@awak-app/simy-cli 0.6.22 → 0.6.25

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

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import { retainApplicableRules } from './purpose-rule-policy.mjs';
+import { reconcileRequirements, retainControllerEvidence, reconcileFindings, findingText, evidenceLedger, currentPurposeObservation } from './purpose-evidence.mjs';
+import { workspaceIdentity } from './purpose-workspace.mjs';
+import { searchEnabled, failureLimitReached, searchState, recordSearchExperiment, rememberSearchWait, searchNeedsPivot, markSearchPivot, repeatedSearchAction } from './purpose-search.mjs';
 // Standalone by design: this exact module is shipped to both provider plugins.
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
@@ -7,6 +11,9 @@ import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 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 { effectiveAcceptanceCriteria } from './acceptance-policy.mjs';
+import { assessRuleReview } from './purpose-rule-review.mjs';
 import { associationContract, validateAssociationResult } from './action-association.mjs';
 import { minimalSufficientChangeInstruction } from './minimal-sufficient.mjs';
 import { continuationMode } from './continuation-policy.mjs';
@@ -14,7 +21,7 @@ import { evaluateOutcomeProgress, restartOutcomeProgressWindow } from './outcome
 
 export const TERMINAL = new Set(['completed', 'reported_done', 'stopped', 'failed', 'budget_exhausted']);
 const EVENTS = new Set(['SessionStart', 'UserPromptSubmit', 'Stop', 'StopFailure', 'SessionEnd', 'Interrupt', 'PermissionRequest', 'Notification']);
-const MAX_BYTES = 64 * 1024;
+const MAX_BYTES = 256 * 1024;
 const RETRYABLE = new Set(['overloaded', 'server_error', 'rate_limit']);
 const APPROVAL_DECISIONS = new Set(['automatic', 'proceed_and_report', 'wait']);
 const LOCAL_ACTIONS = new Set(['read', 'local_edit', 'local_test']);
@@ -190,7 +197,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 64 KiB; reduce task details.');
+      if (Buffer.byteLength(serialized) > MAX_BYTES) throw new Error('Delivery state exceeds 256 KiB; reduce task details.');
       if (serialized === previousBytes) return next;
       temporary = `${file}.${randomUUID()}.tmp`;
       await writeFile(temporary, serialized, { mode: 0o600 });
@@ -289,7 +296,12 @@ function assessedPlan(value) {
   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.');
-    return { id, action: actionDescriptor(option.action), assessment: assessment(option.assessment), expectedVerification: text(option.expectedVerification, 1000), rollback: text(option.rollback, 1000) };
+    const frontier = {};
+    for (const key of ['criterionIds','dependsOn','readResources','writeResources','requiredCapabilities','requiredPermissions']) {
+      if (option[key] !== undefined && (!Array.isArray(option[key]) || option[key].length > 32 || option[key].some(value => typeof value !== 'string' || !value.trim() || value.length > 200))) throw new Error('Invalid work unit metadata.');
+      if (option[key]) frontier[key] = [...new Set(option[key])];
+    }
+    return { id, ...frontier, ...(option.independent === true && text(option.independenceReason, 300) ? { independent: true, independenceReason: text(option.independenceReason, 300) } : {}), action: actionDescriptor(option.action), assessment: assessment(option.assessment), expectedVerification: text(option.expectedVerification, 1000), rollback: text(option.rollback, 1000) };
   });
   if (new Set(alternatives.map(option => option.id)).size !== alternatives.length) throw new Error('Duplicate plan option ID.');
   const selectedOptionId = text(value.selectedOptionId, 80);
@@ -318,22 +330,64 @@ function rejectedActionDiagnosis(managed, rejected) {
       expectedVerification: 'Report the rejection reason and a concrete, different assessed next option.', rollback: 'No changes to undo.' }],
     selectedOptionId: 'diagnose_rejected_action', recommendation: { optionId: 'diagnose_rejected_action', reason: 'Read the recorded rejection before choosing different work.' } });
 }
-export function evaluateAssessedPlan(plan, policy, scopes, now = Date.now()) {
+function researchWaitDiagnosis(managed) {
+  const previous = managed.decision;
+  const action = { kind: 'read', scope: previous.action.scope, summary: 'Inspect the recorded assessment and local evidence; propose a corrected assessed plan without executing the waiting action' };
+  return assessedPlan({ diagnosis: `Research wait: ${previous.reason} Waiting action remains unexecuted: ${previous.action.summary}. Inspect its scope, effect boundaries and verification method before proposing another plan.`,
+    alternatives: [{ id: 'diagnose_research_wait', action,
+      assessment: { risk: 'low', reversibility: 'reversible', externalEffect: 'none', blastRadius: 'single_file', uncertainty: 'low', inObjective: true, userChoice: false },
+      expectedVerification: 'Report observed assessment evidence and a concrete, corrected assessed next option.', rollback: 'No changes to undo.' }],
+    selectedOptionId: 'diagnose_research_wait', recommendation: { optionId: 'diagnose_research_wait', reason: 'Acquire local evidence before reassessing the waiting action.' } });
+}
+// This is only an unexecuted enrollment repair, not recovery of later work.
+// Retain even settled attempt history as a boundary for the dedicated recovery path.
+function canResearchReplan(run, provider, now) {
+  const m = run?.managed, d = m?.decision;
+  const channel = m?.resumeChannel === 'codex_app_server' && provider === 'codex' ||
+    m?.capability === 'live_hook' && ['codex', 'claude'].includes(provider);
+  return Boolean(channel && m.autonomyPolicy && m.approvalScopes?.includes(d?.action?.scope) &&
+    run.state === 'blocked' && run.revision === 0 && d?.outcome === 'wait' && d.waitKind === 'research' &&
+    LOCAL_ACTIONS.has(d.action.kind) && d.assessment?.inObjective === true && d.assessment.userChoice === false &&
+    d.assessment.reversibility === 'reversible' && ['none', 'local'].includes(d.assessment.externalEffect) &&
+    !m.pendingApproval && !m.approvedAction && !m.rejectedActionOverflow && !m.executionUncertain &&
+    !m.executionAttempt && !m.liveWorkspaceLease && !m.resumeLease && !m.dependencyWait &&
+    !m.userQuestion && !['understanding', 'needs_clarification', 'action_association'].includes(m.phase) &&
+    !m.nativeWait && !m.providerWarning && !m.usageBlocked && !m.purpose?.nativeBoundary && !run.blocker && !deliveryStop(run, now, { checkProgress: false }));
+}
+export function evaluateAssessedPlan(plan, policy, scopes, now = Date.now(), { allowLocalTestWrites = false, llmDelegated = false, allowReversibleExternal = false } = {}) {
   const option = plan.alternatives.find(item => item.id === plan.selectedOptionId);
   const { action } = option;
   const facts = assessment(option.assessment);
-  let reason = null;
-  if (!scopes.includes(action.scope)) reason = 'Action scope is outside the task enrollment.';
-  else if (facts.inObjective !== true || facts.userChoice !== false) reason = 'Objective fit or user choice needs review.';
-  else if (Object.values(facts).includes('unknown') || facts.inObjective === null || facts.userChoice === null) reason = 'Action assessment is incomplete.';
-  else if (!option.expectedVerification) reason = 'Expected verification is missing.';
-  else if (!LOCAL_ACTIONS.has(action.kind) || facts.externalEffect === 'external' || facts.reversibility === 'irreversible' || facts.blastRadius === 'multi_system' || facts.risk === 'high' || facts.uncertainty === 'high') reason = 'Action has external, irreversible, broad, or high-uncertainty effects.';
-  else if (action.kind === 'local_edit' && (!option.rollback || facts.reversibility !== 'reversible' || facts.externalEffect !== 'local')) reason = 'Local edit needs a concrete rollback and local reversible effects.';
-  else if (action.kind !== 'local_edit' && facts.externalEffect !== 'none') reason = 'Read or test action has unexpected side effects.';
-  else if (policy === 'strict' && (action.kind === 'local_edit' || facts.risk !== 'low' || facts.uncertainty !== 'low')) reason = 'Strict policy requires low-risk read or local test.';
-  else if (policy === 'balanced' && (facts.risk !== 'low' || facts.uncertainty !== 'low' || action.kind === 'local_edit' && facts.blastRadius !== 'single_file')) reason = 'Balanced policy requires a low-risk, narrow action.';
-  else if (policy === 'autonomous' && (facts.risk === 'medium' && facts.blastRadius !== 'repository' && facts.blastRadius !== 'single_file')) reason = 'Medium-risk action exceeds the repository boundary.';
-  return { id: digest(JSON.stringify({ plan, policy })), outcome: reason ? 'wait' : policy === 'autonomous' && facts.risk === 'medium' ? 'report' : 'proceed', reason: reason || 'Selected action fits the enrolled objective, scope, and policy.', selectedOptionId: option.id, action, assessment: facts, expectedVerification: option.expectedVerification, rollback: option.rollback, policy, at: now };
+  const localWrite = action.kind === 'local_edit' || allowLocalTestWrites && action.kind === 'local_test' && facts.externalEffect === 'local';
+  const autonomous = policy === 'autonomous' && llmDelegated;
+  const external = autonomous && allowReversibleExternal && action.kind === 'external' && facts.externalEffect === 'external';
+  let reason = null, waitKind = 'research';
+  if (!scopes.includes(action.scope)) { reason = 'Action scope is outside the task enrollment.'; waitKind = 'authority'; }
+  else if (facts.inObjective !== true) reason = 'Establish objective fit or choose work within the original task.';
+  else if (facts.reversibility === 'irreversible') { reason = 'Irreversible consequences require an exact user decision.'; waitKind = 'human'; }
+  else if (facts.reversibility !== 'reversible' || facts.externalEffect === 'unknown' || facts.blastRadius === 'unknown') reason = 'Investigate effect boundaries and reversibility before execution.';
+  else if (!autonomous && (facts.userChoice !== false || Object.values(facts).includes('unknown') || facts.userChoice === null)) reason = 'Action assessment or user choice needs review under the selected policy.';
+  else if (!option.expectedVerification) reason = 'Expected verification is missing; acquire a verification method.';
+  else if ((!LOCAL_ACTIONS.has(action.kind) || facts.externalEffect === 'external') && !external) { reason = 'This action needs existing external authority or a reversible supported alternative.'; waitKind = 'authority'; }
+  else if ((localWrite || external) && (!option.rollback || external && /^(?:no changes|none|n\/a)/i.test(option.rollback.trim()))) reason = 'Effectful work needs a concrete restoration plan.';
+  else if (localWrite && facts.externalEffect !== 'local') reason = 'Local write has inconsistent effect boundaries.';
+  else if (!localWrite && !external && facts.externalEffect !== 'none') reason = 'Read or test action has unexpected side effects.';
+  else if (!autonomous && (facts.blastRadius === 'multi_system' || facts.risk === 'high' || facts.uncertainty === 'high')) reason = 'Selected policy requires a narrower or lower-risk action.';
+  else if (policy === 'strict' && (localWrite || facts.risk !== 'low' || facts.uncertainty !== 'low')) reason = 'Strict policy requires low-risk read or local test.';
+  else if (policy === 'balanced' && (facts.risk !== 'low' || facts.uncertainty !== 'low' || localWrite && facts.blastRadius !== 'single_file')) reason = 'Balanced policy requires a low-risk, narrow action.';
+  const report = external || autonomous && (facts.risk !== 'low' || facts.uncertainty !== 'low' || facts.userChoice !== false || facts.blastRadius === 'multi_system') || policy === 'autonomous' && facts.risk === 'medium';
+  return { id: digest(JSON.stringify({ plan, policy, llmDelegated, allowReversibleExternal })), outcome: reason ? 'wait' : report ? 'report' : 'proceed', ...(reason ? { waitKind } : {}), ...(external && !reason ? { autonomousExternal: true } : {}), reason: reason || 'AI selected reversible work within the enrolled objective and provider authority.', selectedOptionId: option.id, action, assessment: facts, expectedVerification: option.expectedVerification, rollback: option.rollback, policy, at: now };
+}
+// Recompute from the frozen plan, not an arbitrary checkpoint flag. Provider
+// permissions are checked independently by the adapter at actual dispatch.
+export function canExecuteAutonomousExternal(managed) {
+  if (!searchEnabled(managed) || managed.resumeChannel !== 'codex_app_server' || managed.autonomyPolicy !== 'autonomous' || managed.executionUncertain || managed.purpose?.nativeBoundary || managed.pendingApproval?.denied || managed.rejectedActionOverflow) return false;
+  const decision = managed.decision;
+  if (!decision?.autonomousExternal || decision.outcome !== 'report' || decision.action.kind !== 'external' || !managed.plan?.alternatives?.length) return false;
+  const selected = managed.plan.alternatives.find(row => row.id === managed.plan.selectedOptionId);
+  if (!selected || JSON.stringify(selected.action) !== JSON.stringify(decision.action) || selected.rollback !== decision.rollback || JSON.stringify(assessment(selected.assessment)) !== JSON.stringify(decision.assessment) || managed.rejectedActionDigests?.includes(digest(JSON.stringify(decision.action)))) return false;
+  const current = evaluateAssessedPlan(managed.plan, managed.autonomyPolicy, managed.approvalScopes, Date.now(), { llmDelegated: true, allowReversibleExternal: true, allowLocalTestWrites: true });
+  return current.autonomousExternal === true && current.outcome === 'report';
 }
 // Shared by live Stop hooks and cold exact-session recovery. Keep the result
 // contract identical across transports; the host still verifies acceptance.
@@ -341,7 +395,7 @@ 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 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; 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|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 review. 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. For semantic conditions use manual. If the complete expected file contents are not yet known from the original user request or observed evidence in this understanding turn, use manual for that criterion and choose a read as the next action to learn them. Never emit file_equals with null, omitted, guessed, or placeholder text; an exact file check requires a bounded concrete UTF-8 string now. Do not perform the proposed next action merely to fill the check, and do not claim that a later read or model report has independently verified a manual criterion. 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. If material context is missing, set exactly 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.`;
+  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. 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.`;
 }
 function boundedContextList(value, maxItems = 8, maxLength = 300) {
   if (!Array.isArray(value) || value.length > maxItems) throw new Error('Session understanding has too many items.');
@@ -372,12 +426,12 @@ function sessionUnderstanding(value) {
     const basisIndex = Number.isSafeInteger(item.basisIndex) && item.basisIndex >= 0 && item.basisIndex < basis.length ? item.basisIndex : null;
     if (item.source === 'user_grounded' && (basisIndex === null || basis[basisIndex].source !== 'user')) throw new Error('User-grounded criterion needs a user-message basis.');
     const check = item.check?.type || 'manual';
-    if (!['manual', 'file_exists', 'file_contains', 'file_equals'].includes(check)) throw new Error('Unsupported inferred acceptance check.');
-    if (check !== 'manual' && (!text(item.check.path, 500) || isAbsolute(item.check.path) || item.check.path.split(/[\\/]/).includes('..'))) throw new Error('Inferred file check needs a relative task path.');
+    if (!['manual', 'semantic', 'file_exists', 'file_contains', 'file_equals'].includes(check)) throw new Error('Unsupported inferred acceptance check.');
+    if (!['manual', 'semantic'].includes(check) && (!text(item.check.path, 500) || isAbsolute(item.check.path) || item.check.path.split(/[\\/]/).includes('..'))) throw new Error('Inferred file check needs a relative task path.');
     if (check === 'file_contains' && !text(item.check.text, 1000)) throw new Error('Inferred file check needs expected text.');
     if (check === 'file_equals' && exactText(item.check.text) === null) throw new Error('Inferred file_equals needs bounded exact UTF-8 text.');
     return { id: `inferred-${index + 1}`, description, source: item.source, basisIndex,
-      check: check === 'manual' ? { type: 'manual' } : { type: check, path: text(item.check.path, 500), ...(check === 'file_contains' ? { text: contextText(item.check.text, 1000) } : {}), ...(check === 'file_equals' ? { text: exactText(item.check.text) } : {}) } };
+      check: ['manual', 'semantic'].includes(check) ? { type: check } : { type: check, path: text(item.check.path, 500), ...(check === 'file_contains' ? { text: contextText(item.check.text, 1000) } : {}), ...(check === 'file_equals' ? { text: exactText(item.check.text) } : {}) } };
   }) : [];
   const result = { state: value.state, objective: contextText(value.objective, 1000), constraints: boundedContextList(value.constraints),
     done: boundedContextList(value.done), remaining: boundedContextList(value.remaining), nextAction: value.nextAction ? actionDescriptor(value.nextAction) : null,
@@ -388,19 +442,92 @@ function sessionUnderstanding(value) {
   if (['ambiguous', 'context_missing'].includes(result.state) && (!result.question || result.ambiguities.length !== 1)) throw new Error('Unclear understanding needs one focused question.');
   return result;
 }
+function recordPurposeReview(managed, review, now) {
+  const purpose = managed.purpose;
+  if (searchEnabled(managed)) reconcileRequirements(managed, review, now);
+  purpose.lastReview = { ...review, at: now, source: 'provider_reported' };
+}
+// Prose is planning context, never a progress receipt. Remember every attained
+// criterion identity so a failure/recovery oscillation cannot renew the clock.
+export function purposeProgressAt(run, now = Date.now()) {
+  const managed = run.managed, purpose = managed?.purpose;
+  if (purpose?.progressVersion === 2) return purpose.lastEvidenceAt || run.startedAt;
+  // Migration can retain actual controller/user acceptance receipts, but never
+  // a v1 provider-reported observation timestamp.
+  const timestamps = (managed?.acceptanceCriteria || []).flatMap(criterion => {
+    const receipt = managed.verified?.[criterion.id];
+    const expectedSource = criterion.check.type === 'manual' ? 'user' : criterion.check.type;
+    return receipt?.source === expectedSource && Number.isFinite(receipt.checkedAt) && receipt.checkedAt <= now
+      ? [receipt.checkedAt] : [];
+  });
+  return Math.max(run.startedAt, ...timestamps);
+}
+function recordPurposeProgress(run, now, countAttempt = true) {
+  if (!purposeEnabled(run)) return;
+  const managed = run.managed, purpose = managed.purpose;
+  if (purpose.progressVersion !== 2) {
+    const baseline = purposeProgressAt(run, now);
+    purpose.progressVersion = 2; purpose.noLearning = 0;
+    purpose.lastEvidenceAt = baseline; delete purpose.observationDigest;
+  }
+  purpose.seenVerifiedCriteria ||= [];
+  const fresh = managed.acceptanceCriteria.filter(criterion => Object.hasOwn(managed.verified, criterion.id))
+    .map(criterion => digest(JSON.stringify(criterion))).filter(key => !purpose.seenVerifiedCriteria.includes(key));
+  if (fresh.length && purpose.seenVerifiedCriteria.length + fresh.length <= 128) {
+    purpose.seenVerifiedCriteria.push(...fresh);
+    purpose.noLearning = 0; purpose.lastEvidenceAt = now;
+  } else {
+    if (countAttempt) purpose.noLearning += 1;
+    if (fresh.length) purpose.progressCapacityReached = true;
+  }
+}
 function recordDecision(managed, plan, now) {
-  const decision = evaluateAssessedPlan(plan, managed.autonomyPolicy, managed.approvalScopes, now);
+  let decision = evaluateAssessedPlan(plan, managed.autonomyPolicy, managed.approvalScopes, now, { allowLocalTestWrites: searchEnabled(managed), llmDelegated: searchEnabled(managed), allowReversibleExternal: searchEnabled(managed) && managed.resumeChannel === 'codex_app_server' });
+  if (searchEnabled(managed) && decision.outcome === 'wait') {
+    rememberSearchWait(managed, 'authorization', { action: decision.action, reason: decision.reason }, now);
+    const priorities = new Map((managed.purpose.lastReview?.priorities || []).map(row => [row.optionId, row.rank]));
+    for (const candidate of [...plan.alternatives].sort((a, b) => (priorities.get(a.id) ?? 99) - (priorities.get(b.id) ?? 99))) {
+      if (candidate.id === plan.selectedOptionId || !candidate.independent) continue;
+      const alternative = { ...plan, selectedOptionId: candidate.id, recommendation: { optionId: candidate.id, reason: 'Continue the highest listed eligible independent alternative.' } };
+      const assessed = evaluateAssessedPlan(alternative, managed.autonomyPolicy, managed.approvalScopes, now, { allowLocalTestWrites: searchEnabled(managed), llmDelegated: searchEnabled(managed), allowReversibleExternal: searchEnabled(managed) && managed.resumeChannel === 'codex_app_server' });
+      if (assessed.outcome !== 'wait' && !managed.rejectedActionOverflow && !managed.rejectedActionDigests?.includes(digest(JSON.stringify(assessed.action)))) {
+        plan = alternative; decision = assessed; break;
+      }
+    }
+  }
   if (managed.rejectedActionOverflow || managed.rejectedActionDigests?.includes(digest(JSON.stringify(decision.action)))) {
     decision.outcome = 'wait';
-    decision.reason = 'A previously rejected action requires a fresh exact user decision.';
+    decision.reason = 'A previously rejected action requires a fresh exact user decision.'; decision.waitKind = 'human';
+  }
+  if (managed.purpose?.nativeBoundary && decision.action.kind !== 'read' && decision.outcome !== 'wait') {
+    decision.nativeIsolationEligible = true;
+    decision.outcome = 'wait';
+    decision.reason = 'Native operation remains pending; shared writes need confirmed ownership or an authorized isolated candidate workspace.';
   }
   managed.decisionGeneration = (managed.decisionGeneration || 0) + 1;
   decision.id = digest(`${managed.taskId}:${managed.decisionGeneration}:${decision.id}`);
+  if (managed.purpose?.enabled) decision.purpose = true;
+  if (searchEnabled(managed)) decision.search = true;
+  if (searchEnabled(managed)) {
+    const ledger = evidenceLedger(managed);
+    ledger.units ||= [];
+    const option = plan.alternatives.find(row => row.id === decision.selectedOptionId);
+    const criterionIds = option?.criterionIds?.length ? option.criterionIds : managed.acceptanceCriteria.map(row => row.id);
+    if (criterionIds.some(id => !managed.acceptanceCriteria.some(row => row.id === id))) throw new Error('Work unit references unknown criterion.');
+    const dependsOn = option?.dependsOn || [];
+    if (dependsOn.some(id => !ledger.units.some(row => row.id === id && row.status === 'verified' && row.purposeRevision === ledger.purposeRevision))) { decision.outcome = 'wait'; decision.reason = 'Required work-unit dependency has not been independently verified.'; }
+    ledger.units.push({ id: decision.id, criterionIds, dependsOn, readResources: option?.readResources || ['task'],
+      writeResources: option?.writeResources || (decision.action.kind === 'read' ? [] : ['task']),
+      requiredCapabilities: option?.requiredCapabilities || [decision.action.kind], requiredPermissions: option?.requiredPermissions || [decision.action.scope],
+      status: decision.outcome === 'wait' ? 'waiting' : 'planned', evidenceRefs: [], purposeRevision: ledger.purposeRevision || 1, action: decision.action, createdAt: now });
+    if (ledger.units.length > 128) { ledger.unitsOmitted = true; ledger.units = ledger.units.filter(row => ['waiting','planned','unknown'].includes(row.status)).concat(ledger.units.filter(row => !['waiting','planned','unknown'].includes(row.status)).slice(-64)); }
+    if (ledger.units.length > 192) throw new Error('Work frontier needs reconciliation before more dispatch.');
+  }
   managed.plan = plan; managed.decision = decision; managed.proposedAction = decision.action;
   managed.decisionHistory ||= [];
   if (managed.decisionHistory.at(-1)?.id !== decision.id) managed.decisionHistory.push({ id: decision.id, at: now, outcome: decision.outcome, reason: decision.reason, selectedOptionId: decision.selectedOptionId, action: decision.action });
   managed.decisionHistory = managed.decisionHistory.slice(-10);
-  managed.pendingApproval = decision.outcome === 'wait' ? { id: decision.id, ...decision.action, reason: decision.reason } : null;
+  managed.pendingApproval = decision.outcome === 'wait' && !(searchEnabled(managed) && decision.waitKind === 'research') ? { id: decision.id, ...decision.action, reason: decision.reason } : null;
   return decision;
 }
 function rememberRejectedAction(managed, pending) {
@@ -437,11 +564,11 @@ function managedSpec(spec, session, provider, observedProcess, admission, now) {
     const id = text(item.id, 80) || `criterion-${index + 1}`;
     if (!/^[A-Za-z0-9_-]+$/.test(id) || ['USER-GOAL', '__proto__', 'constructor', 'prototype', 'toString', 'valueOf', 'hasOwnProperty'].includes(id)) throw new Error('Invalid acceptance criterion ID.');
     const check = item.check || { type: 'manual' };
-    if (!['manual', 'file_exists', 'file_contains', 'file_equals'].includes(check.type)) throw new Error('Unsupported acceptance check.');
-    if (check.type !== 'manual' && (!text(check.path, 500) || isAbsolute(check.path) || check.path.split(/[\\/]/).includes('..'))) throw new Error('Acceptance file must be relative to the task directory.');
+    if (!['manual', 'semantic', 'file_exists', 'file_contains', 'file_equals'].includes(check.type)) throw new Error('Unsupported acceptance check.');
+    if (!['manual', 'semantic'].includes(check.type) && (!text(check.path, 500) || isAbsolute(check.path) || check.path.split(/[\\/]/).includes('..'))) throw new Error('Acceptance file must be relative to the task directory.');
     if (check.type === 'file_contains' && !text(check.text, 1000)) throw new Error('file_contains needs expected text.');
     if (check.type === 'file_equals' && exactText(check.text) === null) throw new Error('file_equals needs bounded exact UTF-8 text.');
-    return { id, description: text(item.description, 500), check: { type: check.type, ...(check.type === 'file_equals' ? { exactPath: check.path } : check.type === 'manual' ? {} : { path: check.path }), ...(check.type === 'file_contains' ? { text: text(check.text, 1000) } : {}), ...(check.type === 'file_equals' ? { text: exactText(check.text) } : {}) } };
+    return { id, description: text(item.description, 500), check: { type: check.type, ...(check.type === 'file_equals' ? { exactPath: check.path } : ['manual', 'semantic'].includes(check.type) ? {} : { path: check.path }), ...(check.type === 'file_contains' ? { text: text(check.text, 1000) } : {}), ...(check.type === 'file_equals' ? { text: exactText(check.text) } : {}) } };
   });
   if (new Set(criteria.map(item => item.id)).size !== criteria.length) throw new Error('Duplicate acceptance criterion ID.');
   const approvalPolicy = config.approvalPolicy || 'wait';
@@ -462,6 +589,7 @@ function managedSpec(spec, session, provider, observedProcess, admission, now) {
   const appServerChannel = config.resumeChannel === 'codex_app_server' && admission?.source === 'codex_app_server' && admission.session === session;
   const autoRecovery = config.autoRecovery === true && exactCodexSession && Boolean(resumeModel) &&
     (appServerChannel || config.resumeChannel === 'codex_exec' && Boolean(observedProcess?.identity));
+  if (config.purpose && config.maxTokens !== undefined && !(provider === 'codex' && appServerChannel)) throw new Error('Provider token budgets require the host-observed Codex app-server channel.');
   let deliveryLevel = null;
   if (config.deliveryLevel !== undefined) {
     const value = config.deliveryLevel;
@@ -470,10 +598,11 @@ function managedSpec(spec, session, provider, observedProcess, admission, now) {
         value.numberingVersion !== 'assurance-ascending-v2' || !text(value.selectionRef, 200)) throw new Error('Delivery level needs the user selection reference, requested/effective levels 1-5, and assurance-ascending-v2 numbering.');
     deliveryLevel = { requested: value.requested, effective: value.effective, numberingVersion: value.numberingVersion, selectionRef: text(value.selectionRef, 200) };
   }
-  const managed = { taskId: randomUUID(), deliveryLevel, thread: { provider, id: session },
+  const managed = { ...(config.purpose ? { purpose: structuredClone(config.purpose) } : {}), taskId: randomUUID(), deliveryLevel, thread: { provider, id: session },
     actionId: text(config.actionId, 200) || null, actionDueAt, acceptanceCriteria: criteria, verified: {}, remainingWork: text(config.remainingWork, 4000) || null,
     initialAction, proposedAction: initialAction, approvalPolicy, approvalScopes: [...new Set(scopes)].slice(0, 20),
     grants: Object.fromEntries(scopes.map(scope => [scope, { decision: approvalPolicy }])), maxNoProgress: positive(config.maxNoProgress, 3, 20),
+    ...(config.purpose ? { maxTokens: config.maxTokens === undefined ? null : positive(config.maxTokens, 1, 1_000_000_000), tokensUsed: 0, usageAvailable: null } : {}),
     maxNoProgressMinutes: positive(config.maxNoProgressMinutes, 30, 1440), lastVerifiedProgressAt: now,
     noProgress: 0, verifiedRevision: 0, consumedVerifiedRevision: 0, notification: null, notificationKey: null,
     continuationPolicy: continuationMode(config.continuationPolicy),
@@ -488,6 +617,11 @@ function managedSpec(spec, session, provider, observedProcess, admission, now) {
 }
 function freezeEnrollment(run, now) {
   if (!run.managed || run.managed.enrollment) return;
+  if (run.managed.purpose) {
+    const ledger = evidenceLedger(run.managed);
+    ledger.purposeRevision ||= 1;
+    ledger.charter ||= { objective: run.objective, criteria: structuredClone(run.managed.acceptanceCriteria), approvalScopes: [...run.managed.approvalScopes], frozenAt: now };
+  }
   run.managed.enrollment = { objective: run.objective, acceptanceDigest: digest(JSON.stringify(run.managed.acceptanceCriteria)),
     deliveryLevel: structuredClone(run.managed.deliveryLevel || null), frozenAt: now };
 }
@@ -496,7 +630,7 @@ export function pendingAcceptance(run) {
   if (enrollment && (enrollment.objective !== run.objective || enrollment.acceptanceDigest !== digest(JSON.stringify(run.managed.acceptanceCriteria)) ||
       JSON.stringify(enrollment.deliveryLevel) !== JSON.stringify(run.managed.deliveryLevel || null))) return [{ id: 'enrollment', description: 'Original objective, level and acceptance contract',
     check: 'manual', detail: 'Enrollment changed unexpectedly; stop and inspect before enrolling a revised task' }];
-  return (run.managed?.acceptanceCriteria || []).filter(item => !Object.hasOwn(run.managed.verified, item.id))
+  return effectiveAcceptanceCriteria(run.managed).filter(item => !Object.hasOwn(run.managed.verified, item.id))
     .map(item => ({ id: item.id, description: item.description, check: item.check.type,
       detail: run.managed.criterionObservations?.[item.id]?.observed_result || (item.check.type === 'manual' ? 'Explicit user verification required' : 'Independent check not yet passed') }));
 }
@@ -508,7 +642,7 @@ export function deliveryAcceptanceContext(run) {
     `${run.managed?.deliveryLevel ? ` Frozen delivery level: ${JSON.stringify(run.managed.deliveryLevel)}.` : ''}` +
     ` Pending acceptance (last recorded checks): ${JSON.stringify(pendingAcceptance(run))}. Continue only within the original request and permissions; manual checks require the user. SQM is optional and 0 applicable checks do not establish quality acceptance.`;
 }
-export async function startDelivery({ root = rootDirectory(), provider, session, cwd = process.cwd(), executionCwd, upgradeRunId, objective, nextStep, maxFailures, continuationPolicy, managed, admission,
+export async function startDelivery({ root = rootDirectory(), provider, session, cwd = process.cwd(), executionCwd, upgradeRunId, objective, nextStep, maxMinutes, maxContinuations, maxFailures, continuationPolicy, managed, admission,
   liveHookAdmission, autoContinueEpoch, providerLinkEpoch, inspectProcess = processIdentity, now = Date.now() }) {
   const link = await providerLinkState(root, provider);
   if (providerLinkEpoch !== undefined && providerLinkEpoch !== link.epoch) throw Object.assign(new Error("SIMY provider connection changed before enrollment."), { code: "provider_link_changed" });
@@ -551,7 +685,8 @@ export async function startDelivery({ root = rootDirectory(), provider, session,
     const waiting = managedState?.decision?.outcome === 'wait';
     const queued = managedState?.capability === 'codex_app_server';
     const run = { id: randomUUID(), objective: text(objective), state: waiting ? 'blocked' : queued ? 'recovery_required' : 'active', nextStep: text(nextStep), startedAt: now, updatedAt: now,
-      maxFailures: positive(maxFailures, 3, 10),
+      ...(managedState?.purpose ? { ...(maxMinutes === undefined ? {} : { deadline: now + positive(maxMinutes, 120, 1440) * 60_000 }), ...(maxContinuations === undefined ? {} : { maxContinuations: positive(maxContinuations, 50, 1000) }) } : {}),
+      maxFailures: positive(maxFailures, 3, 10), maxFailuresSource: maxFailures === undefined ? 'default' : 'explicit',
       continuations: 0, failures: 0, revision: 0, consumedRevision: -1, checkpoint: null, reason: waiting ? managedState.decision.reason : queued ? 'Exact-session supervision is queued; SIMY will acquire the provider writer lock before dispatch.' : 'started',
       ...(queued ? { recoveryCause: 'session_supervision' } : {}), managed: managedState };
     if (executionCwd || previous.run?.executionCwd) run.executionCwd = executionCwd || previous.run.executionCwd;
@@ -579,9 +714,94 @@ export async function startDelivery({ root = rootDirectory(), provider, session,
     return { ...previous, run };
   });
 }
-export async function checkpointDelivery({ root = rootDirectory(), provider, session, cwd = process.cwd(), checkpoint, expectedLease, now = Date.now() }) {
+// Explicit UI opt-in upgrades the existing run without replacing its identity or budgets.
+export async function enablePurposeDelivery({ root = rootDirectory(), provider, session, admission, purpose, expectedRunId, expectedRevision, now = Date.now() }) {
+  return updateRecord(root, provider, session, record => {
+    const run = record?.run;
+    if (!run || run.id !== expectedRunId || run.revision !== expectedRevision || provider !== 'codex' ||
+        admission?.source !== 'codex_app_server' || admission.session !== session || admission.cwd !== record.cwd || !admission.model ||
+        record.admission?.source !== admission.source || record.admission?.model !== admission.model) throw new Error('Exact session changed before automatic continuation.');
+    if (TERMINAL.has(run.state) || run.state === 'auto_resuming' || run.managed?.resumeLease || run.managed?.liveWorkspaceLease ||
+        ['pending', 'transferred', 'pending_received'].includes(run.managed?.handoff?.status)) throw new Error('This task cannot change supervision while completed, executing, or handed off.');
+    if (managedBudgetReason(run, now)) throw new Error('Original budget exhausted; automatic continuation cannot reset it.');
+    if (!run.managed) {
+      const plan = purposeDiagnosisPlan({ approvalScopes: ['task'] }, 'Read the original conversation, reconstruct its purpose and completion conditions, then choose necessary work.');
+      run.managed = managedSpec({ acceptanceCriteria: [], contextBootstrap: true, autonomyPolicy: 'autonomous', approvalScopes: ['task'], approvalPolicy: 'wait',
+        initialPlan: plan, initialAction: plan.alternatives[0].action, autoRecovery: true, resumeChannel: 'codex_app_server', resumeModel: admission.model, purpose },
+        session, provider, record.process, admission, now);
+      run.managed.purpose.previousCheckpoint = run.checkpoint;
+      run.checkpoint = null;
+    } else {
+      if (run.managed.resumeChannel !== 'codex_app_server' || run.managed.resumeModel !== admission.model) throw new Error('Automatic continuation requires the original verified provider channel.');
+      run.managed.purpose = { ...run.managed.purpose, ...purpose };
+      run.managed.autonomyPolicy = 'autonomous';
+      if (run.managed.plan && !run.managed.pendingApproval) recordDecision(run.managed, run.managed.plan, now);
+    }
+    run.managed.purpose.enabled = true;
+    // Preserve pending approvals/questions. The supervisor may investigate them,
+    // but enabling this switch does not grant external effects or native rights.
+    if (!run.managed.pendingApproval && !run.managed.dependencyWait && run.managed.phase !== 'needs_clarification' && !run.managed.userQuestion) {
+      if (run.managed.executionUncertain) prepareRecoveryDiagnosis(run, now);
+      run.managed.autoRecovery = true; run.state = 'recovery_required'; run.recoveryCause = 'session_supervision';
+      run.reason = 'Purpose-driven automatic continuation is enabled.';
+    } else if (run.state === 'paused') { run.state = 'blocked'; }
+    run.updatedAt = now;
+    return record;
+  });
+}
+
+// Called by the owning supervisor, never by an LLM. Each unchanged obstacle gets
+// one bounded diagnostic attempt. It is not permission to replay the old action.
+export function queuePurposeDiagnosis(run, reason, key, now = Date.now()) {
+  if (!purposeEnabled(run) || run.managed.resumeChannel !== 'codex_app_server' ||
+      ['paused', 'stopped', 'completed', 'budget_exhausted'].includes(run.state) || managedBudgetReason(run, now) ||
+      (!searchEnabled(run.managed) && run.managed.pendingApproval?.denied) || run.managed.providerWarning && !run.managed.nativeWait || run.managed.usageBlocked ||
+      ['pending', 'transferred', 'pending_received'].includes(run.managed.handoff?.status)) return false;
+  const purpose = run.managed.purpose;
+  purpose.recoveries ||= [];
+  if (searchEnabled(run.managed)) {
+    // Back off the same obstacle; a newly observed obstacle or independently
+    // verified progress should not inherit an unrelated fifteen-minute delay.
+    const retryKey = digest(JSON.stringify([key, run.managed.verifiedRevision]));
+    if (purpose.searchRetryKey !== retryKey) {
+      purpose.searchRetryKey = retryKey;
+      purpose.searchRetries = 0;
+      purpose.nextSearchAt = 0;
+    }
+    if (now < (purpose.nextSearchAt || 0)) return false;
+    rememberSearchWait(run.managed, run.blocker || 'verification', {
+      action: run.managed.pendingApproval ? { kind: run.managed.pendingApproval.kind, scope: run.managed.pendingApproval.scope, summary: run.managed.pendingApproval.summary } : null,
+      reason, question: run.managed.userQuestion, condition: run.managed.dependencyWait?.condition,
+      owner: run.managed.dependencyWait?.owner,
+    }, now);
+    purpose.nextSearchAt = now + Math.min(15 * 60_000, 15_000 * 2 ** Math.min(6, purpose.searchRetries || 0));
+    purpose.searchRetries = (purpose.searchRetries || 0) + 1;
+  } else {
+    if (purpose.recoveries.includes(key)) return false;
+    if (purpose.recoveries.length >= 20) return false;
+  }
+  purpose.recoveries.push(key);
+  purpose.recoveries = purpose.recoveries.slice(-20);
+  if (run.managed.nativeWait) purpose.nativeBoundary ||= { ...run.managed.nativeWait, provider: run.managed.thread?.provider, state: 'pending', writer: 'unknown' };
+  purpose.lastRecovery = { reason: contextText(reason, 1000), at: now, previousBlocker: run.blocker || null,
+    pendingApproval: run.managed.pendingApproval ? { ...run.managed.pendingApproval } : null,
+    question: run.managed.understandingQuestion?.text || run.managed.userQuestion || null,
+    dependency: run.managed.dependencyWait || null };
+  recordDecision(run.managed, purposeDiagnosisPlan(run.managed, reason), now);
+  if (run.managed.executionUncertain) prepareRecoveryDiagnosis(run, now);
+  if (run.managed.phase === 'needs_clarification') run.managed.phase = 'understanding';
+  run.managed.userQuestion = null; run.managed.understandingQuestion = null; run.managed.dependencyWait = null;
+  run.managed.autoRecovery = true; run.managed.nextAttemptAt = now;
+  run.blocker = null; run.blockerSource = null;
+  run.checkpoint = null; run.consumedRevision = run.revision;
+  run.state = 'recovery_required'; run.recoveryCause = 'session_supervision';
+  run.nextStep = run.managed.decision.action.summary; run.reason = reason; run.updatedAt = now;
+  return true;
+}
+
+export async function checkpointDelivery({ root = rootDirectory(), provider, session, cwd = process.cwd(), checkpoint, expectedLease, toolEvidence = [], sourceContext, controllerEvidence, now = Date.now() }) {
   if (checkpoint?.kind === 'action_association') return checkpointActionAssociation({ root, provider, session, cwd, checkpoint, expectedLease, now });
-  if (checkpoint?.kind === 'session_understanding') return checkpointUnderstanding({ root, provider, session, cwd, checkpoint, expectedLease, now });
+  if (checkpoint?.kind === 'session_understanding') return checkpointUnderstanding({ root, provider, session, cwd, checkpoint, expectedLease, sourceContext, controllerEvidence, now });
   try { cwd = await realpath(cwd); } catch { throw new Error('No matching active Delivery Loop.'); }
   const statuses = ['in_progress', 'completed', 'blocked', 'error'];
   if (!checkpoint || !statuses.includes(checkpoint.status)) throw new Error('Checkpoint status must be in_progress, completed, blocked, or error.');
@@ -601,6 +821,8 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
     if (TERMINAL.has(run.state) || run.state === 'blocked' || run.state === 'recovery_required') throw new Error('Loop is stopped or awaiting a human resume.');
     if (['paused', 'verification_pending'].includes(run.state)) throw new Error('Managed task is paused or awaiting acceptance verification.');
     if (run.managed) {
+      if (searchEnabled(run.managed) && expectedLease && sourceContext) run.managed.purpose.originalContext ||= sourceContext;
+    if (searchEnabled(run.managed) && expectedLease) retainControllerEvidence(run.managed, controllerEvidence, now);
       const performed = run.managed.autonomyPolicy ? structuredClone(run.managed.decision) : null;
       let actionResult = null;
       if (performed) {
@@ -609,11 +831,29 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
         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.');
       }
+      if (purposeEnabled(run)) {
+        const workerPlan = checkpoint.plan ? assessedPlan(checkpoint.plan) : 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))) {
+          effectiveStatus = 'in_progress';
+          repairPlan = purposeDiagnosisPlan(run.managed, 'Completion is unproven: resolve failed/unverified workflow rules against the original purpose.');
+          nextStep = repairPlan.alternatives[0].action.summary;
+        }
+      }
       const previouslyVerified = Object.keys(run.managed.verified).length;
       run.managed.remainingWork = text(checkpoint.remainingWork, 4000) || run.managed.remainingWork;
       await verifyAutomaticCriteria(record, now);
+      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.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 (run.managed.autonomyPolicy && checkpoint.status === 'completed') {
-        const missing = run.managed.acceptanceCriteria.filter(item => item.check.type !== 'manual' && !Object.hasOwn(run.managed.verified, item.id));
+        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);
@@ -633,7 +873,9 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
           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);
-          if (actionResult.status === 'not_run' || actionResult.status === 'failed' && run.managed.decision.action.kind !== 'read') {
+          if (purposeEnabled(run) && !searchEnabled(run.managed) && ['failed', 'not_run'].includes(actionResult.status)) {
+            recordDecision(run.managed, purposeDiagnosisPlan(run.managed, `Investigate the ${actionResult.status} action before further changes: ${actionResult.summary}`), now);
+          } else if (!searchEnabled(run.managed) && (actionResult.status === 'not_run' || actionResult.status === 'failed' && run.managed.decision.action.kind !== 'read')) {
             run.managed.decision.outcome = 'wait'; run.managed.decision.reason = actionResult.status === 'not_run' ? 'Previous selected action was not run.' : 'Failed action requires a read-only diagnosis before another change.';
             run.managed.pendingApproval = { id: run.managed.decision.id, ...run.managed.decision.action, reason: run.managed.decision.reason };
           }
@@ -648,8 +890,12 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
           const plan = assessedPlan(checkpoint.plan);
           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);
-          decision.outcome = 'wait'; decision.reason = 'Provider authorization requires an exact user decision.';
-          run.managed.pendingApproval = { id: decision.id, ...proposed, reason: decision.reason };
+          if (purposeEnabled(run) && run.managed.autonomyPolicy === 'autonomous' && decision.outcome !== 'wait') {
+            effectiveStatus = 'in_progress';
+          } else {
+            decision.outcome = 'wait'; decision.reason = 'Provider authorization requires an exact user decision.';
+            run.managed.pendingApproval = { id: decision.id, ...proposed, reason: decision.reason };
+          }
         } else {
           run.managed.proposedAction = proposed;
           run.managed.pendingApproval = { id: digest(`${run.managed.taskId}:${run.revision + 1}:${JSON.stringify(proposed)}`), ...proposed };
@@ -665,10 +911,22 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
       if (!text(wait?.condition, 1000) || !text(wait?.owner, 200) || !text(wait?.nextCheck, 1000) || !nextStep) throw new Error('External dependency needs waitCondition {condition, owner, nextCheck} and a nextStep.');
       run.managed.dependencyWait = { id: randomUUID(), condition: text(wait.condition, 1000), owner: text(wait.owner, 200), nextCheck: text(wait.nextCheck, 1000), createdAt: now };
     }
+    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 && 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;
+      }
+    }
+    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;
     recordManagedOutcomeProgress(run, now);
-    if (run.managed && effectiveStatus === 'completed') {
+    if (searchEnabled(run.managed) && effectiveStatus === 'completed') {
+      queuePurposeVerification(run, checkpoint.summary, now);
+    } else if (run.managed && effectiveStatus === 'completed') {
       const pending = pendingAcceptance(run);
       if (pending.length) { run.state = 'verification_pending'; run.reason = acceptancePendingReason(run); }
       else if (run.managed.contextBootstrap && !run.managed.acceptanceCriteria.length) {
@@ -684,11 +942,121 @@ export async function checkpointDelivery({ root = rootDirectory(), provider, ses
       delete run.managed.executionUncertain;
       delete run.managed.recoveryDiagnosisDecisionId;
     }
+    for (const request of run.managed?.consistencyOutbox || []) if (request.decisionId && request.decisionId === checkpoint.actionResult?.decisionId) {
+      request.stage = checkpoint.actionResult.status === 'observed' ? 'inspected' : 'inspection_failed';
+      request.observedAt = now; request.result = checkpoint.actionResult.status;
+    }
     notifyState(run, now);
     return record;
   });
   return settled;
 }
+export function queuePurposeVerification(run, claim, now) {
+  const managed = run.managed, state = searchState(managed);
+  recordDecision(managed, purposeDiagnosisPlan(managed, 'Independently inspect the requested outcome and return specific findings.'), now);
+  state.verificationDecisionId = managed.decision.id;
+  state.completionClaim = text(claim, 1000);
+  state.phase = 'verifying';
+  run.checkpoint = null; run.state = 'recovery_required'; run.recoveryCause = 'session_supervision';
+  run.nextStep = 'Independently verify the requested outcome.';
+  run.reason = run.nextStep; managed.autoRecovery = true;
+}
+function externalReviewIsCurrent(managed,review,now) {
+  const refs=[...(review.criteria||[]).filter(row=>row.passed),...(review.rules||[]).filter(row=>row.status==='satisfied'),...(review.workUnits||[])].flatMap(row=>row.evidenceRefs||[]).filter(link=>/^[a-f0-9]{64}$/.test(link.ref));
+  const ledger=managed.purpose.evidence;
+  const observations=[...(ledger?.observations||[]),...(ledger?.reviewObservationActionId===(review.decisionId||managed.decision.id) ? ledger.reviewObservations||[] : [])];
+  return refs.every(link=>observations.some(item=>item.id===link.ref && item.status==='observed' && currentPurposeObservation(item,now,review.observationWindow)));
+}
+export async function settlePurposeVerification({ root, provider, session, expectedLease, review, verifySnapshot, now = Date.now() }) {
+  const started = Date.now(), initialNow = now;
+  const snapshot = (await listRecords(root)).find(record => record.provider === provider && record.session === session);
+  if (!snapshot || snapshot.run?.state !== 'auto_resuming' || snapshot.run.managed?.resumeLease?.id !== expectedLease) throw new Error('Independent review lease changed.');
+  // Keep potentially large IO outside the state lock so pause/stop can persist.
+  const currentDigest = await (verifySnapshot ? verifySnapshot(snapshot) : workspaceIdentity(taskDirectory(snapshot), root, undefined, { excludedPaths: review?.manifest?.source === 'controller_certified_independent_proposal' ? review.manifest.exclusions.map(row => row.path) : [] }));
+  return updateRecord(root, provider, session, async record => {
+    now = initialNow + Math.max(0, Date.now() - started);
+    const run = record?.run, managed = run?.managed;
+    if (!searchEnabled(managed) || !expectedLease || run.state !== 'auto_resuming' || managed.resumeLease?.id !== expectedLease ||
+      managed.purpose.search?.verificationDecisionId !== managed.decision.id || run.revision !== managed.resumeLease.checkpointRevision || now >= run.deadline) throw new Error('Independent review lease changed.');
+    const state = searchState(managed);
+    if (review?.source !== 'independent_codex_session' || !review.session || review.session === session || !review.workspaceDigest || typeof review.passed !== 'boolean') throw new Error('Independent review provenance is missing.');
+    retainApplicableRules(managed, review.rules || []);
+    review = assessRuleReview(review, managed);
+    if (currentDigest !== review.workspaceDigest) {
+      review = { ...review, passed: false, needsHuman: false, findings: [...review.findings, 'Workspace changed before review settlement; verify the new revision.'] };
+    }
+    const nativeResultReview=managed.purpose.nativeBoundary?.state==='writer_completed_requires_verification' && managed.purpose.nativeBoundary.completedTurnId===managed.purpose.nativeBoundary.turnId;
+    if ((managed.purpose.nativeBoundary && !nativeResultReview) || managed.executionUncertain || pendingAcceptance(run).some(row => row.id === 'enrollment')) {
+      review = { ...review, passed: false, needsHuman: false, findings: [...review.findings,
+        'Required operation, effect reconciliation or original-purpose contract remains unresolved. Preserve the waiting unit and continue independent authorized work.'] };
+    }
+    if(!externalReviewIsCurrent(managed,review,now)) review={...review,passed:false,needsHuman:false,findings:[...review.findings,'Controller external evidence expired before settlement; reacquire the same authorized observations and independently re-evaluate without replaying writes.']};
+    const openFindings = reconcileFindings(managed, review, now);
+    const units=evidenceLedger(managed).units;
+    for (const result of (review.passed || review.needsHuman) ? review.workUnits || [] : []) {
+      const unit=units.find(row=>row.id===result.id);
+      if (!unit || !['verified','superseded'].includes(result.status) || !result.evidenceRefs?.length ||
+          unit.criterionIds.some(id=>!review.criteria.some(row=>row.id===id && row.passed))) throw new Error('Required unit resolution needs independent criterion-linked evidence.');
+      if (unit.purposeRevision !== evidenceLedger(managed).purposeRevision) throw new Error('Unit belongs to an old purpose revision.');
+      unit.status=result.status;unit.evidenceRefs=result.evidenceRefs;unit.verifiedAt=now;
+    }
+    state.review = review; delete state.verificationDecisionId;
+    run.revision += 1; run.updatedAt = now;
+    await verifyAutomaticCriteria(record, now);
+    if (review.passed || review.needsHuman) {
+      for (const criterion of effectiveAcceptanceCriteria(managed)) {
+        if (criterion.check.type === 'semantic' && review.criteria.some(row => row.id === criterion.id && row.passed)) {
+          managed.verified[criterion.id] = { source: 'independent_codex_session', checkedAt: now, workspaceDigest: review.workspaceDigest, session: review.session };
+        }
+      }
+      for (const unit of units) if (unit.id.startsWith('criterion:') && unit.criterionIds.every(id=>managed.verified[id])) {unit.status='verified';unit.evidenceRefs=review.criteria.filter(row=>unit.criterionIds.includes(row.id)).flatMap(row=>row.evidenceRefs || []);}
+      const requiredPending=units.filter(row=>row.required && row.purposeRevision === evidenceLedger(managed).purposeRevision && !['verified','superseded'].includes(row.status));
+      const pending = effectiveAcceptanceCriteria(managed).filter(c => !Object.hasOwn(managed.verified, c.id));
+      if (requiredPending.length && (!pending.every(c=>c.check.type==='manual') || !pending.length)) review={...review,passed:false,needsHuman:false,findings:[...review.findings,'Required work units still waiting: '+requiredPending.map(row=>row.id).join(', ')]};
+      if((review.passed || review.needsHuman) && nativeResultReview){delete managed.purpose.nativeBoundary;managed.nativeWait=null;}
+      if (review.passed && !pending.length && !managed.purpose.nativeBoundary && !managed.executionUncertain && pendingAcceptance(run).length === 0) {
+        for (const unit of evidenceLedger(managed).units || []) if (unit.status === 'observed' && unit.criterionIds.every(id => managed.verified[id])) unit.status = 'verified';
+        run.state = 'completed'; run.reason = review.summary; state.phase = 'completed';
+        run.checkpoint = { status: 'completed', summary: review.summary, evidence: review.criteria.map(c => c.evidence) };
+        managed.autoRecovery = false;
+        for (const request of managed.consistencyOutbox || []) {
+          request.stage = 'resolved'; request.verifiedAt = now; request.reviewerSession = review.session;
+          request.workspaceDigest = review.workspaceDigest;
+        }
+      } else if (pending.length && pending.every(c => c.check.type === 'manual')) {
+        run.state = 'verification_pending'; run.reason = 'Only explicitly human acceptance remains.'; state.phase = 'waiting';
+        run.checkpoint = { status: 'completed', summary: review.summary }; managed.autoRecovery = false;
+      } else review = { ...review, passed: false, needsHuman: false, findings: ['Local acceptance changed during review; investigate and recheck.'] };
+    }
+    state.review={...review,decisionId:managed.decision.id};
+    if (!review.passed && !review.needsHuman && openFindings.some(item => item.observation)) {
+      const ledger = evidenceLedger(managed);
+      const lookup = digest(JSON.stringify(openFindings.filter(item => item.observation).map(item => [item.id, item.observation])));
+      if (state.observerLookup !== lookup) {
+        state.observerLookup = lookup;
+        queuePurposeVerification(run, 'Acquire the requested scoped external observations and independently re-evaluate the outcome.', now);
+        notifyState(run, now); return record;
+      }
+    }
+    if (!review.passed && !review.needsHuman && openFindings.length && openFindings.every(item => item.owner === 'controller')) {
+      const ledger = evidenceLedger(managed);
+      const lookup = createHash('sha256').update(JSON.stringify({ findings: openFindings.map(item => item.id).sort(), receipts: ledger.receipts.map(item => item.id), baseline: ledger.baseline?.digest, workspace: review.workspaceDigest })).digest('hex');
+      if (state.controllerLookup !== lookup && (ledger.baseline || ledger.receipts.length)) {
+        state.controllerLookup = lookup;
+        queuePurposeVerification(run, 'Controller retrieved existing baseline and tool receipts; reconcile the missing evidence against the supplied ledger before requesting worker repairs.', now);
+        notifyState(run, now); return record;
+      }
+    }
+    if (!review.passed && !review.needsHuman) {
+      const reason = `Outcome review found remaining work: ${[review.summary, ...openFindings.map(findingText)].join(' ').slice(0, 1800)}`;
+      recordDecision(managed, purposeDiagnosisPlan(managed, reason), now);
+      state.phase = 'repairing'; managed.purpose.lastRecovery = { reason, at: now };
+      run.checkpoint = null; run.state = 'recovery_required'; run.recoveryCause = 'session_supervision';
+      run.nextStep = managed.decision.action.summary; run.reason = reason; managed.autoRecovery = true;
+    }
+    notifyState(run, now); return record;
+  });
+}
 export async function checkpointActionAssociation({ root, provider, session, cwd, checkpoint, expectedLease, now = Date.now() }) {
   cwd = await realpath(cwd);
   return updateRecord(root, provider, session, record => {
@@ -711,12 +1079,12 @@ export async function checkpointActionAssociation({ root, provider, session, cwd
     run.checkpoint = job.saved.checkpoint || null;
     run.revision += 1; run.updatedAt = now; managed.associationCheckpointRevision = run.revision;
     association.previousCheckpoint = job.saved.checkpoint || null;
-    if (expectedLease) run.continuations += 1;
+    if (expectedLease && !searchEnabled(run.managed)) run.continuations += 1;
     run.reason = 'Action matching finished; original selected work remains unchanged.';
     return record;
   });
 }
-async function checkpointUnderstanding({ root, provider, session, cwd, checkpoint, expectedLease, now }) {
+async function checkpointUnderstanding({ root, provider, session, cwd, checkpoint, expectedLease, sourceContext, controllerEvidence, now }) {
   try { cwd = await realpath(cwd); } catch { throw new Error('No matching active Delivery Loop.'); }
   if (!text(checkpoint.summary, 1000)) throw new Error('Understanding checkpoint needs a summary.');
   return updateRecord(root, provider, session, async record => {
@@ -732,6 +1100,10 @@ async function checkpointUnderstanding({ root, provider, session, cwd, checkpoin
     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;
     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);
+    if (searchEnabled(run.managed) && expectedLease && sourceContext) run.managed.purpose.originalContext ||= sourceContext;
+    if (searchEnabled(run.managed) && expectedLease) retainControllerEvidence(run.managed, controllerEvidence, now);
     run.managed.sessionUnderstanding = understanding;
     run.managed.understandingRevision = (run.managed.understandingRevision || 0) + 1;
     run.managed.understandingAnswer = null;
@@ -742,9 +1114,9 @@ async function checkpointUnderstanding({ root, provider, session, cwd, checkpoin
     run.managed.workHistory = run.managed.workHistory.slice(-10);
     run.checkpoint = { kind: 'session_understanding', status: 'in_progress', summary: contextText(checkpoint.summary, 1000), evidence: [], acceptanceMet: false };
     run.revision += 1; run.updatedAt = now;
-    if (expectedLease) run.continuations += 1;
+    if (expectedLease && !searchEnabled(run.managed)) run.continuations += 1;
     if (result.status !== 'observed') run.failures += 1;
-    if (run.failures >= run.maxFailures) {
+    if (failureLimitReached(run)) {
       run.state = 'failed'; run.reason = 'Repeated session understanding failures; inspect the original conversation.';
       notifyState(run, now); return record;
     }
@@ -769,6 +1141,12 @@ async function checkpointUnderstanding({ root, provider, session, cwd, checkpoin
       run.managed.phase = 'active';
       run.state = 'reported_done';
       run.reason = 'Original conversation reports no remaining work; independent completion was not verified.';
+      if (purposeEnabled(run)) {
+        run.managed.acceptanceCriteria = understanding.criteria.filter(item => item.source === 'user_grounded').map(item => ({ id: item.id, description: item.description,
+          check: item.check.type === 'file_equals' ? { type: 'file_equals', exactPath: item.check.path, text: item.check.text } : item.check }));
+        if (searchEnabled(run.managed)) queuePurposeVerification(run, 'Original conversation reports completion.', now);
+        else queuePurposeDiagnosis(run, 'The conversation reports completion. Check the original purpose against actual artifacts and outcomes before accepting that claim.', 'reported_completion', now);
+      }
     } else {
       run.managed.phase = 'needs_clarification';
       run.managed.understandingQuestion = { id: randomUUID(), text: understanding.question, revision: run.managed.understandingRevision };
@@ -806,7 +1184,11 @@ export async function verifyAutomaticCriteria(record, now) {
   };
   const failed = (criterion, detail) => { delete managed.verified[criterion.id]; observe(criterion, false, detail); };
   for (const criterion of managed.acceptanceCriteria) {
-    if (criterion.check.type === 'manual') continue;
+    if (criterion.check.type === 'manual') {
+      if (managed.verified[criterion.id]?.source !== 'user') delete managed.verified[criterion.id];
+      continue;
+    }
+    if (criterion.check.type === 'semantic') continue;
     const path = criterion.check.type === 'file_equals' ? criterion.check.exactPath || criterion.check.path : criterion.check.path;
     if (!path) { failed(criterion, 'Frozen acceptance file path is absent'); continue; }
     const directory = taskDirectory(record);
@@ -828,7 +1210,17 @@ export async function verifyAutomaticCriteria(record, now) {
     } catch { failed(criterion, 'Acceptance file could not be independently read'); }
   }
 }
+function purposeCompletionBarrier(run) {
+  const managed=run.managed;
+  if(!searchEnabled(managed)) return null;
+  if(managed.purpose.nativeBoundary || managed.executionUncertain) return 'Required original operation or effect reconciliation is still unresolved.';
+  const ledger=evidenceLedger(managed);
+  for(const unit of ledger.units) if(unit.purposeRevision===ledger.purposeRevision && unit.id.startsWith('criterion:') && unit.criterionIds.every(id=>managed.verified[id])) unit.status='verified';
+  const pending=ledger.units.filter(unit=>unit.required && unit.purposeRevision===ledger.purposeRevision && !['verified','superseded'].includes(unit.status));
+  return pending.length ? 'Required work units still waiting: '+pending.map(unit=>unit.id).join(', ') : null;
+}
 export async function verifyDelivery({ root = rootDirectory(), provider, session, taskId, criterionId, now = Date.now() }) {
+  const started=Date.now(), initialNow=now;
   return updateRecord(root, provider, session, async record => {
     const run = record?.run;
     if (!run?.managed || run.state !== 'verification_pending') throw new Error('Managed task is not awaiting acceptance verification.');
@@ -837,10 +1229,22 @@ export async function verifyDelivery({ root = rootDirectory(), provider, session
     if (!criterion || criterion.check.type !== 'manual') throw new Error('Only manual criteria can be verified by the user.');
     newVerifiedCriterion(run, criterionId, now);
     run.managed.verified[criterionId] = { source: 'user', checkedAt: now };
+    recordPurposeProgress(run, now, false);
+    if (searchEnabled(run.managed)) {
+      const review = run.managed.purpose.search?.review;
+      const currentDigest = await workspaceIdentity(taskDirectory(record), root, undefined, { excludedPaths: review?.manifest?.source === 'controller_certified_independent_proposal' ? review.manifest.exclusions.map(row => row.path) : [] }).catch(() => null);
+      now=initialNow+Math.max(0,Date.now()-started);
+      if (review?.source !== 'independent_codex_session' || !review.session || review.session===session || (!review.passed && !review.needsHuman) || !review.workspaceDigest || currentDigest !== review.workspaceDigest || !externalReviewIsCurrent(run.managed,review,now)) {
+        for (const c of run.managed.acceptanceCriteria) if (c.check.type === 'semantic') delete run.managed.verified[c.id];
+        queuePurposeVerification(run, 'Human decision recorded; recheck the changed workspace before completing.', now);
+      }
+    }
     if (run.state === 'verification_pending' && run.checkpoint?.status === 'completed') {
       await verifyAutomaticCriteria(record, now);
       if (!pendingAcceptance(run).length) {
-        run.state = 'completed'; run.reason = run.checkpoint.summary;
+        const barrier=purposeCompletionBarrier(run);
+        if(barrier) queuePurposeVerification(run, 'Human decision recorded; '+barrier+' Independently reconcile the required operation before completing.', now);
+        else {run.state = 'completed'; run.reason = run.checkpoint.summary;}
       }
     }
     notifyState(run, now);
@@ -884,13 +1288,14 @@ export function prepareRecoveryDiagnosis(run, now = Date.now()) {
 export const STOP_CODES = Object.freeze({ failureLimit: 'failure_limit', noProgressTime: 'no_progress_time', noProgressAttempts: 'no_progress_attempts' });
 export function deliveryStop(run, now = Date.now(), { checkProgress = true } = {}) {
   const managed = run.managed;
-  if (run.failures >= run.maxFailures) return { code: STOP_CODES.failureLimit,
+  if (failureLimitReached(run)) return { code: STOP_CODES.failureLimit,
     reason: `Stopped after ${run.failures} failed attempts. Open the original conversation to see what went wrong.` };
-  if (!checkProgress || !managed) return null;
+  if (purposeEnabled(run) && (now >= run.deadline || run.continuations >= run.maxContinuations || managed.usageBlocked || managed.maxTokens && managed.tokensUsed >= managed.maxTokens)) return { code: 'purpose_budget', reason: 'Original purpose continuation budget exhausted.' };
+  if (!checkProgress || !managed || searchEnabled(managed)) return null;
   const minutes = managed.maxNoProgressMinutes ?? 30;
-  if (now - (managed.lastVerifiedProgressAt ?? run.startedAt) >= minutes * 60_000) return { code: STOP_CODES.noProgressTime,
-    reason: `Paused because no progress was confirmed in ${minutes} minutes. Review the original conversation, then resume.` };
-  if (managed.noProgress >= managed.maxNoProgress) return { code: STOP_CODES.noProgressAttempts,
+  if (now - (purposeEnabled(run) ? purposeProgressAt(run, now) : (managed.lastVerifiedProgressAt ?? run.startedAt)) >= minutes * 60_000) return { code: STOP_CODES.noProgressTime,
+    reason: purposeEnabled(run) ? `No verified acceptance progress in ${minutes} minutes. Review the original conversation, then resume.` : `Paused because no progress was confirmed in ${minutes} minutes. Review the original conversation, then resume.` };
+  if ((purposeEnabled(run) ? managed.purpose.noLearning || 0 : managed.noProgress) >= managed.maxNoProgress) return { code: STOP_CODES.noProgressAttempts,
     reason: `Paused after ${managed.noProgress} steps without confirmed progress. Review the original conversation, then resume.` };
   return null;
 }
@@ -920,7 +1325,7 @@ function continueAfterHumanDecision(run, now) {
   run.managed.outcomeProgress = restartOutcomeProgressWindow(run.managed.outcomeProgress);
   run.managed.lastVerifiedProgressAt = now;
 }
-const stoppedState = stop => stop.code === STOP_CODES.failureLimit ? 'budget_exhausted' : 'paused';
+const stoppedState = stop => [STOP_CODES.failureLimit, 'purpose_budget'].includes(stop.code) ? 'budget_exhausted' : 'paused';
 // Context-first tasks usually have no host-checkable acceptance, so worker
 // reports can never reset noProgress. Reaching that limit pauses for review
 // instead of failing permanently and ending Auto-continue for the conversation.
@@ -956,7 +1361,7 @@ function recordManagedOutcomeProgress(run, now, assessmentAvailable = true) {
 }
 // Manual/legacy runs have no marker and retain their existing controls.
 export function automaticContinuationAllowed(record) {
-  if (record?.providerArchived === true) return false;
+  if (record?.providerArchived === true || record?.run?.managed?.purpose && record.autoContinue === false) return false;
   const epoch = record?.run?.managed?.autoContinueEpoch;
   return !epoch || record.autoContinue === true && record.autoContinueEpoch === epoch;
 }
@@ -1002,7 +1407,7 @@ export function decideStop(run, now = Date.now()) {
     if (!fresh || cp.status === 'error') next.failures += 1;
     else next.failures = 0;
   }
-  if (next.failures >= next.maxFailures) return finish('failed', 'Repeated failure or missing progress checkpoint; human review required.');
+  if (failureLimitReached(next)) return finish('failed', 'Repeated failure or missing progress checkpoint; human review required.');
   if (next.managed) {
     if (next.managed.autonomyPolicy && next.managed.decision?.outcome === 'wait' && !approvedHook) {
       escalate(next, next.managed.decision.reason);
@@ -1027,7 +1432,20 @@ export function decideStop(run, now = Date.now()) {
     else if (next.managed.associationCheckpointRevision !== next.revision && !initialHook && !replanHook && !understandingHook && !approvedHook && !legacyApprovedHook && !['session_understanding', 'action_association'].includes(cp?.kind)) next.managed.noProgress += 1;
     if (reportedStep) next.managed.reportedProgress = (next.managed.reportedProgress || 0) + 1;
     next.managed.consumedVerifiedRevision = next.managed.verifiedRevision;
-    if (next.managed.noProgress >= next.managed.maxNoProgress) {
+    const repeated = repeatedSearchAction(next);
+    if (repeated && !next.managed.pendingApproval && !next.managed.executionUncertain &&
+        queuePurposeDiagnosis(next, `This action failed ${repeated.failures} times against the same observed workspace and acceptance state. Investigate the failure, choose a different method or acquire new evidence before retrying. Prior result: ${repeated.finding}`, `repeated:${repeated.actionKey}:${repeated.context}`, now)) {
+      markSearchPivot(next.managed, 'Repeated failed experiment; select a discriminating alternative.', now);
+      return { run: next, output: {} };
+    }
+    if (searchNeedsPivot(next, now)) {
+      const reason = 'Change the search strategy: review experiments, identify what was ruled out and select a different discriminating method. Lack of final acceptance is not failure.';
+      markSearchPivot(next.managed, reason, now);
+      next.managed.purpose.lastRecovery = { reason, at: now };
+    }
+    if (!searchEnabled(next.managed) && purposeEnabled(next) && next.managed.purpose.noLearning === next.managed.maxNoProgress - 1 &&
+        queuePurposeDiagnosis(next, 'No acceptance progress: revisit the purpose, gather discriminating evidence and choose a different method.', `progress:${next.managed.verifiedRevision}`, now)) return { run: next, output: {} };
+    if (!searchEnabled(next.managed) && next.managed.noProgress >= next.managed.maxNoProgress) {
       const stop = deliveryStop(next, now);
       escalate(next, stop.reason);
       return finish(pausesWithoutProgress(next.managed) ? 'paused' : 'failed', stop.reason);
@@ -1038,7 +1456,7 @@ export function decideStop(run, now = Date.now()) {
   if (replanHook) next.managed.awaitingReplanHook = false;
   if (understandingHook) { next.managed.awaitingUnderstandingHook = false; next.managed.awaitingAssociationHook = false; }
   if (cp?.nextStep) next.nextStep = cp.nextStep;
-  if (!(next.managed?.resumeChannel === 'codex_app_server' && (next.managed.associationCheckpointRevision === next.revision || next.managed.contextBootstrap && cp?.kind === 'session_understanding'))) next.continuations += 1;
+  if (!searchEnabled(next.managed) && !(next.managed?.resumeChannel === 'codex_app_server' && (next.managed.associationCheckpointRevision === next.revision || next.managed.contextBootstrap && cp?.kind === 'session_understanding'))) next.continuations += 1;
   next.updatedAt = now; next.state = 'active';
   if (approvedHook || legacyApprovedHook) {
     const approval = next.managed.approvedAction;
@@ -1051,7 +1469,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}`;
-  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}\nStay within the original request and permissions. If authorization or information is missing, record a blocked checkpoint and stop. Resume this same task; do not start a replacement loop.` } };
+  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
 // as a crash; an idle provider may be waiting for its user.
@@ -1112,7 +1530,7 @@ export async function handleHook({ input, provider, root = rootDirectory(), now
       if (!TERMINAL.has(record.run.state) && !['paused', 'verification_pending'].includes(record.run.state)) {
         if (!(record.run.state === 'blocked' && record.run.managed.pendingApproval)) record.run.state = 'recovery_required';
         record.run.recoveryCause = 'hook_owner_mismatch';
-        record.run.reason = 'A different or unverified Claude process reported this session. Inspect and explicitly resume in the original conversation.';
+        record.run.reason = 'A different or unverified provider process reported this session. Inspect and explicitly resume in the original conversation.';
         record.run.managed.autoRecovery = false; record.run.updatedAt = now; notifyState(record.run, now);
       }
       return record;
@@ -1179,7 +1597,7 @@ export async function handleHook({ input, provider, root = rootDirectory(), now
       run.state = 'recovery_required'; run.recoveryCause = 'session_end'; run.reason = 'Provider session ended. Check why it ended before resuming.';
     } else if (event === 'StopFailure') {
       run.failures += 1;
-      run.state = run.failures >= run.maxFailures ? 'failed' : 'recovery_required'; run.recoveryCause = 'provider_error';
+      run.state = failureLimitReached(run) ? 'failed' : 'recovery_required'; run.recoveryCause = 'provider_error';
       run.reason = RETRYABLE.has(input.error) ? 'Transient provider error. Resume the existing conversation after the provider recovers.' : 'Provider error requires attention before resuming.';
       run.errorCode = text(input.error, 100); run.retryable = RETRYABLE.has(input.error);
     } else if (event === 'Stop') {
@@ -1256,7 +1674,7 @@ export function canReplanDelivery(run, provider, now = Date.now()) {
   const managed = run?.managed;
   const supported = managed?.resumeChannel === 'codex_app_server' && provider === 'codex' ||
     managed?.capability === 'live_hook' && provider === 'claude' && Boolean(managed.liveHookOwner?.identity);
-  return Boolean(supported && managed.autonomyPolicy && managed.approvalScopes?.length && !managed.rejectedActionOverflow &&
+  return canResearchReplan(run, provider, now) || Boolean(supported && managed.autonomyPolicy && managed.approvalScopes?.length && !managed.rejectedActionOverflow &&
     run.state === 'blocked' && managed.pendingApproval?.denied === true &&
     !deliveryStopBlocksResume(run, now));
 }
@@ -1265,7 +1683,7 @@ export function canChangeDeliveryContinuation(run) {
     !['pending', 'pending_received', 'transferred'].includes(run.managed.handoff?.status));
 }
 function reopenLegacyLimitStop(run, now) {
-  if (run?.state !== 'budget_exhausted' ||
+  if (purposeEnabled(run) || run?.state !== 'budget_exhausted' ||
       deliveryStop(run, now)?.code === STOP_CODES.failureLimit ||
       // Reasons persisted by older versions for stops that were not obsolete caps.
       /No verified|failure limit/i.test(run.reason || '') ||
@@ -1277,9 +1695,9 @@ function reopenLegacyLimitStop(run, now) {
   }
   run.state = 'paused'; run.reason = 'SIMY no longer limits time or turns. Resume this task to continue.';
 }
-export async function controlDelivery({ root = rootDirectory(), provider, session, taskId, approvalId, autonomyPolicy, continuationPolicy, questionId, waitId, answer, action, now = Date.now() }) {
+export async function controlDelivery({ root = rootDirectory(), provider, session, taskId, 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, record => {
+    try { return await updateRecord(root, provider, session, async record => {
     const run = record?.run;
     if (!run) throw new Error('Delivery Loop not found.');
     if (record.providerArchived === true && !['stop', 'pause'].includes(action)) throw new Error('Restore the original provider conversation before changing Delivery Loop.');
@@ -1287,16 +1705,44 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
     if (['pending', 'pending_received'].includes(run.managed?.handoff?.status)) throw new Error('Task handoff is locked; use delivery handoff_cancel or retry the same target to complete the transfer.');
     if (action !== 'stop' && run.managed?.handoff?.status === 'transferred') throw new Error('Task handoff is locked; continue in the received target session.');
     reopenLegacyLimitStop(run, now);
-    if (action === 'continuation_policy') {
+    if (action === 'revise_purpose') {
+      if (!searchEnabled(run.managed) || run.managed.resumeLease || run.state !== 'paused' || !text(purposeUpdate?.sourceRef, 500) || !text(purposeUpdate?.objective, 2000)) throw new Error('Pause the task and supply an explicit user purpose revision with sourceRef, objective and acceptanceCriteria.');
+      const revised=managedSpec({acceptanceCriteria:purposeUpdate.acceptanceCriteria,approvalScopes:run.managed.approvalScopes,initialAction:{kind:'read',scope:run.managed.approvalScopes[0],summary:'Reassess the explicitly revised purpose'}},session,provider,null,null,now);
+      const ledger=evidenceLedger(run.managed);
+      ledger.purposeRevisions ||= [];
+      if (ledger.purposeRevisions.length >= 8) throw new Error('Purpose revision history requires archival before another revision.');
+      ledger.purposeRevisions.push({revision:ledger.purposeRevision,charter:ledger.charter,sourceRef:text(purposeUpdate.sourceRef,500),changedAt:now});
+      if(run.managed.purpose.candidate){
+        run.managed.purpose.retainedCandidates ||= [];
+        if(run.managed.purpose.retainedCandidates.length>=8) throw new Error('Retained candidates require explicit archival before another purpose revision.');
+        run.managed.purpose.retainedCandidates.push({...run.managed.purpose.candidate,status:'retained_old_purpose',purposeRevision:ledger.purposeRevision});
+        delete run.managed.purpose.candidate;
+      }
+      ledger.purposeRevision++;
+      for(const unit of ledger.units) if (!['verified','superseded'].includes(unit.status)) unit.status='superseded_by_user_revision';
+      ledger.requirements=ledger.requirements.filter(row=>row.id.startsWith('rule:'));
+      ledger.findings.forEach(row=>{row.status='superseded_by_user_revision';});
+      run.objective=text(purposeUpdate.objective,2000);run.managed.acceptanceCriteria=revised.acceptanceCriteria;run.managed.verified={};
+      ledger.charter={objective:run.objective,criteria:structuredClone(revised.acceptanceCriteria),approvalScopes:[...run.managed.approvalScopes],frozenAt:now,sourceRef:text(purposeUpdate.sourceRef,500)};
+      delete run.managed.enrollment;freezeEnrollment(run,now);
+      run.managed.pendingApproval=null;delete run.managed.approvedAction;delete run.managed.purpose.lastReview;
+      run.managed.purpose.search={cycle:0,pivots:0,experiments:[],waits:[],observed:[],lastPivotCycle:0};
+      run.revision++;run.updatedAt=now;run.reason='User purpose revision recorded; prior evidence and exact approvals require re-evaluation. Resume explicitly within the existing budget.';
+      run.managed.autoRecovery=false;return record;
+    } else if (action === 'continuation_policy') {
       if (!canChangeDeliveryContinuation(run)) throw new Error('Pause a managed task before changing its continuation policy.');
       if (!['bounded', 'progress'].includes(continuationPolicy)) throw new Error('Select an explicit continuation policy.');
       run.managed.continuationPolicy = continuationMode(continuationPolicy);
       run.continuationPolicyHistory ||= [];
       run.continuationPolicyHistory.push({ policy: continuationPolicy, at: now, source: 'explicit_controller_selection' });
+      run.updatedAt = now; return record;
+    } else if (action === 'disable_auto_continue') {
+      if (!run.managed?.purpose) throw new Error('Purpose continuation is not enabled.');
+      run.managed.purpose.enabled = false; run.managed.autoRecovery = false;
+      if (!TERMINAL.has(run.state)) { run.state = 'paused'; run.reason = 'Automatic continuation paused by user.'; }
       run.updatedAt = now;
       return record;
-    }
-    if (action === 'dependency_ready') {
+    } else if (action === 'dependency_ready') {
       const wait = run.managed?.dependencyWait;
       if (run.state !== 'blocked' || run.blocker !== 'external_dependency' || !wait || wait.id !== waitId ||
           typeof answer !== 'string' || !text(answer, 1000) || answer.length > 1000) throw new Error('Dependency wait changed or confirmation is empty; refresh its status.');
@@ -1340,6 +1786,7 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
       else { run.state = 'recovery_required'; run.recoveryCause = 'policy_change'; run.reason = 'Policy changed; resume the original conversation for the selected action.'; run.managed.autoRecovery = false; }
     }
     else if (action === 'stop') {
+      run.stopReason = { actor: 'user', code: 'explicit_stop', at: now };
       if (TERMINAL.has(run.state)) return record;
       run.state = 'stopped'; run.reason = 'Stopped by user.';
     }
@@ -1349,34 +1796,44 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
       if (!run.managed || !['active', 'auto_resuming'].includes(run.state) && !queuedAppServer) throw new Error('Only a running or queued managed task can pause.');
       if (queuedAppServer || run.state === 'auto_resuming' && run.managed.resumeChannel === 'codex_app_server') run.managed.pausedRecoveryCause = run.recoveryCause || 'session_supervision';
       run.state = 'paused'; run.reason = 'Paused by user.';
+      run.stopReason = { actor: 'user', code: 'explicit_pause', at: now };
     }
     else if (action === 'replan') {
-      if (!canReplanDelivery(run, provider, now)) throw new Error('Replanning needs a rejected assessed approval, a supported original-session channel, and fewer failures than the limit.');
-      continueAfterHumanDecision(run, now);
+      if (!canReplanDelivery(run, provider, now)) throw new Error('Replanning needs a supported original-session channel, a rejected assessed approval or safe research wait, and available budget.');
+      const research = canResearchReplan(run, provider, now);
+      if (research && run.managed.capability === 'live_hook') {
+        const owner = run.managed.liveHookOwner || record.hookSessionProcess;
+        if (run.managed.thread?.provider !== provider || run.managed.thread.id !== session ||
+            !owner?.identity || !record.hookStartedAt || record.hookEndedAt ||
+            record.process?.pid !== owner.pid || record.process?.identity !== owner.identity ||
+            await inspectProcess(owner.pid) !== owner.identity) throw new Error('Research replanning requires the original verified live hook owner.');
+        run.managed.liveHookOwner ||= { ...owner, hookStartedAt: record.hookStartedAt };
+      }
+      if (!research) continueAfterHumanDecision(run, now);
       const rejected = run.managed.pendingApproval;
-      // Also cover denied records written by earlier versions before rejection
-      // fingerprints existed; never re-authorize that exact action on upgrade.
-      rememberRejectedAction(run.managed, rejected);
-      const plan = rejectedActionDiagnosis(run.managed, rejected);
+      // Denied records remain denied; research waits never create an approval.
+      if (!research) rememberRejectedAction(run.managed, rejected);
+      const plan = research ? researchWaitDiagnosis(run.managed) : rejectedActionDiagnosis(run.managed, rejected);
       const decision = recordDecision(run.managed, plan, now);
-      if (decision.outcome !== 'proceed' || decision.action.kind !== 'read') throw new Error('Safe read diagnosis is unavailable; keep the rejected action blocked.');
+      if (decision.outcome !== 'proceed' || decision.action.kind !== 'read') throw new Error('Safe read diagnosis is unavailable; keep the waiting action blocked.');
       delete run.managed.approvedAction;
       run.managed.userQuestion = null;
       run.managed.escalation = null;
       run.blocker = null;
-      run.nextStep = 'Review the recorded rejection and propose a different assessed option without executing it.';
+      run.nextStep = research ? 'Inspect local assessment evidence and propose a corrected assessed option without executing the waiting action.' : 'Review the recorded rejection and propose a different assessed option without executing it.';
       run.checkpoint = null; run.consumedRevision = run.revision;
       if (run.managed.resumeChannel === 'codex_app_server') {
         run.managed.autoRecovery = true;
         run.state = 'recovery_required'; run.recoveryCause = 'session_supervision';
-        run.reason = 'Rejected action remains denied; safe read diagnosis is queued in the exact Codex session.';
+        run.reason = research ? 'Research wait remains unexecuted; safe read diagnosis is queued in the exact Codex session.' : 'Rejected action remains denied; safe read diagnosis is queued in the exact Codex session.';
       } else {
         run.managed.awaitingReplanHook = true;
         run.state = 'active';
-        run.reason = 'Rejected action remains denied; safe read diagnosis awaits the original Claude Stop boundary.';
+        run.reason = research ? 'Research wait remains unexecuted; safe read diagnosis awaits the original provider Stop boundary.' : 'Rejected action remains denied; safe read diagnosis awaits the original Claude Stop boundary.';
       }
     }
     else if (action === 'resume') {
+      delete run.stopReason;
       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.');
@@ -1397,7 +1854,7 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
       const selectedKind = run.managed?.decision?.action?.kind;
       const approvedWait = run.managed?.decision?.outcome === 'wait' && run.managed.approvedAction?.id === run.managed.decision.id && !run.managed.approvedAction.dispatchedAt;
       const queuedAppServer = run.managed?.resumeChannel === 'codex_app_server' &&
-        ['read', 'local_edit', 'local_test'].includes(selectedKind) &&
+        ['read', 'local_edit', 'local_test', ...(searchEnabled(run.managed) ? ['external'] : [])].includes(selectedKind) &&
         (run.managed.decision.outcome !== 'wait' || approvedWait);
       if (queuedAppServer) run.managed.autoRecovery = true;
       run.state = queuedAppServer ? 'recovery_required' : 'active';
@@ -1418,6 +1875,7 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
         run.checkpoint = { status: 'in_progress', summary: run.reason, nextStep: run.nextStep, evidence: [], acceptanceMet: false };
         run.revision += 1;
         run.managed.approvedAction = { id: pending.id, nextStep: run.nextStep, action: { kind: pending.kind, scope: pending.scope, summary: pending.summary } };
+        if (searchEnabled(run.managed) && run.managed.resumeChannel === 'codex_app_server' && pending.kind === 'external' && run.managed.decision?.assessment?.reversibility === 'reversible') run.managed.autoRecovery = true;
       } else {
         pending.denied = true; run.reason = `User rejected ${pending.scope}.`; run.blocker = 'authorization';
         rememberRejectedAction(run.managed, pending);
@@ -1457,6 +1915,7 @@ export async function reconcileRecords({ root = rootDirectory(), now = Date.now(
       const stop = deliveryStop(run, now, { checkProgress: !activeTurn });
       if (stop && !TERMINAL.has(run.state) && !['verification_pending', 'paused'].includes(run.state)) {
         run.state = stoppedState(stop);
+        run.stopReason = { actor: 'system', code: stop.code, at: now, evidence: stop.reason };
         run.reason = stop.reason; run.updatedAt = now;
       }
       else if (run.state === 'active' && observed !== null && observed !== current.process?.identity && current.process?.identity === record.process?.identity) {