@awak-app/simy-cli 0.7.11 → 0.7.12

package/src/desktop-host.js

@@ -1,3 +1,7 @@
+import { createUpdateRuntime } from './update-detachment/runtime.js';
+import { createCoordinatorReconciler } from "./update-detachment/reconciliation-adapter.js";
+import { createLedgerCoordinatorAdapters } from "./update-detachment/ledger-adapter.js";
+import { createUpdateCoordinator } from "./update-detachment/coordinator.js";
 import { sessionWorkState, compareSessionWork, reconcileFamilyCompletion, expireSessionWorkState } from './session-supervision/work-state.js';
 import { createPullRequestObserver } from './session-supervision/pull-requests.js';
 import { sessionDecisionPresentation } from './session-supervision/decision-presentation.js';
@@ -194,6 +198,15 @@ export async function startDesktopHost({ input = process.stdin, output = process
   };
   let agent, updater, analysisManager, automaticContinuation, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null, publishAgain = false, scheduledPublish = null;
   const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin, list: async () => linkedSessions(await recordReader.list()), onChange: () => { if (!closed) setImmediate(() => { void publish().catch(() => {}); }); } });
+  const updateRuntime = createUpdateRuntime({ root, origin:webOrigin,
+    readContext:()=>agent?.getUpdateDetachmentContext?.(), listRecords:()=>recordReader.list(),
+    ...(dependencies.observeUpdateProvider ? {observe:dependencies.observeUpdateProvider} : {}) });
+  const coordinator = createUpdateCoordinator({ ...(dependencies.updateDetachment || {
+    store:updateRuntime.store,gate:updateRuntime.gate,
+    boundary:dependencies.updateSafeBoundary || (async()=>{const holds=updater?.updateDrainState?.();if(holds && (holds.activeWork || holds.applyHolds))return {safe:false,liveExecutions:holds.activeWork,pendingWrites:holds.applyHolds,unsettledPermissions:0};return updateRuntime.boundary();}),
+    reconcile:dependencies.reconcileUpdateConnection || createCoordinatorReconciler(dependencies.updateReconciliation) || updateRuntime.reconcile,
+  }), preserveConnectedOnStartup:true, initialState:env.SIMY_UPDATE_TRANSFER_TOKEN?'detached':'connected',
+    onChange:()=>{if(agent && !closed && !relay)setImmediate(()=>void publish().catch(()=>{}));} });
   let actionAssociations = makeActionAssociations();
   const statisticsCache = new Map();
   let activeStatisticsRead = null;
@@ -436,7 +449,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           if (controller.signal.aborted || !desktopAccessReady(afterObservation) || accessScope(afterObservation) !== requestedScope) {
             await analysisManager.update([]); sessionRefreshAgain = desktopAccessReady(afterObservation); return;
           }
-          await analysisManager.update(analysisSessions(sessions));
+          if (coordinator.acceptsNewWork()) await analysisManager.update(analysisSessions(sessions));
           if (controller.signal.aborted) return;
           sessionStatus = { ...value, sessions, initialLoading: false }; sessionRefreshedAt = Date.now(); })
         .catch(() => { if (closed || relay || controller.signal.aborted) return; sessionStatus = { ...sessionStatus, initialLoading: false, providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
@@ -619,6 +632,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const sampledAccess = structuredClone(status.access || { state: 'unavailable', organizationId: null, organizationName: null });
       if (!await acceptStatusAccess(sampledAccess)) { publishAgain = true; return; }
       status.access = sampledAccess;
+      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.());
+      if(!desktopAccessReady(sampledAccess))status.updateDetachment={...status.updateDetachment,tasks:[],actions:status.updateDetachment.actions.filter(action=>action==='cancel_detach_update')};
       const requestedLinks = await decorateProviderSettings(status);
       const sameScope = desktopAccessReady(currentAccess) &&
         accessScope(lastStatus?.access) === accessScope(currentAccess);
@@ -667,6 +682,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const sampledAccess = structuredClone(status.access || { state: 'unavailable', organizationId: null, organizationName: null });
       if (!await acceptStatusAccess(sampledAccess)) { publishAgain = true; return; }
       status.access = sampledAccess;
+      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.());
+      if(!desktopAccessReady(sampledAccess))status.updateDetachment={...status.updateDetachment,tasks:[],actions:status.updateDetachment.actions.filter(action=>action==='cancel_detach_update')};
       const requestedScope = accessScope(currentAccess);
       const requestedLinks = await decorateProviderSettings(status);
       const allRecords = await recordReader.list();
@@ -709,7 +726,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: deliveryRoot, records: projection?.records || records }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
       await actionAssociations.decorate(status.deliveryHooks, projection);
       const discovery = refreshSessions();
-      automaticContinuation?.tick(discovery.sessions);
+      if (coordinator.acceptsNewWork()) automaticContinuation?.tick(discovery.sessions);
       const sessions = discovery.sessions.map(candidate => automaticContinuation.project(analysisManager.project(candidate)));
       await actionAssociations.decorateSessions?.(sessions, projection);
       const stateRunsBySession = new Map((projection?.records || records).filter(record => record.run).map(record => [`${record.provider}:${record.session}`, record.run]));
@@ -791,6 +808,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
   })();
 
   try {
+    await updateRuntime.initialize();
+    if (env.SIMY_UPDATE_TRANSFER_TOKEN) await updateRuntime.acceptHandoff(env.SIMY_UPDATE_TRANSFER_TOKEN);
+    else await coordinator.initialize();
     analysisManager = await makeAnalysisManager();
     automaticContinuation = makeAutomaticContinuation();
     if (!candidate) {
@@ -803,6 +823,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       dependencies: { packageInfo: updatePackageRoot ? await readCliPackageInfo(updatePackageRoot) : packageInfo,
         logger: message => diagnostics.write(`update: ${message}`) },
     });
+    updater.setCoordinator?.(coordinator);
     agent = await (dependencies.startAgent || startAgent)({
       daemon: true, webOrigin, sessionRoot: root, quiet: true, updateManager: updater,
       deferStartupSynchronization: true, enforceDesktopAccess: true,
@@ -812,9 +833,10 @@ export async function startDesktopHost({ input = process.stdin, output = process
         setImmediate(() => { void publish().catch(() => {}); });
       },
     });
+    if (env.SIMY_UPDATE_TRANSFER_TOKEN) await coordinator.reconnect();
     stopWorkflows = (dependencies.startWorkflowUpdates || startWorkflowUpdates)({ enabled: env.SIMY_AUTO_UPDATE !== "0" });
     updater.on?.("change", () => { void publish().catch(() => {}); });
-    updater.start({ registry: agent.registry, isDesktopIdle: () => !unfinishedDesktopWork,
+    updater.start({ registry: agent.registry, coordinator, isDesktopIdle: () => !unfinishedDesktopWork,
       restartDaemon: async (targetVersion, installation) => {
       if (!installation?.entryPath || !installation?.executablePath) throw new Error("Signed update runtime is unavailable.");
       discoveryStopped = true;
@@ -826,12 +848,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
       // The candidate also shares association records and their sync outbox.
       // Drain the old writer before starting its replacement.
       await actionAssociations.close();
+      const transferToken = coordinator.snapshot().state === 'detached' ? await updateRuntime.prepareHandoff() : null;
       let child;
       try { child = (dependencies.spawn || spawn)(installation.executablePath,
         [join(dirname(installation.entryPath), "desktop-host.js")], {
           stdio: ["pipe", "pipe", "pipe"],
-          env: { ...env, SIMY_DESKTOP_SUPERVISOR_TOKEN: supervisorToken },
+          env: { ...env, SIMY_DESKTOP_SUPERVISOR_TOKEN: supervisorToken, ...(transferToken ? {SIMY_UPDATE_TRANSFER_TOKEN:transferToken} : {}) },
         }); } catch (error) {
+          if(transferToken)await updateRuntime.reclaimFailedHandoff();
           actionAssociations = makeActionAssociations();
           analysisManager = await makeAnalysisManager(); automaticContinuation = makeAutomaticContinuation(); discoveryStopped = false; refreshSessions(true); throw error;
         }
@@ -869,7 +893,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
             let event; try { event = JSON.parse(line); } catch { return; }
             if (accepted) { emit(event); return; }
             if (event.type === "status") {
-              if (!validCandidateStatus(event.status, targetVersion, webOrigin)) {
+              if (!validCandidateStatus(event.status, targetVersion, webOrigin) || transferToken && (event.status.updateDetachment?.connectionState !== 'connected' || event.status.updateDetachment.operationId !== updateRuntime.snapshot(coordinator.snapshot()).operationId)) {
                 finish(reject, new Error("Updated desktop runtime identity mismatch."));
               } else { accepted = true; finish(accept, event); }
             }
@@ -879,8 +903,10 @@ export async function startDesktopHost({ input = process.stdin, output = process
         await stopAgent();
         if (child.exitCode !== null || closed) throw new Error("Updated runtime stopped during handoff.");
         emit(first);
+        return {connectionTransferred:Boolean(transferToken)};
       } catch (error) {
         lines.close(); await stopUpdateCandidate(child);
+        if(transferToken)await updateRuntime.reclaimFailedHandoff();
         if (!closed && !relay) {
           actionAssociations = makeActionAssociations();
           analysisManager = await makeAnalysisManager(); automaticContinuation = makeAutomaticContinuation(); discoveryStopped = false; refreshSessions(true);
@@ -892,7 +918,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     await publish();
     const maintenance = new Map();
     const tick = worker => {
-      if (closed || relay || maintenance.has(worker)) return;
+      if (closed || relay || !coordinator.acceptsNewWork() || maintenance.has(worker)) return;
       const pending = Promise.resolve().then(() => worker.tick()).then(() => { if (!closed && !relay) return publish(); }).catch(() => {}).finally(() => maintenance.delete(worker));
       maintenance.set(worker, pending);
     };
@@ -999,6 +1025,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
       if (!relay.stdin.destroyed && relay.exitCode === null) relay.stdin.write(`${JSON.stringify(command)}\n`);
       return;
     }
+    if(command.action==='cancel_detach_update') {
+      try {updateRuntime.validate(command,coordinator.snapshot(),updater?.snapshot?.());coordinator.cancel();emit({type:'result',id:command.id,ok:true});}
+      catch {emit({type:'result',id:command.id,ok:false,message:'This update operation changed. Refresh its status.'});}
+      return;
+    }
     // Read-only activity must never hold the ordered control queue. Share an
     // identical pending selection and cancel superseded selections immediately.
     let statisticsRequest, requestedStatisticsSelection;
@@ -1014,6 +1045,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
       if (closed) return;
       try {
         const action = command.action;
+        if(['detach_update','update_reconnect'].includes(action)) {
+          const access=await accessSnapshot(); requireDesktopAccess(access);
+          updateRuntime.validate(command,coordinator.snapshot(),updater?.snapshot?.());
+          if(action==='detach_update')await updater.maybeApply({detach:true});
+          else await coordinator.reconnect();
+          emit({type:'result',id:command.id,ok:coordinator.snapshot().state==='connected' && (action!=='detach_update' || updater.snapshot().state==='updated')});
+          await publish();return;
+        }
         if (action === "quit") {
           if (command.forUpdate === true) {
             if (command.force !== true) throw new Error('Confirm before stopping unfinished tasks.');
@@ -1048,6 +1087,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
             if ((status.tasks?.activeCount || 0) + (status.sqmTasks?.activeCount || 0) > 0 ||
               hasUnfinishedSessions(await recordReader.list())) throw new Error('Confirm before stopping tasks to restart.');
           }
+          if (!coordinator.acceptsNewWork()) throw new Error('Reconcile the update connection before starting another update.');
           await executeUpdate(action === 'prepare_update_restart');
           emit({ type: 'result', id: command.id, ok: true });
           void publish().catch(() => {}); return;
@@ -1055,8 +1095,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
         const access = await accessSnapshot();
         const commandScope = accessScope(access);
         if (!desktopActionAllowed(access, command)) throw Object.assign(new Error('Desktop access is required.'), { code: 'desktop_access_required' });
-        if (desktopAccessReady(access) && !desktopActionAllowed({ state: 'unavailable' }, command)) await authorizeWork();
+        const recoveryControl = ['provider_disconnect', 'session_unmonitor'].includes(action) ||
+          ['session_set_auto_continue', 'session_set_email_reports'].includes(action) && command.enabled === false;
+        if (['detach_update', 'update_reconnect'].includes(action)) requireDesktopAccess(access);
+        else if (!recoveryControl && desktopAccessReady(access) && !desktopActionAllowed({ state: 'unavailable' }, command)) await authorizeWork();
 
+        if (!coordinator.acceptsNewWork() && !recoveryControl && !["refresh", "reconnect", "task_detail", "check_update", "quit", "delivery_stop", "delivery_pause", "delivery_reject"].includes(action)) {
+          throw new Error("The update connection requires recovery.");
+        }
         let commandProviderLink;
         if (command.provider && !["provider_connect", "provider_disconnect", "delivery_stop", "delivery_pause", "delivery_reject", "session_untrack", "session_unmonitor"].includes(action) &&
           !(action === "session_set_auto_continue" && command.enabled === false)) {
@@ -1137,7 +1183,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await agent.refreshDesktopStatus();
           await refreshPlugins();
           refreshSessions(true);
-          if (desktopAccessReady(currentAccess)) void actionAssociations.tick().then(publish).catch(() => {});
+          if (desktopAccessReady(currentAccess) && coordinator.acceptsNewWork()) void actionAssociations.tick().then(publish).catch(() => {});
         }
         else if (action === "organizations_refresh") await agent.refreshOrganizations();
         else if (action === "sqm_set_enabled") await agent.setSqmEnabled(command.enabled);

package/src/desktop-status.js

@@ -231,7 +231,7 @@ export function isUnauthorizedError(error) {
 
 export function canStopDesktopTask(task, registryIndex) {
   const state = task?.status || task?.snapshot?.state || task?.state || task?.control_state || task?.controlState || "unknown";
-  return registryIndex === 0 ? !INACTIVE_STATES.has(state) : ["queued", "running", "stopping"].includes(state);
+  return registryIndex === 0 ? !INACTIVE_STATES.has(state) : ["queued", "running", "stopping"].includes(state) || registryIndex === 1 && state === "recovery_required" && Boolean(task?.worker_handle);
 }
 
 function taskStatusItem(task, registryIndex) {

package/src/direct-executor.js

@@ -1,4 +1,10 @@
+import { atomicSave, digest } from './update-detachment/state-store.js';
+import { join } from 'node:path';
+import { captureDispatchProvenance } from './update-detachment/provenance.js';
 import { signalExecutorProcess } from "./runner.js";
+import { createExecutionWorker } from "./update-detachment/worker.js";
+import path from "node:path";
+import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, observeDispatchEvent, queueDispatchReceipt } from './update-detachment/dispatch-gate.js';
 import { randomUUID } from "node:crypto";
 import { withSceneReasoning } from "./codex-plugins/simy/hooks/scene-reasoning.mjs";
 
@@ -58,10 +64,15 @@ export function createDirectTask({
 
 export async function startDirectTask(
   task,
-  { resolveCommand = resolveDesktopExecutorCommand, environment = process.env } = {},
+  { resolveCommand = resolveDesktopExecutorCommand, environment = process.env, session, apiOrigin, sessionRoot, worker = null, workerBinding = null, deadlineAt = null, workerPolicy = null } = {},
 ) {
   if (!task || task.status !== "queued") throw new Error("Direct task must be queued.");
   if (task.invocation_count >= 1) throw new Error("Direct tasks allow only one Provider invocation.");
+  const dispatchOwner = captureDispatchOwner(workerBinding?.root || sessionRoot);
+  const dispatchAttemptId = `${task.id}:provider:1`;
+  const recordRef = join(dispatchOwner.root, 'direct-tasks', `${digest(task.id)}.json`);
+  const provenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: task.backend, worktree: task.repository_path, accountSession: session, origin: apiOrigin, taskId: task.id, recordRef });
+  assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance });
   const command = await resolveCommand({
     backend: task.backend,
     instruction: withSceneReasoning("Complete only the requested bounded direct task in this invocation. Respect the assigned permission mode; do not create an automatic retry loop or expand the task scope.", task.instruction),
@@ -75,17 +86,44 @@ export async function startDirectTask(
   task.invocation_count = 1;
   task.updated_at = new Date().toISOString();
 
+  if (worker || (resolveCommand === resolveDesktopExecutorCommand && process.platform !== "win32")) {
+    const owner = worker || createExecutionWorker();
+    const identity = owner.identity || workerBinding || {
+      provider: task.backend, session: task.id,
+      // Standalone direct invocations inherit the existing account environment.
+      // This is not a verified existing app-server/live-hook account binding.
+      account: "inherited-provider-environment", origin: "simy-direct",
+      worktree: path.resolve(task.repository_path),
+    };
+    task.worker = owner;
+    task.worker_handle = { attemptId: task.id, identity };
+    const originalDeadline = deadlineAt ?? null;
+    task.worker_start = owner.start({ ...task.worker_handle, command, cwd: task.repository_path, backend: task.backend,
+      deadlineAt: originalDeadline, taskId: task.id,
+      preservation: { taskState: "active", metadata: directTaskSnapshot(task), policy: workerPolicy || { model: "provider-default", permissions: task.permission_mode, approvals: { operation: task.operation, maxProviderInvocations: 1 }, budget: null, deadline: originalDeadline }, artifacts: [] } });
+    try { task.worker_handle = { ...task.worker_handle, ...await task.worker_start }; }
+    catch (error) {
+      if (error.workerHandle) task.worker_handle = error.workerHandle;
+      task.status = "recovery_required";
+      task.error = "Worker launch outcome could not be confirmed. Reconcile saved evidence before retrying.";
+      return task;
+    }
+    if (task.stop_requested) await owner.stop(task.worker_handle);
+    return await reconcileDirectWorker(task);
+  }
+
+  atomicSave(recordRef, { schemaVersion: 1, revision: 0, ...directTaskSnapshot(task) });
   return new Promise((resolve) => {
     let settled = false;
     let terminalError = null;
     const rawStdout = [];
     const tokenRecords = [];
-    const child = command.spawn(command.bin, command.args, {
+    const child = dispatchWithFence(dispatchOwner, { taskId: task.id, attemptId: dispatchAttemptId, provenance }, () => command.spawn(command.bin, command.args, {
       cwd: task.repository_path,
       env: { ...process.env, ...command.env },
       stdio: ["ignore", "pipe", "pipe"],
       detached: process.platform !== "win32",
-    });
+    }));
     task.child = child;
     const onLine = (line) => {
       const normalized = String(line || "").trim();
@@ -99,6 +137,7 @@ export async function startDirectTask(
     const stdoutDecoder = createProviderStreamDecoder({
       backend: task.backend,
       stream: "stdout",
+      onEvent: event => { const identity = observeDispatchEvent({ root: dispatchOwner.root, attemptId: dispatchAttemptId, provider: task.backend, event, onError: error => { task.dispatch_recovery_required = error.code || 'provenance_persistence_failed'; } }); if (identity) task.dispatch_identity = identity; },
       onLine,
       onTerminalError: (message) => { terminalError ||= message; },
       onUsage: (usage) => tokenRecords.push({ ...usage, phase: "direct", backend: task.backend }),
@@ -127,6 +166,13 @@ export async function startDirectTask(
       task.error = task.stop_requested ? null : error || (exitCode !== 0 ? `Provider exited with code ${exitCode}.` : null);
       task.result = task.output.at(-1) || rawStdout.join("").trim() || null;
       task.updated_at = new Date().toISOString();
+      try {
+        atomicSave(recordRef, { schemaVersion: 1, revision: 1, ...directTaskSnapshot(task), ...(task.dispatch_recovery_required ? { dispatch_recovery_required: task.dispatch_recovery_required } : {}), ...(task.dispatch_identity ? { dispatch_identity: task.dispatch_identity } : {}) });
+        queueDispatchReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, receiptId: `result:${dispatchAttemptId}`, resultRef: recordRef });
+      } catch (error) {
+        task.dispatch_recovery_required = error.code || 'provenance_persistence_failed';
+        try { atomicSave(recordRef, { schemaVersion: 1, revision: 1, ...directTaskSnapshot(task), ...(task.dispatch_identity ? { dispatch_identity: task.dispatch_identity } : {}) }); } catch {}
+      }
       resolve(task);
     };
     child.on("error", (error) => finish({ error: error.message }));
@@ -137,6 +183,7 @@ export async function startDirectTask(
 export function directTaskSnapshot(task) {
   return {
     id: task.id,
+    ...(task.dispatch_recovery_required ? { dispatch_recovery_required: task.dispatch_recovery_required } : {}),
     status: task.status,
     instruction: task.instruction,
     backend: task.backend,
@@ -153,15 +200,50 @@ export function directTaskSnapshot(task) {
   };
 }
 
+// Read-only reconnect: never starts a second Provider invocation.
+export async function reconcileDirectWorker(task, { worker = task.worker || createExecutionWorker() } = {}) {
+  while (true) {
+    if (task.observation_suspended) return task;
+    const state = await worker.result(task.worker_handle);
+    if (task.observation_suspended) return task;
+    if (state.state === "completed") {
+      const receipt = state.receipt;
+      Object.assign(task, {
+        status: receipt.status, output: receipt.output, result: receipt.result,
+        error: receipt.error, token_usage: receipt.token_usage,
+        updated_at: new Date(receipt.finishedAt).toISOString(),
+      });
+      return task;
+    }
+    if (state.state === "recovery_required") {
+      task.status = "recovery_required";
+      task.error = state.storageError
+        ? "Worker receipt storage failed. The confirmed owner remains stoppable; review saved evidence before retrying."
+        : "Worker owner could not be confirmed. Review saved evidence before retrying.";
+      return task;
+    }
+    task.output = state.output || task.output;
+    task.token_usage = state.token_usage || task.token_usage;
+    task.updated_at = new Date().toISOString();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+
 // Only the child captured by this task may be signalled, including its owned tools.
 export function stopDirectTask(task) {
   if (!task) return Promise.resolve(task);
   return task.stopPromise ||= stopOwnedDirectTask(task);
 }
 async function stopOwnedDirectTask(task) {
-  if (!task || !["queued", "running", "stopping"].includes(task.status)) return task;
+  if (!task || (!["queued", "running", "stopping"].includes(task.status) && !(task.status === "recovery_required" && task.worker_handle))) return task;
   task.stop_requested = true;
   task.status = "stopping";
+  if (task.worker_handle) {
+    // Launch uncertainty does not prevent stopping a separately confirmed owner.
+    await task.worker_start?.catch(() => {});
+    await task.worker.stop(task.worker_handle);
+    return reconcileDirectWorker(task);
+  }
   const child = task.child;
   if (!child) { task.status = "stopped"; task.updated_at = new Date().toISOString(); return task; }
   for (const signal of ["SIGINT", "SIGTERM", "SIGKILL"]) {
@@ -176,3 +258,21 @@ async function stopOwnedDirectTask(task) {
   if (task.child === child) throw new Error("The local task did not stop. Try quitting SIMY.");
   return task;
 }
+
+// The host reconstructs its registry from the registered preservation record,
+// never from a new Provider dispatch or a user-supplied unbound task ID.
+export async function restoreDirectWorkerTask({ worker, handle, registry }) {
+  const state = await worker.adopt(handle);
+  const snapshot = worker.readSnapshot(handle);
+  if (snapshot?.task?.id !== handle.taskId || snapshot.metadata?.id !== handle.taskId) throw new Error("Direct worker task snapshot unavailable.");
+  let task = registry.get(handle.taskId);
+  if (!task) task = registry.create({ ...structuredClone(snapshot.metadata), repository_path: handle.identity.worktree,
+    worker, worker_handle: handle, child: null, invocation_count: 1,
+    stop_requested: snapshot.task.stopRequested || snapshot.task.state === "stopped" || state.state === "stopping" });
+  if (state.state === "completed") return reconcileDirectWorker(task, { worker });
+  task.stop_requested ||= snapshot.task.stopRequested || state.state === "stopping";
+  task.status = task.stop_requested ? "stopping" : state.state === "running" ? "running" : "recovery_required";
+  task.output = state.output || task.output;
+  task.token_usage = state.token_usage || task.token_usage;
+  return task;
+}

package/src/local-task.js

@@ -1,3 +1,5 @@
+import { captureDispatchProvenance } from './update-detachment/provenance.js';
+import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, observeDispatchEvent, queueDispatchReceipt } from './update-detachment/dispatch-gate.js';
 import { normalizePurposeVerification } from "./purpose-local-proof.js";
 import { buildWorkflowReportingInstruction } from "./workflow-reporting.js";
 import { execFile } from "node:child_process";
@@ -449,12 +451,17 @@ export async function startLocalTask(
     beforeSpawn = null,
     session = null,
     apiOrigin = null,
+    sessionRoot,
     observationFetch = globalThis.fetch,
     deliverableUploadSleep = undefined,
   } = {},
 ) {
   if (!task || task.status !== "queued") throw new Error("Local Task must be queued.");
   if (task.invocation_count >= 1) throw new Error("Local Tasks allow only one Provider invocation.");
+  const dispatchOwner = captureDispatchOwner(sessionRoot);
+  const dispatchAttemptId = `${task.id}:provider:1`;
+  const provenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: task.backend, worktree: task.workspace_path, accountSession: session || undefined, origin: apiOrigin || undefined, taskId: task.id, recordRef: path.join(task.task_root, 'task.json') });
+  assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance });
   updateTask(task, {
     control_state: "starting",
     invocation_count: 1,
@@ -573,7 +580,7 @@ export async function startLocalTask(
     const tokenRecords = [];
     let child;
     try {
-      child = command.spawn(command.bin, command.args, {
+      child = dispatchWithFence(dispatchOwner, { taskId: task.id, attemptId: dispatchAttemptId, provenance }, () => command.spawn(command.bin, command.args, {
         cwd: task.workspace_path,
         env: {
           ...process.env,
@@ -586,7 +593,7 @@ export async function startLocalTask(
         },
         stdio: ["ignore", "pipe", "pipe"],
         detached: process.platform !== "win32",
-      });
+      }));
     } catch (error) {
       void rm(runtimeTempRoot, { recursive: true, force: true }).then(
         () => reject(error),
@@ -631,7 +638,7 @@ export async function startLocalTask(
       stream: "stdout",
       onLine,
       onUsage,
-      onEvent: (event) => observationSender?.observe(event),
+      onEvent: (event) => { const identity = observeDispatchEvent({ root: dispatchOwner.root, attemptId: dispatchAttemptId, provider: task.backend, event, onError: error => { task.dispatch_recovery_required = error.code || 'provenance_persistence_failed'; } }); if (identity) task.dispatch_identity = identity; observationSender?.observe(event); },
       onTerminalError: (message) => {
         task.error ||= message;
         task.reason_code ||= "provider_execution_failed";
@@ -786,6 +793,8 @@ export async function startLocalTask(
               : task.error || "Local Task failed.",
       });
       await persist(task);
+      try { queueDispatchReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, receiptId: `result:${dispatchAttemptId}`, resultRef: provenance.recordRef }); }
+      catch (error) { task.dispatch_recovery_required = error.code || 'provenance_persistence_failed'; try { await persist(task); } catch {} }
       resolve(task);
     };
     child.on("error", (spawnError) => void finish({ error: spawnError.message }));
@@ -831,6 +840,8 @@ export async function stopLocalTask(task, { persist = persistLocalTask } = {}) {
 export function localTaskSnapshot(task, { includeEvents = true, includeLocalPaths = false } = {}) {
   return {
     id: task.id,
+    ...(task.dispatch_recovery_required ? { dispatch_recovery_required: task.dispatch_recovery_required } : {}),
+    ...(includeLocalPaths && task.dispatch_identity ? { dispatch_identity: task.dispatch_identity } : {}),
     kind: "local_task",
     status: task.status,
     control_state: task.control_state,

package/src/runner.js

@@ -1,3 +1,5 @@
+import { captureDispatchProvenance } from './update-detachment/provenance.js';
+import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, observeDispatchEvent, queueDispatchReceipt } from './update-detachment/dispatch-gate.js';
 import { execFile, execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { EventEmitter, once } from "node:events";
@@ -1060,7 +1062,11 @@ export async function executeProcessAttempt({
   onExecutionComplete = null,
   readOnly = false,
 }) {
+  const dispatchOwner = captureDispatchOwner(run.sqmHistoryRoot || (run.localStateRoot ? path.dirname(run.localStateRoot) : undefined));
   const phase = marker === "SIMY_AUDIT_JSON:" ? "reviewer" : "executor";
+  const dispatchAttemptId = `${run.snapshot.id}:${phase}:${attemptNumber ?? run.snapshot.attempts?.length ?? 0}`;
+  const provenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: backend, worktree: repositoryPath, accountSession: run.session, origin: run.apiOrigin || undefined, taskId: run.snapshot.id, recordRef: run.localStateRoot ? path.join(run.localStateRoot, `${run.snapshot.id}.json`) : `coding-run:${run.snapshot.id}` });
+  assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance });
   const command = await resolveCommandImpl({
     backend,
     instruction,
@@ -1094,7 +1100,7 @@ export async function executeProcessAttempt({
     let terminalError = null;
     let terminalErrorCode = null;
     const checkpointWrites = [];
-    const child = command.spawn(command.bin, command.args, {
+    const child = dispatchWithFence(dispatchOwner, { taskId: run.snapshot.id, attemptId: dispatchAttemptId, provenance }, () => command.spawn(command.bin, command.args, {
       cwd: repositoryPath,
       env: {
         ...process.env,
@@ -1104,14 +1110,14 @@ export async function executeProcessAttempt({
       },
       stdio: ["ignore", "pipe", "pipe"],
       detached: process.platform !== "win32",
-    });
+    }));
     run.child = child;
 
     const stdoutDecoder = createProviderStreamDecoder({
       backend,
       stream: "stdout",
       onLine: (line) => emitOutput(run, line, { backend }),
-      onEvent: (event) => observationSender?.observe(event),
+      onEvent: (event) => { const identity = observeDispatchEvent({ root: dispatchOwner.root, attemptId: dispatchAttemptId, provider: backend, event, onError: error => { run.snapshot.metadata.dispatch_recovery_required = error.code || 'provenance_persistence_failed'; } }); if (identity) { run.snapshot.metadata.dispatch_identities ||= {}; run.snapshot.metadata.dispatch_identities[dispatchAttemptId] = identity; } observationSender?.observe(event); },
       onTerminalError: (message) => { terminalError ||= message; },
       onUsage: (usage) => {
         tokenUsageRecords.push({
@@ -1183,7 +1189,16 @@ export async function executeProcessAttempt({
         startedAt,
         finishedAt: new Date().toISOString(),
       };
-      try { await onExecutionComplete?.(execution); }
+      try {
+        if (run.localStateRoot) {
+          run.snapshot.metadata.dispatch_results ||= {};
+          run.snapshot.metadata.dispatch_results[dispatchAttemptId] = execution;
+          await saveCodingRunSnapshot(run.localStateRoot, run.snapshot);
+          try { queueDispatchReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, receiptId: `result:${dispatchAttemptId}`, resultRef: provenance.recordRef }); }
+          catch (error) { run.snapshot.metadata.dispatch_recovery_required = error.code || 'provenance_persistence_failed'; await saveCodingRunSnapshot(run.localStateRoot, run.snapshot); }
+        }
+        await onExecutionComplete?.(execution);
+      }
       catch (error) { reject(error); return; }
       // The run must always resolve: a WorkFlow observation failure (or a
       // sender bug) never changes or blocks the Provider result. flush() is

package/src/session-supervision/claude-sessions.js

@@ -2,6 +2,7 @@ import { statisticsFromHandle, unavailableStatistics } from './statistics.js';
 import { constants } from 'node:fs';
 import { lstat, open, readdir, realpath } from 'node:fs/promises';
 import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { boundConversation, CONVERSATION_LIMITS, textContent } from './conversation-context.js';
 import { sessionTitle } from './session-titles.js';
@@ -101,7 +102,7 @@ async function latestCustomTitle(handle, size, id) {
   return title;
 }
 
-async function inspectTranscript(root, projectName, fileName, observedAt, includeContext = false, cacheMetadata = false, includeStatistics = false, signal) {
+async function inspectTranscript(root, projectName, fileName, observedAt, includeContext = false, cacheMetadata = false, includeStatistics = false, signal, includeBoundary = false) {
   signal?.throwIfAborted();
   const id = fileName.slice(0, -'.jsonl'.length);
   if (!UUID.test(id)) return null;
@@ -147,12 +148,17 @@ async function inspectTranscript(root, projectName, fileName, observedAt, includ
     signal?.throwIfAborted();
     if (includeStatistics) candidate.statistics = await statisticsFromHandle(handle, opened, 'claude', id, { signal });
     if (includeContext) candidate.context = await conversationFromHandle(handle, opened, id, metadata.cwd);
+    if (includeBoundary) {
+      candidate.boundary = await boundaryFromHandle(handle, opened, id, metadata.cwd, signal);
+      const after = await lstat(path);
+      if (!after.isFile() || after.isSymbolicLink() || after.dev !== opened.dev || after.ino !== opened.ino || after.size !== opened.size || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs) return null;
+    }
     return candidate;
   } catch (error) { metadataCache.delete(path); if (signal?.aborted) throw error; return null; }
   finally { await handle?.close(); }
 }
 
-async function collect({ home = homedir(), limit = 100, session = null, prioritySessions = [], includeContext = false, cacheMetadata = false, includeStatistics = false, signal } = {}) {
+async function collect({ home = homedir(), limit = 100, session = null, prioritySessions = [], includeContext = false, cacheMetadata = false, includeStatistics = false, includeBoundary = false, signal } = {}) {
   if (signal?.aborted) return [];
   const root = await projectsRoot(home);
   if (!root) return [];
@@ -203,13 +209,13 @@ async function collect({ home = homedir(), limit = 100, session = null, priority
   let nextFile = 0;
   // Catalog prefixes are bounded independently of full transcript size. Use a
   // small I/O pool; exact-context/statistics reads stay serial and identity-safe.
-  await Promise.all(Array.from({ length: Math.min(includeContext || includeStatistics ? 1 : 8, filesToInspect.length) }, async () => {
+  await Promise.all(Array.from({ length: Math.min(includeContext || includeStatistics || includeBoundary ? 1 : 8, filesToInspect.length) }, async () => {
     while (nextFile < filesToInspect.length && !signal?.aborted) {
       const file = filesToInspect[nextFile++];
-      let candidate = await inspectTranscript(root, file.projectName, file.fileName, observedAt, includeContext, cacheMetadata, includeStatistics, signal);
+      let candidate = await inspectTranscript(root, file.projectName, file.fileName, observedAt, includeContext, cacheMetadata, includeStatistics, signal, includeBoundary);
       if (!candidate) continue;
       candidate = decorateLineage(candidate);
-      const key = `${candidate.session}\0${candidate.cwd}${includeContext || includeStatistics ? `\0${file.projectName}\0${file.fileName}` : ''}`;
+      const key = `${candidate.session}\0${candidate.cwd}${includeContext || includeStatistics || includeBoundary ? `\0${file.projectName}\0${file.fileName}` : ''}`;
       if (!result.has(key) || candidate.lastActivityAt > result.get(key).lastActivityAt) result.set(key, candidate);
     }
   }));
@@ -305,6 +311,52 @@ export async function readClaudeConversation(candidate, { home, signal } = {}) {
   return { ...selected[0].context, awaitingTurn: candidate.isRunning === true };
 }
 
+// Update recovery needs coverage of the complete saved transcript, not the
+// deliberately shortened text used for presentation. Stream and validate every
+// envelope while retaining only a digest and counters, never message prose.
+async function boundaryFromHandle(handle, opened, session, cwd, signal) {
+  const maxBytes = 64 * 1024 * 1024, maxLineBytes = 4 * 1024 * 1024;
+  if (!opened.size || opened.size > maxBytes) return null;
+  const hash = createHash('sha256'), buffer = Buffer.alloc(64 * 1024);
+  let offset = 0, pending = Buffer.alloc(0), rows = 0, messageCount = 0, lastMessageRef = null;
+  const decoder = new TextDecoder('utf-8', { fatal: true });
+  while (offset < opened.size) {
+    signal?.throwIfAborted();
+    const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, opened.size - offset), offset);
+    if (!bytesRead) return null;
+    const chunk = buffer.subarray(0, bytesRead); hash.update(chunk); offset += bytesRead;
+    pending = Buffer.concat([pending, chunk]);
+    let newline;
+    while ((newline = pending.indexOf(10)) !== -1) {
+      if (newline > maxLineBytes || ++rows > 250000) return null;
+      const line = pending.subarray(0, newline); pending = pending.subarray(newline + 1);
+      if (!line.length) continue;
+      let item;
+      try { item = JSON.parse(decoder.decode(line)); } catch { return null; }
+      if (!item || typeof item !== 'object' || Array.isArray(item)) return null;
+      if (unscopedFileHistory(item)) continue;
+      if (item.sessionId !== session || item.isSidechain === true) return null;
+      if (!['user', 'assistant'].includes(item.type) || item.isMeta === true) continue;
+      if (typeof item.cwd !== 'string' || !isAbsolute(item.cwd) || !within(cwd, resolve(item.cwd)) || typeof item.uuid !== 'string' || !item.uuid) return null;
+      if (item.type === 'user' && !textContent(item.message?.content).trim() && !item.message?.content?.every?.(part => part?.type === 'tool_result')) return null;
+      messageCount++; lastMessageRef = item.uuid;
+    }
+    if (pending.length > maxLineBytes) return null;
+  }
+  const after = await handle.stat();
+  if (pending.length || !messageCount || after.size !== opened.size || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs) return null;
+  return { schemaVersion: 1, complete: true, digest: hash.digest('hex'), byteLength: offset, messageCount, lastMessageRef };
+}
+
+export async function readClaudeBoundary(candidate, { home, signal = AbortSignal.timeout(8000) } = {}) {
+  signal.throwIfAborted();
+  if (!UUID.test(candidate?.session || '') || typeof candidate?.cwd !== 'string') return null;
+  const matches = (await collect({ home, session: candidate.session, includeBoundary: true, signal })).filter(item => item.cwd === candidate.cwd);
+  signal.throwIfAborted();
+  if (matches.length !== 1 || Number.isFinite(candidate.lastActivityAt) && matches[0].lastActivityAt !== candidate.lastActivityAt) return null;
+  return matches[0].boundary || null;
+}
+
 export async function readClaudeStatistics(candidate, { home, signal } = {}) {
   signal?.throwIfAborted();
   if (!UUID.test(candidate?.session || '')) return unavailableStatistics();