@awak-app/simy-cli 0.5.34 → 0.5.36

package/src/delivery-hooks/command.js

@@ -1,14 +1,26 @@
 import { readFile } from 'node:fs/promises';
-import { startDelivery, checkpointDelivery, controlDelivery, listRecords, rootDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { startDelivery, checkpointDelivery, controlDelivery, listRecords, rootDirectory, verifyDelivery } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 
-export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = process.cwd(), output = console.log } = {}) {
+async function readCheckpointInput(input) {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of input) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    bytes += buffer.length;
+    if (bytes > 64 * 1024) throw new Error('Checkpoint exceeds 64 KiB.');
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = process.cwd(), input = process.stdin, output = console.log } = {}) {
   const [action, ...args] = argv;
   if (!action || action === '--help') {
-    output('simy delivery start --provider codex|claude --session ID --objective TEXT --next-step TEXT [--max-continuations 6] [--max-failures 3] [--max-minutes 30]\nsimy delivery checkpoint --provider codex|claude --session ID --file checkpoint.json\nsimy delivery status\nsimy delivery stop|resume --provider codex|claude --session ID\nEnable and review SIMY hooks in your provider first. Starting a loop opts in only this session. Resume requires the user to resolve the blocker; original budgets are retained.');
+    output('simy delivery start --provider codex|claude --session ID --objective TEXT --next-step TEXT [--managed-file task.json] [--max-continuations 6] [--max-failures 3] [--max-minutes 30]\nsimy delivery checkpoint --provider codex|claude --session ID --file checkpoint.json|-\nsimy delivery status\nsimy delivery stop|pause|resume --provider codex|claude --session ID [--task-id ID]\nsimy delivery replan --provider PROVIDER --session ID --task-id ID\nsimy delivery approve|reject --provider PROVIDER --session ID --task-id ID --approval-id ID\nsimy delivery verify --provider PROVIDER --session ID --task-id ID --criterion-id ID\nsimy delivery set_policy --provider PROVIDER --session ID --task-id ID --autonomy-policy strict|balanced|autonomous\nEnable and review SIMY hooks in your provider first. Manual managed start requires an acceptance specification. Desktop Continue infers the original conversation goal first. Resume preserves original budgets.');
     return 0;
   }
   const options = {};
-  const allowed = new Set(['provider', 'session', 'objective', 'next-step', 'max-continuations', 'max-failures', 'max-minutes', 'file']);
+  const allowed = new Set(['provider', 'session', 'objective', 'next-step', 'max-continuations', 'max-failures', 'max-minutes', 'file', 'managed-file', 'task-id', 'approval-id', 'criterion-id', 'autonomy-policy']);
   for (let i = 0; i < args.length; i += 2) {
     const key = args[i]?.replace(/^--/, '');
     if (!args[i]?.startsWith('--') || !allowed.has(key) || args[i + 1] === undefined || Object.hasOwn(options, key)) throw new Error('Invalid delivery option. Use simy delivery --help.');
@@ -17,14 +29,23 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
   const base = { root, cwd, provider: options.provider, session: options.session };
   let result;
   if (action === 'status') result = (await listRecords(root)).filter(r => (!options.provider || r.provider === options.provider) && (!options.session || r.session === options.session));
-  else if (action === 'start') result = await startDelivery({ ...base, objective: options.objective, nextStep: options['next-step'],
+  else if (action === 'start') {
+    let managed;
+    if (options['managed-file']) {
+      const data = await readFile(options['managed-file'], 'utf8');
+      if (Buffer.byteLength(data) > 64 * 1024) throw new Error('Managed task specification exceeds 64 KiB.');
+      managed = JSON.parse(data);
+    }
+    result = await startDelivery({ ...base, objective: options.objective, nextStep: options['next-step'], managed,
     ...Object.fromEntries([['max-continuations', 'maxContinuations'], ['max-failures', 'maxFailures'], ['max-minutes', 'maxMinutes']].filter(([key]) => options[key] !== undefined).map(([key, field]) => [field, Number(options[key])])) });
+  }
   else if (action === 'checkpoint') {
     if (!options.file) throw new Error('--file is required.');
-    const data = await readFile(options.file, 'utf8');
+    const data = options.file === '-' ? await readCheckpointInput(input) : await readFile(options.file, 'utf8');
     if (Buffer.byteLength(data) > 64 * 1024) throw new Error('Checkpoint exceeds 64 KiB.');
     result = await checkpointDelivery({ ...base, checkpoint: JSON.parse(data) });
-  } else if (['stop', 'resume'].includes(action)) result = await controlDelivery({ ...base, action });
+  } else if (['stop', 'pause', 'resume', 'replan', 'approve', 'reject', 'set_policy'].includes(action)) result = await controlDelivery({ ...base, taskId: options['task-id'], approvalId: options['approval-id'], autonomyPolicy: options['autonomy-policy'], action });
+  else if (action === 'verify') result = await verifyDelivery({ ...base, taskId: options['task-id'], criterionId: options['criterion-id'] });
   else throw new Error('Unknown delivery command.');
   output(JSON.stringify(result, null, 2));
   return 0;

package/src/delivery-hooks/desktop.js

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { reconcileRecords, rootDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { canReplanDelivery, reconcileRecords, rootDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { originalSessionTarget } from '../session-supervision/original-session-target.js';
 
 export const HOOK_SETUP = Object.freeze({
   codex: { settingsUrl: 'codex://settings', docsUrl: 'https://learn.chatgpt.com/docs/hooks', command: '/hooks' },
@@ -11,13 +12,46 @@ export async function deliveryHookStatus({ root = rootDirectory(), now = Date.no
   const records = await reconcileRecords({ root, now });
   return {
     providers: Object.fromEntries(['codex', 'claude'].map(provider => {
-      const latest = records.filter(r => r.provider === provider).sort((a, b) => b.observedAt - a.observedAt)[0];
+      const latest = records.filter(r => r.provider === provider && Number.isFinite(r.observedAt)).sort((a, b) => b.observedAt - a.observedAt)[0];
       return [provider, { ...HOOK_SETUP[provider], state: latest ? 'observed' : 'not_observed', lastObservedAt: latest?.observedAt || null }];
     })),
     runs: records.filter(r => r.run).sort((a, b) => b.run.updatedAt - a.run.updatedAt).slice(0, 30).map(r => ({
-      provider: r.provider, session: r.session, objective: r.run.objective, state: r.run.state, reason: r.run.reason,
+      provider: r.provider, session: r.session, originalSessionTarget: originalSessionTarget(r.provider, r.session),
+      objective: r.run.objective, state: r.run.state, reason: r.run.reason,
       continuations: r.run.continuations, maxContinuations: r.run.maxContinuations, deadline: r.run.deadline,
-      needsAttention: ['blocked', 'failed', 'recovery_required', 'budget_exhausted'].includes(r.run.state), updatedAt: r.run.updatedAt,
+      needsAttention: ['blocked', 'failed', 'recovery_required', 'budget_exhausted', 'verification_pending'].includes(r.run.state), updatedAt: r.run.updatedAt,
+      managed: Boolean(r.run.managed), taskId: r.run.managed?.taskId || null, actionId: r.run.managed?.actionId || null,
+      actionDueAt: r.run.managed?.actionDueAt ?? null,
+      thread: r.run.managed?.thread || null, acceptanceCriteria: (r.run.managed?.acceptanceCriteria || []).map(item =>
+        item.check?.type === 'file_equals' ? { ...item, check: { type: 'file_equals', path: item.check.exactPath || item.check.path, text: item.check.text } } : item),
+      phase: r.run.managed?.phase || 'active', sessionUnderstanding: r.run.managed?.sessionUnderstanding || null,
+      understandingQuestion: r.run.managed?.understandingQuestion || null,
+      remainingWork: r.run.managed?.remainingWork || null, nextStep: r.run.nextStep,
+      pendingApproval: r.run.managed?.pendingApproval || null,
+      autonomyPolicy: r.run.managed?.autonomyPolicy || null, plan: r.run.managed?.plan || null,
+      decision: r.run.managed?.decision || null, decisionHistory: r.run.managed?.decisionHistory || [],
+      escalation: r.run.managed?.escalation || null,
+      approvedAction: r.run.managed?.approvedAction || null,
+      providerWarning: r.run.managed?.providerWarning || null,
+      capability: r.run.managed ? (r.run.state === 'recovery_required' && !r.run.managed.autoRecovery ? 'manual_recovery' :
+        r.run.managed.resumeChannel === 'codex_app_server' ? 'codex_app_server' :
+          r.run.state === 'auto_resuming' ? 'codex_exec_resume' : r.run.managed.capability) : 'live_hook',
+      notification: r.run.managed?.notification || null,
+      verification: r.run.managed ? { verified: Object.keys(r.run.managed.verified).length, total: r.run.managed.acceptanceCriteria.length,
+        pending: r.run.managed.acceptanceCriteria.filter(item => !Object.hasOwn(r.run.managed.verified, item.id)).map(item => item.id),
+        results: r.run.managed.verified } : null,
+      canStop: !['completed', 'reported_done', 'stopped', 'failed', 'budget_exhausted'].includes(r.run.state),
+      canPause: Boolean(r.run.managed) && (['active', 'auto_resuming'].includes(r.run.state) ||
+        r.run.state === 'recovery_required' && ['session_supervision', 'approved_action'].includes(r.run.recoveryCause) &&
+        r.run.managed.resumeChannel === 'codex_app_server' && r.run.managed.autoRecovery),
+      canResume: ['blocked', 'recovery_required', 'paused'].includes(r.run.state) && r.run.managed?.phase !== 'needs_clarification' &&
+        !r.run.managed?.pendingApproval && now < r.run.deadline && r.run.continuations < r.run.maxContinuations,
+      canApprove: r.run.state === 'blocked' && Boolean(r.run.managed?.pendingApproval) && !r.run.managed.pendingApproval.denied,
+      canReject: r.run.state === 'blocked' && Boolean(r.run.managed?.pendingApproval) && !r.run.managed.pendingApproval.denied,
+      canReplan: canReplanDelivery(r.run, r.provider, now),
+      canAnswer: r.run.managed?.phase === 'needs_clarification' && r.run.state === 'blocked' && Boolean(r.run.managed.understandingQuestion?.id) &&
+        now < r.run.deadline && r.run.continuations < r.run.maxContinuations && r.run.failures < r.run.maxFailures,
+      canSetPolicy: Boolean(r.run.managed?.autonomyPolicy) && !['completed', 'reported_done', 'stopped', 'failed', 'budget_exhausted'].includes(r.run.state),
     })),
   };
 }

package/src/delivery-hooks/supervisor.js

@@ -0,0 +1,281 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { dirname } from 'node:path';
+import { assessedCheckpointContract, checkpointDelivery, decideStop, listRecords, notifyState, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { resolveBackendExecutable } from '../backend-executable.js';
+import { executeCodexAppServer } from '../session-supervision/codex-app-server.js';
+
+const MAX_OUTPUT = 64 * 1024;
+const SAFE_PROVIDER_CODES = new Set(['identity', 'permission_narrowed', 'permission_restore', 'turn_failed', 'checkpoint',
+  'closed', 'timeout', 'unsupported', 'unavailable', 'manual_provider_action', 'checkpoint_rejected', 'provider_approval']);
+function safeProviderCode(code) { return SAFE_PROVIDER_CODES.has(code) ? code : 'provider_error'; }
+function providerFailureReason(code) {
+  if (code === 'permission_restore') return 'Codex sandbox restoration could not be confirmed; inspect the original conversation before resuming.';
+  if (code === 'permission_narrowed') return 'The original Codex sandbox no longer permits the selected action.';
+  if (code === 'identity') return 'Codex session identity, workspace, or model changed; inspect before resuming.';
+  if (code === 'checkpoint' || code === 'checkpoint_rejected') return 'Codex returned an invalid managed checkpoint; inspect its plan before resuming.';
+  if (code === 'turn_failed') return 'The Codex turn did not complete; inspect the original conversation.';
+  return 'Codex recovery process failed; inspect its checkpoint and original session before manual resume.';
+}
+async function assertActiveLease(root, provider, session, leaseId, signal, currentTime = Date.now) {
+  if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
+  const current = (await listRecords(root)).find(item => item.provider === provider && item.session === session);
+  if (signal?.aborted || current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) {
+    throw new Error('Managed recovery lease changed before provider dispatch.');
+  }
+  if (currentTime() >= current.run.deadline) throw new Error('Managed recovery deadline expired before provider dispatch.');
+  const managed = current.run.managed;
+  const approvedWait = managed.decision?.outcome === 'wait' && managed.approvedAction?.id === managed.decision.id && !managed.approvedAction.dispatchedAt;
+  if (managed.autonomyPolicy && ((managed.decision?.outcome === 'wait' && !approvedWait) || managed.resumeLease.decisionId !== managed.decision?.id)) throw new Error('Assessed action changed before provider dispatch.');
+}
+export function parseAgentCheckpoint(output, expectedSession) {
+  let message = null;
+  let startedSession = null;
+  for (const line of String(output).split('\n')) {
+    try {
+      const event = JSON.parse(line);
+      if (event.type === 'thread.started') {
+        if (startedSession && startedSession !== event.thread_id) throw new Error('Codex reported inconsistent thread identities.');
+        startedSession = event.thread_id;
+      }
+      if (event.type === 'item.completed' && event.item?.type === 'agent_message') message = event.item.text;
+    } catch (error) { if (error?.message === 'Codex reported inconsistent thread identities.') throw error; }
+  }
+  if (startedSession !== expectedSession) throw new Error('Codex resumed a different or unverified thread.');
+  if (!message || Buffer.byteLength(message) > 16 * 1024) throw new Error('Codex did not return a bounded final checkpoint.');
+  let checkpoint;
+  try { checkpoint = JSON.parse(message); } catch { throw new Error('Codex final message was not a JSON checkpoint.'); }
+  if (!checkpoint || typeof checkpoint !== 'object' || Array.isArray(checkpoint)) throw new Error('Invalid Codex checkpoint.');
+  return checkpoint;
+}
+
+// The provider CLI is a new process. It is used only for an exact Codex UUID
+// enrolled for this recovery channel after a corroborated process exit.
+export async function executeCodexResume(record, { signal, root, leaseId, executable = resolveBackendExecutable, currentTime = Date.now } = {}) {
+  if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
+  const binary = await executable('codex');
+  if (!binary) throw new Error('Codex executable unavailable.');
+  await assertActiveLease(root, record.provider, record.session, leaseId, signal, currentTime);
+  const run = record.run;
+  const context = { taskId: run.managed.taskId, session: record.session, objective: run.objective, nextStep: run.nextStep,
+    remainingWork: run.managed.remainingWork, acceptanceCriteria: run.managed.acceptanceCriteria, proposedAction: run.managed.proposedAction,
+    currentDecision: run.managed.autonomyPolicy ? run.managed.decision : undefined, diagnosis: run.managed.plan?.diagnosis,
+    budgets: { continuations: run.continuations, maxContinuations: run.maxContinuations, failures: run.failures, maxFailures: run.maxFailures, deadline: run.deadline } };
+  const prompt = run.managed.autonomyPolicy ? `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\nExecute ONLY currentDecision.action. Its expectedVerification and rollback apply to this turn. Stay within provider permissions. End with ONLY one JSON checkpoint. ${assessedCheckpointContract(run.managed.decision)} Do not write SIMY state directly.` : `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\nStay within the original task and provider permissions. End with ONLY one JSON object: {"status":"in_progress|completed|blocked|error","summary":"...","nextStep":"...","remainingWork":"...","proposedAction":{"kind":"read|local_edit|local_test|external|destructive|scope_change|unknown","scope":"...","summary":"..."},"evidence":[],"acceptanceMet":false}. For blocked include blocker (authorization, missing_information, external_dependency), and for authorization include approval {kind,scope,summary}. Do not claim completion without checking frozen acceptance. SIMY independently verifies supported criteria. Do not write SIMY state directly. If approval or input is needed, return blocked and stop.`;
+  const sandbox = run.managed.autonomyPolicy && run.managed.decision?.action.kind === 'read' ? 'read-only' : run.managed.autoRecoverySandbox;
+  const args = ['exec', '--json', '--skip-git-repo-check', '-s', sandbox, '-m', run.managed.resumeModel, 'resume', record.session, prompt];
+  if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
+  if (currentTime() >= run.deadline) throw new Error('Managed recovery deadline expired before provider dispatch.');
+  return new Promise((resolve, reject) => {
+    const child = spawn(binary, args, { cwd: record.cwd, stdio: ['ignore', 'pipe', 'pipe'], signal,
+      env: { ...process.env, SIMY_HOME: dirname(root) } });
+    let error = '', spawnError = null, pending = '', lastMessage = null;
+    const startedSessions = new Set();
+    const consumeLine = line => {
+      if (Buffer.byteLength(line) > MAX_OUTPUT) return;
+      try {
+        const event = JSON.parse(line);
+        if (event.type === 'thread.started' && typeof event.thread_id === 'string') startedSessions.add(event.thread_id);
+        if (event.type === 'item.completed' && event.item?.type === 'agent_message' && typeof event.item.text === 'string') lastMessage = event.item.text;
+      } catch { /* Other provider events are ignored. */ }
+    };
+    let forceKill;
+    const terminate = () => {
+      if (child.exitCode !== null || forceKill) return;
+      child.kill('SIGTERM');
+      forceKill = setTimeout(() => child.kill('SIGKILL'), 2_000);
+      forceKill.unref();
+    };
+    signal?.addEventListener('abort', terminate, { once: true });
+    const watch = setInterval(() => {
+      void listRecords(root).then(records => {
+        const current = records.find(item => item.provider === record.provider && item.session === record.session);
+        if (current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) terminate();
+      }).catch(terminate);
+    }, 500);
+    watch.unref();
+    child.stdout.on('data', chunk => {
+      const lines = (pending + chunk).split('\n');
+      pending = lines.pop().slice(-MAX_OUTPUT);
+      for (const line of lines) consumeLine(line);
+    });
+    child.stderr.on('data', chunk => { error = (error + chunk).slice(-MAX_OUTPUT); });
+    const cleanup = () => { clearInterval(watch); clearTimeout(forceKill); signal?.removeEventListener('abort', terminate); };
+    child.once('error', failure => { spawnError = failure; terminate(); });
+    child.once('close', code => {
+      cleanup(); if (pending) consumeLine(pending);
+      const output = [...startedSessions].map(thread_id => JSON.stringify({ type: 'thread.started', thread_id })).join('\n') + '\n' +
+        (lastMessage === null ? '' : JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: lastMessage } }));
+      if (spawnError) reject(spawnError); else resolve({ code, output, error });
+    });
+  });
+}
+
+export async function tickManagedTasks({ root, now = Date.now(), execute, inspectProcess, signal } = {}) {
+  const tickWallStart = Date.now();
+  const currentTime = () => now + Math.max(0, Date.now() - tickWallStart);
+  if (signal?.aborted) return;
+  await reconcileRecords({ root, now, ...(inspectProcess ? { inspectProcess } : {}) });
+  if (signal?.aborted) return;
+  const records = await listRecords(root);
+  for (const record of records) {
+    if (signal?.aborted) break;
+    const claimNow = currentTime();
+    const run = record.run;
+    if (!run?.managed) continue;
+    if (run.state === 'auto_resuming' && claimNow - run.managed.resumeLease?.claimedAt > 5 * 60_000) {
+      await updateRecord(root, record.provider, record.session, current => {
+        if (current?.run?.state !== 'auto_resuming' || current.run.managed.resumeLease?.id !== run.managed.resumeLease?.id) return current;
+        current.run.state = 'recovery_required'; current.run.managed.autoRecovery = false;
+        current.run.reason = 'Managed recovery was interrupted; inspect the original session before manual resume.';
+        current.run.updatedAt = claimNow; notifyState(current.run, claimNow); return current;
+      });
+      continue;
+    }
+    const appServer = run.managed.resumeChannel === 'codex_app_server';
+    const causeAllowed = run.recoveryCause === 'process_exit' || appServer && ['session_supervision', 'approved_action'].includes(run.recoveryCause);
+    const approvedWait = run.managed.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test'].includes(run.managed.decision.action?.kind) &&
+      run.managed.approvedAction?.id === run.managed.decision.id && !run.managed.approvedAction.dispatchedAt;
+    if (run.state !== 'recovery_required' || !causeAllowed || !run.managed.autoRecovery || run.managed.pendingApproval || run.managed.autonomyPolicy && run.managed.decision?.outcome === 'wait' && !approvedWait || appServer && run.managed.nextAttemptAt > claimNow) continue;
+    const leaseId = randomUUID();
+    let claimed;
+    try { claimed = await updateRecord(root, record.provider, record.session, current => {
+      const live = current?.run;
+      const appChannel = live?.managed?.resumeChannel === 'codex_app_server';
+      const allowedCause = live?.recoveryCause === 'process_exit' || appChannel && ['session_supervision', 'approved_action'].includes(live?.recoveryCause);
+      const approved = live?.managed?.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test'].includes(live.managed.decision.action?.kind) &&
+        live.managed.approvedAction?.id === live.managed.decision.id && !live.managed.approvedAction.dispatchedAt;
+      if (!live?.managed?.autoRecovery || live.state !== 'recovery_required' || !allowedCause || live.managed.pendingApproval || live.managed.autonomyPolicy && (!live.managed.decision || live.managed.decision.outcome === 'wait' && !approved) || appChannel && live.managed.nextAttemptAt > currentTime()) return current;
+      if (currentTime() >= live.deadline || live.continuations >= live.maxContinuations || live.failures >= live.maxFailures) {
+        live.state = 'budget_exhausted'; live.reason = 'Original managed continuation budget exhausted.'; live.updatedAt = currentTime(); notifyState(live, live.updatedAt); return current;
+      }
+      live.state = 'auto_resuming'; live.managed.resumeLease = { id: leaseId, claimedAt: currentTime(), checkpointRevision: live.revision, decisionId: live.managed.decision?.id || null };
+      live.managed.autoAttempts = (live.managed.autoAttempts || 0) + 1;
+      live.updatedAt = currentTime(); return current;
+    }); } catch (error) {
+      if (error?.message === 'Delivery state is busy; retry the command.') continue;
+      throw error;
+    }
+    if (claimed?.run?.managed?.resumeLease?.id !== leaseId) continue;
+    let result;
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    if (signal?.aborted) controller.abort();
+    else signal?.addEventListener('abort', abort, { once: true });
+    const timeout = setTimeout(abort, Math.max(1, Math.min(5 * 60_000, claimed.run.deadline - currentTime())));
+    const watch = setInterval(() => {
+      void listRecords(root).then(records => {
+        const current = records.find(item => item.provider === record.provider && item.session === record.session);
+        if (current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) controller.abort();
+      }).catch(() => controller.abort());
+    }, 500);
+    watch.unref();
+    try {
+      if (!controller.signal.aborted) await assertActiveLease(root, record.provider, record.session, leaseId, controller.signal, currentTime);
+      if (controller.signal.aborted) result = { code: -2, cancelled: true };
+      else {
+        const runner = execute || (appServer ? executeCodexAppServer : executeCodexResume);
+        result = await runner(claimed, { signal: controller.signal, root, leaseId, currentTime,
+          beforeDispatch: async providerSandbox => {
+            await assertActiveLease(root, record.provider, record.session, leaseId, controller.signal, currentTime);
+            await updateRecord(root, record.provider, record.session, current => {
+              const live = current?.run;
+              if (live?.state !== 'auto_resuming' || live.managed?.resumeLease?.id !== leaseId) throw new Error('Managed recovery lease changed before provider dispatch.');
+              if (appServer && !live.managed.providerSandbox) {
+                if (!providerSandbox || !['readOnly', 'workspaceWrite', 'dangerFullAccess', 'externalSandbox'].includes(providerSandbox.type)) throw new Error('Original Codex sandbox policy is unavailable.');
+                live.managed.providerSandbox = { type: providerSandbox.type,
+                  ...(providerSandbox.type === 'workspaceWrite' ? { writableRoots: Array.isArray(providerSandbox.writableRoots) ? providerSandbox.writableRoots.filter(value => typeof value === 'string').slice(0, 20) : [] } : {}) };
+              }
+              const approved = live.managed.approvedAction;
+              if (live.managed.decision?.outcome === 'wait') {
+                if (approved?.id !== live.managed.decision.id || approved.dispatchedAt) throw new Error('Selected action needs fresh approval.');
+                approved.dispatchedAt = currentTime();
+              }
+              return current;
+            });
+          } });
+      }
+    } catch (error) { result = { code: controller.signal.aborted ? -2 : -1, cancelled: controller.signal.aborted,
+      errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }
+    finally { clearTimeout(timeout); clearInterval(watch); signal?.removeEventListener('abort', abort); }
+    if (controller.signal.aborted) result = { ...result, code: -2, cancelled: true };
+    if (result.code === 0) {
+      try {
+        await checkpointDelivery({ root, provider: record.provider, session: record.session, cwd: record.cwd,
+          checkpoint: result.checkpoint || parseAgentCheckpoint(result.output, record.session), expectedLease: leaseId, now: Date.now() });
+      } catch { result = { code: -1, errorCode: 'checkpoint_rejected' }; }
+    }
+    await updateRecord(root, record.provider, record.session, async current => {
+      const live = current?.run;
+      if (live?.managed?.resumeLease?.id !== leaseId) return current;
+      delete live.managed.resumeLease;
+      live.managed.attempts ||= [];
+      live.managed.attempts.push({ id: leaseId, startedAt: claimed.run.managed.resumeLease.claimedAt, endedAt: Date.now(),
+        checkpointRevision: live.revision, outcome: result.busy ? 'busy' : result.cancelled ? 'cancelled' : result.code === 0 ? 'checkpoint' : 'failed',
+        errorCode: result.code === 0 || result.busy || result.cancelled ? null : safeProviderCode(result.errorCode),
+        restorationUnverified: result.restorationUnverified === true,
+        reason: result.busy ? 'Exact provider session currently has another writer.' : result.cancelled ? 'Managed recovery cancelled before completion.' : result.code === 0 ? 'Structured checkpoint recorded.' : 'Provider failed or returned an invalid checkpoint.',
+        nextStep: live.nextStep });
+      live.managed.attempts = live.managed.attempts.slice(-20);
+      if (result.restorationUnverified) {
+        live.managed.providerWarning = 'Original Codex permissions could not be verified after the interrupted turn; inspect that conversation.';
+        if (live.state !== 'auto_resuming') live.reason = `${String(live.reason || '').slice(0, 400)} ${live.managed.providerWarning}`.trim();
+      }
+      if (live.state !== 'auto_resuming') {
+        live.updatedAt = Date.now(); notifyState(live, live.updatedAt); return current;
+      }
+      if (result.busy) {
+        live.state = 'recovery_required'; live.recoveryCause = 'session_supervision';
+        live.reason = 'Original Codex conversation is in use; SIMY will retry after the writer lock becomes available.';
+        live.managed.nextAttemptAt = Date.now() + 15_000;
+      } else if (result.errorCode === 'provider_approval') {
+        live.state = 'blocked'; live.blocker = 'authorization'; live.managed.autoRecovery = false;
+        live.reason = 'Codex requires provider approval or user input in the original conversation.';
+      } else if (result.cancelled) {
+        live.managed.autoRecovery = false; live.state = 'recovery_required'; live.recoveryCause = 'shutdown_cancelled';
+        live.reason = 'Managed recovery was cancelled; inspect the original session before manual resume.';
+      } else if (result.code !== 0) {
+        live.failures += 1; live.managed.autoRecovery = false;
+        live.state = live.failures >= live.maxFailures ? 'failed' : 'recovery_required';
+        live.recoveryCause = 'provider_error';
+        live.reason = appServer ? providerFailureReason(safeProviderCode(result.errorCode)) +
+          (result.restorationUnverified ? ' Original provider permissions also require inspection.' : '') :
+          'Codex recovery process failed; inspect its checkpoint and original session before manual resume.';
+      } else if (live.revision <= run.revision) {
+        live.failures += 1;
+        live.reason = result.code === 0 ? 'Codex recovery returned without a checkpoint.' : 'Codex recovery failed; inspect the original session.';
+        live.state = live.failures >= live.maxFailures ? 'failed' : 'recovery_required';
+        live.recoveryCause = 'process_exit';
+      } else {
+        if (live.checkpoint?.status === 'completed') {
+          await verifyAutomaticCriteria(current, Date.now());
+          const pending = live.managed.acceptanceCriteria.filter(item => !Object.hasOwn(live.managed.verified, item.id));
+          if (pending.length) {
+            live.state = 'verification_pending'; live.reason = `Acceptance verification pending: ${pending.map(item => item.id).join(', ')}`;
+            live.updatedAt = Date.now(); notifyState(live, live.updatedAt); return current;
+          }
+        }
+        const decision = decideStop(live, Date.now());
+        current.run = decision.run;
+        if (current.run.state === 'active') {
+          current.run.state = 'recovery_required'; current.run.recoveryCause = appServer ? 'session_supervision' : 'process_exit';
+          current.run.reason = 'Verified checkpoint recorded; next bounded exact-session attempt is pending.';
+        }
+      }
+      current.run.updatedAt = Date.now(); notifyState(current.run, current.run.updatedAt); return current;
+    });
+  }
+}
+
+export function createManagedSupervisor(options) {
+  let running = null, closed = false;
+  const controller = new AbortController();
+  return {
+    tick() {
+      if (closed) return Promise.resolve();
+      if (!running) running = tickManagedTasks({ ...options, signal: controller.signal }).finally(() => { running = null; });
+      return running;
+    },
+    async close() { closed = true; controller.abort(); await running; },
+  };
+}

package/src/desktop-host.js

@@ -1,5 +1,7 @@
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
-import { controlDelivery } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
+import { controlDelivery, verifyDelivery } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
+import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
+import { answerSession, continueSession, discoverSessions, enrollSession, monitorSession } from "./session-supervision/index.js";
 import { createWindowsDesktopUpdater } from "./windows-desktop-updater.js";
 import { spawn, execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -39,8 +41,22 @@ export async function startDesktopHost({ input = process.stdin, output = process
   const lock = candidate ? null : await acquireDesktopProcessLock(root, { webOrigin });
   const supervisorToken = lock?.nonce || env.SIMY_DESKTOP_SUPERVISOR_TOKEN;
   let agent, updater, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null;
+  const managedSupervisor = (dependencies.createManagedSupervisor || createManagedSupervisor)({ root: join(root, "delivery-hooks") });
   let shuttingDown = null;
   let commands;
+  let sessionStatus = { sessions: [], providers: { codex: { discovery: "loading", reason: null }, claude: { discovery: "loading", reason: null } }, refreshedAt: null };
+  let sessionRefresh = null, sessionRefreshedAt = 0, sessionRefreshAgain = false;
+  const refreshSessions = (force = false) => {
+    if (force && sessionRefresh) sessionRefreshAgain = true;
+    if (!sessionRefresh && (force || Date.now() - sessionRefreshedAt >= 15_000)) {
+      sessionRefresh = Promise.resolve().then(() => (dependencies.discoverSessions || discoverSessions)({ root: join(root, "delivery-hooks") }))
+        .then(value => { sessionStatus = value; sessionRefreshedAt = Date.now(); })
+        .catch(() => { sessionStatus = { ...sessionStatus, providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
+        .finally(() => { sessionRefresh = null; if (sessionRefreshAgain) { sessionRefreshAgain = false; refreshSessions(true); }
+          if (!closed) setImmediate(() => { void publish().catch(() => {}); }); });
+    }
+    return sessionStatus;
+  };
   let pluginSetup = { state: "unknown" };
   const inspectPlugins = dependencies.inspectPlugins || inspectSqmAgentSkill;
   const refreshPlugins = async () => {
@@ -56,12 +72,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
     publishing = Promise.resolve(agent.getDesktopStatus()).then(async (status) => {
       status.pluginSetup = { ...pluginSetup };
       status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: join(root, "delivery-hooks") }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
+      status.sessionSupervision = refreshSessions();
       if (!closed && !relay) emit({ type: "status", status });
     }).finally(() => { publishing = null; });
     return publishing;
   };
   const stopAgent = async () => {
     clearInterval(timer);
+    await managedSupervisor.close();
     await stopWorkflows();
     if (agent) await createAgentShutdown(agent)();
   };
@@ -147,14 +165,17 @@ export async function startDesktopHost({ input = process.stdin, output = process
     } });
     await refreshPlugins();
     await publish();
-    timer = setInterval(() => { void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." })); }, 3_000);
+    timer = setInterval(() => {
+      void managedSupervisor.tick().catch(() => {});
+      void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." }));
+    }, 3_000);
   } catch (error) { await close(); throw error; }
 
   let queue = Promise.resolve();
   commands = createInterface({ input, crlfDelay: Infinity });
   commands.on("line", (line) => {
     if (closed) return;
-    if (line.length > 4096) return;
+    if (line.length > 16384) return;
     let command; try { command = JSON.parse(line); } catch { return; }
     if (typeof command.id !== "string" || command.id.length > 128) return;
     if (relay) {
@@ -175,6 +196,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           else await agent.refreshCodexStatus?.();
           await agent.refreshDesktopStatus();
           await refreshPlugins();
+          refreshSessions(true);
         }
         else if (action === "login") {
           const url = await agent.requestDesktopLogin();
@@ -211,9 +233,31 @@ export async function startDesktopHost({ input = process.stdin, output = process
         else if (action === "codex_hooks" || action === "claude_hooks") {
           const provider = action === "codex_hooks" ? "codex" : "claude";
           await (dependencies.openHookSettings || openHookSetup)(provider);
-        } else if (action === "delivery_stop" || action === "delivery_resume") {
+        } else if (["delivery_stop", "delivery_resume", "delivery_pause", "delivery_approve", "delivery_reject", "delivery_replan", "delivery_set_policy"].includes(action)) {
           await controlDelivery({ root: join(root, "delivery-hooks"), provider: command.provider, session: command.session,
-            action: action === "delivery_stop" ? "stop" : "resume" });
+            taskId: command.taskId, approvalId: command.approvalId, autonomyPolicy: command.autonomyPolicy, action: action.slice("delivery_".length) });
+        } else if (action === "delivery_verify") {
+          await verifyDelivery({ root: join(root, "delivery-hooks"), provider: command.provider, session: command.session,
+            taskId: command.taskId, criterionId: command.criterionId });
+        } else if (action === "session_monitor" || action === "session_unmonitor") {
+          await (dependencies.monitorSession || monitorSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
+            session: command.session, monitor: action === "session_monitor" });
+          await refreshSessions(true);
+        } else if (action === "session_enroll") {
+          await (dependencies.enrollSession || enrollSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
+            session: command.session, objective: command.objective, acceptanceCriteria: command.acceptanceCriteria,
+            autonomyPolicy: command.autonomyPolicy, maxMinutes: command.maxMinutes,
+            maxContinuations: command.maxContinuations, maxFailures: command.maxFailures });
+          await refreshSessions(true);
+        } else if (action === "session_continue") {
+          await (dependencies.continueSession || continueSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
+            session: command.session, autonomyPolicy: command.autonomyPolicy, maxMinutes: command.maxMinutes,
+            maxContinuations: command.maxContinuations, maxFailures: command.maxFailures });
+          await refreshSessions(true);
+        } else if (action === "session_answer") {
+          await (dependencies.answerSession || answerSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
+            session: command.session, taskId: command.taskId, questionId: command.questionId, answer: command.answer });
+          await refreshSessions(true);
         }
         else if (action === "quit") {
           const status = await agent.getDesktopStatus();
@@ -223,8 +267,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
         } else throw new Error("Unsupported desktop action.");
         emit({ type: "result", id: command.id, ok: true });
         await publish();
-      } catch {
-        emit({ type: "result", id: command.id, ok: false, message: "Action could not finish. Refresh the status and try again; active tasks must finish before quitting." });
+      } catch (error) {
+        emit({ type: "result", id: command.id, ok: false, message: String(command.action || "").startsWith("session_")
+          ? sessionActionError(error) : "Action could not finish. Refresh the status and try again; active tasks must finish before quitting." });
       }
     }).catch(() => {});
   });
@@ -232,6 +277,16 @@ export async function startDesktopHost({ input = process.stdin, output = process
   return { close, publish, agent };
 }
 
+function sessionActionError(error) {
+  const message = String(error?.message || "");
+  if (/already has a Delivery Loop|budgets cannot be reset/i.test(message)) return "This conversation already has a task. Open its existing supervision instead.";
+  if (/model.*unavailable|did not expose.*model/i.test(message)) return "This provider did not expose the conversation model; automatic continuation is unavailable.";
+  if (/workspace changed|metadata.*unavailable|session.*changed/i.test(message)) return "The conversation identity or workspace changed. Refresh and select it again.";
+  if (/objective|acceptance|autonomy policy|budget/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);
+  if (/question changed|answer is empty|session understanding|context/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);
+  return "This conversation could not be enrolled. Refresh its provider status and try again.";
+}
+
 function validCandidateStatus(status, version, webOrigin) {
   return status?.schemaVersion === 1 && status.version === version && status.webOrigin === webOrigin
     && ["signed_out", "signed_in", "expired"].includes(status.auth?.state)

package/src/index.js

@@ -25,6 +25,7 @@ import { prepareDaemonWorkflows } from "./sqm/workflow-onboarding.js";
 import { startWorkflowUpdates } from "./sqm/workflow-update.js";
 import { DEFAULT_WEB_ORIGIN, resolveWebOrigin } from "./web-origin.js";
 import { assertNoDesktopHostForOrigin } from "./desktop-process-lock.js";
+import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 
 const argv = process.argv.slice(2);
 const args = new Set(argv);
@@ -187,8 +188,14 @@ async function runLocalAgent() {
     updateManager,
   });
   let stopWorkflowUpdates = async () => {};
+  const managedSupervisor = daemon ? createManagedSupervisor({ root: join(process.env.SIMY_HOME?.trim() || join(homedir(), '.simy'), 'delivery-hooks') }) : null;
+  const managedTimer = managedSupervisor ? setInterval(() => { void managedSupervisor.tick().catch(() => {}); }, 3_000) : null;
+  managedTimer?.unref();
+  if (managedSupervisor) void managedSupervisor.tick().catch(() => {});
   const closeAgent = createAgentShutdown(agent);
   const shutdownAgent = async () => {
+    if (managedTimer) clearInterval(managedTimer);
+    await managedSupervisor?.close();
     await stopWorkflowUpdates();
     await closeAgent();
   };