diff --git a/.github/GOVERNANCE.md b/.github/GOVERNANCE.md
index 5c1273f068..aba5c2f9a5 100644
--- a/.github/GOVERNANCE.md
+++ b/.github/GOVERNANCE.md
@@ -208,7 +208,7 @@ access, and takes effect only when the invited contributor accepts it.
 | [`@hhyykk`](https://github.com/hhyykk) | Write | Active external collaborator; the 2026-10-21 organization invitation is no longer pending, and active organization membership was not established |
 | [`@maxliux5`](https://github.com/maxliux5) | Write | Active; external collaborator |
 | [`@JackyCSer`](https://github.com/JackyCSer) | Write | Active; organization Member |
-| [`@cocolord`](https://github.com/cocolord) | Write | Active; organization Member |
+| [`@cocolord`](https://github.com/cocolord) | Maintain | Active organization Member; repository role updated 2026-11-07 |
 | [`@wujc12`](https://github.com/wujc12) | Write | Active; organization Member |
 | [`@songoow`](https://github.com/songoow) | Maintain | Active; organization Member |
 | [`@now-ing`](https://github.com/now-ing) | Write | Active; organization Member |
@@ -274,6 +274,19 @@ Update this snapshot through a pull request when invitations are accepted,
 expire or are otherwise resolved. Maintainer appointments follow the separate
 process below.
 
+On 2026-11-07, the lead maintainer granted `@cocolord` repository Maintain
+to help carry the small-kernel refactors through review and merge. Recent
+work includes deferred loading at the Host and process boundaries in
+[#8185](https://github.com/loopx-project/loopx/pull/8185) and CLI registry
+inspection in [#8233](https://github.com/loopx-project/loopx/pull/8233).
+The existing [main ruleset](https://github.com/loopx-project/loopx/rules/18121976)
+allows Maintain holders to bypass branch rules when merging through a PR.
+The [repository merge policy](../AGENTS.md#merge-authority-and-validation)
+still requires explicit maintainer authorization, review of the proposed
+revision and validation for core refactors. Its limits on merging one's own
+PRs continue to apply. Code ownership and release authority follow their
+separate procedures.
+
 ## Subsystem Maintainers
 
 A subsystem maintainer is accountable for review quality and contract
diff --git a/apps/presentation/dashboard/smoke/goal-acceptance-contract-smoke.mjs b/apps/presentation/dashboard/smoke/goal-acceptance-contract-smoke.mjs
index 9cd8ec23b1..f1a326f38e 100644
--- a/apps/presentation/dashboard/smoke/goal-acceptance-contract-smoke.mjs
+++ b/apps/presentation/dashboard/smoke/goal-acceptance-contract-smoke.mjs
@@ -31,6 +31,9 @@ for (const copy of Object.values(deliveryReviewCopy)) {
     scope: { kind: "selected_work", todo_ids: ["todo_confirmed"] } }), snapshot.goal_id);
   assert.ok(deliveryReviewMarkdown(selected, copy).includes(copy.contract.selectedWork));
   assert.ok(deliveryReviewMarkdown(parseDeliveryReview(withContract(contract), snapshot.goal_id), copy).includes(copy.contract.allWork));
+  const goalOnly = parseDeliveryReview(withContract({ ...contract,
+    scope: { kind: "goal" }, tasks: [], held_todo_ids: [] }), snapshot.goal_id);
+  assert.ok(deliveryReviewMarkdown(goalOnly, copy).includes(copy.contract.goalOnly));
   const empty = parseDeliveryReview(withContract({ ...contract, criteria: [], tasks: [] }), snapshot.goal_id);
   assert.ok(deliveryReviewMarkdown(empty, copy).includes(copy.contract.noTasks));
   assert.ok(deliveryReviewMarkdown(empty, copy).includes(copy.contract.noCriteria));
diff --git a/apps/presentation/dashboard/smoke/research-analysis-read-smoke.mjs b/apps/presentation/dashboard/smoke/research-analysis-read-smoke.mjs
index 66e9854990..edc67d2be8 100644
--- a/apps/presentation/dashboard/smoke/research-analysis-read-smoke.mjs
+++ b/apps/presentation/dashboard/smoke/research-analysis-read-smoke.mjs
@@ -5,8 +5,10 @@ import {mkdtemp, mkdir, readFile, writeFile, rm} from "node:fs/promises";
 import {tmpdir} from "node:os";
 import {resolve} from "node:path";
 import {createInterface} from "node:readline";
+import {createElement} from "react";
+import {renderToStaticMarkup} from "react-dom/server";
 import {resolveTestPython} from "../../../../scripts/test-python.mjs";
-import {readAnalysisSnapshot} from "../src/features/personal-workspace/goal-research-analysis.tsx";
+import {readAnalysisSnapshot, ResearchAnalysisPanel} from "../src/features/personal-workspace/goal-research-analysis.tsx";
 
 // A language-specific cache miss must not hide the same registered pack's
 // older, unspecified-language result or turn a read into model execution.
@@ -86,6 +88,25 @@ try {
   failOriginal = false;
   assert.deepEqual((await read()).originalPack, original, "The ordinary read retries recovery without execution");
 
+  // A failed/in-flight observation is unknown; only a successful empty read
+  // supports the absence message. Keep the existing read retry as recovery.
+  for (const zh of [true, false]) {
+    const empty = {...pack, availability: "available", selection: {exhaustive: false}, episode_count: 0};
+    const controller = {zh, pack: empty, requestPack: empty, location: {open: true}, panel: {current: null},
+      readOnly: true, loading: false, snapshot: {catalog: {}}, read: async () => {}, close: () => {}};
+    const noSaved = zh ? "此来源尚无已保存的分析。" : "This source has no saved analysis yet.";
+    const render = state => renderToStaticMarkup(createElement(ResearchAnalysisPanel, {analysis: {...controller, ...state}}));
+    assert.ok(render({}).includes(noSaved), "A successful empty source retains its ordinary absence state");
+    for (const state of [{loading: true}, {readError: "Source unavailable"}, {snapshot: {catalog: {}, originalReadError: "Original unavailable"}}]) {
+      const html = render(state);
+      assert.ok(!html.includes(noSaved), "An incomplete source read must not claim that no saved analysis exists");
+      if (!state.loading) {
+        assert.ok(html.includes('role="alert"'));
+        assert.ok(html.includes(zh ? 'aria-label="重试读取"' : 'aria-label="Retry reading"'));
+      }
+    }
+  }
+
   for (const options of [{current: () => false}, {signal: AbortSignal.abort()}]) {
     reset("zh");
     value = await read(true, undefined, options.signal, options.current);
diff --git a/apps/presentation/dashboard/src/data/delivery-review.ts b/apps/presentation/dashboard/src/data/delivery-review.ts
index ad2b7a2a92..4986e2f37a 100644
--- a/apps/presentation/dashboard/src/data/delivery-review.ts
+++ b/apps/presentation/dashboard/src/data/delivery-review.ts
@@ -138,7 +138,7 @@ export function reviewNodeColumn(node: ReviewNode) {
 }
 
 type ConfiguredContract = GoalAcceptanceChecks;
-type ContractExportLabels = Record<"title" | "boundary" | "scope" | "selectedWork" | "allWork" | "source" | "revision" | "digest" | "objective" | "criteria"
+type ContractExportLabels = Record<"title" | "boundary" | "scope" | "goalOnly" | "selectedWork" | "allWork" | "source" | "revision" | "digest" | "objective" | "criteria"
   | "nonGoals" | "tasks" | "verification" | "unknown" | "noTasks" | "noCriteria" | "notApplicable"
   | "heldTasks" | "receipt" | "receiptNote" | "operation" | "verificationScope" | "allCriteria" | "passed" | "failed" | "exitCode"
   | "oracleChecker" | "oracleSourceDigest" | "oracleCheckedAt" | "oracleInputVersions" | "oracleOutputVersions", string> & {
@@ -236,7 +236,7 @@ export function deliveryReviewMarkdown(snapshot: DeliveryReviewSnapshot, labels:
   if (hasConfiguredGoalChecks(contract)) {
     const copy = labels.contract;
     rows.push("", `## ${copy.title}`, "", copy.boundary,
-      `${copy.scope}: ${contract.scope?.kind === "selected_work" ? copy.selectedWork : copy.allWork}`,
+      `${copy.scope}: ${contract.scope?.kind === "goal" ? copy.goalOnly : contract.scope?.kind === "selected_work" ? copy.selectedWork : copy.allWork}`,
       `${copy.source}: ${line(snapshot.goal_id)}`, `${copy.revision}: ${contract.revision}`, `${copy.digest}: ${line(contract.digest)}`,
       "", `### ${copy.objective}`, line(contract.objective || copy.unknown), "", `### ${copy.criteria}`);
     if (contract.non_goals.length) rows.push(`${copy.nonGoals}: ${line(contract.non_goals.join("; "))}`);
@@ -246,8 +246,8 @@ export function deliveryReviewMarkdown(snapshot: DeliveryReviewSnapshot, labels:
       if (criterion.oracle) rows.push(`  ${copy.oracleChecker}: ${line(criterion.oracle.source_id)} · ${copy.oracleState[criterion.oracle.state]}`,
         `  ${copy.oracleSourceDigest}: ${line(criterion.oracle.source_digest)}`);
     }
-    rows.push("", `### ${copy.tasks}`);
-    if (!contract.tasks.length) rows.push(copy.noTasks);
+    if (contract.tasks.length || contract.scope?.kind !== "goal") rows.push("", `### ${copy.tasks}`);
+    if (!contract.tasks.length && contract.scope?.kind !== "goal") rows.push(copy.noTasks);
     for (const task of contract.tasks) {
       rows.push(`- ${line(task.todo_id)}: ${copy.taskState[task.state]}`,
         `  ${copy.criteria}: ${line(task.criterion_ids.join(", ") || copy.unknown)}`);
diff --git a/apps/presentation/dashboard/src/data/fixtures/edgebench-ad-20261023-history.json b/apps/presentation/dashboard/src/data/fixtures/edgebench-ad-20261023-history.json
index e411881ddd..7c2117859b 100644
--- a/apps/presentation/dashboard/src/data/fixtures/edgebench-ad-20261023-history.json
+++ b/apps/presentation/dashboard/src/data/fixtures/edgebench-ad-20261023-history.json
@@ -22,6 +22,12 @@
       "Native and local measurement scopes remain distinct. Cancelled or invalid runs do not qualify a scientific comparison."
     ],
     "redactions": [],
+    "trajectory_archive": {
+      "url": "https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/resolve/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/ad_placement_optimization.zip",
+      "sha256": "45ce26e44a59587b5a086d3aabde9bba9899b184abd6a21029f75c8b6695a44b",
+      "manifest_url": "https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/blob/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/manifest.json",
+      "redactions_url": "https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/blob/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/redactions.json"
+    },
     "boundary": "Display-state events only. No authority or credential store, raw session transcript, hidden evaluator, workspace or model weights are included."
   },
   "source_counts": {
diff --git a/apps/presentation/dashboard/src/data/fixtures/edgebench-grid-context-on-20261103-history.json b/apps/presentation/dashboard/src/data/fixtures/edgebench-grid-context-on-20261103-history.json
index dc64720394..93b4599ac6 100644
--- a/apps/presentation/dashboard/src/data/fixtures/edgebench-grid-context-on-20261103-history.json
+++ b/apps/presentation/dashboard/src/data/fixtures/edgebench-grid-context-on-20261103-history.json
@@ -21,6 +21,12 @@
       "These runs include operational interventions and are not a qualified causal comparison. Local and native measurements retain separate scopes."
     ],
     "redactions": [],
+    "trajectory_archive": {
+      "url": "https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/resolve/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/grid_turing_robot.zip",
+      "sha256": "ea147c9ae7173e3f1ce9ca6e0bbda5e0103e2be035b8e6d0658dd35a2d282c8d",
+      "manifest_url": "https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/blob/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/manifest.json",
+      "redactions_url": "https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/blob/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/redactions.json"
+    },
     "boundary": "Display-state events only. No execution/authority store, credentials, raw session transcript, hidden evaluator, workspace or model weights are included."
   },
   "source_counts": {
diff --git a/apps/presentation/dashboard/src/data/fixtures/edgebench-schema-20261025-history.json b/apps/presentation/dashboard/src/data/fixtures/edgebench-schema-20261025-history.json
index c4b3f81750..060a2356aa 100644
--- a/apps/presentation/dashboard/src/data/fixtures/edgebench-schema-20261025-history.json
+++ b/apps/presentation/dashboard/src/data/fixtures/edgebench-schema-20261025-history.json
@@ -22,6 +22,12 @@
       "Native and local measurement scopes remain distinct. Cancelled or invalid runs do not qualify a scientific comparison."
     ],
     "redactions": [],
+    "trajectory_archive": {
+      "url": "https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/resolve/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/schemathesis_config_modernization.zip",
+      "sha256": "e892d3b9569d84c7fff8ce80c2a0ae9f9a801d5f745eb980bfc918835327b2ea",
+      "manifest_url": "https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/blob/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/manifest.json",
+      "redactions_url": "https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/blob/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/redactions.json"
+    },
     "boundary": "Display-state events only. No authority or credential store, raw session transcript, hidden evaluator, workspace or model weights are included."
   },
   "source_counts": {
diff --git a/apps/presentation/dashboard/src/data/goal-acceptance-actions.ts b/apps/presentation/dashboard/src/data/goal-acceptance-actions.ts
index 00ebe4c742..c956403af4 100644
--- a/apps/presentation/dashboard/src/data/goal-acceptance-actions.ts
+++ b/apps/presentation/dashboard/src/data/goal-acceptance-actions.ts
@@ -17,7 +17,7 @@ export async function acceptanceRequest(goalId: string, operation?: Record<strin
 // Read model only. The existing typed acceptance owner validates the complete
 // document and its command/file bindings again at apply time.
 const preparedDocument = z.object({objective: z.string().min(1),
-  scope: z.discriminatedUnion("kind", [z.object({kind: z.literal("all_advancement")}),
+  scope: z.discriminatedUnion("kind", [z.object({kind: z.literal("goal")}),z.object({kind: z.literal("all_advancement")}),
     z.object({kind: z.literal("selected_work"), todo_ids: z.array(z.string()).min(1)})]),
   criteria: z.array(z.object({id: z.string(), description: z.string(),
     validation_argv: z.array(z.string()).min(1),
diff --git a/apps/presentation/dashboard/src/data/goal-acceptance-observation.ts b/apps/presentation/dashboard/src/data/goal-acceptance-observation.ts
index 8676d8a15e..cd50a77ad6 100644
--- a/apps/presentation/dashboard/src/data/goal-acceptance-observation.ts
+++ b/apps/presentation/dashboard/src/data/goal-acceptance-observation.ts
@@ -35,6 +35,7 @@ const goalAcceptanceChecksSchema = z.object({
     outcome_id: z.string().optional(),
     revision: z.number().int().positive(), digest: z.string().min(1), objective: z.string(),
     scope: z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("goal") }).strict(),
       z.object({ kind: z.literal("all_advancement") }).strict(),
       z.object({ kind: z.literal("selected_work"), todo_ids: z.array(z.string().min(1)).min(1) }).strict(),
     ]).optional(),
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/delivery-review-copy.ts b/apps/presentation/dashboard/src/features/personal-workspace/delivery-review-copy.ts
index 8794b3701f..a3578d4ec9 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/delivery-review-copy.ts
+++ b/apps/presentation/dashboard/src/features/personal-workspace/delivery-review-copy.ts
@@ -3,7 +3,7 @@ import type { ReviewExportLabels } from "../../data/delivery-review.js";
 export const goalAcceptanceContractCopy = {
   en: {
     title: "Delivery check", boundary: "Artifact checks do not establish independent review, adoption or Goal completion.",
-    scope: "Contract coverage", allWork: "All advancement work (including future tasks)", selectedWork: "Only explicitly selected tasks",
+    goalOnly: "Goal completion only", scope: "Contract coverage", allWork: "All advancement work (including future tasks)", selectedWork: "Only explicitly selected tasks",
     source: "Goal source", revision: "Contract revision", digest: "Contract digest", objective: "Objective", criteria: "Acceptance criteria", nonGoals: "Outside scope",
     tasks: "Task associations", verification: "Artifact verification", unknown: "Unknown", noTasks: "No task associations reported. Coverage is unknown.",
     noCriteria: "No acceptance criteria reported.", retained: "Retained snapshot; refresh to read current acceptance facts.",
@@ -17,7 +17,7 @@ export const goalAcceptanceContractCopy = {
   },
   "zh-CN": {
     title: "交付检查", boundary: "产物检查不等于独立复核、实际采用或 Goal 完成。",
-    scope: "合同覆盖范围", allWork: "全部推进任务（包括后续新增任务）", selectedWork: "仅明确选定的任务",
+    goalOnly: "仅 Goal 整体验收", scope: "合同覆盖范围", allWork: "全部推进任务（包括后续新增任务）", selectedWork: "仅明确选定的任务",
     source: "Goal 来源", revision: "合同版本", digest: "合同摘要", objective: "目标", criteria: "验收条件", nonGoals: "范围之外",
     tasks: "任务关联", verification: "产物验证", unknown: "未知", noTasks: "未提供任务关联，覆盖范围未知。",
     noCriteria: "未提供验收条件。", retained: "当前保留旧快照，请刷新读取最新验收事实。",
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/goal-acceptance-contract.tsx b/apps/presentation/dashboard/src/features/personal-workspace/goal-acceptance-contract.tsx
index a949d77d60..1ff7163a94 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/goal-acceptance-contract.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/goal-acceptance-contract.tsx
@@ -118,10 +118,10 @@ export function GoalAcceptanceContractSection({goalId, contract: retained, copy,
           <button type="button" disabled={busy || !writeCurrent || !checksConfigured} onClick={() => void operate("clear-checks")}>{zh ? "移除检查配置" : "Remove check configuration"}</button>
         </div>
         <dl className="delivery-acceptance-source"><div><dt>{copy.source}</dt><dd><code>{goalId}</code></dd></div>
-          {checksConfigured ? <><div><dt>{copy.scope}</dt><dd>{contract.scope?.kind === "selected_work" ? copy.selectedWork : copy.allWork}</dd></div>
+          {checksConfigured ? <><div><dt>{copy.scope}</dt><dd>{contract.scope?.kind === "goal" ? copy.goalOnly : contract.scope?.kind === "selected_work" ? copy.selectedWork : copy.allWork}</dd></div>
             <div><dt>{copy.revision}</dt><dd>{contract.revision}</dd></div><div><dt>{copy.digest}</dt><dd><code>{contract.digest}</code></dd></div></> : null}
         </dl>
-        {checksConfigured ? <><p>{contract.non_goals.join(" · ")}</p><h4>{copy.tasks}</h4>
+        {checksConfigured ? <><p>{contract.non_goals.join(" · ")}</p>{contract.tasks.length ? <h4>{copy.tasks}</h4> : null}
           <ul>{contract.tasks.map(task => <li key={task.todo_id}><code>{task.todo_id}</code> · {copy.taskState[task.state]}
             <p>{copy.criteria}: {task.criterion_ids.join(", ") || copy.unknown}</p>
             {task.applicable === false ? <p>{copy.notApplicable}</p> : null}
@@ -171,7 +171,7 @@ export function GoalAcceptanceContractSection({goalId, contract: retained, copy,
           onClick={() => void operate(plan ? "adopt" : "verify")}>{busy ? (zh ? "正在检查…" : "Checking…") : plan ? (zh ? "采用并检查" : "Use plan and check") : (zh ? "检查交付" : "Check delivery")}</button> : null}
       </header> : null}
       {plan ? <div className="delivery-check-plan">
-        <p>{plan.document.scope.kind === "all_advancement" ? copy.allWork
+        <p>{plan.document.scope.kind === "goal" ? copy.goalOnly : plan.document.scope.kind === "all_advancement" ? copy.allWork
           : (zh ? `仅覆盖方案选定的 ${plan.document.scope.todo_ids.length} 项任务` : `Covers only ${plan.document.scope.todo_ids.length} selected tasks`)}</p>
         <ul>{plan.document.criteria.map(item => <li key={item.id}>{item.description}</li>)}</ul>
         {plan.document.criteria.some(item => item.oracle?.output_refs.length) ? <p>{zh ? "交付物" : "Delivery"}: {Array.from(new Set(plan.document.criteria.flatMap(item => item.oracle?.output_refs ?? []))).join(" · ")}</p> : null}
diff --git a/apps/presentation/dashboard/src/features/personal-workspace/goal-research-analysis.tsx b/apps/presentation/dashboard/src/features/personal-workspace/goal-research-analysis.tsx
index 1a640313d1..2b47843827 100644
--- a/apps/presentation/dashboard/src/features/personal-workspace/goal-research-analysis.tsx
+++ b/apps/presentation/dashboard/src/features/personal-workspace/goal-research-analysis.tsx
@@ -577,7 +577,8 @@ export function ResearchAnalysisPanel({analysis: a, onHistory}: {analysis: Contr
         {a.pending || a.recordedRunning ? <><p role="status">{a.pending ? <LoaderCircle size={15} aria-hidden className="analysis-spin"/> : null}{a.pending ? (zh ? "正在处理分析请求…" : "Processing analysis request…") : (zh ? "上次记录仍待分析结果；当前执行状态尚未核验。" : "The last receipt awaits a result; current execution is unverified.")}</p><button type="button" onClick={() => void a.cancel()} disabled={a.readOnly || a.cancelPending || currentJob?.cancel_requested}>{currentJob?.cancel_requested ? (zh ? "已请求取消" : "Cancellation requested") : a.cancelPending ? (zh ? "正在请求取消…" : "Requesting cancellation…") : (zh ? "取消分析" : "Cancel analysis")}</button></>
           : a.savedOriginal && !a.readOnly ? <button className="analysis-primary" type="button" disabled={!available} onClick={() => void a.execute(failed)}><Sparkles size={15} aria-hidden/>{zh ? "用中文分析所选范围" : "Analyze selected scope in English"}</button>
             : result ? <button type="button" onClick={() => void a.read().catch(() => undefined)}><RefreshCw size={14} aria-hidden/>{zh ? "刷新结果" : "Refresh result"}</button>
-            : a.readOnly ? <><p className={sourceAvailable ? undefined : "analysis-warning"}>{sourceAvailable ? (zh ? "此来源尚无已保存的分析。" : "This source has no saved analysis yet.") : reasonCopy(p.reason_code, zh)}</p><button type="button" onClick={() => void a.read().catch(() => undefined)}>{zh ? "刷新结果" : "Refresh result"}</button></>
+            : a.readOnly ? (a.loading || a.readError || a.snapshot?.originalReadError ? null
+              : <><p className={sourceAvailable ? undefined : "analysis-warning"}>{sourceAvailable ? (zh ? "此来源尚无已保存的分析。" : "This source has no saved analysis yet.") : reasonCopy(p.reason_code, zh)}</p><button type="button" onClick={() => void a.read().catch(() => undefined)}>{zh ? "刷新结果" : "Refresh result"}</button></>)
             : <button className="analysis-primary" type="button" disabled={!available} onClick={() => void a.execute(failed)}><Sparkles size={15} aria-hidden/>{failed ? (zh ? "重试分析" : "Retry analysis") : p.continuation ? analysisActionLabel(p, zh) : (zh ? "分析所选范围" : "Analyze selected scope")}</button>}
         {(!result || a.savedOriginal) && !a.readOnly && !a.pending && !a.recordedRunning ? <small>{a.requestPack?.continuation?.can_reuse ? (zh ? "复用已有判读，无需新模型调用。" : "Reuses existing judgments without a new model call.") : zh ? "使用本机 Codex 账户，单独产生分析用量；浏览不调用 Agent。" : "Uses the local Codex account with separate analysis usage. Browsing never invokes an Agent."}</small> : null}
       </div> : null}
diff --git a/apps/presentation/dashboard/src/views/dashboard-page.tsx b/apps/presentation/dashboard/src/views/dashboard-page.tsx
index f635802772..0343e93e11 100644
--- a/apps/presentation/dashboard/src/views/dashboard-page.tsx
+++ b/apps/presentation/dashboard/src/views/dashboard-page.tsx
@@ -3879,21 +3879,11 @@ export function DashboardPage() {
     if (search.statusUrl && source.kind === "example") {
       return;
     }
+    // Empty active rows and failed history do not establish Goal absence.
+    // Wait for the complete source before discarding a stopped-Goal bookmark.
+    if (source.kind === "url" && goalArchiveLoadState.phase !== "ready") return;
     const goalIds = new Set(goalRows.map((row) => row.goal.id));
-    if (goalRows.length === 0) {
-      if (search.goalId) {
-        void navigate({
-          replace: true,
-          search: (current) => ({
-            ...current,
-            goalId: "",
-          }),
-        });
-      }
-      return;
-    }
-    if (search.goalId && !goalIds.has(search.goalId)
-      && goalArchiveLoadState.phase !== "loading") {
+    if (search.goalId && !goalIds.has(search.goalId)) {
       void navigate({
         replace: true,
         search: (current) => ({
diff --git a/benchmark/README.md b/benchmark/README.md
index a97fcc0117..bcc666d16c 100644
--- a/benchmark/README.md
+++ b/benchmark/README.md
@@ -1396,3 +1396,87 @@ This used real Codex processes and native HTTP with deterministic local inferenc
 and synthetic grading. It does **not** qualify scientific research utility,
 matched strategy results, or the frontend restore journey. Actual task/profile
 admission and measured continuation outcomes remain required.
+
+### Continue an interrupted Host in its retained filesystem
+
+The explicit `benchmark.runtime.scheduler` budget-continuation entrypoint can
+settle a returned, budget-interrupted native Host before the next normal wake.
+It retains the original scheduler attempt, wake receipt, Goal, Todos and native
+conversation. A new append-only phase records the exact source and one finite
+deadline; retrying that phase cannot refill time. The next wake still performs
+ordinary quota, Stop, current-profile and session checks. No tool is replayed,
+work marked complete, or replan obligation discarded by this settlement.
+
+New scheduler-owned attempts carry an attempt identity and passive process
+cleanup observations. Recovery requires one matching returned budget receipt,
+a terminated original process group, the unchanged session binding, and stable
+native history ending in an interrupted Turn within that process window.
+Unknown failures, live processes, pending native effects, ambiguous receipts,
+changed profiles and stopped Goals remain held. Ordinary scheduler invocation
+does not opt into continuation. Completed-checkpoint admission stays unchanged.
+
+An older worker without the process observation can instead retain its exact
+stopped Docker filesystem. Prepare evidence through the existing Docker archive
+provider; do not substitute an older sealed checkpoint or copy files over the
+current workspace. The declaration names the original `goal_id`, `agent_id`,
+`workspace`, `runtime_root`, `native_home`, `registry`, `scheduler_state`,
+`wake_log_dir`, `phase_clock` and `wake_turn_id` (absolute guest paths for paths).
+For example:
+
+```sh
+python -m benchmark.edgebench.stopped_recovery \
+  --source-container FULL_CONTAINER_ID \
+  --declaration /private/recovery/source.json \
+  --output /private/recovery/source-proof.json --install
+```
+
+The command refuses a running container, non-inert restart command or external
+mounts. It inventories the current workspace, runtime, registry, original wake,
+native history and SQLite WAL/journal companions, then verifies the container
+remained stopped. `--install` places and reads back only a content-addressed
+inert proof in that same container's control directory; omitting it is read-only.
+Neither form starts the container, restores scoring authority or calls a model.
+Keep exclusive ownership of the source during preparation and continuation.
+
+After independently restoring the original native evaluator's history,
+opportunities and actual cooldown, restart only the same inert container and
+pass its returned `installed_proof_path` as `LOOPX_INTERRUPTED_SOURCE` to the
+explicit scheduler continuation. Preserve all original guest paths, native
+configuration and session. Hot-upgraded LoopX source belongs outside inventoried
+directories. Supply the separately admitted remaining allowance through the
+existing `LOOPX_PHASE_DEADLINE_EPOCH`; leave the original phase-clock file intact
+for source verification. Any changed participant, including a missing WAL,
+refuses settlement. A held reason is printed and the original phase remains
+selected; inspect the original evidence rather than delete it or select fresh.
+
+This provider path qualifies transport recovery, not a new sealed research point
+or cross-container restore. It never grants evaluator registration, budget,
+execution authorization or scientific comparability. Keep the prior failed
+segment and new segment separately attributable, and verify actual model activity
+and native feedback after dispatch. Disposable tests exercise real Docker archive
+and proof installation; SQLite/process tests exercise interrupted work followed
+by the same session's next Turn without paid model calls.
+
+The legacy stopped-source path accepts only Docker's default container-ID hostname.
+The receiver derives the current UTS hostname independently and refuses copied
+proofs in a different worker, including custom-hostname sources. This is an
+accidental-cross-worker boundary under the trusted Docker operator, not a
+cryptographic defense against that operator spoofing hostnames. The installed
+proof initially has root ownership and mode `0600`; a non-root worker's operator
+must assign that one inert file to the original execution user before consumption.
+Only verified SQLite `-shm` companions are omitted as rebuildable indexes; arbitrary
+workspace files with that suffix remain protected.
+
+An explicitly continued phase can carry a hash-bound content handoff through
+`LOOPX_RECOVERY_HANDOFF` and `LOOPX_RECOVERY_HANDOFF_SHA256`. Use the existing
+`handoff restore --input FILE --format json` content envelope (`ok: true` and
+`handoff_text`), without ownership arguments. The normal heartbeat presents it;
+a successful same-session Host receipt confirms its digest and stops repeated
+presentation. An uncertain attempt retains the same input, and missing or changed
+bytes fail closed. A legitimate later budget phase can bind its own new handoff;
+the earlier phase and digest remain immutable. Native submission-ID remapping
+belongs in this infrastructure handoff, never a replacement solution Todo.
+
+Recovery settles process transport only. Preserved pending semantic replan
+attempts still require their original settlement owner; an interrupted replan
+is not silently declared complete or cleared to force dispatch.
diff --git a/benchmark/edgebench/run.py b/benchmark/edgebench/run.py
index eb6114b809..0d3e9c477d 100644
--- a/benchmark/edgebench/run.py
+++ b/benchmark/edgebench/run.py
@@ -124,6 +124,8 @@ def main(argv=None):
                         help="Opt-in short heartbeat context with same-invocation full captures")
     parser.add_argument("--context-delivery", choices=("off", "on"),
                         help="Native Codex context delivery: on by default for heartbeat workers; pass off to disable")
+    parser.add_argument("--execution-observation", choices=("local_probe",),
+                        help="Optional local execution probe for heartbeat workers")
     parser.add_argument("--provider-request-admission", action="store_true",
                         help="Opt-in canonical admission before each heartbeat custom Responses request")
     parser.add_argument("--native-goal-continue", action="store_true",
@@ -204,6 +206,8 @@ def main(argv=None):
         args.context_delivery = Execution(mode="heartbeat" if args.worker.startswith("heartbeat-") else "plain").context_delivery
     if args.context_delivery != "off" and not args.worker.startswith("heartbeat-"):
         parser.error("--context-delivery requires a heartbeat worker")
+    if args.execution_observation is not None and not args.worker.startswith("heartbeat-"):
+        parser.error("--execution-observation requires a heartbeat worker")
     if args.provider_request_admission:
         if not args.worker.startswith("heartbeat-"):
             parser.error("--provider-request-admission requires a heartbeat worker")
@@ -374,6 +378,8 @@ def main(argv=None):
                          task_entry=args.task_entry,
                          turn_envelope=args.turn_envelope,
                          context_delivery=args.context_delivery,
+                         **({"execution_observation": args.execution_observation}
+                            if args.execution_observation is not None else {}),
                          **({"provider_request_admission": True} if args.provider_request_admission else {}),
                          native_goal_continue=args.native_goal_continue,
                          replan_after_turns=args.replan_after_turns,
@@ -444,6 +450,8 @@ def main(argv=None):
         "sforge_source": active_source_receipt(),
         **turn_envelope_receipt(explicit=args.turn_envelope),
         **({"context_delivery": "on"} if args.context_delivery != "off" else {}),
+        **({"execution_observation": args.execution_observation}
+           if args.execution_observation is not None else {}),
         **({"provider_request_admission": "on"} if args.provider_request_admission else {}),
         **({"native_goal_continue": True} if args.native_goal_continue else {}),
         "task_sha256": hashlib.sha256(task_file.read_bytes()).hexdigest(),
diff --git a/benchmark/edgebench/stopped_recovery.py b/benchmark/edgebench/stopped_recovery.py
new file mode 100644
index 0000000000..18c3d8593b
--- /dev/null
+++ b/benchmark/edgebench/stopped_recovery.py
@@ -0,0 +1,199 @@
+"""Prepare inert evidence from one stopped worker's unchanged filesystem.
+
+The Docker provider proves namespace termination. The runtime recovery owner
+checks these exact bytes and the native session before any new admission.
+This command never starts a container, restores a judge, or invokes a model.
+"""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime
+import hashlib
+import io
+import json
+import math
+import os
+from pathlib import Path
+import re
+import tarfile
+import tempfile
+import time
+
+from .checkpoint_controller import _remaining
+from .checkpoint_worker import _archive_component, _guest_path
+
+
+def file_inventory(root: Path) -> list[dict]:
+    entries = [root] if root.is_file() else sorted(root.rglob('*'))
+    result = []
+    for path in entries:
+        if path.is_symlink():
+            raise ValueError('Interrupted source inventory cannot contain symlinks')
+        if path.name.endswith('-shm'):
+            database = path.with_name(path.name[:-4])
+            if database.is_file() and not database.is_symlink():
+                with database.open('rb') as source:
+                    if source.read(16) == b'SQLite format 3\0':
+                        continue  # Only a SQLite participant's reader index is rebuilt.
+        if path.is_file():
+            h = hashlib.sha256()
+            with path.open('rb') as stream:
+                while data := stream.read(1024 * 1024):
+                    h.update(data)
+            result.append({'path': '' if path == root else str(path.relative_to(root)),
+                           'bytes': path.stat().st_size, 'sha256': h.hexdigest()})
+        elif not path.is_dir():
+            raise ValueError('Interrupted source inventory contains a special file')
+    return result
+
+
+def source_paths(declaration: dict) -> dict[str, str]:
+    required = {'goal_id', 'agent_id', 'workspace', 'runtime_root', 'native_home',
+                'registry', 'scheduler_state', 'wake_log_dir', 'phase_clock', 'wake_turn_id'}
+    if set(declaration) != required:
+        raise ValueError('Stopped recovery requires its exact lane and original source paths')
+    for key in required - {'goal_id', 'agent_id', 'wake_turn_id'}:
+        _guest_path(declaration[key])
+    if not re.fullmatch(r'wake-[0-9]+-[a-f0-9]{12}', declaration['wake_turn_id']):
+        raise ValueError('Stopped recovery requires the original worker wake identity')
+    home = declaration['native_home']
+    # Explicit native participants exclude auth, caches and credential stores.
+    return {**{k: declaration[k] for k in ('workspace', 'runtime_root', 'registry',
+                'scheduler_state', 'wake_log_dir', 'phase_clock')},
+            'host_pending': declaration['scheduler_state'] + '.host-attempt',
+            'native_sessions': home + '/sessions', 'native_state': home + '/state_5.sqlite',
+            'native_history': home + '/thread_history_1.sqlite', 'native_config': home + '/config.toml'}
+
+
+def prepare_stopped_recovery(client, *, container_id: str, declaration: dict,
+                             output: Path, timeout: float = 120, install: bool = False) -> dict:
+    if not math.isfinite(timeout) or timeout <= 0:
+        raise ValueError('Stopped recovery timeout must be finite and positive')
+    deadline = time.monotonic() + timeout
+    if not re.fullmatch(r'[a-f0-9]{64}', container_id):
+        raise ValueError('Stopped recovery requires one full container identity')
+    paths = source_paths(declaration)
+    if output.exists() or output.is_symlink() or output.parent.resolve() != output.parent:
+        raise ValueError('Stopped recovery output must be fresh and physical')
+    box = client.containers.get(container_id)
+    box.reload()
+    before = dict(box.attrs['State'])
+    if (box.id != container_id or before.get('Status') != 'exited'
+            or before.get('Running') is not False or before.get('Pid') != 0
+            or before.get('Restarting') or before.get('Paused') or before.get('Dead')):
+        raise ValueError('Original worker namespace is not demonstrably stopped')
+    # This source can be restarted as an inert shell, never by replaying its
+    # original install/run command. Actual restart remains the caller's action.
+    if box.attrs['Config'].get('Entrypoint') or box.attrs['Config'].get('Cmd') != ['tail', '-f', '/dev/null']:
+        raise ValueError('Original worker must have an inert restart command')
+    if box.attrs['Config'].get('Hostname') != box.id[:12]:
+        raise ValueError('Stopped recovery requires the original default Docker hostname')
+    if box.attrs.get('Mounts'):
+        raise ValueError('Stopped worker has externally writable mounts')
+    finished = datetime.fromisoformat(before['FinishedAt'].replace('Z', '+00:00')).timestamp()
+    components = []
+    with tempfile.TemporaryDirectory(prefix='.stopped-source-', dir=output.parent) as temporary:
+        copied = {}
+        for key, remote in paths.items():
+            local = _archive_component(box, remote, Path(temporary) / key, deadline=deadline)
+            copied[key] = local
+            # SQLite companions are declared separately: a WAL is committed
+            # source data, not an optional display/cache file.
+            for suffix in ('', '-wal', '-journal') if local.is_file() else ('',):
+                member = Path(str(local) + suffix)
+                if member.exists():
+                    components.append({'source_path': remote + suffix,
+                                       'files': file_inventory(member), 'directory': member.is_dir()})
+        state_raw = copied['scheduler_state'].read_bytes()
+        state = json.loads(state_raw)
+        if (state.get('host_attempt', {}).get('status') != 'started'
+                or json.loads(copied['host_pending'].read_bytes()) != {'pending': True}):
+            raise ValueError('Stopped legacy recovery requires the original unresolved Host attempt')
+        wake = copied['wake_log_dir'] / declaration['wake_turn_id'] / 'receipt.json'
+        raw = wake.read_bytes()
+        receipt = json.loads(raw)
+        candidates = [p for p in copied['wake_log_dir'].glob('*/receipt.json')
+                      if p.stat().st_mtime > copied['scheduler_state'].stat().st_mtime]
+        if candidates != [wake]:
+            raise ValueError('Stopped source has no unique returned wake after its Host attempt')
+        if (receipt.get('turn_id') != declaration['wake_turn_id'] or receipt.get('host_invoked') is not True
+                or receipt.get('budget_exhausted') is not True or receipt.get('mode') != 'heartbeat'
+                or receipt.get('stage') != 'execute' or receipt.get('ok') is not False
+                or 'host_failure' in receipt):
+            raise ValueError('Stopped source lacks an exact interrupted budget receipt')
+        start = int(declaration['wake_turn_id'].split('-')[1]) / 1_000_000_000
+        phase = float(copied['phase_clock'].read_text())
+        if not start <= phase <= finished:
+            raise ValueError('Stopped source phase did not expire during the original wake')
+        result = {'container_id': box.id, 'source_state': before, 'declaration': declaration,
+                  'components': components, 'scheduler_state_sha256': hashlib.sha256(state_raw).hexdigest(),
+                  'receipt_sha256': hashlib.sha256(raw).hexdigest(),
+                  'process_started_at': start, 'process_stopped_at': finished,
+                  'source_phase_deadline_epoch': phase, 'session': receipt.get('session'),
+                  'execution_authority_granted': False}
+        box.reload()
+        if box.attrs['State'] != before:
+            raise ValueError('Original worker changed during stopped-source readback')
+    if install:
+        from docker.errors import NotFound
+
+        raw = json.dumps(result, sort_keys=True).encode()
+        name = 'interruption-source-' + hashlib.sha256(raw).hexdigest() + '.json'
+        parent = Path(declaration['scheduler_state']).parent
+        if any(parent == Path(p) or Path(p) in parent.parents for p in
+               (declaration['workspace'], declaration['runtime_root'], declaration['wake_log_dir'], declaration['native_home'])):
+            raise ValueError('Recovery proof must not mutate its inventoried source directories')
+        # A stopped worker's inert control directory is the sole destination;
+        # never place the proof in a different container or overwrite old state.
+        package = io.BytesIO()
+        with tarfile.open(fileobj=package, mode='w') as archive:
+            member = tarfile.TarInfo(name)
+            member.mode, member.size = 0o600, len(raw)
+            archive.addfile(member, io.BytesIO(raw))
+        box.reload()
+        if box.attrs['State'] != before:
+            raise ValueError('Original worker changed before proof installation')
+        with tempfile.TemporaryDirectory(prefix='.proof-existing-', dir=output.parent) as directory:
+            try:
+                existing = _archive_component(box, str(parent / name), Path(directory) / 'proof', deadline=deadline)
+            except NotFound:
+                existing = None
+            if existing is not None and existing.read_bytes() != raw:
+                raise ValueError('Original worker recovery proof path is already occupied')
+        if existing is None:
+            _remaining(deadline)
+            if not box.put_archive(str(parent), package.getvalue()):
+                raise ValueError('Original worker did not accept its inert recovery proof')
+        with tempfile.TemporaryDirectory(prefix='.proof-readback-', dir=output.parent) as directory:
+            copied = _archive_component(box, str(parent / name), Path(directory) / 'proof', deadline=deadline)
+            if copied.read_bytes() != raw:
+                raise ValueError('Original worker recovery proof readback differs')
+        box.reload()
+        if box.attrs['State'] != before:
+            raise ValueError('Original worker changed during proof installation')
+        result['installed_proof_path'] = str(parent / name)
+    _remaining(deadline)
+    with os.fdopen(os.open(output, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600), 'w') as stream:
+        json.dump(result, stream, indent=2)
+        stream.flush()
+        os.fsync(stream.fileno())
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source-container', required=True)
+    parser.add_argument('--declaration', type=Path, required=True)
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--install', action='store_true', help='Place the inert proof only in this same stopped worker')
+    args = parser.parse_args()
+    import docker
+    result = prepare_stopped_recovery(docker.from_env(timeout=30),
+        container_id=args.source_container, declaration=json.loads(args.declaration.read_bytes()),
+        output=args.output, install=args.install)
+    print(json.dumps({'container_id': result['container_id'], 'output': str(args.output),
+                      'installed_proof_path': result.get('installed_proof_path'), 'execution_authority_granted': False}))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/benchmark/runtime/EXECUTION_OBSERVATIONS.md b/benchmark/runtime/EXECUTION_OBSERVATIONS.md
index ccf8e9cfae..844c44aee1 100644
--- a/benchmark/runtime/EXECUTION_OBSERVATIONS.md
+++ b/benchmark/runtime/EXECUTION_OBSERVATIONS.md
@@ -39,6 +39,15 @@ merely to produce an attachment. Configuration and readback invoke neither a
 probe nor a model. Runtime receipts record the selected producer, which does
 not attest execution, adoption or improvement.
 
+The native SForge runner accepts the same producer with
+`--execution-observation local_probe` on a heartbeat worker. It forwards the
+selection to the shared installer and records it in both runner and worker
+receipts. The wrapper uses isolated Python to execute the staged probe source
+while keeping the task working directory for candidate paths. The installer
+checks the wrapper's `--help` once as the worker user before model entry.
+An unavailable wrapper fails setup for an explicitly selected producer.
+The observation runs only when a worker invokes it.
+
 Choose the settlement plan's ordinary `command_template` for in-flight progress
 without new decision evidence. Use `semantic_closeout_command_template` for new
 evidence from this admitted work, a route change or Todo completion; bind the
@@ -126,6 +135,25 @@ Malformed optional diagnostics preserve reliable host measurements and retain
 a bounded diagnostic-error receipt. Evidence paths must be fresh; raw output
 stays local. The probe neither submits nor accesses hidden evaluation.
 
+When simultaneous memory could change a candidate choice, run the complete
+representative workload with the same probe and pass
+`--memory-limit-bytes <applicable-reference-limit>`. On Linux the producer
+estimates group proportional set size by reading one PID at a time. It skips
+samples with unstable membership. A stable group can move retained memory
+between PID reads, so the sampled sum can overstate simultaneous occupancy.
+The adjacent `.memory.json` binds that estimate and reference to the exact
+candidate and input revision. The main observation cites its digest only after
+a successful write. Missing samples stay unknown. A sidecar failure preserves
+the original process result. Processes in other groups and peaks between samples
+are outside coverage, and PSS accounting differs from a container limit.
+
+When this estimate could change a choice, check actual overlap independently
+and record the supported next comparison in the existing Yardstick decision.
+Keep the best authoritative evidence, reuse the matching incumbent observation,
+and compare a lower-footprint mechanism on the same complete workload where
+overlap matters. The estimate alone supplies no limit verdict or selected
+action. A native timeout alone supplies no memory observation.
+
 The adjacent `.candidate.json` preserves selected relative paths and hashes.
 `candidate_sha256` hashes the sorted JSON file manifest, not native archive
 container bytes. Pins cover only declared files at the probe boundaries, not
@@ -189,6 +217,24 @@ Stop、原预算和真实阻塞继续有效，不为填满时长制造任务。
 变化拒绝归因；文件清单哈希不是原生归档哈希，只覆盖明确选择的文件及探针
 边界，不覆盖传递依赖或独立写入者，结果仍须证明对应实际评测快照和输入版本。
 
+SForge heartbeat worker 可显式传入 `--execution-observation local_probe`，
+沿用共享安装路径，并在 runner 和 worker 回执中记录选择。入口以隔离 Python
+执行已部署的探针源码，候选路径仍相对于任务工作目录。安装时用 worker 身份
+核对一次 `--help`。该入口不可用时在模型进入前报告安装失败。测量只在
+worker 自己调用探针时发生。
+
+当并行内存占用会影响候选选择时，用同一入口执行完整代表性工作集并传入
+`--memory-limit-bytes <参考上限>`。Linux 逐 PID 读取 PSS，组成员变化或数据
+不完整时跳过该次采样。组成员稳定时，内存仍可能在两次读取之间转移，累加值
+可能高于真实同时占用。相邻 `.memory.json` 将估计和参考值绑定到候选及输入
+版本。写入成功才把其摘要记入原观测，写入失败仍保留原进程结果。组外进程和
+采样间峰值未覆盖，PSS 与容器内存限额的统计口径有差异。
+
+这项估计会影响选择时，独立核对真实同时占用，再通过原 Yardstick 写入有证据
+的下一比较。保留最好的权威结果，复用同口径 incumbent 测量；确有并行保留
+影响时，把下一次有界试验用于同一完整工作集上的较低占用机制。估计本身不产生
+超限判定或自动选择。只有超时回执时，内存保持未知。
+
 当前授权工作实际产生或取得新的决策证据后，才进入相应工作段的检查点。旧反馈读回、
 记账和没有新增信息的确定性重复验证只是上下文，应先用于推进原任务。使用当前
 settlement plan 的 `durable_writeback.semantic_closeout_command_template`，
diff --git a/benchmark/runtime/harbor.py b/benchmark/runtime/harbor.py
index 6ecd140fee..2d1da47048 100644
--- a/benchmark/runtime/harbor.py
+++ b/benchmark/runtime/harbor.py
@@ -366,11 +366,22 @@ async def install(self, environment: BaseEnvironment) -> None:
             if doctor_payload.get("ok") is not True:
                 raise RuntimeError(f"LoopX doctor failed: {doctor_payload}")
             if self.execution_observation is not None:
-                wrapper = (f"#!/bin/sh\nexec env PYTHONPATH={shlex.quote(_SRC)} "
-                           f"{_PYTHON}/bin/python3 -m benchmark.runtime.research_probe \"$@\"\n")
-                await self.exec_as_agent(environment,
-                    command=f"printf %s {shlex.quote(wrapper)} > {_PROFILE}/bin/loopx-research-probe; "
-                            f"chmod 0755 {_PROFILE}/bin/loopx-research-probe", env=self._profile_env())
+                entrypoint = f"{_SRC}/benchmark/runtime/research_probe.py"
+                # Keep the task cwd for candidate paths without importing the
+                # probe or its dependencies from that cwd or user site.
+                bootstrap = (
+                    "import runpy\nimport sys\n"
+                    f"sys.path.insert(0, {_SRC!r})\n"
+                    f"runpy.run_path({entrypoint!r}, run_name='__main__')\n"
+                )
+                launcher = shlex.join([f"{_PYTHON}/bin/python3", "-I", "-c", bootstrap])
+                wrapper = f"#!/bin/sh\nexec {launcher} \"$@\"\n"
+                probe = shlex.quote(f"{_PROFILE}/bin/loopx-research-probe")
+                installed = await self.exec_as_agent(environment, env=self._profile_env(), timeout_sec=30,
+                    command=f"test ! -L {probe} && printf %s {shlex.quote(wrapper)} > {probe} && "
+                            f"chmod 0755 {probe} && {probe} --help")
+                if installed.return_code or "--candidate-file" not in (installed.stdout or ""):
+                    raise RuntimeError("Local execution probe is unavailable to the benchmark worker")
 
         receipt = {
             "loopx_commit": actual_commit,
diff --git a/benchmark/runtime/interruption_recovery.py b/benchmark/runtime/interruption_recovery.py
new file mode 100644
index 0000000000..2e01364649
--- /dev/null
+++ b/benchmark/runtime/interruption_recovery.py
@@ -0,0 +1,234 @@
+"""Reconcile one interrupted benchmark Host, without certifying its work.
+
+This is Python provider/process IO around the existing Codex session, native
+history and external scheduler owners. It does not decide Goal/Todo recovery,
+grant budget, replay a tool, restore judge authority or manufacture a checkpoint.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import re
+import stat
+
+
+def recovery_handoff(env: dict[str, str]) -> tuple[dict | None, str]:
+    """Read content through the existing handoff owner; never adopt ownership."""
+    path, digest = env.get('LOOPX_RECOVERY_HANDOFF'), env.get('LOOPX_RECOVERY_HANDOFF_SHA256')
+    if path is None and digest is None:
+        return None, ''
+    if not path or not re.fullmatch(r'[0-9a-f]{64}', digest or ''):
+        raise ValueError('Recovery handoff requires its exact path and digest')
+    source = Path(path)
+    if not source.is_absolute() or source.resolve() != source or source.is_symlink():
+        raise ValueError('Recovery handoff must be a physical absolute file')
+    # Reject special files before reading, including a raced FIFO replacement.
+    descriptor = os.open(source, os.O_RDONLY | getattr(os, 'O_NONBLOCK', 0) | getattr(os, 'O_NOFOLLOW', 0))
+    with os.fdopen(descriptor, 'rb') as stream:
+        if not stat.S_ISREG(os.fstat(stream.fileno()).st_mode):
+            raise ValueError('Recovery handoff must be a regular file')
+        raw = stream.read(65537)
+    if len(raw) > 65536 or hashlib.sha256(raw).hexdigest() != digest:
+        raise ValueError('Recovery handoff bytes changed or exceed the transport bound')
+    from loopx.cli_commands.handoff_restore import restore_handoff_input
+    text = restore_handoff_input(raw.decode('utf-8'), input_format='json')
+    return {'path': path, 'sha256': digest}, text
+
+
+class ProcessObservers:
+    """Preserve request-admission cleanup while retaining process observations."""
+    def __init__(self, *observers):
+        self.observers = [observer for observer in observers if observer is not None]
+
+    def started(self, process):
+        for observer in self.observers:
+            observer.started(process)
+
+    def before_cleanup(self, process, error):
+        for observer in self.observers:
+            observer.before_cleanup(process, error)
+
+    def signal_requested(self, number):
+        for observer in self.observers:
+            observer.signal_requested(number)
+
+    def after_cleanup(self, process, error):
+        for observer in self.observers:
+            observer.after_cleanup(process, error)
+
+
+def _physical_read(path: Path) -> bytes:
+    if path.is_symlink() or path.resolve(strict=True) != path or not path.is_file():
+        raise ValueError("Interruption evidence must be a physical regular file")
+    return path.read_bytes()
+
+
+def _number(value):
+    if type(value) not in (int, float) or not math.isfinite(value):
+        raise ValueError("Interruption evidence requires finite process times")
+    return value
+
+
+def _process_window(receipt):
+    process = receipt.get("native_process", {})
+    after = process.get("after_cleanup") or {}
+    if (process.get("schema_version") != "native_codex_process_observation_v1"
+            or type(process.get("pid")) is not int or process["pid"] <= 1
+            or type(after.get("return_code")) is not int
+            or process.get("cleanup_error_type") is not None
+            or process.get("persistence_error_type") is not None):
+        raise ValueError("Original native process termination is unproven")
+    started = _number(process.get("started_at_unix"))
+    stopped = _number(after.get("observed_at_unix"))
+    if started > stopped:
+        raise ValueError("Original native process window is invalid")
+    # The worker owns and reaps this process group. A still-live group is a
+    # conservative hold even if the PID has since been reused.
+    if os.name != "posix":
+        raise ValueError("Original process-group termination is unavailable")
+    try:
+        os.killpg(process["pid"], 0)
+    except ProcessLookupError:
+        return started, stopped
+    except PermissionError as error:
+        raise ValueError("Original process-group termination is unavailable") from error
+    raise ValueError("Original native process group is still alive")
+
+
+def _stopped_source(state_file: Path, state: dict, env: dict[str, str], wake_log_dir: str):
+    """Consume the Docker provider's exact, explicitly prepared legacy source.
+
+    This is only valid on that unchanged filesystem. A proof cannot be combined
+    with an older checkpoint or with a newly created Goal/native home.
+    """
+    from benchmark.edgebench.stopped_recovery import file_inventory, source_paths
+
+    proof_path = Path(env['LOOPX_INTERRUPTED_SOURCE']).absolute()
+    raw = _physical_read(proof_path)
+    proof = json.loads(raw)
+    declaration = proof['declaration']
+    stopped = proof['source_state']
+    expected = {'goal_id': env['LOOPX_GOAL_ID'], 'agent_id': env['LOOPX_AGENT_ID'],
+        'workspace': env['LOOPX_PROJECT'], 'runtime_root': env['LOOPX_RUNTIME_ROOT'],
+        'native_home': env['CODEX_HOME'], 'registry': env['LOOPX_REGISTRY'],
+        'scheduler_state': str(state_file), 'wake_log_dir': wake_log_dir}
+    if (not re.fullmatch(r'[a-f0-9]{64}', proof.get('container_id', ''))
+            or stopped.get('Status') != 'exited' or stopped.get('Running') is not False
+            or stopped.get('Pid') != 0 or stopped.get('Restarting') or stopped.get('Paused')
+            or stopped.get('Dead') or proof.get('execution_authority_granted') is not False
+            or any(declaration.get(k) != v for k, v in expected.items())
+            or hashlib.sha256(_physical_read(state_file)).hexdigest() != proof['scheduler_state_sha256']):
+        raise ValueError('Stopped recovery proof differs from the original worker')
+    # Derive identity from the current UTS namespace, never a caller env value.
+    # The Docker producer only accepts the original default hostname. This
+    # prevents accidentally consuming copied evidence in a fresh worker; the
+    # trusted host/operator remains responsible for Docker namespace authority.
+    if os.name != 'posix' or os.uname().nodename != proof['container_id'][:12]:
+        raise ValueError('Stopped recovery is only valid in the original container namespace')
+    required = set(source_paths(declaration).values())
+    supplied = {part['source_path'] for part in proof['components']}
+    if not required <= supplied or any(p not in required and not any(
+            p == base + suffix for base in required for suffix in ('-wal', '-journal')) for p in supplied):
+        raise ValueError('Stopped recovery proof omits or adds source participants')
+    if len(supplied) != len(proof['components']):
+        raise ValueError('Stopped recovery proof repeats source participants')
+    for base in required:
+        for suffix in ('-wal', '-journal'):
+            if Path(base + suffix).exists() != (base + suffix in supplied):
+                raise ValueError('Stopped recovery source SQLite companions changed')
+    for component in proof['components']:
+        root = Path(component['source_path'])
+        if root.resolve(strict=True) != root or root.is_symlink() or root.is_dir() != component['directory']:
+            raise ValueError('Stopped recovery source participant moved')
+        if file_inventory(root) != component['files']:
+            raise ValueError('Stopped recovery source bytes changed')
+    path = Path(wake_log_dir) / declaration['wake_turn_id'] / 'receipt.json'
+    receipt_raw = _physical_read(path)
+    if hashlib.sha256(receipt_raw).hexdigest() != proof['receipt_sha256']:
+        raise ValueError('Stopped recovery original wake changed')
+    receipt = json.loads(receipt_raw)
+    return path, receipt_raw, receipt, proof
+
+
+def read_interrupted_host(state: dict, *, state_file: Path, env: dict[str, str], wake_log_dir: str) -> dict:
+    """Qualify an exact returned wake, then inspect its existing native session.
+
+    No caller-supplied terminal boolean or inferred last score authorizes this
+    path. Missing legacy evidence remains a recovery gap, not a new attempt.
+    """
+    from .scheduler import BUDGET_EXHAUSTED_EXIT_CODE
+    from loopx.control_plane.turn_driver.codex_agent_session import CodexAgentSession
+    from loopx.hosts.codex_checkpoint import native_interrupted_turn
+    from .codex import process_environment
+    from scripts.external_scheduler_worker import _host_pending
+
+    # Match the worker's original isolated home, not an operator's ambient one.
+    env = process_environment(Path(env["LOOPX_CODEX_HOME"]), base=env)
+    if _host_pending(state_file) is not True:
+        raise ValueError("Original Host pending witness is unresolved or already cleared")
+
+    prior = state.get("host_attempt", {})
+    attempt = prior.get("attempt_id", "")
+    legacy = bool(env.get('LOOPX_INTERRUPTED_SOURCE')) and not attempt
+    if ((not legacy and not re.fullmatch(r"[0-9a-f]{32}", attempt))
+            or prior.get("status") not in {"started", "stopped"}
+            or "host_failure" in prior
+            or (prior["status"] == "stopped" and prior.get("stop_exit_code") != BUDGET_EXHAUSTED_EXIT_CODE)):
+        raise ValueError("Original Host interruption identity is unavailable")
+    source = None
+    if legacy:
+        path, raw, receipt, source = _stopped_source(state_file, state, env, wake_log_dir)
+    else:
+        matches = []
+        root = Path(wake_log_dir).absolute()
+        for path in root.glob("*/receipt.json"):
+            raw = _physical_read(path)
+            try:
+                receipt = json.loads(raw)
+            except ValueError:
+                continue
+            if isinstance(receipt, dict) and receipt.get("host_attempt_id") == attempt:
+                matches.append((path, raw, receipt))
+        if len(matches) != 1:
+            raise ValueError("Original Host interruption must have one exact wake receipt")
+        path, raw, receipt = matches[0]
+    if (receipt.get("turn_id") != path.parent.name or receipt.get("mode") != "heartbeat"
+            or receipt.get("stage") != "execute" or receipt.get("host_invoked") is not True
+            or receipt.get("budget_exhausted") is not True or receipt.get("ok") is not False
+            or "host_failure" in receipt
+            or (not legacy and any(receipt.get(key) != env["LOOPX_" + key.upper()]
+                                   for key in ("goal_id", "agent_id")))):
+        raise ValueError("Original Host receipt is not this lane's interrupted budget stop")
+    started, stopped = ((_number(source['process_started_at']), _number(source['process_stopped_at']))
+                        if legacy else _process_window(receipt))
+    try:
+        phase = float(source['source_phase_deadline_epoch'] if legacy else receipt["phase_deadline_epoch"])
+    except (KeyError, TypeError, ValueError) as error:
+        raise ValueError("Original Host phase clock is unavailable") from error
+    if not math.isfinite(phase) or not started <= phase <= stopped:
+        raise ValueError("Original Host stopped outside its phase deadline")
+    session = receipt.get("session") or {}
+    if session.get("binding_scope") != "agent" or not session.get("session_id"):
+        raise ValueError("Original Host session is unavailable")
+    current = CodexAgentSession(env, context="resume",
+        sandbox=env.get("LOOPX_CODEX_SANDBOX", "danger-full-access"), receipt={})
+    with current.admission.launch_lifetime(operation="benchmark_interrupted_host_recovery"):
+        pass  # Also checks legacy source/mirror activation, unlike require_current alone.
+    if (not current.binding or current.session_id != session["session_id"]
+            or prior.get("session_id") not in (None, current.session_id)):
+        raise ValueError("Original Host session binding changed")
+    native = native_interrupted_turn(env, current.session_id,
+        process_started_at=started, process_stopped_at=stopped)
+    with current.admission.launch_lifetime(operation="benchmark_interrupted_host_recovery"):
+        pass  # A concurrent Stop or registry change cannot authorize the new phase.
+    if _physical_read(path) != raw:
+        raise ValueError("Original Host receipt changed during readback")
+    return {**({'source_container_id': source['container_id'],
+                'source_proof_sha256': hashlib.sha256(_physical_read(Path(env['LOOPX_INTERRUPTED_SOURCE']))).hexdigest()}
+               if legacy else {'host_attempt_id': attempt}), "wake_turn_id": receipt["turn_id"],
+            "receipt_path": str(path), "receipt_sha256": hashlib.sha256(raw).hexdigest(),
+            "source_phase_deadline_epoch": phase, "session_profile_digest": current.digest,
+            "native": native}
diff --git a/benchmark/runtime/research_probe.py b/benchmark/runtime/research_probe.py
index 9b4f87025c..316be73ef0 100644
--- a/benchmark/runtime/research_probe.py
+++ b/benchmark/runtime/research_probe.py
@@ -6,6 +6,7 @@
 """
 from __future__ import annotations
 
+from _thread import LockType
 import argparse
 import hashlib
 import json
@@ -14,6 +15,8 @@
 from pathlib import Path
 import signal
 import subprocess
+import sys
+import threading
 import time
 
 
@@ -45,6 +48,9 @@ def execution_observation_guidance() -> str:
         "use `loopx-research-probe --help` to wrap the relevant local execution within its existing "
         "budget. Do not repeat an experiment merely to produce an attachment. Retain actual host "
         "elapsed time, exit or timeout, and selected-file hashes; keep unmeasured values unknown. "
+        "When aggregate memory could change the choice, reuse or estimate the complete workload with "
+        "the applicable reference using --memory-limit-bytes. If the estimate is decision-critical, "
+        "verify real overlap and compare a lower-footprint method on the same workload and accepted outcome. "
         "Method ids are producer declarations and optional solver counters are reports, not "
         "independently verified execution. Attach available execution_observation through ordinary "
         "Explore writeback with matching candidate, input revision and evidence refs. This tool "
@@ -69,14 +75,81 @@ def candidate_snapshot(paths: list[Path], workspace: Path) -> tuple[str, list[di
     return hashlib.sha256(encoded.encode()).hexdigest(), files
 
 
+def _group_members(group_id: int) -> dict[int, bytes]:
+    members = {}
+    for entry in Path("/proc").iterdir():
+        if not entry.name.isdecimal():
+            continue
+        try:
+            stat = (entry / "stat").read_bytes().rsplit(b")", 1)[1].split()
+        except (FileNotFoundError, ProcessLookupError):
+            continue
+        # Fields after comm start with state, ppid and pgrp. Use starttime to
+        # distinguish PID reuse, and skip zombies which no longer own memory.
+        if int(stat[2]) == group_id and int(stat[3]) == group_id and stat[0] != b"Z":
+            members[int(entry.name)] = stat[19]
+    return members
+
+
+def _group_pss_sample(group_id: int) -> tuple[int, int] | None:
+    try:
+        members = _group_members(group_id)
+        if not members:
+            return None
+        footprint = 0
+        for pid in members:
+            rollup = Path(f"/proc/{pid}/smaps_rollup").read_bytes()
+            pss = next(line.split() for line in rollup.splitlines() if line.startswith(b"Pss:"))
+            if len(pss) != 3 or pss[2] != b"kB" or not pss[1].isdigit():
+                return None
+            footprint += int(pss[1]) * 1024
+        # This checks membership only. PSS reads happen one PID at a time,
+        # so a stable group can still move memory between those reads.
+        if members == _group_members(group_id):
+            return footprint, len(members)
+    except (OSError, IndexError, ValueError, StopIteration):
+        pass  # Racing/denied reads are unknown, not a smaller valid sample.
+    return None
+
+
+def _observe_group_pss(group_id: int, stopped: threading.Event, samples: dict, lock: LockType) -> None:
+    while not stopped.is_set():
+        sample = _group_pss_sample(group_id)
+        with lock:
+            if stopped.is_set():
+                return
+            if sample is None:
+                samples["incomplete_samples"] += 1
+            else:
+                peak, members = sample
+                samples["complete_samples"] += 1
+                if samples["peak_sampled_pss_bytes"] is None or peak > samples["peak_sampled_pss_bytes"]:
+                    samples.update(peak_sampled_pss_bytes=peak, members_at_peak=members)
+        stopped.wait(0.25)
+
+
+def _memory_observation(samples: dict, source: dict, limit_bytes: int, evidence_ref: str) -> dict:
+    return {
+        "measurement_basis": "linux-sequential-process-group-pss-v1",
+        "candidate_sha256": source["candidate_sha256"],
+        "input_revision": source["input_revision"],
+        "executed_method_id": source["executed_method_id"],
+        "probe_evidence_ref": evidence_ref.strip(),
+        "reference_memory_bytes": limit_bytes,
+        **samples,
+    }
+
+
 def run_probe(*, command: list[str], candidate_files: list[Path], output: Path,
               input_revision: str, planned_method_id: str, executed_method_id: str,
               evidence_ref: str, limit_seconds: float, change_reason: str | None = None,
-              diagnostics: Path | None = None) -> dict:
+              diagnostics: Path | None = None, memory_limit_bytes: int | None = None) -> dict:
     from loopx.capabilities.explore.execution_observation import normalize_execution_observation
 
     if not command or not math.isfinite(limit_seconds) or limit_seconds <= 0:
         raise ValueError("a command and finite positive local probe limit are required")
+    if memory_limit_bytes is not None and (type(memory_limit_bytes) is not int or memory_limit_bytes <= 0):
+        raise ValueError("memory_limit_bytes requires a positive integer")
     workspace = Path.cwd().resolve()
     before, files = candidate_snapshot(candidate_files, workspace)
     observation = dict(schema_version="explore_execution_observation_v0",
@@ -87,7 +160,11 @@ def run_probe(*, command: list[str], candidate_files: list[Path], output: Path,
     normalize_execution_observation(observation)  # Reject bad attribution before execution.
     if diagnostics is not None and diagnostics.exists():
         raise FileExistsError("use a fresh diagnostic path; previous observations cannot describe this probe")
-    # Reserve before any process effect. Existing evidence is never overwritten.
+    # Reserve the primary receipt before any process effect. A stale sidecar
+    # cannot be adopted as a new probe, including a dangling symbolic link.
+    memory_output = output.with_suffix(output.suffix + ".memory.json")
+    if memory_limit_bytes is not None and os.path.lexists(memory_output):
+        raise FileExistsError("use a fresh memory observation path")
     with output.open("x", encoding="utf-8") as record:
         with output.with_suffix(output.suffix + ".candidate.json").open("x", encoding="utf-8") as source:
             source.write(json.dumps({"candidate_sha256": before, "files": files}, sort_keys=True) + "\n")
@@ -96,15 +173,33 @@ def run_probe(*, command: list[str], candidate_files: list[Path], output: Path,
             env["LOOPX_RESEARCH_DIAGNOSTICS"] = str(diagnostics.resolve())
         started = time.monotonic()
         timed_out = False
+        samples = (dict(complete_samples=0, incomplete_samples=0, peak_sampled_pss_bytes=None, members_at_peak=None)
+                   if memory_limit_bytes is not None else None)
         with output.with_suffix(output.suffix + ".stdout").open("xb") as stdout, \
              output.with_suffix(output.suffix + ".stderr").open("xb") as stderr:
             process = subprocess.Popen(command, cwd=workspace, env=env, stdout=stdout, stderr=stderr,
                                        start_new_session=True)
+            stopped = None
+            sampler = None
+            wait_seconds = limit_seconds
             try:
-                process.wait(timeout=limit_seconds)
+                if samples is not None and sys.platform == "linux":
+                    sampling_start = time.monotonic()
+                    stopped, lock = threading.Event(), threading.Lock()
+                    sampler = threading.Thread(target=_observe_group_pss,
+                        args=(process.pid, stopped, samples, lock), daemon=True)
+                    try:
+                        sampler.start()
+                    except RuntimeError:
+                        sampler = None  # Unavailable diagnostics must not cancel the probe.
+                    wait_seconds = max(0, limit_seconds - (time.monotonic() - sampling_start))
+                process.wait(timeout=wait_seconds)
             except subprocess.TimeoutExpired:
                 timed_out = True
             finally:
+                if stopped is not None:
+                    with lock:
+                        stopped.set()
                 # Stop the owned group, including descendants that outlive a
                 # successful leader; they must not continue changing a candidate.
                 try:
@@ -112,6 +207,8 @@ def run_probe(*, command: list[str], candidate_files: list[Path], output: Path,
                 except ProcessLookupError:
                     pass
                 process.wait()
+                if sampler is not None:
+                    sampler.join(timeout=0.25)
         observation["elapsed_seconds"] = time.monotonic() - started
         observation["exit_code"] = process.returncode
         observation["stop_reason"] = "host_timeout" if timed_out else f"process_exit:{process.returncode}"
@@ -125,6 +222,19 @@ def run_probe(*, command: list[str], candidate_files: list[Path], output: Path,
         # completed execution or change its real exit/timeout status.
         result = normalize_execution_observation(observation)
         try:
+            if samples is not None and memory_limit_bytes is not None:
+                measurement = _memory_observation(samples, result, memory_limit_bytes, evidence_ref)
+                encoded = json.dumps(measurement, sort_keys=True, separators=(",", ":")).encode() + b"\n"
+                try:
+                    with memory_output.open("xb", buffering=0) as memory_record:
+                        if memory_record.write(encoded) != len(encoded):
+                            raise OSError("incomplete optional memory observation")
+                        os.fsync(memory_record.fileno())
+                except OSError:
+                    print("Optional process-group memory observation could not be retained.", file=sys.stderr)
+                else:
+                    result["evidence_refs"].append("resource:" + hashlib.sha256(encoded).hexdigest())
+                    result = normalize_execution_observation(result)
             if diagnostics is not None:
                 try:
                     if diagnostics.exists():
@@ -178,6 +288,8 @@ def main() -> int:
     parser.add_argument("--change-reason")
     parser.add_argument("--evidence-ref", required=True)
     parser.add_argument("--limit-seconds", type=float, required=True)
+    parser.add_argument("--memory-limit-bytes", type=int,
+        help="Write a .memory.json diagnostic with sequential Linux PSS samples and this reference (bytes)")
     parser.add_argument("--diagnostics", type=Path)
     parser.add_argument("command", nargs=argparse.REMAINDER)
     args = vars(parser.parse_args())
diff --git a/benchmark/runtime/scheduler.py b/benchmark/runtime/scheduler.py
index 822cab9f99..235d4152a8 100644
--- a/benchmark/runtime/scheduler.py
+++ b/benchmark/runtime/scheduler.py
@@ -9,6 +9,7 @@
 from pathlib import Path
 import re
 import shlex
+import sys
 import time
 
 # Private process transport between the benchmark wake and its shell scheduler.
@@ -89,19 +90,28 @@ def _phase_receipt(state_file: Path, wake_log_dir: str | None) -> dict | None:
     return value if isinstance(value, dict) else None
 
 
-def _create_resume_state(target: Path, predecessor: Path) -> None:
+def _create_resume_state(target: Path, predecessor: Path, *, recovered: dict | None = None,
+                         replan_attempts=None, handoff: dict | None = None) -> None:
     if target.is_symlink():
         raise ValueError("Resumed scheduler state must not be a symlink")
     try:
-        with target.open("x", encoding="utf-8") as stream:
-            json.dump({"resume_from": str(predecessor)}, stream)
+        with os.fdopen(os.open(target, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600), "w", encoding="utf-8") as stream:
+            value = {"resume_from": str(predecessor)}
+            if recovered is not None:
+                value.update(interruption_recovery=recovered,
+                    recovered_session_id=recovered["native"]["session_id"],
+                    replan_attempts=replan_attempts or [])
+            if handoff is not None:
+                value["recovery_handoff"] = handoff
+            json.dump(value, stream)
+            stream.flush()
+            os.fsync(stream.fileno())
     except FileExistsError:
         return
-    target.chmod(0o600)
 
 
 def resume_state_file(state_file: str, *, phase_deadline: float, agent_id: str,
-                      wake_log_dir: str | None = None) -> str:
+                      wake_log_dir: str | None = None, env: dict[str, str] | None = None) -> str:
     """Select a new transport phase only after an explicit budget continuation.
 
     Kernel state and native sessions stay in place. The original scheduler
@@ -111,6 +121,8 @@ def resume_state_file(state_file: str, *, phase_deadline: float, agent_id: str,
     if (isinstance(phase_deadline, bool) or not isinstance(phase_deadline, (int, float))
             or not math.isfinite(phase_deadline) or phase_deadline <= time.time()):
         raise ValueError("Budget continuation requires an open finite phase deadline")
+    from .interruption_recovery import recovery_handoff
+    handoff, _ = recovery_handoff(env or {})
     path = _physical_state(Path(state_file).absolute())
     from loopx.file_lock import try_exclusive_file_lock
     from scripts.external_scheduler_worker import HOST_LOCK_OPERATION, _host_attempt, _host_pending
@@ -135,7 +147,20 @@ def resume_state_file(state_file: str, *, phase_deadline: float, agent_id: str,
         if state is None:
             return str(predecessor)
         prior = state.get("host_attempt")
-        if not isinstance(prior, dict) or prior.get("status") != "stopped":
+        recovery = state.get("interruption_recovery")
+        can_continue_stopped_phase = (isinstance(prior, dict) and prior.get("status") == "stopped"
+                                      and prior.get("stop_exit_code") == BUDGET_EXHAUSTED_EXIT_CODE)
+        requested_suffix = hashlib.sha256(float(phase_deadline).hex().encode()).hexdigest()[:20]
+        same_phase = predecessor.name == f"{path.stem}.phase-{requested_suffix}{path.suffix}"
+        if ((recovery is not None or state.get("resume_from"))
+                and state.get("recovery_handoff") != handoff
+                and (same_phase or not can_continue_stopped_phase)):
+            raise ValueError("Recovered phase handoff is immutable; preserve its exact input")
+        if (recovery is not None and recovery.get("phase_deadline_epoch") != phase_deadline
+                and not (isinstance(prior, dict) and prior.get("status") == "stopped"
+                         and prior.get("stop_exit_code") == BUDGET_EXHAUSTED_EXIT_CODE)):
+            raise ValueError("Recovered phase deadline is immutable; inspect the current phase before continuing")
+        if not isinstance(prior, dict):
             return str(predecessor)
         # Validate the captured record with its existing transport owner.
         scope = prior.get("scope")
@@ -145,7 +170,27 @@ def resume_state_file(state_file: str, *, phase_deadline: float, agent_id: str,
             _host_attempt(state, scope)
         except (TypeError, ValueError):
             return str(predecessor)
-        if (prior.get("stop_exit_code") != BUDGET_EXHAUSTED_EXIT_CODE
+        # A returned interrupted wake is distinct from a pre-dispatch stop.
+        # Explicit continuation only reconciles transport; all Goal/Stop,
+        # replan, lease and launch decisions remain with the normal next wake.
+        recovered = None
+        if env is not None and wake_log_dir and _host_pending(predecessor) is not None:
+            from .interruption_recovery import read_interrupted_host
+
+            try:
+                recovered = read_interrupted_host(state, state_file=predecessor, env=env, wake_log_dir=wake_log_dir)
+            except (OSError, ValueError, RuntimeError, TimeoutError, KeyError, TypeError) as error:
+                print(f"Interrupted Host remains held: {type(error).__name__}: {error}", file=sys.stderr)
+        if recovered is not None:
+            suffix = hashlib.sha256(float(phase_deadline).hex().encode()).hexdigest()[:20]
+            target = path.with_name(f"{path.stem}.phase-{suffix}{path.suffix}")
+            recovered.update(source_state_sha256=hashlib.sha256(predecessor.read_bytes()).hexdigest(),
+                             phase_deadline_epoch=phase_deadline)
+            _create_resume_state(target, predecessor, recovered=recovered,
+                                 replan_attempts=state.get("replan_attempts"), handoff=handoff)
+            return str(target)
+        if (prior.get("status") != "stopped"
+                or prior.get("stop_exit_code") != BUDGET_EXHAUSTED_EXIT_CODE
                 or "host_failure" in prior or _host_pending(predecessor) is None
                 or state.get("last_wake_rc") != BUDGET_EXHAUSTED_EXIT_CODE
                 or state.get("last_wake_status") != "wake_requested_stop"):
@@ -167,7 +212,7 @@ def resume_state_file(state_file: str, *, phase_deadline: float, agent_id: str,
                 or result.get("host_invoked") is not False or result.get("mode") != "heartbeat"
                 or result.get("stage") != "execute"):
             return str(predecessor)
-        _create_resume_state(target, predecessor)
+        _create_resume_state(target, predecessor, handoff=handoff)
         return str(target)
 
 
@@ -206,7 +251,8 @@ def main() -> int:
     args = parser.parse_args()
     state = resume_state_file(args.state_file,
         phase_deadline=float(os.environ["LOOPX_PHASE_DEADLINE_EPOCH"]),
-        agent_id=os.environ["LOOPX_AGENT_ID"], wake_log_dir=os.environ.get("LOOPX_WAKE_LOG_DIR"))
+        agent_id=os.environ["LOOPX_AGENT_ID"], wake_log_dir=os.environ.get("LOOPX_WAKE_LOG_DIR"),
+        env=dict(os.environ))
     command = worker_command(dict(os.environ), python=args.python, source=args.source,
                              state_file=state, host_timeout=args.host_timeout)
     os.execvpe(command[0], command, os.environ)
diff --git a/benchmark/runtime/sforge.py b/benchmark/runtime/sforge.py
index c742e69b26..a446e9dd51 100644
--- a/benchmark/runtime/sforge.py
+++ b/benchmark/runtime/sforge.py
@@ -25,6 +25,7 @@
 from .harbor import (
     BenchmarkCodex, _CONTROL, _CODEX_HOME, _PYTHON, _SCHEDULER_STATE, _SRC,
 )
+from .research_probe import resolve_execution_observation
 from .scheduler import worker_command
 
 
@@ -93,6 +94,7 @@ def __init__(self, config, *, profile: str, cwd: str,
                  task_entry: str | None = None,
                  turn_envelope: bool = False,
                  context_delivery: str | None = None,
+                 execution_observation: str | None = None,
                  provider_request_admission: bool = False,
                  native_goal_continue: bool = False,
                  replan_after_turns: int | None = None,
@@ -114,6 +116,9 @@ def __init__(self, config, *, profile: str, cwd: str,
             mode="heartbeat" if profile.startswith("heartbeat-") else "plain",
             context_delivery=context_delivery,
         ).context_delivery
+        self.execution_observation = resolve_execution_observation(execution_observation)
+        if self.execution_observation is not None and not profile.startswith("heartbeat-"):
+            raise ValueError("execution_observation requires a heartbeat worker")
         if type(provider_request_admission) is not bool:
             raise ValueError("provider_request_admission must be a boolean opt-in")
         if provider_request_admission and not profile.startswith("heartbeat-"):
@@ -336,6 +341,8 @@ def _install_worker(self, backend, handle, log_dir, logger):
                 task_entry=self.task_entry,
                 turn_envelope=self.turn_envelope,
                 context_delivery=self.context_delivery,
+                **({"execution_observation": self.execution_observation}
+                   if self.execution_observation is not None else {}),
                 **({"provider_request_admission": True} if self.provider_request_admission else {}),
                 native_goal_continue=self.native_goal_continue,
                 replan_after_turns=self.replan_after_turns,
@@ -435,6 +442,8 @@ def _install_worker(self, backend, handle, log_dir, logger):
             "explore_graph": self.profile == "heartbeat-explore",
             "explore_harness": self.profile == "heartbeat-explore",
             "feedback": self.feedback,
+            **({"execution_observation": self.execution_observation}
+               if self.execution_observation is not None else {}),
             **({"feedback_delivery": "codex_hooks", "feedback_payload": FEEDBACK_PAYLOAD}
                if self.feedback == "best-only" else {}),
             **(self.runtime._replan_receipt() if self.runtime and
diff --git a/benchmark/runtime/worker.py b/benchmark/runtime/worker.py
index 968539ed90..f7673de2ef 100644
--- a/benchmark/runtime/worker.py
+++ b/benchmark/runtime/worker.py
@@ -126,7 +126,9 @@ def heartbeat_body(env: dict[str, str], turn_id: str, *, native_goal: bool,
     )
     from .research_probe import runtime_execution_guidance
 
-    return body + runtime_execution_guidance(env)
+    from .interruption_recovery import recovery_handoff
+    _, handoff = recovery_handoff(env)
+    return body + runtime_execution_guidance(env) + ("\nRecovery handoff (content only):\n" + handoff if handoff else "")
 
 
 @contextmanager
@@ -207,11 +209,18 @@ def native_child_process(command, *, env, stdout, stderr, session_wake, receipt,
         guard = ProviderRequestAdmission(env, session_wake, receipt, wake,
             timeout=timeout, original_quota=original_quota)
         scope = guard.serve(command)
+    observation = guard
+    if env.get("LOOPX_HOST_ATTEMPT_ID") and session_wake is not None:
+        from loopx.capabilities.benchmark_toolkit.native_codex_process import NativeCodexProcessObservation
+        from .interruption_recovery import ProcessObservers
+
+        native_observation = NativeCodexProcessObservation(lambda value: receipt.update(native_process=value))
+        observation = ProcessObservers(native_observation, guard)
     with scope as routed:
         with child_process(routed, env=env, stdout=stdout, stderr=stderr,
                 goal_admission=session_wake.admission if session_wake is not None else None,
                 check_current_launch=heartbeat_launch_check(env, session_wake, original_quota=original_quota),
-                **({"process_observation": guard} if guard is not None else {})) as process:
+                **({"process_observation": observation} if observation is not None else {})) as process:
             yield process
     if guard is not None and guard.refusal_code is not None:
         from loopx.control_plane.goals.first_party_host_admission import FirstPartyHostRuntimeRejected
@@ -548,6 +557,11 @@ def run_once(env: dict[str, str]) -> dict:
         "ok": False,
         "timed_out": False,
     }
+    if env.get("LOOPX_HOST_ATTEMPT_ID"):
+        # The scheduler supplies the transport identity, never model prose.
+        receipt.update(host_attempt_id=env["LOOPX_HOST_ATTEMPT_ID"],
+            goal_id=env.get("LOOPX_GOAL_ID"), agent_id=env.get("LOOPX_AGENT_ID"),
+            phase_deadline_epoch=env.get("LOOPX_PHASE_DEADLINE_EPOCH"))
     session_wake = None
     phase_work_deadline = None
     checkpoint_context = ExitStack()
@@ -555,6 +569,10 @@ def run_once(env: dict[str, str]) -> dict:
         Path(env.get("LOOPX_RUNTIME_ROOT", str(home))) / "benchmark-pending-turn.json"
     )
     try:
+        from .interruption_recovery import recovery_handoff
+        handoff, _ = recovery_handoff(env)
+        if handoff is not None:
+            receipt["recovery_handoff_sha256"] = handoff["sha256"]
         if stage == "execute" and env.get("LOOPX_PHASE_DEADLINE_EPOCH"):
             remaining = float(env["LOOPX_PHASE_DEADLINE_EPOCH"]) - time.time()
             # Heartbeat work uses the whole remaining phase. Cleanup is bounded
diff --git a/benchmark/tests/test_interruption_recovery.py b/benchmark/tests/test_interruption_recovery.py
new file mode 100644
index 0000000000..451f5ea341
--- /dev/null
+++ b/benchmark/tests/test_interruption_recovery.py
@@ -0,0 +1,247 @@
+"""Retained interrupted work resumes through ordinary admission, never replay."""
+from __future__ import annotations
+
+from contextlib import contextmanager
+import copy
+import json
+import os
+from pathlib import Path
+import shlex
+import sys
+import time
+
+import pytest
+
+from benchmark.runtime.interruption_recovery import _process_window
+from benchmark.runtime.scheduler import resume_state_file
+from loopx.hosts import codex_checkpoint as native
+
+
+def _history(monkeypatch, tmp_path, *, change=None):
+    tail = dict(id="last", status="interrupted", error=None, startedAt=110, completedAt=120,
+                items=[dict(type="commandExecution", status="failed")])
+    turns = [dict(id="first", status="completed", items=[]), tail]
+    if change == "in_progress":
+        tail["status"] = "inProgress"
+    elif change == "pending_effect":
+        tail["items"][0]["status"] = "inProgress"
+    elif change == "outside_window":
+        tail["startedAt"] = 90
+    elif change == "completed":
+        tail["status"] = "completed"
+    elif change == "duplicate":
+        turns[0]["id"] = "last"
+    calls = []
+
+    class Transport:
+        def request(self, method, params):
+            calls.append(method)
+            if method == "thread/read":
+                return {"thread": {"id": "other" if change == "wrong_session" else "session",
+                                   "cwd": str(tmp_path)}}
+            assert method == "thread/turns/list"  # No native resume/interrupt/model method.
+            result = copy.deepcopy(turns)
+            if change == "changed_history" and calls.count(method) > 1:
+                result[0]["items"] = [dict(type="agentMessage", text="later")]
+            return dict(data=result, nextCursor=None)
+
+    @contextmanager
+    def reader(*args, **kwargs):
+        yield Transport()
+
+    monkeypatch.setattr(native, "native_checkpoint_reader", reader)
+    return calls
+
+
+@pytest.mark.parametrize("change", ["in_progress", "pending_effect", "outside_window", "completed",
+                                    "duplicate", "wrong_session", "changed_history"])
+def test_native_interruption_rejects_unproven_or_changed_tail(monkeypatch, tmp_path, change):
+    _history(monkeypatch, tmp_path, change=change)
+    with pytest.raises(ValueError):
+        native.native_interrupted_turn({"LOOPX_PROJECT": str(tmp_path)}, "session",
+            process_started_at=100, process_stopped_at=125)
+
+
+def test_interruption_readback_does_not_relax_completed_checkpoint(monkeypatch, tmp_path):
+    calls = _history(monkeypatch, tmp_path)
+    result = native.native_interrupted_turn({"LOOPX_PROJECT": str(tmp_path)}, "session",
+        process_started_at=100, process_stopped_at=125)
+    assert result["turn_count"] == 2 and result["turn_id"] == "last"
+    assert calls == ["thread/read", "thread/turns/list", "thread/turns/list"]
+    with native.native_checkpoint_reader({}, timeout=10) as transport:
+        with pytest.raises(ValueError, match="completed final cursor"):
+            native._complete_history(transport.request, "session")
+
+
+@pytest.mark.skipif(os.name != "posix", reason="Process-group termination requires POSIX")
+def test_live_process_group_cannot_be_settled():
+    evidence = dict(native_process=dict(schema_version="native_codex_process_observation_v1",
+        pid=os.getpgrp(), started_at_unix=100, after_cleanup=dict(return_code=0, observed_at_unix=110)))
+    with pytest.raises(ValueError, match="still alive"):
+        _process_window(evidence)
+
+
+@pytest.mark.skipif(os.name != "posix", reason="Owned process-group cleanup requires POSIX")
+@pytest.mark.parametrize("fault", [None, "profile", "stop", "wrong_session", "duplicate_wake"])
+def test_real_sqlite_scheduler_retains_interrupted_session_then_admits_next_turn(tmp_path, monkeypatch, fault):
+    from benchmark.runtime import worker
+    from benchmark.tests.test_worker_phase_budget import _phase_worker
+    from tests import test_external_scheduler_worker as scheduler_fixture
+
+    env, project, _runtime, _source, goal_state, _clock = _phase_worker(tmp_path, monkeypatch)
+    monkeypatch.setattr(worker, "time", time)
+    binary = Path(env["CODEX_BIN"])
+    binary.write_text(f"#!{sys.executable}\n" + '''
+import json, os, pathlib, signal, sys, time
+history=pathlib.Path('native-history.json')
+if 'app-server' in sys.argv:
+    for line in sys.stdin:
+        message=json.loads(line)
+        if 'id' not in message: continue
+        method=message['method']
+        if method=='initialize': result={}
+        elif method=='thread/read': result={'thread':{'id':'original-native','cwd':str(pathlib.Path.cwd())}}
+        elif method=='thread/turns/list': result={'data':[json.loads(history.read_text())],'nextCursor':None}
+        else: raise AssertionError(method)
+        print(json.dumps({'jsonrpc':'2.0','id':message['id'],'result':result}),flush=True)
+    sys.exit(0)
+with pathlib.Path('native-argv').open('a') as f: f.write(json.dumps(sys.argv[1:])+'\\n')
+print(json.dumps({'type':'thread.started','thread_id':'original-native'}),flush=True)
+start=int(time.time())
+def interrupted(*args):
+    history.write_text(json.dumps({'id':'interrupted-work','status':'interrupted','error':None,
+        'startedAt':start,'completedAt':int(time.time()),
+        'items':[{'type':'commandExecution','status':'failed'}]}))
+    sys.exit(130)
+signal.signal(signal.SIGINT,interrupted)
+payload=sys.stdin.read()
+with pathlib.Path('native-inputs').open('a') as f:f.write(json.dumps(payload)+'\\n')
+if pathlib.Path('continue').exists():
+    print(json.dumps({'type':'turn.completed'}),flush=True)
+else:
+    time.sleep(60)
+''')
+    entry = tmp_path / "worker-entry.py"
+    entry.write_text("from benchmark.runtime import worker\n"
+                     "from benchmark.runtime.interruption_recovery import recovery_handoff\n"
+                     "worker.heartbeat_body=lambda env,*a,**kw:'synthetic authorized work'+recovery_handoff(env)[1]\n"
+                     "raise SystemExit(worker.main())\n")
+    for key, value in env.items():
+        monkeypatch.setenv(key, value)
+    args, _ = scheduler_fixture._guarded_host(tmp_path / "scheduler")
+    args.once = True
+    args.registry, args.runtime_root = env["LOOPX_REGISTRY"], env["LOOPX_RUNTIME_ROOT"]
+    args.goal_id, args.agent_id = env["LOOPX_GOAL_ID"], env["LOOPX_AGENT_ID"]
+    args.wake_cmd = shlex.join([sys.executable, str(entry)])
+    args.wake_stop_exit_code, args.wake_timeout_seconds = 75, 30
+    monkeypatch.setattr(scheduler_fixture.worker, "run_quota_should_run",
+        lambda *a, **kw: scheduler_fixture._hint_payload(should_run=True))
+    initial_goal = goal_state.read_bytes()
+    monkeypatch.setenv("LOOPX_PHASE_DEADLINE_EPOCH", str(time.time() + 8))
+    assert scheduler_fixture.worker.run_worker(args) == 0
+    original = Path(args.state_file)
+    old_bytes = original.read_bytes()
+    old = json.loads(old_bytes)
+    assert old["host_attempt"]["status"] == "stopped"
+    receipts = list(Path(env["LOOPX_WAKE_LOG_DIR"]).glob("*/receipt.json"))
+    assert len(receipts) == 1
+    first = json.loads(receipts[0].read_bytes())
+    assert first["host_invoked"] and first["budget_exhausted"]
+    assert first["host_attempt_id"] == old["host_attempt"]["attempt_id"]
+    assert first["native_process"]["after_cleanup"]["return_code"] is not None
+    deadline = time.time() + 60
+    monkeypatch.setenv("LOOPX_PHASE_DEADLINE_EPOCH", str(deadline))
+    if fault == "profile":
+        monkeypatch.setenv("MODEL_NAME", "different-model")
+    elif fault == "stop":
+        from loopx.control_plane.goals.activation_service import set_goal_activation_state
+        result = set_goal_activation_state(registry_path=Path(args.registry), goal_id=args.goal_id,
+            state="stopped", reason="Owner stopped this work.", actor_kind="owner", execute=True)
+        assert result["ok"]
+    elif fault == "wrong_session":
+        first["session"]["session_id"] = "another-native"
+        receipts[0].write_text(json.dumps(first))
+    elif fault == "duplicate_wake":
+        second_receipt = receipts[0].parent.with_name("duplicate") / "receipt.json"
+        second_receipt.parent.mkdir()
+        second_receipt.write_bytes(receipts[0].read_bytes())
+    if fault is None:
+        import hashlib
+        brief = tmp_path / 'recovery-handoff.json'
+        brief.write_text(json.dumps({'ok': True, 'handoff_text': 'Retained submission old-7 is now restored-7; read the inherited history. Goal and opportunities are unchanged.'}))
+        monkeypatch.setenv('LOOPX_RECOVERY_HANDOFF', str(brief))
+        monkeypatch.setenv('LOOPX_RECOVERY_HANDOFF_SHA256', hashlib.sha256(brief.read_bytes()).hexdigest())
+    new = resume_state_file(str(original), phase_deadline=deadline, agent_id=args.agent_id,
+        wake_log_dir=env["LOOPX_WAKE_LOG_DIR"], env=dict(os.environ))
+    if fault:
+        assert new == str(original) and original.read_bytes() == old_bytes
+        assert len((project / "native-argv").read_text().splitlines()) == 1
+        return
+    assert new != str(original)
+    settlement = json.loads(Path(new).read_bytes())
+    assert settlement["recovered_session_id"] == "original-native"
+    assert settlement["interruption_recovery"]["native"]["turn_id"] == "interrupted-work"
+    assert resume_state_file(str(original), phase_deadline=deadline, agent_id=args.agent_id,
+        wake_log_dir=env["LOOPX_WAKE_LOG_DIR"], env=dict(os.environ)) == new
+    with pytest.raises(ValueError, match="immutable"):
+        resume_state_file(str(original), phase_deadline=deadline + 60, agent_id=args.agent_id,
+            wake_log_dir=env["LOOPX_WAKE_LOG_DIR"], env=dict(os.environ))
+    (project / "continue").touch()
+    args.state_file = new
+    assert scheduler_fixture.worker.run_worker(args) == 0
+    argv = [json.loads(line) for line in (project / "native-argv").read_text().splitlines()]
+    assert len(argv) == 2 and "resume" in argv[1] and "original-native" in argv[1]
+    assert original.read_bytes() == old_bytes and goal_state.read_bytes() == initial_goal
+    assert json.loads(Path(new).read_bytes())["recovery_handoff_delivered"] is True
+    assert scheduler_fixture.worker.run_worker(args) == 0
+    inputs = [json.loads(line) for line in (project / 'native-inputs').read_text().splitlines()]
+    assert len(inputs) == 3
+    assert 'restored-7' in inputs[1] and 'restored-7' not in inputs[2]
+
+
+
+def test_recovery_handoff_missing_changed_and_default_parity(tmp_path):
+    import hashlib
+    from benchmark.runtime.interruption_recovery import recovery_handoff
+    assert recovery_handoff({}) == (None, '')
+    path = tmp_path / 'handoff.json'
+    raw = json.dumps({'ok': True, 'handoff_text': 'Read retained history; no ownership change.'}).encode()
+    env = dict(LOOPX_RECOVERY_HANDOFF=str(path), LOOPX_RECOVERY_HANDOFF_SHA256=hashlib.sha256(raw).hexdigest())
+    with pytest.raises(FileNotFoundError): recovery_handoff(env)
+    path.write_bytes(raw)
+    first = recovery_handoff(env)
+    assert recovery_handoff(env) == first
+    path.write_bytes(raw + b' ')
+    with pytest.raises(ValueError, match='bytes changed'): recovery_handoff(env)
+    with pytest.raises(ValueError): recovery_handoff({'LOOPX_RECOVERY_HANDOFF': str(path)})
+
+
+@pytest.mark.parametrize('status', ['started', 'unknown', 'returned'])
+def test_new_transport_phase_does_not_clear_unsettled_semantic_replan(tmp_path, monkeypatch, status):
+    from tests.test_external_scheduler_worker import _guarded_host, worker
+    from tests.test_external_scheduler_replan_retry import _replan
+    from benchmark.runtime.scheduler import _create_resume_state
+    args, count = _guarded_host(tmp_path, kind='provider_capacity', recover_at=2)
+    args.once = True
+    monkeypatch.setattr(worker, 'run_quota_should_run', lambda *a, **kw: _replan(tmp_path))
+    assert worker.run_worker(args, clock=lambda: 1000.0) == 1
+    old = Path(args.state_file)
+    state = json.loads(old.read_bytes())
+    attempts = state['replan_attempts']
+    attempts[0]['status'] = status
+    target = tmp_path / 'continued.json'
+    _create_resume_state(target, old, recovered={'native': {'session_id': 'same-session'}},
+                         replan_attempts=attempts)
+    args.state_file = str(target)
+    assert worker.run_worker(args, clock=lambda: 1031.0) in (0, 2)
+    assert count.read_text() == '1'
+    assert json.loads(target.read_bytes())['replan_attempts'] == attempts
+
+
+@pytest.mark.skipif(not hasattr(os, 'mkfifo'), reason='FIFO boundary requires POSIX')
+def test_recovery_handoff_rejects_fifo_without_waiting_for_a_writer(tmp_path):
+    from benchmark.runtime.interruption_recovery import recovery_handoff
+    pipe = tmp_path / 'handoff.fifo'
+    os.mkfifo(pipe)
+    with pytest.raises(ValueError, match='regular file'):
+        recovery_handoff(dict(LOOPX_RECOVERY_HANDOFF=str(pipe), LOOPX_RECOVERY_HANDOFF_SHA256='a' * 64))
diff --git a/benchmark/tests/test_scheduler_phase_resume.py b/benchmark/tests/test_scheduler_phase_resume.py
index bd633cb8b1..52d1410241 100644
--- a/benchmark/tests/test_scheduler_phase_resume.py
+++ b/benchmark/tests/test_scheduler_phase_resume.py
@@ -189,3 +189,43 @@ def test_only_explicit_continuation_wraps_the_existing_scheduler():
     assert continued[1:3] == ["-m", "benchmark.runtime.scheduler"]
     assert worker_command({**env, "LOOPX_EXECUTION_MODE": "native-goal"}, **options,
                           resume_budget_stop=True) == ["/python", "-m", "benchmark.runtime.worker"]
+
+
+def test_later_authorized_phase_can_bind_a_new_handoff_without_rewriting_prior(tmp_path, monkeypatch):
+    import hashlib
+    from benchmark.runtime import interruption_recovery
+    root = tmp_path / 'scheduler.json'
+    _stopped(root)
+    source = json.loads(root.read_bytes())
+    old_deadline = time.time() - 10
+    source.update(interruption_recovery={'phase_deadline_epoch': old_deadline},
+                  recovery_handoff={'path': '/old/handoff', 'sha256': 'a' * 64})
+    root.write_text(json.dumps(source))
+    old = root.read_bytes()
+    brief = tmp_path / 'new-handoff.json'
+    brief.write_text(json.dumps({'ok': True, 'handoff_text': 'New phase, same objective and opportunity.'}))
+    env = dict(LOOPX_RECOVERY_HANDOFF=str(brief), LOOPX_RECOVERY_HANDOFF_SHA256=hashlib.sha256(brief.read_bytes()).hexdigest())
+    monkeypatch.setattr(interruption_recovery, 'read_interrupted_host',
+        lambda *a, **kw: {'native': {'session_id': 'original'}})
+    deadline = time.time() + 100
+    selected = Path(resume_state_file(str(root),phase_deadline=deadline,agent_id='agent',wake_log_dir=str(tmp_path/'wakes'),env=env))
+    assert selected != root and root.read_bytes() == old
+    assert json.loads(selected.read_bytes())['recovery_handoff']['sha256'] == env['LOOPX_RECOVERY_HANDOFF_SHA256']
+
+
+def test_pre_dispatch_continuation_binds_and_replays_its_optional_handoff(tmp_path):
+    import hashlib
+    root = tmp_path / 'scheduler.json'
+    _stopped(root)
+    brief = tmp_path / 'handoff.json'
+    brief.write_text(json.dumps({'ok': True, 'handoff_text': 'Keep the original goal.'}))
+    env = dict(LOOPX_RECOVERY_HANDOFF=str(brief), LOOPX_RECOVERY_HANDOFF_SHA256=hashlib.sha256(brief.read_bytes()).hexdigest())
+    deadline = time.time() + 100
+    def select():
+        return Path(resume_state_file(str(root),phase_deadline=deadline,agent_id='agent',wake_log_dir=str(tmp_path/'wakes'),env=env))
+    phase = select()
+    assert json.loads(phase.read_bytes())['recovery_handoff']['sha256'] == env['LOOPX_RECOVERY_HANDOFF_SHA256']
+    assert select() == phase
+    brief.write_text(json.dumps({'ok': True, 'handoff_text': 'Different material.'}))
+    env['LOOPX_RECOVERY_HANDOFF_SHA256'] = hashlib.sha256(brief.read_bytes()).hexdigest()
+    with pytest.raises(ValueError, match='immutable'): select()
diff --git a/benchmark/tests/test_sforge_runtime.py b/benchmark/tests/test_sforge_runtime.py
index f1ad1b25cc..336cecac39 100644
--- a/benchmark/tests/test_sforge_runtime.py
+++ b/benchmark/tests/test_sforge_runtime.py
@@ -1470,3 +1470,62 @@ def before_solver(**kwargs):
         run.main(args)
     receipt = json.loads((tmp_path / "runs/storage/fixture/runtime-receipt.json").read_text())
     assert receipt.get("context_delivery") == (expected_delivery if expected_delivery != "off" else None)
+
+
+@pytest.mark.parametrize(("profile", "selected"), [
+    ("heartbeat-explore", False), ("heartbeat-explore", True), ("native-goal", True),
+])
+def test_edgebench_cli_reuses_local_probe_and_reports_selection_before_model(tmp_path, monkeypatch, capsys,
+                                                                              profile, selected):
+    pytest.importorskip("sforge")
+    pytest.importorskip("harbor")
+    from types import SimpleNamespace
+    from benchmark.edgebench import run
+    from benchmark.runtime.harbor import BenchmarkCodex
+
+    producer = "local_probe" if selected else None
+    monkeypatch.delenv("OPENAI_BASE_URL", raising=False)
+    monkeypatch.setenv("LOOPX_SRC_DIR", str(tmp_path))
+    monkeypatch.setenv("LOOPX_EXPECTED_COMMIT", "fixture")
+    monkeypatch.setenv("CODEX_AUTH_JSON_PATH", "/synthetic-unused-credential")
+    (tmp_path / "fixture.json").write_text("{}")
+    monkeypatch.setattr(run, "source_pins", lambda *a: ("fixture", "fixture"))
+    monkeypatch.setattr(run, "load_benchmark", lambda *a: None)
+    monkeypatch.setattr(run, "make_task_spec", lambda *a: SimpleNamespace(
+        cwd="/task", work_image_key="work", judge_image_key="judge", internet=False,
+        game_mode=False, submit_paths=["solver.py"], work=SimpleNamespace(agent_query="Original acceptance."),
+        judge=SimpleNamespace(selection="score_first", score_direction="maximize")))
+    backend = SimpleNamespace(image_exists=lambda image: True,
+                              exec_run=lambda *a, **k: SimpleNamespace(exit_code=0))
+    monkeypatch.setattr(run, "RecordingDockerBackend", lambda **k: backend)
+
+    async def install_at_transport_boundary(self, environment):
+        assert environment.default_user == "agent"
+        assert self.execution_observation == producer
+        assert self._worker_env(cwd="/task").get("LOOPX_EXECUTION_OBSERVATION") == producer
+
+    monkeypatch.setattr(BenchmarkCodex, "install", install_at_transport_boundary)
+    trial = tmp_path / "runs" / "probe" / "fixture"
+
+    def stop_before_model(**kwargs):
+        worker = kwargs["agent"]
+        worker.install_stop_hook(backend, None, trial, None)
+        assert json.loads((trial / "worker-profile.json").read_text()).get("execution_observation") == producer
+        raise RuntimeError("isolated install boundary")
+
+    monkeypatch.setattr(run, "run_agent", stop_before_model)
+    args = ["--task", "fixture", "--tasks-dir", str(tmp_path), "--log-dir", str(tmp_path),
+            "--run-id", "probe", "--worker", profile, "--model", "fixture",
+            "--effort", "xhigh", "--judge-url", "http://127.0.0.1:9999"]
+    if selected:
+        args += ["--execution-observation", producer]
+    if profile == "native-goal":
+        with pytest.raises(SystemExit, match="2"):
+            run.main(args)
+        assert "--execution-observation requires a heartbeat worker" in capsys.readouterr().err
+        assert not trial.exists()
+        return
+    with pytest.raises(RuntimeError, match="isolated install boundary"):
+        run.main(args)
+    receipt = json.loads((trial / "runtime-receipt.json").read_text())
+    assert receipt.get("execution_observation") == producer
diff --git a/benchmark/tests/test_stopped_recovery.py b/benchmark/tests/test_stopped_recovery.py
new file mode 100644
index 0000000000..fc4049b0fc
--- /dev/null
+++ b/benchmark/tests/test_stopped_recovery.py
@@ -0,0 +1,244 @@
+"""A stopped source proof observes existing bytes, and grants no execution."""
+from __future__ import annotations
+
+import io
+import json
+import os
+from pathlib import Path
+import shutil
+import tarfile
+import time
+from types import SimpleNamespace
+
+import pytest
+
+from benchmark.edgebench import stopped_recovery as subject
+from benchmark.runtime.interruption_recovery import _stopped_source
+
+
+def _source(root):
+    paths = dict(goal_id="fixture-goal", agent_id="fixture-agent", workspace=str(root / "workspace"),
+        runtime_root=str(root / "runtime"), native_home=str(root / "native"),
+        registry=str(root / "control/registry.json"), scheduler_state=str(root / "control/state.json"),
+        wake_log_dir=str(root / "wakes"), phase_clock=str(root / "control/deadline"),
+        wake_turn_id="wake-100000000000-deadbeefabcd")
+    for path in [Path(paths[k]) for k in ("workspace", "runtime_root", "native_home", "wake_log_dir")]:
+        path.mkdir(parents=True)
+    (root / "control").mkdir()
+    for file in ("workspace/answer", "runtime/goal", "native/state_5.sqlite",
+                 "native/state_5.sqlite-wal", "native/thread_history_1.sqlite", "native/config.toml"):
+        (root / file).write_bytes((b"SQLite format 3\0" if file.endswith(".sqlite") else b"") + b"synthetic retained bytes")
+    (root / "native/sessions").mkdir()
+    (root / "native/sessions/session.jsonl").write_text("{}\n")
+    (root / "control/registry.json").write_text("{}")
+    (root / "control/deadline").write_text("105")
+    state = Path(paths["scheduler_state"])
+    state.write_text(json.dumps(dict(host_attempt=dict(status="started", scope="a" * 64, attempt=1))))
+    state.with_name(state.name + '.host-attempt').write_text('{"pending":true}')
+    os.utime(state, (99, 99))
+    receipt = Path(paths["wake_log_dir"]) / paths["wake_turn_id"] / "receipt.json"
+    receipt.parent.mkdir()
+    receipt.write_text(json.dumps(dict(turn_id=paths["wake_turn_id"], host_invoked=True, budget_exhausted=True,
+        mode="heartbeat", stage="execute", ok=False, session=dict(binding_scope="agent", session_id="original"))))
+    os.utime(receipt, (110, 110))
+    return paths
+
+
+def _fake_container(monkeypatch):
+    box = SimpleNamespace(id="a" * 64, attrs={"State": dict(Status="exited", Running=False, Pid=0,
+        FinishedAt="1970-01-01T00:02:00Z"), "Config": dict(Cmd=["tail", "-f", "/dev/null"], Hostname="a" * 12), "Mounts": []})
+    box.reload = lambda: None
+    def archive(container, remote, destination, **kwargs):
+        destination.mkdir()
+        source = Path(remote)
+        if source.is_dir():
+            return Path(shutil.copytree(source, destination / source.name))
+        copied = Path(shutil.copy2(source, destination / source.name))
+        for suffix in ("-wal", "-journal"):
+            if Path(remote + suffix).exists():
+                shutil.copy2(remote + suffix, str(copied) + suffix)
+        return copied
+    monkeypatch.setattr(subject, "_archive_component", archive)
+    monkeypatch.setattr(os, "uname", lambda: SimpleNamespace(nodename="a" * 12))
+    return box, SimpleNamespace(containers=SimpleNamespace(get=lambda identity: box))
+
+
+@pytest.mark.parametrize("fault", [None, "live", "restart_command", "mount", "custom_hostname", "ambiguous_wake"])
+def test_prepare_stopped_source_keeps_original_state_and_requires_unique_return(tmp_path, monkeypatch, fault):
+    declaration = _source(tmp_path)
+    box, client = _fake_container(monkeypatch)
+    original = Path(declaration["scheduler_state"]).read_bytes()
+    if fault == "live":
+        box.attrs["State"].update(Status="running", Running=True, Pid=42)
+    elif fault == "restart_command":
+        box.attrs["Config"]["Cmd"] = ["run-original-job"]
+    elif fault == "mount":
+        box.attrs["Mounts"] = [dict(Source="/writable")]
+    elif fault == "custom_hostname":
+        box.attrs["Config"]["Hostname"] = "custom-worker"
+    elif fault == "ambiguous_wake":
+        second = tmp_path / "wakes/second/receipt.json"
+        second.parent.mkdir()
+        second.write_text("{}")
+    output = tmp_path / "source-proof.json"
+    if fault:
+        with pytest.raises(ValueError):
+            subject.prepare_stopped_recovery(client, container_id=box.id, declaration=declaration, output=output)
+        assert not output.exists()
+    else:
+        result = subject.prepare_stopped_recovery(client, container_id=box.id, declaration=declaration, output=output)
+        assert result["execution_authority_granted"] is False
+        assert any(p["source_path"].endswith("state_5.sqlite-wal") for p in result["components"])
+    assert Path(declaration["scheduler_state"]).read_bytes() == original
+
+
+@pytest.mark.parametrize("fault", [None, "workspace", "wal_removed", "new_journal", "session_removed", "state", "wrong_lane", "copied_proof", "wrong_container"])
+def test_consumer_rejects_stale_or_incomplete_latest_source(tmp_path, monkeypatch, fault):
+    declaration = _source(tmp_path)
+    box, client = _fake_container(monkeypatch)
+    proof = tmp_path / "source-proof.json"
+    subject.prepare_stopped_recovery(client, container_id=box.id, declaration=declaration, output=proof)
+    env = dict(LOOPX_INTERRUPTED_SOURCE=str(proof), LOOPX_GOAL_ID=declaration["goal_id"],
+        LOOPX_AGENT_ID=declaration["agent_id"], LOOPX_PROJECT=declaration["workspace"],
+        LOOPX_RUNTIME_ROOT=declaration["runtime_root"], CODEX_HOME=declaration["native_home"],
+        LOOPX_REGISTRY=declaration["registry"])
+    if fault == "workspace":
+        (tmp_path / "workspace/answer").write_text("different")
+    elif fault == "wal_removed":
+        (tmp_path / "native/state_5.sqlite-wal").unlink()
+    elif fault == "new_journal":
+        (tmp_path / "native/state_5.sqlite-journal").write_text("different")
+    elif fault == "session_removed":
+        (tmp_path / "native/sessions/session.jsonl").unlink()
+    elif fault == "state":
+        (tmp_path / "control/state.json").write_text("{}")
+    elif fault == "wrong_lane":
+        env["LOOPX_AGENT_ID"] = "other"
+    elif fault == "copied_proof":
+        monkeypatch.setattr(os, "uname", lambda: SimpleNamespace(nodename="b" * 12))
+    elif fault == "wrong_container":
+        value = json.loads(proof.read_bytes())
+        value["container_id"] = "b" * 64
+        proof.write_text(json.dumps(value))
+    if fault:
+        with pytest.raises(ValueError):
+            _stopped_source(Path(declaration["scheduler_state"]), {}, env, declaration["wake_log_dir"])
+    else:
+        first = _stopped_source(Path(declaration["scheduler_state"]), {}, env, declaration["wake_log_dir"])
+        assert _stopped_source(Path(declaration["scheduler_state"]), {}, env, declaration["wake_log_dir"]) == first
+
+
+@pytest.mark.parametrize("timeout", [0, -1, float("inf"), -float("inf"), float("nan")])
+def test_stopped_recovery_rejects_invalid_archive_timeout(tmp_path, timeout):
+    output = tmp_path / "proof.json"
+    with pytest.raises(ValueError, match="timeout must be finite and positive"):
+        subject.prepare_stopped_recovery(None, container_id="a" * 64,
+            declaration=_source(tmp_path), output=output, timeout=timeout)
+    assert not output.exists()
+
+
+@pytest.mark.skipif(os.environ.get("LOOPX_EDGEBENCH_DOCKER_SMOKE") != "1", reason="Explicit disposable Docker qualification")
+def test_real_stopped_docker_proof_installation_is_inert_and_read_back(tmp_path, monkeypatch):
+    docker = pytest.importorskip("docker")
+    client = docker.from_env(timeout=30)
+    box = client.containers.create("python:3.12-slim", ["tail", "-f", "/dev/null"], network_disabled=True)
+    local = tmp_path / "fixture"
+    local.mkdir()
+    declaration = _source(local)
+    declaration = {key: value.replace(str(local), "/fixture") for key, value in declaration.items()}
+    try:
+        package = io.BytesIO()
+        with tarfile.open(fileobj=package, mode="w") as archive:
+            archive.add(local, arcname="fixture")
+        assert box.put_archive("/", package.getvalue())
+        box.start()
+        box.stop(timeout=2)
+        box.reload()
+        original = dict(box.attrs["State"])
+        archive_requests = []
+        get = client.api._get
+
+        def observe_archive_timeout(url, **options):
+            if url.endswith("/archive"):
+                archive_requests.append((options["params"]["path"], options["timeout"]))
+            return get(url, **options)
+
+        monkeypatch.setattr(client.api, "_get", observe_archive_timeout)
+        archive_component = subject._archive_component
+        expired_output = tmp_path / "expired-proof.json"
+        with monkeypatch.context() as slow_reader:
+            def enter_after_deadline(*args, **kwargs):
+                time.sleep(0.02)
+                return archive_component(*args, **kwargs)
+
+            slow_reader.setattr(subject, "_archive_component", enter_after_deadline)
+            with pytest.raises(TimeoutError, match="capture window closed"):
+                subject.prepare_stopped_recovery(client, container_id=box.id, declaration=declaration,
+                    output=expired_output, timeout=0.001, install=True)
+        assert not expired_output.exists() and not archive_requests
+        box.reload()
+        assert box.attrs["State"] == original
+
+        allowance = 30
+        proof = subject.prepare_stopped_recovery(client, container_id=box.id, declaration=declaration,
+            output=tmp_path / "proof.json", timeout=allowance, install=True)
+        assert proof["installed_proof_path"].startswith("/fixture/control/interruption-source-")
+        assert len([path for path, _ in archive_requests if path == proof["installed_proof_path"]]) == 2
+        remaining = [seconds for _, seconds in archive_requests]
+        assert all(0 < seconds <= allowance for seconds in remaining)
+        assert remaining == sorted(remaining, reverse=True)
+        monkeypatch.setattr(client.api, "_get", get)
+        assert proof["execution_authority_granted"] is False
+        box.reload()
+        assert box.attrs["State"] == original
+        # Install only public source outside the inventoried fixture and consume
+        # the proof inside the same original namespace, including a replay.
+        code = Path(__file__).resolve().parents[2]
+        package = io.BytesIO()
+        with tarfile.open(fileobj=package, mode="w") as archive:
+            for directory in ("benchmark", "loopx"):
+                for path in (code / directory).rglob("*"):
+                    if path.is_file() and path.suffix in {".py", ".json"}:
+                        archive.add(path, arcname="source/" + str(path.relative_to(code)))
+        assert box.put_archive("/", package.getvalue())
+        env = dict(LOOPX_INTERRUPTED_SOURCE=proof["installed_proof_path"],
+            LOOPX_GOAL_ID=declaration["goal_id"], LOOPX_AGENT_ID=declaration["agent_id"],
+            LOOPX_PROJECT=declaration["workspace"], LOOPX_RUNTIME_ROOT=declaration["runtime_root"],
+            CODEX_HOME=declaration["native_home"], LOOPX_REGISTRY=declaration["registry"])
+        script = ("import sys,json;sys.path.insert(0,'/source');from pathlib import Path;"
+            "from benchmark.runtime.interruption_recovery import _stopped_source;"
+            f"a=(Path({declaration['scheduler_state']!r}),{{}},{env!r},{declaration['wake_log_dir']!r});"
+            "first=_stopped_source(*a);assert _stopped_source(*a)==first;print('same namespace replay verified')")
+        box.start()
+        result = box.exec_run(["python", "-c", script])
+        assert result.exit_code == 0, result.output.decode()
+        # A new worker with identical source bytes cannot use this proof.
+        other = client.containers.create("python:3.12-slim", ["tail", "-f", "/dev/null"], network_disabled=True)
+        try:
+            for remote in ("/fixture", "/source"):
+                stream, _ = box.get_archive(remote)
+                assert other.put_archive("/", b"".join(stream))
+            other.start()
+            rejected = other.exec_run(["python", "-c", script])
+            assert rejected.exit_code != 0
+            assert b"original container namespace" in rejected.output
+        finally:
+            other.remove(force=True)
+    finally:
+        box.remove(force=True)
+
+
+def test_inventory_preserves_arbitrary_shm_names_and_omits_only_sqlite_index(tmp_path):
+    answer = tmp_path / 'answer-shm'
+    answer.write_text('original candidate')
+    before = subject.file_inventory(tmp_path)
+    answer.write_text('different candidate')
+    assert subject.file_inventory(tmp_path) != before
+    (tmp_path / 'database').write_bytes(b'SQLite format 3\0' + b'synthetic database')
+    index = tmp_path / 'database-shm'
+    index.write_bytes(b'rebuildable index')
+    before = subject.file_inventory(tmp_path)
+    index.write_bytes(b'rebuilt reader index')
+    assert subject.file_inventory(tmp_path) == before
+    (tmp_path / 'database').write_bytes(b'not a database')
+    assert any(row['path'] == 'database-shm' for row in subject.file_inventory(tmp_path))
diff --git a/benchmark/tests/test_task_entry.py b/benchmark/tests/test_task_entry.py
index 571e83e78f..6b58f0c3a8 100644
--- a/benchmark/tests/test_task_entry.py
+++ b/benchmark/tests/test_task_entry.py
@@ -125,13 +125,42 @@ def test_raw_worker_rejects_invalid_observation_before_creating_a_wake(tmp_path,
     assert not wakes.exists()
 
 
-@pytest.mark.parametrize("settings", [{}, {"execution_observation": "local_probe"}])
-def test_install_records_and_exposes_only_the_selected_observation_producer(tmp_path, monkeypatch, settings):
+@pytest.mark.parametrize("entry", ["omitted", "ready", "workspace-shadow", "symlink", "missing-interpreter"])
+def test_install_records_and_exposes_only_the_selected_observation_producer(tmp_path, monkeypatch, entry):
     pytest.importorskip("harbor")
-    from benchmark.runtime.harbor import BenchmarkCodex, CodexOffline
+    if not Path("/bin/sh").is_file():
+        pytest.skip("requires a POSIX shell for the actual worker entrypoint")
+    from benchmark.runtime import harbor
 
-    agent = BenchmarkCodex(logs_dir=tmp_path, model_name="fixture", **settings)
+    selected = entry != "omitted"
+    profile = tmp_path / "profile"
+    bin_dir = profile / "bin"
+    bin_dir.mkdir(parents=True)
+    interpreter_dir = tmp_path / "python" / "bin"
+    interpreter_dir.mkdir(parents=True)
+    if entry != "missing-interpreter":
+        (interpreter_dir / "python3").symlink_to(sys.executable)
+    wrapper = bin_dir / "loopx-research-probe"
+    sentinel = tmp_path / "untouched"
+    if entry == "symlink":
+        sentinel.write_text("unchanged")
+        wrapper.symlink_to(sentinel)
+    if entry == "workspace-shadow":
+        shadow = tmp_path / "benchmark"
+        (shadow / "runtime").mkdir(parents=True)
+        (shadow / "__init__.py").write_text("")
+        (shadow / "runtime" / "research_probe.py").write_text(
+            "from pathlib import Path\nPath('shadow-called').touch()\nprint('--candidate-file --memory-limit-bytes')\n")
+        shadow_loopx = tmp_path / "loopx"
+        shadow_loopx.mkdir()
+        (shadow_loopx / "__init__.py").write_text("from pathlib import Path\nPath('shadow-called').touch()\n")
+    monkeypatch.setattr(harbor, "_PROFILE", str(profile))
+    monkeypatch.setattr(harbor, "_PYTHON", str(interpreter_dir.parent))
+    monkeypatch.setattr(harbor, "_SRC", str(Path(__file__).resolve().parents[2]))
+    agent = harbor.BenchmarkCodex(logs_dir=tmp_path, model_name="fixture",
+                                 execution_observation="local_probe" if selected else None)
     commands = []
+    wrapper_reads = []
 
     async def no_op(*args, **kwargs):
         pass
@@ -141,28 +170,71 @@ async def stage(*args, **kwargs):
         return "fixture"
 
     async def execute(*args, **kwargs):
-        commands.append(kwargs["command"])
+        command = kwargs["command"]
+        commands.append(command)
+        if "benchmark/runtime/research_probe.py" in command:
+            result = subprocess.run(["/bin/sh", "-c", command], cwd=tmp_path,
+                                    env={"PATH": "/usr/bin:/bin", "PYTHONPATH": str(tmp_path),
+                                         "PYTHONDONTWRITEBYTECODE": "1"},
+                                    text=True, capture_output=True, timeout=10)
+            wrapper_reads.append(result)
+            return SimpleNamespace(stdout=result.stdout, stderr=result.stderr, return_code=result.returncode)
         return SimpleNamespace(stdout='{"ok":true}', stderr="", return_code=0)
 
     async def task_exec(**kwargs):
         return SimpleNamespace(stdout="/usr/local/bin:/usr/bin:/bin", return_code=0)
 
+    async def execute_root(*args, **kwargs):
+        assert "benchmark/runtime/research_probe.py" not in kwargs["command"]
+        return await execute(*args, **kwargs)
+
     for key in ("LOOPX_SRC_DIR", "LOOPX_PORTABLE_PYTHON", "LOOPX_NODE_DIR"):
         monkeypatch.setenv(key, str(tmp_path))
-    monkeypatch.setattr(CodexOffline, "install", no_op)
+    monkeypatch.setattr(harbor.CodexOffline, "install", no_op)
     monkeypatch.setattr(agent, "_stage_source", stage)
-    monkeypatch.setattr(agent, "exec_as_root", execute)
+    monkeypatch.setattr(agent, "exec_as_root", execute_root)
     monkeypatch.setattr(agent, "exec_as_agent", execute)
     monkeypatch.setattr(agent, "_get_env", lambda key: None)
-    asyncio.run(agent.install(SimpleNamespace(default_user="fixture", upload_dir=no_op, exec=task_exec)))
-    selected = bool(settings)
-    assert any("-m benchmark.runtime.research_probe" in command for command in commands) is selected
+    environment = SimpleNamespace(default_user="fixture", upload_dir=no_op, exec=task_exec)
+    if entry in {"symlink", "missing-interpreter"}:
+        with pytest.raises(RuntimeError, match="Local execution probe is unavailable"):
+            asyncio.run(agent.install(environment))
+        assert len(wrapper_reads) == 1 and wrapper_reads[0].returncode != 0
+        assert not any("> /logs/agent/loopx-install.json" in command for command in commands)
+        if entry == "symlink":
+            assert wrapper.is_symlink() and sentinel.read_text() == "unchanged"
+        return
+
+    asyncio.run(agent.install(environment))
+    assert any("benchmark/runtime/research_probe.py" in command for command in commands) is selected
+    assert len(wrapper_reads) == int(selected)
+    if selected:
+        assert os.access(wrapper, os.X_OK) and "--memory-limit-bytes" in wrapper_reads[0].stdout
+    else:
+        assert not wrapper.exists()
     command = next(command for command in commands if "> /logs/agent/loopx-install.json" in command)
     receipt = json.loads(shlex.split(command)[2])
     assert receipt.get("execution_observation") == ("local_probe" if selected else None)
     assert "research_loop" not in receipt
     assert receipt["task_entry"] == "loopx-planned"
     assert receipt.get("stride_strategy") is None
+    if entry == "workspace-shadow":
+        candidate = tmp_path / "candidate.py"
+        candidate.write_text("print('real probe kept the task cwd')")
+        invocation = subprocess.run([str(wrapper),
+            "--candidate-file", candidate.name, "--output", "probe.json", "--input-revision", "inputs-v1",
+            "--planned-method-id", "method:local", "--executed-method-id", "method:local",
+            "--evidence-ref", "probe:trusted", "--limit-seconds", "5", "--memory-limit-bytes", "8388608",
+            "--", sys.executable, candidate.name],
+            cwd=tmp_path, env={**os.environ, "PYTHONPATH": str(tmp_path)},
+            capture_output=True, text=True, timeout=12)
+        assert invocation.returncode == 0, invocation.stderr
+        observation = json.loads(invocation.stdout)
+        assert observation == json.loads((tmp_path / "probe.json").read_text())
+        memory = json.loads((tmp_path / "probe.json.memory.json").read_text())
+        assert memory["reference_memory_bytes"] == 8388608 and memory["candidate_sha256"] == observation["candidate_sha256"]
+        assert (tmp_path / "probe.json.stdout").read_text().strip() == "real probe kept the task cwd"
+        assert not (tmp_path / "shadow-called").exists()
 
 
 @pytest.fixture
diff --git a/docs/architecture/rfcs/monorepo-distribution-split-v0.md b/docs/architecture/rfcs/monorepo-distribution-split-v0.md
index 3d0b327f7b..3e030cbc4f 100644
--- a/docs/architecture/rfcs/monorepo-distribution-split-v0.md
+++ b/docs/architecture/rfcs/monorepo-distribution-split-v0.md
@@ -824,6 +824,184 @@ Approval needs a reviewed decision, not implementation progress or silence.
   installation, R1 managed minimal or D1–D7. No preset, frontend operation,
   permission or persisted state changes; protected execution keeps its owner.
 
+### 2026-11-07 — Caller process-transport loading proposal
+
+- **Baseline and boundary:** `7f521ff4505fa916a98a7401032922189eef414a`
+  loads `extensions.process_runtime` during the pure Turn-decision import.
+  Doctor Git, contract scanning, caller validation and Host bridge transport
+  now resolve their existing reexports on use. The original function objects,
+  signatures, direct/from/star imports, discovery, caller patch points,
+  preloaded-owner bindings and reload behavior remain available. This uses the
+  existing lazy-export pattern; the export-name set is local compatibility
+  metadata, not a shared state vocabulary. Python retains platform transport;
+  TypeScript retains decisions, deadlines, authority and receipts. No provider,
+  capability, default or process algorithm is added.
+- **Executable evidence:** the four cold-caller oracles fail on the immutable
+  baseline. Focused compatibility checks and the existing architecture oracle
+  pass on the proposal; the Turn-preview unselected-module guard is retained.
+  Real isolated Git, validation and bridge tests cover timeout, cancellation,
+  exited-leader descendants, stdin policy, framing and unconfirmed cleanup.
+  A newly built monolithic wheel repeats compatibility and real-process checks
+  outside the checkout. Complete public discovery/star name sets and transport
+  signatures match the baseline. This is source/wheel proposal evidence, not an
+  upgrade or adoption result.
+- **Measured scope:** pure Turn-decision import loads 337 LoopX modules instead
+  of 338. Pure import and help start no processes or connections; supported help
+  and unknown-command output/exit status remain identical. Shared synthetic
+  SQLite fixtures exercise accepted and rejected registered Turn plans: both
+  revisions start two Node processes and thirteen Git probes, with 62/61
+  connection observations respectively. Their complete returned envelopes match
+  except the source-decision digest from fresh observations. Registered plans
+  still select process transport; the entire preview dependency closure is not
+  qualified as cold. One removed import does not establish latency, RSS,
+  complete-cost, managed-Turn or long-horizon benefit.
+- **Remaining and rollback:** retain I3 for at least one minor release. D2, D5,
+  D6, I3, D3 and full R0/V10/M1/R1/context/model/install acceptance remain open.
+  Canary passes its six direct checks and 17 of 18 selected checks.
+  `first-connect-contract-smoke.py` fails with `KeyError: should_run` on both
+  baseline and proposal; its inline-field assumption needs separate repair.
+  This failure and existing broader lint/browser failures remain open.
+  The completed author proposal may enter normal review with disclosed
+  holds; protected runtime merge still requires maintainer authorization.
+  Revert this caller loading change to restore eager binding without state
+  migration; no unrelated language rewrite is required.
+
+### 2026-11-06 — History reader selected loading
+
+- **Baseline and boundary:** `22b0f6c25`. Ordinary `history` reads and help use
+  the existing registrar/handler through the shared CLI grammar and guard.
+  Maintenance actions, rejected parser requests and a preloaded full CLI retain
+  the original route, including handler/renderer patch points. History algorithms,
+  evidence windows, public imports and the TS owner remain unchanged. This is a
+  reversible R0 reader slice in the monolithic distribution; I3 still requires
+  at least one minor release for public moves.
+- **Real-path evidence:** 27 actual-console cases per baseline/candidate source
+  and installed-wheel environment preserve stdout/stderr/exit codes, UTC order,
+  Agent filtering, limits, empty/unknown inputs and current/stale evidence reads.
+  Four additional installed/source facade probes preserve patched handlers and
+  renderers. The preloaded-handler oracle failed before its correction; final
+  history/parser selection passes 26 tests. Existing durable history, artifact
+  and evidence oracles are retained. Required native services use disposable
+  process and data namespaces, with authenticated exit readback.
+- **Matched measurement:** Apple M4 Pro, 48 GiB, macOS 27 arm64, Python 3.13.5,
+  Node 26.0.0; matched Python dependencies and source-pair Node dependencies.
+  Each of four workloads has 30 interleaved baseline/candidate pairs, precompiled
+  bytecode and fresh Python processes with warm native-service reuse. The final
+  sampling takes 229 seconds; all three rounds total 698 seconds, below the
+  frozen 20-minute sampling bound. Setup, validation and tracing are separate.
+  Earlier environment/refinement observations retain their original scope.
+
+| Workload | Median / p95 elapsed ms, base → candidate | Median CPU ms | Median CLI peak RSS MiB |
+| --- | --- | --- | --- |
+| Source help | 1552 / 1862 → 204 / 349 | 670 → 100 | 91.4 → 31.3 |
+| Source Agent read | 1603 / 1833 → 417 / 482 | 665 → 150 | 91.9 → 34.4 |
+| Wheel help | 1621 / 2053 → 220 / 375 | 695 → 100 | 91.8 → 31.0 |
+| Wheel Agent read | 1648 / 1825 → 414 / 462 | 725 → 150 | 92.2 → 34.6 |
+
+- **Loading and effects:** source/wheel help loads 155 rather than 1157 LoopX
+  modules; registered reads load 208 rather than 1158, evidence reads 210 rather
+  than 1159. Python audit read-open observations decrease from 1290 to 246 for
+  source help and 1311 to 723 for its cold native read; wheel observations are
+  1291 → 247 and 1710 → 723. Help has zero observed writes/processes/connections.
+  Cold registered reads retain six write-opens, two process starts and one
+  connection, with 252/355 client IPC bytes sent/received. Evidence reads retain
+  one write-open, two connections and 1377/804 IPC bytes. These required effects
+  are not optional activation. A serving runtime can work without Node on PATH;
+  cold absence retains the existing failure. Output bytes match. Timing includes
+  interpreter and process invocation; descendant CPU/RSS/I/O, full model and
+  attention costs remain unknown.
+- **Holds and remaining work:** measured help p95 remains above the proposed
+  200 ms target; D6 is not adopted. Source-session loader inventory and Turn
+  preview import checks fail identically on the untouched baseline. Their failures
+  are retained as qualification holds. This does not close full R0/V10, M1,
+  split installation, R1/context/host qualification or open design decisions.
+  Revert the loader slice for rollback; no state migration is involved.
+
+### 2026-11-06 — Selected version loading and matched costs
+
+The independent proposal `8a79d8602e699e51452ca1f43dc9b9527c81aa1b` at baseline
+`5a58635028fbef1316dc66531daf5fdb655e9b13` selects the existing version registrar
+and handler through `cli_runtime`. It reuses the canonical global grammar,
+format precedence, usage hooks and controller guard. Rejected parsing retains
+full-CLI fallback and diagnostics; explicitly bound package or full-CLI exports
+retain their registrar/handler patch points without triggering lazy exports
+on ordinary queries. Public imports, identity and types remain
+unchanged. No capability, provider, package, permission, preset or TypeScript
+decision owner is added. The separate DSH/helper and negative cost proposal is
+[#8185](https://github.com/loopx-project/loopx/pull/8185); its E7/E8 observations
+are distinct from this version-path comparison and are not a dependency.
+
+The initial `55e3ef45a` comparison retains 120 ordinary-query observations
+(source median 1.546 → 0.059 seconds; wheel 1.554 → 0.072). A later independent
+case finds that it ignores a patched package-facade handler, returning 0 instead
+of 37. Its passing premerge did not cover that branch. The failure and original
+inputs/data remain retained; they do not qualify facade compatibility. The
+proposal repairs both package registrar and handler adoption, then freezes the
+new exact-head comparison below.
+
+- **Real caller:** source and freshly installed monolithic wheels at both
+  immutable revisions exercise the actual `loopx` console. All 27 cases per
+  distribution have identical stdout, stderr and exit status, including
+  global/local/repeated formats, explicit paths, help, unknown/abbreviated
+  options, missing/empty values and fallback. Independent unknown-command/
+  option cases reject with exit 2 and no result. Version works with Node absent
+  in all four variants; outer-controller read behavior and full-CLI patch points
+  remain compatible.
+- **Loading census:** separate parent instrumentation records 1,157 → 10
+  LoopX modules in both distributions, with the candidate contained in the
+  baseline set. Source read-opens are 1,286 → 28 and wheel 1,289 → 29.
+  Each version capture has zero write-opens, subprocesses, observed local IPC
+  connections and covered socket bytes. Stdout remains 81 bytes; stderr is empty.
+- **Frozen comparison:** all four environments have verified provenance,
+  CPython 3.13.5 and identical 57 dependency versions. Stdlib, dependencies and
+  all 1,421 LoopX sources have valid timestamp bytecode in owned cache prefixes;
+  post-measurement/profile source/header inventories have no missing/invalid
+  caches and match the preflight. Every sample has fresh Python and disables
+  bytecode writes; disk cache is uncontrolled. No broker/warm-broker comparison
+  is made. Order is source then wheel, AB on even pairs and BA on odd pairs.
+  Both corrected groups complete 30 pairs: 120 accepted observations in 62.246
+  seconds. Including the first study, aggregate sampling is 166.191 seconds,
+  below the unchanged 1,200-second cap. All observations are retained.
+
+| Distribution | Baseline seconds, median / p95 | Proposal seconds, median / p95 | CPU seconds, median (base → proposal) | RSS MiB, median (base → proposal) | Median paired proposal minus baseline, seconds |
+| --- | --- | --- | --- | --- | --- |
+| Source | 0.980 / 1.056 | 0.055 / 0.075 | 0.520 → 0.037 | 90.17 → 16.81 | -0.9242 |
+| Monolithic wheel | 0.948 / 1.147 | 0.056 / 0.077 | 0.511 → 0.038 | 89.89 → 16.60 | -0.8993 |
+
+p95 uses nearest rank; paired differences and differences of arm medians are
+distinct statistics. Median latency falls about 94% in both source and wheel
+on this macOS arm64 environment; CPU and target RSS also fall. One-minute host
+load ranges from 8.25 to 9.06. This qualifies a material version-query
+improvement under frozen conditions, without adopting portable D6 budgets or
+claiming real managed-Turn/long-horizon savings. Usage covers the target and
+waited descendants; no child is launched in the census. Native detail and
+complete authoring/model/maintenance costs remain unknown.
+
+The heartbeat-to-final-freeze interval is about 2,404 seconds, including
+overlapping recovery, initial study, correction, dependency/build/install,
+test, cache and parity work; overlapping phases cannot be summed. Cache
+preparation is recorded separately. Corrected console/facade parity takes
+82.759 seconds, instrumentation 2.539 and four parent profiles 4.155. Earlier
+parity/instrumentation/profile costs of 136.239 / 3.830 / 7.089 seconds remain
+retained. Cross-study timing levels are not treated as a code comparison.
+Existing `performance-diagnosis` recipes show export loading and full parser
+construction in baseline sampled stacks; weights remain separate from repeated
+latency. Monolithic packaging is verified, without split-install or installed
+host-upgrade qualification.
+
+Seven selected-loading cases fail on the baseline and pass on the proposal.
+The package registrar/handler case passes on the baseline, fails on the initial
+candidate and passes on the correction; canonical diagnostic and full-CLI
+patch-point cases pass in both baseline and proposal. All 161 entrypoint cases and
+focused lint pass. Owner-scoped mypy with `--follow-imports=skip` fails with
+33 identical diagnostics at base/proposal after line normalization; this is
+neither a pass nor the full configured type check. Adoption requires final-head
+validation, independent review and merge readiness. I3's minimum one minor
+release window remains in force; no D3/expiry decision is made. R0's wider census,
+R1/minimal, D2/D5/D6, hard-lease/context/model and split-install acceptance remain
+open. The bounded refactor reuses its existing parser/handler; larger runtime
+and package changes retain their accepted owners.
+
 ### 2026-11-06 — Discovery integration and the next executable boundary
 
 - **Integrated:** [#8012](https://github.com/loopx-project/loopx/pull/8012)
@@ -1288,6 +1466,7 @@ open; independent exact-head review and required validation govern adoption.
 | E4 | Selected CLI loading seam | `9cae3b28939f72fa4aadab5cfe49e19bcbdab372` | Linked entrypoint/CLI in Section 4 | Source-audited | No new timing claim |
 | E5 | DSH composition example | Pinned upstream commit | [`minimal.patch.yml`](https://github.com/deepseek-ai/deepseek-harness/blob/f3803c96974ad4a94195fb97e5c637e9c2a3afe3/packages/bundle/web-app/presets/minimal.patch.yml), [`standard.patch.yml`](https://github.com/deepseek-ai/deepseek-harness/blob/f3803c96974ad4a94195fb97e5c637e9c2a3afe3/packages/bundle/web-app/presets/standard.patch.yml), [`sdk-minimal`](https://github.com/deepseek-ai/deepseek-harness/blob/f3803c96974ad4a94195fb97e5c637e9c2a3afe3/packages/bundle/sdk-minimal/README.md) | Source-audited | Shared preset composition and a self-contained SDK bundle; not a LoopX host qualification or permission recommendation |
 | E6 | Pi core/context example | Pinned upstream commit | [`agent` core](https://github.com/badlogic/pi-mono/blob/f14813e96510a7cf7562a120e809c6a134af073d/packages/agent/README.md) | Source-audited | Agent/tool/event core with `transformContext`, `convertToLlm`, `prepareRequest` and `finishTurn` seams; no LoopX authority or performance claim |
+| E9 | Selected version loading and matched cost | `5a5863502` / `8a79d8602`; macOS arm64 / CPython 3.13.5 | Version checkpoint above; existing console/version and performance-diagnosis owners | Corrected two groups × 30 pairs; 120 observations; public-facade/parity/cache readback pass; material query improvement | Initial 120 observations and facade failure retained; public-safe aggregates; full Turn/minimal, split install, host upgrade and complete costs unqualified; E7/E8 remain with #8185 |
 | E7 | Bounded paired cost campaign | `a9485073f` / `86d9c542d`; named environment above | Paired cost checkpoint above; existing entrypoint/SQLite fixture and performance-diagnosis owners | 499 observations; source groups complete, wheel incomplete; cache attribution unqualified | Aggregate public-safe evidence only; no speedup, full V10, split-install or model-cost qualification |
 | E8 | Matched-bytecode representative comparison | `546c08c0d` / `0df5ad792`; named environment above | Matched-bytecode checkpoint above; same CLI/SQLite and performance-diagnosis owners | Six groups × 30 pairs; 360 observations; parity/rejection and cache readback pass; no demonstrated material benefit | Aggregate public-safe evidence only; later integration, full V10, minimal, split install and model costs unqualified |
 
diff --git a/docs/architecture/rfcs/monorepo-distribution-split-v0.zh-CN.md b/docs/architecture/rfcs/monorepo-distribution-split-v0.zh-CN.md
index 9c9ea152a0..9ac069fb79 100644
--- a/docs/architecture/rfcs/monorepo-distribution-split-v0.zh-CN.md
+++ b/docs/architecture/rfcs/monorepo-distribution-split-v0.zh-CN.md
@@ -599,6 +599,139 @@ R0 可以先于目录移动交付，但不代表内核合格。R3/R4 可选，
   不关闭完整 R0/V10、M1、拆包安装、R1 managed minimal 或 D1–D7。不改变 preset、
   前端操作、权限或持久化状态；受保护执行仍由既有 owner 所有。
 
+### 2026-11-07 — 调用方进程传输按需加载提案
+
+- **基线与边界：**`7f521ff4505fa916a98a7401032922189eef414a` 的纯
+  Turn-decision import 会加载 `extensions.process_runtime`。Doctor Git、
+  contract 扫描、调用方 validation 和 Host bridge transport 改为使用时解析既有
+  reexport。保留原函数对象、签名、direct/from/star import、名称发现、调用方补丁点、
+  预加载 owner 的绑定和 reload 行为。复用现有 lazy-export 模式；导出名集合是本地
+  兼容元数据，不是共享状态词汇。Python 保留平台传输，TypeScript 保留决策、deadline、
+  authority 与 receipt；不新增 provider、capability、default 或进程算法。
+- **可执行证据：**四个冷加载调用方 oracle 在不可变基线上失败。提案通过聚焦兼容
+  检查和既有架构 oracle，保留 Turn-preview 的未选模块隔离门。真实隔离的 Git、
+  validation 和 bridge 测试覆盖 timeout、cancellation、leader 退出后的后代、stdin
+  策略、framing 和未确认 cleanup。重新构建的单体 wheel 在源码目录外重复兼容与真实
+  进程检查；完整公开 discovery/star 名称集合及 transport 签名与基线一致。这是
+  source/wheel 提案证据，不代表现有 host 升级或实际采用。
+- **实测范围：**纯 Turn-decision import 的 LoopX 模块数从 338 降至 337。
+  纯 import 和 help 没有进程启动或连接，支持的 help、unknown-command 输出与退出码
+  保持一致。共享合成 SQLite fixture 覆盖接受与拒绝的已注册 Turn plan：两个版本都
+  启动两个 Node 进程和十三个 Git probe，连接观察分别为 62/61 次。完整返回 envelope
+  仅 fresh observation 的 source-decision digest 不同。已注册 plan 仍会选择进程
+  transport，完整 preview 依赖闭包尚未通过冷加载资格。减少一个 import 不能证明
+  latency、RSS、完整成本、managed-Turn 或长程收益。
+- **剩余与回滚：**I3 至少保留一个 minor release。D2、D5、D6、I3、D3，以及完整
+  R0/V10/M1/R1/context/model/install 验收仍开放。Canary 六个 direct check 通过，
+  18 个 selected check 中 17 个通过；`first-connect-contract-smoke.py` 在基线与
+  提案都报 `KeyError: should_run`，其 inline-field 假设需要独立修复。该失败与既有
+  全库 lint/browser 失败仍开放。完成的作者提案可披露 hold 后进入正常 review；受保护 runtime
+  合入仍需 maintainer 授权。回退本调用方加载改动即可恢复 eager binding，无需状态
+  迁移或无关语言重写。
+
+### 2026-11-06 — History 读取路径的所选加载
+
+- **基线与边界：** `22b0f6c25`。普通 `history` 读取与帮助通过共享 CLI grammar
+  和 guard 复用既有 registrar/handler。维护动作、parser 拒绝及已预加载完整 CLI
+  的进程保留原路径，包括 handler/renderer patch 点。历史算法、证据窗口、公开
+  import 与 TS owner 均不变。这是单体发行物中可回滚的 R0 读取片；公开迁移的
+  I3 仍至少保留一个 minor 版本。
+- **真实路径证据：** 基线／候选源码与实际安装 wheel 的四个环境，各有 27 个
+  console 用例保留 stdout/stderr/退出码、UTC 排序、Agent 过滤、limit、空／未知
+  输入与当前／过期证据读取。另有四个安装／源码 facade 探针保留被 patch 的
+  handler 与 renderer。预加载 handler 的 oracle 在修复前失败；最终 history／
+  parser 选择通过 26 个测试。既有历史、artifact 与证据 oracle 保留。必需原生
+  服务使用可丢弃的数据／进程命名空间，并通过认证的退出回读确认清理。
+- **匹配测量：** Apple M4 Pro、48 GiB、macOS 27 arm64、Python 3.13.5、
+  Node 26.0.0；Python 依赖及源码配对中的 Node 依赖版本一致。四个负载各有 30
+  组交错基线／候选配对，bytecode 预编译，Python 每次启动新进程，原生服务暖复用。
+  最终采样 229 秒，三轮合计 698 秒，低于冻结的 20 分钟采样上限；安装、验证及
+  tracing 单独记录。此前环境／兼容性修正前的观察保留原有效性范围。
+
+| 负载 | elapsed 中位数 / p95 ms，基线 → 候选 | CPU 中位数 ms | CLI 峰值 RSS 中位数 MiB |
+| --- | --- | --- | --- |
+| 源码帮助 | 1552 / 1862 → 204 / 349 | 670 → 100 | 91.4 → 31.3 |
+| 源码 Agent 读取 | 1603 / 1833 → 417 / 482 | 665 → 150 | 91.9 → 34.4 |
+| Wheel 帮助 | 1621 / 2053 → 220 / 375 | 695 → 100 | 91.8 → 31.0 |
+| Wheel Agent 读取 | 1648 / 1825 → 414 / 462 | 725 → 150 | 92.2 → 34.6 |
+
+- **加载与效果：** 源码／wheel 帮助由 1157 降至 155 个 LoopX 模块，注册 Goal
+  读取由 1158 降至 208，证据读取由 1159 降至 210。Python audit 的 read-open
+  观察中，源码帮助为 1290 → 246，冷原生读取为 1311 → 723；wheel 分别为
+  1291 → 247、1710 → 723。帮助观察到的写入／进程／连接均为零。冷注册读取
+  保留六次 write-open、两个进程启动、一个连接，客户端 IPC 发送／接收为
+  252/355 bytes；证据读取保留一次 write-open、两个连接及 1377/804 IPC bytes。
+  这些必需效果不属于可选激活。已有服务可在 PATH 无 Node 时继续工作，冷缺失
+  保留原拒绝。输出字节一致；耗时包含解释器与进程调用，子孙进程 CPU/RSS/I/O、
+  完整模型与人工注意力成本仍未知。
+- **保留项与后续：** 实测帮助 p95 仍高于提出的 200 ms 目标，不采纳 D6。
+  source-session loader 清单及 Turn preview import 检查在未改动基线上同样失败，
+  保留为资格验证限制。本片不关闭完整 R0/V10、M1、拆包安装、R1／context／宿主
+  资格或开放设计决策。回滚只需撤回加载片，不涉及状态迁移。
+
+### 2026-11-06 — Version 按需加载及匹配成本
+
+独立候选 `8a79d8602e699e51452ca1f43dc9b9527c81aa1b` 对比基线
+`5a58635028fbef1316dc66531daf5fdb655e9b13`，由 `cli_runtime` 选择既有
+version registrar 与 handler，复用规范全局语法、format 优先级、usage hook
+及 controller guard。解析拒绝保留完整 CLI fallback 与诊断；已显式加载完整
+CLI 或绑定 package 导出的调用保留其 registrar/handler patch 点；普通查询不会
+触发 lazy exports。公开 import、身份及类型不变。
+不新增 capability、provider、package、权限、preset 或 TypeScript 决策 owner。
+独立 DSH/helper 及负面成本提案仍在 [#8185](https://github.com/loopx-project/loopx/pull/8185)；
+其 E7/E8 与本次 version 对照分开，也不构成依赖。
+
+初始 `55e3ef45a` 对照的 120 个普通查询观察继续保留：source 中位数
+1.546 → 0.059 秒、wheel 1.554 → 0.072 秒。随后独立用例发现它忽略已替换的
+package-facade handler，返回 0 而非 37；此前通过的 premerge 未覆盖该分支。
+原输入、数据和失败保留，不将其视为 facade 兼容资格。提案补回 package
+registrar 与 handler 的采纳后，另行冻结下列精确 head 对照。
+
+- **真实调用：** 两个不可变版本的源码及新安装单体 wheel 均经实际 `loopx`
+  console 执行。每种发行形态的 27 个用例，stdout、stderr、退出状态完全一致，
+  覆盖全局／局部／重复 format、显式路径、help、未知／缩写参数、缺失／空值及
+  fallback。独立未知命令／参数 oracle 以 exit 2 拒绝且无结果。四个组合在缺少
+  Node 时均可查询 version；outer-controller 读行为及完整 CLI patch 点兼容。
+- **加载清点：** 独立 parent 插桩记录，两种发行形态均为 1,157 → 10 个 LoopX
+  模块，候选是基线的子集。Source read-open 1,286 → 28，wheel 1,289 → 29。
+  每个 version 捕获的 write-open、子进程、观测到的本地 IPC 连接及覆盖 socket
+  字节均为零。Stdout 保持 81 字节，stderr 为空。
+- **冻结对照：** 四个环境均核验来源，使用 CPython 3.13.5 及相同 57 个依赖
+  版本。标准库、依赖及全部 1,421 个 LoopX 源文件，在独占 cache prefix 具有
+  有效时间戳字节码；测量／profile 后的源码及 header 清点与预检一致，无缺失／
+  无效缓存。每次采样是新 Python 进程，禁止字节码写入；磁盘缓存不受控，不比较
+  broker／warm broker。顺序为源码先于 wheel，偶数对 AB、奇数对 BA。两组各
+  完成 30 对，共 120 个有效观察，采样 62.246 秒。计入首轮后合计采样
+  166.191 秒，低于不变的 1,200 秒上限；全部观察保留。
+
+| 发行形态 | 基线秒数，中位数 / p95 | 候选秒数，中位数 / p95 | CPU 秒数，中位数（基线 → 候选） | RSS MiB，中位数（基线 → 候选） | 配对候选减基线的中位数，秒 |
+| --- | --- | --- | --- | --- | --- |
+| Source | 0.980 / 1.056 | 0.055 / 0.075 | 0.520 → 0.037 | 90.17 → 16.81 | -0.9242 |
+| 单体 wheel | 0.948 / 1.147 | 0.056 / 0.077 | 0.511 → 0.038 | 89.89 → 16.60 | -0.8993 |
+
+p95 使用 nearest rank；配对差中位数与两 arm 中位数之差不同。本次 macOS
+arm64 条件下，source 与 wheel 中位延迟均约下降 94%，CPU 与 target RSS
+也下降。一分钟宿主负载为 8.25–9.06。本片证明冻结条件下的明显版本查询收益，
+不采纳可移植 D6 预算，不声明真实 managed Turn 或长程节省。用量覆盖 target
+及等待子进程，清点中未启动子进程；native 细节及完整编写／模型／维护成本未知。
+
+从本次唤醒时间戳到最终冻结约 2,404 秒，包含有重叠的入口恢复、首轮实验、修正、
+依赖／构建／安装、测试、缓存及一致性验证；重叠阶段不可求和。缓存准备单独记录。
+修正后的 console/facade 一致性为 82.759 秒、插桩 2.539 秒、四个 parent
+profile 4.155 秒；首轮 136.239 / 3.830 / 7.089 秒成本继续保留。
+不同轮的耗时水平不作为代码对照。既有
+`performance-diagnosis` recipe 在基线采样栈中显示 export loading 及完整 parser
+构建；栈权重与重复延迟分开。已验证单体打包，不代表拆包安装或已安装宿主升级。
+
+七项 selected-loading 用例在基线失败、候选通过。Package registrar/handler
+用例在基线通过、初始候选失败、修正后通过；规范诊断及完整 CLI patch 点在基线／
+候选均通过。完整入口 161 项及聚焦 lint 通过。Owner-scoped mypy 使用
+`--follow-imports=skip`，基线与候选在行号归一后均有 33 项相同错误，不是通过或
+完整配置的类型检查。采纳仍需最终 head 验证、独立评审及 merge readiness。
+I3 至少一个 minor release 的窗口继续有效，不作 D3／到期决策。R0 更广清点、
+R1/minimal、D2/D5/D6、hard-lease／context／model 及拆包安装验收仍开放。
+有界重构复用既有 parser/handler；更大 runtime/package 改动保留在其已接受 owner。
+
 ### 2026-11-06 — 发现路径集成与下一条可执行边界
 
 - **已集成：** [#8012](https://github.com/loopx-project/loopx/pull/8012)
@@ -969,6 +1102,7 @@ hard-lease／context／model 和拆包安装验收仍开放；采纳仍受独立
 | E4 | 所选 CLI 加载接缝 | `9cae3b28939f72fa4aadab5cfe49e19bcbdab372` | 第 4 节链接的入口/CLI | 源码审计 | 无新性能测量 |
 | E5 | DSH 装配范例 | 固定上游 commit | [`minimal.patch.yml`](https://github.com/deepseek-ai/deepseek-harness/blob/f3803c96974ad4a94195fb97e5c637e9c2a3afe3/packages/bundle/web-app/presets/minimal.patch.yml)、[`standard.patch.yml`](https://github.com/deepseek-ai/deepseek-harness/blob/f3803c96974ad4a94195fb97e5c637e9c2a3afe3/packages/bundle/web-app/presets/standard.patch.yml)、[`sdk-minimal`](https://github.com/deepseek-ai/deepseek-harness/blob/f3803c96974ad4a94195fb97e5c637e9c2a3afe3/packages/bundle/sdk-minimal/README.md) | 源码审计 | 共享预设装配与自包含 SDK bundle；不代表 LoopX 宿主资格或权限建议 |
 | E6 | Pi core/上下文范例 | 固定上游 commit | [`agent` core](https://github.com/badlogic/pi-mono/blob/f14813e96510a7cf7562a120e809c6a134af073d/packages/agent/README.md) | 源码审计 | Agent/tool/event core，以及 `transformContext`、`convertToLlm`、`prepareRequest`、`finishTurn` 接缝；无 LoopX authority 或性能声明 |
+| E9 | Version 按需加载及匹配成本 | `5a5863502` / `8a79d8602`；macOS arm64 / CPython 3.13.5 | 上述 version checkpoint；既有 console/version 及 performance-diagnosis owner | 修正后两组各 30 对，共 120 个观察；公开 facade／一致性／缓存读回通过；版本查询明显改善 | 首轮 120 个观察及 facade 失败保留；仅公开安全汇总；完整 Turn/minimal、拆包安装、宿主升级及完整成本未取得资格；E7/E8 保留在 #8185 |
 | E7 | 有界成对成本实验 | `a9485073f` / `86d9c542d`；上述具名环境 | 上述成对成本 checkpoint；既有入口／SQLite 夹具及 performance-diagnosis owner | 499 个观察；源码组完整，wheel 不完整；缓存归因未取得资格 | 仅公开安全汇总；不证明提速、完整 V10、拆包安装或模型成本 |
 | E8 | 字节码匹配的代表性对照 | `546c08c0d` / `0df5ad792`；上述具名环境 | 上述匹配字节码 checkpoint；相同 CLI/SQLite 及 performance-diagnosis owner | 六组各 30 对，共 360 个观察；语义／拒绝及缓存读回通过；未证明明显收益 | 仅公开安全汇总；后续集成、完整 V10、minimal、拆包安装及模型成本未取得资格 |
 
diff --git a/docs/reference/benchmark-campaign-report.md b/docs/reference/benchmark-campaign-report.md
index 7f7029b5e6..1eaebbf95b 100644
--- a/docs/reference/benchmark-campaign-report.md
+++ b/docs/reference/benchmark-campaign-report.md
@@ -203,3 +203,21 @@ run enters `needs_makeup`, even with a valid score or a successful process exit.
 Only a matching completed run with an audited normal end and a satisfied Goal
 can use the early-finish allowance. Incomplete and unverified durations exclude a
 case from the duration-qualified comparison. Retain raw results for diagnosis.
+
+An operator can explicitly set `duration_policy.makeup_tolerance_ms` when small
+terminal shortfalls do not warrant another run. It defaults to zero and must be
+a nonnegative safe integer smaller than `target_ms`. For example, a tolerance of
+`900000` waives at most fifteen minutes. After unioning the verified active
+intervals, a terminal run with a positive observed duration and a remaining gap
+at or below that tolerance is marked `within_tolerance`, rather than `covered`.
+The report retains the actual `active_ms`, `remaining_ms` and selected policy.
+Unknown duration still needs verification; short planned/running rows retain
+their status, and no runtime deadline or stopping rule changes.
+
+`within_tolerance` satisfies only the report's declared duration condition. It
+does not change run status, scores, integrity/countability, or matched-comparison
+eligibility. A cancelled result stays out of the descriptive comparison, and an
+uncountable score stays out of `qualified_common_n` even when its duration qualifies.
+The Markdown report labels the waiver and its threshold. Callers should use this
+same projection when selecting makeup work rather than rounding the raw duration
+or inventing a second threshold.
diff --git a/docs/reference/goal-acceptance-observations.md b/docs/reference/goal-acceptance-observations.md
index 1ad7b24455..1c24e573b2 100644
--- a/docs/reference/goal-acceptance-observations.md
+++ b/docs/reference/goal-acceptance-observations.md
@@ -302,13 +302,15 @@ Count the complete task: with an Agent-prepared plan already delivered, the owne
 has one required decision. If the original request still lacks acceptance intent
 or authority, that missing decision is an additional round; preparing a proposal
 alone does not establish a one-round cold-start or live-model experience.
-No-plan/default-off behavior remains unchanged, and no Lark action is introduced.
+The default outcome feedback loop continues while executable verification awaits
+an owner-authorized check.
 
 中文：普通路径由 Agent 根据目标与既有上下文准备方案，负责人在交付处核对要求、覆盖范围和
 执行影响，一次“采用并检查”；已有配置直接“检查交付”。JSON 导入仅保留为高级迁移入口。
 `prepare --execute` 只保存可审阅方案，不修改 Goal 规则、不执行检查。丢失回执先对账，
 不能自动重跑；历史通过不能认证变化后的版本。交互次数从原始意图算起，前置缺失的意图或
-授权不能从计数中省略。此入口沿用可信本机所有者边界，不证明远程身份、独立复核或实际采用。
+授权不能从计数中省略。成果反馈默认运行，可执行检查等待所有者授权。此入口沿用可信本机
+所有者边界，不证明远程身份、独立复核或实际采用。
 显式启用的 Goal LoopX 会话在原生工具声明 `prepare_check` 时，可直接准备相同方案；
 Goal、Agent 与运行目录由宿主固定，暂停、过期 Turn 或撤销配置后不能继续准备。
 旧原生线程的工具声明不会自动升级，也不会为新增工具替换未完成线程；未声明时保留 CLI
@@ -356,11 +358,28 @@ and binding are separate: selected work with no confirmed binding remains held.
 Bindings outside the selected set are rejected. Agents cannot change coverage;
 owner configuration still uses preview, provider CAS and exact operation replay.
 
+`goal` checks the Goal as a whole without gating local Todo execution or
+completion. It requires empty `bindings`; it does not mean every new task needs
+an acceptance association. Use it for an independently checked cross-task
+commitment. With a retained outcome, `{"outcome_id":"...","scope":{"kind":"goal"},"criteria":[...]}`
+uses the original requirement descriptions and needs no placeholder Todo.
+The outcome ID binds the receipt to that outcome. A standalone Goal check
+reports on the Goal as a whole. An unmet configured check cannot be satisfied
+by an Agent's self-review or local Todo completion. The outcome remains available to ordinary replanning when its
+linked work ends; permission, Stop, real blockers and the host's finite budget
+still govern execution. A scope declaration itself never runs a checker.
+
+`goal` 只验收整个 Goal，不给局部 Todo 加执行或完成门禁，`bindings` 必须为空。
+它适用于跨任务的独立验收承诺，可直接引用既有成果要求，无需占位 Todo。
+`outcome_id` 将检查回执绑定到对应成果。独立的 Goal 检查报告整个 Goal 的验证结果。
+局部任务完成或 Agent 自评不能替代已配置检查；未满足的成果在工作结束后仍进入
+原有重规划流程。权限、Stop、真实阻塞及宿主有限预算继续生效。
+
 Legacy persisted documents without `scope` retain their Goal-wide behavior and
 original digest. Reading or upgrading does not narrow them. A fresh configuration
 without scope is rejected with an actionable error; original committed retries
-still recover their receipts. An older runtime that does not understand selected
-coverage rejects it rather than silently ignoring it; update readers before an
+still recover their receipts. An older runtime that does not understand the selected
+coverage kind rejects it rather than silently ignoring it; update readers before an
 owner-approved scope change.
 
 Unselected work retains its ordinary validation, claims, leases, permissions and
diff --git a/docs/reference/handoff-mode.md b/docs/reference/handoff-mode.md
index 7154973ae2..02670a00ff 100644
--- a/docs/reference/handoff-mode.md
+++ b/docs/reference/handoff-mode.md
@@ -84,6 +84,16 @@ For an eligible task edit without explicit proof, recovery now offers ordinary
 through inspect/acquire/release. Expired or replaced references remain rejected;
 recovery advice itself never grants execution or changes state.
 
+If the refused edit supplied `--update-expected-provider-revision`, reclaiming
+execution does not validate that old revision, even when the claim reports no
+Todo change. Recovery then gives a targeted `todo list --todo-id ...` step after
+claiming. Reconcile that Todo with the intended edit before filling the retry's
+claim reference and `authority_read.provider_revision` from the read. No full
+Goal reread is needed by this recovery contract. The CLI does not replace the
+CAS automatically; a later concurrent edit still rejects the retry. Keep the
+original operation id and reconciled intent. Calls without an explicit CAS
+retain the direct claim-and-retry path, and recovery never overrides a Stop.
+
 An expired hard-lease execution can be reclaimed with ordinary `todo claim`
 by an eligible registered Agent. When the expired holder still matches the Todo
 claim, the claim owner and a fresh execution generation change in one canonical
@@ -363,6 +373,13 @@ claim+lease 均不可执行，必须先审核迁移；合并式 claim+lease 仍
 提示不包含 execution key、不授予权限，也不修改 mode 或 provider。并发造成 version
 变化时重新读取，不能绕过 CAS；dry-run 和拒绝路径不产生 Todo 或租约写入。
 
+如果被拒绝的编辑提供了 `--update-expected-provider-revision`，重新认领不证明旧版本
+仍可用于编辑，即使认领回包显示 Todo 没有变化。恢复提示会在认领后给出只读取该 Todo
+的 `todo list --todo-id ...`。核对当前内容与原编辑意图后，再把新认领引用和这次读取的
+`authority_read.provider_revision` 填入重试命令；此恢复契约不要求重读整个 Goal。
+CLI 不会自动替换 CAS，读取后若再有并发修改，重试仍会拒绝。保留原 operation id 和
+核对后的意图。不带显式 CAS 的调用保持直接认领并重试，恢复也不会覆盖 Stop。
+
 修改已 deferred Todo 的等待条件若被拒绝，恢复命令先以 `--status open
 --clear-resume-when`、审核后的 reason、新 update operation 和当前 provider CAS
 显式恢复原任务；读回后，再用另一个 operation 和新的 CAS 提交审核后的延期。
diff --git a/examples/cli-control-plane-command-modularization-smoke.py b/examples/cli-control-plane-command-modularization-smoke.py
index 31cd0cb91a..2cdb180627 100644
--- a/examples/cli-control-plane-command-modularization-smoke.py
+++ b/examples/cli-control-plane-command-modularization-smoke.py
@@ -175,11 +175,35 @@ def assert_todo_markdown_error_payload() -> None:
     assert_contains(result.stdout, "- error: todo add requires --role", "todo markdown error")
 
 
+def assert_history_reader_route() -> None:
+    with tempfile.TemporaryDirectory(prefix="loopx-cli-history-smoke-") as tmp:
+        script = f"""
+import contextlib
+import io
+import json
+import sys
+from loopx.entrypoint import main
+output = io.StringIO()
+with contextlib.redirect_stdout(output):
+    result = main(["--registry", {str(Path(tmp) / 'absent.json')!r},
+                   "--format", "json", "history", "--agent-id", "fixture-agent"])
+assert result == 1
+assert json.loads(output.getvalue()) == {{"ok": False,
+    "error": "--agent-id requires --goal-id without a history action"}}
+for module in ("loopx.cli", "loopx.chat_server", "loopx.cli_commands.benchmark_dispatch"):
+    assert module not in sys.modules, module
+"""
+        result = subprocess.run([sys.executable, "-c", script], cwd=REPO_ROOT,
+                                text=True, capture_output=True, check=False)
+    assert result.returncode == 0, result.stdout + result.stderr
+
+
 def main() -> int:
     assert_source_shape()
     assert_help_surfaces()
     assert_todo_error_payload()
     assert_todo_markdown_error_payload()
+    assert_history_reader_route()
     print("cli-control-plane-command-modularization-smoke: ok")
     return 0
 
diff --git a/examples/personal-workspace-browser/research-history.md b/examples/personal-workspace-browser/research-history.md
index 6454cb1211..4152f3172c 100644
--- a/examples/personal-workspace-browser/research-history.md
+++ b/examples/personal-workspace-browser/research-history.md
@@ -92,6 +92,36 @@ the same preview's `--fixture` option; their original Goal IDs stay intact.
 These display captures do not include their complete session trajectories or
 qualify installed App adoption, paid analysis or a scientific comparison.
 
+## Captured session archives
+
+The [fixed capture set](https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/tree/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories) links the three real display
+fixtures above to all four retained solver-session files:
+
+| Display fixture | Captured session archive |
+| --- | --- |
+| Grid context on | [Grid ZIP](https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/resolve/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/grid_turing_robot.zip) |
+| Ad placement | [Ad ZIP](https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/resolve/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/ad_placement_optimization.zip) |
+| Schemathesis | [Schema ZIP](https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/resolve/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/schemathesis_config_modernization.zip) |
+
+Each fixture's `provenance.trajectory_archive` pins the archive and its SHA-256.
+The [manifest](https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/blob/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/manifest.json) binds native session IDs,
+original/published/compressed hashes, record counts and capture variants; the
+[redaction audit](https://huggingface.co/datasets/huangrt01/loopx-edgebench-research-checkpoints-20261015/blob/a97e88f951deb6827d7051a59927860e9e4c4476/20261107-real-benchmark-trajectories/redactions.json) identifies every
+removed opaque encrypted field. All plaintext values and unchanged JSONL lines
+were compared with the source, and all seven published files were read back by
+SHA-256. The 382 Explore records remain byte-identical.
+
+The Schema receiver's alternate runtime capture is a strict prefix missing
+56 tail records; the longer worker-session file is retained. Earlier Schema
+session history keeps its original identity. Complete captured files do not
+establish whole-run coverage or active duration. Invalid/cancelled statuses,
+unknown adoption/cost and unqualified scientific comparisons remain explicit.
+The earlier checkpoint release below remains available at its original version.
+
+中文：三例现有真实展示样例现在关联到同一固定 HF 版本的完整已捕获会话，保留
+原文、身份、取消/无效状态及未知覆盖。Schema 较短副本缺少的 56 条尾部记录已
+由较长原文件保留；清单和逐字段脱敏审计可查，不据此推断科学收益或完整运行覆盖。
+
 ## Earlier research checkpoints
 
 ### Saved analysis reference
diff --git a/examples/workspace-progressive-loading-browser-smoke.mjs b/examples/workspace-progressive-loading-browser-smoke.mjs
index 8c6bcead61..6cc9354a70 100644
--- a/examples/workspace-progressive-loading-browser-smoke.mjs
+++ b/examples/workspace-progressive-loading-browser-smoke.mjs
@@ -84,19 +84,14 @@ try {
   await page.waitForFunction(() => [...document.querySelectorAll('.personal-goal-link')].find((el) => el.textContent.includes('ready project'))?.textContent.match(/加载|Loading/) === null);
   retryFails = false;
   revisionMismatch = true;
+  const beforeRevisionRetry = requested.filter((id) => id === "retry").length;
+  const revisionRead = page.waitForResponse((response) => new URL(response.url()).searchParams.get("goal_id") === "retry"
+    && requested.filter((id) => id === "retry").length >= beforeRevisionRetry + 2);
   await page.getByTestId("goal-status-loading").getByRole("button").click();
-  while (requested.filter((id) => id === "retry").length < 2) {
-    await new Promise((done) => setTimeout(done, 10));
-  }
+  await revisionRead;
   await page.getByTestId("goal-status-loading").getByRole("button").waitFor();
   revisionMismatch = false;
-  const clickedRevisionRetry = await page.evaluate(() => {
-    const button = document.querySelector('[data-testid="goal-status-loading"] button');
-    if (!button) return false;
-    button.click();
-    return true;
-  });
-  assert.equal(clickedRevisionRetry, true, "revision error should keep a manual retry button mounted");
+  await page.getByTestId("goal-status-loading").getByRole("button").click();
   await page.getByTestId("goal-status-loading").waitFor({ state: "hidden" });
   assert.ok(requested.filter((id) => id === "ready").length >= 2, "a transient service error should recover automatically");
   assert.ok(!requested.includes("archived"), "stopped history must not compete with the active first screen");
@@ -159,7 +154,7 @@ try {
     // different Goal still fails. Directory lifecycle identity is unchanged.
     await accessPage.locator(".personal-goal-link").filter({ hasText: "ready project" }).click();
     await accessPage.locator(".personal-goal-tabs").getByRole("button", { name: locale === "en" ? "Tasks" : "任务", exact: true }).click();
-    await accessPage.getByText(readyText, { exact: true }).waitFor();
+    await accessPage.locator('[data-goal-panel="tasks"]').getByText(readyText, { exact: true }).waitFor();
     const history = accessPage.getByTestId("completed-task-lane");
     await history.getByText(historyText, { exact: true }).waitFor();
     await accessPage.getByRole("button", { name: locale === "en" ? "List" : "列表", exact: true }).click();
@@ -170,7 +165,7 @@ try {
     readyText = "Review updated public evidence";
     historyText = "Updated completed public evidence";
     await accessPage.getByRole("button", { name: locale === "en" ? "Refresh status" : "刷新状态", exact: true }).click();
-    await accessPage.getByText(readyText, { exact: true }).waitFor({ timeout: 5_000 });
+    await accessPage.locator('[data-goal-panel="tasks"]').getByText(readyText, { exact: true }).waitFor({ timeout: 5_000 });
     await history.getByText(historyText, { exact: true }).waitFor();
     assert.equal(await history.getByText("Completed public evidence", { exact: true }).count(), 0);
     assert.equal(await expandHistory.getAttribute("aria-expanded"), "true", "refresh preserves list expansion");
@@ -187,8 +182,74 @@ try {
     assert.deepEqual(counts, { ready: 3, access: 4 }, "a failed re-read exposes its error instead of presenting the retained snapshot as current");
     await accessPage.close();
   }
+  // An active-first fallback is incomplete even when it contains no Goals.
+  // Loading or failed stopped history cannot disprove a bookmarked Goal.
+  for (const activeIds of [[], ["ready"]]) {
+    const archivePage = await browser.newPage({ viewport: { width: 1440, height: 960 } });
+    archivePage.on("pageerror", (error) => errors.push(error.message));
+    let releaseArchive;
+    const archiveGate = new Promise((done) => { releaseArchive = done; });
+    let archiveFails = true;
+    let mutations = 0;
+    const scoped = (scope) => {
+      const ids = scope === "stopped" ? ["archived"] : activeIds;
+      const payload = snapshot("archived");
+      payload.run_history.goals = ids.flatMap((id) => snapshot(id).run_history.goals);
+      payload.attention_queue.items = [];
+      payload.todo_index.items = [];
+      payload.goal_projection = { schema_version: "loopx_goal_projection_scope_v0", scope,
+        complete: false, projected_goal_count: ids.length, registry_goal_count: activeIds.length + 1,
+        registry_revision: directory.registry_revision };
+      return payload;
+    };
+    await archivePage.route("**/status.json*", async (route) => {
+      const query = new URL(route.request().url()).searchParams;
+      if (query.has("view")) return route.fulfill({ status: 404 });
+      const scope = query.get("goal_activation");
+      assert.ok(scope === "active" || scope === "stopped");
+      if (scope === "stopped") {
+        await archiveGate;
+        if (archiveFails) return route.fulfill({ status: 503, json: { ok: false } });
+      }
+      return route.fulfill({ json: scoped(scope) });
+    });
+    await archivePage.route("**/api/**", (route) => {
+      if (route.request().method() !== "GET") mutations++;
+      return route.fulfill({ status: 503, json: { ok: false } });
+    });
+    try {
+      await archivePage.goto(`${origin}/chat/?goalId=archived&view=research`);
+      await archivePage.locator(".personal-stopped-goals").waitFor();
+      await archivePage.evaluate(() => new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done))));
+      await archivePage.screenshot({ path: resolve(out, `stopped-loading-${activeIds.length}.png`) });
+      assert.equal(new URL(archivePage.url()).searchParams.get("goalId"), "archived", "pending history must preserve the deep link, including an empty active projection");
+      releaseArchive();
+      await archivePage.locator(".personal-stopped-goal-error button").waitFor();
+      assert.equal(new URL(archivePage.url()).searchParams.get("goalId"), "archived", "failed history is unknown, not an absent Goal");
+      archiveFails = false;
+      await archivePage.locator(".personal-stopped-goal-error button").click();
+      await archivePage.locator(".personal-channel-title h1").filter({ hasText: "archived project" }).waitFor();
+      assert.equal(new URL(archivePage.url()).searchParams.get("view"), "research");
+      assert.match(await archivePage.locator(".personal-channel-title h1").innerText(), /archived project/);
+      assert.match(await archivePage.locator('.personal-goal-tabs button[aria-current="page"]').innerText(), /研究|Research/);
+      await archivePage.screenshot({ path: resolve(out, `stopped-recovered-${activeIds.length}.png`) });
+      await archivePage.setViewportSize({ width: 390, height: 844 });
+      assert.ok(await archivePage.locator(".personal-channel-title h1").isVisible());
+      await archivePage.screenshot({ path: resolve(out, `stopped-recovered-${activeIds.length}-narrow.png`) });
+      await archivePage.setViewportSize({ width: 1440, height: 960 });
+      await archivePage.reload();
+      await archivePage.locator(".personal-channel-title h1").filter({ hasText: "archived project" }).waitFor();
+      assert.equal(new URL(archivePage.url()).searchParams.get("goalId"), "archived", "reload preserves the stopped Goal without activating it");
+      await archivePage.goto(`${origin}/chat/?goalId=absent&view=research`);
+      await archivePage.waitForURL((url) => !url.searchParams.get("goalId"));
+      assert.equal(mutations, 0, "bookmark recovery must remain read-only");
+    } finally {
+      releaseArchive();
+      await archivePage.close();
+    }
+  }
   assert.deepEqual(errors, []);
-  console.log(JSON.stringify({ ok: true, directory_ms: directoryMs, peak_concurrent_requests: peak, checks: ["directory-before-slow-goal", "ready-peer-usable", "queue-progress", "isolated-failure", "registry-revision-fence", "retry", "service-restart-recovery", "lazy-stopped-goals", "access-no-auto-retry", "access-manual-recovery-preserves-peers", "full-refresh-observes-external-todo", "full-refresh-invalidates-completed-history", "failed-reread-replaces-stale-snapshot", "bilingual-access", "mobile", "no-render-errors"] }));
+  console.log(JSON.stringify({ ok: true, directory_ms: directoryMs, peak_concurrent_requests: peak, checks: ["directory-before-slow-goal", "ready-peer-usable", "queue-progress", "isolated-failure", "registry-revision-fence", "retry", "service-restart-recovery", "lazy-stopped-goals", "access-no-auto-retry", "access-manual-recovery-preserves-peers", "full-refresh-observes-external-todo", "full-refresh-invalidates-completed-history", "failed-reread-replaces-stale-snapshot", "stopped-deep-link-loading-error-retry-reload", "absent-goal-after-complete-read", "read-only-bookmark-recovery", "bilingual-access", "mobile", "no-render-errors"] }));
 } finally {
   releaseSlow();
   await cleanupBrowserSmoke({ browser, server, fixturePaths: [] });
diff --git a/loopx/canary/premerge.py b/loopx/canary/premerge.py
index da31b0ebdd..0df7aeda38 100644
--- a/loopx/canary/premerge.py
+++ b/loopx/canary/premerge.py
@@ -900,6 +900,7 @@ def build_premerge_validation_gate(
     catalog_path: Path | None = None,
 ) -> dict[str, Any]:
     target_repo_root = (repo_root or REPO_ROOT).resolve()
+    base_ref = (base_ref or "origin/main").strip() or "origin/main"
     files = _dedupe(list(changed_files or []))
     if files:
         catalog_path = resolve_canary_catalog_path(catalog_path, repo_root=target_repo_root)
@@ -968,6 +969,7 @@ def build_premerge_validation_gate(
             timeout_seconds=timeout_seconds,
             fail_fast=fail_fast,
             progress_callback=catalog_progress if execute else None,
+            cli_output_base_ref=base_ref,
         )
         _emit_section_progress(
             catalog_progress,
@@ -1024,6 +1026,7 @@ def build_premerge_validation_gate(
             timeout_seconds=timeout_seconds,
             fail_fast=fail_fast,
             progress_callback=risk_progress if execute else None,
+            cli_output_base_ref=base_ref,
         )
         _emit_section_progress(
             risk_progress,
@@ -1088,7 +1091,7 @@ def build_premerge_validation_gate(
         "ok": ok,
         "schema_version": PREMERGE_GATE_SCHEMA_VERSION,
         "repo_root": str(target_repo_root),
-        "base_ref": (base_ref or "origin/main").strip() or "origin/main",
+        "base_ref": base_ref,
         "tier": tier if tier in PREMERGE_TIERS else "standard",
         "dry_run": not execute,
         "executes_checks": execute,
diff --git a/loopx/canary/runner.py b/loopx/canary/runner.py
index 53ab3c4a62..5da0fc5f84 100644
--- a/loopx/canary/runner.py
+++ b/loopx/canary/runner.py
@@ -8,6 +8,7 @@
 import tempfile
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from functools import partial
 from pathlib import Path
 from typing import Any, Callable
 
@@ -305,6 +306,7 @@ def _run_check(
     check_index: int | None = None,
     check_count: int | None = None,
     repo_root: Path | None = None,
+    cli_output_base_ref: str | None = None,
 ) -> dict[str, Any]:
     repo_root = (repo_root or REPO_ROOT).resolve()
     normalized = normalize_canary_command(str(check.get("command") or ""), repo_root=repo_root)
@@ -328,6 +330,14 @@ def _run_check(
             home.mkdir()
             env = {**os.environ, "LOOPX_USAGE_PING": "0", "HOME": str(home),
                    "CODEX_HOME": str(home / ".codex")}
+            if (
+                cli_output_base_ref is not None
+                and normalized["script"] == "examples/control_plane/cli-output-budget-regression-smoke.py"
+            ):
+                # Match CI's two-ref handoff so the child uses the selected
+                # base's merge-base with HEAD, even for non-main targets.
+                env["LOOPX_CLI_OUTPUT_BASE_REF"] = cli_output_base_ref
+                env["LOOPX_CLI_OUTPUT_MAIN_REF"] = cli_output_base_ref
             for name in ("LOOPX_RUNTIME_ROOT", "LOOPX_REGISTRY"):
                 env.pop(name, None)
             for name in ("TMPDIR", "TEMP", "TMP"):
@@ -612,6 +622,7 @@ def build_canary_smoke_suite_run(
     parallel_jobs: int = 1,
     progress_callback: ProgressCallback | None = None,
     repo_root: Path | None = None,
+    cli_output_base_ref: str | None = None,
 ) -> dict[str, Any]:
     """Build and optionally execute a continue-on-failure smoke suite.
 
@@ -712,6 +723,14 @@ def build_canary_smoke_suite_run(
         "auto_restored": False,
     }
     if execute:
+        run_check = partial(
+            _run_check,
+            timeout_seconds=max(1.0, timeout_seconds),
+            check_count=len(selected),
+            repo_root=repo_root,
+        )
+        if cli_output_base_ref is not None:
+            run_check = partial(run_check, cli_output_base_ref=cli_output_base_ref)
         git_ok, tracked_before, git_stderr = _tracked_change_paths(repo_root=repo_root)
         clean_start = git_ok and not tracked_before
         if allow_tracked_side_effects:
@@ -749,13 +768,7 @@ def build_canary_smoke_suite_run(
                     check=check,
                     repo_root=repo_root,
                 )
-                result = _run_check(
-                    check,
-                    timeout_seconds=max(1.0, timeout_seconds),
-                    check_index=index,
-                    check_count=len(selected),
-                    repo_root=repo_root,
-                )
+                result = run_check(check, check_index=index)
                 if side_effect_guard["enforced"]:
                     after_ok, tracked_after, after_stderr = _tracked_change_paths(repo_root=repo_root)
                     side_effects = sorted(set(tracked_after) - set(tracked_before))
@@ -799,14 +812,7 @@ def build_canary_smoke_suite_run(
                         check=check,
                         repo_root=repo_root,
                     )
-                    future = executor.submit(
-                        _run_check,
-                        check,
-                        repo_root=repo_root,
-                        timeout_seconds=max(1.0, timeout_seconds),
-                        check_index=index,
-                        check_count=len(selected),
-                    )
+                    future = executor.submit(run_check, check, check_index=index)
                     futures[future] = (index, check)
                 for future in as_completed(futures):
                     index, check = futures[future]
@@ -840,13 +846,7 @@ def build_canary_smoke_suite_run(
                     check=check,
                     repo_root=repo_root,
                 )
-                result = _run_check(
-                    check,
-                    timeout_seconds=max(1.0, timeout_seconds),
-                    check_index=index,
-                    check_count=len(selected),
-                    repo_root=repo_root,
-                )
+                result = run_check(check, check_index=index)
                 result["serial_execution_required"] = True
                 result["serial_execution_reason"] = _serial_smoke_reason(check, repo_root=repo_root)
                 indexed_results[index] = result
diff --git a/loopx/capabilities/explore/README.md b/loopx/capabilities/explore/README.md
index 3f8102d8a2..735cb9b76c 100644
--- a/loopx/capabilities/explore/README.md
+++ b/loopx/capabilities/explore/README.md
@@ -119,6 +119,23 @@ identify the current retained candidate, establish causality, satisfy acceptance
 or authorize execution. Actual adoption and outcome benefit require subsequent
 work and evidence; automatic branch rankings remain unchanged.
 
+When an enabled work Yardstick has two different measured candidates on its
+declared goal profile, from findings on the same node and Goal/Agent/Todo
+binding, Explore context names the observed better-scoring candidate as an
+available comparison base and links the scoped evidence. A
+tied goal outcome calls for checking headroom. The detail read shows a proxy
+ordering only when its exact profile compares the same two candidates, with
+separate result references and metric directions for each profile. Weigh
+continuation, a distinct mechanism or a compatible combination by expected
+end-to-end gain and full implementation and validation cost. Use a bounded
+check that can change the choice while honoring the accepted constraints and
+budget. The compact cue keeps the recorded next-action reason and adds a
+separate comparison cue. The detail read retains the complete work decision.
+The comparison uses findings from the current work, target, and acceptance
+reference. A different target or acceptance reference needs its own eligible
+pair, even when the measured metric, evaluator and inputs stay the same.
+The comparison is advisory and carries no retention or execution obligation.
+
 Manually captured measured findings also appear in the existing result pages
 and, when linked to eligible work, its exact-source comparison cards. They need
 no `writeback-result` origin tag. Read the page before optionally binding a
diff --git a/loopx/capabilities/semantic_preference/__init__.py b/loopx/capabilities/semantic_preference/__init__.py
index 2a6134d134..50694762ee 100644
--- a/loopx/capabilities/semantic_preference/__init__.py
+++ b/loopx/capabilities/semantic_preference/__init__.py
@@ -1,12 +1,35 @@
 """Optional provider-neutral semantic preference recall."""
+from __future__ import annotations
 
-from .contract import application_receipt, maintenance_receipt, provider_doctor, recall
-from .reward_memory import run_semantic_preference_reward_memory
+from importlib import import_module
+from typing import TYPE_CHECKING, Any
 
-__all__ = [
-    "application_receipt",
-    "maintenance_receipt",
-    "provider_doctor",
-    "recall",
-    "run_semantic_preference_reward_memory",
-]
+if TYPE_CHECKING:
+    from .contract import application_receipt as application_receipt
+    from .contract import maintenance_receipt as maintenance_receipt
+    from .contract import provider_doctor as provider_doctor
+    from .contract import recall as recall
+    from .reward_memory import run_semantic_preference_reward_memory as run_semantic_preference_reward_memory
+
+# The Turn start hook reads local preferences without selecting a recall provider.
+_EXPORTS = {
+    "application_receipt": "contract",
+    "maintenance_receipt": "contract",
+    "provider_doctor": "contract",
+    "recall": "contract",
+    "run_semantic_preference_reward_memory": "reward_memory",
+}
+__all__ = list(_EXPORTS)
+
+
+def __getattr__(name: str) -> Any:
+    module = _EXPORTS.get(name)
+    if module is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    value = getattr(import_module(f".{module}", __name__), name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))
diff --git a/loopx/cli_commands/project_lifecycle_refresh_state.py b/loopx/cli_commands/project_lifecycle_refresh_state.py
index e34037aa89..fc9989189f 100644
--- a/loopx/cli_commands/project_lifecycle_refresh_state.py
+++ b/loopx/cli_commands/project_lifecycle_refresh_state.py
@@ -844,14 +844,10 @@ def handle_refresh_state_command(
             if (material_refresh_ready and isinstance(candidate, Mapping)
                     and candidate.get("validation_bound") is True):
                 # A late reflection may recover after spend already committed.
-                # Read the same settlement; never repeat its accounting effect.
+                # Reuse the settlement read after recording the refresh event.
                 attach_reward_memory_ingest_after_spend(
                     payload, execute=True, registry_path=registry_path,
-                    runtime_root=runtime_root, goal_id=args.goal_id,
-                    agent_id=args.agent_id, todo_id=args.todo_id,
-                    turn_instance_id=args.turn_instance_id,
-                    replan_obligation_id=getattr(args, "replan_obligation_id", None),
-                    goal_ref=goal_ref,
+                    runtime_root=runtime_root, readback=settlement_readback,
                 )
         if material_refresh_ready and post_writeback_hooks:
             settlement_identity = (
diff --git a/loopx/cli_commands/quota.py b/loopx/cli_commands/quota.py
index 0cb147ab61..92339b96f0 100644
--- a/loopx/cli_commands/quota.py
+++ b/loopx/cli_commands/quota.py
@@ -506,9 +506,10 @@ def _record_non_guard_quota_event(
     )
     if args.quota_command == "spend-slot" and spend_turn_instance_id:
         assert context is not None  # A settlement requires a prepared authority context.
-        _export("attach_spend_settlement_result")(
+        readback = _export("attach_spend_settlement_result")(
             payload,
             runtime_root=context.runtime_root,
+            registry_path=registry_path,
             goal_id=args.goal_id,
             agent_id=args.agent_id,
             todo_id=rollout_todo_id,
@@ -521,12 +522,7 @@ def _record_non_guard_quota_event(
             execute=bool(args.execute),
             runtime_root=context.runtime_root,
             registry_path=registry_path,
-            goal_id=args.goal_id,
-            agent_id=args.agent_id,
-            todo_id=rollout_todo_id,
-            turn_instance_id=spend_turn_instance_id,
-            replan_obligation_id=rollout_replan_obligation_id,
-            goal_ref=goal_ref,
+            readback=readback,
         )
 
 
diff --git a/loopx/cli_commands/quota_reward_memory.py b/loopx/cli_commands/quota_reward_memory.py
index b4d2147c62..17580d090b 100644
--- a/loopx/cli_commands/quota_reward_memory.py
+++ b/loopx/cli_commands/quota_reward_memory.py
@@ -4,7 +4,10 @@
 
 from collections.abc import Mapping
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ..control_plane.quota.settlement import QuotaSettlementReadback
 
 
 def stage_reward_memory_outcome_candidate(
@@ -65,30 +68,12 @@ def attach_reward_memory_ingest_after_spend(
     execute: bool,
     runtime_root: Path,
     registry_path: Path,
-    goal_id: str,
-    agent_id: str,
-    todo_id: str | None,
-    turn_instance_id: str,
-    replan_obligation_id: str | None,
-    goal_ref: Mapping[str, Any] | None = None,
+    readback: QuotaSettlementReadback,
 ) -> None:
     if not execute or payload.get("ok") is not True:
         return
     from ..capabilities.reward_memory.turn_hooks import run_staged_memory_settlement
-    from ..control_plane.quota.settlement import read_heartbeat_settlement
 
-    readback = read_heartbeat_settlement(
-        runtime_root,
-        goal_id=goal_id,
-        agent_id=agent_id,
-        todo_id=todo_id,
-        turn_instance_id=turn_instance_id,
-        replan_obligation_id=replan_obligation_id,
-        registry_path=registry_path,
-        goal_ref=goal_ref,
-    )
-    if readback is None:
-        return
     identity = readback.identity.value
     writeback_event = readback.writeback_event
     details_value = (
diff --git a/loopx/cli_commands/todo_event.py b/loopx/cli_commands/todo_event.py
index dc8b12c476..893bba5a2a 100644
--- a/loopx/cli_commands/todo_event.py
+++ b/loopx/cli_commands/todo_event.py
@@ -62,6 +62,21 @@ def _route_native_recovery(
         arguments = descriptor.get("cli_args")
         if descriptor.get("reference_source") == "claim_operation_id_from_claim":
             arguments = _original_todo_arguments(args)
+            required = descriptor.get("requires_flags")
+            if isinstance(required, list) and "--update-expected-provider-revision" in required:
+                # Core requires a post-claim targeted read. Project its pending
+                # references, not the old values or the claim's new revision.
+                for flag, placeholder in (
+                    ("--claim-operation-id", "<claim_operation_id_from_claim>"),
+                    ("--update-expected-provider-revision", "<provider_revision_from_reconciled_todo_read>"),
+                ):
+                    for index, argument in enumerate(arguments):
+                        if argument == flag and index + 1 < len(arguments):
+                            arguments[index + 1] = placeholder
+                            break
+                        if argument.startswith(flag + "="):
+                            arguments[index] = flag + "=" + placeholder
+                            break
         else:
             arguments = list(arguments) if isinstance(arguments, list) else command[1:]
         # The update adapter may already bind selectors. Inspect only the global
diff --git a/loopx/cli_runtime.py b/loopx/cli_runtime.py
index fee6385e67..620ae27875 100644
--- a/loopx/cli_runtime.py
+++ b/loopx/cli_runtime.py
@@ -74,7 +74,7 @@
 # Existing CLI vocabulary; this group selects loading, not registry authority.
 _REGISTRY_INSPECTION_COMMANDS = frozenset({"registry", "registry-boundary"})
 _SELECTED_COMMANDS = _STATUS_COMMANDS | GLOBAL_READ_COMMANDS | PROJECT_LIFECYCLE_COMMANDS | _REGISTRY_INSPECTION_COMMANDS | {
-	"todo", "quota", "task-lease", "change-window", "delegation", "turn", "doctor", "commands",
+	"todo", "quota", "task-lease", "change-window", "delegation", "turn", "doctor", "commands", "version",
 	"authority-archive", "coordination-shadow", "extension", "slash-commands",
 	"manager-inbox",
 	"agent-context", "agent-directory", "agent-capabilities",
@@ -85,6 +85,7 @@
 	"goal-acceptance",
 	"host-mode-plan",
 	"capability",
+	"history",
 }
 # Existing CLI vocabulary; this set chooses loading, not operation authority.
 _CAPABILITY_DISCOVERY_COMMANDS = frozenset({"list", "show"})
@@ -475,6 +476,10 @@ def _build_selected_parser(command: str) -> LoopXArgumentParser:
 		from .help_surface import register_command_reference
 
 		register_command_reference(subparsers)
+	elif command == "version":
+		from .cli_commands.version import register_version_command
+
+		register_version_command(subparsers, add_subcommand_format)
 	elif command == "performance-diagnosis":
 		from .capabilities.performance_diagnosis.cli import register_performance_diagnosis_commands
 
@@ -495,6 +500,10 @@ def _build_selected_parser(command: str) -> LoopXArgumentParser:
 		from .cli_commands.capability import register_capability_commands
 
 		register_capability_commands(subparsers, add_subcommand_format)
+	elif command == "history":
+		from .cli_commands.history import register_history_command
+
+		register_history_command(subparsers)
 	else:  # pragma: no cover - caller guards the private interface
 		raise ValueError(f"unsupported selected command: {command}")
 	return parser
@@ -801,6 +810,12 @@ def _dispatch_selected(args: argparse.Namespace, raw_argv: list[str]) -> int:
 			inspect_registry_boundary=inspect_registry_boundary,
 			render_registry_boundary_markdown=render_registry_boundary_markdown,
 		)
+	elif args.command == "version":
+		from .cli_commands.version import handle_version_command
+
+		result = handle_version_command(
+			args, output_format=output_format, print_payload=print_payload,
+		)
 	elif args.command == "capability":
 		from .cli_commands.capability import handle_capability_command
 
@@ -817,6 +832,14 @@ def _dispatch_selected(args: argparse.Namespace, raw_argv: list[str]) -> int:
 			registry_was_supplied=user_supplied_registry(raw_argv),
 			output_format=output_format, print_payload=print_payload,
 		)
+	elif args.command == "history":
+		from .cli_commands.history import handle_history_command
+
+		# Direct full-CLI callers retain their original facade-bound handler.
+		result = handle_history_command(
+			args, registry_path=registry_path, runtime_root_arg=args.runtime_root,
+			print_payload=print_payload,
+		)
 	else:
 		result = dispatch_common_command(
 			args,
@@ -865,11 +888,27 @@ def main(argv: list[str] | None = None) -> int:
 
 
 def _run_command(command: str | None, raw_argv: list[str]) -> int:
+	if command == "version":
+		version_exports = sys.modules.get("loopx.cli_commands")
+		# Inspect bound exports without triggering the lazy facade. Explicit
+		# package/full-CLI imports retain their registrar and handler patch points.
+		if "loopx.cli" in sys.modules or (
+			version_exports is not None
+			and ("handle_version_command" in vars(version_exports)
+				or "register_version_command" in vars(version_exports))
+		):
+			return _run_full_cli(raw_argv)
+	if command == "history" and "loopx.cli" in sys.modules:
+		# An explicitly loaded facade keeps its existing handler/renderer bindings.
+		return _run_full_cli(raw_argv)
 	if command in _SELECTED_COMMANDS:
 		try:
 			args = _build_selected_parser(command).parse_args(raw_argv)
 		except _SelectedParseRejected:
 			return _run_full_cli(raw_argv)
+		if command == "history" and args.history_action is not None:
+			# Select ordinary reads; maintenance keeps its complete original route.
+			return _run_full_cli(raw_argv)
 		if command == "capability":
 			if args.capability_command not in _CAPABILITY_DISCOVERY_COMMANDS:
 				return _run_full_cli(raw_argv)
diff --git a/loopx/contract.py b/loopx/contract.py
index b310687f6e..070af451f9 100644
--- a/loopx/contract.py
+++ b/loopx/contract.py
@@ -4,6 +4,7 @@
 import os
 import re
 import subprocess
+import sys as _sys
 from collections.abc import Iterator, Mapping
 from dataclasses import dataclass
 from pathlib import Path
@@ -36,7 +37,6 @@
 from .control_plane.todos.active_state_editing import COMPLETED_WORK_ARCHIVE_HEADING
 from .control_plane.todos.active_state_todo_parser import active_state_incomplete_warning
 from .control_plane.todos.authoring_scope import todo_contract_diagnostics
-from .extensions.process_runtime import terminate_process_tree
 from .history import (
     RunHistoryAudit,
     build_run_history_audit,
@@ -67,6 +67,36 @@
 )
 
 
+# Keep the historical exports and caller patch points, but select the OS
+# transport only when used. Decisions and deadlines remain with the caller.
+_PROCESS_RUNTIME_EXPORTS = ("terminate_process_tree",)
+
+
+def __getattr__(name: str) -> Any:
+    if name not in _PROCESS_RUNTIME_EXPORTS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    from .extensions import process_runtime
+
+    for export in _PROCESS_RUNTIME_EXPORTS:
+        globals().setdefault(export, getattr(process_runtime, export))
+    return globals()[name]
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_PROCESS_RUNTIME_EXPORTS))
+
+
+def _export(name: str) -> Any:
+    return getattr(_sys.modules[__name__], name)
+
+
+# An already selected owner retains the former import-time binding, including
+# owner replacements installed before this module was imported.
+if "loopx.extensions.process_runtime" in _sys.modules:
+    for _name in _PROCESS_RUNTIME_EXPORTS:
+        globals()[_name] = getattr(_sys.modules["loopx.extensions.process_runtime"], _name)
+
+
 @dataclass(frozen=True)
 class LeakRule:
     pattern: re.Pattern[str]
@@ -350,7 +380,7 @@ def _retire_owned_probe(process: subprocess.Popen[str]) -> None:
     """
 
     try:
-        terminate_process_tree(process, grace_seconds=0.2)
+        _export("terminate_process_tree")(process, grace_seconds=0.2)
     except (OSError, RuntimeError):
         pass
     finally:
@@ -1694,3 +1724,9 @@ def render_contract_markdown(payload: dict[str, Any]) -> str:
             lines.extend(["", f"## {title}"])
             lines.extend(f"- {item}" for item in items)
     return "\n".join(lines)
+
+
+# Star imports retain every former public name, including the lazy reexports.
+__all__ = sorted(
+    {name for name in globals() if not name.startswith("_")} | set(_PROCESS_RUNTIME_EXPORTS)
+)
diff --git a/loopx/control_plane/capabilities/explore_turn_context.ts b/loopx/control_plane/capabilities/explore_turn_context.ts
index b6a4fa911e..61acb0739f 100644
--- a/loopx/control_plane/capabilities/explore_turn_context.ts
+++ b/loopx/control_plane/capabilities/explore_turn_context.ts
@@ -358,11 +358,15 @@ export function projectExploreTurnContext(params: JsonObject): JsonObject {
             target: {summary: "", scope: "", acceptance_ref: ""},
             authoritative: {metric: "", unit: "", higher_is_better: true, comparison_scope: "", input_revision: "", evaluation_ref: ""},
             proxy: null, counterevidence_refs: [], next_action: {method_id: "", reason: "", cost_bound: ""}, prior_finding_id: null}},
-        ...(workCues.length ? {work_yardsticks: workCues.slice(0, 3).map(cue => resultNode !== null ? cue : {
-          source_finding_id: cue.source_finding_id, node_id: cue.node_id,
-          todo_id: (cue.binding as JsonObject).todo_id, target: (cue.target as JsonObject).summary,
-          cue: (cue.next_action as JsonObject).reason, counterevidence_refs: cue.counterevidence_refs,
-          details_command: resultRead("--result-node", String(cue.node_id)),
+        ...(workCues.length ? {work_yardsticks: workCues.slice(0, 3).map(cue => {
+          if (resultNode !== null) return cue;
+          const comparison = cue.search_comparison as JsonObject | undefined;
+          return {source_finding_id: cue.source_finding_id, node_id: cue.node_id,
+            todo_id: (cue.binding as JsonObject).todo_id, target: (cue.target as JsonObject).summary,
+            cue: (cue.next_action as JsonObject).reason, counterevidence_refs: cue.counterevidence_refs,
+            ...(comparison ? {comparison_cue: comparison.guidance,
+              comparison_candidate_ref: (comparison.goal as JsonObject).preferred_candidate_ref} : {}),
+            details_command: resultRead("--result-node", String(cue.node_id))};
         }), omitted_work_yardsticks: Math.max(0, workCues.length - 3),
           work_yardstick_command: command("turn-context", "--agent-id", agent, "--todo-id", "<todo-id>")} : {}),
       } : {}),
diff --git a/loopx/control_plane/collaboration/conversation_inventory.py b/loopx/control_plane/collaboration/conversation_inventory.py
index c399670fac..97fd5e28c5 100644
--- a/loopx/control_plane/collaboration/conversation_inventory.py
+++ b/loopx/control_plane/collaboration/conversation_inventory.py
@@ -12,7 +12,7 @@
 import json
 
 from ..content_digest import BARE_SHA256_PATTERN
-from .goal_instance_scope import CollaborationLifecycleRejected, collaboration_goal_scope, decide_collaboration_lifecycle
+from .goal_instance_scope import collaboration_goal_scope, inspect_original_request_batch
 from .inbox import _entry, _now, _read, _receipt, _request_lock, _root, read_inbox_transaction, reply_status
 from .links import read_linked_work
 from .source_chat_observation import is_source_chat_host, original_delivery_facts, original_turn_reader
@@ -175,7 +175,7 @@ def read_conversation_requests(root, registry, store, session, *, goal_ids, core
                                          caller_goal_ref=requests[0][1].get("goal_ref")) as scope,
                 _locked_request_batch(root, scope, requests) as available,
             ):
-                prepared = []
+                candidates = []
                 for path, route, request_id in requests:
                     if path not in available:
                         failed += 1
@@ -196,23 +196,24 @@ def read_conversation_requests(root, registry, store, session, *, goal_ids, core
                             continue
                         grant = source_context_target_authority(root, source_session, turn,
                             {"goal_id": gid, "agent_id": route["agent_id"]})
-                        try:
-                            decide_collaboration_lifecycle(scope, operation="original_request_inspect", record=row, route=route,
-                                initial_delivery=original_delivery_facts(row, route, turn, source_id=grant["source_id"]))
-                        except CollaborationLifecycleRejected as exc:
-                            # Only this typed refusal proves the route and source
-                            # matched before the conflicting receipt was observed.
-                            # Withhold the brief, work and completion state as before.
-                            if exc.decision.get("delivery_proof_reason") == "handoff_receipt_conflict" and len(diagnostics) < 12:
-                                diagnostics.append({"request_id": row["request_id"], "goal_id": gid, "agent_id": row["agent_id"],
-                                    "code": exc.decision["code"], "reason": exc.decision["delivery_proof_reason"]})
-                            raise
-                        # Do not retain full model responses while waiting for
-                        # linked-work IO; only the displayed question is used.
+                        delivery = original_delivery_facts(row, route, turn, source_id=grant["source_id"])
+                        # Keep the displayed question and original handoff proof.
                         source_turn = {"turn_id": turn["turn_id"], "message": turn.get("message", "")}
-                        prepared.append((row, source_session["session_id"], source_turn))
+                        candidates.append((row, source_session["session_id"], source_turn, delivery))
                     except (OSError, ValueError, KeyError, TypeError):
                         failed += 1
+                decisions = inspect_original_request_batch(scope, [item[3] for item in candidates])
+                prepared = []
+                for (row, source_session_id, source_turn, _), decision in zip(candidates, decisions, strict=True):
+                    if decision["kind"] == "reject":
+                        failed += 1
+                        # The typed owner only reports a conflict after matching
+                        # the original route and source.
+                        if decision.get("delivery_proof_reason") == "handoff_receipt_conflict" and len(diagnostics) < 12:
+                            diagnostics.append({"request_id": row["request_id"], "goal_id": gid, "agent_id": row["agent_id"],
+                                "code": decision["code"], "reason": decision["delivery_proof_reason"]})
+                        continue
+                    prepared.append((row, source_session_id, source_turn))
                 observations = _read_receipt_batch(root, [row for row, _, _ in prepared])
                 for (row, source_session_id, source_turn), observed in zip(prepared, observations, strict=True):
                     if observed is None:
diff --git a/loopx/control_plane/collaboration/goal_instance_lifecycle.ts b/loopx/control_plane/collaboration/goal_instance_lifecycle.ts
index b56cdb4858..970b2baa2f 100644
--- a/loopx/control_plane/collaboration/goal_instance_lifecycle.ts
+++ b/loopx/control_plane/collaboration/goal_instance_lifecycle.ts
@@ -1,6 +1,6 @@
 import type { JsonObject } from "../effect_program.ts";
 import { EffectRuntimeRequestError } from "../effect_runtime_errors.ts";
-import { assertNever, jsonObject } from "../runtime_decode.ts";
+import { assertNever, jsonObject, requireJsonObject } from "../runtime_decode.ts";
 import { BARE_SHA256_PATTERN } from "../content_digest.ts";
 import {
   parseExactGoalRef,
@@ -353,3 +353,20 @@ export function decideCollaborationLifecycle(
     "operation" in facts ? decideExactLifecycle(facts) : facts, raw, selectedOperation,
   );
 }
+
+/** Decide one existing inventory batch under the caller's retained lifetime guard. */
+export function inspectOriginalRequestBatch(value: JsonObject): JsonObject {
+  const { profile_id, caller_goal_ref, current_goal_ref, items } = value;
+  if (!Array.isArray(items) || items.length > 12) {
+    throw new EffectRuntimeRequestError("original request inspection accepts at most 12 items");
+  }
+  return {
+    items: items.map((item) => decideCollaborationLifecycle({
+      ...requireJsonObject(item, "original request inspection item"),
+      profile_id,
+      caller_goal_ref,
+      current_goal_ref,
+      operation: "original_request_inspect",
+    })),
+  };
+}
diff --git a/loopx/control_plane/collaboration/goal_instance_scope.py b/loopx/control_plane/collaboration/goal_instance_scope.py
index 7932328520..e36efabb15 100644
--- a/loopx/control_plane/collaboration/goal_instance_scope.py
+++ b/loopx/control_plane/collaboration/goal_instance_scope.py
@@ -8,7 +8,7 @@
 
 from ...agent_registry import registered_agent_ids_for_goal
 from ...file_lock import exclusive_cross_runtime_file_lock
-from ..effect_runtime import effect_runtime_result
+from ..effect_runtime import EffectRuntimeRejected, effect_runtime_result
 from ..goals.activation import goal_is_stopped
 from ..goals.source_session_registry_state import exact_goal_ref, guard_path
 from ..projects.registry_codec import (
@@ -185,6 +185,14 @@ def __init__(self, decision: dict[str, Any]):
         super().__init__(f"collaboration lifecycle rejected: {decision.get('code')}")
 
 
+def _lifecycle_scope_facts(scope: CollaborationGoalScope) -> dict[str, Any]:
+    return {
+        "profile_id": scope.profile_id,
+        "caller_goal_ref": scope.caller_goal_ref,
+        "current_goal_ref": scope.current_goal_ref,
+    }
+
+
 def decide_collaboration_lifecycle(
     scope: CollaborationGoalScope,
     *,
@@ -198,10 +206,8 @@ def decide_collaboration_lifecycle(
     result = effect_runtime_result(
         "collaboration.goal_instance.decide",
         {
-            "profile_id": scope.profile_id,
+            **_lifecycle_scope_facts(scope),
             "operation": operation,
-            "caller_goal_ref": scope.caller_goal_ref,
-            "current_goal_ref": scope.current_goal_ref,
             "record_goal_ref": (
                 record.get("goal_ref") if isinstance(record, dict) else None
             ),
@@ -216,3 +222,38 @@ def decide_collaboration_lifecycle(
     if result.get("kind") == "reject":
         raise CollaborationLifecycleRejected(result)
     return result
+
+
+def inspect_original_request_batch(
+    scope: CollaborationGoalScope, deliveries: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Read independent decisions while the caller holds the existing batch guards."""
+    if not deliveries:
+        return []
+    scope_facts = _lifecycle_scope_facts(scope)
+    items = [{
+        "record_goal_ref": delivery["request"].get("goal_ref"),
+        "route_goal_ref": delivery["route"].get("goal_ref"),
+        "initial_delivery": delivery,
+    } for delivery in deliveries]
+    try:
+        result = effect_runtime_result(
+            "collaboration.goal_instance.inspect_original_requests",
+            {**scope_facts, "items": items},
+        )
+        decisions = result.get("items") if isinstance(result, dict) else None
+    except EffectRuntimeRejected as error:
+        if error.diagnostic_code != "request_too_large":
+            raise
+        # Large historical proofs that fit individually keep the ordinary wire.
+        decisions = [
+            effect_runtime_result("collaboration.goal_instance.decide", {
+                **scope_facts, **item, "operation": "original_request_inspect",
+            }) for item in items
+        ]
+    if not isinstance(decisions, list) or len(decisions) != len(items) or any(
+        not isinstance(decision, dict) or decision.get("kind") not in {"allow", "legacy", "reject"}
+        for decision in decisions
+    ):
+        raise RuntimeError("original request inspection count or decision is invalid")
+    return decisions
diff --git a/loopx/control_plane/collaboration/inbox_read.ts b/loopx/control_plane/collaboration/inbox_read.ts
index cace31ba76..ada656aed9 100644
--- a/loopx/control_plane/collaboration/inbox_read.ts
+++ b/loopx/control_plane/collaboration/inbox_read.ts
@@ -55,11 +55,21 @@ function readRecord(path: string): JsonObject {
   try {
     const stat = fstatSync(fd);
     if (!stat.isFile()) fail("invalid manager context record");
-    if (stat.size > 128_000) fail("manager context record too large");
-    const buffer = Buffer.alloc(128_001);
+    const limit = 128_000;
+    if (stat.size > limit) fail("manager context record too large");
+    // Most receipts are small. Read one byte past the observed size so an
+    // in-place append still gets the same bounded read through EOF.
+    let buffer = Buffer.alloc(stat.size + 1);
     let size = 0, count: number;
-    while (size < buffer.length && (count = readSync(fd, buffer, size, buffer.length - size, null)) > 0) size += count;
-    if (size > 128_000) fail("manager context record too large");
+    while ((count = readSync(fd, buffer, size, buffer.length - size, null)) > 0) {
+      size += count;
+      if (size > limit) fail("manager context record too large");
+      if (size === buffer.length) {
+        const expanded = Buffer.alloc(limit + 1);
+        buffer.copy(expanded);
+        buffer = expanded;
+      }
+    }
     const bytes = buffer.subarray(0, size);
     let parsed: unknown;
     try {
diff --git a/loopx/control_plane/coordination/claim_execution_recovery.ts b/loopx/control_plane/coordination/claim_execution_recovery.ts
index cac6bf365e..53301ca322 100644
--- a/loopx/control_plane/coordination/claim_execution_recovery.ts
+++ b/loopx/control_plane/coordination/claim_execution_recovery.ts
@@ -9,6 +9,7 @@ import {executeCoordinationTodoClaim, type CoordinationTodoClaimInput} from "./t
 type RecoveryInput = Pick<CoordinationTodoClaimInput, "goal_id" | "todo_id" | "actor_agent_id" |
   "registered_agents" | "expected_role" | "operation_id" | "now"> & {
     claim_operation_id: string; expected_provider_revision: string;
+    caller_expected_provider_revision?: string;
   };
 
 export async function claimExecutionRecovery(store: AuthorityStore, input: RecoveryInput,
@@ -35,6 +36,20 @@ export async function claimExecutionRecovery(store: AuthorityStore, input: Recov
   // An optional observation failure must not hide the original proof refusal.
   if (preview === null) return undefined;
   if (preview.dry_run === true && ["planned", "no_change"].includes(String(preview.status))) {
+    if (input.caller_expected_provider_revision !== undefined) {
+      // Claim advances authority even when the Todo body is unchanged. It does
+      // not prove that no other writer changed the Todo before the new claim.
+      // Retain the caller's CAS obligation; never silently rebase its edit.
+      return {action: "claim_task", lease_state: "expired", execution_authority_granted: false,
+        reason: "The original execution expired. Explicitly claim this Todo, then inspect this same Todo and reconcile its current content with the intended edit. A new claim does not validate the old provider revision. Only after reconciliation, retry with the returned claim_operation_id and authority_read.provider_revision from that inspection. Keep the operation intent and id; do not reuse either stale reference or assume unchanged content from the claim receipt. Claim and inspection grant no permission to overwrite intervening edits.",
+        claim: {command: "loopx todo claim", cli_args: ["todo", "claim", "--goal-id", input.goal_id,
+          "--todo-id", input.todo_id, "--agent-id", input.actor_agent_id, "--claimed-by", input.actor_agent_id]},
+        inspect: {command: "loopx todo list", cli_args: ["todo", "list", "--goal-id", input.goal_id,
+          "--todo-id", input.todo_id]},
+        retry: {command: `loopx todo ${command}`,
+          requires_flags: ["--claim-operation-id", "--update-expected-provider-revision"],
+          reference_source: "claim_operation_id_from_claim"}};
+    }
     return {action: "claim_task", lease_state: "expired", execution_authority_granted: false,
       reason: "The original execution expired. Explicitly run a new ordinary Todo claim, then retry the unchanged operation with its returned claim_operation_id. Do not reuse the expired claim id. Claim rechecks current ownership and eligibility; this preview grants no execution authority.",
       claim: {command: "loopx todo claim", cli_args: ["todo", "claim", "--goal-id", input.goal_id,
diff --git a/loopx/control_plane/coordination/todo_update.ts b/loopx/control_plane/coordination/todo_update.ts
index 53ca56cc7f..d7335372a2 100644
--- a/loopx/control_plane/coordination/todo_update.ts
+++ b/loopx/control_plane/coordination/todo_update.ts
@@ -225,6 +225,7 @@ export async function executeCoordinationTodoUpdate(
     try { input = {...input, ...await claimExecutionProof(store, head.head, input, claimReference), claim_operation_id: undefined}; }
     catch (error) {
       const recovery = await claimExecutionRecovery(store, {...input, claim_operation_id: claimReference,
+        caller_expected_provider_revision: input.expected_provider_revision,
         expected_provider_revision: head.provider_revision}, "update", error, authoritySourcesCurrent, observeWorkspace);
       return {...rejection("claim_execution_unavailable", error instanceof Error ? error.message : "Original task claim unavailable"),
         ...(recovery === undefined ? {} : {handoff_mode: head.head.handoff_mode, recovery})};
diff --git a/loopx/control_plane/effect_runtime_handlers.ts b/loopx/control_plane/effect_runtime_handlers.ts
index b3765822f4..af454f6393 100644
--- a/loopx/control_plane/effect_runtime_handlers.ts
+++ b/loopx/control_plane/effect_runtime_handlers.ts
@@ -662,6 +662,7 @@ export function createEffectRuntimeHandlers(
       "collaboration.goal_instance.decide",
       lazyHandler(() => import("./collaboration/goal_instance_lifecycle.ts"), ({decideCollaborationLifecycle}) => (params) => decideCollaborationLifecycle(params)),
     ],
+    ["collaboration.goal_instance.inspect_original_requests", lazyHandler(() => import("./collaboration/goal_instance_lifecycle.ts"), ({inspectOriginalRequestBatch}) => inspectOriginalRequestBatch)],
     ["external_evidence.discover", lazyHandler(() => import("./capabilities/external_evidence.ts"), ({projectExternalEvidenceDiscovery}) => projectExternalEvidenceDiscovery)],
     ["external_evidence.plan", lazyHandler(() => import("./capabilities/external_evidence.ts"), ({planExternalEvidenceRequest}) => planExternalEvidenceRequest)],
     ["external_evidence.receipt", lazyHandler(() => import("./capabilities/external_evidence.ts"), ({recordExternalEvidenceReceiptObservation}) => recordExternalEvidenceReceiptObservation)],
diff --git a/loopx/control_plane/goals/acceptance_authority.ts b/loopx/control_plane/goals/acceptance_authority.ts
index d723b26394..7fb57339b4 100644
--- a/loopx/control_plane/goals/acceptance_authority.ts
+++ b/loopx/control_plane/goals/acceptance_authority.ts
@@ -303,7 +303,7 @@ export async function configureGoalAcceptance(store: AuthorityStore, value: Json
     // Historical receipts above remain replayable; new configurations must make
     // the blast radius explicit, including updates to legacy contracts.
     if (document.scope === undefined) return source(store, failure("goal_acceptance_scope_required",
-      "Select selected_work with todo_ids or explicitly choose all_advancement before configuring acceptance."));
+      "Select goal for Goal-only checks, selected_work with todo_ids, or all_advancement before configuring acceptance."));
     const todos = acceptanceTodos(head.head, String(request.goal_id));
     if (document.scope?.kind === "selected_work") for (const todoId of document.scope.todo_ids) {
       const todo = todos.get(todoId);
diff --git a/loopx/control_plane/goals/acceptance_contract.ts b/loopx/control_plane/goals/acceptance_contract.ts
index 85557506e9..05c6f2ab3c 100644
--- a/loopx/control_plane/goals/acceptance_contract.ts
+++ b/loopx/control_plane/goals/acceptance_contract.ts
@@ -27,6 +27,7 @@ export interface AcceptanceCriterion extends JsonObject {
 }
 export type AcceptanceScope =
   | {kind: "all_advancement"}
+  | {kind: "goal"}
   | {kind: "selected_work"; todo_ids: string[]};
 export interface AcceptanceDocument extends JsonObject {
   outcome_id?: string;
@@ -169,6 +170,10 @@ function validationFiles(value: unknown): {path: string; sha256: string}[] {
  * and its canonical bytes; an explicit subset may still contain unbound work. */
 function normalizeAcceptanceScope(value: unknown): AcceptanceScope {
   const scope = canonicalAuthorityObject(value, "acceptance scope");
+  if (scope.kind === "goal") {
+    acceptanceKeys(scope, ["kind"]);
+    return {kind: "goal"};
+  }
   if (scope.kind === "all_advancement") {
     acceptanceKeys(scope, ["kind"]);
     return {kind: "all_advancement"};
@@ -179,7 +184,7 @@ function normalizeAcceptanceScope(value: unknown): AcceptanceScope {
     list(scope.todo_ids, "acceptance scope Todos", 4096, 1).map(id), "acceptance scope Todos")};
 }
 function acceptanceIncludes(scope: AcceptanceScope | undefined, todoId: string): boolean {
-  return scope?.kind !== "selected_work" || scope.todo_ids.includes(todoId);
+  return scope?.kind !== "goal" && (scope?.kind !== "selected_work" || scope.todo_ids.includes(todoId));
 }
 
 export function normalizeGoalAcceptanceDocument(value: unknown): AcceptanceDocument {
@@ -225,11 +230,13 @@ export function normalizeGoalAcceptanceDocument(value: unknown): AcceptanceDocum
 export function resolveGoalAcceptanceDocument(head: JsonObject, goalId: string, value: unknown): AcceptanceDocument {
   const raw = canonicalAuthorityObject(value, "acceptance document");
   if (raw.outcome_id === undefined) return normalizeGoalAcceptanceDocument(raw);
-  acceptanceKeys(raw, ["outcome_id", "criteria"]);
+  acceptanceKeys(raw, ["outcome_id", "criteria"], ["scope"]);
+  const goalOnly = raw.scope !== undefined && normalizeAcceptanceScope(raw.scope).kind === "goal";
+  acceptanceRequire(raw.scope === undefined || goalOnly, "compact outcome checks support only explicit Goal scope");
   const basis = goalOutcomeCheckBasis(head, goalId, raw.outcome_id);
   const requirements = basis.requirements as {id: string; description: string}[];
   const todoIds = basis.todo_ids as string[];
-  acceptanceRequire(todoIds.length > 0, "link outcome work before preparing executable checks");
+  acceptanceRequire(goalOnly || todoIds.length > 0, "link outcome work before preparing executable checks");
   const criteria = list(raw.criteria, "acceptance criteria", 64, 1).map(value => {
     const check = canonicalAuthorityObject(value, "requirement check");
     acceptanceKeys(check, ["id", "validation_argv"], ["validation_timeout_seconds", "validation_files", "oracle"]);
@@ -238,8 +245,8 @@ export function resolveGoalAcceptanceDocument(head: JsonObject, goalId: string,
     return {...check, id: requirement.id, description: requirement.description};
   });
   return normalizeGoalAcceptanceDocument({outcome_id: basis.outcome_id, objective: basis.objective, non_goals: [],
-    scope: {kind: "selected_work", todo_ids: todoIds}, criteria,
-    bindings: todoIds.map(todo_id => ({todo_id, criterion_ids: criteria.map(c => c.id)}))});
+    scope: goalOnly ? {kind: "goal"} : {kind: "selected_work", todo_ids: todoIds}, criteria,
+    bindings: goalOnly ? [] : todoIds.map(todo_id => ({todo_id, criterion_ids: criteria.map(c => c.id)}))});
 }
 
 function acceptanceDigestMatches(todo: JsonObject, boundDigest: string): boolean {
@@ -343,6 +350,7 @@ function acceptanceWorkDigest(todos: ReadonlyMap<string, JsonObject>, scope: Acc
   head: JsonObject): string {
   const objective = currentGoalObjective(head)?.revisions.at(-1)?.digest;
   const digest = (work: unknown) => canonicalAuthoritySha256(objective === undefined ? work : {work, objective});
+  if (scope?.kind === "goal") return digest([]);
   if (scope?.kind === "selected_work") return digest(scope.todo_ids.map(todo_id => ({
     todo_id, digest: todos.has(todo_id) ? goalAcceptanceTodoDigest(todos.get(todo_id)!) : null,
   })));
@@ -563,7 +571,8 @@ export class GoalAcceptanceRead {
     }
     this.validateTodoReadModel();
     const todos = this.read.todoIndex.todos;
-    const taskIds = new Set(state.document.scope?.kind === "selected_work" ? state.document.scope.todo_ids
+    const taskIds = new Set(state.document.scope?.kind === "goal" ? []
+      : state.document.scope?.kind === "selected_work" ? state.document.scope.todo_ids
       : [...todos.values()].filter(advancement).map(todo => String(todo.todo_id)));
     for (const binding of state.bindings) taskIds.add(binding.todo_id);
     const tasks = [...taskIds].sort(authorityUnicodeCompare).map(key => this.task(key, todos.get(key), state));
diff --git a/loopx/control_plane/goals/outcome_requirements.ts b/loopx/control_plane/goals/outcome_requirements.ts
index d9d295921b..32f73cfedb 100644
--- a/loopx/control_plane/goals/outcome_requirements.ts
+++ b/loopx/control_plane/goals/outcome_requirements.ts
@@ -363,11 +363,15 @@ export function observeOutcomeRequirements(declaration: JsonObject, acceptance:
   oracleObservations: JsonObject[] = []): JsonObject {
   const current = declaration.current_lifetime === true;
   const allCriteria = (acceptance.criteria ?? []) as JsonObject[], tasks = (acceptance.tasks ?? []) as JsonObject[];
+  const goalScope = (acceptance.scope as JsonObject | undefined)?.kind === "goal";
+  const criteriaForOutcome = (outcomeId: string): JsonObject[] =>
+    acceptance.outcome_id === outcomeId || (acceptance.outcome_id === undefined && !goalScope)
+      ? allCriteria : [];
   const outcomes = (declaration.outcomes as (Outcome & {basis_digest?: string; review_basis_current: boolean; work: {todo_id: string; status: string}[]})[]).map(o => ({...o,
     requirements: o.requirements.map(r => {
-      const criteria = acceptance.outcome_id === undefined || acceptance.outcome_id === o.id ? allCriteria : [];
+      const criteria = criteriaForOutcome(o.id);
       const criterion = criteria.find(c => c.id === r.id && c.description === r.description);
-      const covered = o.todo_ids.length > 0 && o.todo_ids.every(key => tasks.some(t => t.todo_id === key && t.state === "ready" && (t.criterion_ids as string[]).includes(r.id)));
+      const covered = goalScope || o.todo_ids.length > 0 && o.todo_ids.every(key => tasks.some(t => t.todo_id === key && t.state === "ready" && (t.criterion_ids as string[]).includes(r.id)));
       const oracle = criterion?.oracle as JsonObject | undefined;
       const receipt = acceptance.verification as JsonObject | null | undefined;
       const ownResult = (receipt?.results as JsonObject[] | undefined)?.find(result => result.criterion_id === r.id);
@@ -385,8 +389,8 @@ export function observeOutcomeRequirements(declaration: JsonObject, acceptance:
   const uncovered = current ? outcomes.flatMap(outcome => {
     const unmet = outcome.requirements.filter(r => !r.planning_satisfied).map(r => r.id);
     if (!unmet.length || outcome.work.some(w => !["done", "missing"].includes(String(w.status)))) return [];
-    const criteria = acceptance.outcome_id === undefined || acceptance.outcome_id === outcome.id ? allCriteria
-      .filter(criterion => outcome.requirements.some(requirement => requirement.id === criterion.id)) : [];
+    const criteria = criteriaForOutcome(outcome.id)
+      .filter(criterion => outcome.requirements.some(requirement => requirement.id === criterion.id));
     const receipt = acceptance.verification as JsonObject | null | undefined;
     const basis = {outcome_id: outcome.id, basis_digest: outcome.basis_digest ?? null, work: outcome.work,
       requirements: outcome.requirements.map(({id, status, planning_satisfied, agent_review}) => ({id, status, planning_satisfied,
diff --git a/loopx/control_plane/heartbeat/task_body.py b/loopx/control_plane/heartbeat/task_body.py
index f50db9f9ea..7ef45d1309 100644
--- a/loopx/control_plane/heartbeat/task_body.py
+++ b/loopx/control_plane/heartbeat/task_body.py
@@ -64,6 +64,11 @@ def bind_exact_turn_settlement_task_body(
             placeholder,
             render_turn_bootstrap(value=turn_instance_id),
         )
+    if bound != task_body:
+        # The producer already supplied the timestamp. Its concrete assignment
+        # and separate guard still carry the original identity on retries;
+        # only reusable wake templates need the substitution instruction.
+        bound = bound.replace(f"{HEARTBEAT_TURN_BOOTSTRAP_RULE}\n", "", 1)
     plan_path = ("writeback.settlement_plan.ordered_steps" if captured_envelope
                  else "interaction_contract.cli_channel.settlement_plan.ordered_steps")
     return (
diff --git a/loopx/control_plane/quota/settlement.py b/loopx/control_plane/quota/settlement.py
index 8fb3983721..4ea55d529d 100644
--- a/loopx/control_plane/quota/settlement.py
+++ b/loopx/control_plane/quota/settlement.py
@@ -144,6 +144,14 @@ def render_refresh_recovery_markdown(payload: dict[str, Any]) -> str | None:
     return "\n".join(lines)
 
 
+@dataclass(frozen=True, slots=True)
+class QuotaSpendPrecheck:
+    identity: SettlementResult[SettlementIdentity]
+    settlement: SettlementResult[dict[str, Any]]
+    progress: dict[str, Any] | None
+    spend_run_present: bool
+
+
 @dataclass(frozen=True, slots=True)
 class QuotaSettlementReadback:
     identity: SettlementResult[SettlementIdentity]
@@ -323,27 +331,15 @@ def _semantic_replan_guard(value: Any) -> dict[str, Any] | None:
     return result
 
 
-def read_heartbeat_settlement(
+def _read_heartbeat_settlement_payload(
     runtime_root: Path,
     *,
     goal_id: str,
-    agent_id: str | None,
-    todo_id: str | None,
-    turn_instance_id: str | None,
-    replan_obligation_id: str | None = None,
-    infer_turn_instance_id: bool = False,
-    allow_unbound_binding: bool = False,
-    resolve_original_binding: bool = False,
-    refresh_retry: dict[str, Any] | None = None,
-    registry_path: Path | None = None,
-    goal_ref: Mapping[str, Any] | None = None,
+    fields: Mapping[str, Any],
+    registry_path: Path | None,
+    goal_ref: Mapping[str, Any] | None,
     source_admission: Mapping[str, Any] | None = None,
-    borrow_source_admission: bool = False,
-    heartbeat_reentry_guard: dict[str, Any] | None = None,
-    include_record_bodies: bool = True,
-) -> QuotaSettlementReadback | None:
-    """Read one complete heartbeat settlement through the TS domain owner."""
-
+) -> Mapping[str, Any] | None:
     def read(admission: Mapping[str, Any] | None) -> Any:
         try:
             return effect_runtime_result(
@@ -352,44 +348,13 @@ def read(admission: Mapping[str, Any] | None) -> Any:
                     "schema_version": QUOTA_SETTLEMENT_READBACK_REQUEST_SCHEMA,
                     "runtime_root": str(runtime_root.expanduser()),
                     "goal_id": goal_id,
-                    "agent_id": agent_id,
-                    "todo_id": todo_id,
-                    "turn_instance_id": turn_instance_id,
-                    "replan_obligation_id": replan_obligation_id,
-                    "infer_turn_instance_id": infer_turn_instance_id,
-                    "allow_unbound_binding": allow_unbound_binding,
-                    **({"include_record_bodies": include_record_bodies}
-                        if include_record_bodies is not True else {}),
-                    **(
-                        {"resolve_original_binding": True}
-                        if resolve_original_binding
-                        else {}
-                    ),
-                    **(
-                        {"refresh_retry": refresh_retry}
-                        if refresh_retry is not None
-                        else {}
-                    ),
-                    **(
-                        {"goal_ref": dict(goal_ref)}
-                        if goal_ref is not None
-                        else {}
-                    ),
+                    **fields,
+                    **({"goal_ref": dict(goal_ref)} if goal_ref is not None else {}),
                     **(
                         {"source_admission": dict(admission)}
                         if admission is not None
                         else {}
                     ),
-                    **(
-                        {"borrow_source_admission": True}
-                        if borrow_source_admission
-                        else {}
-                    ),
-                    **(
-                        {"heartbeat_reentry_guard": heartbeat_reentry_guard}
-                        if heartbeat_reentry_guard is not None
-                        else {}
-                    ),
                 },
                 large_local_snapshot=True,
             )
@@ -421,6 +386,103 @@ def read(admission: Mapping[str, Any] | None) -> Any:
         return None
     if payload.get("found") is not True:
         raise RuntimeError("TypeScript quota settlement readback result shape mismatch")
+    return payload
+
+
+def read_quota_spend_precheck(
+    runtime_root: Path,
+    *,
+    goal_id: str,
+    agent_id: str | None,
+    todo_id: str | None,
+    turn_instance_id: str | None,
+    replan_obligation_id: str | None = None,
+    infer_turn_instance_id: bool = False,
+    allow_unbound_binding: bool = False,
+    registry_path: Path | None = None,
+    goal_ref: Mapping[str, Any] | None = None,
+) -> QuotaSpendPrecheck | None:
+    """Read the identity and replay controls before building a fresh preview."""
+
+    payload = _read_heartbeat_settlement_payload(
+        runtime_root,
+        goal_id=goal_id,
+        fields={
+            "agent_id": agent_id,
+            "todo_id": todo_id,
+            "turn_instance_id": turn_instance_id,
+            "replan_obligation_id": replan_obligation_id,
+            "infer_turn_instance_id": infer_turn_instance_id,
+            "allow_unbound_binding": allow_unbound_binding,
+            "spend_precheck": True,
+        },
+        registry_path=registry_path,
+        goal_ref=goal_ref,
+    )
+    if payload is None:
+        return None
+    spend_run_present = payload.get("spend_run_present")
+    if not isinstance(spend_run_present, bool):
+        raise RuntimeError("TypeScript quota spend precheck result shape mismatch")
+    return QuotaSpendPrecheck(
+        identity=_readback_result(payload.get("identity"), identity=True),
+        settlement=_readback_result(payload.get("settlement")),
+        progress=_optional_readback_record(payload.get("progress")),
+        spend_run_present=spend_run_present,
+    )
+
+
+def read_heartbeat_settlement(
+    runtime_root: Path,
+    *,
+    goal_id: str,
+    agent_id: str | None,
+    todo_id: str | None,
+    turn_instance_id: str | None,
+    replan_obligation_id: str | None = None,
+    infer_turn_instance_id: bool = False,
+    allow_unbound_binding: bool = False,
+    resolve_original_binding: bool = False,
+    refresh_retry: dict[str, Any] | None = None,
+    registry_path: Path | None = None,
+    goal_ref: Mapping[str, Any] | None = None,
+    source_admission: Mapping[str, Any] | None = None,
+    borrow_source_admission: bool = False,
+    heartbeat_reentry_guard: dict[str, Any] | None = None,
+    include_record_bodies: bool = True,
+) -> QuotaSettlementReadback | None:
+    """Read one complete heartbeat settlement through the TS domain owner."""
+
+    payload = _read_heartbeat_settlement_payload(
+        runtime_root,
+        goal_id=goal_id,
+        fields={
+            "agent_id": agent_id,
+            "todo_id": todo_id,
+            "turn_instance_id": turn_instance_id,
+            "replan_obligation_id": replan_obligation_id,
+            "infer_turn_instance_id": infer_turn_instance_id,
+            "allow_unbound_binding": allow_unbound_binding,
+            **(
+                {"include_record_bodies": include_record_bodies}
+                if include_record_bodies is not True
+                else {}
+            ),
+            **({"resolve_original_binding": True} if resolve_original_binding else {}),
+            **({"refresh_retry": refresh_retry} if refresh_retry is not None else {}),
+            **({"borrow_source_admission": True} if borrow_source_admission else {}),
+            **(
+                {"heartbeat_reentry_guard": heartbeat_reentry_guard}
+                if heartbeat_reentry_guard is not None
+                else {}
+            ),
+        },
+        registry_path=registry_path,
+        goal_ref=goal_ref,
+        source_admission=source_admission,
+    )
+    if payload is None:
+        return None
     workspace_causality = _optional_readback_record(
         payload.get("workspace_causality")
     )
diff --git a/loopx/control_plane/quota/settlement_cli.py b/loopx/control_plane/quota/settlement_cli.py
index bf3e2cd458..c57e084a1f 100644
--- a/loopx/control_plane/quota/settlement_cli.py
+++ b/loopx/control_plane/quota/settlement_cli.py
@@ -22,6 +22,7 @@
     requalify_bound_heartbeat_receipt,
 )
 from .settlement import (
+    QuotaSettlementReadback,
     attach_settlement_progress,
     read_heartbeat_settlement,
     settlement_result_payload,
@@ -460,16 +461,15 @@ def attach_spend_settlement_result(
     payload: dict[str, object],
     *,
     runtime_root: Path,
+    registry_path: Path,
     goal_id: str,
     agent_id: str | None,
     todo_id: str | None,
     turn_instance_id: str,
     replan_obligation_id: str | None = None,
     goal_ref: Mapping[str, object] | None = None,
-) -> None:
-    registry_path = (
-        Path(str(payload["registry"])) if payload.get("registry") else None
-    )
+) -> QuotaSettlementReadback:
+    """Attach receipts and return the same post-event observation to the caller."""
     readback = read_heartbeat_settlement(
         runtime_root,
         goal_id=goal_id,
@@ -500,3 +500,4 @@ def attach_spend_settlement_result(
     elif payload.get("receipt_repair_required"):
         payload["receipt_repair_required"] = False
         payload["receipt_repaired"] = True
+    return readback
diff --git a/loopx/control_plane/quota/settlement_readback.ts b/loopx/control_plane/quota/settlement_readback.ts
index 9dbcc27cc4..d77a381bc3 100644
--- a/loopx/control_plane/quota/settlement_readback.ts
+++ b/loopx/control_plane/quota/settlement_readback.ts
@@ -1434,6 +1434,11 @@ export async function readQuotaSettlement(value: unknown): Promise<JsonObject> {
     return prepareBlockedWait(value);
   }
   const request = decodeRequest(value);
+  const spendPrecheck = jsonObject(value)?.spend_precheck;
+  if (spendPrecheck !== undefined && typeof spendPrecheck !== "boolean") {
+    throw new EffectRuntimeRequestError("spend_precheck must be a boolean");
+  }
+  if (spendPrecheck) request.include_record_bodies = true;
   const withOwner = request.borrow_source_admission
     ? withBorrowedQuotaAccountingOwner
     : withQuotaAccountingOwner;
@@ -1453,7 +1458,19 @@ export async function readQuotaSettlement(value: unknown): Promise<JsonObject> {
           "a stored Monitor poll may already have committed its observation; recover the exact monitor-poll before an unavailable closeout",
         );
       }
-      return result;
+      if (!spendPrecheck || result.found !== true) return result;
+      // Preview still needs a fresh full read. The earlier replay check needs
+      // only its receipts and whether a spend Run already needs receipt repair.
+      const settlement = requireJsonObject(result.settlement, "quota settlement bundle");
+      const outcome = requireJsonObject(settlement.result, "quota settlement result");
+      return {
+        schema_version: result.schema_version,
+        found: true,
+        identity: result.identity,
+        settlement: {...settlement, result: {...outcome, value: null}},
+        progress: result.progress,
+        spend_run_present: jsonObject(result.spend_run) !== null,
+      };
     },
   );
 }
diff --git a/loopx/control_plane/runtime/validation_command.py b/loopx/control_plane/runtime/validation_command.py
index 1e896e9b5b..b104d7bfcc 100644
--- a/loopx/control_plane/runtime/validation_command.py
+++ b/loopx/control_plane/runtime/validation_command.py
@@ -3,13 +3,41 @@
 import os
 import shlex
 import subprocess
+import sys as _sys
 from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
 from contextvars import ContextVar
 from pathlib import Path
 from typing import Any
 
-from ...extensions.process_runtime import terminate_process_tree
+# Keep the historical exports and caller patch points, but select the OS
+# transport only when used. Decisions and deadlines remain with the caller.
+_PROCESS_RUNTIME_EXPORTS = ("terminate_process_tree",)
+
+
+def __getattr__(name: str) -> Any:
+    if name not in _PROCESS_RUNTIME_EXPORTS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    from ...extensions import process_runtime
+
+    for export in _PROCESS_RUNTIME_EXPORTS:
+        globals().setdefault(export, getattr(process_runtime, export))
+    return globals()[name]
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_PROCESS_RUNTIME_EXPORTS))
+
+
+def _export(name: str) -> Any:
+    return getattr(_sys.modules[__name__], name)
+
+
+# An already selected owner retains the former import-time binding, including
+# owner replacements installed before this module was imported.
+if "loopx.extensions.process_runtime" in _sys.modules:
+    for _name in _PROCESS_RUNTIME_EXPORTS:
+        globals()[_name] = getattr(_sys.modules["loopx.extensions.process_runtime"], _name)
 
 # Frozen wire id shared with capabilities/issue_fix. Kept verbatim for wire
 # compatibility with existing caller-repo-branch receipts.
@@ -80,7 +108,7 @@ def run_caller_validation(
             # subprocess.run's immediate-kill cancellation rather than adding
             # time to the declared validation budget. It also handles an exited
             # POSIX leader whose surviving children still hold the output pipes.
-            terminate_process_tree(process, grace_seconds=0)
+            _export("terminate_process_tree")(process, grace_seconds=0)
             raise
     return {
         "schema_version": CALLER_VALIDATION_RECEIPT_SCHEMA_VERSION,
@@ -99,3 +127,9 @@ def require_validation_passed(step: Mapping[str, Any]) -> None:
         raise RuntimeError(
             f"{step.get('command_label')} failed with exit code {step.get('exit_code')}"
         )
+
+
+# Star imports retain every former public name, including the lazy reexports.
+__all__ = sorted(
+    {name for name in globals() if not name.startswith("_")} | set(_PROCESS_RUNTIME_EXPORTS)
+)
diff --git a/loopx/control_plane/turn_driver/host_bridge_transport.py b/loopx/control_plane/turn_driver/host_bridge_transport.py
index 79f012086b..d46f14c95a 100644
--- a/loopx/control_plane/turn_driver/host_bridge_transport.py
+++ b/loopx/control_plane/turn_driver/host_bridge_transport.py
@@ -10,31 +10,37 @@
 import threading
 import time
 from typing import Any
-from typing import TYPE_CHECKING as _TYPE_CHECKING
 
-if _TYPE_CHECKING:
-    from ...extensions.process_runtime import (
-        force_terminate_process as force_terminate_process,
-        write_process_stdin_before_deadline as write_process_stdin_before_deadline,
-    )
-
-# Preview needs the bridge type; process helpers belong to execution or an
-# explicit caller import. Keep their existing identity and patch seams.
-_PROCESS_EXPORTS = ("force_terminate_process", "write_process_stdin_before_deadline")
+# Keep the historical exports and caller patch points, but select the OS
+# transport only when used. Decisions and deadlines remain with the caller.
+_PROCESS_RUNTIME_EXPORTS = (
+    "force_terminate_process", "write_process_stdin_before_deadline",
+)
 
 
 def __getattr__(name: str) -> Any:
-    if name not in _PROCESS_EXPORTS:
+    if name not in _PROCESS_RUNTIME_EXPORTS:
         raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
     from ...extensions import process_runtime
 
-    value = getattr(process_runtime, name)
-    globals()[name] = value
-    return value
+    for export in _PROCESS_RUNTIME_EXPORTS:
+        globals().setdefault(export, getattr(process_runtime, export))
+    return globals()[name]
 
 
 def __dir__() -> list[str]:
-    return sorted(set(globals()) | set(_PROCESS_EXPORTS))
+    return sorted(set(globals()) | set(_PROCESS_RUNTIME_EXPORTS))
+
+
+def _export(name: str) -> Any:
+    return getattr(_sys.modules[__name__], name)
+
+
+# An already selected owner retains the former import-time binding, including
+# owner replacements installed before this module was imported.
+if "loopx.extensions.process_runtime" in _sys.modules:
+    for _name in _PROCESS_RUNTIME_EXPORTS:
+        globals()[_name] = getattr(_sys.modules["loopx.extensions.process_runtime"], _name)
 
 
 class GuardedHostBridge:
@@ -85,8 +91,8 @@ def send(self, frame: str) -> None:
         if self.next(deadline=self.deadline) != {"kind": "ready"}:
             raise RuntimeError("managed Host bridge did not become ready")
         self.requested = True
-        write_stdin = getattr(_sys.modules[__name__], "write_process_stdin_before_deadline")
-        write_stdin(self.process, frame, deadline=self.deadline, cancel_and_reap=self.cancel)
+        _export("write_process_stdin_before_deadline")(self.process, frame, deadline=self.deadline,
+            cancel_and_reap=self.cancel)
 
     def cancel(self) -> None:
         if self.cancelled:
@@ -97,8 +103,7 @@ def cancel(self) -> None:
             if not self.requested:
                 # No request bytes have been sent, so this bridge cannot own a
                 # Host. This also handles suspension before JS handlers exist.
-                getattr(_sys.modules[__name__], "force_terminate_process")(
-                    self.process, process_tree_owned=True)
+                _export("force_terminate_process")(self.process, process_tree_owned=True)
                 self.not_launched = True
             elif self.process.poll() is None:
                 self.process.terminate()
@@ -123,8 +128,7 @@ def cancel(self) -> None:
             # Killing the bridge alone cannot certify an unobserved detached
             # Host. Retain the launching record and fail instead of claiming it.
             if self.process.poll() is None:
-                getattr(_sys.modules[__name__], "force_terminate_process")(
-                    self.process, process_tree_owned=True)
+                _export("force_terminate_process")(self.process, process_tree_owned=True)
             raise RuntimeError("managed Host bridge cleanup unconfirmed") from error
 
     def close_output(self) -> None:
@@ -140,4 +144,7 @@ def close_output(self) -> None:
             self.output.close()
 
 
-__all__ = [name for name in globals() if not name.startswith("_")] + list(_PROCESS_EXPORTS)
+# Star imports retain every former public name, including the lazy reexports.
+__all__ = sorted(
+    {name for name in globals() if not name.startswith("_")} | set(_PROCESS_RUNTIME_EXPORTS)
+)
diff --git a/loopx/control_plane/work_items/yardstick_decision.ts b/loopx/control_plane/work_items/yardstick_decision.ts
index f236ab6281..b27d24953a 100644
--- a/loopx/control_plane/work_items/yardstick_decision.ts
+++ b/loopx/control_plane/work_items/yardstick_decision.ts
@@ -5,6 +5,8 @@ import {parseTodoTimestampMicros} from "../runtime_timestamp.ts";
 import {EffectRuntimeRequestError} from "../effect_runtime_errors.ts";
 import {requireJsonObject, type JsonObject} from "../runtime_decode.ts";
 import {isExploreEvidenceRef} from "../capabilities/explore_evidence_ref.ts";
+import {projectExploreMeasurementFeedback, type ExploreMeasurementFeedback,
+  type ExploreMeasurementPoint} from "../capabilities/explore_measurements.ts";
 
 export const WORK_YARDSTICK_DECISION_SCHEMA = "work_yardstick_decision_v0";
 export type WorkYardstickProfile = {metric: string; unit: string; higher_is_better: boolean;
@@ -77,12 +79,15 @@ export function normalizeWorkYardstickCapture(params: JsonObject): WorkYardstick
   }
   return {decision: normalizeWorkYardstickDecision(capture.decision, params.evidence_refs), binding: normalized as WorkYardstickCapture["binding"]};
 }
+function belongsToWork(row: JsonObject, binding: JsonObject): boolean {
+  const capture = row.work_yardstick as WorkYardstickCapture | undefined;
+  const source = capture?.binding;
+  return !!source && source.goal_id === binding.goal_id && source.agent_id === binding.agent_id
+    && source.todo_id === binding.todo_id;
+}
+
 function currentFinding(findings: JsonObject[], binding: JsonObject): JsonObject | undefined {
-  return findings.filter(row => {
-    const capture = row.work_yardstick as JsonObject | undefined;
-    const source = capture?.binding as JsonObject | undefined;
-    return source && ["goal_id", "agent_id", "todo_id"].every(key => source[key] === binding[key]);
-  }).sort((a, b) => {
+  return findings.filter(row => belongsToWork(row, binding)).sort((a, b) => {
     // Late delivery reuses the original committed time, not append order.
     const left = parseTodoTimestampMicros(String(a.last_updated_at ?? ""));
     const right = parseTodoTimestampMicros(String(b.last_updated_at ?? ""));
@@ -107,15 +112,52 @@ export function validateWorkYardstickContinuation(params: JsonObject): JsonObjec
   }
   return {decision};
 }
+
+function measuredPair(row: ExploreMeasurementFeedback | undefined) {
+  const previous = row?.previous_best, latest = row?.latest;
+  if (!previous || !latest || !Number.isFinite(previous.value)) return null;
+  const {value, candidate_ref, evidence_ref} = latest.measurement;
+  if (value === null || !Number.isFinite(value) || candidate_ref === previous.candidate_ref) return null;
+  const recent: ExploreMeasurementPoint = {finding_id: latest.finding_id, candidate_ref, evidence_ref, value};
+  const preferred = value === previous.value ? null : (value > previous.value) === row.higher_is_better
+    ? candidate_ref : previous.candidate_ref;
+  return {previous_best: previous, latest: recent, preferred_candidate_ref: preferred};
+}
+
+function matchesProfile(row: ExploreMeasurementFeedback, profile: WorkYardstickProfile): boolean {
+  return Object.entries(profile).every(([key, value]) => row[key as keyof WorkYardstickProfile] === value);
+}
+
+function measuredSearchComparison(feedback: ExploreMeasurementFeedback[], decision: WorkYardstickDecision) {
+  const pairFor = (profile: WorkYardstickProfile) => measuredPair(feedback.find(row => matchesProfile(row, profile)));
+  const goal = pairFor(decision.authoritative);
+  if (!goal) return null;
+  const screen = decision.proxy && pairFor(decision.proxy);
+  // Both comparisons have two distinct candidates. Order is append/declaration
+  // order, so join the unordered pair instead of assuming execution chronology.
+  const goalCandidates = [goal.previous_best.candidate_ref, goal.latest.candidate_ref];
+  const proxy = screen && goalCandidates.includes(screen.previous_best.candidate_ref)
+    && goalCandidates.includes(screen.latest.candidate_ref) ? screen : null;
+  const reversed = !!(goal.preferred_candidate_ref && proxy?.preferred_candidate_ref
+    && goal.preferred_candidate_ref !== proxy.preferred_candidate_ref);
+  const opening = goal.preferred_candidate_ref === null
+    ? "Observed goal results tie under this scope. Check remaining headroom before another evaluation. "
+    : (reversed ? "The proxy reverses the observed goal order. " : "") +
+      "Use the better-scoring candidate under this scope as a comparison base when available. ";
+  return {goal, ...(proxy ? {proxy, proxy_order_reversed: reversed} : {}),
+    guidance: opening + "Weigh continuing, a different mechanism or a compatible combination by expected end-to-end gain and full implementation and validation cost. Prefer a bounded check that can change the choice."};
+}
+
 export function projectWorkYardstickCue(params: JsonObject): JsonObject | null {
   if (params.enabled !== true || !params.todo_id) return null;
-  const source = currentFinding((params.findings ?? []) as JsonObject[], params);
+  const findings = (params.findings ?? []) as JsonObject[];
+  const source = currentFinding(findings, params);
   if (!source) return null;
   const capture = normalizeWorkYardstickCapture({capture: source.work_yardstick, evidence_refs: source.evidence_refs,
     goal_id: params.goal_id, agent_id: params.agent_id});
-  const decision = capture.decision as JsonObject;
-  const counter = decision.counterevidence_refs as string[];
-  const previous = ((params.findings ?? []) as JsonObject[]).find(row => row.finding_id === decision.prior_finding_id);
+  const decision = capture.decision;
+  const counter = decision.counterevidence_refs;
+  const previous = findings.find(row => row.finding_id === decision.prior_finding_id);
   const priorCapture = previous?.work_yardstick as JsonObject | undefined;
   const priorBinding = priorCapture?.binding as JsonObject | undefined;
   const priorDecision = priorCapture?.decision as JsonObject | undefined;
@@ -127,11 +169,21 @@ export function projectWorkYardstickCue(params: JsonObject): JsonObject | null {
       candidate_sha256: execution.candidate_sha256, evidence_refs: execution.evidence_refs,
       recorded_planned_method_matches: execution.planned_method_id === (priorDecision!.next_action as JsonObject).method_id}
     : null;
-  const profiles = [decision.authoritative, decision.proxy].filter(Boolean) as JsonObject[];
-  const feedback = ((params.measurement_feedback ?? []) as JsonObject[]).filter(row => row.node_id === source.node_id && profiles.some(p =>
-    Object.entries(p).every(([key, value]) => row[key] === value)));
+  const profiles = decision.proxy ? [decision.authoritative, decision.proxy] : [decision.authoritative];
+  const feedback = ((params.measurement_feedback ?? []) as ExploreMeasurementFeedback[]).filter(row =>
+    row.node_id === source.node_id && profiles.some(p => matchesProfile(row, p)));
+  // An earlier target can share the same evaluator profile and work identity.
+  // Filter source findings before ranking so its best cannot displace a legal pair.
+  const scopedFindings = findings.filter(row => {
+    const target = (row.work_yardstick as WorkYardstickCapture | undefined)?.decision?.target;
+    return row.node_id === source.node_id && belongsToWork(row, params) && target !== undefined
+      && target.summary === decision.target.summary && target.scope === decision.target.scope
+      && target.acceptance_ref === decision.target.acceptance_ref;
+  });
+  const searchComparison = measuredSearchComparison(projectExploreMeasurementFeedback(scopedFindings), decision);
   return {source_finding_id: source.finding_id, node_id: source.node_id, binding: capture.binding, ...decision,
     measurement_feedback: feedback,
+    ...(searchComparison ? {search_comparison: searchComparison} : {}),
     ...(followthrough ? {previous_decision_followthrough: followthrough} : {}),
     guidance: counter.length
       ? "Counterevidence is recorded for this scoped proxy. Reassess its use at the next concrete choice; a local screening heuristic cannot veto an informative authoritative check by itself. Preserve accepted correctness, authorization and budget constraints."
diff --git a/loopx/doctor_git.py b/loopx/doctor_git.py
index 0c71ef8341..d5f201a53f 100644
--- a/loopx/doctor_git.py
+++ b/loopx/doctor_git.py
@@ -10,26 +10,36 @@
 from enum import Enum
 from pathlib import Path
 from typing import Any
-from typing import TYPE_CHECKING as _TYPE_CHECKING
 from urllib.parse import urlsplit
 
-if _TYPE_CHECKING:
-    from .extensions.process_runtime import terminate_process_tree as terminate_process_tree
+# Keep the historical exports and caller patch points, but select the OS
+# transport only when used. Decisions and deadlines remain with the caller.
+_PROCESS_RUNTIME_EXPORTS = ("terminate_process_tree",)
 
 
-# Successful read-only Git probes do not need process cleanup. Keep the former
-# helper export and patch point, resolving its owner only when requested.
 def __getattr__(name: str) -> Any:
-    if name != "terminate_process_tree":
+    if name not in _PROCESS_RUNTIME_EXPORTS:
         raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-    from .extensions.process_runtime import terminate_process_tree
+    from .extensions import process_runtime
 
-    globals()[name] = terminate_process_tree
-    return terminate_process_tree
+    for export in _PROCESS_RUNTIME_EXPORTS:
+        globals().setdefault(export, getattr(process_runtime, export))
+    return globals()[name]
 
 
 def __dir__() -> list[str]:
-    return sorted(set(globals()) | {"terminate_process_tree"})
+    return sorted(set(globals()) | set(_PROCESS_RUNTIME_EXPORTS))
+
+
+def _export(name: str) -> Any:
+    return getattr(_sys.modules[__name__], name)
+
+
+# An already selected owner retains the former import-time binding, including
+# owner replacements installed before this module was imported.
+if "loopx.extensions.process_runtime" in _sys.modules:
+    for _name in _PROCESS_RUNTIME_EXPORTS:
+        globals()[_name] = getattr(_sys.modules["loopx.extensions.process_runtime"], _name)
 
 
 # `doctor` inspects a checkout the operator may not control, so every Git read
@@ -82,7 +92,7 @@ def _retire_owned_probe(process: subprocess.Popen[str]) -> None:
     """
 
     try:
-        getattr(_sys.modules[__name__], "terminate_process_tree")(process, grace_seconds=0.2)
+        _export("terminate_process_tree")(process, grace_seconds=0.2)
     except (OSError, RuntimeError):
         # The answer is already unknown; an unconfirmed cleanup must not turn a
         # read-only diagnostic into a traceback.
@@ -344,4 +354,7 @@ def trusted_release_ref_for_root(
     return None
 
 
-__all__ = [name for name in globals() if not name.startswith("_")] + ["terminate_process_tree"]
+# Star imports retain every former public name, including the lazy reexports.
+__all__ = sorted(
+    {name for name in globals() if not name.startswith("_")} | set(_PROCESS_RUNTIME_EXPORTS)
+)
diff --git a/loopx/hosts/codex_checkpoint.py b/loopx/hosts/codex_checkpoint.py
index 0f2e7b9df8..af34afe824 100644
--- a/loopx/hosts/codex_checkpoint.py
+++ b/loopx/hosts/codex_checkpoint.py
@@ -25,7 +25,7 @@
 from loopx.control_plane.turn_driver.codex_stdio import StdioNativeGoalTransport, native_checkpoint_reader
 
 
-def _complete_history(request, session_id: str, *, interrupted_guard: dict | None = None) -> list[dict[str, Any]]:
+def _retained_history(request, session_id: str) -> list[dict[str, Any]]:
     turns = []
     cursor = None
     seen = set()
@@ -45,17 +45,65 @@ def _complete_history(request, session_id: str, *, interrupted_guard: dict | Non
         seen.add(cursor)
     if not turns or any(t.get("status") not in {"completed", "failed", "interrupted"} or not t.get("id") for t in turns):
         raise ValueError("native checkpoint requires complete retained turns")
+    ids = [t["id"] for t in turns]
+    if len(set(ids)) != len(ids):
+        raise ValueError("native checkpoint history contains duplicate turns")
+    return turns
+
+
+def _complete_history(request, session_id: str, *, interrupted_guard: dict | None = None) -> list[dict[str, Any]]:
+    turns = _retained_history(request, session_id)
     if interrupted_guard is None:
         if turns[-1].get("status") != "completed":
             raise ValueError("native checkpoint requires a completed final cursor")
     else:
         _verify_interrupted_guard(turns, interrupted_guard)
-    ids = [t["id"] for t in turns]
-    if len(set(ids)) != len(ids):
-        raise ValueError("native checkpoint history contains duplicate turns")
     return turns
 
 
+def native_interrupted_turn(env: dict[str, str], session_id: str, *,
+                            process_started_at: float, process_stopped_at: float,
+                            timeout: float = 30) -> dict[str, Any]:
+    """Read a stable interrupted tail; this is not checkpoint admission.
+
+    The caller proves original process termination and current session ownership.
+    No resume, fork, interruption, model call, history edit or command replay occurs.
+    A completed research-checkpoint cursor remains a separate, stricter contract.
+    """
+    if (not session_id or any(type(v) not in (int, float) or not math.isfinite(v)
+            for v in (process_started_at, process_stopped_at, timeout))
+            or process_started_at > process_stopped_at or timeout <= 0):
+        raise ValueError("Native interruption requires its original process window")
+    deadline = time.monotonic() + timeout
+    with native_checkpoint_reader(env, timeout=timeout) as transport:
+        def request(method, params):
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise TimeoutError("Native interruption readback window closed")
+            transport.response_timeout_sec = remaining
+            return transport.request(method, params)
+        _native_thread_readback(request, env, session_id)
+        turns = _retained_history(request, session_id)
+        tail = turns[-1]
+        start, end = tail.get("startedAt"), tail.get("completedAt")
+        if (tail.get("status") != "interrupted" or tail.get("error") is not None
+                or any(type(value) not in (int, float) or not math.isfinite(value)
+                       for value in (start, end))
+                # Native Turn timestamps have second resolution.
+                or not math.floor(process_started_at) <= start <= end <= math.ceil(process_stopped_at)):
+            raise ValueError("Native interruption differs from the original process window")
+        if any(item.get("status") in {"inProgress", "running", "pending"}
+               for item in tail.get("items", [])):
+            raise ValueError("Native interruption still has pending effects")
+        encoded = json.dumps(turns, sort_keys=True, separators=(",", ":")).encode()
+        reread = _retained_history(request, session_id)
+        if json.dumps(reread, sort_keys=True, separators=(",", ":")).encode() != encoded:
+            raise ValueError("Native interruption advanced during readback")
+        return {"session_id": session_id, "turn_id": tail["id"],
+                "visible_history_sha256": hashlib.sha256(encoded).hexdigest(),
+                "turn_count": len(turns)}
+
+
 def _guard_cli_arguments(command: str, guard: dict) -> list[str]:
     """Parse the provider shell wrapper plus the renderer's optional Turn assignment."""
     outer = shlex.split(command)
diff --git a/loopx/quota.py b/loopx/quota.py
index 3e659cd3d9..27e9ccb9e5 100644
--- a/loopx/quota.py
+++ b/loopx/quota.py
@@ -60,6 +60,7 @@
 )
 from .control_plane.quota.settlement import (
     read_heartbeat_settlement,
+    read_quota_spend_precheck,
     settlement_result_payload,
 )
 from .control_plane.quota.ledger_readback import (
@@ -1673,7 +1674,7 @@ def spend_quota_slot(
             or recover_unbound_visible_goal
         )
     ):
-        settlement_readback = read_heartbeat_settlement(
+        settlement_readback = read_quota_spend_precheck(
             Path(str(raw_runtime_root)).expanduser(),
             goal_id=safe_goal_id,
             agent_id=agent_id,
@@ -1712,7 +1713,7 @@ def spend_quota_slot(
     if turn_instance_id and raw_runtime_root:
         runtime_root = Path(str(raw_runtime_root)).expanduser()
         if settlement_readback is None:
-            settlement_readback = read_heartbeat_settlement(
+            settlement_readback = read_quota_spend_precheck(
                 runtime_root,
                 goal_id=safe_goal_id,
                 agent_id=agent_id,
@@ -1771,8 +1772,7 @@ def spend_quota_slot(
                     else {}
                 ),
             }
-        prior_spend_run = settlement_readback.spend_run
-        if prior_spend_run is not None:
+        if settlement_readback.spend_run_present:
             return {
                 "ok": True,
                 "mode": "spend-slot",
diff --git a/scripts/benchmark-campaign-report.ts b/scripts/benchmark-campaign-report.ts
index 1ac64a6e0d..acc0d0aac8 100644
--- a/scripts/benchmark-campaign-report.ts
+++ b/scripts/benchmark-campaign-report.ts
@@ -56,7 +56,7 @@ export type CampaignInput = {
   observed_at: string; title: string; case_ids: string[];
   arms: { arm_id: string; label: string }[];
   selection: Selection[]; incidents: Incident[]; notes: string[];
-  duration_policy?: { target_ms: number; allow_goal_completion: string[] };
+  duration_policy?: { target_ms: number; allow_goal_completion: string[]; makeup_tolerance_ms?: number };
   execution_audit?: ExecutionAudit[];
 };
 
@@ -94,6 +94,9 @@ export function validateInput(raw: unknown): CampaignInput {
   if (d.duration_policy !== undefined) {
     const policy = d.duration_policy;
     requireThat(policy && Number.isSafeInteger(policy.target_ms) && policy.target_ms > 0, 'positive active duration target required');
+    requireThat(policy.makeup_tolerance_ms === undefined ||
+      (Number.isSafeInteger(policy.makeup_tolerance_ms) && policy.makeup_tolerance_ms >= 0 &&
+        policy.makeup_tolerance_ms < policy.target_ms), 'makeup tolerance must be a nonnegative integer below target');
     requireThat(Array.isArray(policy.allow_goal_completion) && distinct(policy.allow_goal_completion) &&
       policy.allow_goal_completion.every(id => armIds.has(id)), 'unknown or duplicate early completion arm');
   }
@@ -192,6 +195,7 @@ function durationCoverage(d: CampaignInput, policy: NonNullable<CampaignInput['d
     else if (acceptedGoal) disposition = 'goal_completed';
     else if (row.status === 'planned' || row.status === 'running') disposition = row.status;
     else if (remaining_ms === null) disposition = 'verify_duration';
+    else if (active_ms !== null && active_ms > 0 && remaining_ms <= (policy.makeup_tolerance_ms ?? 0)) disposition = 'within_tolerance';
     else disposition = 'needs_makeup';
     return { case_id, arm_id, run_id, active_ms, remaining_ms, disposition };
   });
@@ -200,7 +204,7 @@ function durationCoverage(d: CampaignInput, policy: NonNullable<CampaignInput['d
 export function buildReport(raw: unknown) {
   const d = validateInput(raw);
   const coverage = d.duration_policy && durationCoverage(d, d.duration_policy);
-  const covered = new Set(coverage?.filter(row => ['covered', 'goal_completed'].includes(row.disposition)).map(key));
+  const covered = new Set(coverage?.filter(row => ['covered', 'goal_completed', 'within_tolerance'].includes(row.disposition)).map(key));
   const selected = new Map(d.selection.map(r => [key(r), r]));
   const summary = d.arms.map(a => {
     const rows = d.selection.filter(r => r.arm_id === a.arm_id);
@@ -296,6 +300,11 @@ export function buildReport(raw: unknown) {
   return { schema_version: 'benchmark_campaign_report_v1', input_sha256: digest(d),
     observed_at: d.observed_at, title: d.title, summary, comparisons, selection: d.selection,
     ...(coverage ? { duration_coverage: coverage } : {}),
+    ...(d.duration_policy?.makeup_tolerance_ms !== undefined ? { duration_policy: {
+      target_ms: d.duration_policy.target_ms,
+      allow_goal_completion: d.duration_policy.allow_goal_completion,
+      makeup_tolerance_ms: d.duration_policy.makeup_tolerance_ms,
+    } } : {}),
     configuration_profiles, score_time_series, incidents: d.incidents,
     execution_audit: d.execution_audit ?? [], notes: d.notes };
 }
@@ -331,7 +340,10 @@ export function renderMarkdown(r: Report): string {
     table(['实验组','运行数','Source','Scorer','Model','预算(h)','主动提交冷却(s)','后台评测(s)','资源档位','证据覆盖'],r.configuration_profiles.map(p => [labels.get(p.arm_id),p.run_count,known(p.source_revision_id),known(p.scorer_revision_id),known(p.model_id),hours(p.budget_ms),seconds(p.active_submission_cooldown_ms),seconds(p.background_evaluation_interval_ms),known(p.resource_profile),`${p.configuration_supplied ? p.run_count : 0}/${p.run_count}`])) +
     '\n\n均分使用相同题目交集、相同归一化规则，尺度 0–100。未出分不填 0；授权的故障判零单独保留来源。以下为描述性比较；源版本、协议、资源差异和完整性复核仍需独立审查。\n\n' +
     table(['对比范围','共同题数',...r.summary.map(a => a.label),'第二组−第一组','共同题中双方/各方可计数'],r.comparisons.map(c => [c.arms.map(a => labels.get(a)).join(' / '),c.n,...r.summary.map(a => number(c.means[a.arm_id] ?? null)),number(c.delta_second_minus_first),c.qualified_common_n])) +
-    (r.duration_coverage ? '\n\n## 各臂有效运行时间\n\n' + table(['题目','实验臂','已运行（小时）','距目标（小时）','状态'],
+    (r.duration_coverage ? '\n\n## 各臂有效运行时间\n\n' +
+      ((r.duration_policy?.makeup_tolerance_ms ?? 0) > 0
+        ? `已终止运行的补时容差：${r.duration_policy!.makeup_tolerance_ms! / 60000} 分钟。within_tolerance 表示容差内免补；实际时长和缺口保持原值，不提前停止正在运行的任务。\n\n` : '') +
+      table(['题目','实验臂','已运行（小时）','距目标（小时）','状态'],
       r.duration_coverage.map(row => [row.case_id, labels.get(row.arm_id), hours(row.active_ms), hours(row.remaining_ms), row.disposition])) : '') +
     '\n\n' + r.notes.map(n => '- ' + cell(n)).join('\n') + '\n\n## 共同题目与排除记录\n\n' +
     r.comparisons.map(c => `- ${c.arms.map(a => labels.get(a)).join(' / ')}：${c.case_ids.join('、') || '无'}。`).join('\n') +
diff --git a/scripts/external_scheduler_worker.py b/scripts/external_scheduler_worker.py
index 42ced4e060..739449a359 100644
--- a/scripts/external_scheduler_worker.py
+++ b/scripts/external_scheduler_worker.py
@@ -30,6 +30,7 @@
 import signal
 import sys
 import time
+import uuid
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
@@ -921,12 +922,25 @@ def save(fields: dict[str, Any]) -> None:
                         # state write or the Host invocation can be interrupted.
                         _save_host_pending(state_path, True)
                         state["host_attempt"] = {"scope": scope, "status": "started",
+                            "attempt_id": uuid.uuid4().hex,
                             "attempt": prior.get("attempt", 0) + 1,
-                            "session_id": prior.get("session_id"),
+                            "session_id": prior.get("session_id") or state.get("recovered_session_id"),
                             **({"replan_obligation_id": attempt["obligation_id"]}
                                if attempt is not None else {})}
                         save({})
-                        environment = {**os.environ, "LOOPX_HOST_RETRY_SESSION_ID": prior.get("session_id") or ""}
+                        environment = {**os.environ,
+                            "LOOPX_HOST_ATTEMPT_ID": state["host_attempt"]["attempt_id"],
+                            "LOOPX_HOST_RETRY_SESSION_ID": state["host_attempt"]["session_id"] or ""}
+                        # The explicit continuation phase may carry one frozen
+                        # content handoff. It grants no work/ownership authority.
+                        # Keep it for uncertain retries; stop presenting it only
+                        # after the same native Host returns a successful receipt.
+                        for key in ("LOOPX_RECOVERY_HANDOFF", "LOOPX_RECOVERY_HANDOFF_SHA256"):
+                            environment.pop(key, None)
+                        handoff = state.get("recovery_handoff")
+                        if handoff is not None and not state.get("recovery_handoff_delivered"):
+                            environment.update(LOOPX_RECOVERY_HANDOFF=handoff["path"],
+                                               LOOPX_RECOVERY_HANDOFF_SHA256=handoff["sha256"])
                     wake_result = _run_wake(
                         args.wake_cmd,
                         timeout_seconds=getattr(args, "wake_timeout_seconds", None),
@@ -962,6 +976,11 @@ def save(fields: dict[str, Any]) -> None:
                         failure = _host_result(wake_result, state["host_attempt"], clock())
                         if failure is None:
                             state.pop("host_attempt", None)
+                            if handoff is not None and not state.get("recovery_handoff_delivered"):
+                                receipt = json.loads(wake_result.stdout)
+                                if receipt.get("recovery_handoff_sha256") != handoff["sha256"]:
+                                    raise ValueError("Native Host did not confirm the recovery handoff input")
+                                state["recovery_handoff_delivered"] = True
                         else:
                             state["host_attempt"] = failure
                             wake_failed = True
diff --git a/skills/loopx-self-repair/references/repair-patterns.md b/skills/loopx-self-repair/references/repair-patterns.md
index 5de1a84a5c..1a712f6dc5 100644
--- a/skills/loopx-self-repair/references/repair-patterns.md
+++ b/skills/loopx-self-repair/references/repair-patterns.md
@@ -271,6 +271,7 @@ teaches a reusable control-plane lesson.
 | `commit_hygiene_drift` | Broad commit includes temporary smokes, raw logs, local state, or unrelated docs. | `git status`, `git diff --stat`, `git ls-files --others --exclude-standard`, AGENTS.md. | Worktree was staged by chronology rather than reviewer logic. | Use explicit pathspecs, split commits, keep only durable smokes, and update AGENTS/skill if the failure mode recurs. |
 | `migration_terminal_receipt_replay_gap` | A migrated transaction succeeds once, then an idempotent legacy retry is rejected as receipt corruption or times out on a lock that the first response lost. | Versioned operation receipt, persisted state, lock owner/token, exact caller retry identity, pre-migration replay behavior, and focused native plus compatibility tests. | The new owner modeled only held/committed receipts and treated a closed no-op receipt as incomplete, or generated retry identity inside the callee after the caller's retry boundary. | Model terminal no-op receipts separately from held authority proofs, replay them without retired private tokens, and generate one stable operation id outside any transport retry while minting a new id for independent calls. Cover direct native replay and the compatibility adapter's response-loss boundary. |
 | `typed_kernel_import_surface_drift` | Focused tests and premerge canaries pass, but CI mypy starts reporting unrelated errors in a previously unchecked module after a small typed-kernel change. | Exact mypy entry files, the new import edge, base/head module diffs, and whether the imported module owns the new behavior or is only a type source. | A checked kernel dependency imported a broad runtime or Goal-routing owner for one enum, provider decision or filesystem helper, expanding strict mypy traversal beyond the owning contract. | Keep caller policy with its caller and shared filesystem helpers in a dependency-light runtime module. Validate behavior parity and the exact CI mypy command after changing kernel dependencies, using the same source installation and import environment; an extra PYTHONPATH can hide the imported-module failure. |
+| `premerge_comparison_base_not_forwarded` | Premerge on an integration branch reports unexpected CLI output growth even though its receipt names the intended target. | Outer base, the comparison child's resolved Git ref, and the same fixture replay with the intended base. Keep the candidate's own ceiling failures separate. | The selector and direct checks know the target, but the budget child inherits a different base or falls back to main. | Pass the selected base through the shared runner to that child only, using its existing two-ref interface. Verify a non-main target, standalone inheritance, concurrent calls and a child failure through the real subprocess boundary. Preserve the original failed observation and budget checks. |
 | `browser_smoke_presentation_copy_drift` | Browser checks time out after retention wording changes, or mistake a longer source label in a content-sized layout for an empty primary column. | Same immutable base and scenario, production bundle, accessible names, native point identities, exact values, citation and focus return, plus affected pipeline entrypoints. | Smoke locators freeze superseded copy or box-size relationships rather than result identity and information hierarchy. | Keep provenance-accurate UI. Bind existing result keys with role locators, preserve accessible meaning and independent numeric, source, failure and recovery oracles, then run the same workload before and after against its real owner. A replacement layout oracle needs a failing equal-column control, not a weaker threshold. Do not restore overclaims, increase timeouts or delete assertions. |
 | `packaged_surface_completion_illusion` | A development route or API-mocked browser smoke passes while the packaged product still serves an older UI, loses local history after refresh, hides every healthy Agent, or records important contradictions only as non-failing observations. | packaged entry title and first viewport, emitted bundle identity, real loopback capabilities, service-restart history, Last-Event-ID replay, mobile navigation close behavior, and the acceptance report's untested/observation fields. | UI completion was inferred from component tests or a Vite route; the release asset, launcher environment, durable local session path, and hard browser assertions evolved separately. | Make packaged-route parity a blocking acceptance contract. Build and launch the real bundle with a controlled executable path, convert semantic observations into assertions, persist status-only and Agent-backed messages independently, test refresh plus restart recovery, and require every design criterion to be PASS or explicitly gated before claiming the surface complete. |
 | `dashboard_status_source_generation_gap` | Switching between local and SSH sources leaves the old Goal list visible, or the selector and route oscillate between two sources after a slow tunnel ensure or status response. | User selection order, tunnel-ensure start/finish order, status fetch start/finish order, requested and loaded URLs, projection revision, route commits, and the rendered Goal identity. | Request freshness starts only after SSH preparation, a foreground request captures its revision before advancing it, or an older route commit clears a newer pending selection. | Fence the complete selection transaction—from user intent through tunnel ensure, fetch, payload commit, and route commit—with one monotonic selection generation plus a projection revision. Let only the current generation clear pending state; reject background responses whose target is no longer the committed source. Cover delayed A/B fetches and delayed SSH-then-local selection with a focused browser smoke that asserts payload, selector, and route remain aligned. |
diff --git a/tests/canary/test_repository_root.py b/tests/canary/test_repository_root.py
index 22b0dced34..4e312fce3b 100644
--- a/tests/canary/test_repository_root.py
+++ b/tests/canary/test_repository_root.py
@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import json
+import os
 import subprocess
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
@@ -12,6 +14,7 @@
 from loopx.canary.premerge import build_premerge_validation_gate
 from loopx.canary.runner import build_canary_smoke_suite_run, normalize_canary_command
 from loopx.cli import main
+from tests.source_cli import run_source_cli
 
 
 def _git(repo: Path, *args: str) -> None:
@@ -131,6 +134,105 @@ def test_concurrent_checkout_roots_do_not_share_process_state(tmp_path):
         assert str(repo) in result["selected_checks"][0]["stdout_tail"]
 
 
+_CLI_BUDGET_SCRIPT = "examples/control_plane/cli-output-budget-regression-smoke.py"
+_CLI_BUDGET_ENV = ("LOOPX_CLI_OUTPUT_BASE_REF", "LOOPX_CLI_OUTPUT_MAIN_REF")
+_NEIGHBOR_SCRIPT = "examples/semantic-vocabulary-drift-smoke.py"
+_AMBIENT_REFS = ("ambient-base", "ambient-main")
+
+
+def _cli_budget_checkout(path: Path) -> Path:
+    repo = _checkout(path)
+    probe = (
+        "import json, os\n"
+        f"print(json.dumps([os.environ.get(name) for name in {_CLI_BUDGET_ENV!r}]))\n"
+    )
+    for script in (
+        _NEIGHBOR_SCRIPT,
+        "examples/control_plane/control-plane-maintainability-ratchet-smoke.py",
+        _CLI_BUDGET_SCRIPT,
+    ):
+        child = repo / script
+        child.parent.mkdir(parents=True, exist_ok=True)
+        fail = (
+            'if os.environ.get("CANARY_FIXTURE_FAIL") == "1":\n'
+            "    raise SystemExit(7)\n"
+            if script == _CLI_BUDGET_SCRIPT else ""
+        )
+        child.write_text(probe + fail, encoding="utf-8")
+    metrics = Path("loopx/canary/module_metric_baseline.json")
+    (repo / metrics).parent.mkdir(parents=True)
+    (repo / metrics).write_bytes((DEFAULT_CATALOG_PATH.parents[2] / metrics).read_bytes())
+    _git(repo, "add", "examples", "loopx")
+    _git(repo, "commit", "-m", "install synthetic validation probes")
+    _git(repo, "update-ref", "refs/remotes/origin/main", "HEAD")
+    _git(repo, "commit", "--allow-empty", "-m", "integration target")
+    _git(repo, "branch", "integration/base")
+    changed = repo / "loopx/control_plane/testing/cli_output_budget.py"
+    changed.parent.mkdir(parents=True)
+    changed.write_text("# Exercise CLI output budget selection.\n", encoding="utf-8")
+    _git(repo, "add", "loopx")
+    _git(repo, "commit", "-m", "select CLI output budget check")
+    return repo
+
+
+def _check_for_script(run: dict, script: str) -> dict:
+    return next(item for item in run["selected_checks"] if item["normalized"]["script"] == script)
+
+
+@pytest.mark.parametrize(
+    ("base_args", "expected_base", "child_exit"),
+    [
+        (["--git-diff-base", "integration/base"], "integration/base", 0),
+        ([], "origin/main", 0),
+        (["--git-diff-base", "integration/base"], "integration/base", 7),
+    ],
+)
+def test_premerge_scopes_cli_budget_base_to_its_child(tmp_path, base_args, expected_base, child_exit):
+    repo = _cli_budget_checkout(tmp_path / "repo")
+    env = {**os.environ, **dict(zip(_CLI_BUDGET_ENV, _AMBIENT_REFS)), "CANARY_FIXTURE_FAIL": str(int(child_exit != 0))}
+    response = run_source_cli(
+        ["--format", "json", "canary", "premerge", "--from-git-diff", "--tier", "quick",
+         "--no-progress", *base_args],
+        cwd=repo, env=env, check=False, timeout=60,
+    )
+    assert response.stdout, response.stderr
+    payload = json.loads(response.stdout)
+    assert payload["base_ref"] == expected_base
+    budget = _check_for_script(payload["catalog_run"], _CLI_BUDGET_SCRIPT)
+    neighbor = _check_for_script(payload["catalog_run"], _NEIGHBOR_SCRIPT)
+    assert json.loads(budget["stdout_tail"]) == [expected_base, expected_base]
+    assert json.loads(neighbor["stdout_tail"]) == list(_AMBIENT_REFS)
+    assert budget["returncode"] == child_exit
+    assert budget["ok"] is (child_exit == 0)
+    assert payload["validation_summary"]["failure_count"] == int(child_exit != 0)
+    if child_exit:
+        assert response.returncode != 0 and payload["gate"]["merge_gate_passed"] is False
+
+
+def test_cli_budget_children_keep_independent_bases_and_standalone_defaults(tmp_path, monkeypatch):
+    repo = _cli_budget_checkout(tmp_path / "repo")
+    for name, value in zip(_CLI_BUDGET_ENV, _AMBIENT_REFS):
+        monkeypatch.setenv(name, value)
+    monkeypatch.delenv("CANARY_FIXTURE_FAIL", raising=False)
+
+    def run(base: str | None) -> dict:
+        return build_canary_smoke_suite_run(
+            repo_root=repo, scripts=[_CLI_BUDGET_SCRIPT, _NEIGHBOR_SCRIPT],
+            parallel_jobs=2, cli_output_base_ref=base,
+        )
+
+    bases = ("integration/base", "origin/main", None)
+    with ThreadPoolExecutor(max_workers=3) as executor:
+        results = list(executor.map(run, bases))
+    for base, result in zip(bases, results):
+        assert result["ok"] and result["effective_parallel_jobs"] == 2
+        budget = _check_for_script(result, _CLI_BUDGET_SCRIPT)
+        assert json.loads(budget["stdout_tail"]) == ([base, base] if base else list(_AMBIENT_REFS))
+        neighbor = _check_for_script(result, _NEIGHBOR_SCRIPT)
+        assert json.loads(neighbor["stdout_tail"]) == list(_AMBIENT_REFS)
+    assert tuple(os.environ[name] for name in _CLI_BUDGET_ENV) == _AMBIENT_REFS
+
+
 @pytest.mark.parametrize("command", [
     "python examples/../../escape.py", "python examples/root-smoke.py ; echo unsafe",
     "python ../elsewhere/examples/root-smoke.py",
diff --git a/tests/control_plane/test_canonical_claim_execution_proof.py b/tests/control_plane/test_canonical_claim_execution_proof.py
index da5a3d6bfc..072c0d1fe3 100644
--- a/tests/control_plane/test_canonical_claim_execution_proof.py
+++ b/tests/control_plane/test_canonical_claim_execution_proof.py
@@ -104,7 +104,12 @@ def expired_managed_claim(tmp_path, monkeypatch, request):
         f"import {{prepareCoordinationProjectionCommit}} from {json.dumps((module / 'coordination_projection.ts').as_uri())};"
         "let text='';for await(const chunk of process.stdin)text+=chunk;const input=JSON.parse(text);"
         "const store=await openLocalAuthorityStore(input.runtime,input.goal);let result;"
-        "if(input.patch){const head=await store.loadAuthority();"
+        "if(input.todo_patch){const head=await store.loadAuthority();"
+        "const todo=head.head.todos.find(todo=>todo.todo_id===input.todo);"
+        "result=await store.commitAuthority(prepareCoordinationProjectionCommit({goal_id:input.goal,"
+        "operation_id:'synthetic-edit-'+head.provider_revision,expected_provider_revision:head.provider_revision,projection:head.head,"
+        "mutations:[{kind:'todo_upsert',todo:{...todo,...input.todo_patch}}]}));}"
+        "else if(input.patch){const head=await store.loadAuthority();"
         "result=await store.commitAuthority(prepareCoordinationProjectionCommit({goal_id:input.goal,"
         "operation_id:'synthetic-identity-change',expected_provider_revision:head.provider_revision,projection:head.head,"
         "mutations:[{kind:'lease_upsert',lease:{...head.head.leases[0],...input.patch}}]}));}"
@@ -114,9 +119,9 @@ def expired_managed_claim(tmp_path, monkeypatch, request):
         "process.stdout.write(JSON.stringify(result));"
     )
 
-    def author(patch=None):
+    def author(patch=None, *, todo_patch=None):
         result = subprocess.run(["node", "--no-warnings", "--experimental-strip-types", "--input-type=module", "-e", script],
-            input=json.dumps({"runtime": str(runtime), "goal": goal, "todo": target, "patch": patch}),
+            input=json.dumps({"runtime": str(runtime), "goal": goal, "todo": target, "patch": patch, "todo_patch": todo_patch}),
             capture_output=True, text=True, timeout=45, check=True)
         accepted = json.loads(result.stdout)
         assert accepted["status"] == "applied", accepted
@@ -196,6 +201,8 @@ def test_changed_execution_packet_never_recommends_claim_adoption(expired_manage
     before = snapshot()
     for command in ("update", "complete"):
         extra = ["--note", "Reviewed progress"] if command == "update" else ["--evidence", "evidence:output"]
+        if command == "update":
+            extra += ["--update-expected-provider-revision", before[1]]
         rejected = cli(["todo", command, *selected, "--agent-id", "agent-a", "--claim-operation-id",
                         "expired-original-claim", *extra], expected_exit=1)
         assert rejected["error_code"] == "claim_execution_unavailable"
@@ -205,3 +212,80 @@ def test_changed_execution_packet_never_recommends_claim_adoption(expired_manage
         assert "todo list" in render_todo_markdown(rejected)
         assert cli(recovery["inspect"]["cli_args"], use_fixture_route=False)["todo"] == before[0]
     assert snapshot() == before
+
+
+@pytest.mark.parametrize("intervening_edit", ["none", "before-claim", "after-read"])
+def test_expired_claim_with_cas_reconciles_only_selected_todo(
+    expired_managed_claim, intervening_edit, record_property,
+):
+    cli, selected, snapshot, author, _ = expired_managed_claim
+    original = snapshot()
+    attempt = ["todo", "update", *selected, "--agent-id", "agent-a", "--claim-operation-id",
+               "expired-original-claim", "--update-operation-id", "original-reviewed-edit",
+               "--update-expected-provider-revision", original[1], "--note", "Validated progress"]
+    before = snapshot()
+    refused = cli(attempt, expected_exit=1)
+    assert refused.get("error_code") == "claim_execution_unavailable", json.dumps(refused)
+    recovery = refused["recovery"]
+    assert recovery["action"] == "claim_task" and recovery["execution_authority_granted"] is False
+    assert snapshot() == before
+    assert recovery["inspect"]["cli_args"][-2:] == selected[-2:]
+    assert recovery["retry"]["requires_flags"] == ["--claim-operation-id", "--update-expected-provider-revision"]
+    retry = recovery["retry"]["cli_args"]
+    assert "expired-original-claim" not in retry
+    assert retry[retry.index("--update-expected-provider-revision") + 1] == "<provider_revision_from_reconciled_todo_read>"
+    rendered = render_todo_markdown(refused)
+    assert rendered.index("todo claim") < rendered.index("todo list") < rendered.index("todo update")
+    if intervening_edit == "before-claim":
+        author(todo_patch={"text": "Preserve another writer's accepted correction"})
+        before = snapshot()
+    prepared = cli(recovery["claim"]["cli_args"], use_fixture_route=False)
+    assert prepared["ok"] and prepared["todo_changed"] is False
+    # Claim only describes its own change, not changes since the old caller read.
+    current = cli(recovery["inspect"]["cli_args"], use_fixture_route=False)
+    assert current["todo"] == before[0]
+    revision = current["authority_read"]["provider_revision"]
+    assert revision != original[1]
+    retry = [prepared["claim_operation_id"] if value == "<claim_operation_id_from_claim>" else
+             revision if value == "<provider_revision_from_reconciled_todo_read>" else value for value in retry]
+    if intervening_edit == "after-read":
+        author(todo_patch={"text": "Preserve a concurrent correction after inspection"})
+        concurrent = snapshot()
+        rejected = cli(retry, expected_exit=1, use_fixture_route=False)
+        assert rejected["error_code"] == "provider_revision_mismatch"
+        assert snapshot() == concurrent, "recovery must not silently rebase a concurrent edit"
+        current = cli(recovery["inspect"]["cli_args"], use_fixture_route=False)
+        retry[retry.index("--update-expected-provider-revision") + 1] = current["authority_read"]["provider_revision"]
+    accepted = cli(retry, use_fixture_route=False)
+    assert accepted["ok"]
+    final = snapshot()
+    assert final[0]["text"] == current["todo"]["text"]
+    assert final[0]["note"] == "Validated progress"
+    assert final[0]["status"] == "open"
+    assert cli(retry, use_fixture_route=False)["ok"] and snapshot() == final
+    record_property("recovery_interaction", json.dumps({
+        "commands": ["todo update (refused)", "todo claim", "todo list --todo-id", "todo update (reconciled retry)"],
+        "whole_goal_reads": 0, "automatic_revision_rebase": False,
+        "intervening_edit": intervening_edit, "verification_reads_excluded": True,
+    }))
+
+
+@pytest.mark.parametrize("reference", ["old-reference", "-old-reference"])
+def test_cas_retry_projection_preserves_intent_and_routes_without_stale_references(tmp_path, reference):
+    from loopx.cli import build_parser
+    from loopx.cli_commands.todo_event import _route_native_recovery
+
+    args = build_parser().parse_args([
+        "todo", "update", "--goal-id", "example-goal", "--todo-id", "todo_example", "--agent-id", "agent-a",
+        "--claim-operation-id=" + reference, "--update-operation-id", "original-intent",
+        "--update-expected-provider-revision=" + reference, "--note=--update-expected-provider-revision",
+    ])
+    packet = {"recovery": {"retry": {"command": "loopx todo update",
+        "requires_flags": ["--claim-operation-id", "--update-expected-provider-revision"],
+        "reference_source": "claim_operation_id_from_claim"}}}
+    _route_native_recovery(packet, args, registry_path=tmp_path / "registry.json", runtime_root_arg=str(tmp_path / "runtime"))
+    retried = build_parser().parse_args(packet["recovery"]["retry"]["cli_args"])
+    assert retried.claim_operation_id == "<claim_operation_id_from_claim>"
+    assert retried.update_expected_provider_revision == "<provider_revision_from_reconciled_todo_read>"
+    assert retried.update_operation_id == "original-intent" and retried.note == "--update-expected-provider-revision"
+    assert retried.registry == str(tmp_path / "registry.json") and retried.runtime_root == str(tmp_path / "runtime")
diff --git a/tests/control_plane/test_chat_request_inventory.py b/tests/control_plane/test_chat_request_inventory.py
index d714b7cd9d..6ac9ffa038 100644
--- a/tests/control_plane/test_chat_request_inventory.py
+++ b/tests/control_plane/test_chat_request_inventory.py
@@ -512,8 +512,8 @@ def test_inventory_rereads_goal_lifetime_between_batches(api, monkeypatch, limit
             response={"context_handoff_receipt": delivered})
         server.chat_store.finalize_managed_turn_completion(session["session_id"], turn["turn_id"])
     original_scope = inventory.collaboration_goal_scope
-    original_decide = inventory.decide_collaboration_lifecycle
-    calls, modes = [], []
+    original_inspect = inventory.inspect_original_request_batch
+    calls, modes, batch_sizes = [], [], []
 
     @contextmanager
     def scope(*args, **kwargs):
@@ -525,21 +525,46 @@ def scope(*args, **kwargs):
             calls.append(current.current_goal_ref)
             yield current
 
-    def decide(*args, **kwargs):
-        result = original_decide(*args, **kwargs)
-        modes.append(result.get("mode"))
-        return result
+    def inspect(current, deliveries):
+        results = original_inspect(current, deliveries)
+        batch_sizes.append(len(deliveries))
+        modes.extend(result.get("mode") for result in results)
+        return results
 
     monkeypatch.setattr(inventory, "collaboration_goal_scope", scope)
-    monkeypatch.setattr(inventory, "decide_collaboration_lifecycle", decide)
+    monkeypatch.setattr(inventory, "inspect_original_request_batch", inspect)
     code, value = _inventory(api, route["session_id"], view="history", limit=limit)
     assert code == 200 and len(calls) == 2
     assert calls[0] == f["ref"] and calls[1] != f["ref"]
     # The existing typed owner permits proven historical inspection after a
     # replacement; it must observe the new lifetime rather than reuse the old.
+    assert batch_sizes == [12, 1]
     assert modes == ["current_instance"] * 12 + ["historical_read"]
     assert value["matched"] == 13 and value["coverage"] == {"scan_complete": True, "unreadable": 0, "diagnostics": []}
 
+def test_inventory_falls_back_only_when_inspection_exceeds_the_wire_limit(api, monkeypatch):
+    from loopx.control_plane.collaboration import goal_instance_scope
+    from loopx.control_plane.effect_runtime import EffectRuntimeRejected
+
+    _, _, route = _source(api)
+    original = goal_instance_scope.effect_runtime_result
+    operations = []
+    batch_method = "collaboration.goal_instance.inspect_original_requests"
+    single_method = "collaboration.goal_instance.decide"
+
+    def result(method, params):
+        operations.append(method)
+        if method == batch_method:
+            raise EffectRuntimeRejected("oversized inspection", diagnostic_code="request_too_large")
+        return original(method, params)
+
+    monkeypatch.setattr(goal_instance_scope, "effect_runtime_result", result)
+    code, value = _inventory(api, route["session_id"], view="history")
+    assert code == 200 and value["matched"] == 1
+    assert value["rows"][0]["request_id"] == route["request_id"]
+    assert operations == [batch_method, single_method]
+
+
 def test_conflicting_receipt_is_diagnosable_but_does_not_authorize_content_or_controls(api):
     control, _, route = _source(api)
     _, f, server = api
diff --git a/tests/control_plane/test_goal_acceptance_cli.py b/tests/control_plane/test_goal_acceptance_cli.py
index 7688fc4af0..9041657584 100644
--- a/tests/control_plane/test_goal_acceptance_cli.py
+++ b/tests/control_plane/test_goal_acceptance_cli.py
@@ -19,6 +19,7 @@
     run_json_cli_result,
     write_fixture_registry,
 )
+from tests.control_plane.codex_checkpoint_fixture import read_cli_policy_payload
 
 
 @pytest.fixture(params=["file", "sqlite"])
@@ -82,11 +83,14 @@ def acceptance_goal(tmp_path, monkeypatch, request):
     document_path.write_text(json.dumps(document))
 
     def run(*arguments):
-        return run_json_cli_result(
+        code, payload = run_json_cli_result(
             *arguments,
             registry_path=registry,
             runtime_root=runtime,
         )
+        if arguments[:2] == ("quota", "should-run"):
+            payload = read_cli_policy_payload(json.dumps(payload), returncode=code)
+        return code, payload
 
     def cli(*arguments):
         return run("goal-acceptance", *arguments, "--goal-id", "goal-acceptance")
@@ -535,3 +539,73 @@ def test_owner_scope_correction_restores_independent_work_through_real_cli(accep
     assert code == 1 and verified["checks_passed"] is False
     (project / "artifact.txt").write_text("accepted")
     assert cli("verify", "--execute")[0] == 0
+
+
+def test_goal_only_checks_keep_local_work_free_and_outcome_unmet(acceptance_goal):
+    project, checks_file, cli, run = acceptance_goal
+    outcome_file = project / "goal-outcome.json"
+    description = "The external work commitment is fulfilled"
+    for outcome_id in ("campaign", "independent"):
+        outcome_file.write_text(json.dumps({"outcome_id": outcome_id, "owner_agent_id": "agent-a",
+            "objective": f"Complete the authorized {outcome_id} work", "requirements": [
+                {"id": "commitment", "description": description}],
+            "source": {"ref": f"owner:{outcome_id}", "summary": "The owner retained a Goal-wide commitment"}}))
+        code, refined = cli("refine", "--agent-id", "agent-a", "--document", str(outcome_file),
+            "--expected-provider-revision", cli("inspect")[1]["provider_revision"],
+            "--operation-id", f"goal-only-{outcome_id}", "--execute")
+        assert code == 0, refined
+    default_contract = cli("inspect")[1]["goal_acceptance_contract"]
+    assert default_contract.get("verification") is None
+    assert {gap["outcome_id"] for gap in default_contract["outcome_requirements"]["acceptance_gaps"]} == {
+        "campaign", "independent"}
+
+    command = [sys.executable, "-c",
+        "from pathlib import Path; assert Path('commitment.txt').read_text() == 'fulfilled'"]
+    checks_file.write_text(json.dumps({"scope": {"kind": "goal"}, "objective": "Verify the Goal artifact",
+        "non_goals": [], "bindings": [], "criteria": [
+            {"id": "commitment", "description": description, "validation_argv": command}]}))
+    code, configured = cli("configure", "--document", str(checks_file),
+        "--expected-provider-revision", cli("inspect")[1]["provider_revision"],
+        "--operation-id", "standalone-goal-check", "--execute")
+    assert code == 0, configured
+    artifact = project / "commitment.txt"
+    artifact.write_text("fulfilled")
+    code, passed = cli("verify", "--agent-id", "agent-a", "--execute")
+    assert code == 0 and passed["checks_passed"] is True, passed
+    current = cli("inspect")[1]["goal_acceptance_contract"]
+    assert current["status"] == "accepted"
+    outcomes = current["outcome_requirements"]["outcomes"]
+    assert {outcome["id"]: outcome["requirements"][0]["status"] for outcome in outcomes} == {
+        "campaign": "unverified", "independent": "unverified"}
+    artifact.unlink()
+
+    checks_file.write_text(json.dumps({"outcome_id": "campaign", "scope": {"kind": "goal"},
+        "criteria": [{"id": "commitment", "validation_argv": command}]}))
+    code, configured = cli("configure", "--document", str(checks_file),
+        "--expected-provider-revision", cli("inspect")[1]["provider_revision"],
+        "--operation-id", "goal-only-configure", "--execute")
+    assert code == 0, configured
+    contract = configured["goal_acceptance_contract"]
+    assert contract["scope"] == {"kind": "goal"}
+    assert contract["tasks"] == [] and contract["held_todo_ids"] == []
+    assert contract["status"] == "stale"
+    assert contract["outcome_requirements"]["acceptance_gaps"][0]["kind"] == "goal_outcome_uncovered"
+    code, failed = cli("verify", "--agent-id", "agent-a", "--execute")
+    assert code == 1 and failed["checks_passed"] is False, failed
+    assert cli("inspect")[1]["goal_acceptance_contract"]["status"] == "failed"
+    code, completed = run("todo", "complete", "--goal-id", "goal-acceptance",
+        "--todo-id", "todo_export", "--agent-id", "agent-a")
+    assert code == 0, completed
+    code, quota = run("quota", "should-run", "--goal-id", "goal-acceptance", "--agent-id", "agent-a")
+    assert code == 0, quota
+    assert quota["decision"] == "autonomous_replan_required", quota
+    assert quota["goal_frontier_projection"].get("terminal_state") is None
+    artifact.write_text("fulfilled")
+    code, passed = cli("verify", "--agent-id", "agent-a", "--execute")
+    assert code == 0 and passed["checks_passed"] is True, passed
+    current = cli("inspect")[1]["goal_acceptance_contract"]
+    assert current["status"] == "accepted"
+    outcomes = current["outcome_requirements"]["outcomes"]
+    assert {outcome["id"]: outcome["requirements"][0]["status"] for outcome in outcomes} == {
+        "campaign": "accepted", "independent": "unverified"}
+    assert {gap["outcome_id"] for gap in current["outcome_requirements"]["acceptance_gaps"]} == {"independent"}
diff --git a/tests/control_plane/test_heartbeat_agent_input.py b/tests/control_plane/test_heartbeat_agent_input.py
index 8e158e23c1..a37ba7eed7 100644
--- a/tests/control_plane/test_heartbeat_agent_input.py
+++ b/tests/control_plane/test_heartbeat_agent_input.py
@@ -158,6 +158,34 @@ def test_thin_agent_input_keeps_exact_turn_and_bootstrap_identity_when_present()
     assert projected["bootstrap"] is True
 
 
+@pytest.mark.parametrize("mode", ["full", "compact", "brief", "thin"])
+@pytest.mark.parametrize("windows", [False, True])
+def test_bound_prompt_keeps_original_turn_without_wake_time_substitution(mode, windows, monkeypatch):
+    import loopx.project_prompt as prompt_shell
+
+    monkeypatch.setattr(prompt_shell, "_is_windows_host", lambda: windows)
+    args = dict(goal_id="bound-heartbeat", agent_id="agent-a",
+                runtime_profile="codex_app_heartbeat", **{mode: True})
+    dynamic = build_heartbeat_prompt(**args)
+    bound = build_heartbeat_prompt(**args, turn_instance_id="original-turn")
+    # A reusable wake template still needs timestamp substitution. A producer-
+    # bound prompt must preserve that original identity, including on retry.
+    assert "Per wake, replace `<current_time_iso>` once." in dynamic["task_body"]
+    assert "reuse the value on retries" in dynamic["task_body"]
+    assert "Per wake, replace" not in bound["task_body"]
+    assert "<current_time_iso>" not in bound["task_body"]
+    assignment = ('$LOOPX_TURN = "original-turn"' if windows
+                  else "LOOPX_TURN=original-turn")
+    lines = bound["task_body"].splitlines()
+    assert lines.count(assignment) == 1
+    assert bound["quota_guard_command"] in lines
+    assert lines.index(assignment) < lines.index(bound["quota_guard_command"])
+    # Binding does not replace the dynamic shell read with an unscoped guard.
+    assert "--turn-instance-id" in bound["quota_guard_command"]
+    assert "LOOPX_TURN" in bound["quota_guard_command"]
+    assert "interaction_contract.cli_channel.settlement_plan.ordered_steps" in bound["task_body"]
+
+
 def test_thin_agent_input_error_is_actionable_without_generator_diagnostics() -> None:
     generated = build_heartbeat_prompt_error_payload(
         goal_id="heartbeat-agent-input",
diff --git a/tests/control_plane/test_heartbeat_envelope_transport.py b/tests/control_plane/test_heartbeat_envelope_transport.py
index e19efdb46f..f7d1bc3d50 100644
--- a/tests/control_plane/test_heartbeat_envelope_transport.py
+++ b/tests/control_plane/test_heartbeat_envelope_transport.py
@@ -354,7 +354,7 @@ def complete_page(value):
         '--todo-id', ALTERNATIVE_TODO_ID, '--turn-instance-id', TURN_ID,
         '--classification', 'validated_progress', '--delivery-batch-scale', 'implementation',
         '--delivery-outcome', 'outcome_progress', '--delivery-boundary', 'in_flight_continuation',
-        '--no-global-sync', '--suppress-external-sinks')
+        '--no-global-sync', '--suppress-external-sinks', cwd=project)
     assert rc == 0, refresh
     spend = refresh['settlement_owed']['command']
     for _ in range(2):
diff --git a/tests/control_plane/test_research_execution_loop.py b/tests/control_plane/test_research_execution_loop.py
index cee7f893ca..50e0570ef3 100644
--- a/tests/control_plane/test_research_execution_loop.py
+++ b/tests/control_plane/test_research_execution_loop.py
@@ -141,6 +141,180 @@ def test_probe_cli_preserves_a_failed_candidate_exit_and_its_observation(tmp_pat
     observed = json.loads(output.read_text())
     assert observed["exit_code"] == 3 and observed["search_iterations"] is None
     assert json.loads(output.with_suffix(".json.candidate.json").read_text())["candidate_sha256"] == observed["candidate_sha256"]
+    assert not output.with_suffix(".json.memory.json").exists()
+
+
+def test_memory_observation_without_samples_leaves_timeout_and_next_method_unknown(tmp_path, monkeypatch):
+    import benchmark.runtime.research_probe as producer
+
+    monkeypatch.setattr(producer, "_group_pss_sample", lambda _group: None)
+    observed = probe(tmp_path, monkeypatch, source="import time; time.sleep(1)",
+                     limit_seconds=0.08, memory_limit_bytes=1024)
+    sidecar = tmp_path / "observation.json.memory.json"
+    evidence = json.loads(sidecar.read_bytes())
+    assert observed["stop_reason"] == "host_timeout" and observed["exit_code"] < 0
+    assert evidence["candidate_sha256"] == observed["candidate_sha256"]
+    assert evidence["complete_samples"] == 0 and evidence["peak_sampled_pss_bytes"] is None
+    assert "observed_limit_exceeded" not in evidence and "next_action" not in evidence
+    assert "resource:" + hashlib.sha256(sidecar.read_bytes()).hexdigest() in observed["evidence_refs"]
+
+
+def test_changed_candidate_cannot_publish_memory_evidence(tmp_path, monkeypatch):
+    with pytest.raises(ValueError, match="candidate changed"):
+        probe(tmp_path, monkeypatch,
+              source="from pathlib import Path; Path(__file__).write_text('print(0)')", memory_limit_bytes=1024)
+    assert json.loads((tmp_path / "observation.json").read_text())["ok"] is False
+    assert not (tmp_path / "observation.json.memory.json").exists()
+
+
+@pytest.mark.skipif(sys.platform != "linux", reason="requires a real Linux file size limit")
+def test_optional_memory_file_short_write_preserves_cli_result(tmp_path):
+    candidate = tmp_path / "candidate.py"
+    candidate.write_text("print('candidate finished'); raise SystemExit(7)")
+    # Change only the kernel limit for the optional file. The memory read
+    # and resulting real FileIO.write still use their production paths.
+    (tmp_path / "sitecustomize.py").write_text("""
+from contextlib import contextmanager
+from pathlib import Path
+import resource
+
+original_open = Path.open
+
+@contextmanager
+def limit_size(stream):
+    soft, hard = resource.getrlimit(resource.RLIMIT_FSIZE)
+    try:
+        resource.setrlimit(resource.RLIMIT_FSIZE, (64, hard))
+        with stream as opened:
+            yield opened
+    finally:
+        resource.setrlimit(resource.RLIMIT_FSIZE, (soft, hard))
+
+def open_with_limit(path, *args, **kwargs):
+    stream = original_open(path, *args, **kwargs)
+    return limit_size(stream) if path.name.endswith(".memory.json") else stream
+
+Path.open = open_with_limit
+""")
+    output = tmp_path / "observed.json"
+    process = subprocess.run([sys.executable, "-m", "benchmark.runtime.research_probe",
+        "--candidate-file", str(candidate), "--output", str(output), "--input-revision", "fixture-v1",
+        "--planned-method-id", "method:work", "--executed-method-id", "method:work",
+        "--evidence-ref", "probe:failed", "--limit-seconds", "5", "--memory-limit-bytes", "1024",
+        "--", sys.executable, str(candidate)], cwd=tmp_path, capture_output=True, text=True, timeout=10,
+        env={**os.environ, "PYTHONPATH": os.pathsep.join((str(tmp_path), str(fixture.REPO_ROOT)))})
+    assert process.returncode == 7, process.stderr
+    assert "Optional process-group memory observation could not be retained." in process.stderr
+    assert output.with_suffix(".json.memory.json").stat().st_size == 64
+    assert output.with_suffix(".json.stdout").read_text().strip() == "candidate finished"
+    observation = json.loads(output.read_bytes())
+    assert json.loads(process.stdout) == observation and observation["exit_code"] == 7
+    assert not any(ref.startswith("resource:") for ref in observation["evidence_refs"])
+
+
+@pytest.mark.skipif(sys.platform != "linux" or not Path("/proc/self/smaps_rollup").exists(),
+                    reason="requires live Linux process-group PSS")
+def test_sampled_memory_compares_complete_workloads_with_equal_outputs(tmp_path):
+    limit_bytes = 38 * 1024 * 1024
+    revision = "two-complete-shards-v1"
+    shard_size = 22 * 1024 * 1024
+    # All three mechanisms compute the same independent workload. One expands
+    # both buffers at once. A streaming contender bounds retained state.
+    template = """
+import json
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+if len(sys.argv) == 2:
+    marker = int(sys.argv[1])
+    if {streaming}:
+        total = 0
+        chunk_size = 1024 * 1024
+        for offset in range(0, {shard_size}, chunk_size):
+            scratch = bytearray([marker]) * min(chunk_size, {shard_size} - offset)
+            total += sum(scratch)
+    else:
+        scratch = bytearray([marker]) * {shard_size}
+        total = sum(scratch)
+    # The parent releases this worker only after reading the amount of live
+    # payload. In the concurrent case both buffers are held at that barrier.
+    print(total, len(scratch), flush=True)
+    sys.stdin.readline()
+else:
+    def shard(marker):
+        return subprocess.Popen(
+            [sys.executable, __file__, str(marker)],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True,
+        )
+    def read(process):
+        total, retained = (int(item) for item in process.stdout.readline().split())
+        assert process.poll() is None
+        return total, retained
+    def finish(process):
+        process.stdin.close()
+        assert process.wait(timeout=3) == 0
+    first = shard(1)
+    a, retained_a = read(first)
+    if {parallel}:
+        second = shard(2)
+        b, retained_b = read(second)
+        simultaneous_payload = retained_a + retained_b
+        time.sleep(0.60)
+        finish(first)
+        finish(second)
+    else:
+        time.sleep(0.60)
+        finish(first)
+        second = shard(2)
+        b, retained_b = read(second)
+        simultaneous_payload = max(retained_a, retained_b)
+        time.sleep(0.60)
+        finish(second)
+    receipt = dict(values=[a, b], simultaneous_payload=simultaneous_payload)
+    Path("last-workload.json").write_text(json.dumps(receipt))
+    print(json.dumps(receipt))
+"""
+
+    def execute(name, *, streaming=False, parallel, method_id):
+        candidate = tmp_path / f"{name}.py"
+        candidate.write_text(template.format(shard_size=shard_size, streaming=streaming, parallel=parallel))
+        output = tmp_path / f"{name}.observation.json"
+        command = [sys.executable, "-m", "benchmark.runtime.research_probe",
+            "--candidate-file", str(candidate), "--output", str(output), "--input-revision", revision,
+            "--planned-method-id", method_id, "--executed-method-id", method_id,
+            "--evidence-ref", f"probe:{name}", "--limit-seconds", "6",
+            "--memory-limit-bytes", str(limit_bytes), "--", sys.executable, str(candidate)]
+        process = subprocess.run(command, cwd=tmp_path, env={**os.environ, "PYTHONPATH": str(fixture.REPO_ROOT)},
+                                 text=True, capture_output=True, timeout=10)
+        assert process.returncode == 0, process.stderr
+        execution = json.loads(output.with_suffix(".json.stdout").read_text())
+        assert execution["values"] == [shard_size, 2 * shard_size]
+        observation = json.loads(process.stdout)
+        memory_bytes = output.with_suffix(".json.memory.json").read_bytes()
+        memory = json.loads(memory_bytes)
+        ref = "resource:" + hashlib.sha256(memory_bytes).hexdigest()
+        assert ref in observation["evidence_refs"]
+        assert memory["candidate_sha256"] == observation["candidate_sha256"]
+        assert memory["input_revision"] == revision and memory["complete_samples"] > 0
+        assert memory["reference_memory_bytes"] == limit_bytes
+        assert "observed_limit_exceeded" not in memory and "next_action" not in memory
+        return observation, memory, execution
+
+    baseline, incumbent_memory, incumbent_run = execute(
+        "incumbent", parallel=False, method_id="method:sequential")
+    challenger, expanded_memory, expanded_run = execute(
+        "expanded", parallel=True, method_id="method:expanded")
+    contender, streamed_memory, streamed_run = execute(
+        "streamed", streaming=True, parallel=True, method_id="method:streaming")
+    assert incumbent_run["simultaneous_payload"] == shard_size < limit_bytes
+    assert expanded_run["simultaneous_payload"] == 2 * shard_size > limit_bytes
+    assert streamed_run["simultaneous_payload"] == 2 * 1024 * 1024 < limit_bytes
+    assert expanded_memory["members_at_peak"] == 3
+    assert (streamed_memory["peak_sampled_pss_bytes"] < incumbent_memory["peak_sampled_pss_bytes"]
+            < expanded_memory["peak_sampled_pss_bytes"])
+    assert len({baseline["candidate_sha256"], challenger["candidate_sha256"], contender["candidate_sha256"]}) == 3
 
 
 @pytest.mark.parametrize("provider", ["file", "sqlite"])
diff --git a/tests/control_plane/test_work_yardstick_cli.py b/tests/control_plane/test_work_yardstick_cli.py
index 8868d472e9..b25cc101d5 100644
--- a/tests/control_plane/test_work_yardstick_cli.py
+++ b/tests/control_plane/test_work_yardstick_cli.py
@@ -4,11 +4,12 @@
 or a causal benchmark gain. No evaluator, credentials or active Goal are used.
 """
 import hashlib
+from itertools import groupby
 import json
 
 
 from tests.control_plane.test_quota_settlement_cli import (
-    _write_fixture, _run_cli, GOAL_ID, AGENT_ID, TODO_ID,
+    _initialize_fixture_authority, _projected_cli_args, _write_fixture, _run_cli, GOAL_ID, AGENT_ID, TODO_ID,
 )
 from loopx.capabilities.explore.result_log import explore_result_log_path, load_explore_result_events
 from loopx.capabilities.explore.turn_context import explore_turn_context
@@ -35,13 +36,18 @@ def attachment():
         evidence_refs=["result:reversal"], work_yardstick_decision=decision())
 
 
-def setup(tmp_path, enabled=True):
-    project, runtime, path = _write_fixture(tmp_path, provider="sqlite")
+def setup(tmp_path, enabled=True, *, active=False):
+    project, runtime, path = _write_fixture(tmp_path)
     config = json.loads(path.read_text())
+    if active:
+        config["goals"][0]["status"] = "active"
+        state = project / config["goals"][0]["state_file"]
+        state.write_text(state.read_text().replace("status: active-read-only", "status: active", 1))
     config["goals"][0]["explore_graph"] = {"enabled": True}
     config["goals"][0]["quota"]["allowed_slots"] = 4
     config["goals"][0].setdefault("execution_profile", {})["yardstick_enabled"] = enabled
     path.write_text(json.dumps(config))
+    _initialize_fixture_authority(project, runtime, provider="sqlite")
     return project, runtime, path
 
 
@@ -55,11 +61,11 @@ def binding(turn):
     return ["--goal-id", GOAL_ID, "--agent-id", AGENT_ID, "--todo-id", TODO_ID, "--turn-instance-id", turn]
 
 
-def refresh(project, runtime, path, turn, source):
+def refresh(project, runtime, path, turn, source, *options):
     run(project, runtime, path, "quota", "should-run", "--codex-app", *binding(turn))
     return run(project, runtime, path, "refresh-state", *binding(turn), "--classification", "validated_change",
         "--delivery-batch-scale", "implementation", "--delivery-outcome", "outcome_progress",
-        "--explore-result-json", str(source), "--no-global-sync", "--suppress-external-sinks")
+        "--explore-result-json", str(source), "--no-global-sync", "--suppress-external-sinks", *options)
 
 
 def context(runtime, path, *, detail=True):
@@ -71,6 +77,147 @@ def context(runtime, path, *, detail=True):
     return compact
 
 
+def test_measured_yardstick_restarts_comparison_when_the_acceptance_basis_changes(tmp_path):
+    project, runtime, path = setup(tmp_path, active=True)
+    source = tmp_path / "finding.json"
+
+    def record(turn, acceptance, candidates, previous=None):
+        finding = attachment()
+        choice = finding["work_yardstick_decision"]
+        choice["target"]["acceptance_ref"] = acceptance
+        choice["counterevidence_refs"] = []
+        choice["prior_finding_id"] = previous
+        finding["measurements"] = [
+            {**choice["authoritative"], "candidate_ref": f"candidate:{name}",
+             "evidence_ref": f"result:{name}", "value": value}
+            for name, value in candidates
+        ]
+        finding["evidence_refs"] = [measurement["evidence_ref"] for measurement in finding["measurements"]]
+        source.write_text(json.dumps(finding))
+        receipt = refresh(project, runtime, path, turn, source, "--delivery-boundary", "in_flight_continuation")
+        assert receipt["explore_result_delivery"]["ok"], receipt
+        run(project, runtime, path, *_projected_cli_args(receipt["settlement_owed"]["command"], turn_instance_id=turn))
+        return receipt["explore_result_delivery"]["finding_id"]
+
+    old = record("turn-old-basis", "acceptance:task-v1", [("old-a", 10), ("old-b", 20)])
+    assert context(runtime, path)["graph"]["work_yardsticks"][0]["search_comparison"]["goal"][
+        "preferred_candidate_ref"] == "candidate:old-b"
+    first = record("turn-first-new-basis", "acceptance:task-v2", [("new-c", 6)], old)
+    compact = context(runtime, path, detail=False)["graph"]["work_yardsticks"][0]
+    assert compact["source_finding_id"] == first and "comparison_candidate_ref" not in compact
+    assert "search_comparison" not in context(runtime, path)["graph"]["work_yardsticks"][0]
+    latest = record("turn-second-new-basis", "acceptance:task-v2", [("new-d", 9)], first)
+    cue = context(runtime, path)["graph"]["work_yardsticks"][0]
+    comparison = cue["search_comparison"]["goal"]
+    assert cue["target"]["acceptance_ref"] == "acceptance:task-v2"
+    assert comparison["previous_best"]["finding_id"] == first and comparison["latest"]["finding_id"] == latest
+    assert comparison["preferred_candidate_ref"] == "candidate:new-d"
+
+
+def test_measured_yardstick_changes_next_work_from_local_screening_to_a_whole_goal_comparison(tmp_path):
+    project, runtime, path = setup(tmp_path, active=True)
+    acceptance = tmp_path / "acceptance.json"
+    acceptance.write_text(json.dumps(dict(outcome_id="encoded-artifact", owner_agent_id=AGENT_ID,
+        objective="Reduce the encoded artifact size", todo_ids=[TODO_ID],
+        requirements=[{"id": "round-trip", "description": "Decoding must preserve every original entry in order"}],
+        source={"ref": "message:encoding-request", "summary": "Preserve the complete input"})))
+    before = run(project, runtime, path, "goal-acceptance", "inspect", "--goal-id", GOAL_ID)
+    run(project, runtime, path, "goal-acceptance", "refine", "--goal-id", GOAL_ID, "--agent-id", AGENT_ID,
+        "--document", str(acceptance), "--operation-id", "declare-encoding", "--expected-provider-revision",
+        before["provider_revision"], "--execute")
+    run(project, runtime, path, "configure-goal", "--goal-id", GOAL_ID, "--execution-replan-after-turns", "2",
+        "--execution-stride-strategy", "evidence_conditioned_v1", "--execute")
+    payload = ["repeated-entry"] * 24 + ["other-entry"] * 24
+
+    def encode(value):
+        return json.dumps(value, separators=(",", ":")).encode()
+
+    def dictionary_encode(items):
+        keys = list(dict.fromkeys(items))
+        return {"keys": keys, "indices": [keys.index(item) for item in items]}
+
+    base = dictionary_encode(payload)
+    trial = attachment()
+    choice = trial["work_yardstick_decision"]
+    choice["authoritative"].update(metric="size", unit="bytes", higher_is_better=False)
+    choice["proxy"].update(metric="size", unit="bytes", higher_is_better=False, comparison_scope="validation:single-entry")
+    choice["counterevidence_refs"] = []
+    choice["next_action"] = dict(method_id="method:plain", reason="Try another plain encoding using the tiny screen",
+                                 cost_bound="One artifact and one bounded end-to-end check")
+    items = [(choice["authoritative"], payload, "goal"), (choice["proxy"], payload[:1], "screen")]
+    trial["measurements"] = [
+        {**profile, "candidate_ref": f"candidate:{name}", "evidence_ref": f"result:{source}-{name}",
+         "value": len(encode(candidate))}
+        for profile, data, source in items
+        for name, candidate in [("dictionary", dictionary_encode(data)), ("plain", data)]
+    ]
+    assert trial["measurements"][0]["value"] < trial["measurements"][1]["value"]
+    assert trial["measurements"][2]["value"] > trial["measurements"][3]["value"]
+    trial["evidence_refs"] = [row["evidence_ref"] for row in trial["measurements"]]
+    source = tmp_path / "measured-pair.json"
+    source.write_text(json.dumps(trial))
+    first = refresh(project, runtime, path, "turn-pair", source, "--delivery-boundary", "in_flight_continuation")
+    assert first["explore_result_delivery"]["ok"]
+    run(project, runtime, path, *_projected_cli_args(first["settlement_owed"]["command"], turn_instance_id="turn-pair"))
+
+    guard = run(project, runtime, path, "quota", "should-run", "--codex-app", *binding("turn-compare"))
+    compact = run(project, runtime, path, "explore", "turn-context", "--goal-id", GOAL_ID, "--agent-id", AGENT_ID,
+                  "--todo-id", TODO_ID)["graph"]["work_yardsticks"][0]
+    assert compact["comparison_candidate_ref"] == "candidate:dictionary"
+    assert compact["cue"] == choice["next_action"]["reason"]
+    assert "different mechanism or a compatible combination" in compact["comparison_cue"]
+    assert "full implementation and validation cost" in compact["comparison_cue"]
+    assert compact["comparison_cue"] in json.dumps(guard)
+    detailed = run(project, runtime, path, "explore", "turn-context", "--goal-id", GOAL_ID, "--agent-id", AGENT_ID,
+                   "--todo-id", TODO_ID, "--result-node", compact["node_id"])["graph"]["work_yardsticks"][0]
+    assert detailed["next_action"] == choice["next_action"]
+    comparison = detailed["search_comparison"]
+    assert comparison["goal"]["preferred_candidate_ref"] == "candidate:dictionary"
+    assert comparison["proxy"]["preferred_candidate_ref"] == "candidate:plain"
+    assert comparison["proxy_order_reversed"] is True
+
+    # Deterministic consumer. Combine the evidenced baseline with an independent
+    # representation change and verify the original end-to-end outcome.
+    selected_base = {"candidate:dictionary": base}[compact["comparison_candidate_ref"]]
+    runs = [[index, len(list(group))] for index, group in groupby(selected_base["indices"])]
+    artifact = project / "combined-encoding.json"
+    artifact.write_bytes(encode({"keys": selected_base["keys"], "runs": runs}))
+    result = json.loads(artifact.read_bytes())
+    assert [result["keys"][i] for i, count in result["runs"] for _ in range(count)] == payload
+    assert artifact.stat().st_size < len(encode(base))
+    digest = hashlib.sha256(artifact.read_bytes()).hexdigest()
+    follow = attachment()
+    follow["evidence_refs"] = ["result:combined"]
+    follow["work_yardstick_decision"] = {**choice, "prior_finding_id": detailed["source_finding_id"]}
+    follow["execution_observation"] = dict(schema_version="explore_execution_observation_v0", candidate_sha256=digest,
+        input_revision="inputs-v1", planned_method_id="method:plain", executed_method_id="method:dictionary-runs",
+        change_reason="The matched outcome favored the dictionary; test a different representation on that base",
+        elapsed_seconds=None, limit_seconds=None, search_iterations=1, stop_reason="complete",
+        evidence_refs=["result:combined"], result_ref="result:combined", result_candidate_sha256=digest, exit_code=0)
+    follow["measurements"] = [{**choice["authoritative"], "value": artifact.stat().st_size,
+                               "candidate_ref": f"sha256:{digest}", "evidence_ref": "result:combined"}]
+    source.write_text(json.dumps(follow))
+    saved = run(project, runtime, path, "refresh-state", *binding("turn-compare"), "--classification", "validated_change",
+        "--delivery-batch-scale", "implementation", "--delivery-outcome", "outcome_progress",
+        "--delivery-boundary", "in_flight_continuation", "--explore-result-json", str(source), "--no-global-sync", "--suppress-external-sinks")
+    assert saved["explore_result_delivery"]["ok"]
+    cue = context(runtime, path)["graph"]["work_yardsticks"][0]
+    assert cue["previous_decision_followthrough"]["executed_method_id"] == "method:dictionary-runs"
+    assert cue["search_comparison"]["goal"]["preferred_candidate_ref"] == f"sha256:{digest}"
+    assert "proxy" not in cue["search_comparison"]  # The old proxy did not measure this new pair.
+    run(project, runtime, path, *_projected_cli_args(saved["settlement_owed"]["command"], turn_instance_id="turn-compare"))
+    review = run(project, runtime, path, "quota", "should-run", "--codex-app",
+                 "--goal-id", GOAL_ID, "--agent-id", AGENT_ID, "--turn-instance-id", "turn-review")
+    assert "periodic_review_due" in {trigger["kind"] for trigger in review["autonomous_replan_obligation"]["triggers"]}
+    assert cue["search_comparison"]["guidance"] in json.dumps(review)
+    assert "comparison_candidate_ref" in json.dumps(review)
+    before = context(runtime, path, detail=False)["graph"]["measurement_feedback"]
+    run(project, runtime, path, "configure-goal", "--goal-id", GOAL_ID, "--no-execution-yardstick-enabled", "--execute")
+    disabled = run(project, runtime, path, "explore", "turn-context", "--goal-id", GOAL_ID, "--agent-id", AGENT_ID,
+                   "--todo-id", TODO_ID)["graph"]
+    assert "work_yardsticks" not in disabled and disabled["measurement_feedback"] == before
+
+
 def test_sqlite_current_work_to_ordinary_turn_to_concrete_action_and_readback(tmp_path):
     project, runtime, path = setup(tmp_path)
     source = tmp_path / "capture.json"
diff --git a/tests/control_plane_ts/benchmark_campaign_report.test.ts b/tests/control_plane_ts/benchmark_campaign_report.test.ts
index 09a7269db2..46f195b0e4 100644
--- a/tests/control_plane_ts/benchmark_campaign_report.test.ts
+++ b/tests/control_plane_ts/benchmark_campaign_report.test.ts
@@ -216,3 +216,67 @@ test('duration policy checks every selected arm and only accepts verified volunt
   input.selection[0].active_intervals[0].end_ms = -1;
   assert.throws(() => buildReport(input),/observed solver interval/);
 });
+
+test('makeup tolerance waives only known terminal gaps, retaining actual duration and qualification gates', () => {
+  const input = fixture();
+  input.duration_policy = {target_ms: 100, allow_goal_completion: [], makeup_tolerance_ms: 15};
+  for (const [i, elapsed] of [85, 84, 100, 86, 0, 85].entries()) {
+    input.selection[i].active_intervals = [{start_ms: 0, end_ms: elapsed, evidence_ref: 'solver:segment'}];
+  }
+  // Overlap is not extra active time: 50 + 45 - 10 = 85.
+  input.selection[0].active_intervals = [[0,50],[40,85]].map(([start_ms,end_ms]) =>
+    ({start_ms,end_ms,evidence_ref:'solver:segment'}));
+  let report = buildReport(input);
+  assert.deepEqual(report.duration_coverage!.map(row => row.disposition),
+    ['within_tolerance', 'needs_makeup', 'covered', 'within_tolerance', 'needs_makeup', 'within_tolerance']);
+  assert.equal(report.duration_coverage![0].active_ms, 85);
+  assert.equal(report.duration_coverage![0].remaining_ms, 15);
+  assert.equal(report.comparisons[0].qualified_common_n, 2);
+  assert.deepEqual(report.duration_policy, input.duration_policy);
+  assert.match(renderMarkdown(report), /容差内免补/);
+  input.selection[0].score!.countable = false;
+  report = buildReport(input);
+  assert.equal(report.comparisons[0].qualified_common_n, 1);
+  input.selection[0].status = 'cancelled';
+  assert.equal(buildReport(input).comparisons[0].n, 2);
+  input.selection[0].status = 'running';
+  assert.equal(buildReport(input).duration_coverage![0].disposition, 'running');
+  input.selection[0].status = 'planned';
+  assert.equal(buildReport(input).duration_coverage![0].disposition, 'planned');
+  input.selection[0].status = 'completed';
+  delete input.selection[0].active_intervals;
+  assert.equal(buildReport(input).duration_coverage![0].disposition, 'verify_duration');
+  input.selection[0].active_intervals = [{start_ms:0,end_ms:85,evidence_ref:'solver:segment'}];
+  delete input.duration_policy.makeup_tolerance_ms;
+  assert.equal(buildReport(input).duration_coverage![0].disposition, 'needs_makeup');
+});
+
+test('duration tolerance rejects invalid policy and real CLI retains the declared waiver', () => {
+  const input = fixture();
+  input.duration_policy = {target_ms: 100, allow_goal_completion: []};
+  for (const bad of [-1, 100, 101, 1.5, NaN, Infinity, true, null]) {
+    input.duration_policy.makeup_tolerance_ms = bad as number;
+    assert.throws(() => buildReport(input), /makeup tolerance/);
+  }
+  input.duration_policy.makeup_tolerance_ms = 15;
+  (input.duration_policy as typeof input.duration_policy & {operator_annotation: string}).operator_annotation =
+    'must not enter report output';
+  input.selection[0].active_intervals = [{start_ms:0,end_ms:85,evidence_ref:'solver:segment'}];
+  const dir = mkdtempSync(join(tmpdir(), 'duration-tolerance-'));
+  try {
+    const path = join(dir, 'input.json'), prefix = join(dir, 'report');
+    writeFileSync(path, JSON.stringify(input));
+    const run = spawnSync(process.execPath, ['--experimental-strip-types', resolve('scripts/benchmark-campaign-report.ts'), path, prefix], {encoding:'utf8'});
+    assert.equal(run.status, 0, run.stderr);
+    const actual = JSON.parse(readFileSync(prefix + '.json', 'utf8'));
+    assert.equal(actual.duration_policy.makeup_tolerance_ms, 15);
+    assert.deepEqual(actual.duration_policy, {
+      target_ms: 100,
+      allow_goal_completion: [],
+      makeup_tolerance_ms: 15,
+    });
+    assert.equal(actual.duration_coverage[0].disposition, 'within_tolerance');
+    assert.equal(actual.duration_coverage[0].remaining_ms, 15);
+    assert.match(readFileSync(prefix + '.md', 'utf8'), /容差内免补/);
+  } finally { rmSync(dir, {recursive: true, force: true}); }
+});
diff --git a/tests/control_plane_ts/collaboration_goal_instance_lifecycle.test.ts b/tests/control_plane_ts/collaboration_goal_instance_lifecycle.test.ts
index 2ac7ba80ca..3e326c3788 100644
--- a/tests/control_plane_ts/collaboration_goal_instance_lifecycle.test.ts
+++ b/tests/control_plane_ts/collaboration_goal_instance_lifecycle.test.ts
@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { decideCollaborationLifecycle, proveOriginalRequestDelivery } from "../../loopx/control_plane/collaboration/goal_instance_lifecycle.ts";
+import { decideCollaborationLifecycle, inspectOriginalRequestBatch, proveOriginalRequestDelivery } from "../../loopx/control_plane/collaboration/goal_instance_lifecycle.ts";
 
 const INSTANCE_A = "ginst_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 const INSTANCE_B = "ginst_bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ -263,3 +263,25 @@ test("readback observes a committed active request without permitting its result
     current_goal_ref: GOAL_B, initial_delivery: committedDelivery("failed"),
   })), { kind: "allow", mode: "historical_read", goal_ref: GOAL_A });
 });
+
+test("a bounded inspection batch keeps independent request refusals and order", () => {
+  for (const profile_id of [null, "source_session_v1"]) {
+    const valid = committedDelivery("running", profile_id !== null);
+    const conflict = { ...valid, turn: { ...valid.turn, context_handoff_receipt: {} } };
+    const wrongSource = { ...conflict, authorized_source_id: "web:other" };
+    const scope = { profile_id, caller_goal_ref: GOAL_A, current_goal_ref: GOAL_B };
+    const item = (initial_delivery: typeof valid) => ({
+      initial_delivery, record_goal_ref: GOAL_A, route_goal_ref: GOAL_A,
+    });
+    assert.deepEqual(inspectOriginalRequestBatch({
+      ...scope, items: [item(conflict), item(valid), item(wrongSource)],
+    }), {
+      items: [
+        { kind: "reject", code: "initial_delivery_unproved", delivery_proof_reason: "handoff_receipt_conflict" },
+        profile_id === null ? { kind: "legacy" } : { kind: "allow", mode: "historical_read", goal_ref: GOAL_A },
+        { kind: "reject", code: "initial_delivery_unproved" },
+      ],
+    });
+    assert.throws(() => inspectOriginalRequestBatch({ ...scope, items: Array(13).fill(item(valid)) }), /at most 12/);
+  }
+});
diff --git a/tests/control_plane_ts/goal_acceptance_authority.test.ts b/tests/control_plane_ts/goal_acceptance_authority.test.ts
index 9016695958..a491260cae 100644
--- a/tests/control_plane_ts/goal_acceptance_authority.test.ts
+++ b/tests/control_plane_ts/goal_acceptance_authority.test.ts
@@ -483,6 +483,34 @@ for (const provider of providers) {
     assert.equal((replacementHead.head.goal_acceptance as JsonObject).revision, 1);
     assert.equal(acceptanceWorkGuard(replacementHead.head, goal, "todo_first")?.allowed, true);
   });
+  test(`${provider}: Goal-only checks preserve local work and require independent verification`, options, async t => {
+    const store = await fixture(t, provider); await seed(store);
+    const doc = {...document(), scope: {kind: "goal"}, bindings: []};
+    assert.throws(() => normalizeGoalAcceptanceDocument({...doc, bindings: document().bindings}), /outside/);
+    const request = await configureRequest(store, {document: doc});
+    assert.equal((await configureGoalAcceptance(store, request)).status, "applied");
+    const before = (await head(store)).head;
+    assert.equal(projectGoalAcceptance(before, goal).status, "unverified");
+    assert.deepEqual(projectGoalAcceptance(before, goal).tasks, []);
+    for (const id of ["todo_first", "todo_second"]) {
+      assert.equal(acceptanceWorkGuard(before, goal, id), null);
+      assert.equal(acceptanceCompletionRequirements(before, goal, id), null);
+    }
+    await update(store, "todo_first", {done: true, status: "done", completion_continuation: "no_followup"});
+    assert.equal(projectGoalAcceptance((await head(store)).head, goal).status, "unverified",
+      "local completion cannot certify a Goal check");
+    const failed = await verifyRequest(store, {results: [
+      {criterion_id: "outcome", passed: false, exit_code: 1},
+      {criterion_id: "prerequisite", passed: true, exit_code: 0},
+    ]});
+    assert.equal((await commitGoalAcceptanceVerification(store, failed)).status, "applied");
+    assert.equal(projectGoalAcceptance((await head(store)).head, goal).status, "failed");
+    assert.equal((await commitGoalAcceptanceVerification(store, await verifyRequest(store))).status, "applied");
+    assert.equal(projectGoalAcceptance((await head(store)).head, goal).status, "accepted");
+    await update(store, "todo_new", todoFixtureRecord(todo("todo_new"), "native"));
+    assert.equal(acceptanceWorkGuard((await head(store)).head, goal, "todo_new"), null);
+    assert.equal(projectGoalAcceptance((await head(store)).head, goal).status, "accepted");
+  });
   test(`${provider}: selected work isolates admission and verification without weakening its own guard`, options, async t => {
     const store = await fixture(t, provider); await seed(store);
     const doc = {...document(), scope: {kind: "selected_work", todo_ids: ["todo_first"]},
diff --git a/tests/control_plane_ts/inbox_read_transaction.test.ts b/tests/control_plane_ts/inbox_read_transaction.test.ts
index c9ea35acf2..64023d378e 100644
--- a/tests/control_plane_ts/inbox_read_transaction.test.ts
+++ b/tests/control_plane_ts/inbox_read_transaction.test.ts
@@ -141,6 +141,15 @@ for (const bytes of [Buffer.from("\ufeff{}"), Buffer.from([0xff]), Buffer.alloc(
   });
 }
 
+test("a valid record at the byte limit retains its complete content", async t => {
+  const f = fixture(t), request = f.publish(1);
+  const path = join(f.folder, request.request_id + ".json");
+  const original = readFileSync(path);
+  writeFileSync(path, Buffer.concat([original, Buffer.alloc(128_000 - original.length, 32)]));
+  const result = (await f.call("pending", {request_id: request.request_id})).result as JsonObject;
+  assert.equal((result.items as JsonObject[])[0].message, request.message);
+});
+
 test("malformed receipts retain the request and recovery advice", async t => {
   const f = fixture(t), request = f.publish(1);
   mkdirSync(join(f.base, "decisions"));
diff --git a/tests/control_plane_ts/quota_settlement_readback.test.ts b/tests/control_plane_ts/quota_settlement_readback.test.ts
index 8d743616ec..37d0016a0a 100644
--- a/tests/control_plane_ts/quota_settlement_readback.test.ts
+++ b/tests/control_plane_ts/quota_settlement_readback.test.ts
@@ -594,6 +594,17 @@ test("settlement progress requires both effects and exact receipts", async t =>
         }
       }
       assert.deepEqual(controls, expected, "Pending recovery and all controls/receipts retain complete parity");
+      const precheck = await readQuotaSettlement(request(root, {spend_precheck: true}));
+      const settlement = requireJsonObject(result.settlement, "full settlement bundle");
+      const outcome = requireJsonObject(settlement.result, "full settlement result");
+      assert.deepEqual(precheck, {
+        schema_version: result.schema_version,
+        found: true,
+        identity: result.identity,
+        settlement: {...settlement, result: {...outcome, value: null}},
+        progress: result.progress,
+        spend_run_present: entry.spend === true,
+      });
       await assert.rejects(readQuotaSettlement(request(root, {include_record_bodies: "false"})), /must be a boolean/);
     } finally { await rm(root, { recursive: true, force: true }); }
   });
diff --git a/tests/control_plane_ts/yardstick_decision.test.ts b/tests/control_plane_ts/yardstick_decision.test.ts
index f63a665c61..2b406e6e08 100644
--- a/tests/control_plane_ts/yardstick_decision.test.ts
+++ b/tests/control_plane_ts/yardstick_decision.test.ts
@@ -4,6 +4,7 @@ import {normalizeWorkYardstickDecision, normalizeWorkYardstickCapture,
   validateWorkYardstickContinuation, projectWorkYardstickCue} from "../../loopx/control_plane/work_items/yardstick_decision.ts";
 import {normalizeExploreResultAttachment} from "../../loopx/control_plane/capabilities/explore_result_writeback.ts";
 import {projectExploreTurnContext} from "../../loopx/control_plane/capabilities/explore_turn_context.ts";
+import {projectExploreMeasurementFeedback} from "../../loopx/control_plane/capabilities/explore_measurements.ts";
 
 const authoritative = {metric: "quality", unit: "points", higher_is_better: true,
   comparison_scope: "validation:fixed", input_revision: "inputs-v1", evaluation_ref: "evaluator:outcome-v1"};
@@ -53,6 +54,54 @@ test("a late replay cannot replace a newer committed choice; exact profiles sele
   assert.equal(Object.hasOwn(cue, "fidelity_validated"), false);
 });
 
+test("goal and proxy join the same two candidates regardless of declared order and metric direction", () => {
+  const timeProxy = {...proxy, higher_is_better: false, unit: "seconds"};
+  const measured = {...finding, work_yardstick: {binding, decision: {...decision, proxy: timeProxy}}, measurements: [
+    {...authoritative, value: 0, candidate_ref: "candidate:a", evidence_ref: "result:goal-a"},
+    {...authoritative, value: 3, candidate_ref: "candidate:b", evidence_ref: "result:goal-b"},
+    {...timeProxy, value: 4, candidate_ref: "candidate:b", evidence_ref: "result:screen-b"},
+    {...timeProxy, value: 2, candidate_ref: "candidate:a", evidence_ref: "result:screen-a"},
+  ]};
+  const project = (row = measured) => projectWorkYardstickCue({...binding, enabled: true, findings: [row],
+    measurement_feedback: projectExploreMeasurementFeedback([row])})!.search_comparison;
+  const result = project();
+  assert.equal(result.goal.preferred_candidate_ref, "candidate:b");
+  assert.equal(result.goal.previous_best.value, 0);
+  assert.equal(result.proxy.preferred_candidate_ref, "candidate:a");
+  assert.equal(result.proxy.latest.evidence_ref, "result:screen-a");
+  assert.equal(result.proxy_order_reversed, true);
+  assert.match(result.guidance, /comparison base when available/);
+  assert.match(result.guidance, /continuing, a different mechanism or a compatible combination/);
+
+  const observations = (changeIndex: number, changed: object) => ({...measured,
+    measurements: measured.measurements.map((row, index) => index === changeIndex ? {...row, ...changed} : row)});
+  assert.equal(project(observations(1, {value: null})), undefined);
+  assert.equal(project(observations(1, {evaluation_ref: "evaluator:other"})), undefined);
+  assert.equal(project(observations(2, {candidate_ref: "candidate:unrelated"})).proxy, undefined);
+  assert.equal(project(observations(2, {comparison_scope: "validation:other"})).proxy, undefined);
+  assert.equal(project(observations(2, {input_revision: "other-inputs"})).proxy, undefined);
+
+  const cap = project({...measured, measurements: measured.measurements.map((row, index) =>
+    index < 2 ? {...row, value: 10} : row)});
+  assert.equal(cap.goal.preferred_candidate_ref, null);
+  assert.equal(cap.proxy_order_reversed, false);
+  assert.match(cap.guidance, /goal results tie under this scope/);
+  const repeat = {...measured, finding_id: "later-retest", recorded_order: 2,
+    measurements: [{...measured.measurements[1]!, value: 3}]};
+  const sameCandidate = projectWorkYardstickCue({...binding, enabled: true, findings: [repeat, measured],
+    measurement_feedback: projectExploreMeasurementFeedback([repeat, measured])})!;
+  assert.equal(sameCandidate.search_comparison, undefined);
+
+  for (const other of [{...binding, goal_id: "other"}, {...binding, agent_id: "peer"}, {...binding, todo_id: "todo_other"}]) {
+    const foreign = {...repeat, work_yardstick: {...repeat.work_yardstick, binding: other},
+      measurements: [{...repeat.measurements[0]!, candidate_ref: "candidate:foreign", value: 99}]};
+    const shared = projectWorkYardstickCue({...binding, enabled: true, findings: [foreign, measured],
+      measurement_feedback: projectExploreMeasurementFeedback([foreign, measured])})!;
+    assert.equal(shared.source_finding_id, measured.finding_id);
+    assert.deepEqual(shared.search_comparison, result);
+  }
+});
+
 test("only strictly older committed replay preserves a stale predecessor as history", () => {
   const params = {enabled: true, decision, binding, findings: [finding]};
   assert.deepEqual(validateWorkYardstickContinuation({...params,
diff --git a/tests/test_cli_entrypoint.py b/tests/test_cli_entrypoint.py
index 7e33ef3070..128b8ebf2f 100644
--- a/tests/test_cli_entrypoint.py
+++ b/tests/test_cli_entrypoint.py
@@ -331,17 +331,89 @@ def test_version_flag_skips_full_cli_import() -> None:
     assert completed.returncode == 0, completed.stderr
 
 
-def test_other_arguments_delegate_to_full_cli() -> None:
+@pytest.mark.parametrize("arguments", [
+    ["version"],
+    ["--format", "json", "version"],
+    ["version", "--format", "json"],
+    ["--format=markdown", "version", "--format=json"],
+    ["--format=json", "version", "--format=markdown"],
+    ["--registry", "missing-registry.json", "--runtime-root", "missing-runtime",
+     "--cli-bin", "fixture-loopx", "version", "--format", "json"],
+    ["--format", "markdown", "--format", "json", "version"],
+])
+def test_version_command_uses_its_selected_owner(arguments: list[str]) -> None:
+    completed = run_cli_main(
+        "loopx.entrypoint", arguments,
+        forbidden_modules=("loopx.cli", "loopx.chat_manager", "loopx.control_plane.effect_runtime"),
+        environment={"LOOPX_USAGE_PING": "0"},
+    )
+    assert completed.returncode == 0, completed.stderr
+    from loopx import __version__
+
+    if arguments[-1] == "--format=markdown" or arguments == ["version"]:
+        assert completed.stdout == f"loopx {__version__}\n\n"
+    else:
+        assert json.loads(completed.stdout) == {
+            "ok": True, "schema_version": "loopx_version_v0",
+            "name": "loopx", "version": __version__,
+        }
+
+
+def test_version_command_retains_full_cli_diagnostics() -> None:
+    arguments = [
+        ["version", "--help"], ["version", "-h"],
+        ["version", "--unknown-option"], ["version", "--format", "yaml"],
+        ["version", "--format"], ["version", "--format="],
+        ["--format", "yaml", "version"], ["--format", "", "version"],
+        ["--format", "version"], ["--format", "json", "version", "extra"],
+        ["--cli-bin", "", "version"], ["--registry", "version"],
+        ["--for", "json", "version"], ["version", "--for", "json"],
+        ["version", "--registry", "missing.json"], ["version", "--version"],
+        ["--version", "version"], ["--", "version"],
+    ]
+    assert run_cli_batch("loopx.entrypoint", arguments) == run_cli_batch("loopx.cli", arguments)
+
+
+def test_version_command_retains_explicit_full_cli_patch_points() -> None:
     script = """
+from loopx import cli
 from loopx.entrypoint import main
+from loopx.cli_commands.version import register_version_command
 
-raise SystemExit(main(["--format", "json", "version"]))
+assert cli.register_version_command is register_version_command
+seen = []
+def patched(args, **kwargs):
+    seen.append(args.command)
+    return 37
+cli.handle_version_command = patched
+assert main(["version"]) == 37
+assert seen == ["version"]
 """
-    completed = run_isolated_script(script)
+    completed = run_isolated_script(script, environment={"LOOPX_USAGE_PING": "0"})
+    assert completed.returncode == 0, completed.stderr
+
 
+def test_version_command_retains_explicit_package_export_patch_points() -> None:
+    script = """
+from loopx import cli_commands
+from loopx.cli_commands import handle_version_command, register_version_command
+from loopx.entrypoint import main
+
+assert cli_commands.handle_version_command is handle_version_command
+seen = []
+def register(*args, **kwargs):
+    seen.append("register")
+    return register_version_command(*args, **kwargs)
+def patched(args, **kwargs):
+    seen.append(args.command)
+    return 37
+cli_commands.register_version_command = register
+cli_commands.handle_version_command = patched
+assert main(["version"]) == 37
+assert seen == ["register", "version"]
+"""
+    completed = run_isolated_script(script, environment={"LOOPX_USAGE_PING": "0"})
     assert completed.returncode == 0, completed.stderr
-    payload = json.loads(completed.stdout)
-    assert payload["schema_version"] == "loopx_version_v0"
 
 
 def test_top_level_help_skips_full_cli_import() -> None:
@@ -1785,3 +1857,184 @@ def test_global_read_preserves_empty_coverage_without_loading_full_cli(tmp_path,
 		assert payload["coverage"]["complete"] is False
 		assert payload["goals"] == []
 	assert registry.read_bytes() == before
+
+
+@pytest.mark.parametrize("arguments", [
+	["--help"], ["--evidence-ref", "absent", "--help"],
+	["repair-index-duplicates", "--help"],
+])
+def test_history_help_loads_only_its_reader(arguments):
+	result = run_cli_main("loopx.entrypoint", ["history", *arguments],
+		forbidden_modules=("loopx.cli", "loopx.chat_server",
+			"loopx.cli_commands.benchmark_dispatch"),
+		environment={"PATH": ""})
+	assert result.returncode == 0, result.stderr
+	assert "--evidence-ref" in result.stdout
+	assert "--agent-id" in result.stdout
+	assert result.stderr == ""
+
+
+@pytest.mark.parametrize("format_name", ["json", "markdown"])
+@pytest.mark.parametrize("limit", [-1, 0, 1, 10])
+def test_history_reader_preserves_scope_chronology_and_limits(tmp_path, format_name, limit):
+	registry, runtime = write_command_fixture(tmp_path)
+	index = runtime / "goals/perf-goal/runs/index.jsonl"
+	index.parent.mkdir(parents=True)
+	rows = [
+		{"goal_id": "perf-goal", "agent_id": "perf-agent",
+		 "generated_at": "2026-08-19T00:30:00+08:00", "classification": "offset-earlier"},
+		{"goal_id": "perf-goal", "agent_id": "perf-agent",
+		 "generated_at": "2026-08-18T17:00:00Z", "classification": "utc-later"},
+		{"goal_id": "perf-goal", "agent_id": "other-agent",
+		 "generated_at": "2026-08-18T18:00:00Z", "classification": "other-lane"},
+	]
+	index.write_text("".join(json.dumps(row) + "\n" for row in rows))
+	before = {p: p.read_bytes() for p in tmp_path.rglob("*") if p.is_file()}
+	argv = ["--registry=" + str(registry), "--runtime-root=" + str(runtime),
+		"--cli-bin", "loopx", "--format", format_name, "history",
+		"--goal-id", "perf-goal", "--agent-id", "perf-agent", "--limit", str(limit)]
+	selected = run_cli_main("loopx.entrypoint", argv, forbidden_modules=("loopx.cli",))
+	full = run_cli_main("loopx.cli", argv)
+	assert selected.returncode == full.returncode == 0, (selected.stderr, full.stderr)
+	assert selected.stdout == full.stdout
+	assert selected.stderr == full.stderr == ""
+	assert "other-lane" not in selected.stdout
+	if format_name == "json":
+		payload = json.loads(selected.stdout)
+		expected = ["utc-later", "offset-earlier"][:max(0, limit)]
+		assert [row["classification"] for row in payload["runs"]] == expected
+		assert [row["classification"] for row in payload["goals"][0]["latest_runs"]] == expected
+	assert {p: p.read_bytes() for p in tmp_path.rglob("*") if p.is_file()} == before
+
+
+def test_history_reader_retains_required_native_runtime_failure(tmp_path):
+	registry, runtime = write_command_fixture(tmp_path)
+	index = runtime / "goals/perf-goal/runs/index.jsonl"
+	index.parent.mkdir(parents=True)
+	index.write_text(json.dumps({"goal_id": "perf-goal", "agent_id": "perf-agent",
+		"generated_at": "2026-08-18T17:00:00Z", "classification": "bounded_probe"}) + "\n")
+	argv = ["--registry", str(registry), "--runtime-root", str(runtime),
+		"--format", "json", "history", "--goal-id", "perf-goal"]
+	temporary = tmp_path / "no-node-runtime"
+	temporary.mkdir()
+	environment = {"PATH": "", **{key: str(temporary) for key in ("TMPDIR", "TEMP", "TMP")}}
+	selected = run_cli_main("loopx.entrypoint", argv, forbidden_modules=("loopx.cli",),
+		environment=environment)
+	full = run_cli_main("loopx.cli", argv, environment=environment)
+	assert selected.returncode == full.returncode == 1
+	assert selected.stdout == full.stdout
+	assert selected.stderr == full.stderr == ""
+	assert json.loads(selected.stdout)["error"] == "LoopX Effect runtime requires Node.js 22.22.3 or newer on PATH"
+
+
+@pytest.mark.parametrize("case", ["current", "other-agent", "stale", "no-node"])
+def test_history_reader_preserves_native_evidence_reference_window(tmp_path, case):
+	from loopx.control_plane.work_items.replan_context_codec import project_replan_context
+
+	registry, runtime = write_command_fixture(tmp_path)
+	index = runtime / "goals/perf-goal/runs/index.jsonl"
+	index.parent.mkdir(parents=True)
+	observation = "Keep independent failure evidence.\nPreserve the next decision's constraint."
+	index.write_text(json.dumps({"goal_id": "perf-goal", "agent_id": "perf-agent",
+		"generated_at": "2026-08-18T17:00:00Z", "classification": "bounded_probe",
+		"health_check": observation}) + "\n")
+	context = project_replan_context(goal_id="perf-goal", agent_id="perf-agent", runs=(),
+		source_status={"registry": str(registry), "runtime_root": str(runtime),
+			"run_history": {"goals": []}})
+	argv = ["--registry", str(registry), "--runtime-root", str(runtime),
+		"--format", "json", "history", "--goal-id", "perf-goal", "--agent-id",
+		"other-agent" if case == "other-agent" else "perf-agent",
+		"--evidence-ref", context["evidence"][0]["evidence_ref"], "--limit", "0"]
+	if case == "stale":
+		index.write_text("")
+	before = index.read_bytes()
+	environment = None
+	if case == "no-node":
+		temporary = tmp_path / "no-node-runtime"
+		temporary.mkdir()
+		environment = {"PATH": "", **{key: str(temporary) for key in ("TMPDIR", "TEMP", "TMP")}}
+	selected = run_cli_main("loopx.entrypoint", argv, forbidden_modules=("loopx.cli",),
+		environment=environment)
+	full = run_cli_main("loopx.cli", argv, environment=environment)
+	assert selected.returncode == full.returncode == (0 if case == "current" else 1)
+	assert selected.stdout == full.stdout
+	assert selected.stderr == full.stderr == ""
+	payload = json.loads(selected.stdout)
+	if case == "current":
+		assert payload["evidence"]["health_check"] == observation
+	elif case == "no-node":
+		assert "requires Node.js" in payload["error"]
+	else:
+		assert "unavailable" in payload["error"]
+	assert index.read_bytes() == before
+
+
+def test_history_reader_keeps_complete_parser_diagnostics():
+	cases = [
+		["history", "unknown-action"], ["history", "--unknown"],
+		["history", "--agent-i", "agent"], ["history", "--evidence-ref"],
+		["history", "--limit", "invalid"], ["history", "--format", "json"],
+		["--format", "unknown", "history"], ["--cli-bin", "", "history"],
+		["--registry", "history"], ["--runtime-root", "history"],
+	]
+	selected, full = run_cli_batch("loopx.entrypoint", cases), run_cli_batch("loopx.cli", cases)
+	assert selected == full
+	assert all(result["returncode"] == 2 and not result["stdout"] for result in selected)
+
+
+@pytest.mark.parametrize("arguments,error", [
+	(["--agent-id", "perf-agent"], "--agent-id requires --goal-id without a history action"),
+	(["--evidence-ref", "absent", "--goal-id", "perf-goal"],
+	 "--evidence-ref requires --goal-id and --agent-id without a history action"),
+])
+def test_history_reader_validation_refusals_match_full_cli(tmp_path, arguments, error):
+	argv = ["--registry", str(tmp_path / "missing.json"), "--format", "json", "history", *arguments]
+	selected = run_cli_main("loopx.entrypoint", argv, forbidden_modules=("loopx.cli",))
+	full = run_cli_main("loopx.cli", argv)
+	assert selected.returncode == full.returncode == 1
+	assert selected.stdout == full.stdout
+	assert selected.stderr == full.stderr == ""
+	assert json.loads(selected.stdout) == {"ok": False, "error": error}
+	assert not list(tmp_path.iterdir())
+
+
+@pytest.mark.parametrize("action", [
+	None, "inspect-index-duplicates", "repair-index-duplicates",
+	"rebuild-index-collisions", "trajectory-hygiene",
+])
+def test_history_maintenance_and_explicit_full_cli_keep_patch_points(tmp_path, action):
+	arguments = ["history", *([action] if action else []), "--goal-id", "perf-goal"]
+	# Direct full-CLI bindings retain their handler even for ordinary reads.
+	module = "loopx.entrypoint" if action else "loopx.cli"
+	script = f"""
+import loopx.cli as full
+from {module} import main
+seen = []
+def original_path(args, **kwargs):
+    seen.append((args.history_action, args.goal_id))
+    return 73
+full.handle_history_command = original_path
+assert main(["--registry", {str(tmp_path / 'absent.json')!r}, *{arguments!r}]) == 73
+assert seen == [({action!r}, "perf-goal")]
+"""
+	result = run_isolated_script(script)
+	assert result.returncode == 0, result.stderr
+	assert not list(tmp_path.iterdir())
+
+
+def test_history_entrypoint_retains_preloaded_full_cli_handler(tmp_path):
+	script = f"""
+import loopx.cli as full
+from loopx.entrypoint import main
+seen = []
+def original_path(args, **kwargs):
+    seen.append((args.history_action, args.goal_id))
+    return 73
+full.handle_history_command = original_path
+assert main(["--registry", {str(tmp_path / 'absent.json')!r},
+             "history", "--goal-id", "perf-goal"]) == 73
+assert seen == [(None, "perf-goal")]
+"""
+	result = run_isolated_script(script)
+	assert result.returncode == 0, result.stderr
+	assert not list(tmp_path.iterdir())
diff --git a/tests/test_loopx_turn_driver.py b/tests/test_loopx_turn_driver.py
index e5c1047393..8527b5637a 100644
--- a/tests/test_loopx_turn_driver.py
+++ b/tests/test_loopx_turn_driver.py
@@ -1821,35 +1821,42 @@ def recording_collect_status(*args: Any, **kwargs: Any) -> dict[str, Any]:
     )
 
 
+@pytest.mark.parametrize("provider", ("file", "sqlite"))
 def test_turn_cli_projects_explicit_fresh_iteration_context(
-    tmp_path: Path,
+    tmp_path: Path, provider: str,
 ) -> None:
-    project, runtime, registry = _write_live_fixture(tmp_path)
-    output = io.StringIO()
-
-    with contextlib.redirect_stdout(output):
-        exit_code = cli_main(
-            [
-                "--registry",
-                str(registry),
-                "--runtime-root",
-                str(runtime),
-                "--format",
-                "json",
-                "turn",
-                "plan",
-                "--goal-id",
-                "loopx-turn-fixture",
-                "--agent-id",
-                "codex-fixture",
-                "--iteration-context",
-                "fresh",
-                "--include-transaction-detail",
-            ]
-        )
+    _, runtime, registry = _write_live_fixture(tmp_path, provider=provider)
+    # Use the CLI entrypoint in a fresh process. In-process
+    # callers and test collection may already have selected these providers.
+    process = subprocess.run(
+        [
+            sys.executable, "-c", "\n".join((
+                "import sys",
+                "from loopx.entrypoint import main",
+                "status = main(sys.argv[1:])",
+                "unselected = {'loopx.capabilities.semantic_preference.contract',",
+                "              'loopx.capabilities.semantic_preference.reward_memory'}",
+                "assert not unselected & sys.modules.keys(), unselected & sys.modules.keys()",
+                "raise SystemExit(status)",
+            )),
+            "--registry", str(registry),
+            "--runtime-root", str(runtime),
+            "--format", "json",
+            "turn", "plan",
+            "--goal-id", "loopx-turn-fixture",
+            "--agent-id", "codex-fixture",
+            "--iteration-context", "fresh",
+            "--include-transaction-detail",
+        ],
+        cwd=Path(__file__).resolve().parents[1],
+        env={**os.environ, "LOOPX_USAGE_PING": "0"},
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
 
-    payload = json.loads(output.getvalue())
-    assert exit_code == 0, payload
+    assert process.returncode == 0, process.stdout + process.stderr
+    payload = json.loads(process.stdout)
     assert payload["session"]["action"] == "start_new"
     assert payload["session"]["context_policy"] == {
         "schema_version": "loopx_iteration_context_policy_v0",
diff --git a/tests/test_process_runtime_loading.py b/tests/test_process_runtime_loading.py
new file mode 100644
index 0000000000..ca185761d2
--- /dev/null
+++ b/tests/test_process_runtime_loading.py
@@ -0,0 +1,186 @@
+"""Existing transport exports stay compatible while pure callers stay cold."""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import textwrap
+
+import pytest
+
+# Existing caller reexports, not a new transport API or state vocabulary.
+CALLERS = {
+    "loopx.doctor_git": ("terminate_process_tree",),
+    "loopx.contract": ("terminate_process_tree",),
+    "loopx.control_plane.runtime.validation_command": ("terminate_process_tree",),
+    "loopx.control_plane.turn_driver.host_bridge_transport": (
+        "force_terminate_process", "write_process_stdin_before_deadline",
+    ),
+}
+
+
+def _run(code: str) -> None:
+    completed = subprocess.run(
+        [sys.executable, "-c", textwrap.dedent(code)],
+        env={**os.environ, "PYTHONDONTWRITEBYTECODE": "1", "LOOPX_USAGE_PING": "0"},
+        capture_output=True, text=True, timeout=30,
+    )
+    assert completed.returncode == 0, completed.stderr
+
+
+@pytest.mark.parametrize("module_name", CALLERS)
+def test_pure_caller_import_leaves_process_transport_unselected(module_name: str) -> None:
+    _run(rf"""
+        import importlib, sys
+        effects = []
+        sys.addaudithook(lambda event, args: effects.append(event)
+            if event in ('subprocess.Popen', 'socket.connect') else None)
+        module = importlib.import_module({module_name!r})
+        assert 'loopx.extensions.process_runtime' not in sys.modules
+        assert set({CALLERS[module_name]!r}) <= set(dir(module))
+        assert effects == []
+        try:
+            getattr(module, 'missing_transport_export')
+        except AttributeError:
+            pass
+        else:
+            raise AssertionError('unknown attribute accepted')
+        assert 'loopx.extensions.process_runtime' not in sys.modules
+    """)
+
+
+@pytest.mark.parametrize("module_name", CALLERS)
+@pytest.mark.parametrize("mode", ["attribute", "from", "star"])
+def test_explicit_transport_export_is_original_function(module_name: str, mode: str) -> None:
+    _run(rf"""
+        import importlib, inspect
+        module = importlib.import_module({module_name!r})
+        names = {CALLERS[module_name]!r}
+        namespace = {{}}
+        if {mode!r} == 'from':
+            exec('from {module_name} import ' + ', '.join(names), namespace)
+        elif {mode!r} == 'star':
+            exec('from {module_name} import *', namespace)
+        else:
+            namespace.update((name, getattr(module, name)) for name in names)
+        owner = importlib.import_module('loopx.extensions.process_runtime')
+        for name in names:
+            value = namespace[name]
+            assert value is getattr(owner, name)
+            assert value is getattr(module, name)
+            assert inspect.signature(value) == inspect.signature(getattr(owner, name))
+        if {mode!r} == 'star':
+            assert {{name for name in namespace if not name.startswith('_')}} == {{
+                name for name in dir(module) if not name.startswith('_')}}
+    """)
+
+
+@pytest.mark.parametrize("module_name", CALLERS)
+def test_preloaded_owner_preserves_import_time_binding(module_name: str) -> None:
+    _run(rf"""
+        import importlib
+        owner = importlib.import_module('loopx.extensions.process_runtime')
+        names = {CALLERS[module_name]!r}
+        def before(*args, **kwargs): pass
+        def after(*args, **kwargs): pass
+        for name in names:
+            setattr(owner, name, before)
+        module = importlib.import_module({module_name!r})
+        for name in names:
+            setattr(owner, name, after)
+            assert getattr(module, name) is before
+    """)
+
+
+@pytest.mark.parametrize("module_name", CALLERS)
+def test_caller_patch_points_remain_internal_bindings(module_name: str) -> None:
+    _run(rf"""
+        import importlib, io, time
+        from pathlib import Path
+        module = importlib.import_module({module_name!r})
+        names = {CALLERS[module_name]!r}
+        calls = []
+        def patched(*args, **kwargs):
+            calls.append((args, kwargs))
+        for name in names:
+            setattr(module, name, patched)
+        class Process:
+            stdout = io.StringIO()
+            stderr = io.StringIO()
+            returncode = 0
+            def __enter__(self): return self
+            def __exit__(self, *args): pass
+            def wait(self, **kwargs): return 0
+            def poll(self): return 0
+            def communicate(self, **kwargs): raise KeyboardInterrupt()
+        process = Process()
+        if {module_name!r} in ('loopx.doctor_git', 'loopx.contract'):
+            module._retire_owned_probe(process)
+            assert calls == [((process,), {{'grace_seconds': 0.2}})]
+        elif {module_name!r}.endswith('validation_command'):
+            module.subprocess.Popen = lambda *args, **kwargs: process
+            try:
+                module.run_caller_validation(Path.cwd(), validation_argv=['fixture'],
+                    validation_label='fixture', timeout_seconds=1)
+            except KeyboardInterrupt:
+                pass
+            else:
+                raise AssertionError('cancellation lost')
+            assert calls == [((process,), {{'grace_seconds': 0}})]
+        else:
+            process.stdout = io.StringIO('{{"kind":"ready"}}\n')
+            bridge = module.GuardedHostBridge(process,
+                deadline=time.monotonic()+2, cleanup_timeout=1)
+            try:
+                bridge.send('fixture\n')
+                assert calls[0][0] == (process, 'fixture\n')
+                assert calls[0][1]['cancel_and_reap'] == bridge.cancel
+            finally:
+                bridge.close_output()
+            calls.clear()
+            process.stdout = io.StringIO()
+            bridge = module.GuardedHostBridge(process,
+                deadline=time.monotonic()+2, cleanup_timeout=1)
+            try:
+                bridge.cancel()
+                assert calls == [((process,), {{'process_tree_owned': True}})]
+                assert bridge.not_launched
+            finally:
+                bridge.close_output()
+    """)
+
+
+@pytest.mark.parametrize("module_name", CALLERS)
+def test_first_export_binds_the_original_owner_bundle(module_name: str) -> None:
+    _run(f"""
+        import importlib
+        module = importlib.import_module({module_name!r})
+        names = {CALLERS[module_name]!r}
+        first = getattr(module, names[0])
+        owner = importlib.import_module('loopx.extensions.process_runtime')
+        originals = {{name: getattr(owner, name) for name in names}}
+        def replacement(*args, **kwargs): pass
+        for name in names:
+            setattr(owner, name, replacement)
+            assert getattr(module, name) is originals[name]
+        assert first is originals[names[0]]
+    """)
+
+
+@pytest.mark.parametrize("module_name", CALLERS)
+def test_reload_rebinds_exports_from_the_selected_owner(module_name: str) -> None:
+    _run(f"""
+        import importlib
+        module = importlib.import_module({module_name!r})
+        names = {CALLERS[module_name]!r}
+        getattr(module, names[0])
+        owner = importlib.import_module('loopx.extensions.process_runtime')
+        def owner_patch(*args, **kwargs): pass
+        def caller_patch(*args, **kwargs): pass
+        for name in names:
+            setattr(owner, name, owner_patch)
+            setattr(module, name, caller_patch)
+        importlib.reload(module)
+        for name in names:
+            assert getattr(module, name) is owner_patch
+    """)