@awak-app/simy-cli 0.6.30 → 0.6.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.6.30",
+  "version": "0.6.32",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -50,7 +50,8 @@
     "test:macos-installer": "node --test packaging/test-macos-packaging.mjs",
     "build:macos-installer:production": "bash packaging/build-macos-arm64.sh --production",
     "test:e2e:claude-parity": "node ./scripts/claude-parity-runtime-e2e.js",
-    "test:e2e:claude-plugin": "node ./scripts/claude-plugin-runtime-e2e.js"
+    "test:e2e:claude-plugin": "node ./scripts/claude-plugin-runtime-e2e.js",
+    "test:e2e:sqm-faults": "node ./scripts/sqm-complete-loop-e2e.js"
   },
   "engines": {
     "node": ">=20"

package/src/cli-contract.js

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

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

@@ -1810,15 +1810,33 @@ function reopenLegacyLimitStop(run, now) {
   }
   run.state = 'paused'; run.reason = 'SIMY no longer limits time or turns. Resume this task to continue.';
 }
-export async function controlDelivery({ root = rootDirectory(), provider, session, taskId, approvalId, autonomyPolicy, continuationPolicy, questionId, waitId, answer, purposeUpdate, action, inspectProcess = processIdentity, now = Date.now() }) {
+// Decision versions include explicit human controls, which must invalidate old
+// UI commands without fabricating provider checkpoint/progress revisions.
+export function advanceDeliveryControlRevision(run) {
+  run.controlRevision = (run.controlRevision ?? 0) + 1;
+}
+export function deliveryDecisionRevision(run) {
+  const controls = run?.controlRevision ?? 0;
+  if (!Number.isSafeInteger(run?.revision) || run.revision < 0 || !Number.isSafeInteger(controls) || controls < 0) return undefined;
+  const revision = run.revision + controls;
+  return Number.isSafeInteger(revision) ? revision : undefined;
+}
+export async function controlDelivery({ root = rootDirectory(), provider, session, taskId, expectedRunId, expectedRevision, approvalId, autonomyPolicy, continuationPolicy, questionId, waitId, answer, purposeUpdate, action, inspectProcess = processIdentity, now = Date.now() }) {
   for (let retry = 0; ; retry += 1) {
     try { return await updateRecord(root, provider, session, async record => {
     const run = record?.run;
     if (!run) throw new Error('Delivery Loop not found.');
+    if ((expectedRunId !== undefined || expectedRevision !== undefined) &&
+        (typeof expectedRunId !== 'string' || !expectedRunId || !Number.isSafeInteger(expectedRevision) || expectedRevision < 0 ||
+         run.id !== expectedRunId || deliveryDecisionRevision(run) !== expectedRevision)) throw new Error('This decision changed. Refresh before choosing.');
     if (record.providerArchived === true && !['stop', 'pause'].includes(action)) throw new Error('Restore the original provider conversation before changing Delivery Loop.');
     if (run.managed && taskId !== run.managed.taskId) throw new Error('Managed task identity changed; refresh its status.');
     if (['pending', 'pending_received'].includes(run.managed?.handoff?.status)) throw new Error('Task handoff is locked; use delivery handoff_cancel or retry the same target to complete the transfer.');
     if (action !== 'stop' && run.managed?.handoff?.status === 'transferred') throw new Error('Task handoff is locked; continue in the received target session.');
+    const commitControl = () => {
+      advanceDeliveryControlRevision(run);
+      return record;
+    };
     reopenLegacyLimitStop(run, now);
     if (action === 'revise_purpose') {
       if (!searchEnabled(run.managed) || run.managed.resumeLease || run.state !== 'paused' || !text(purposeUpdate?.sourceRef, 500) || !text(purposeUpdate?.objective, 2000)) throw new Error('Pause the task and supply an explicit user purpose revision with sourceRef, objective and acceptanceCriteria.');
@@ -1843,20 +1861,20 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
       run.managed.pendingApproval=null;delete run.managed.approvedAction;delete run.managed.purpose.lastReview;
       run.managed.purpose.search={cycle:0,pivots:0,experiments:[],waits:[],observed:[],lastPivotCycle:0};
       run.revision++;run.updatedAt=now;run.reason='User purpose revision recorded; prior evidence and exact approvals require re-evaluation. Resume explicitly within the existing budget.';
-      run.managed.autoRecovery=false;return record;
+      run.managed.autoRecovery=false;return commitControl();
     } else if (action === 'continuation_policy') {
       if (!canChangeDeliveryContinuation(run)) throw new Error('Pause a managed task before changing its continuation policy.');
       if (!['bounded', 'progress'].includes(continuationPolicy)) throw new Error('Select an explicit continuation policy.');
       run.managed.continuationPolicy = continuationMode(continuationPolicy);
       run.continuationPolicyHistory ||= [];
       run.continuationPolicyHistory.push({ policy: continuationPolicy, at: now, source: 'explicit_controller_selection' });
-      run.updatedAt = now; return record;
+      run.updatedAt = now; return commitControl();
     } else if (action === 'disable_auto_continue') {
       if (!run.managed?.purpose) throw new Error('Purpose continuation is not enabled.');
       run.managed.purpose.enabled = false; run.managed.autoRecovery = false;
       if (!TERMINAL.has(run.state)) { run.state = 'paused'; run.reason = 'Automatic continuation paused by user.'; }
       run.updatedAt = now;
-      return record;
+      return commitControl();
     } else if (action === 'dependency_ready') {
       const wait = run.managed?.dependencyWait;
       if (run.state !== 'blocked' || run.blocker !== 'external_dependency' || !wait || wait.id !== waitId ||
@@ -1902,8 +1920,8 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
       else { run.state = 'recovery_required'; run.recoveryCause = 'policy_change'; run.reason = 'Policy changed; resume the original conversation for the selected action.'; run.managed.autoRecovery = false; }
     }
     else if (action === 'stop') {
-      run.stopReason = { actor: 'user', code: 'explicit_stop', at: now };
       if (TERMINAL.has(run.state)) return record;
+      run.stopReason = { actor: 'user', code: 'explicit_stop', at: now };
       run.state = 'stopped'; run.reason = 'Stopped by user.';
     }
     else if (action === 'pause') {
@@ -1997,7 +2015,7 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
         rememberRejectedAction(run.managed, pending);
       }
     } else throw new Error('Unsupported control.');
-    run.updatedAt = now; notifyState(run, now); return record;
+    run.updatedAt = now; notifyState(run, now); return commitControl();
     }); } catch (error) {
       // Explicit user controls wait briefly for a live short state writer;
       // they never reclaim unknown owners or broaden execution authority.

package/src/delivery-hooks/desktop.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { canReplanDelivery, purposeProgressAt, pendingAcceptance, deliveryStop, deliveryStopBlocksResume, reconcileRecords, rootDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { canReplanDelivery, deliveryDecisionRevision, purposeProgressAt, pendingAcceptance, deliveryStop, deliveryStopBlocksResume, 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({
@@ -30,7 +30,7 @@ export async function deliveryHookStatus({ root = rootDirectory(), now = Date.no
     })),
     runs: records.filter(r => r.run && r.providerArchived !== true).sort((a, b) => b.run.updatedAt - a.run.updatedAt).slice(0, 30).map(r => ({
       provider: r.provider, session: r.session, originalSessionTarget: originalSessionTarget(r.provider, r.session),
-      objective: r.run.objective, state: r.run.state, reason: r.run.reason,
+      objective: r.run.objective, state: r.run.state, reason: r.run.reason, runId: r.run.id, revision: deliveryDecisionRevision(r.run), recoveryCause: r.run.recoveryCause, autoRecovery: r.run.managed?.autoRecovery === true,
       continuations: r.run.continuations,
       continuationPolicy: r.run.managed?.continuationPolicy || 'bounded',
       startedAt: r.run.startedAt,

package/src/delivery-hooks/legacy-hook-routing.js

@@ -6,7 +6,7 @@ import { pinnedWorkflowSource } from './local-runtime.js';
 const digest = bytes => createHash('sha256').update(bytes).digest('hex');
 // Exact shipped 0.6.23 and 0.6.24 entrypoints only. Customized hooks are retained.
 const shipped = new Set(['8a454293d119eac7cdb46c2df70c6b54a431fcf575bbf4f48f3373ca14414f3b', '339dc64d7ac980f9bfdafd1b2feea47ef8e86b2895b9d6e040086b005a806a79']);
-export const legacyRoutingShim = `// SIMY managed immutable-runtime route v1. Original exports retained for compatibility.
+const originalLegacyRoutingShim = `// SIMY managed immutable-runtime route v1. Original exports retained for compatibility.
 export * from './delivery-loop.pre-runtime-route.mjs';
 import { readFile, readdir, lstat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
@@ -34,6 +34,10 @@ export async function main(provider) {
   } catch { process.stdout.write('{}\\n'); process.stderr.write('SIMY runtime route unavailable; original task state was preserved.\\n'); }
 }
 `;
+export const legacyRoutingShim = originalLegacyRoutingShim.replace(
+  "for (const input of ['package.json', 'package-lock.json', 'README.md', 'src']) await visit(input);",
+  "for (const input of ['package.json', 'package-lock.json', 'README.md', 'src']) { try { await visit(input); } catch (error) { if (input === 'package-lock.json' && error.code === 'ENOENT') hash.update('packaged-without-lock\\0'); else throw error; } } if (pin.fingerprintVersion === 2) await visit('node_modules');",
+);
 export async function routeLegacyHooks({ root, codexHome = process.env.CODEX_HOME || join(homedir(), '.codex') } = {}) {
   await pinnedWorkflowSource({ root });
   const folder = join(codexHome, 'plugins/cache/personal/simy');
@@ -47,9 +51,10 @@ export async function routeLegacyHooks({ root, codexHome = process.env.CODEX_HOM
     if (manifest.name !== 'simy' || manifest.version !== version || (await lstat(file)).isSymbolicLink()) continue;
     const bytes = await readFile(file), before = digest(bytes), next = digest(legacyRoutingShim);
     if (before === next) { receipts.push({ version, outcome: 'current', routeDigest: next }); continue; }
-    if (!shipped.has(before)) { receipts.push({ version, outcome: 'customized_retained', originalDigest: before }); continue; }
+    const managedV1 = before === digest(originalLegacyRoutingShim);
+    if (!shipped.has(before) && !managedV1) { receipts.push({ version, outcome: 'customized_retained', originalDigest: before }); continue; }
     const backup = join(cache, 'hooks/delivery-loop.pre-runtime-route.mjs');
-    try { await writeFile(backup, bytes, { mode: 0o600, flag: 'wx' }); }
+    try { if (!managedV1) await writeFile(backup, bytes, { mode: 0o600, flag: 'wx' }); }
     catch (error) { if (error.code !== 'EEXIST' || digest(await readFile(backup)) !== before) throw error; }
     const temporary = `${file}.${randomUUID()}.tmp`;
     await writeFile(temporary, legacyRoutingShim, { mode: 0o600 }); await rename(temporary, file);

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

@@ -1,16 +1,18 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { cp, lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { cp, lstat, mkdir, readFile, readdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { acquireDesktopProcessLock } from '../desktop-process-lock.js';
+import { compareVersions } from '../backend-executable.js';
 import { stableHookRuntime } from '../hook-runtime.js';
 
 const exec = promisify(execFile);
 const packageRoot = fileURLToPath(new URL('../../', import.meta.url));
 const inputs = ['package.json', 'package-lock.json', 'README.md', 'src'];
 
-async function fingerprint(source, { allowMissingLock = false } = {}) {
+async function fingerprint(source, { allowMissingLock = false, includeDependencies = false } = {}) {
   const hash = createHash('sha256');
   async function visit(relative) {
     const target = join(source, relative);
@@ -29,6 +31,7 @@ async function fingerprint(source, { allowMissingLock = false } = {}) {
       else throw error;
     }
   }
+  if (includeDependencies) await visit('node_modules');
   return hash.digest('hex');
 }
 
@@ -40,12 +43,17 @@ async function atomicJson(file, value) {
 
 function quote(value) { return `'${value.replaceAll("'", "'\\''")}'`; }
 
-export async function localRuntimeStatus({ root, source = packageRoot, allowMissingLock = false } = {}) {
+export async function localRuntimeStatus({ root, source = packageRoot, allowMissingLock = false, includeDependencies } = {}) {
   const pkg = JSON.parse(await readFile(join(source, 'package.json'), 'utf8'));
+  if (includeDependencies === undefined) {
+    try { includeDependencies = JSON.parse(await readFile(join(source, 'runtime-build.json'), 'utf8')).fingerprintVersion === 2; }
+    catch (error) { if (error.code !== 'ENOENT') throw error; includeDependencies = false; }
+  }
+  if (includeDependencies) allowMissingLock = true;
   let installation = null;
   try { installation = JSON.parse(await readFile(join(root, 'delivery-runtime', 'current.json'), 'utf8')); }
   catch (error) { if (error.code !== 'ENOENT') throw error; }
-  return { version: pkg.version, source: resolve(source), sourceDigest: await fingerprint(source, { allowMissingLock }),
+  return { version: pkg.version, source: resolve(source), sourceDigest: await fingerprint(source, { allowMissingLock, includeDependencies }),
     purposeVersion: 2, decisionPolicy: 'llm-first-hc102', stateContractVersion: 2, consistencyMonitorVersion: 1, installation };
 }
 
@@ -58,14 +66,51 @@ export async function pinnedWorkflowSource({ root, source = packageRoot } = {})
   if (resolve(current.release || '') !== expected) throw new Error('Local workflow pin points outside its immutable releases.');
   const info = await lstat(expected);
   if (!info.isDirectory() || info.isSymbolicLink()) throw new Error('Pinned workflow source must be a regular directory.');
-  const status = await localRuntimeStatus({ root, source: expected });
+  const status = await localRuntimeStatus({ root, source: expected, allowMissingLock: true, includeDependencies: current.fingerprintVersion === 2 });
   if (status.sourceDigest !== current.digest || status.version !== current.version) throw new Error('Pinned workflow runtime failed integrity verification.');
   return resolve(source) === expected ? null : expected;
 }
 
+// Only the installer-selected bundle can advance an older local pin. Never
+// adopt a checkout, downgrade a candidate, or touch task/provider state.
+export async function adoptInstalledRuntime({ root, source = packageRoot, codexHome } = {}) {
+  let selected;
+  try { selected = await realpath(join(root, 'installer/current/Contents/Resources/cli')); }
+  catch (error) { if (error.code === 'ENOENT') return { adopted: false }; throw error; }
+  if (await realpath(source) !== selected) return { adopted: false };
+  const status = await localRuntimeStatus({ root, source, allowMissingLock: true, includeDependencies: false });
+  if (!status.installation || compareVersions(status.version, status.installation.version) <= 0) return { adopted: false };
+  // Validate the existing pin before replacing it; corruption is not an upgrade.
+  await pinnedWorkflowSource({ root, source });
+  const owner = await acquireDesktopProcessLock(root);
+  try {
+  const { routeLegacyHooks } = await import('./legacy-hook-routing.js');
+  await routeLegacyHooks({ root, ...(codexHome ? { codexHome } : {}) });
+  const installation = await installLocalRuntime({ root, source, allowMissingLock: true, includeDependencies: true,
+    expectedInstallationDigest: status.installation.digest,
+    verifyBeforeActivate: async () => {
+      if (await realpath(join(root, 'installer/current/Contents/Resources/cli')) !== selected) throw new Error('Installer selection changed during runtime adoption.');
+    },
+    installDependencies: async target => {
+      // Use the packaged dependencies without network or lifecycle scripts.
+      await cp(join(source, 'node_modules'), join(target, 'node_modules'), { recursive: true, dereference: true });
+    },
+  });
+  // A locally activated candidate is a separate explicit activation contract.
+  // Retain its receipt, but prevent watchdog replay of the superseded source.
+  const activeFile = join(root, 'desktop-runtime/active.json');
+  try {
+    const active = JSON.parse(await readFile(activeFile, 'utf8'));
+    if (active.digest !== installation.digest && !active.suspendedBy) await atomicJson(activeFile, { ...active, suspendedBy: 'runtime_upgrade_requires_activation', supersededBy: installation.digest });
+  } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  return { adopted: true, installation };
+  } finally { await owner.release(); }
+}
+
 // Install a frozen candidate alongside the released app, without replacing a
 // signed application, changing provider trust, or starting any registered task.
-export async function installLocalRuntime({ root, source = packageRoot,
+export async function installLocalRuntime({ root, source = packageRoot, allowMissingLock = false, includeDependencies = false,
+  expectedInstallationDigest, verifyBeforeActivate = async () => {},
   installDependencies = async target => exec(process.platform === 'win32' ? 'npm.cmd' : 'npm',
     ['ci', '--omit=dev', '--ignore-scripts', '--no-audit', '--no-fund'], { cwd: target, timeout: 120_000, maxBuffer: 1024 * 1024 }),
 } = {}) {
@@ -76,7 +121,8 @@ export async function installLocalRuntime({ root, source = packageRoot,
   await mkdir(lock); // An existing install is not silently stolen.
   const staged = join(storage, `.staged-${randomUUID()}`);
   try {
-    const before = await localRuntimeStatus({ root, source });
+    const before = await localRuntimeStatus({ root, source, allowMissingLock, includeDependencies });
+    if (expectedInstallationDigest && before.installation?.digest !== expectedInstallationDigest) throw new Error('Runtime selection changed before adoption.');
     const digest = before.sourceDigest;
     const release = join(storage, 'releases', digest);
     await mkdir(dirname(release), { recursive: true, mode: 0o700 });
@@ -88,16 +134,21 @@ export async function installLocalRuntime({ root, source = packageRoot,
     } catch (error) { if (error.code !== 'ENOENT') throw error; }
     if (!exists) {
       await mkdir(staged, { mode: 0o700 });
-      for (const input of inputs) await cp(join(source, input), join(staged, input), { recursive: true, errorOnExist: true });
-      if (await fingerprint(staged) !== digest || await fingerprint(source) !== digest) throw new Error('Runtime source changed while copying; no candidate activated.');
-      await installDependencies(staged);
-      if (await fingerprint(staged) !== digest) throw new Error('Dependency installation changed the runtime source.');
-      await atomicJson(join(staged, 'runtime-build.json'), { schema: 1, version: before.version, digest });
+      for (const input of inputs) {
+        try { await cp(join(source, input), join(staged, input), { recursive: true, errorOnExist: true }); }
+        catch (error) { if (!(allowMissingLock && input === 'package-lock.json' && error.code === 'ENOENT')) throw error; }
+      }
+      if (includeDependencies) await installDependencies(staged);
+      if (await fingerprint(staged, { allowMissingLock, includeDependencies }) !== digest || await fingerprint(source, { allowMissingLock, includeDependencies }) !== digest) throw new Error('Runtime source changed while copying; no candidate activated.');
+      if (!includeDependencies) await installDependencies(staged);
+      if (await fingerprint(staged, { allowMissingLock, includeDependencies }) !== digest) throw new Error('Dependency installation changed the runtime source.');
+      await atomicJson(join(staged, 'runtime-build.json'), { schema: 1, version: before.version, digest, fingerprintVersion: includeDependencies ? 2 : 1 });
       await rename(staged, release);
     } else {
       const saved = JSON.parse(await readFile(join(release, 'runtime-build.json'), 'utf8'));
-      if (saved.schema !== 1 || saved.digest !== digest || await fingerprint(release) !== digest) throw new Error('Existing candidate failed integrity verification.');
+      if (saved.schema !== 1 || saved.digest !== digest || await fingerprint(release, { allowMissingLock, includeDependencies }) !== digest) throw new Error('Existing candidate failed integrity verification.');
     }
+    await verifyBeforeActivate();
     const bin = join(root, 'bin');
     await mkdir(bin, { recursive: true, mode: 0o700 });
     const launcher = join(bin, 'simy-delivery');
@@ -114,7 +165,7 @@ export async function installLocalRuntime({ root, source = packageRoot,
       await writeFile(cliTemporary, `#!/bin/sh\nexec ${quote(stableHookRuntime())} ${quote(join(release, 'src/index.js'))} --no-auto-update "$@"\n`, { mode: 0o700 });
       await rename(cliTemporary, cli);
     } finally { await rm(cliTemporary, { force: true }); }
-    const current = { schema: 1, version: before.version, digest, release, launcher, cli,
+    const current = { schema: 1, version: before.version, digest, release, launcher, cli, fingerprintVersion: includeDependencies ? 2 : 1,
       previous: before.installation?.digest === digest ? before.installation.previous
         : before.installation ? { version: before.installation.version, digest: before.installation.digest, release: before.installation.release } : null };
     await atomicJson(join(storage, 'current.json'), current);

package/src/desktop-host.js

@@ -1,3 +1,4 @@
+import { sessionDecisionPresentation } from './session-supervision/decision-presentation.js';
 import { PROVIDER_LINKS, readProviderLinks, writeProviderLink, requireProviderLink } from "./provider-links.js";
 import { randomUUID } from "node:crypto";
 import { readCodexStatistics, unavailableStatistics } from './session-supervision/statistics.js';
@@ -32,7 +33,7 @@ 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 { adoptInstalledRuntime, 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";
@@ -695,7 +696,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
         const run = runsBySession.get(`${session.provider}:${session.session}`);
         if (run) run.actionDeadline = session.actionDeadline;
       }
-      status.sessionSupervision = { ...discovery, refreshing: Boolean(sessionRefresh), sessions };
+      status.sessionSupervision = { ...discovery, refreshing: Boolean(sessionRefresh), sessions: sessions.map(candidate => ({ ...candidate,
+        decisionRequest: sessionDecisionPresentation(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`)) })) };
       const latestAccess = await accessSnapshot();
       if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks ||
         !desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope ||
@@ -1172,7 +1174,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await (dependencies.openHookSettings || openHookSetup)(provider);
         } else if (["delivery_stop", "delivery_resume", "delivery_pause", "delivery_approve", "delivery_reject", "delivery_replan", "delivery_set_policy", "delivery_dependency_ready", "delivery_continuation_policy"].includes(action)) {
           await controlDelivery({ root: join(root, "delivery-hooks"), provider: command.provider, session: command.session,
-            taskId: command.taskId, approvalId: command.approvalId, autonomyPolicy: command.autonomyPolicy, continuationPolicy: command.continuationPolicy, waitId: command.waitId, answer: command.answer, action: action.slice("delivery_".length) });
+            taskId: command.taskId, expectedRunId: command.expectedRunId, expectedRevision: command.expectedRevision, approvalId: command.approvalId, autonomyPolicy: command.autonomyPolicy, continuationPolicy: command.continuationPolicy, waitId: command.waitId, answer: command.answer, 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 });
@@ -1334,7 +1336,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           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 });
+            session: command.session, taskId: command.taskId, expectedRunId: command.expectedRunId, expectedRevision: command.expectedRevision, questionId: command.questionId, answer: command.answer });
           await refreshSessions(true);
         }
         else throw new Error("Unsupported desktop action.");
@@ -1463,6 +1465,15 @@ export function isDesktopHostEntry(entry = process.argv[1]) {
   catch { return false; }
 }
 
+function desktopStartupError(error, fallbackMessage = "SIMY could not start. Check whether another SIMY window is already running, then reconnect.") {
+  const conflict = error?.code === PROCESS_CONFLICT_CODE;
+  return {
+    type: "error",
+    ...(conflict ? { code: PROCESS_CONFLICT_CODE, conflicts: error.conflicts || [] } : {}),
+    message: conflict ? PROCESS_CONFLICT_MESSAGE : fallbackMessage,
+  };
+}
+
 export function startDesktopEntry() {
   let host;
   const stop = () => { void host?.close().finally(() => process.exit(0)); };
@@ -1473,14 +1484,7 @@ export function startDesktopEntry() {
   captureRuntimeOutput(diagnostics, { stderr: process.stderr });
   applyLoginShellPath({ diagnostics }).catch(() => {}).then(() => startDesktopHost()).then((value) => { host = value; }).catch((error) => {
     diagnostics.write(`startup failed: ${error?.stack || error}`);
-    const conflict = error?.code === PROCESS_CONFLICT_CODE;
-    process.stdout.write(`${JSON.stringify({
-      type: "error",
-      ...(conflict ? { code: PROCESS_CONFLICT_CODE, conflicts: error.conflicts || [] } : {}),
-      message: conflict
-        ? PROCESS_CONFLICT_MESSAGE
-        : "SIMY could not start. Check whether another SIMY window is already running, then reconnect.",
-    })}\n`);
+    process.stdout.write(`${JSON.stringify(desktopStartupError(error))}\n`);
     process.exitCode = 1;
   });
 }
@@ -1488,14 +1492,20 @@ export function startDesktopEntry() {
 if (isDesktopHostEntry()) {
   try {
     const root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy');
+    try { await adoptInstalledRuntime({ root }); }
+    catch (error) {
+      if (error.code === PROCESS_CONFLICT_CODE) throw error;
+      await pinnedWorkflowSource({ root }); // Only a verified previous runtime may recover.
+      process.stderr.write('SIMY runtime upgrade deferred: ' + error.message + '\n');
+    }
     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');
+  } catch (error) {
+    process.stdout.write(JSON.stringify(desktopStartupError(error, 'Local desktop runtime integrity could not be verified. Inspect delivery runtime status; the previous task state was retained.')) + '\n');
     process.exitCode = 1;
   }
 }

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

@@ -0,0 +1,54 @@
+const clean = value => typeof value === 'string' ? value.trim().slice(0, 2000) : '';
+
+// The presentation never invents consent or executes a choice. Commands still
+// validate the exact live proposal, question, run identity and revision.
+export function sessionDecisionPresentation(candidate, run) {
+  if (!candidate || candidate.isRunning || candidate.archived) return null;
+  const identity = { provider: candidate.provider, session: candidate.session };
+  const control = { ...identity, ...(run?.taskId ? { taskId: run.taskId } : {}),
+    ...(run?.runId ? { expectedRunId: run.runId, expectedRevision: run.revision } : {}) };
+  const choice = (label, effect, action, fields = {}) => ({ label, effect, action, fields: { ...control, ...fields } });
+  const frozen = typeof run?.runId === 'string' && run.runId.length > 0 && Number.isSafeInteger(run.revision) && run.revision >= 0;
+  const refreshDecision = () => ({ kind: 'unresolved', title: '判断の状態を再確認します',
+    question: '現在の作業と判断の対応を確認できません。最新の状態を取得してから選んでください。',
+    context: 'この確認だけでは操作を許可したり、作業を再開したりしません。',
+    choices: [choice('状況を再確認する', '最新の状態を取得します。許可・停止状態は変更しません。', 'refresh', identity)] });
+  const approval = run?.pendingApproval;
+  if (approval?.id && clean(approval.summary) && !approval.denied && run.canApprove && !frozen) return refreshDecision();
+  if (approval?.id && clean(approval.summary) && !approval.denied && run.canApprove) return {
+    kind: 'approval', title: 'この操作を許可しますか？',
+    question: `実行する操作：${clean(approval.summary)}`, context: `対象：${({ task: 'この依頼の範囲', repository: 'この作業のリポジトリ' })[approval.scope] || clean(approval.scope) || '依頼された操作の範囲'}`,
+    choices: [choice('この操作だけを許可', '表示された対象・操作だけを許可します。AI側で権限確認が必要な場合は別途案内します。', 'delivery_approve', { approvalId: approval.id }),
+      choice('許可しない', run.canReplan ? 'この操作は実行しません。別の方法を調べる場合は「AIに状況確認を任せる」を選んでください。' : 'この操作は実行しません。別の方法が必要な場合は、元のAI会話で確認してください。', 'delivery_reject', { approvalId: approval.id })],
+  };
+  const question = run?.understandingQuestion;
+  if (run?.canAnswer && question?.id && clean(question.text) && !frozen) return refreshDecision();
+  if (run?.canAnswer && question?.id && clean(question.text)) return {
+    kind: 'question', title: '続けるために、この点を教えてください', question: clean(question.text),
+    context: '回答を受け取ってから目的を確認し、許可された作業を続けます。',
+    answerFields: { ...control, taskId: run.taskId, questionId: question.id },
+    choices: [],
+  };
+  if (run?.dependencyWait || run?.autoRecovery && ['recovery_required', 'auto_resuming'].includes(run.state) ||
+      ['supervising', 'watching', 'waiting'].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}会話が終了し、自動継続が止まっています。`,
+      process_exit: '元のAIが終了したため、自動継続できていません。', provider_error: 'AIの実行でエラーが発生し、作業が止まっています。',
+      shutdown_cancelled: 'SIMYの終了時に作業が中断されました。', hook_owner_mismatch: '元のAI会話の接続が変わりました。' })[run.recoveryCause]
+      || '作業を続けるための条件を確認できていません。';
+    const choices = [];
+    if (run.canReplan && frozen) choices.push(choice('AIに状況確認を任せる', '目的・履歴・制限を維持して原因と安全な次の手順を調べます。操作の許可を追加することはありません。', 'delivery_replan'));
+    if (run.canResume && frozen) choices.push(choice('再開を依頼する', '保存した目的と履歴を引き継ぎます。接続や権限が不足する場合は、その内容を案内します。', 'delivery_resume'));
+    choices.push(choice(`元の${candidate.provider === 'claude' ? 'Claude' : 'Codex'}会話を開く`, '接続や権限の確認が必要な場合、元のAI会話で確認できます。会話を開くだけでは作業を再開しません。', 'open_original'));
+    if (candidate.autoContinue === true) choices.push(choice('自動継続をオフにする', '今後の自動継続をオフにします。作業の履歴は残ります。', 'session_set_auto_continue', { ...identity, enabled: false }));
+    return { kind: 'recovery', title: '作業が止まっています。対応を選んでください', question: frozen && (run.canReplan || run.canResume) ? (run.canReplan ? '選ぶこと：AIに状況確認を任せるか、元の会話を確認するか。' : '選ぶこと：再開を依頼するか、元の会話を確認するか。') : 'この画面からの再開には対応していません。元のAI会話で状態を確認できます。', context: `理由：${context}`, choices };
+  }
+  if (candidate.autoContinueStatus === 'needs_user' || candidate.analysis?.state === 'needs_user') return {
+    kind: 'unresolved', title: '必要な判断内容を確認します',
+    question: '判断していただく内容をまだ特定できていません。具体的な内容が分かるまで、操作の許可は求めません。',
+    context: 'まず会話と最新の状態を確認します。元のAIが権限の確認を求めている場合は、その会話で確認が必要です。',
+    choices: [choice('状況を再確認する', '最新の状態を取得します。許可・停止状態は変更しません。', 'refresh', identity)],
+  };
+  return null;
+}

package/src/session-supervision/index.js

@@ -4,7 +4,7 @@ import { effectiveAcceptanceCriteria } from '../codex-plugins/simy/hooks/accepta
 import { purposeFailureMode } from '../codex-plugins/simy/hooks/purpose-search.mjs';
 import { realpath } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
-import { TERMINAL as TERMINAL_RUNS, canUpgradeDelivery, enablePurposeDelivery, claudeHookChannel, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord, recordProviderArchive } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { TERMINAL as TERMINAL_RUNS, advanceDeliveryControlRevision, canUpgradeDelivery, enablePurposeDelivery, claudeHookChannel, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord, recordProviderArchive } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { listCodexSessions, codexThreadMetadata, openCodexAppServer, readCodexSession, readCodexArchiveStates, CodexAppServerError } from './codex-app-server.js';
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { loadPurposeRuleSet } from './purpose-instruction.js';
@@ -404,6 +404,9 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
         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; }
       } 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
+    // card must not undo this switch, even when no provider checkpoint arrived.
+    if (next.run) advanceDeliveryControlRevision(next.run);
     return next;
   });
   if (enabled && updated.run && !updated.run.managed) {
@@ -524,6 +527,6 @@ export async function continueSession(options) {
     acceptanceCriteria: [], contextBootstrap: true });
 }
 
-export async function answerSession({ root, provider, session, taskId, questionId, answer, now = Date.now() }) {
-  return controlDelivery({ root, provider, session, taskId, questionId, answer, action: 'session_answer', now });
+export async function answerSession({ root, provider, session, taskId, expectedRunId, expectedRevision, questionId, answer, now = Date.now() }) {
+  return controlDelivery({ root, provider, session, taskId, expectedRunId, expectedRevision, questionId, answer, action: 'session_answer', now });
 }