@awak-app/simy-cli 0.7.25 → 0.7.26

package/src/session-supervision/codex-app-server.js

@@ -2,7 +2,7 @@ import { agentRole } from '../codex-plugins/simy/hooks/loop-kernel.mjs';
 import { captureAcceptanceReads } from './acceptance-reads.js';
 import { providerFailureDiagnostic } from './provider-failure.js';
 import { captureDispatchProvenance } from '../update-detachment/provenance.js';
-import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, rootFromDelivery } from '../update-detachment/dispatch-gate.js';
+import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, queueProviderTerminalReceipt, rootFromDelivery } from '../update-detachment/dispatch-gate.js';
 import { normalizePullRequests } from './pull-requests.js';
 import { delegatedNativeSandbox, canWriteWorkspace, authorizedWorktreeGitRoots } from './native-delegation.js';
 import { flexibleReasoning } from '../codex-plugins/simy/hooks/purpose-cycle.mjs';
@@ -541,7 +541,16 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     let cursor = null;
     do {
       if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
-      const page = await readPage(cursor, ANALYSIS_MAX_TURNS - turns.filter(terminal).length);
+      let page;
+      try { page = await readPage(cursor, ANALYSIS_MAX_TURNS - turns.filter(terminal).length); }
+      catch (error) {
+        // An oversized older turn (often attachments) must not discard an
+        // already complete recent exchange. This is omitted history, not a
+        // fabricated turn. Latest-page overflow still fails closed, and the
+        // classifier must judge whether the bounded context is sufficient.
+        if (cursor && turns.some(terminal) && error?.code === 'response_too_large') break;
+        throw error;
+      }
       for (const turn of page.data) {
         if (typeof turn?.id !== 'string' || !turn.id || turnIds.has(turn.id)) throw new CodexAppServerError('context_unavailable', 'Codex returned ambiguous conversation pagination.');
         turnIds.add(turn.id); turns.push(turn);
@@ -654,9 +663,10 @@ async function frozenNativeSandbox(record, root, signal) {
   return policy;
 }
 
-export async function executeCodexAppServer(record, { webOrigin, openClient = openCodexAppServer, signal, authorizePreparation = async () => {}, beforeDispatch = async () => {}, onStarted = async () => {}, onActivity = () => {}, onUsage = () => {}, onEvidence = async () => {}, observeExternal = collectPurposeObservations, root, auditOnly = false, opinionOnly = false, peerAction, runPeerReview = runCodexPeerOpinion } = {}) {
+export async function executeCodexAppServer(record, { webOrigin, openClient = openCodexAppServer, signal, authorizePreparation = async () => {}, beforeDispatch = async () => {}, onStarted = async () => {}, onActivity = () => {}, onUsage = () => {}, onEvidence = async () => {}, observeExternal = collectPurposeObservations, root, auditOnly = false, opinionOnly = false, peerAction, dispatchAttemptId: requestedAttemptId, runPeerReview = runCodexPeerOpinion } = {}) {
   const dispatchOwner = captureDispatchOwner(root ? rootFromDelivery(root) : undefined);
   let dispatchAttemptId;
+  if (requestedAttemptId && (!auditOnly || record.run?.managed?.outcomeAudit?.lease?.id !== requestedAttemptId)) throw new CodexAppServerError('identity', 'Independent audit dispatch must use its original lease.');
   const provenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: record.provider, providerSession: record.session, worktree: taskDirectory(record), taskId: record.run.managed.taskId, recordRef: recordPath(root || rootDirectory(), record.provider, record.session) });
   assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance });
   const run = record.run, decision = run.managed?.decision;
@@ -697,13 +707,29 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
       output_schema: { type: 'object', properties: { opinion: { type: 'string' } }, required: ['opinion'], additionalProperties: false },
     }, { signal, readOnlyAnalysis: true, allowAutomaticRetry: false,
       model: run.managed.resumeModel, cwd: taskDirectory(record), openClient, readAuthentication: readCodexAuthentication,
-      dispatchTransport: initiate => dispatchWithFence(dispatchOwner, { taskId: run.managed.taskId || record.session, attemptId: run.managed.resumeLease?.id, provenance }, attemptId => {
+      dispatchTransport: initiate => dispatchWithFence(dispatchOwner, { taskId: run.managed.taskId || record.session, attemptId: requestedAttemptId || run.managed.resumeLease?.id,
+        provenance: captureDispatchProvenance({ root: dispatchOwner.root, provider: record.provider, providerSession: peerSession,
+          worktree: taskDirectory(record), taskId: run.managed.taskId || record.session, recordRef: recordPath(root || rootDirectory(), record.provider, record.session) }) }, attemptId => {
+        assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance });
         if (root && hasPendingUserStop(root, record)) throw new CodexAppServerError('cancelled', 'User stopped this provider task.');
         dispatchAttemptId = attemptId;
         return initiate();
       }),
       beforeDispatch: async () => { await authorizePreparation(); await beforeDispatch({ type: 'readOnly', networkAccess: false }); },
-      onContext: session => { if (peerSession && peerSession !== session) ambiguousContext = true; peerSession = session; },
+      onContext: async session => {
+        if (!session || session === record.session || peerSession && peerSession !== session) { ambiguousContext = true; throw new CodexAppServerError('identity', 'Independent peer context changed.'); }
+        peerSession = session;
+        await onEvidence({ source: 'adapter_capture', actionId: decision.id, workerContext: { session, originalSession: record.session, cwd: taskDirectory(record), model: run.managed.resumeModel, ephemeralRequested: true } });
+      },
+      onStarted: ({ session, turnId }) => {
+        if (!dispatchAttemptId || session !== peerSession) throw new CodexAppServerError('identity', 'Independent peer identity changed.');
+        queueDispatchReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, receiptId: `provider:${dispatchAttemptId}:${turnId}`, providerExecutionId: turnId });
+        onActivity();
+      },
+      onTerminal: ({ session, turnId, status, response }) => {
+        if (!dispatchAttemptId || session !== peerSession || session === record.session) throw new CodexAppServerError('identity', 'Independent peer identity changed.');
+        queueProviderTerminalReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, providerSession: session, providerExecutionId: turnId, status, response });
+      },
       onUsage: observed => { usage = observed; onUsage(observed); } });
     if (!peerSession || peerSession === record.session || ambiguousContext || typeof reply.output?.opinion !== 'string' || !reply.output.opinion.trim()) throw new CodexAppServerError('identity', 'Independent peer context or opinion unavailable.');
     return { code: 0, dispatchAttemptId, opinion: { text: evidenceExcerpt(reply.output.opinion, 2000).text, source: 'independent_codex_session', session: peerSession, model: reply.model }, usage, toolEvidence: [] };
@@ -722,6 +748,8 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
   const beforeEvidence = searchEnabled(run.managed) && !reviewing ? await captureWorkspace() : null;
   let evidenceQueue = Promise.resolve(), evidenceFailure = null;
   let activeTurnId = null, turnCompleted = false, turnStart = null, startReceipt = null;
+  let releaseTurnNotifications, terminalResolve;
+  const terminalObserved = new Promise(resolve => { terminalResolve = resolve; });
   let usage = null, lastTotal = null;
   try {
     // An unavailable login is a connection dependency, not an action approval.
@@ -870,13 +898,18 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
         lastTotal = Math.max(lastTotal ?? 0, total);
         onUsage({ ...usage });
       };
-      const cleanup = () => { unsubscribe(); signal?.removeEventListener('abort', cancelled); client.child.removeListener('close', closed); };
+      const cleanup = () => { releaseTurnNotifications = unsubscribe; signal?.removeEventListener('abort', cancelled); client.child.removeListener('close', closed); };
       const finish = (error, value) => { if (settled) return; settled = true; cleanup(); if (error) reject(error); else resolve(value); };
       const cancelled = () => finish(new CodexAppServerError('cancelled', 'Codex turn was cancelled.'));
       const closed = () => finish(new CodexAppServerError('closed', 'Codex app-server closed before turn completion.'));
       const complete = () => {
         if (!completion || !turnId || !startRecorded || completion.turn?.id !== turnId) return;
         turnCompleted = true;
+        try { queueProviderTerminalReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, providerSession: targetSession,
+          providerExecutionId: turnId, status: completion.turn.status, response: messages.get(turnId) || '' }); }
+        catch (error) { terminalResolve(); return finish(error); }
+        terminalResolve();
+        if (settled) return;
         if (completion.turn.status !== 'completed') return finish(new CodexAppServerError('turn_failed', 'Codex turn did not complete.'));
         const message = messages.get(turnId);
         if (!message || Buffer.byteLength(message) > (run.managed.purpose?.enabled ? 128 : 16) * 1024) return finish(new CodexAppServerError('checkpoint', 'Codex did not return a bounded checkpoint.'));
@@ -887,6 +920,13 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
         }
       };
       const unsubscribe = client.onNotification((method, params, requestId) => {
+        if (settled) {
+          if (requestId === undefined && params.threadId === targetSession) {
+            if (method === 'item/completed' && params.turnId === turnId && params.item?.type === 'agentMessage') messages.set(turnId, params.item.text);
+            if (method === 'turn/completed' && params.turn?.id === turnId) { completion = params; complete(); }
+          }
+          return;
+        }
         if (requestId !== undefined && params.threadId === targetSession && /requestApproval|requestPermissions/i.test(method)) return finish(Object.assign(new CodexAppServerError('provider_approval', 'Codex requires provider approval or user input.'), { providerTurnId: params.turnId || turnId }));
         if (requestId !== undefined && params.threadId === targetSession && /requestUserInput/i.test(method)) return finish(Object.assign(new CodexAppServerError(searchEnabled(run.managed) ? 'provider_question' : 'provider_approval', 'Provider asked a question; investigate before requesting a human decision.'), { providerTurnId: params.turnId || turnId, question: evidenceExcerpt(params.questions || [], 2000).text }));
         if (params.threadId !== targetSession) return;
@@ -905,7 +945,7 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
       signal?.addEventListener('abort', cancelled, { once: true });
       client.child.once('close', closed);
       const targetProvenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: record.provider, providerSession: targetSession, worktree: isolated ? executionCwd : record.cwd, taskId: run.managed.taskId || record.session, recordRef: recordPath(root || rootDirectory(), record.provider, record.session) });
-      turnStart = dispatchWithFence(dispatchOwner, { taskId: run.managed.taskId || record.session, attemptId: run.managed.resumeLease?.id, provenance: targetProvenance }, attemptId => { assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance }); if (root && hasPendingUserStop(root, record)) throw new CodexAppServerError('cancelled', 'User stopped this provider task.'); dispatchAttemptId = attemptId; return client.request('turn/start', { threadId: targetSession, input: [{ type: 'text', text: `${prompt}\n${purposeInstruction}` }], cwd: isolated ? executionCwd : record.cwd,
+      turnStart = dispatchWithFence(dispatchOwner, { taskId: run.managed.taskId || record.session, attemptId: requestedAttemptId || run.managed.resumeLease?.id, provenance: targetProvenance }, attemptId => { assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance }); if (root && hasPendingUserStop(root, record)) throw new CodexAppServerError('cancelled', 'User stopped this provider task.'); dispatchAttemptId = attemptId; return client.request('turn/start', { threadId: targetSession, input: [{ type: 'text', text: `${prompt}\n${purposeInstruction}` }], cwd: isolated ? executionCwd : record.cwd,
         model: run.managed.resumeModel, ...(isolated ? {sandboxPolicy} : {}) }); })
         .then(async response => { turnId = response?.turn?.id; activeTurnId = turnId; if (turnId) queueDispatchReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, receiptId: `provider:${dispatchAttemptId}:${turnId}`, providerExecutionId: turnId }); if (!turnId) finish(new CodexAppServerError('turn_failed', 'Codex did not start a turn.')); else {
           startReceipt = Promise.resolve().then(() => onStarted({ turnId, session: targetSession }));
@@ -991,6 +1031,11 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
       if (turnStart && !activeTurnId) await Promise.race([turnStart, new Promise(resolve => setTimeout(resolve, 2_000))]).catch(() => {});
       if (!turnCompleted && activeTurnId) await client.request('turn/interrupt', { threadId: targetSession, turnId: activeTurnId }, 2_000).catch(() => {});
     }
+    if (activeTurnId && !turnCompleted && !client.closed) await new Promise(resolve => {
+      const timer = setTimeout(resolve, 2_000);
+      terminalObserved.then(() => { clearTimeout(timer); resolve(); });
+    });
+    releaseTurnNotifications?.();
     await client.close();
 
   }

package/src/session-supervision/codex-peer-opinion.js

@@ -11,16 +11,22 @@ const disabledFeatures = [
 export async function runCodexPeerOpinion(provider, request, {
   model, cwd, openClient, readAuthentication, signal,
   beforeDispatch = async () => {}, dispatchTransport = initiate => initiate(),
-  onContext = () => {}, onUsage = () => {}, timeoutMs = 120_000,
+  onContext = () => {}, onUsage = () => {}, onStarted = () => {}, onTerminal = () => {}, timeoutMs = 120_000,
 } = {}) {
   if (provider !== 'codex' || !model || !cwd || !openClient || !readAuthentication) {
     throw new Error('Peer opinion requires the task’s Codex transport, model and workspace.');
   }
   signal = AbortSignal.any([...(signal ? [signal] : []), AbortSignal.timeout(timeoutMs)]);
   signal.throwIfAborted();
-  const client = await openClient({ signal, cancelOnAbort: true, isolateConnectors: true, maxLineBytes: 1024 * 1024 });
+  const client = await openClient({ signal, cancelOnAbort: false, isolateConnectors: true, maxLineBytes: 1024 * 1024 });
   let threadId, turnId, completed = false, unsubscribe, abort, closed;
-  let startPromise;
+  let startPromise, terminalResolve;
+  const terminalObserved = new Promise(resolve => { terminalResolve = resolve; });
+  // Preparation is abortable, but an owned turn must get a bounded chance to
+  // report interruption before its transport is closed.
+  let preparing = true;
+  const cancelPreparation = () => { if (preparing) void client.close(); };
+  signal.addEventListener('abort', cancelPreparation, { once: true });
   try {
     if (await readAuthentication(client) === 'missing') {
       throw Object.assign(new Error('The task’s Codex account is not signed in.'), { code: 'authentication_required' });
@@ -73,9 +79,14 @@ export async function runCodexPeerOpinion(provider, request, {
       }
     };
     const finish = () => {
-      if (settled || !turnId || !turns.has(turnId)) return;
+      if (!turnId || !turns.has(turnId)) return;
       const turn = turns.get(turnId);
+      if (completed) return;
       completed = true;
+      try { onTerminal({ session: threadId, turnId, status: turn.status, response: messages.get(turnId) || '' }); }
+      catch (error) { terminalResolve(); return fail(error); }
+      terminalResolve();
+      if (settled) return;
       if (turn.status !== 'completed') return fail(Object.assign(new Error('Peer turn did not complete.'), { code: 'turn_failed' }));
       let output;
       try { output = JSON.parse(messages.get(turnId) || ''); } catch {
@@ -89,6 +100,7 @@ export async function runCodexPeerOpinion(provider, request, {
     };
     unsubscribe = client.onNotification((method, params, requestId) => {
       if (params.threadId !== threadId) return;
+      if (settled && !['item/completed', 'turn/completed'].includes(method)) return;
       if (requestId !== undefined) return fail(Object.assign(new Error('Peer requested a tool or approval.'), { code: 'provider_approval' }));
       if (method === 'item/completed' && params.item?.type === 'agentMessage') messages.set(params.turnId, params.item.text);
       if (['item/started', 'item/completed'].includes(method) && ['commandExecution', 'mcpToolCall', 'fileChange', 'webSearch', 'dynamicToolCall'].includes(params.item?.type)) {
@@ -108,6 +120,8 @@ export async function runCodexPeerOpinion(provider, request, {
     client.child?.once('close', closed);
     await beforeDispatch();
     signal?.throwIfAborted();
+    preparing = false;
+    signal.removeEventListener('abort', cancelPreparation);
     startPromise = Promise.resolve(dispatchTransport(() => client.request('turn/start', {
       threadId, model, cwd, input: [{ type: 'text', text: request.prompt }],
       outputSchema: request.output_schema, sandboxPolicy: { type: 'readOnly', networkAccess: false },
@@ -115,14 +129,22 @@ export async function runCodexPeerOpinion(provider, request, {
     const started = await Promise.race([startPromise, done]);
     turnId = started.turn?.id;
     if (!turnId) throw new Error('Peer turn did not start.');
+    await onStarted({ session: threadId, turnId });
     reportUsage();
     finish();
     return await done;
   } finally {
     signal?.removeEventListener('abort', abort);
     if (closed) client.child?.removeListener('close', closed);
+    signal.removeEventListener('abort', cancelPreparation);
+    if (!completed && turnId && !client.closed) {
+      await client.request('turn/interrupt', { threadId, turnId }, 2000).catch(() => {});
+      if (!completed && !client.closed) await new Promise(resolve => {
+        const timer = setTimeout(resolve, 2000);
+        terminalObserved.then(() => { clearTimeout(timer); resolve(); });
+      });
+    }
     unsubscribe?.();
-    if (!completed && turnId) await client.request('turn/interrupt', { threadId, turnId }, 2000).catch(() => {});
     await client.close();
   }
 }

package/src/session-supervision/consistency-auditor.js

@@ -121,7 +121,7 @@ async function auditConsistencyAttempt(record, findings, request, { root, signal
   };
   let usage = null, usageWrites = Promise.resolve();
   try {
-    result = await execute(view, { root, signal: controller.signal, openClient, auditOnly: true, opinionOnly, peerAction: record.run.managed.decision?.action, authorizePreparation:beforeDispatch,
+    result = await execute(view, { root, signal: controller.signal, openClient, auditOnly: true, opinionOnly, dispatchAttemptId: id, peerAction: record.run.managed.decision?.action, authorizePreparation:beforeDispatch,
       beforeDispatch: async () => { await beforeDispatch(); await retainDiagnostic('dispatching'); },
       onEvidence: evidence => {
         const context = evidence?.workerContext;

package/src/session-supervision/continuation-analysis.js

@@ -1,3 +1,4 @@
+import { OUTCOME_PLAN_SCHEMA, OUTCOME_PLAN_INSTRUCTION, validateOutcomePlan } from './outcome-plan.js';
 import { withSceneReasoning } from '../codex-plugins/simy/hooks/scene-reasoning.mjs';
 import { correctiveFollowupInstruction } from '../codex-plugins/simy/hooks/result-cycle.mjs';
 import { readCodexConversation } from './codex-app-server.js';
@@ -7,7 +8,7 @@ import { runStructuredProviderReview } from '../sqm/review-worker.js';
 import { inspectProviderStatus } from '../desktop-status.js';
 import { createHash } from 'node:crypto';
 
-export const CONTINUATION_ANALYSIS_VERSION = 10;
+export const CONTINUATION_ANALYSIS_VERSION = 11;
 const BLOCKER_TYPES = ['approval', 'missing_information', 'external_dependency', 'execution_failure'];
 const STATES = ['continue', 'no_action', 'needs_user', 'waiting', 'uncertain'];
 const string = maximum => ({ type: 'string', maxLength: maximum });
@@ -17,8 +18,9 @@ const EVIDENCE_SCHEMA = {
 };
 const OUTPUT_SCHEMA = {
   type: 'object', additionalProperties: false,
-  required: ['state', 'reason', 'objective', 'remaining', 'nextAction', 'basis', 'assessment', 'blocker', 'pendingActions', 'nextActionAuthorization'],
+  required: ['state', 'reason', 'objective', 'remaining', 'nextAction', 'basis', 'assessment', 'blocker', 'pendingActions', 'nextActionAuthorization', 'outcomePlan'],
   properties: {
+    outcomePlan: { anyOf: [{ type: 'null' }, OUTCOME_PLAN_SCHEMA] },
     state: { type: 'string', enum: STATES }, reason: string(600), objective: string(600),
     remaining: { type: 'array', maxItems: 8, items: string(400) },
     nextAction: { anyOf: [string(600), { type: 'null' }] },
@@ -53,6 +55,7 @@ Determine whether the ORIGINAL user request contains concrete unfinished work wi
 ${correctiveFollowupInstruction} In this read-only classifier, select and ground the next action; do not perform it or answer the user yourself. A corrective question can establish investigation intent in context; use earlier still-valid work authorization for repairs and tests. Mere uncertainty about a completed result does not prove a defect: investigate the specific disputed outcome without inventing implementation work.
 When supplied, originalProviderGoal is read-only goal metadata from this exact original conversation. Consider its objective together with the latest finished conversation evidence. An active goal can span several turns: a finished subtask does not necessarily finish the whole goal. Active status alone is NOT evidence of remaining actionable work; require concrete unfinished work in the finished messages. Later user corrections, cancellation and permissions still govern. A complete goal adds no new work or acceptance obligations; a distinct later explicit user request can be assessed on its own. Never resume a paused/blocked/usageLimited/budgetLimited goal or reset its limits. Goal evidence must use role=goal, turnRef=provider-goal and a verbatim excerpt from its objective; never present goal metadata as a human message. A truncated goal is incomplete evidence.
 Write objective in the original user's language as the intended user experience: who should be able to do what, in which situation. Preserve the actual requested scope; do not replace the outcome with implementation tasks, test commands or constraints. Keep constraints in the reasoning and authorization checks. Do not invent an experience when the user only requested technical work.
+${OUTCOME_PLAN_INSTRUCTION}
 State rules:
 - A final answer or missing plan/checkpoint alone is not completion. If original requested implementation remains explicitly unfinished, generate a concrete authorized next action even when the assistant supplied none; use enabling conditions, alternative routes or independent work. If only comparison and a Word document were requested and delivered, unimplemented features described in that document are outside scope. Do not let a generic completion phrase override concrete contradictory unfinished-work evidence, or invent gaps when the requested outcome is reported complete.
 - continue: the user requested concrete work, work remains unfinished, and a specific feasible next step can be safely taken within existing authority. A continued local investigation/edit/test can qualify. Require user evidence for the objective AND evidence of concrete remaining work. Do not invent additional acceptance checks after the assistant says the requested work is done.
@@ -181,7 +184,8 @@ export function validateContinuationAnalysis(output, context) {
   if (blocker && (!assessment.userRequestedWork || !assessment.unfinished || assessment.optionalFollowUp ||
       !['needs_user', 'waiting', 'uncertain'].includes(state))) throw new Error('Blocker contradicts task status');
   if (validatedPendingActions.length && (!assessment.userRequestedWork || !assessment.unfinished || assessment.optionalFollowUp || state === 'no_action')) throw new Error('Pending action contradicts task status');
-  return { state, reason, objective, remaining, nextAction: state === 'continue' ? output.nextAction : null, basis, blocker,
+  const outcomePlan = validateOutcomePlan(output.outcomePlan, { objective, state, nextAction: output.nextAction, validateEvidence });
+  return { state, reason, objective, remaining, outcomePlan, nextAction: state === 'continue' ? output.nextAction : null, basis, blocker,
     ...(Object.hasOwn(output, 'pendingActions') ? { pendingActions: validatedPendingActions } : {}),
     ...(Object.hasOwn(output, 'nextActionAuthorization') ? { nextActionAuthorization: state === 'continue' ? nextActionAuthorization : null } : {}),
     analysisVersion: CONTINUATION_ANALYSIS_VERSION };

package/src/session-supervision/decision-presentation.js

@@ -30,7 +30,7 @@ export function sessionDecisionPresentation(candidate, run) {
     choices: [],
   };
   if (run?.dependencyWait || run?.autoRecovery && ['recovery_required', 'auto_resuming'].includes(run.state) ||
-      ['supervising', 'watching', 'waiting'].includes(candidate.autoContinueStatus)) return null;
+      ['supervising', 'watching', 'waiting', 'starting', 'recovering'].includes(candidate.autoContinueStatus)) return null;
   if (run && ['recovery_required', 'paused', 'failed', 'blocked'].includes(run.state)) {
     const providerName = candidate.provider === 'claude' ? 'Claude' : candidate.provider === 'codex' ? 'Codex' : 'AI';
     const context = run.state === 'paused' ? 'この作業は停止中です。停止の指示は自動で解除しません。' : ({ session_end: `元の${providerName}会話が終了し、自動継続が止まっています。`,

package/src/session-supervision/index.js

@@ -127,7 +127,7 @@ function navigationParent(item, record) {
 }
 
 export async function discoverSessions({ root, openClient = openCodexAppServer, listClaude = listClaudeSessions,
-  inspectProcess = processIdentity, now: requestedNow, signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false } = {}) {
+  inspectProcess = processIdentity, now: requestedNow, signal, listCodexTitles = readCodexTitles, listCodexChildren = readCodexChildSessions, codexHome, connectedProviders = ['codex', 'claude'], includeArchived = false, includeSelectionCandidates = false } = {}) {
   const now = requestedNow ?? Date.now();
   const assertActive = () => { if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.'); };
   assertActive();
@@ -269,7 +269,11 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     }
   }
   const projected = new Array(items.length);
-  const codexTitles = items.some(item => item.provider === 'codex' && !sessionTitle(item.title)) ? await listCodexTitles() : new Map();
+  const codexTitles = connected.has('codex') && (includeSelectionCandidates || items.some(item => item.provider === 'codex' && !sessionTitle(item.title)))
+    ? await listCodexTitles({ codexHome }) : new Map();
+  // Title-index entries are navigation hints, not verified session metadata.
+  // Manual addition still reads the exact provider session before persisting.
+  const selectionCandidates = includeSelectionCandidates ? [...codexTitles].map(([session, title]) => ({ provider: 'codex', session, title })) : undefined;
   assertActive();
   let nextItem = 0;
   const project = async item => {
@@ -337,14 +341,15 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       ...autoContinueState(record, isRunning, availability),
       lastActivityAt: item.lastActivityAt, createdAt: item.createdAt ?? null, observation, availability: item.availability,
       taskId: run?.managed?.taskId || record?.associationTaskId || null,
-      binding: { mode, taskId: run?.managed?.taskId || record?.associationTaskId || null },
+      binding: { mode, taskId: run?.managed?.taskId || record?.associationTaskId || null,
+        ...(upgradeable ? { upgradeRunId: run.id } : {}) },
       originalSessionTarget: originalSessionTarget(item.provider, item.session),
       continuationMode: item.provider === 'claude' ? liveHook ? 'live_hook' : 'manual' : supported ? 'codex_app_server' : 'manual',
       ...(!archived && continuationAdmission ? { continuationAdmission } : {}),
       continuationReasonCode: availability.reasonCode || claudeChannel?.code || 'ready',
       capabilities: { canMonitor: item.capabilities?.canMonitor ?? true,
         canPurposeContinue: !archived && supported && (!run || !['completed', 'reported_done', 'stopped', 'failed', 'budget_exhausted'].includes(run.state)),
-        canAnalyze: !archived && !run && (item.provider === 'codex' ? item.observation.source === 'codex_app_server' && !codexError : item.observation.source === 'claude_local_index' && !claudeError),
+        canAnalyze: !archived && (item.provider === 'codex' ? item.observation.source === 'codex_app_server' && !codexError : item.observation.source === 'claude_local_index' && !claudeError),
         canEnroll: !archived && (supported || liveHook) && !run, canContinue: !archived && (supported || liveHook) && !run,
         canAutoContinue: !archived && (supported || liveHook) && (!run || upgradeable || Boolean(run.managed) && !TERMINAL_RUNS.has(run.state)) },
       reason: item.provider === 'claude' ? continuationIssue?.reason || claudeChannel.reason :
@@ -364,7 +369,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   const stateNow = requestedNow ?? Date.now();
   for (const candidate of projected) candidate.workState = sessionWorkState(candidate, recordsByKey.get(`${candidate.provider}:${candidate.session}`)?.run, { now: stateNow });
   projected.sort(compareSessionWork);
-  return { sessions: includeArchived ? projected : projected.filter(item => !item.archived && !item.localHidden), providers: { codex: { discovery: !connected.has('codex') ? 'disconnected' : codexError ? 'unavailable' : 'ready', reason: codexError }, claude: { discovery: !connected.has('claude') ? 'disconnected' : claudeError ? 'unavailable' : 'local_index', reason: claudeError } }, refreshedAt: now };
+  return { ...(selectionCandidates ? { selectionCandidates } : {}), sessions: includeArchived ? projected : projected.filter(item => !item.archived && !item.localHidden), providers: { codex: { discovery: !connected.has('codex') ? 'disconnected' : codexError ? 'unavailable' : 'ready', reason: codexError }, claude: { discovery: !connected.has('claude') ? 'disconnected' : claudeError ? 'unavailable' : 'local_index', reason: claudeError } }, refreshedAt: now };
 }
 
 // Saving consent needs an exact admitted identity, not another provider RPC.
@@ -447,6 +452,10 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
           failureBudgetMode: purposeFailureMode(next),
           ruleDigest: purposeRules.digest, ruleIds: purposeRules.rules.map(rule => rule.id) };
         if (next.run.state === 'paused' && next.run.reason === 'Automatic continuation paused by user.') { next.run.state = 'recovery_required'; next.run.recoveryCause = 'session_supervision'; next.run.managed.autoRecovery = true; }
+        // OFF keeps the current native turn alive. Re-enabling during that
+        // same turn restores future continuation without starting another turn.
+        if (previous.autoContinue === false && next.run.state === 'auto_resuming' && next.run.stopReason?.actor !== 'user')
+          next.run.managed.autoRecovery = true;
       } else if (!enabled && next.run.managed.purpose) { if (next.run.state !== 'auto_resuming') next.run.managed.purpose.enabled = false; next.run.managed.autoRecovery = false; if (!TERMINAL_RUNS.has(next.run.state) && next.run.state !== 'auto_resuming') { next.run.state = 'paused'; next.run.reason = 'Automatic continuation paused by user.'; } }
     }
     // The desktop preference is an explicit human control too: an old decision
@@ -454,20 +463,17 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
     if (next.run) advanceDeliveryControlRevision(next.run);
     return next;
   });
-  if (enabled && updated.run && !updated.run.managed) {
-    // Enrollment checks this exact opt-in epoch under its state lock, so an
-    // overlapping Off action prevents the promotion from dispatching work.
-    await continueSession({ ...options, root, provider, session,
-      ...updated.autoContinueSettings, autoContinueEpoch: updated.autoContinueEpoch, expectedProviderEpoch: link.epoch });
-    return readRecord(root, provider, session);
-  }
+  // Consent is durable now. Provider reads and ordinary-loop promotion belong
+  // to the background coordinator, so their failure cannot undo this response.
   return updated;
 }
 
 export async function readSessionAutoContinue({ root, provider, session }) {
   const record = await readRecord(root, provider, session);
   return { enabled: record?.autoContinue === true, epoch: record?.autoContinueEpoch || null,
-    settings: record?.autoContinueSettings, hasRun: Boolean(record?.run) };
+    settings: record?.autoContinueSettings, hasRun: Boolean(record?.run),
+    upgradeRunId: canUpgradeDelivery(record?.run, { automatic: true })
+      ? record.run.id : null };
 }
 
 // Tracking is local observation metadata. It neither starts nor stops the
@@ -577,6 +583,8 @@ export async function followupSession(options) {
 export async function continueSession(options) {
   options = sessionLoopOptions(options);
   const record = await readRecord(options.root, options.provider, options.session);
+  if (options.upgradeRunId && (record?.run?.id !== options.upgradeRunId || record.run.managed))
+    throw Object.assign(new Error('The original task changed before automatic continuation started.'), { code: 'session_task_changed' });
   if (record?.run && !record.run.managed) {
     // The user asked to continue this task. Adopt its goal and failure budget,
     // rather than enrolling the generic context-bootstrap goal as a new run.

package/src/session-supervision/outcome-plan.js

@@ -0,0 +1,76 @@
+import { sanitizedText } from './conversation-context.js';
+
+// A read-only route to the requested outcome. Never an execution permission or
+// acceptance certificate. Old/partial analyses intentionally have no plan.
+const text = { type: 'string', minLength: 1, maxLength: 600 };
+const id = { type: 'string', pattern: '^[a-zA-Z0-9_-]{1,60}$' };
+const evidence = { type: 'array', maxItems: 6, items: {
+  type: 'object', additionalProperties: false, required: ['role', 'turnRef', 'snippet'],
+  properties: { role: { type: 'string', enum: ['user', 'assistant', 'goal'] },
+    turnRef: { type: 'string', maxLength: 160 }, snippet: { type: 'string', maxLength: 280 } },
+} };
+export const OUTCOME_PLAN_SCHEMA = {
+  type: 'object', additionalProperties: false, required: ['destination', 'criteria', 'steps'],
+  properties: {
+    destination: text,
+    criteria: { type: 'array', minItems: 1, maxItems: 8, items: {
+      type: 'object', additionalProperties: false, required: ['id', 'description', 'basis'],
+      properties: { id, description: text, basis: evidence },
+    } },
+    steps: { type: 'array', minItems: 1, maxItems: 12, items: {
+      type: 'object', additionalProperties: false,
+      required: ['id', 'title', 'criterionIds', 'dependsOn', 'exitCondition', 'state', 'evidence'],
+      properties: { id, title: text, exitCondition: text,
+        criterionIds: { type: 'array', minItems: 1, maxItems: 8, items: id },
+        dependsOn: { type: 'array', maxItems: 11, items: id },
+        state: { type: 'string', enum: ['planned', 'current', 'reported'] }, evidence },
+    } },
+  },
+};
+
+export const OUTCOME_PLAN_INSTRUCTION = `Return outcomePlan as a destination-driven proposed route, separate from chronological work reports. First identify the user's requested destination (exactly objective) and observable completion criteria grounded in direct user or active original-goal evidence. Work BACKWARDS from each criterion: what result must exist immediately before it, and what prerequisites enable that result? Then return those necessary steps in dependency/execution order. Every step must link to criterionIds and have a concrete observable exitCondition; cover every criterion. Do not turn paths, HEAD hashes, commands executed or investigation diary entries into milestones. Infer reasonable prerequisite steps within scope, but never add publication, deployment or other outcomes the user did not request. A plan grants no authority. Preserve blocked/future stages even when one safe action can proceed.
+For each criterion include verbatim basis citations establishing requested scope; assistant suggestions alone are not requirements. For each step use planned unless the conversation explicitly reports its result (reported, with verbatim user/assistant evidence). Reported never means independently verified. At most one step is current; only for state=continue, and its title must exactly equal nextAction. Current depends only on stages reported accomplished; otherwise include the next enabling prerequisite first. Never mark an inferred step accomplished. For answered questions, casual chat, insufficient destination/criteria evidence or a route you cannot ground, return outcomePlan=null rather than inventing a full workflow. Do not treat an absent plan as a reason to continue completed work.`;
+
+export function validateOutcomePlan(value, { objective, state, nextAction, validateEvidence }) {
+  if (value == null) return null;
+  try {
+    const string = value => {
+      if (typeof value !== 'string' || !value.trim() || value.length > 600 || sanitizedText(value) !== value || /[\u0000-\u0008\u000b\u000c\u000e-\u001f]/u.test(value)) throw Error('Invalid text');
+      return value;
+    };
+    const identifier = value => { if (typeof value !== 'string' || !/^[a-zA-Z0-9_-]{1,60}$/.test(value)) throw Error('Invalid id'); return value; };
+    const list = (value, max, min = 0) => { if (!Array.isArray(value) || value.length < min || value.length > max) throw Error('Invalid list'); return value; };
+    if (value.destination !== objective || !objective) throw Error('Wrong destination');
+    const ids = new Set();
+    const criteria = list(value.criteria, 8, 1).map(c => {
+      const id = identifier(c.id);
+      if (ids.has(id)) throw Error('Duplicate criterion');
+      ids.add(id);
+      const basis = list(c.basis, 6, 1).map(validateEvidence);
+      if (!basis.every(e => ['user', 'goal'].includes(e.role))) throw Error('Unrequested criterion');
+      return { id, description: string(c.description), basis };
+    });
+    const prior = new Map(), covered = new Set();
+    let current = 0;
+    const steps = list(value.steps, 12, 1).map(s => {
+      const id = identifier(s.id), title = string(s.title), exitCondition = string(s.exitCondition);
+      if (prior.has(id) || !['planned', 'current', 'reported'].includes(s.state)) throw Error('Invalid step');
+      const criterionIds = list(s.criterionIds, 8, 1).map(identifier);
+      if (criterionIds.some(id => !ids.has(id))) throw Error('Unknown criterion');
+      criterionIds.forEach(id => covered.add(id));
+      const dependsOn = list(s.dependsOn, 11).map(identifier);
+      // Prior-only references reject cycles and forward/missing dependencies.
+      if (dependsOn.some(id => !prior.has(id))) throw Error('Invalid dependency');
+      const evidence = list(s.evidence, 6).map(validateEvidence);
+      if (s.state === 'reported' && (!evidence.length || evidence.some(e => e.role === 'goal'))) throw Error('Missing result report');
+      if (s.state === 'current' && (++current > 1 || state !== 'continue' || title !== nextAction || dependsOn.some(id => prior.get(id) !== 'reported'))) throw Error('Wrong current step');
+      prior.set(id, s.state);
+      return { id, title, criterionIds, dependsOn, exitCondition, state: s.state, evidence };
+    });
+    if (covered.size !== ids.size || state === 'continue' && current !== 1) throw Error('Incomplete route');
+    return { destination: objective, criteria, steps };
+  } catch {
+    // An optional presentation plan must never change triage/dispatch authority.
+    return null;
+  }
+}

package/src/session-supervision/purpose-instruction.js

@@ -9,6 +9,33 @@ import { readFile, readdir } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import { purposeContract, llmDecisionInstruction } from '../codex-plugins/simy/hooks/purpose-cycle.mjs';
 const root = new URL('../orchestrator/delivery/', import.meta.url);
+
+// Transport context is a view. Scheduling, effects, stops and acceptance keep
+// using the complete durable ledger; old alternatives must not exhaust RPC input.
+export function purposeInstructionContext(managed) {
+  const view = structuredClone(managed), ledger = view.purpose?.evidence;
+  if (!Array.isArray(ledger?.units) || ledger.units.length <= 64) return view;
+  const ids = new Set([view.decision?.id, view.recoveryDiagnosisDecisionId,
+    view.executionUncertain?.decisionId].filter(Boolean));
+  const byId = new Map(ledger.units.map(unit => [unit.id, unit]));
+  const pending = [...ids];
+  for (let index = 0; index < pending.length; index++) {
+    for (const id of byId.get(pending[index])?.dependsOn || []) if (!ids.has(id)) {
+      ids.add(id); pending.push(id);
+    }
+  }
+  const important = ledger.units.filter(unit => ids.has(unit.id) ||
+    ['unknown','running','dispatched','in_flight'].includes(unit.status));
+  const chosen = [...important, ...ledger.units.slice(-48)];
+  const unique = new Map(chosen.map(unit => [unit.id, unit]));
+  const statuses = {};
+  for (const unit of ledger.units) statuses[unit.status] = (statuses[unit.status] || 0) + 1;
+  ledger.contextProjection = { totalUnits: ledger.units.length, includedUnits: unique.size,
+    omittedUnits: ledger.units.length - unique.size, statuses,
+    note: 'Transmission view only. Omitted operations remain in durable state, not completed or authorized. Read additional units through the existing delivery status CLI when needed; select fields rather than dumping the full ledger.' };
+  ledger.units = [...unique.values()];
+  return view;
+}
 // Optional reference material must not become an execution prerequisite.
 export async function loadPurposeRuleSet(options = {}) {
   try { return await readPurposeRuleSet(options); }
@@ -45,6 +72,7 @@ async function readPurposeRuleSet({ readFileImpl = readFile, readdirImpl = readd
 }
 export async function buildPurposeInstruction(managed, { reviewer = false, cwd, webOrigin, allowNetwork = false, signal, knowledgeLoader = loadHypothesisKnowledge, authorizeKnowledgeNetwork, root: memoryRoot, record, memoryLoader = recallPerspectives } = {}) {
   if (!managed?.purpose?.enabled) return withSceneReasoning();
+  managed = purposeInstructionContext(managed);
   const ruleSet = await loadPurposeRuleSet();
   if (reviewer) return `${llmDecisionInstruction}\nInspect the requested behavior and report concrete defects or missing outcomes. Consult relevant references only when useful. No rule inventory coverage, proof attachments, score or audit receipt is required.`;
   const knowledge = await knowledgeLoader({ cwd, webOrigin, allowNetwork, signal, ...(authorizeKnowledgeNetwork ? { authorizeNetwork: authorizeKnowledgeNetwork } : {}) });

package/src/session-supervision/recovery-frontier.js

@@ -3,6 +3,18 @@ import { reconcileWorkFrontier, revalidateWorkProposal } from '../codex-plugins/
 import { searchEnabled } from '../codex-plugins/simy/hooks/purpose-search.mjs';
 import { taskDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 
+function frontierOptions(record) {
+  const m = record.run.managed, ledger = m.purpose?.evidence;
+  const prior = ledger?.units?.find(unit => unit.id === m.executionUncertain?.decisionId);
+  // This controller-created read exists to reconcile one retained unknown
+  // effect. Keep that effect unknown and fence all writers and other holders.
+  const reconciling = m.decision?.action?.kind === 'read' &&
+    m.recoveryDiagnosisDecisionId === m.decision.id && prior?.status === 'unknown' &&
+    prior.owner === m.taskId && prior.purposeRevision === ledger.purposeRevision;
+  return { stopped: ['paused', 'stopped', 'cancelled'].includes(record.run.state),
+    ...(reconciling ? { reconcileUnknownUnitId: prior.id } : {}) };
+}
+
 // Enroll the controller's canonical workspace, never a worker-provided lock ID.
 // Read-only diagnosis/verification is the path that resolves observed effects;
 // it must remain possible while the frontier prevents another writer.
@@ -30,7 +42,7 @@ export function recoveryWorkProposal(record) {
       if (unit.action.kind !== 'read' && !unit.writeResources.includes(workspace)) unit.writeResources.push(workspace);
     }
     // Missing PR readback stays blocked. This boundary never invents CI evidence.
-    const proposal = reconcileWorkFrontier(managed, { stopped: ['paused', 'stopped', 'cancelled'].includes(record.run.state) });
+    const proposal = reconcileWorkFrontier(managed, frontierOptions(record));
     delete managed.frontierIssue;
     return proposal;
   } catch {
@@ -45,9 +57,7 @@ export function admitRecoveryWork(record, proposal, leaseId, now) {
   const unit = managed.purpose.evidence.units.find(row => row.id === managed.decision.id);
   if (!unit && managed.decision.action.kind === 'read' && ['understanding', 'needs_clarification'].includes(managed.phase)) return;
   if (!unit) throw new Error('Selected work unit is missing.');
-  const current = revalidateWorkProposal(managed, proposal, unit.id, {
-    stopped: ['paused', 'stopped', 'cancelled'].includes(record.run.state),
-  });
+  const current = revalidateWorkProposal(managed, proposal, unit.id, frontierOptions(record));
   if (!current.eligible) {
     throw new Error(`Work proposal needs reconciliation: ${current.reason || 'not eligible'}`);
   }

package/src/session-supervision/remote-command-queue.js

@@ -0,0 +1,15 @@
+// A remote usage scan must not hold up explicit preference or stop requests.
+// Mutations retain arrival order; authorization remains in the native handlers.
+export function createRemoteCommandQueue({ handle }) {
+  let controls = Promise.resolve(), observations = Promise.resolve();
+  return {
+    enqueue(command) {
+      const observation = ['session_statistics', 'refresh'].includes(command.action);
+      const pending = (observation ? observations : controls).then(() => handle(command));
+      // Keep a failed request from poisoning subsequent requests in that lane.
+      if (observation) observations = pending.catch(() => {});
+      else controls = pending.catch(() => {});
+      return pending;
+    },
+  };
+}

package/src/session-supervision/remote-control.js

@@ -1,3 +1,6 @@
+export { createRemoteManagedDelivery } from './remote-managed-delivery.js';
+export { createRemoteCommandQueue } from './remote-command-queue.js';
+
 // Only host-discovered admission may reach the native mutation API.
 export function createControl({ authorize, select, set, followup, save, revoke, root }) {
   return async command => {