@awak-app/simy-cli 0.7.4 → 0.7.6

package/README.md

@@ -1027,6 +1027,17 @@ recovery operations do not switch identity automatically. The private
 
 自律判断の改定方針と人間判断候補の一覧: [AI判断を基本にする改定](docs/ai-decision-policy.md)。LLMの文脈理解・推論・調査を基本にし、HC-01〜HC-102を判断の批判視点として適用します。
 
+### Explicit local re-delegation of legacy Codex tasks
+
+After the user explicitly delegates again, `simy delivery redelegate-native
+--provider codex --session ID --task-id ID --consent-ref REF` records current
+native local edit/test authority for that exact legacy task. The reference identifies
+the user's new instruction. It does not reconstruct historical enrollment, resume
+stopped tasks, change the execution directory, reset budgets, or grant network or
+connector use. Current native rights are still checked before each worker dispatch.
+An active lease, pending approval, changed task or provider connection prevents
+application. Resolve an actual dependency only after the new receipt is stored.
+
 ### Local autonomous recovery (0.6.25)
 
 `simy delivery runtime install` pins a hash-verified snapshot. `runtime desktop-install`
@@ -1064,6 +1075,42 @@ recorded; an audit receipt does not complete a task. SQM evidence stays bound to
 repository/commit/diff scope and does not prove the whole user outcome. Git output
 no longer uses a 10 MiB `execFile` buffer; the full diff is still retained in memory.
 
+Routine purpose alignment asks the existing independent AI for a short natural
+language opinion using the conversation and available work. The working LLM weighs
+it against the user's purpose, adopts useful parts, disagrees or tries a small
+reversible experiment, then continues. Uncertainty and disagreement do not require
+consensus, a decision log, extra forms or human arbitration. Only the latest opinion
+is retained; delivering it closes the consultation request without a worker reply.
+Advice supplies neither acceptance evidence nor permission. Actual completion and
+known outcome gaps retain the independent verification path.
+
+For enrolled purpose-v2 tasks with `decisionPolicy:llm-first-hc102`, ordinary
+reasoning is now optional: `purposeReview` can be omitted, a short natural-language
+note, or an object with `thinking`. Existing structured reports still work. The
+worker chooses useful perspectives for the situation; there is no per-checkpoint
+hypothesis/refutation/observation/ranking quota. Missing observations are retained
+as unverified, not fabricated. An unobserved write goes to automatic read-only
+reconciliation before another effect; missing reasoning notes alone do not stop
+a valid next plan. Original acceptance, known failed obligations, provider
+permissions, user stops and total budgets remain enforced. The v1 contract is
+unchanged. Existing enrolled v2 records need no restart or replacement for this
+parser change; installing this code does not resume a stopped task.
+
+Reproduce the prototype locally (no provider call or existing task mutation):
+
+```bash
+npm run test:e2e:flexible-delivery
+```
+
+It runs the real controller and temporary filesystem through missing observations
+→ investigation → implementation → separate verification, an uncertain write,
+an unmet review returning to repair, and an explicit user stop. Worker/reviewer
+responses in this deterministic demo are scripted. For an opt-in real Codex trial
+in a new disposable conversation, use
+`node scripts/purpose-search-live-e2e.js --run --max-minutes=4`.
+That trial reports actual checkpoints and completion separately; the automated
+demo is not proof of uninterrupted operation in the installed desktop host.
+
 If a later audit finds unmet work while an earlier review was waiting only for
 human acceptance, the controller reopens independent inspection of the durable
 findings. Confirmed gaps return to diagnosis, authorized repair and reinspection;
@@ -1071,6 +1118,10 @@ incorrect findings need captured counterevidence to be refuted. Restarting the h
 retains this handoff, task identity and budgets. Actual human acceptance is never
 supplied by the repair loop, and unresolved native permissions are preserved.
 
+Outcome audits and recovery workers serialize their access to a task. Full outcome inspection has a finite five-minute default deadline, brief peer opinions two minutes; both respect the original task deadline. Failed inspections wait from settlement time before retrying, and worker progress alone does not reset that backoff. Independent JSON evidence ignores formatting whitespace only and must retain complete scalar values.
+
+Owned-worker Git commits require the checkout’s administrative paths to be explicitly allowed by both the original frozen and current native sandbox policies (or full access in each). Implicit workspace access does not grant Git-metadata writes.
+
 Codex cold recovery and independent audit are supported. Claude retains its
 original live-hook boundary; cold recovery and detached independent audit are not
 implemented in this release and are exposed as a capability gap. Neither an

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -51,6 +51,7 @@
     "build:macos-installer:production": "bash packaging/build-macos-arm64.sh --production",
     "test:e2e:claude-parity": "node ./scripts/claude-parity-runtime-e2e.js",
     "test:e2e:claude-plugin": "node ./scripts/claude-plugin-runtime-e2e.js",
+    "test:e2e:flexible-delivery": "node --test --test-name-pattern=\"flexible prototype\" test/purpose-search.test.js",
     "test:e2e:sqm-faults": "node ./scripts/sqm-complete-loop-e2e.js"
   },
   "engines": {

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.7.4";
+export const CLI_VERSION = "0.7.6";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/codex-plugins/simy/hooks/consistency-handoff.mjs

@@ -18,14 +18,14 @@ export function recordHandoffStage(item, stage, now, details = {}) {
 export function handoffHealth(managed, now) {
   const requests = managed?.consistencyOutbox || [];
   const busy = Boolean(managed?.resumeLease || managed?.liveWorkspaceLease || managed?.outcomeAudit?.lease);
-  return requests.filter(item => !['resolved', 'superseded'].includes(item.stage)).map(item => ({
+  return requests.filter(item => !item.advisory && !['resolved', 'superseded'].includes(item.stage)).map(item => ({
     id: item.id, owner: item.owner || 'task_controller', stage: item.stage,
     overdue: !busy && now >= (item.dueAt || (item.observedAt || item.receivedAt || item.createdAt || now) + HANDOFF_PROGRESS_MS),
     ageMs: Math.max(0, now - (item.createdAt || now)), effectDecisionId: item.decisionId || null,
   }));
 }
 export function handoffMetrics(records, now) {
-  const requests = records.flatMap(r => r.run?.managed?.consistencyOutbox || []);
+  const requests = records.flatMap(r => r.run?.managed?.consistencyOutbox || []).filter(item => !item.advisory);
   const resolved = requests.filter(r => r.stage === 'resolved' && Number.isFinite(r.verifiedAt) && Number.isFinite(r.createdAt));
   const audits = records.map(r => r.run?.managed?.outcomeAudit).filter(Boolean);
   return { pendingHandoffs: requests.filter(r => !['resolved', 'superseded'].includes(r.stage)).length,

package/src/codex-plugins/simy/hooks/delivery-loop.mjs

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { MAX_STATE_BYTES } from './state-limits.mjs';
+import { rememberPerspectives, perspectiveScope, recallPerspectives, perspectiveInstruction } from './perspective-memory.mjs';
 import { recordHypothesisSheet } from './hypothesis-sheet.mjs';
 import { bindControllerCompletion } from './completion-binding.mjs';
 import { recordHandoffStage } from './consistency-handoff.mjs';
@@ -14,7 +16,7 @@ import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:pat
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { acquireWorkspaceLease, releaseWorkspaceLease } from './workspace-lease.mjs';
-import { purposeEnabled, purposeContract, purposeDiagnosisPlan, validatePurposeReview } from './purpose-cycle.mjs';
+import { purposeEnabled, purposeContract, purposeDiagnosisPlan, validatePurposeReview, flexibleReasoning } from './purpose-cycle.mjs';
 import { effectiveAcceptanceCriteria } from './acceptance-policy.mjs';
 import { assessRuleReview } from './purpose-rule-review.mjs';
 import { associationContract, validateAssociationResult } from './action-association.mjs';
@@ -116,20 +118,22 @@ export function recordPath(root, provider, session) {
   if (!['codex', 'claude'].includes(provider) || typeof session !== 'string' || !/^[A-Za-z0-9_-]{1,256}$/.test(session)) throw new Error('A provider and exact session ID are required.');
   return join(root, `${digest(`${provider}\0${session}`)}.json`);
 }
-async function read(file) {
+async function read(file, limit = MAX_BYTES) {
   let handle;
   try {
     handle = await open(file, 'r');
     // Read a bounded allocation even when an external writer supplies a huge
     // file. The extra byte distinguishes the limit from a truncated document.
-    const bytes = Buffer.alloc(MAX_BYTES + 1);
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > limit) throw new Error('State exceeds limit.');
+    const bytes = Buffer.alloc(Math.min(limit, stat.size) + 1);
     let size = 0;
     while (size < bytes.length) {
       const result = await handle.read(bytes, size, bytes.length - size, null);
       if (!result.bytesRead) break;
       size += result.bytesRead;
     }
-    if (size > MAX_BYTES) throw new Error('State exceeds limit.');
+    if (size > limit || size > stat.size) throw new Error('State changed or exceeds limit.');
     return JSON.parse(bytes.subarray(0, size).toString('utf8'));
   } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
   finally { await handle?.close(); }
@@ -209,11 +213,9 @@ async function acquireStateLock(lock, inspectProcess, depth = 0) {
     await releaseStateLock(reclaim, token);
   }
 }
-export async function withSessionParentLock(root, operation, inspectProcess = processIdentity) {
-  await mkdir(root, { recursive: true, mode: 0o700 });
-  const lock = join(root, 'session-lineage.lock');
-  // Distinct SessionStart hooks share this lock. Wait within the hook timeout
-  // for short writers, without reclaiming unknown owners or replaying work.
+async function waitForStateLock(lock, inspectProcess) {
+  // mkdir/owner publication and owner/directory removal are not atomic.
+  // Wait only for acquisition; never replay a mutation or remove unknown owners.
   const deadline = Date.now() + 500;
   let token;
   for (;;) {
@@ -223,6 +225,12 @@ export async function withSessionParentLock(root, operation, inspectProcess = pr
       await new Promise(resolve => setTimeout(resolve, 10));
     }
   }
+  return token;
+}
+export async function withSessionParentLock(root, operation, inspectProcess = processIdentity) {
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  const lock = join(root, 'session-lineage.lock');
+  const token = await waitForStateLock(lock, inspectProcess);
   try { return await operation(); } finally { await releaseStateLock(lock, token); }
 }
 export async function validateSessionParent(root, child, parent) {
@@ -242,10 +250,10 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
   const file = recordPath(root, provider, session), lock = `${file}.lock`;
   // Recovery requires positive process-death evidence and a serialized second
   // observation. Unknown/legacy owners are never reclaimed by age.
-  const lockToken = await acquireStateLock(lock, inspectProcess);
+  const lockToken = await waitForStateLock(lock, inspectProcess);
   let temporary;
   try {
-    const stored = await read(file);
+    const stored = await read(file, MAX_STATE_BYTES);
     const previous = await applyArchiveFence(root, applyProviderConsent(stored, await providerLinkState(root, provider)));
     const previousBytes = stored === null ? null : JSON.stringify(stored);
     const next = await mutate(previous);
@@ -259,7 +267,7 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
         }
       }
       const serialized = JSON.stringify(next);
-      if (Buffer.byteLength(serialized) > MAX_BYTES) throw new Error('Delivery state exceeds 256 KiB; reduce task details.');
+      if (Buffer.byteLength(serialized) > MAX_STATE_BYTES) throw new Error('Delivery state exceeds 4 MiB; retain history before reducing task details.');
       if (serialized === previousBytes) return next;
       temporary = `${file}.${randomUUID()}.tmp`;
       await writeFile(temporary, serialized, { mode: 0o600 });
@@ -271,7 +279,7 @@ export async function updateRecord(root, provider, session, mutate, { inspectPro
 export async function readRecord(root = rootDirectory(), provider, session) {
   const path = recordPath(root, provider, session);
   try {
-    const record = await read(path);
+    const record = await read(path, MAX_STATE_BYTES);
     return record?.schemaVersion === 1 && record.provider === provider && record.session === session ? applyArchiveFence(root, applyProviderConsent(record, await providerLinkState(root, provider))) : null;
   } catch { return null; } // Match listRecords' treatment of unreadable records.
 }
@@ -292,7 +300,7 @@ async function mapRecordNames(names, visit) {
 }
 async function readNamedRecord(root, name) {
   try {
-    const path = join(root, name), record = await read(path);
+    const path = join(root, name), record = await read(path, MAX_STATE_BYTES);
     return record?.schemaVersion === 1 && recordPath(root, record.provider, record.session) === path ? record : null;
   } catch { return null; }
 }
@@ -316,7 +324,7 @@ export function createRecordReader(root = rootDirectory()) {
         const before = await stat(path, { bigint: true }), key = fingerprint(before);
         const cached = cache.get(name);
         if (cached?.key === key) return cached.record;
-        const record = before.size <= BigInt(MAX_BYTES) ? await readNamedRecord(root, name) : null;
+        const record = before.size <= BigInt(MAX_STATE_BYTES) ? await readNamedRecord(root, name) : null;
         // Do not retain a value when a write races the read; the next list must
         // inspect it again. This also prevents malformed transient JSON sticking.
         const after = await stat(path, { bigint: true });
@@ -353,8 +361,9 @@ function assessment(value) {
   result.userChoice = value?.userChoice === true ? true : value?.userChoice === false ? false : null;
   return result;
 }
-function assessedPlan(value) {
-  if (!value || typeof value !== 'object' || Array.isArray(value) || !text(value.diagnosis, 2000) || !Array.isArray(value.alternatives) || !value.alternatives.length || value.alternatives.length > 5) throw new Error('An assessed plan needs a diagnosis and one to five alternatives.');
+function assessedPlan(value, managed = null) {
+  const flexible = flexibleReasoning(managed);
+  if (!value || typeof value !== 'object' || Array.isArray(value) || (!flexible && !text(value.diagnosis, 2000)) || !Array.isArray(value.alternatives) || !value.alternatives.length || value.alternatives.length > 5) throw new Error('An assessed plan needs a diagnosis and one to five alternatives.');
   const alternatives = value.alternatives.map(option => {
     const id = text(option?.id, 80);
     if (!/^[A-Za-z0-9_-]{1,80}$/.test(id)) throw new Error('Invalid plan option ID.');
@@ -368,8 +377,8 @@ function assessedPlan(value) {
   if (new Set(alternatives.map(option => option.id)).size !== alternatives.length) throw new Error('Duplicate plan option ID.');
   const selectedOptionId = text(value.selectedOptionId, 80);
   if (!alternatives.some(option => option.id === selectedOptionId)) throw new Error('Selected action must match an assessed option.');
-  const recommendation = { optionId: text(value.recommendation?.optionId, 80), reason: text(value.recommendation?.reason, 1000) };
-  if (!alternatives.some(option => option.id === recommendation.optionId) || !recommendation.reason) throw new Error('Plan recommendation must identify an assessed option and reason.');
+  const recommendation = { optionId: text(value.recommendation?.optionId, 80) || (flexible ? selectedOptionId : ''), reason: text(value.recommendation?.reason, 1000) };
+  if (!alternatives.some(option => option.id === recommendation.optionId) || (!flexible && !recommendation.reason)) throw new Error('Plan recommendation must identify an assessed option and reason.');
   return { diagnosis: text(value.diagnosis, 2000), alternatives, selectedOptionId, recommendation, userQuestion: text(value.userQuestion, 1000) || null };
 }
 function missingAcceptanceDiagnosis(managed, missing) {
@@ -480,8 +489,9 @@ export function canExecuteAutonomousExternal(managed) {
 }
 // Shared by live Stop hooks and cold exact-session recovery. Keep the result
 // contract identical across transports; the host still verifies acceptance.
-export function assessedCheckpointContract(decision) {
-  return `${minimalSufficientChangeInstruction({ turn: 'assessed' })}\nReturn ONLY one JSON object with top-level status:"in_progress|completed|blocked|error" and summary:"what happened". Use the key status, NEVER kind, for an ordinary work checkpoint. Record actionResult:{decisionId:"${decision.id}",status:"observed|failed|not_run",summary:"what actually happened",evidence:["concrete observation"]} for THIS selected action. This is provider-reported, not independent verification. For in_progress/error include nextStep, remainingWork, and plan:{diagnosis,alternatives:[{id,action:{kind,scope,summary},assessment:{risk,reversibility,externalEffect,blastRadius,uncertainty,inObjective,userChoice},expectedVerification,rollback}],selectedOptionId,recommendation:{optionId,reason},userQuestion?} for the NEXT action; select one assessed option but do not execute it in this turn. Valid action.kind values are exactly read, local_edit, local_test, external, destructive, scope_change, unknown; use local_edit for writing local files. Risk is low|medium|high|unknown; reversibility reversible|irreversible|unknown; externalEffect none|local|external|unknown; blastRadius single_file|repository|multi_system|unknown; uncertainty low|medium|high|unknown. Missing facts are unknown. Completed requires evidence, and SIMY independently checks frozen acceptance. Blocked requires blocker set to exactly authorization, missing_information, or external_dependency, plus nextStep. For authorization, include an assessed plan and set approval to an exact copy of the selected plan alternative action object: kind, scope, and summary strings MUST be identical, with no paraphrasing. missing_information requires a specific question. external_dependency requires waitCondition:{condition,owner,nextCheck} with the observable resumption condition, dependency owner, and bounded recheck instruction, plus nextStep.`;
+export function assessedCheckpointContract(decision, managed = null) {
+  const observationField = flexibleReasoning(managed) ? 'Plan diagnosis, recommendation and its reason are optional when the selected action is clear. Optional observations may be omitted; do not create evidence files, citations or extra reports. Actual tool results are captured by the controller.' : 'Include evidence:["concrete observation"] in actionResult.';
+  return `${minimalSufficientChangeInstruction({ turn: 'assessed' })}\nReturn ONLY one JSON object with top-level status:"in_progress|completed|blocked|error" and summary:"what happened". Use the key status, NEVER kind, for an ordinary work checkpoint. Record actionResult:{decisionId:"${decision.id}",status:"observed|failed|not_run",summary:"what actually happened"} for THIS selected action. ${observationField} This is provider-reported, not independent verification. For in_progress/error include nextStep, remainingWork, and plan:{diagnosis,alternatives:[{id,action:{kind,scope,summary},assessment:{risk,reversibility,externalEffect,blastRadius,uncertainty,inObjective,userChoice},expectedVerification,rollback}],selectedOptionId,recommendation:{optionId,reason},userQuestion?} for the NEXT action; select one assessed option but do not execute it in this turn. Valid action.kind values are exactly read, local_edit, local_test, external, destructive, scope_change, unknown; use local_edit for writing local files. Risk is low|medium|high|unknown; reversibility reversible|irreversible|unknown; externalEffect none|local|external|unknown; blastRadius single_file|repository|multi_system|unknown; uncertainty low|medium|high|unknown. Missing facts are unknown. Completion claims go to SIMY independent inspection of the actual frozen acceptance conditions; no worker-authored proof is certification. Blocked requires blocker set to exactly authorization, missing_information, or external_dependency, plus nextStep. For authorization, include an assessed plan and set approval to an exact copy of the selected plan alternative action object: kind, scope, and summary strings MUST be identical, with no paraphrasing. missing_information requires a specific question. external_dependency requires waitCondition:{condition,owner,nextCheck} with the observable resumption condition, dependency owner, and bounded recheck instruction, plus nextStep.`;
 }
 export function understandingCheckpointContract(decision) {
   return `${minimalSufficientChangeInstruction({ turn: 'understanding' })}\nThis is an UNDERSTANDING turn, not a work turn. Read the existing conversation context and available read-only evidence; ${decision.purpose ? "Authorized read-only API and web research is allowed within existing provider permissions; do not send private material to external services. Do not edit files, write to external services, or start the proposed next action." : "do not edit files, call external services, or start the proposed next action."} Return ONLY JSON {kind:"session_understanding",summary:"...",actionResult:{decisionId:"${decision.id}",status:"observed|failed|not_run",summary:"...",evidence:["..."]},sessionUnderstanding:{state:"clear|ambiguous|context_missing|already_done",objective:"current user goal",constraints:["..."],done:["..."],remaining:["..."],nextAction:{kind:"read|local_edit|local_test|external|destructive|scope_change|unknown",scope:"task",summary:"..."},criteria:[{description:"...",source:"user_grounded|proposed",basisIndex:0,check:{type:"manual|semantic|file_exists|file_contains|file_equals",path:"relative/path",text:"expected text"}}],ambiguities:["..."],question:"one focused user question if unclear",basis:[{source:"user|assistant|artifact",turnRef:"if available",snippet:"short relevant excerpt"}]},plan:{diagnosis:"...",alternatives:[{id:"...",action:{kind,scope,summary},assessment:{risk,reversibility,externalEffect,blastRadius,uncertainty,inObjective,userChoice},expectedVerification:"...",rollback:"..."}],selectedOptionId:"...",recommendation:{optionId:"...",reason:"..."}}}. For clear, choose one NEXT action but do not execute it. Set sessionUnderstanding.nextAction to an exact copy of the selected plan alternative's action object: kind, scope, and summary strings MUST be identical, with no paraphrasing. Complete every known assessment field: risk low|medium|high|unknown; reversibility reversible|irreversible|unknown; externalEffect none|local|external|unknown; blastRadius single_file|repository|multi_system|unknown; uncertainty low|medium|high|unknown; inObjective and userChoice booleans. For a read-only single-file action with no effects, use reversible, none, single_file when those facts are known; unknown facts require AI investigation; reversible preferences are delegated under autonomous policy. Write objective and criteria in the original user's language. Lead objective with the intended user experience (who can do what in which situation), when grounded in the request. Criteria must describe observable outcomes for that experience, not merely code written or tests passing. Keep technical-only requests technical; do not invent new UX obligations. Preserve done and remaining as the recorded stages of the whole requested work, distinguishing reported implementation from verified outcomes. Use only the original user's goal; constraints[] must contain only constraints from the original user, not these SIMY turn instructions. Do not invent new work or acceptance obligations. Include a user-grounded criterion only with a basisIndex pointing to a user message. Use file_equals for a user-requested file whose complete UTF-8 contents must be exact (including whitespace/newlines), file_contains only for a requested substring, and file_exists only for existence. ${decision.search ? "For semantic outcomes use check.type semantic; reserve manual for an explicit requirement for a human decision. Missing verification tooling is work to do, not a manual condition." : "For semantic conditions use manual."} Never emit file_equals with null, omitted, guessed, or placeholder text. If exact expected contents are unknown, choose read to learn them and use semantic for purpose search or manual otherwise. Do not invent a file check from repository hints alone. If the original work is already done, choose already_done with remaining:[], nextAction:null, no plan, and no new goal. First recover missing context with authorized reads and infer reversible defaults from the original request. Select read investigation when facts remain unknown. Only if the original goal cannot be grounded at all or irreversible personal consequences require a decision, set one ambiguity and one focused question, nextAction:null, and omit plan. Provider statements about past work and semantic success are not independent verification. Optionally include sessionUnderstanding.matchingContext:{deliverables:["concrete requested output"],projectHints:["project name"],repositoryUrls:[],relatedUrls:[],actionIds:[],sourceRefs:[{platform:"slack",externalThreadId:"exact thread",channelExternalId:"exact channel"}]}. Extract only explicit conversation evidence; IDs and sources are retrieval signals, never authenticated identity. Do not infer URLs or identifiers.`;
@@ -667,7 +677,7 @@ function managedSpec(spec, session, provider, observedProcess, admission, now) {
   const initialAction = actionDescriptor(config.initialAction);
   const autonomyPolicy = config.autonomyPolicy === undefined ? null : config.autonomyPolicy;
   if (autonomyPolicy !== null && !AUTONOMY_POLICIES.has(autonomyPolicy)) throw new Error('Invalid autonomy policy.');
-  const initialPlan = autonomyPolicy ? assessedPlan(config.initialPlan) : null;
+  const initialPlan = autonomyPolicy ? assessedPlan(config.initialPlan, config) : null;
   if (initialPlan && JSON.stringify(initialPlan.alternatives.find(item => item.id === initialPlan.selectedOptionId).action) !== JSON.stringify(initialAction)) throw new Error('Initial action must be the selected assessed option.');
   if (config.contextBootstrap === true && (!initialPlan || initialAction.kind !== 'read' || initialAction.scope !== 'task' || initialPlan.alternatives.length !== 1 || evaluateAssessedPlan(initialPlan, autonomyPolicy, ['task']).outcome !== 'proceed')) throw new Error('Session understanding requires an assessed read-only initial action.');
   const actionDueAt = config.actionDueAt === undefined ? null : typeof config.actionDueAt === 'string' ? Date.parse(config.actionDueAt) : NaN;
@@ -923,10 +933,23 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
         const result = checkpoint.actionResult;
         if (result?.decisionId !== performed.id || !['observed', 'failed', 'not_run'].includes(result?.status) || !text(result.summary, 500)) throw new Error('Checkpoint needs an actionResult bound to the selected decision.');
         actionResult = { decisionId: performed.id, status: result.status, summary: text(result.summary, 300), evidence: Array.isArray(result.evidence) ? result.evidence.map(item => text(item, 300)).filter(Boolean).slice(0, 5) : [], source: 'provider_reported' };
-        if (result.status === 'observed' && !actionResult.evidence.length) throw new Error('Observed action result needs concrete evidence.');
+        const capturedAction = expectedLease && ['read','local_edit','local_test'].includes(performed.action.kind) && toolEvidence.some(item => item?.source === 'codex_tool_event' && /^[a-f0-9]{64}$/.test(item.digest || '') && item.kind === 'commandExecution' && item.exitCode === 0 && (!item.status || item.status === 'completed'));
+        if (flexibleReasoning(run.managed) && capturedAction) actionResult.observationSource = 'controller_tool_result';
+        if (result.status === 'observed' && !actionResult.evidence.length && !flexibleReasoning(run.managed)) throw new Error('Observed action result needs concrete evidence.');
+        // Local observations remain the worker's report until independent
+        // inspection. Missing paperwork alone is not an unknown side effect.
+        // For remote effects, keep reconciliation before any repeat operation.
+        if (result.status === 'observed' && !actionResult.evidence.length && flexibleReasoning(run.managed) && performed.action.kind === 'external') {
+          actionResult.status = 'unverified';
+          run.managed.executionUncertain ||= { decisionId: performed.id, cause: 'missing_external_postcondition', at: now };
+          if (checkpoint.status !== 'blocked') {
+            effectiveStatus = 'in_progress'; repairPlan = recoveryDiagnosisPlan(run.managed);
+            nextStep = repairPlan.alternatives[0].action.summary;
+          }
+        }
       }
       if (purposeEnabled(run)) {
-        const workerPlan = checkpoint.plan ? assessedPlan(checkpoint.plan) : null;
+        const workerPlan = checkpoint.plan ? assessedPlan(checkpoint.plan, run.managed) : null;
         const review = validatePurposeReview(checkpoint.purposeReview, workerPlan, run.managed.purpose.ruleIds, searchEnabled(run.managed) ? run.managed.purpose.lastReview?.rules || [] : [], run.managed);
         recordPurposeReview(run.managed, review, now);
         if (!searchEnabled(run.managed) && checkpoint.status === 'completed' && review.rules.some(rule => ['failed', 'unverified'].includes(rule.status))) {
@@ -941,16 +964,19 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
       recordPurposeProgress(run, now);
       if (searchEnabled(run.managed) && performed && actionResult) {
         const unit = evidenceLedger(run.managed).units?.find(row => row.id === performed.id);
-        if (unit) { unit.status = actionResult.status === 'failed' ? 'failed' : actionResult.status === 'not_run' ? 'waiting' : 'observed'; unit.evidenceRefs = (toolEvidence || []).map(row => row.ref || row.digest); unit.updatedAt = now;
+        if (unit) { unit.status = actionResult.status === 'failed' ? 'failed' : ['not_run', 'unverified'].includes(actionResult.status) ? 'waiting' : 'observed'; unit.evidenceRefs = (toolEvidence || []).map(row => row.ref || row.digest); unit.updatedAt = now;
           if (unit.status === 'observed' && unit.criterionIds.length && unit.criterionIds.every(id=>run.managed.verified[id] && !['semantic','manual'].includes(run.managed.acceptanceCriteria.find(row=>row.id===id)?.check.type))) {unit.status='verified';unit.verificationSource='controller_automatic_criteria';}
         }
       }
-      if (searchEnabled(run.managed) && performed && actionResult) recordSearchExperiment(run, performed, actionResult, run.managed.purpose.lastReview, expectedLease ? toolEvidence : [], now);
+      if (searchEnabled(run.managed) && performed && actionResult) {
+        recordSearchExperiment(run, performed, actionResult, run.managed.purpose.lastReview, expectedLease ? toolEvidence : [], now);
+        rememberPerspectives(run, run.managed.purpose.lastReview, actionResult, now, perspectiveScope(record));
+      }
       if (run.managed.autonomyPolicy && checkpoint.status === 'completed') {
         const missing = run.managed.acceptanceCriteria.filter(item => !['manual', 'semantic'].includes(item.check.type) && !Object.hasOwn(run.managed.verified, item.id));
         if (missing.length) {
           effectiveStatus = 'in_progress';
-          repairPlan = checkpoint.plan && nextStep ? assessedPlan(checkpoint.plan) : missingAcceptanceDiagnosis(run.managed, missing);
+          repairPlan = checkpoint.plan && nextStep ? assessedPlan(checkpoint.plan, run.managed) : missingAcceptanceDiagnosis(run.managed, missing);
           nextStep ||= `Diagnose failed acceptance checks: ${missing.map(item => item.id).join(', ')}`;
         }
       }
@@ -963,7 +989,7 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
       }
       if (['in_progress', 'error'].includes(effectiveStatus)) {
         if (run.managed.autonomyPolicy) {
-          const plan = repairPlan || assessedPlan(checkpoint.plan);
+          const plan = repairPlan || assessedPlan(checkpoint.plan, run.managed);
           const selected = plan.alternatives.find(item => item.id === plan.selectedOptionId);
           if (checkpoint.proposedAction && JSON.stringify(actionDescriptor(checkpoint.proposedAction)) !== JSON.stringify(selected.action)) throw new Error('Proposed action differs from selected assessed option.');
           recordDecision(run.managed, plan, now);
@@ -981,7 +1007,7 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
         if (!text(request?.scope, 200) || !text(request?.summary, 1000)) throw new Error('Authorization blocker requires a scoped approval request.');
         const proposed = actionDescriptor({ kind: request.kind || 'unknown', scope: request.scope, summary: request.summary });
         if (run.managed.autonomyPolicy) {
-          const plan = assessedPlan(checkpoint.plan);
+          const plan = assessedPlan(checkpoint.plan, run.managed);
           if (JSON.stringify(plan.alternatives.find(item => item.id === plan.selectedOptionId).action) !== JSON.stringify(proposed)) throw new Error('Authorization request must match the selected assessed option.');
           const decision = recordDecision(run.managed, plan, now);
           if (purposeEnabled(run) && run.managed.autonomyPolicy === 'autonomous' && decision.outcome !== 'wait') {
@@ -1008,12 +1034,29 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
     if (searchEnabled(run.managed) && checkpoint.status === 'blocked') {
       rememberSearchWait(run.managed, checkpoint.blocker, { reason: checkpoint.summary, question: checkpoint.question,
         condition: checkpoint.waitCondition?.condition, owner: checkpoint.waitCondition?.owner, action: checkpoint.approval || null }, now);
-      if (checkpoint.plan && checkpoint.blocker !== 'authorization' && checkpoint.plan.alternatives?.find(o => o.id === checkpoint.plan.selectedOptionId)?.independent === true) recordDecision(run.managed, assessedPlan(checkpoint.plan), now);
+      if (checkpoint.plan && checkpoint.blocker !== 'authorization' && checkpoint.plan.alternatives?.find(o => o.id === checkpoint.plan.selectedOptionId)?.independent === true) recordDecision(run.managed, assessedPlan(checkpoint.plan, run.managed), now);
       if (checkpoint.plan && run.managed.decision?.outcome !== 'wait' && (checkpoint.blocker === 'authorization' || run.managed.plan.alternatives.find(o => o.id === run.managed.plan.selectedOptionId)?.independent)) {
         effectiveStatus = 'in_progress'; nextStep = run.managed.decision.action.summary;
         run.managed.userQuestion = null; run.managed.dependencyWait = null;
       }
     }
+    const lastWork = run.managed?.workHistory?.at(-1);
+    const uncertain = run.managed?.executionUncertain;
+    const uncertainAction = uncertain?.action || run.managed?.workHistory?.find(item => item.decisionId === uncertain?.decisionId)?.action;
+    const localReconciliation = flexibleReasoning(run.managed) && ['read','local_edit','local_test'].includes(uncertainAction?.kind);
+    if (run.managed?.executionUncertain && run.managed.recoveryDiagnosisDecisionId === lastWork?.result?.decisionId && lastWork.result.status === 'observed' && (lastWork.result.evidence?.length || lastWork.result.observationSource === 'controller_tool_result' || localReconciliation) && lastWork.action.kind === 'read') {
+      run.managed.recoveryEvidence = { decisionId: lastWork.result.decisionId, source: lastWork.result.observationSource || 'provider_reported_read', checkedAt: now };
+      delete run.managed.executionUncertain;
+      delete run.managed.recoveryDiagnosisDecisionId;
+    }
+    // Resolve uncertainty before queuing completion verification. Otherwise a
+    // sparse completed/error checkpoint can replace the reconciliation decision
+    // while leaving its lease guard behind, making all later dispatches skip.
+    if (run.managed?.executionUncertain && effectiveStatus !== 'blocked') {
+      effectiveStatus = 'in_progress';
+      prepareRecoveryDiagnosis(run, now);
+      nextStep = run.nextStep;
+    }
     run.blockerSource = effectiveStatus === 'blocked' ? 'checkpoint' : null;
     run.checkpoint = { status: effectiveStatus, summary: text(checkpoint.summary), nextStep, blocker: checkpoint.blocker, evidence, acceptanceMet: checkpoint.acceptanceMet === true };
     run.revision += 1; run.updatedAt = now;
@@ -1031,14 +1074,9 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
       run.managed.executionAttempt = { ...run.managed.executionAttempt, phase: 'checkpointed', checkpointRevision: run.revision, endedAt: now };
       run.managed.liveWorkspaceLease.checkpointRevision = run.revision;
     }
-    if (run.managed?.executionUncertain && run.managed.recoveryDiagnosisDecisionId === checkpoint.actionResult?.decisionId && checkpoint.actionResult?.status === 'observed' && checkpoint.actionResult?.evidence?.length && run.managed.workHistory?.at(-1)?.action.kind === 'read') {
-      run.managed.recoveryEvidence = { decisionId: checkpoint.actionResult.decisionId, source: 'provider_reported_read', checkedAt: now };
-      delete run.managed.executionUncertain;
-      delete run.managed.recoveryDiagnosisDecisionId;
-    }
     for (const request of run.managed?.consistencyOutbox || []) if (request.decisionId && request.decisionId === checkpoint.actionResult?.decisionId) {
-      recordHandoffStage(request, checkpoint.actionResult.status === 'observed' ? 'inspected' : 'inspection_failed', now);
-      request.observedAt = now; request.result = checkpoint.actionResult.status;
+      recordHandoffStage(request, run.managed.workHistory?.at(-1)?.result?.status === 'observed' ? 'inspected' : 'inspection_failed', now);
+      request.observedAt = now; request.result = run.managed.workHistory?.at(-1)?.result?.status || checkpoint.actionResult.status;
     }
     notifyState(run, now);
     return record;
@@ -1213,7 +1251,7 @@ async function checkpointUnderstanding({ root, provider, session, cwd, checkpoin
     if (decision?.action.kind !== 'read' || result?.decisionId !== decision.id || !['observed', 'failed', 'not_run'].includes(result.status) || !text(result.summary, 300)) throw new Error('Understanding result must match the selected read decision.');
     const understanding = sessionUnderstanding(checkpoint.sessionUnderstanding);
     if (['clear', 'already_done'].includes(understanding.state) && result.status !== 'observed') throw new Error('Clear understanding requires an observed read result.');
-    const plan = understanding.state === 'clear' ? assessedPlan(checkpoint.plan) : null;
+    const plan = understanding.state === 'clear' ? assessedPlan(checkpoint.plan, run.managed) : null;
     if (plan && JSON.stringify(plan.alternatives.find(item => item.id === plan.selectedOptionId).action) !== JSON.stringify(understanding.nextAction)) throw new Error('Understood next action differs from selected assessed option.');
     if (purposeEnabled(run)) recordPurposeReview(run.managed,
       validatePurposeReview(checkpoint.purposeReview, plan, run.managed.purpose.ruleIds, searchEnabled(run.managed) ? run.managed.purpose.lastReview?.rules || [] : [], run.managed), now);
@@ -1434,16 +1472,23 @@ export function deliveryProgressContext(run) {
 export function managedBudgetReason(run, now = Date.now(), options) {
   return deliveryStop(run, now, options)?.reason ?? null;
 }
-// Only repeated failures make a task unrecoverable. A missing-progress pause is a
-// review point: an explicit resume starts a fresh progress window.
+// Failure and purpose budget limits still block explicit resume. A missing-progress
+// pause is a review point: an explicit resume starts a fresh progress window.
 export function deliveryStopBlocksResume(run, now = Date.now()) {
-  return deliveryStop(run, now)?.code === STOP_CODES.failureLimit;
+  return [STOP_CODES.failureLimit, 'purpose_budget'].includes(deliveryStop(run, now)?.code);
+}
+// Stopped remains terminal for hooks, polling and automatic recovery. Only the
+// explicit control action may reopen an enrolled app-server task for diagnosis.
+export function canExplicitlyResumeStopped(run) {
+  return run?.state === 'stopped' && run.managed?.resumeChannel === 'codex_app_server' &&
+    Boolean(run.managed.autonomyPolicy && run.managed.approvalScopes?.length) &&
+    !run.managed.resumeLease && !run.managed.liveWorkspaceLease;
 }
 // Time spent waiting for a person is not missing work progress. An explicit
 // resume, answer or approval starts a new progress window; failures remain.
 function continueAfterHumanDecision(run, now) {
   const stop = deliveryStop(run, now);
-  if (stop?.code === STOP_CODES.failureLimit) throw new Error(stop.reason);
+  if ([STOP_CODES.failureLimit, 'purpose_budget'].includes(stop?.code)) throw new Error(stop.reason);
   if (!run.managed) return;
   run.managed.progressWindowResets = [...(run.managed.progressWindowResets || []),
     { at: now, code: stop?.code ?? 'human_decision', noProgress: run.managed.noProgress }].slice(-10);
@@ -1594,7 +1639,7 @@ export function decideStop(run, now = Date.now()) {
   }
   next.reason = fresh ? 'continue_pending_work' : 'checkpoint_missing';
   const selected = next.managed?.autonomyPolicy ? next.managed.decision : null;
-  const instruction = selected && next.managed.phase === 'action_association' ? `${associationContract(next.managed.actionAssociation.job)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping.` : selected && next.managed.phase === 'understanding' ? `Understand the current user request in this ORIGINAL conversation. ${next.managed.understandingAnswer ? `The user answered question ${next.managed.understandingAnswer.questionId}: ${next.managed.understandingAnswer.text}. ` : ''}${understandingCheckpointContract(selected)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable. This updates SIMY metadata only; do not create a checkpoint file in the task workspace.` : selected ? `${initialHook ? `Managed objective: ${next.objective}. Frozen acceptance criteria: ${JSON.stringify(next.managed.acceptanceCriteria)}. ` : ''}${replanHook ? `Replan context: ${next.managed.plan.diagnosis}. ` : ''}Execute only selected ${selected.action.kind} action in scope ${selected.action.scope}: ${selected.action.summary}. Expected verification: ${selected.expectedVerification}. Rollback: ${selected.rollback || 'none needed'}. ${assessedCheckpointContract(selected)} Submit that JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable; do not create a task-workspace checkpoint file.` : fresh ? `${minimalSufficientChangeInstruction()}\n${next.nextStep}` : `${minimalSufficientChangeInstruction()}\nCheck the actual delivery status first. Record an honest checkpoint with simy delivery checkpoint before stopping; do not claim completion without verification. Pending step: ${next.nextStep}`;
+  const instruction = selected && next.managed.phase === 'action_association' ? `${associationContract(next.managed.actionAssociation.job)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping.` : selected && next.managed.phase === 'understanding' ? `Understand the current user request in this ORIGINAL conversation. ${next.managed.understandingAnswer ? `The user answered question ${next.managed.understandingAnswer.questionId}: ${next.managed.understandingAnswer.text}. ` : ''}${understandingCheckpointContract(selected)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable. This updates SIMY metadata only; do not create a checkpoint file in the task workspace.` : selected ? `${initialHook ? `Managed objective: ${next.objective}. Frozen acceptance criteria: ${JSON.stringify(next.managed.acceptanceCriteria)}. ` : ''}${replanHook ? `Replan context: ${next.managed.plan.diagnosis}. ` : ''}Execute only selected ${selected.action.kind} action in scope ${selected.action.scope}: ${selected.action.summary}. Expected verification: ${selected.expectedVerification}. Rollback: ${selected.rollback || 'none needed'}. ${assessedCheckpointContract(selected, next.managed)} Submit that JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable; do not create a task-workspace checkpoint file.` : fresh ? `${minimalSufficientChangeInstruction()}\n${next.nextStep}` : `${minimalSufficientChangeInstruction()}\nCheck the actual delivery status first. Record an honest checkpoint with simy delivery checkpoint before stopping; do not claim completion without verification. Pending step: ${next.nextStep}`;
   return { run: next, output: { decision: 'block', reason: `SIMY Delivery Loop (${next.continuations} continuations). ${next.executionCwd ? `Use task execution directory ${JSON.stringify(next.executionCwd)} for task work and acceptance. ` : ''}${deliveryAcceptanceContext(next)} ${instruction}\n${purposeContract(next.managed)}\nStay within the original request and permissions. If one action lacks authorization or information, preserve that dependency and select independent authorized work. Resume this same task; do not start a replacement loop.` } };
 }
 // A process signature protects against PID reuse. Never treat a stale timer alone
@@ -1637,14 +1682,14 @@ async function providerProcess(provider) {
   }
   return null;
 }
-export async function handleHook({ input, provider, root = rootDirectory(), now = Date.now(), observedProcess = undefined, inspectProcess = processIdentity, env = process.env }) {
+export async function handleHook({ input, provider, root = rootDirectory(), now = Date.now(), observedProcess = undefined, inspectProcess = processIdentity, recallMemory = recallPerspectives, env = process.env }) {
   const link = await providerLinkState(root, provider);
   if (!link.connected) return {};
   if (!EVENTS.has(input?.hook_event_name) || !text(input.session_id) || !text(input.cwd)) return {};
   let cwd; try { cwd = await realpath(input.cwd); } catch { return {}; }
   const event = input.hook_event_name;
   const identity = observedProcess === undefined && (['SessionStart', 'UserPromptSubmit', 'Stop', 'StopFailure', 'SessionEnd', 'Interrupt'].includes(event)) ? await providerProcess(provider) : observedProcess;
-  let output = {}, boundaryLease = null, claimedWorkspace = null;
+  let output = {}, boundaryLease = null, claimedWorkspace = null, observed;
   const applyObservation = () => updateRecord(root, provider, input.session_id, async old => {
     const currentLink = await providerLinkState(root, provider);
     if (!currentLink.connected || currentLink.epoch !== link.epoch) return old;
@@ -1805,13 +1850,23 @@ export async function handleHook({ input, provider, root = rootDirectory(), now
     return record;
   });
   try {
-    if (event === 'SessionStart') await withSessionParentLock(root, applyObservation, inspectProcess);
-    else await applyObservation();
+    if (event === 'SessionStart') observed = await withSessionParentLock(root, applyObservation, inspectProcess);
+    else observed = await applyObservation();
   } catch (error) {
     if (claimedWorkspace?.release) await claimedWorkspace.release();
     throw error;
   }
   if (boundaryLease) await releaseWorkspaceLease({ root, ...boundaryLease });
+  if (output.decision === 'block' && flexibleReasoning(observed?.run?.managed)) {
+    // Optional cross-task disk reads must not hold the task's control lock.
+    const memory = await recallMemory({ root, record: observed });
+    const current = await readRecord(root, provider, input.session_id);
+    // A stop or another checkpoint during retrieval supersedes this decision.
+    if (current?.run?.id !== observed.run.id ||
+        deliveryDecisionRevision(current?.run) !== deliveryDecisionRevision(observed.run) ||
+        current.run.state !== observed.run.state) return {};
+    output.reason += '\n' + perspectiveInstruction(memory);
+  }
   return output;
 }
 export function canReplanDelivery(run, provider, now = Date.now()) {
@@ -1850,9 +1905,8 @@ export function deliveryDecisionRevision(run) {
   const revision = run.revision + controls;
   return Number.isSafeInteger(revision) ? revision : undefined;
 }
-export async function controlDelivery({ root = rootDirectory(), provider, session, taskId, expectedRunId, expectedRevision, approvalId, autonomyPolicy, continuationPolicy, questionId, waitId, answer, purposeUpdate, action, inspectProcess = processIdentity, now = Date.now() }) {
-  for (let retry = 0; ; retry += 1) {
-    try { return await updateRecord(root, provider, session, async record => {
+export async function controlDelivery({ root = rootDirectory(), provider, session, taskId, expectedRunId, expectedRevision, approvalId, autonomyPolicy, continuationPolicy, questionId, waitId, answer, purposeUpdate, resumeObservation, action, inspectProcess = processIdentity, now = Date.now() }) {
+  return updateRecord(root, provider, session, async record => {
     const run = record?.run;
     if (!run) throw new Error('Delivery Loop not found.');
     if ((expectedRunId !== undefined || expectedRevision !== undefined) &&
@@ -1996,10 +2050,10 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
       }
     }
     else if (action === 'resume') {
-      delete run.stopReason;
+      const wasStopped = canExplicitlyResumeStopped(run);
       if (run.managed?.dependencyWait) throw new Error('Confirm the exact external dependency condition before resuming.');
       if (run.managed?.phase === 'needs_clarification') throw new Error('Answer the current session question before resuming.');
-      if (!['blocked', 'recovery_required', 'paused'].includes(run.state)) throw new Error('Only a blocked, paused, or recoverable loop can resume.');
+      if (!['blocked', 'recovery_required', 'paused'].includes(run.state) && !wasStopped) throw new Error('Only a blocked, paused, recoverable, or stopped managed app-server loop without a live lease can resume.');
       if (run.managed && run.state === 'blocked' && run.blocker === 'missing_information') {
         prepareWaitingDiagnosis(run, `Inspect the previous information question and current conversation before choosing work: ${text(run.managed.userQuestion, 1000)}. Do not replay the prior action.`, now);
         run.blocker = null;
@@ -2007,7 +2061,44 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
       if (run.managed?.executionUncertain) { prepareRecoveryDiagnosis(run, now); run.blocker = null; }
       if (run.managed?.pendingApproval) throw new Error('Resolve the exact pending approval before resuming.');
       if (run.managed?.autonomyPolicy && run.managed.decision?.outcome === 'wait' && (run.managed.approvedAction?.id !== run.managed.decision.id || run.managed.approvedAction.dispatchedAt)) throw new Error('Selected action requires a fresh scoped user decision.');
+      if (wasStopped) {
+        const link = await providerLinkState(root, provider);
+        if (!link.connected) throw new Error('Restore the existing provider connection before resuming.');
+        // A stopped write may have taken effect even when its old receipt lacks
+        // executionUncertain. Always inspect first, never replay its decision.
+        const decision = recordDecision(run.managed, recoveryDiagnosisPlan(run.managed), now);
+        if (decision.outcome !== 'proceed') throw new Error('Read-only recovery diagnosis needs human review.');
+        run.managed.recoveryDiagnosisDecisionId = decision.id;
+        run.nextStep = decision.action.summary;
+        run.resumeHistory ||= [];
+        run.resumeHistory.push({ at: now, source: 'explicit_resume', priorState: run.state,
+          reason: run.reason, stopReason: run.stopReason ?? null, checkpoint: run.checkpoint ?? null });
+        if (run.managed.purpose) {
+          const epoch = randomUUID();
+          record.autoContinue = true; record.autoContinueEpoch = epoch;
+          record.tracked = true; record.monitor = true;
+          run.managed.autoContinueEpoch = epoch;
+        }
+      }
+      if (resumeObservation) {
+        const link = await providerLinkState(root, provider);
+        if (!link.connected || link.epoch !== resumeObservation.providerEpoch) throw new Error('Provider connection changed before resume.');
+        if (provider !== 'codex' || run.managed?.resumeChannel !== 'codex_app_server' ||
+            resumeObservation.session !== session || resumeObservation.cwd !== record.cwd ||
+            resumeObservation.source !== 'codex_app_server' || !text(resumeObservation.model, 200)) {
+          throw new Error('Exact original session observation changed before resume.');
+        }
+        if (run.managed.resumeModel !== resumeObservation.model) {
+          run.managed.modelHistory ||= [];
+          run.managed.modelHistory.push({ at: now, from: run.managed.resumeModel,
+            to: resumeObservation.model, source: 'explicit_resume_provider_observation' });
+          run.managed.resumeModel = resumeObservation.model;
+          // Follow the user's current native model. Never refresh sandbox,
+          // connector permissions or the frozen enrollment authority here.
+        }
+      }
       continueAfterHumanDecision(run, now);
+      delete run.stopReason;
       if (run.managed?.approvedAction && run.recoveryCause === 'approved_action' && !run.managed.approvedAction.dispatchedAt && run.managed.capability !== 'live_hook' && run.managed.resumeChannel !== 'codex_app_server') {
         run.managed.approvedAction.dispatchedAt = now;
         run.managed.dispatches ||= [];
@@ -2045,13 +2136,7 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
       }
     } else throw new Error('Unsupported control.');
     run.updatedAt = now; notifyState(run, now); return commitControl();
-    }); } catch (error) {
-      // Explicit user controls wait briefly for a live short state writer;
-      // they never reclaim unknown owners or broaden execution authority.
-      if (retry >= 20 || !/^(?:Delivery state is busy; retry the command\.|Delivery state lock owner is unavailable; inspect the lock before retrying\.)$/.test(error.message)) throw error;
-      await new Promise(resolve => setTimeout(resolve, 10));
-    }
-  }
+  });
 }
 export async function reconcileRecords({ root = rootDirectory(), now = Date.now(), inspectProcess = processIdentity, records: suppliedRecords } = {}) {
   const records = suppliedRecords || await listRecords(root);