@awak-app/simy-cli 0.6.23 → 0.6.25

package/src/delivery-hooks/local-supervisor.js

@@ -0,0 +1,25 @@
+import { dirname } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { assertNoDesktopHostForOrigin } from '../desktop-process-lock.js';
+import { createManagedSupervisor } from './supervisor.js';
+
+export async function superviseLocalDelivery({ root, once = false, signal,
+  createSupervisor = createManagedSupervisor, checkOwner = assertNoDesktopHostForOrigin, wait = delay } = {}) {
+  // Delivery records share this local root across origins. A staging desktop
+  // can own the same provider session, so fence every live owner in this root.
+  const check = () => checkOwner(dirname(root), null);
+  await check();
+  const supervisor = createSupervisor({ root });
+  const stop = () => { void supervisor.close(); };
+  signal?.addEventListener('abort', stop, { once: true });
+  try {
+    do {
+      if (signal?.aborted) break;
+      await check();
+      await supervisor.tick();
+      if (once) break;
+      try { await wait(3_000, undefined, { signal }); }
+      catch (error) { if (!signal?.aborted) throw error; }
+    } while (!signal?.aborted);
+  } finally { signal?.removeEventListener('abort', stop); await supervisor.close(); }
+}

package/src/delivery-hooks/runtime-watchdog.js

@@ -0,0 +1,101 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { assertNoDesktopHostForOrigin } from '../desktop-process-lock.js';
+import { pinnedWorkflowSource, localRuntimeStatus } from './local-runtime.js';
+import { desktopRuntimeStatus } from './desktop-runtime.js';
+import { consistencyMonitorStatus } from './consistency-monitor.js';
+const exec = promisify(execFile);
+async function read(file) { try { return JSON.parse(await readFile(file, 'utf8')); } catch (error) { if (error.code === 'ENOENT') return null; throw error; } }
+async function save(file, value) {
+  const temp = `${file}.${randomUUID()}.tmp`;
+  try { await writeFile(temp, JSON.stringify(value), { mode: 0o600 }); await rename(temp, file); }
+  finally { const { rm } = await import('node:fs/promises'); await rm(temp, { force: true }); }
+}
+async function candidate(root) {
+  await pinnedWorkflowSource({ root });
+  const pin = await read(join(root, 'delivery-runtime/current.json'));
+  const value = await read(join(root, 'desktop-runtime/candidate.json'));
+  if (!pin || value?.digest !== pin.digest || value?.version !== pin.version || value.app !== join(root, 'desktop-runtime', `SIMY Local-${pin.digest}.app`)) throw Error('Local desktop candidate identity mismatch.');
+  const actual = await localRuntimeStatus({ root, source: join(value.app, 'Contents/Resources/cli') });
+  if (actual.sourceDigest !== pin.digest || actual.version !== pin.version) throw Error('Local desktop candidate integrity mismatch.');
+  return value;
+}
+
+export async function suspendDesktopWatchdog(root) {
+  const file = join(root, 'desktop-runtime/active.json'), active = await read(file);
+  if (active) await save(file, { ...active, suspendedBy: 'user_quit', suspendedAt: Date.now() });
+}
+
+export async function activateLocalDesktop({ root, checkOwner = assertNoDesktopHostForOrigin, run = exec } = {}) {
+  const value = await candidate(root);
+  await checkOwner(root, null); // A live owner is never killed by activation.
+  await run('/usr/bin/codesign', ['--verify', '--deep', '--strict', value.app]);
+  await run('/usr/bin/open', ['-n', '-a', value.app]);
+  await save(join(root, 'desktop-runtime/active.json'), { ...value, activatedAt: Date.now(), scope: 'previously_opted_in_tasks' });
+  return { ...value, activation: 'launch_requested' };
+}
+
+// External deterministic observer survives host exits and sleep/wake. Only an
+// explicitly activated candidate may be relaunched, with the normal owner lock.
+// A live mismatched/unhealthy host is reported, never forcibly replaced.
+export async function tickRuntimeWatchdog({ root, now = Date.now(), run = exec,
+  checkOwner = assertNoDesktopHostForOrigin, observeHost = desktopRuntimeStatus,
+  observeMonitor = consistencyMonitorStatus } = {}) {
+  await mkdir(join(root, 'desktop-runtime'), { recursive: true, mode: 0o700 });
+  const file = join(root, 'desktop-runtime/watchdog.json');
+  const previous = await read(file) || {};
+  const state = { lastAttemptAt: now, lastSuccessAt: previous.lastSuccessAt || null, ownerPid: process.pid, launches: previous.launches || 0, lastLaunchAt: previous.lastLaunchAt || null,
+    host: null, monitor: null, error: null, action: 'observe' };
+  try {
+    state.host = await observeHost({ root });
+    state.monitor = await observeMonitor(join(root, 'delivery-hooks'), now);
+    const active = await read(join(root, 'desktop-runtime/active.json'));
+    if (active?.suspendedBy === 'user_quit') state.action = 'user_quit_preserved';
+    if (active && !active.suspendedBy && state.host.state !== 'matched' && now - (previous.lastLaunchAt || 0) >= 60_000) {
+      try { await checkOwner(root, null); }
+      catch (error) { if (error.code !== 'process_conflict') throw error; state.action = 'live_owner_preserved'; }
+      if (state.action !== 'live_owner_preserved') {
+        const value = await candidate(root);
+        // Installing another candidate does not authorize its automatic activation.
+        if (value.digest !== active.digest) throw Error('Active desktop pin changed; activate the prepared candidate explicitly.');
+        await run('/usr/bin/codesign', ['--verify', '--deep', '--strict', value.app]);
+        await run('/usr/bin/open', ['-n', '-a', value.app]);
+        state.action = 'relaunch_requested'; state.lastLaunchAt = now; state.launches++;
+      }
+    }
+    state.lastSuccessAt = now;
+  } catch { state.error = { code: 'runtime_watchdog_failed', at: now }; }
+  await save(file, state);
+  return state;
+}
+export async function watchLocalRuntime({ root, signal, once = false } = {}) {
+  do {
+    if (signal?.aborted) break;
+    await tickRuntimeWatchdog({ root });
+    if (once) break;
+    try { await delay(30_000, undefined, { signal }); } catch (error) { if (!signal?.aborted) throw error; }
+  } while (!signal?.aborted);
+}
+
+export async function installRuntimeWatchdog({ root, home = homedir(), run = exec, platform = process.platform } = {}) {
+  if (platform !== 'darwin') throw Error('Desktop watchdog installation currently requires macOS.');
+  const active = await read(join(root, 'desktop-runtime/active.json'));
+  const value = await candidate(root);
+  if (!active || active.digest !== value.digest) throw Error('Activate the verified desktop before installing its watchdog.');
+  const folder = join(home, 'Library/LaunchAgents'); await mkdir(folder, { recursive: true });
+  const label = 'com.awak.simy.local-runtime-watchdog';
+  const plist = join(folder, `${label}.plist`);
+  const xml = value => String(value).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+  const content = `<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict><key>Label</key><string>${label}</string><key>ProgramArguments</key><array><string>${xml(join(root, 'bin/simy-delivery'))}</string><string>runtime</string><string>watch</string></array><key>EnvironmentVariables</key><dict><key>SIMY_HOME</key><string>${xml(root)}</string></dict><key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>ThrottleInterval</key><integer>30</integer></dict></plist>`;
+  await writeFile(plist, content, { mode: 0o600 });
+  await run('/usr/bin/plutil', ['-lint', plist]);
+  const domain = `gui/${process.getuid()}`;
+  try { await run('/bin/launchctl', ['bootout', `${domain}/${label}`]); } catch { /* First install has no job. */ }
+  await run('/bin/launchctl', ['bootstrap', domain, plist]);
+  return { label, plist, scope: 'activated_local_desktop_only' };
+}

package/src/delivery-hooks/supervisor.js

@@ -1,16 +1,23 @@
+import { retainControllerEvidence } from '../codex-plugins/simy/hooks/purpose-evidence.mjs';
+import { workspaceIdentity, reviewWorkspaceIdentity } from '../session-supervision/purpose-verification.js';
+import { searchEnabled, failureLimitReached } from '../codex-plugins/simy/hooks/purpose-search.mjs';
+import { reconcilePurposeTasks } from '../session-supervision/purpose-recovery.js';
+import { runConsistencyMonitor } from './consistency-monitor.js';
+import { desktopRuntimeStatus } from './desktop-runtime.js';
+import { auditConsistencyTask } from '../session-supervision/consistency-auditor.js';
 import { minimalSufficientChangeInstruction } from '../codex-plugins/simy/hooks/minimal-sufficient.mjs';
 import { requireProviderLink } from '../provider-links.js';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
-import { automaticContinuationAllowed, assessedCheckpointContract, checkpointDelivery, decideStop, deliveryProgressContext, deliveryStop, listRecords, readRecord, managedBudgetReason, notifyState, processIdentity, sharesTaskWorkspace, taskDirectory, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { canExecuteAutonomousExternal, automaticContinuationAllowed, settlePurposeVerification, assessedCheckpointContract, checkpointDelivery, decideStop, deliveryProgressContext, deliveryStop, listRecords, readRecord, managedBudgetReason, notifyState, processIdentity, sharesTaskWorkspace, taskDirectory, 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';
 import { acquireWorkspaceLease, leaseOwnerDead } from '../session-supervision/workspace-lease.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']);
+const SAFE_PROVIDER_CODES = new Set(['authentication_required', 'identity', 'permission_narrowed', 'permission_restore', 'turn_failed', 'checkpoint',
+  'closed', 'timeout', 'unsupported', 'unavailable', 'manual_provider_action', 'checkpoint_rejected', 'provider_approval', 'provider_question', 'usage_unavailable']);
 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.';
@@ -133,18 +140,21 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
   });
 }
 
-export async function tickManagedTasks({ root, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch, readRecords } = {}) {
+export async function tickManagedTasks({ root, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch, readRecords, observeTurn, observeAuthentication } = {}) {
   const tickWallStart = Date.now();
   const currentTime = () => now + Math.max(0, Date.now() - tickWallStart);
   if (signal?.aborted) return;
-  const records = await reconcileRecords({ root, now, ...(inspectProcess ? { inspectProcess } : {}),
-    ...(readRecords ? { records: await readRecords() } : {}) });
+  const readCandidates = readRecords || (() => listRecords(root));
+  await reconcilePurposeTasks({ root, signal, now, observeTurn, observeAuthentication, readRecords: readCandidates });
+  await reconcileRecords({ root, now, ...(inspectProcess ? { inspectProcess } : {}), records: await readCandidates() });
   if (signal?.aborted) return;
+  const records = await readCandidates();
   for (let record of records) {
     if (signal?.aborted) break;
     const claimNow = currentTime();
     let run = record.run;
     if (!run?.managed) continue;
+    if (run.managed.maxTokens && run.managed.outcomeAudit?.lease) continue;
     if (run.state === 'auto_resuming') {
       const owner = run.managed.resumeLease?.owner;
       const ownerDead = await leaseOwnerDead(owner, inspectProcess);
@@ -152,9 +162,10 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       if (!ownerDead && (owner || claimNow - run.managed.resumeLease?.claimedAt <= 5 * 60_000)) continue;
       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.state = 'recovery_required'; current.run.recoveryCause = 'interrupted_owner'; current.run.managed.autoRecovery = false;
         current.run.reason = 'Managed recovery was interrupted; inspect the original session before manual resume.';
         const attempt = current.run.managed.executionAttempt;
+        if (attempt?.budgetReservation && attempt.phase === 'dispatching') { attempt.budgetReservation.state = 'unknown'; current.run.managed.unknownConsumption = true; if (current.run.managed.maxTokens) current.run.managed.usageBlocked = true; }
         if (attempt?.phase === 'dispatching' && attempt.action?.kind !== 'read') current.run.managed.executionUncertain = {
           attemptId: attempt.id, decisionId: attempt.decisionId, action: attempt.action, at: claimNow };
         current.run.updatedAt = claimNow; notifyState(current.run, claimNow); return current;
@@ -165,7 +176,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     try { await requireProviderLink({ root, provider: record.provider }); } catch { 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) &&
+    const approvedWait = run.managed.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test', 'external'].includes(run.managed.decision.action?.kind) &&
       run.managed.approvedAction?.id === run.managed.decision.id && !run.managed.approvedAction.dispatchedAt;
     if (run.managed.executionUncertain && run.managed.recoveryDiagnosisDecisionId !== run.managed.decision?.id) continue;
     if (['pending', 'transferred', 'pending_received'].includes(run.managed.handoff?.status)) continue;
@@ -196,17 +207,22 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       if (!automaticContinuationAllowed(current)) return current;
       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) &&
+      const approved = live?.managed?.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test', 'external'].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;
       const stop = deliveryStop(live, currentTime());
       if (stop) {
-        live.state = stop.code === 'failure_limit' ? 'failed' : 'paused'; live.reason = stop.reason; live.updatedAt = currentTime(); notifyState(live, live.updatedAt); return current;
+        live.state = stop.code === 'purpose_budget' ? 'budget_exhausted' : stop.code === 'failure_limit' ? 'failed' : 'paused'; live.reason = stop.reason; 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,
         owner: { pid: process.pid, identity: ownerIdentity } };
       live.managed.executionAttempt = { id: leaseId, decisionId: live.managed.decision?.id || null,
-        action: live.managed.decision?.action || live.managed.proposedAction, phase: 'claimed', claimedAt: currentTime(), lastActivityAt: currentTime() };
+        action: live.managed.decision?.action || live.managed.proposedAction,
+        budgetReservation: { rootTaskId: live.managed.taskId, tokens: live.managed.maxTokens ? Math.max(0, live.managed.maxTokens - (live.managed.tokensUsed || 0)) : null, state: 'reserved', epoch: leaseId }, phase: 'claimed', claimedAt: currentTime(), lastActivityAt: currentTime() };
+      for (const request of live.managed.consistencyOutbox || []) if (['pending', 'received', 'inspected', 'inspection_failed'].includes(request.stage) && request.targetTask === live.managed.taskId) {
+        request.stage = 'received'; request.receivedAt = currentTime(); request.decisionId = live.managed.decision?.id;
+        request.leaseId = leaseId;
+      }
       live.managed.autoAttempts = (live.managed.autoAttempts || 0) + 1;
       live.updatedAt = currentTime(); return current;
     }); } catch (error) {
@@ -220,6 +236,15 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     let result;
     let resource;
     let lastActivityAt = currentTime();
+    let usage = null, usageQueue = Promise.resolve(), usageError = null;
+    // Tool and token notifications can arrive together. Share one in-process
+    // write queue so our own receipts do not contend for the record lock.
+    let receiptQueue = Promise.resolve();
+    const persistReceipt = mutate => {
+      const pending = receiptQueue.then(() => updateRecord(root, record.provider, record.session, mutate));
+      receiptQueue = pending.catch(() => {});
+      return pending;
+    };
     let dispatched = false, waitingForTool = false;
     const controller = new AbortController();
     const abort = () => controller.abort();
@@ -263,6 +288,14 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         await authorizeClaim();
         const runner = execute || (appServer ? executeCodexAppServer : executeCodexResume);
         result = await runner(claimed, { signal: controller.signal, root, leaseId, currentTime, leaseMonitored: true,
+          onEvidence: async evidence => {
+            await persistReceipt(current => {
+              if (current?.run?.managed?.resumeLease?.id !== leaseId || current.run.managed.decision?.id !== evidence.actionId) throw new Error('Evidence capture lease changed.');
+              if (searchEnabled(current.run.managed)) retainControllerEvidence(current.run.managed, evidence, currentTime());
+              return current;
+            });
+          },
+          onUsage: observed => { usage = observed; usageQueue = persistReceipt(current => { if (current?.run?.managed?.resumeLease?.id === leaseId) current.run.managed.executionAttempt.observedUsage = observed; return current; }).catch(error=>{usageError=error;}); if (claimed.run.managed.maxTokens && (claimed.run.managed.tokensUsed || 0) + observed.tokens >= claimed.run.managed.maxTokens) controller.abort(); },
           onActivity: observation => { lastActivityAt = currentTime(); waitingForTool = observation?.waitingForTool === true; },
           beforeDispatch: async providerSandbox => {
             await assertActiveLease(root, record.provider, record.session, leaseId, controller.signal, currentTime);
@@ -272,9 +305,13 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
               if (!automaticContinuationAllowed(current)) throw new Error('Automatic continuation was disabled 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,
+                live.managed.providerSandbox = { type: providerSandbox.type, networkAccess: providerSandbox.networkAccess === true,
                   ...(providerSandbox.type === 'workspaceWrite' ? { writableRoots: Array.isArray(providerSandbox.writableRoots) ? providerSandbox.writableRoots.filter(value => typeof value === 'string').slice(0, 20) : [] } : {}) };
               }
+              const selected=live.managed.plan?.alternatives?.find(row=>row.id===live.managed.decision?.selectedOptionId);
+              const ledger=live.managed.purpose?.evidence;
+              if(selected?.dependsOn?.some(id=>!ledger?.units?.some(unit=>unit.id===id && unit.status==='verified' && unit.purposeRevision===ledger.purposeRevision))) throw new Error('Required dependency is not independently verified.');
+              if (live.managed.decision?.autonomousExternal && !canExecuteAutonomousExternal(live.managed)) throw new Error('Autonomous external authority changed before dispatch.');
               const approved = live.managed.approvedAction;
               live.managed.executionAttempt.phase = 'dispatching';
               live.managed.executionAttempt.dispatchedAt = currentTime();
@@ -295,13 +332,17 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       : error?.code === 'desktop_access_required'
       ? { code: -3, busy: true, accessDenied: true }
       : { code: controller.signal.aborted ? -2 : -1, cancelled: controller.signal.aborted,
-        errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }
-    finally { stopWatch(); signal?.removeEventListener('abort', abort); }
+        providerTurnId: error?.providerTurnId, question: error?.question, errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }
+    try {
+    await usageQueue;
+    if (usageError) result = { ...result, code: -1, errorCode: 'usage_unavailable' };
+    usage ||= result?.usage || null;
     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() });
+        if (result.verification) await settlePurposeVerification({ root, provider: record.provider, session: record.session, expectedLease: leaseId, review: result.verification, verifySnapshot: current => reviewWorkspaceIdentity(current, root, result.verification, { signal: controller.signal }), now: Date.now() });
+        else await checkpointDelivery({ root, provider: record.provider, session: record.session, cwd: record.cwd,
+          checkpoint: result.checkpoint || parseAgentCheckpoint(result.output, record.session), expectedLease: leaseId, toolEvidence: result.toolEvidence || [], sourceContext: result.sourceContext, controllerEvidence: result.controllerEvidence, now: Date.now() });
         await updateRecord(root, record.provider, record.session, current => {
           if (current?.run?.managed?.executionAttempt?.id !== leaseId) return current;
           current.run.managed.executionAttempt.phase = 'checkpointed';
@@ -318,16 +359,27 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
           }
           return current;
         });
-      } catch { result = { code: -1, errorCode: 'checkpoint_rejected' }; }
+      } catch (error) { result = { ...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;
+      if (searchEnabled(live.managed) && !result.busy && (dispatched || result.code === 0)) live.continuations += 1;
+      if (live.managed.executionAttempt?.budgetReservation) live.managed.executionAttempt.budgetReservation.state = usage && result.code===0 ? 'settled' : dispatched ? 'unknown' : 'released';
+      if (dispatched && (!usage || result.code!==0)) {live.managed.unknownConsumption = true;if(live.managed.maxTokens) live.managed.usageBlocked=true;}
+      if (usage) {
+        live.managed.tokensUsed = (live.managed.tokensUsed || 0) + usage.tokens;
+        live.managed.usageAvailable = true;
+        live.managed.lastUsage = { ...usage, attemptId: leaseId };
+      } else if (!result.busy && live.managed.maxTokens && dispatched) {
+        live.managed.usageAvailable = false; live.managed.usageBlocked = true;
+      }
       const attempt = live.managed.executionAttempt;
       if (!result.busy && attempt?.phase === 'dispatching' && attempt.action?.kind !== 'read') live.managed.executionUncertain = {
         attemptId: leaseId, decisionId: attempt.decisionId, action: attempt.action, at: Date.now() };
       live.managed.attempts ||= [];
+      if (live.managed.purpose?.enabled && result.providerTurnId) live.managed.purpose.lastOwnedTurnId = result.providerTurnId;
       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),
@@ -354,15 +406,24 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         live.state = 'recovery_required'; live.recoveryCause = 'session_supervision';
         live.reason = result.accessDenied ? 'Sign in to a SIMY organization with SQM and Developer access before continuing.' : '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 === 'authentication_required') {
+        live.state = 'blocked'; live.blocker = 'external_dependency'; live.blockerSource = 'connection'; live.managed.autoRecovery = false;
+        live.managed.authenticationWait = { since: Date.now(), nextCheckAt: Date.now() + 60_000 };
+        live.reason = 'The configured provider is not logged in. SIMY will recheck account availability and resume diagnosis when restored within the existing budget.';
+      } else if (result.errorCode === 'provider_question') {
+        live.state = 'blocked'; live.blocker = 'missing_information'; live.blockerSource = 'question'; live.managed.autoRecovery = false;
+        live.managed.userQuestion = result.question || 'Inspect the original conversation for the unanswered provider question.';
+        live.reason = 'Investigate the provider question; use existing evidence for routine decisions and preserve genuine user choices.';
       } else if (result.errorCode === 'provider_approval') {
-        live.state = 'blocked'; live.blocker = 'authorization'; live.managed.autoRecovery = false;
+        live.state = 'blocked'; live.blocker = 'authorization'; live.blockerSource = 'provider'; live.managed.autoRecovery = false;
+        live.managed.nativeWait = { turnId: result.providerTurnId || null, observedAt: Date.now() };
         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.state = failureLimitReached(live) ? 'failed' : 'recovery_required';
         live.recoveryCause = 'provider_error';
         live.reason = appServer ? providerFailureReason(safeProviderCode(result.errorCode)) +
           (result.restorationUnverified ? ' Original provider permissions also require inspection.' : '') :
@@ -370,7 +431,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       } 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.state = failureLimitReached(live) ? 'failed' : 'recovery_required';
         live.recoveryCause = 'process_exit';
       } else {
         if (live.checkpoint?.status === 'completed') {
@@ -393,18 +454,25 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     // Settling uncertainty must precede unlocking: otherwise another session
     // could start a write in the effect/checkpoint persistence gap.
     await resource?.release({ unconfirmed: result.restorationUnverified === true });
+    } finally { stopWatch(); signal?.removeEventListener('abort', abort); }
   }
 }
 
 export function createManagedSupervisor(options) {
-  let running = null, closed = false;
+  let running = null, auditing = null, closed = false;
   const controller = new AbortController();
   return {
     tick() {
       if (closed) return Promise.resolve();
+      if (!auditing) auditing = (async () => {
+        const runtime = await desktopRuntimeStatus({ root: dirname(options.root) }).catch(() => ({ state: 'runtime_observation_failed' }));
+        await runConsistencyMonitor({ root: options.root, runtime, readRecords: options.readRecords || (() => listRecords(options.root)),
+          onAudit: (record, findings, request) => auditConsistencyTask(record, findings, request, {
+            root: options.root, signal: controller.signal, authorize: options.authorizeDispatch || (async () => {}) }) });
+      })().catch(() => {}).finally(() => { auditing = null; });
       if (!running) running = tickManagedTasks({ ...options, signal: controller.signal }).finally(() => { running = null; });
       return running;
     },
-    async close() { closed = true; controller.abort(); await running; },
+    async close() { closed = true; controller.abort(); await Promise.allSettled([running, auditing]); },
   };
 }

package/src/desktop-host.js

@@ -23,12 +23,16 @@ import { spawn, execFile } from "node:child_process";
 import { promisify, isDeepStrictEqual } from "node:util";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
 import { realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { startAgent } from "./agent.js";
 import { createRuntimeDiagnostics, captureRuntimeOutput } from "./runtime-diagnostics.js";
+import { suspendDesktopWatchdog } from './delivery-hooks/runtime-watchdog.js';
+import { attestDesktopRuntime } from './delivery-hooks/desktop-runtime.js';
+import { pinnedWorkflowSource } from './delivery-hooks/local-runtime.js';
 import { applyLoginShellPath } from "./login-shell-path.js";
 import { createCliAutoUpdater, readCliPackageInfo } from "./auto-update.js";
 import { createAgentShutdown } from "./shutdown.js";
@@ -139,6 +143,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
     throw new Error("Desktop update supervisor is no longer running.");
   }
   const lock = candidate ? null : await acquireDesktopProcessLock(root, { webOrigin });
+  if (lock && !dependencies.startAgent) {
+    try { await attestDesktopRuntime({ root }); } catch (error) { await lock.release(); throw error; }
+  }
   const supervisorToken = lock?.nonce || env.SIMY_DESKTOP_SUPERVISOR_TOKEN;
   const deliveryRoot = join(root, "delivery-hooks");
   const recordReader = createRecordReader(deliveryRoot);
@@ -970,6 +977,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
             const status = await agent.getDesktopStatus();
             if ((status.tasks?.activeCount || 0) + (status.sqmTasks?.activeCount || 0) > 0) throw new Error("Tasks are still running. Confirm before quitting.");
           }
+          if (command.forUpdate !== true) await suspendDesktopWatchdog(root);
           // Cancel first, then acknowledge. The native app waits for the host
           // exit; this deadline also covers a stuck remote flush/discovery.
           const deadline = setTimeout(async () => {
@@ -1455,7 +1463,7 @@ export function isDesktopHostEntry(entry = process.argv[1]) {
   catch { return false; }
 }
 
-if (isDesktopHostEntry()) {
+export function startDesktopEntry() {
   let host;
   const stop = () => { void host?.close().finally(() => process.exit(0)); };
   process.once("SIGTERM", stop); process.once("SIGINT", stop);
@@ -1476,3 +1484,18 @@ if (isDesktopHostEntry()) {
     process.exitCode = 1;
   });
 }
+
+if (isDesktopHostEntry()) {
+  try {
+    const root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy');
+    const selected = await pinnedWorkflowSource({ root });
+    if (selected) {
+      process.env.SIMY_AUTO_UPDATE = '0';
+      const selectedHost = await import(pathToFileURL(join(selected, 'src/desktop-host.js')).href);
+      selectedHost.startDesktopEntry();
+    } else startDesktopEntry();
+  } catch {
+    process.stdout.write(JSON.stringify({ type: 'error', message: 'Local desktop runtime integrity could not be verified. Inspect delivery runtime status; the previous task state was retained.' }) + '\n');
+    process.exitCode = 1;
+  }
+}