@awak-app/simy-cli 0.7.15 → 0.7.17

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

@@ -1,11 +1,14 @@
 import { createHash, randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { lstat, mkdir, readFile, readdir, rename, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
 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']);
+// Exact shipped entrypoints only. The third digest is commit 2052e787
+// (cached plugin 3c0e4690). Customized hooks are reported, never overwritten.
+const shipped = new Set(['8a454293d119eac7cdb46c2df70c6b54a431fcf575bbf4f48f3373ca14414f3b', '339dc64d7ac980f9bfdafd1b2feea47ef8e86b2895b9d6e040086b005a806a79', '4339ec2ebcd56ee570ef203fc654d8af5dec47a1845dc749dd4e4439ecb35fd3']);
+const managedRouteDigests = new Set(['cac5c3bc9800aa7f97c917e8de2a1e7afcc4b300d349971b35993465f364ceee']);
 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';
@@ -34,10 +37,32 @@ 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(
+const packagedLegacyRoutingShim = 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 every public binding from the selected runtime, including helpers used
+// by sibling hooks. Backups are inert; importing the shim never evaluates them.
+const runtimeSource = readFileSync(new URL('../codex-plugins/simy/hooks/delivery-loop.mjs', import.meta.url), 'utf8');
+const publicBindings = [...runtimeSource.matchAll(/^export (?:async )?(?:function|const) (\w+)/gm)].map(match => match[1]).filter(name => name !== 'main');
+export const legacyRoutingShim = packagedLegacyRoutingShim
+  .replace('// SIMY managed immutable-runtime route v1. Original exports retained for compatibility.', '// SIMY managed immutable-runtime route v4. All bindings use the selected runtime.')
+  .replace("export * from './delivery-loop.pre-runtime-route.mjs';\n", '')
+  .replace('export async function main(provider) {', 'async function selectRuntime() {')
+  .replace('await selected.main(provider);', 'return selected;')
+  .replace("    const hash = createHash('sha256');", "    const rootInfo = await lstat(source); if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink()) throw Error('Invalid runtime root');\n    const hash = createHash('sha256');")
+  .replace("} catch { process.stdout.write('{}\\n'); process.stderr.write('SIMY runtime route unavailable; original task state was preserved.\\n'); }", '} catch { return null; }')
+  + `\nconst selected = await selectRuntime();\nexport const { ${publicBindings.join(', ')} } = selected || {};\nexport async function main(provider) {\n  if (selected) return selected.main(provider);\n  process.stdout.write('{}\\n');\n  process.stderr.write('SIMY runtime route unavailable; original task state was preserved.\\n');\n}\n`;
+
+// Stable Node entry for OS services. Every new process resolves the same pin;
+// changing a release never changes modules underneath an existing process.
+export function pinnedCliEntry(root) {
+  const loader = legacyRoutingShim.split('\nconst selected = await selectRuntime();')[0]
+    .replace("const root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy');", `const root = ${JSON.stringify(root)}; process.env.SIMY_HOME = root;`)
+    .replace('src/codex-plugins/simy/hooks/delivery-loop.mjs', 'src/index.js');
+  return loader + "\nif (!await selectRuntime()) { process.stderr.write('SIMY selected runtime unavailable.\\n'); process.exitCode = 1; }\n";
+}
+
 export async function routeLegacyHooks({ root, codexHome = process.env.CODEX_HOME || join(homedir(), '.codex') } = {}) {
   await pinnedWorkflowSource({ root });
   const folder = join(codexHome, 'plugins/cache/personal/simy');
@@ -51,10 +76,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; }
-    const managedV1 = before === digest(originalLegacyRoutingShim);
-    if (!shipped.has(before) && !managedV1) { receipts.push({ version, outcome: 'customized_retained', originalDigest: before }); continue; }
+    const managedRoute = before === digest(originalLegacyRoutingShim) || before === digest(packagedLegacyRoutingShim) || managedRouteDigests.has(before);
+    if (!shipped.has(before) && before !== digest(runtimeSource) && !managedRoute) { receipts.push({ version, outcome: 'customized_retained', originalDigest: before }); continue; }
     const backup = join(cache, 'hooks/delivery-loop.pre-runtime-route.mjs');
-    try { if (!managedV1) await writeFile(backup, bytes, { mode: 0o600, flag: 'wx' }); }
+    try { if (!managedRoute) 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);
@@ -64,3 +89,16 @@ export async function routeLegacyHooks({ root, codexHome = process.env.CODEX_HOM
   await writeFile(join(root, 'delivery-runtime/legacy-routes.json'), JSON.stringify({ at: Date.now(), receipts }), { mode: 0o600 });
   return receipts;
 }
+
+// Also used during service installation after a handover performed by an older
+// watcher which did not know this launcher. Atomic replacement keeps startup safe.
+export async function installPinnedCliEntry(root) {
+  const entry = join(root, 'bin/simy-runtime.mjs');
+  await mkdir(join(root, 'bin'), { recursive: true, mode: 0o700 });
+  const temporary = `${entry}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, pinnedCliEntry(resolve(root)), { mode: 0o600 });
+    await rename(temporary, entry);
+  } finally { await rm(temporary, { force: true }); }
+  return entry;
+}

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

@@ -7,6 +7,7 @@ import { fileURLToPath } from 'node:url';
 import { acquireDesktopProcessLock } from '../desktop-process-lock.js';
 import { compareVersions } from '../backend-executable.js';
 import { stableHookRuntime } from '../hook-runtime.js';
+import { acquireSupervisorOwner, readSupervisorState, supervisorProcessAlive, supervisorProcessIdentity } from './supervisor-owner.js';
 
 const exec = promisify(execFile);
 const packageRoot = fileURLToPath(new URL('../../', import.meta.url));
@@ -96,6 +97,7 @@ export async function adoptInstalledRuntime({ root, source = packageRoot, codexH
       await cp(join(source, 'node_modules'), join(target, 'node_modules'), { recursive: true, dereference: true });
     },
   });
+  if (installation.activation === 'deferred') return { adopted: false, installation };
   // 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');
@@ -107,10 +109,56 @@ export async function adoptInstalledRuntime({ root, source = packageRoot, codexH
   } finally { await owner.release(); }
 }
 
+// The command always installs its own source. A lockless packaged bundle may
+// reuse bundled dependencies only when selected by the existing installer or
+// already verified as the immutable pin; arbitrary checkouts still need a lock.
+export async function installCurrentLocalRuntime({ root, source = packageRoot } = {}) {
+  try { await lstat(join(source, 'package-lock.json')); }
+  catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    const selectedSource = async () => {
+      try { return await realpath(join(root, 'installer/current/Contents/Resources/cli')); }
+      catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+    };
+    const canonicalSource = await realpath(source);
+    const selected = await selectedSource();
+    const pinFile = join(root, 'delivery-runtime/current.json');
+    const readPin = async () => {
+      try { return JSON.parse(await readFile(pinFile, 'utf8')); }
+      catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+    };
+    let pin;
+    const assertPinUnchanged = async () => {
+      if (JSON.stringify(await readPin()) !== JSON.stringify(pin)) throw new Error('Runtime selection changed during installation.');
+      await pinnedWorkflowSource({ root, source });
+      if (JSON.stringify(await readPin()) !== JSON.stringify(pin)) throw new Error('Runtime selection changed during installation.');
+    };
+    return installLocalRuntime({ root, source, allowMissingLock: true, includeDependencies: true,
+      verifyBeforeInstall: async () => {
+        // Capture and validate the entire receipt under the install lock. A
+        // digest alone cannot authorize a replaced release path or build mode.
+        pin = await readPin();
+        await assertPinUnchanged();
+        // The validated receipt can retain an OS alias such as /var while the
+        // running immutable source resolves to /private/var on macOS.
+        const isPinned = pin?.fingerprintVersion === 2 && await realpath(pin.release) === canonicalSource;
+        if (selected !== canonicalSource && !isPinned) throw new Error('Lockless runtime installation requires the installer-selected bundle or verified immutable pin.');
+        if (selected === canonicalSource && await selectedSource() !== canonicalSource) throw new Error('Installer selection changed during runtime installation.');
+      },
+      verifyBeforeActivate: async () => {
+        await assertPinUnchanged();
+        if (selected === canonicalSource && await selectedSource() !== canonicalSource) throw new Error('Installer selection changed during runtime installation.');
+      },
+      installDependencies: target => cp(join(source, 'node_modules'), join(target, 'node_modules'), { recursive: true, dereference: true }),
+    });
+  }
+  return installLocalRuntime({ root, source });
+}
+
 // 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, allowMissingLock = false, includeDependencies = false,
-  expectedInstallationDigest, verifyBeforeActivate = async () => {},
+  expectedInstallationDigest, verifyBeforeInstall = async () => {}, verifyBeforeActivate = async () => {}, handoverId,
   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 }),
 } = {}) {
@@ -121,6 +169,7 @@ export async function installLocalRuntime({ root, source = packageRoot, allowMis
   await mkdir(lock); // An existing install is not silently stolen.
   const staged = join(storage, `.staged-${randomUUID()}`);
   try {
+    await verifyBeforeInstall();
     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;
@@ -148,6 +197,30 @@ export async function installLocalRuntime({ root, source = packageRoot, allowMis
       const saved = JSON.parse(await readFile(join(release, 'runtime-build.json'), 'utf8'));
       if (saved.schema !== 1 || saved.digest !== digest || await fingerprint(release, { allowMissingLock, includeDependencies }) !== digest) throw new Error('Existing candidate failed integrity verification.');
     }
+    const activationLock = await acquireDesktopProcessLock(join(root, 'supervisor-runtime', 'control-lock'), {
+      alive: supervisorProcessAlive, identity: supervisorProcessIdentity });
+    let handoverOwner, handover;
+    try {
+    let control;
+    try { control = JSON.parse(await readFile(join(root, 'supervisor-runtime/control.json'), 'utf8')); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    // Preparing a release must not disable the existing watchdog's recovery
+    // contract. Keep its pin and launchers until a coordinated handover.
+    if (handoverId) {
+      handover = await readSupervisorState(join(root, 'supervisor-runtime/handover.json'));
+      if (!control?.enabled || handover?.version !== 1 || handover.id !== handoverId || handover.status !== 'drained' ||
+          handover.epoch !== control.epoch || handover.target?.digest !== digest || handover.target.release !== release ||
+          ![handover.fromDigest, digest].includes(control.digest) ||
+          ![handover.fromDigest, digest].includes(before.installation?.digest)) throw new Error('Supervisor handover changed or was stopped.');
+      // Fence every replacement until the previous owner has actually released
+      // its singleton, including the acknowledgement/release crash gap.
+      handoverOwner = await acquireSupervisorOwner(root);
+    }
+    if (!handover && control?.enabled === true && control.digest !== digest) {
+      return { schema: 1, version: before.version, digest, release,
+        activation: 'deferred', reason: 'supervisor_handover_required',
+        activeInstallation: before.installation };
+    }
     await verifyBeforeActivate();
     const bin = join(root, 'bin');
     await mkdir(bin, { recursive: true, mode: 0o700 });
@@ -165,10 +238,17 @@ export async function installLocalRuntime({ root, source = packageRoot, allowMis
       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 { installPinnedCliEntry } = await import('./legacy-hook-routing.js');
+    await installPinnedCliEntry(root);
     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);
+    if (handover) {
+      await atomicJson(join(root, 'supervisor-runtime/control.json'), { ...control, digest, release, updatedAt: Date.now() });
+      await atomicJson(join(root, 'supervisor-runtime/handover.json'), { ...handover, status: 'activated', activatedAt: Date.now() });
+    }
     return current;
+    } finally { await handoverOwner?.release(); await activationLock.release(); }
   } finally { await rm(staged, { recursive: true, force: true }); await rm(lock, { recursive: true, force: true }); }
 }

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

@@ -3,26 +3,35 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { assertNoDesktopHostForOrigin } from '../desktop-process-lock.js';
 import { createManagedSupervisor } from './supervisor.js';
 import { acquireSupervisorOwner } from './supervisor-owner.js';
+import { pendingSupervisorHandover, acknowledgeSupervisorDrain } from './supervisor-handover.js';
 
 export async function superviseLocalDelivery({ root, webOrigin, once = false, signal,
   createSupervisor = createManagedSupervisor, checkOwner = assertNoDesktopHostForOrigin, wait = delay,
-  acquireOwner = acquireSupervisorOwner } = {}) {
+  acquireOwner = acquireSupervisorOwner, pendingHandover = pendingSupervisorHandover,
+  acknowledgeDrain = acknowledgeSupervisorDrain } = {}) {
   // 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 owner = await acquireOwner(dirname(root));
+  const owner = await acquireOwner(dirname(root), { handoverVersion: 1 });
   try {
   await check();
-  const supervisor = createSupervisor({ root, webOrigin });
+  const supervisor = createSupervisor({ root, webOrigin,
+    shouldYield: async () => Boolean(await pendingHandover(dirname(root), owner.nonce)) });
   const stop = () => { void supervisor.close(); };
   signal?.addEventListener('abort', stop, { once: true });
   try {
     do {
       if (signal?.aborted) break;
+      const handover = await pendingHandover(dirname(root), owner.nonce);
+      if (handover) {
+        await supervisor.drain();
+        await acknowledgeDrain(dirname(root), handover, signal);
+        break;
+      }
       await check();
       await supervisor.tick();
-      if (once) break;
+      if (once) { await supervisor.idle?.(); break; }
       try { await wait(3_000, undefined, { signal }); }
       catch (error) { if (!signal?.aborted) throw error; }
     } while (!signal?.aborted);

package/src/delivery-hooks/repair-continuation.js

@@ -0,0 +1,80 @@
+import { readRecord, pendingAcceptance } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { tickManagedTasks } from './supervisor.js';
+
+const matches = (record, target) => record?.provider === target.provider && record.session === target.session &&
+  record.run?.id === target.runId && record.run?.managed?.taskId === target.taskId;
+
+// A projection of the original task, never a second completion decision or ledger.
+export function originalWorkResult(record) {
+  const run = record.run;
+  const managed = run.managed;
+  const completed = run.state === 'completed';
+  const waiting = run.state === 'recovery_required' && !managed.autoRecovery || ['blocked', 'paused', 'stopped', 'budget_exhausted', 'failed', 'verification_pending'].includes(run.state);
+  const pending = pendingAcceptance(run);
+  return {
+    status: completed ? 'completed' : run.state === 'reported_done' ? 'reported_done' : waiting ? run.state : 'in_progress',
+    completed,
+    objective: run.objective,
+    result: completed || run.state === 'reported_done' ? run.checkpoint?.summary || run.reason : null,
+    remainingWork: completed ? [] : pending.length ? pending.map(item => item.description) :
+      [managed.remainingWork || run.nextStep || run.reason].filter(Boolean),
+    requiredAction: waiting ? managed.userQuestion || managed.dependencyWait?.condition || run.reason : null,
+    message: completed ? '元の仕事の完成条件を確認し、完了しました。' :
+      run.state === 'reported_done' ? '元の会話は完了を報告しています。完成条件の確認は未完了です。' :
+      waiting ? '元の仕事は未完了です。残件と必要な操作を確認してください。' : '元の仕事の残作業を続行中です。',
+  };
+}
+
+// Repair owner has already queued an authorized action on the original record.
+// Never resume/replan here: those controls may reset progress or release a wait.
+// The durable supervisor owns retries, writer claims, budgets and notifications.
+export async function continueRepairedDelivery({ root, webOrigin, request, repair, signal,
+  tick = tickManagedTasks, drain = false, ...executionOptions } = {}) {
+  const target = request?.target;
+  if (request?.scope !== 'repair_continue' || typeof request.requestId !== 'string' || !request.requestId.trim() || request.requestId.length > 200 || !target?.provider || !target.session || !target.runId || !target.taskId) {
+    throw new Error('An exact original task and explicit repair_continue request are required.');
+  }
+  const read = async () => {
+    const record = await readRecord(root, target.provider, target.session);
+    return matches(record, target) ? record : null;
+  };
+  let record = await read();
+  if (!record) return { status: 'target_changed', completed: false, request, repair };
+  const receipt = record.run.managed.repairRequest;
+  if (repair?.reason === 'already_requested' && receipt?.requestId === request.requestId && receipt.status === 'resolved') {
+    repair = { ...repair, status: 'resolved', message: '停止原因の解消は確認済みです。' };
+  }
+  // Only a resolved repair can initiate a continuation tick. In-progress repair
+  // and uncertain effects remain with their existing owner; status reads are safe.
+  while (repair?.status === 'resolved' && !signal?.aborted &&
+      record.run.state === 'recovery_required' && record.run.managed.autoRecovery) {
+    const attemptId = record.run.managed.attempts?.at(-1)?.id;
+    await tick({ ...executionOptions, root, webOrigin, signal,
+      readRecords: async () => { const current = await read(); return current ? [current] : []; } });
+    record = await read();
+    const attempt = record?.run.managed.attempts?.at(-1);
+    // Continue only after a settled checkpoint. Busy owners, backoff, failed
+    // turns and unchanged state stay with the existing durable supervisor.
+    if (!drain || !record || attempt?.id === attemptId || attempt?.outcome !== 'checkpoint') break;
+  }
+  if (!record) return { status: 'target_changed', completed: false, request, repair };
+  const work = originalWorkResult(record);
+  if (!work.completed && repair?.status === 'needs_human') {
+    work.status = 'needs_human';
+    work.requiredAction = repair.message || repair.reason;
+    work.message = '元の仕事は未完了です。必要な操作を確認してください。';
+  }
+  return { request, repair, ...work };
+}
+
+// Conversation entry composition. Repair settles its durable receipt first;
+// continuation then reads the original task and uses its existing next action.
+export async function repairAndContinueDelivery(options = {}) {
+  const repairTask = options.repairTask || (await import('./repair.js')).repairStoppedDelivery;
+  const repair = await repairTask(options);
+  const work = await continueRepairedDelivery({ ...options.supervisorOptions,
+    root: options.root, webOrigin: options.webOrigin || options.request?.webOrigin,
+    request: options.request, repair, signal: options.signal, drain: true });
+  return { ...work.repair, taskCompleted: work.completed, work,
+    message: `${work.repair?.message || ''} ${work.message || ''}`.trim() };
+}

package/src/delivery-hooks/repair.js

@@ -0,0 +1,164 @@
+import { repairAndContinueDelivery } from './repair-continuation.js';
+import { createHash } from 'node:crypto';
+import { readRecord, updateRecord, automaticContinuationAllowed, deliveryStop, prepareWaitingDiagnosis,
+  prepareRecoveryDiagnosis, queuePurposeDiagnosis, advanceDeliveryControlRevision, canReplanDelivery, processIdentity } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { leaseOwnerDead } from '../session-supervision/workspace-lease.js';
+import { requireProviderLink } from '../provider-links.js';
+import { diagnoseDelivery, diagnosticProjection } from './diagnosis.js';
+import { tickManagedTasks } from './supervisor.js';
+
+// One bounded adapter to the existing controller, not another worker or consent store.
+const fingerprint = record => createHash('sha256').update(JSON.stringify([
+  record?.run?.id, record?.run?.revision, record?.run?.controlRevision, record?.run?.state,
+  record?.run?.blocker, record?.run?.managed?.decision?.id, record?.run?.managed?.attempts?.at(-1)?.id,
+  record?.run?.managed?.purpose?.lastObservedTurnId,
+])).digest('hex');
+const matches = (record, target) => record?.provider === target.provider && record?.session === target.session &&
+  record.run?.id === target.runId && record.run?.managed?.taskId === target.taskId;
+function boundary(record, now) {
+  const run = record?.run, m = run?.managed;
+  if (record?.providerArchived) return 'user_stopped';
+  if (!m || record.provider !== 'codex' || m.resumeChannel !== 'codex_app_server') return 'unsupported_target';
+  if (!automaticContinuationAllowed(record) || run.stopReason?.actor === 'user' || ['stopped', 'paused'].includes(run.state)) return 'user_stopped';
+  if (deliveryStop(run, now)) return 'budget_or_failure_limit';
+  if (['permission_narrowed', 'permission_restore', 'manual_provider_action'].includes(m.attempts?.at(-1)?.errorCode)) return 'permission_required';
+  if (m.authenticationWait) return 'login_required';
+  if (m.pendingApproval || m.nativeWait || m.providerWarning || m.purpose?.nativeBoundary || run.blocker === 'authorization') return 'permission_required';
+  if (m.dependencyWait || m.understandingQuestion || m.userQuestion) return 'answer_or_dependency_required';
+  if (['pending', 'pending_received', 'transferred'].includes(m.handoff?.status)) return 'handoff_pending';
+  return null;
+}
+const humanReasons = new Set(['login_required', 'permission_required', 'answer_or_dependency_required', 'provider_link_required']);
+function response(request, status, reason, extra = {}) {
+  return { status, reason, request, taskCompleted: false, ...extra,
+    message: status === 'resolved' ? '停止原因の解消を確認しました。元の仕事全体の完了は別途確認します。'
+      : status === 'needs_human' && !humanReasons.has(reason) ? '元の会話で確認結果に記載された操作を行ってください。'
+      : humanReasons.has(reason) ? ({ login_required: '元のプロバイダにログインしてください。', permission_required: '元の会話で必要な権限・承認を確認してください。', answer_or_dependency_required: '元の会話の質問または外部条件を確認してください。', provider_link_required: '元のプロバイダとの接続を確認してください。' })[reason]
+        : '停止原因はまだ解消を確認できていません。現在の結果から続けます。' };
+}
+
+export async function repairStoppedDelivery({ root, webOrigin, request, issues, signal, diagnosis,
+  diagnose = diagnoseDelivery, tick = tickManagedTasks, supervisorOptions = {}, now = Date.now, inspectProcess = processIdentity } = {}) {
+  if (request?.scope !== 'repair_continue' || typeof request.requestId !== 'string' || !request.requestId.trim() || request.requestId.length > 200 ||
+      !request.target?.runId || !request.target?.taskId || !['codex', 'claude'].includes(request.target?.provider) || !request.target?.session) {
+    throw Error('Repair requires an explicit repair_continue request and an exact existing task reference.');
+  }
+  const target = request.target, read = () => readRecord(root, target.provider, target.session);
+  const result = (reason, extra) => response(request, humanReasons.has(reason) ? 'needs_human' : 'unresolved', reason, extra);
+  let initial = await read();
+  if (!matches(initial, target)) return result('target_changed', { executed: false });
+  if (signal?.aborted) return result('cancelled', { executed: false });
+  let link;
+  try { link = await requireProviderLink({ root, provider: target.provider }); }
+  catch { return result('provider_link_required', { executed: false }); }
+  let reason = boundary(initial, now());
+  if (reason) return result(reason, { executed: false });
+  const previous = initial.run.managed.repairRequest;
+  const interrupted = previous?.status === 'running' && await leaseOwnerDead(previous.owner, inspectProcess);
+  if (!interrupted && (previous?.requestId === request.requestId || previous?.status === 'running') || previous?.settledFingerprint === fingerprint(initial)) {
+    return result('already_requested', { executed: false, priorStatus: previous.status });
+  }
+  if (initial.run.managed.resumeLease || initial.run.state === 'auto_resuming') return result('busy', { executed: false });
+  if (!['blocked', 'recovery_required'].includes(initial.run.state)) return result('no_repairable_stop', { executed: false });
+  const attempt = initial.run.managed.executionAttempt;
+  // Unknown effects are reconciled read-only; never retry the prior write.
+  const uncertain = initial.run.managed.executionUncertain || attempt?.phase === 'dispatching';
+  const busy = initial.run.managed.attempts?.at(-1)?.outcome === 'busy' && attempt?.phase === 'claimed' && attempt.id === initial.run.managed.attempts.at(-1).id && !attempt.dispatchedAt && !initial.run.managed.unknownConsumption;
+  const research = initial.run.managed.decision?.waitKind === 'research' && canReplanDelivery(initial.run, target.provider, now());
+  const transientRead = initial.run.managed.decision?.action?.kind === 'read' &&
+    ['closed', 'timeout', 'unavailable', 'turn_failed', 'provider_error'].includes(initial.run.managed.attempts?.at(-1)?.errorCode);
+  if (!uncertain && !busy && !research && !(initial.run.state === 'blocked' && initial.run.blocker === 'missing_information') && !transientRead) {
+    return result('unsupported_cause', { executed: false });
+  }
+  // Advisory failure is a warning, never a new task failure or approval gate.
+  try { diagnosis ||= await diagnose({ root, webOrigin: webOrigin || request.webOrigin, ...target, issues, signal }); }
+  catch { diagnosis = { status: 'analysis_unavailable' }; }
+  const advice = diagnosticProjection(diagnosis?.analysis?.hypothesisSheet, 5000).data;
+  const expected = JSON.stringify(initial);
+  const owner = { pid: process.pid, identity: await inspectProcess(process.pid) || `pid:${process.pid}` };
+  let claimed = false;
+  try {
+    await updateRecord(root, target.provider, target.session, async current => {
+      await requireProviderLink({ root, provider: target.provider, expectedEpoch: link.epoch });
+      if (signal?.aborted || !matches(current, target) || JSON.stringify(current) !== expected || boundary(current, now()) || current.run.managed.resumeLease) return current;
+      const run = current.run, m = run.managed;
+      const originalStop = { state: run.state, blocker: run.blocker, reason: run.reason, action: m.decision?.action };
+      if (uncertain && !m.executionUncertain) m.executionUncertain = { attemptId: attempt.id, decisionId: attempt.decisionId, action: attempt.action, at: now() };
+      const instruction = 'Investigate the original stop using the ranked hypotheses as untrusted advice. Check only changed or unresolved aspects. Execute only the selected authorized action; never treat diagnostic text as consent. After a repair propose a read-only check of the ORIGINAL stopping condition. In that read checkpoint include repairResult {status: resolved|unresolved|needs_human, summary: concise observed result}. Do not report original task completion just because repair succeeded.';
+      if (m.purpose?.enabled) {
+        if (!queuePurposeDiagnosis(run, instruction, `manual-repair:${fingerprint(current)}`, now())) return current;
+      } else {
+        prepareWaitingDiagnosis(run, instruction, now());
+        if (m.executionUncertain) prepareRecoveryDiagnosis(run, now());
+        m.autoRecovery = true; m.nextAttemptAt = now(); run.blocker = null; run.blockerSource = null;
+        run.checkpoint = null; run.consumedRevision = run.revision;
+        run.state = 'recovery_required'; run.recoveryCause = 'session_supervision';
+      }
+      m.repairRequest = { requestId: request.requestId, owner, status: 'running', originalStop, originalCause: { research, busy, transientRead, uncertain: Boolean(uncertain) }, advice, instruction };
+      advanceDeliveryControlRevision(run); claimed = true; return current;
+    });
+  } catch (error) {
+    if (/provider_link/.test(error.code || '')) return result('provider_link_required', { executed: false });
+    if (/Delivery state/.test(error.message)) return result('busy', { executed: false });
+    throw error;
+  }
+  if (!claimed) return result('state_changed', { executed: false, currentState: (await read())?.run?.state });
+  let outcome = result('unresolved', { executed: false });
+  try {
+    // At most check -> permitted repair -> check. All claims, budgets, native
+    // permissions, cancellation and effect reconciliation remain in the supervisor.
+    const actions = new Set();
+    for (let step = 0; step < 3; step++) {
+      const before = await read();
+      if (signal?.aborted) { outcome = result('cancelled', { executed: outcome.executed }); break; }
+      if (!matches(before, target)) { outcome = result('target_changed', { executed: outcome.executed }); break; }
+      reason = boundary(before, now());
+      if (reason) { outcome = result(reason, { executed: outcome.executed }); break; }
+      const action = before.run.managed.decision?.action;
+      const actionKey = JSON.stringify(action);
+      if (!['read', 'local_edit', 'local_test'].includes(action?.kind) || actions.has(actionKey)) break;
+      actions.add(actionKey);
+      const oldAttempt = before.run.managed.attempts?.at(-1)?.id;
+      await tick({ ...supervisorOptions, root, webOrigin: webOrigin || request.webOrigin, signal,
+        authorizeDispatch: async record => {
+          await requireProviderLink({ root, provider: target.provider, expectedEpoch: link.epoch });
+          return supervisorOptions.authorizeDispatch?.(record);
+        },
+        readRecords: async () => { const current = await read(); return matches(current, target) && current.run.managed.repairRequest?.requestId === request.requestId ? [current] : []; } });
+      const after = await read();
+      if (!matches(after, target)) { outcome = result('target_changed', { executed: outcome.executed }); break; }
+      const latest = after.run.managed.attempts?.at(-1);
+      const executed = outcome.executed || Boolean(latest?.id !== oldAttempt && latest?.outcome !== 'busy');
+      try { await requireProviderLink({ root, provider: target.provider, expectedEpoch: link.epoch }); }
+      catch { outcome = result('provider_link_required', { executed }); break; }
+      if (signal?.aborted) { outcome = result('cancelled', { executed }); break; }
+      reason = boundary(after, now());
+      if (reason) { outcome = result(reason, { executed }); break; }
+      const history = after.run.managed.workHistory?.at(-1);
+      if (latest?.id !== oldAttempt && latest?.outcome === 'checkpoint' && history?.repairResult) {
+        outcome = response(request, history.repairResult.status, 'observed_check', { executed, repairResult: history.repairResult, verificationSource: 'provider_observed' }); break;
+      }
+      outcome = result(latest?.outcome === 'busy' ? 'busy' : 'unresolved', { executed });
+      if (uncertain || latest?.id === oldAttempt || latest?.outcome !== 'checkpoint' || history?.result?.status !== 'observed' || after.run.managed.executionUncertain) break;
+    }
+    return { ...outcome, warnings: [
+      ...(diagnosis?.status === 'analysis_unavailable' ? ['diagnosis_unavailable'] : []),
+      ...(diagnosis?.analysis?.sheetDiagnostic ? ['incomplete_advisory_sheet'] : []),
+    ] };
+  } finally {
+    await updateRecord(root, target.provider, target.session, current => {
+      if (matches(current, target) && current.run.managed.repairRequest?.requestId === request.requestId) {
+        const receipt = current.run.managed.repairRequest;
+        receipt.status = outcome.status; receipt.reason = outcome.reason; receipt.settledFingerprint = fingerprint(current);
+        delete receipt.advice; delete receipt.instruction;
+      }
+      return current;
+    });
+  }
+}
+
+// Keep the conversation entry stable while returning to the original work only
+// after the repair receipt has settled. The repair adapter above owns diagnosis.
+export async function repairDelivery(options = {}) {
+  return repairAndContinueDelivery({ ...options, repairTask: repairStoppedDelivery });
+}

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

@@ -0,0 +1,84 @@
+import { join, resolve } from 'node:path';
+import { lstat, realpath } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { acquireDesktopProcessLock } from '../desktop-process-lock.js';
+import { localRuntimeStatus, installLocalRuntime } from './local-runtime.js';
+import { observeSupervisorOwner, readSupervisorState, saveSupervisorState, supervisorProcessIdentity, supervisorProcessAlive } from './supervisor-owner.js';
+
+export const handoverPath = root => join(root, 'supervisor-runtime/handover.json');
+const controlPath = root => join(root, 'supervisor-runtime/control.json');
+const lockControl = root => acquireDesktopProcessLock(join(root, 'supervisor-runtime/control-lock'), {
+  alive: supervisorProcessAlive, identity: supervisorProcessIdentity });
+
+export async function requestSupervisorHandover({ root, release, observeOwner = observeSupervisorOwner } = {}) {
+  const target = resolve(release);
+  if ((await lstat(target)).isSymbolicLink() || await realpath(target) !== target) throw new Error('Use a canonical immutable release.');
+  const candidate = await localRuntimeStatus({ root, source: target });
+  if (target !== join(resolve(root), 'delivery-runtime/releases', candidate.sourceDigest)) throw new Error('Handover target is not a verified installed release.');
+  const lock = await lockControl(root);
+  try {
+    const control = await readSupervisorState(controlPath(root));
+    if (!control?.enabled) return { status: 'not_requested', reason: 'supervisor_disabled' };
+    const owner = await observeOwner(root);
+    const watcher = await readSupervisorState(join(root, 'supervisor-runtime/watchdog.json'));
+    // Never signal old/unknown owners, or mistake process liveness for support.
+    if (owner.state !== 'running' || owner.handoverVersion !== 1 || !Number.isFinite(owner.lastHeartbeatAt) || owner.heartbeatStale) return {
+      status: 'not_requested', reason: 'owner_handover_unavailable', owner };
+    if (watcher?.handoverVersion !== 1 || watcher.epoch !== control.epoch || !Number.isFinite(watcher.at) ||
+        Date.now() - watcher.at > 30_000) return { status: 'not_requested', reason: 'watcher_handover_unavailable' };
+    const watcherOwner = await readSupervisorState(join(root, 'supervisor-runtime/watcher/desktop-app.lock/owner.json'));
+    if (!watcherOwner?.nonce || watcherOwner.nonce !== watcher.watcherNonce ||
+        await supervisorProcessIdentity(watcherOwner.pid).catch(() => null) !== watcherOwner.startedAt) return {
+      status: 'not_requested', reason: 'watcher_identity_unconfirmed' };
+    if (control.digest === candidate.sourceDigest) return { status: 'already_selected' };
+    const previous = await readSupervisorState(handoverPath(root));
+    if (previous && ['requested', 'drained'].includes(previous.status) && previous.epoch === control.epoch) {
+      if (previous.target.digest === candidate.sourceDigest) {
+        if (previous.status === 'drained' || previous.ownerNonce === owner.nonce) return previous;
+        // The original owner died before acknowledging. Rebind only after a
+        // fresh explicit retry, retaining the original identity and request.
+        const rebound = { ...previous, ownerNonce: owner.nonce, previousOwnerNonce: previous.ownerNonce, reboundAt: Date.now() };
+        await saveSupervisorState(handoverPath(root), rebound); return rebound;
+      }
+      throw new Error('Another supervisor handover is pending.');
+    }
+    const request = { version: 1, id: randomUUID(), status: 'requested', epoch: control.epoch,
+      ownerNonce: owner.nonce, fromDigest: control.digest, requestedAt: Date.now(),
+      target: { digest: candidate.sourceDigest, release: target, version: candidate.version } };
+    await saveSupervisorState(handoverPath(root), request);
+    return request;
+  } finally { await lock.release(); }
+}
+
+export async function pendingSupervisorHandover(root, nonce) {
+  const request = await readSupervisorState(handoverPath(root));
+  if (request?.version !== 1 || request.status !== 'requested' || request.ownerNonce !== nonce) return null;
+  const control = await readSupervisorState(controlPath(root));
+  return control?.enabled && control.epoch === request.epoch && control.digest === request.fromDigest ? request : null;
+}
+
+export async function acknowledgeSupervisorDrain(root, request, signal) {
+  const lock = await lockControl(root);
+  try {
+    const current = await pendingSupervisorHandover(root, request.ownerNonce);
+    if (signal?.aborted || current?.id !== request.id) return false;
+    await saveSupervisorState(handoverPath(root), { ...current, status: 'drained', drainedAt: Date.now() });
+    return true;
+  } finally { await lock.release(); }
+}
+
+// A watcher can finish an interrupted activation from the same durable request.
+// installLocalRuntime revalidates epoch, owner absence and release under locks.
+export async function completeSupervisorHandover(root) {
+  const request = await readSupervisorState(handoverPath(root));
+  if (request?.version !== 1 || request.status !== 'drained') return null;
+  const control = await readSupervisorState(controlPath(root));
+  if (!control?.enabled || control.epoch !== request.epoch) return null;
+  // Installed bundles may omit the lockfile and include dependencies in their
+  // fingerprint. Keep that format when activating the already-frozen release.
+  const build = await readSupervisorState(join(request.target.release, 'runtime-build.json'));
+  const includeDependencies = build?.fingerprintVersion === 2;
+  const candidate = await localRuntimeStatus({ root, source: request.target.release, allowMissingLock: true, includeDependencies });
+  if (candidate.sourceDigest !== request.target.digest) throw new Error('Supervisor handover runtime changed before activation.');
+  return installLocalRuntime({ root, source: request.target.release, handoverId: request.id, allowMissingLock: true, includeDependencies });
+}

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

@@ -47,6 +47,7 @@ export async function observeSupervisorOwner(root, { now = Date.now(), alive = s
   try { heartbeat = await readSupervisorState(join(supervisorOwnerRoot(root), 'heartbeat.json')); } catch {}
   const lastHeartbeatAt = heartbeat?.nonce === owner.nonce && Number.isFinite(heartbeat.at) ? heartbeat.at : null;
   return { state: 'running', pid: owner.pid, nonce: owner.nonce, lastHeartbeatAt,
+    ...(heartbeat?.nonce === owner.nonce && heartbeat.handoverVersion === 1 ? { handoverVersion: 1 } : {}),
     heartbeatStale: lastHeartbeatAt !== null && now - lastHeartbeatAt > 60_000 };
 }
 
@@ -54,14 +55,14 @@ export async function observeSupervisorOwner(root, { now = Date.now(), alive = s
 // than letting a missing identity probe reclaim a live owner. Task leases and
 // desktop ownership remain separate, and keep their existing authority checks.
 export async function acquireSupervisorOwner(root, { alive = supervisorProcessAlive,
-  identity = supervisorProcessIdentity, heartbeatMs = 15_000 } = {}) {
+  identity = supervisorProcessIdentity, heartbeatMs = 15_000, handoverVersion } = {}) {
   const directory = supervisorOwnerRoot(root);
   const lock = await acquireDesktopProcessLock(directory, { alive, identity });
   const file = join(directory, 'heartbeat.json');
   let pending = Promise.resolve(), closed = false;
   const beat = () => {
     pending = pending.catch(() => {}).then(async () => {
-      if (!closed) await saveSupervisorState(file, { version: 1, pid: process.pid, nonce: lock.nonce, at: Date.now() });
+      if (!closed) await saveSupervisorState(file, { version: 1, pid: process.pid, nonce: lock.nonce, at: Date.now(), ...(handoverVersion === 1 ? { handoverVersion } : {}) });
     });
     return pending;
   };