@awak-app/simy-cli 0.7.10 → 0.7.12

package/src/delivery-hooks/supervisor.js

@@ -1,3 +1,5 @@
+import { captureDispatchProvenance } from '../update-detachment/provenance.js';
+import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, rootFromDelivery, observeDispatchEvent } from '../update-detachment/dispatch-gate.js';
 import { safeCheckpointDiagnostic } from './checkpoint-diagnostic.js';
 import { recordHandoffStage } from '../codex-plugins/simy/hooks/consistency-handoff.mjs';
 import { retainControllerEvidence } from '../codex-plugins/simy/hooks/purpose-evidence.mjs';
@@ -13,7 +15,7 @@ import { requireProviderLink } from '../provider-links.js';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
-import { canExecuteAutonomousExternal, automaticContinuationAllowed, settlePurposeVerification, assessedCheckpointContract, checkpointDelivery, decideStop, deliveryProgressContext, deliveryStop, listRecords, readRecord, managedBudgetReason, notifyState, processIdentity, sharesTaskWorkspace, taskDirectory, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { hasPendingUserStop, recordPath, canExecuteAutonomousExternal, automaticContinuationAllowed, settlePurposeVerification, assessedCheckpointContract, checkpointDelivery, decideStop, deliveryProgressContext, deliveryStop, listRecords, readRecord, managedBudgetReason, notifyState, processIdentity, sharesTaskWorkspace, taskDirectory, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { resolveBackendExecutable } from '../backend-executable.js';
 import { executeCodexAppServer } from '../session-supervision/codex-app-server.js';
 import { acquireWorkspaceLease, leaseOwnerDead } from '../session-supervision/workspace-lease.js';
@@ -50,6 +52,7 @@ async function assertActiveLease(root, provider, session, leaseId, signal, curre
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
   await requireProviderLink({ root, provider });
   const current = await readRecord(root, provider, session);
+  if (hasPendingUserStop(root, current)) throw new Error('User stopped this provider task.');
   if (signal?.aborted || current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) {
     throw new Error('Managed recovery lease changed before provider dispatch.');
   }
@@ -83,12 +86,15 @@ export function parseAgentCheckpoint(output, expectedSession) {
 // The provider CLI is a new process. It is used only for an exact Codex UUID
 // enrolled for this recovery channel after a corroborated process exit.
 export async function executeCodexResume(record, { signal, root, leaseId, executable = resolveBackendExecutable, currentTime = Date.now, onActivity = () => {}, beforeDispatch = async () => {}, leaseMonitored = false } = {}) {
+  const dispatchOwner = captureDispatchOwner(rootFromDelivery(root));
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
+  const run = record.run;
+  const provenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: record.provider, providerSession: record.session, worktree: taskDirectory(record), taskId: run.managed.taskId, recordRef: recordPath(root, record.provider, record.session) });
+  assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance });
   const binary = await executable('codex');
   if (!binary) throw new Error('Codex executable unavailable.');
   await assertActiveLease(root, record.provider, record.session, leaseId, signal, currentTime);
-  const run = record.run;
-    const context = { taskId: run.managed.taskId, session: record.session, sessionCwd: record.cwd, executionCwd: taskDirectory(record), objective: run.objective, nextStep: run.nextStep,
+  const context = { taskId: run.managed.taskId, session: record.session, sessionCwd: record.cwd, executionCwd: taskDirectory(record), objective: run.objective, nextStep: run.nextStep,
     lastDependencyResolution: run.managed.lastDependencyResolution,
     ...(run.managed.upgradedFrom ? { adoptedLoop: run.managed.upgradedFrom, priorCheckpoint: run.checkpoint } : {}),
     remainingWork: run.managed.remainingWork, acceptanceCriteria: run.managed.acceptanceCriteria, proposedAction: run.managed.proposedAction,
@@ -102,14 +108,15 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
 
   return new Promise((resolve, reject) => {
-    const child = spawn(binary, args, { cwd: record.cwd, stdio: ['ignore', 'pipe', 'pipe'], signal,
-      env: { ...process.env, SIMY_HOME: dirname(root) } });
+    const child = dispatchWithFence(dispatchOwner, { taskId: run.managed?.taskId || record.session, attemptId: leaseId, provenance }, () => { if (hasPendingUserStop(root, record)) throw new Error('User stopped this provider task.'); return spawn(binary, args, { cwd: taskDirectory(record), stdio: ['ignore', 'pipe', 'pipe'], signal,
+      env: { ...process.env, SIMY_HOME: dirname(root) } }); });
     let error = '', spawnError = null, pending = '', lastMessage = null;
     const startedSessions = new Set();
     const consumeLine = line => {
       if (Buffer.byteLength(line) > MAX_OUTPUT) return;
       try {
         const event = JSON.parse(line);
+        observeDispatchEvent({ root: dispatchOwner.root, attemptId: leaseId, provider: record.provider, event });
         if (event.type === 'thread.started' && typeof event.thread_id === 'string') startedSessions.add(event.thread_id);
         if (event.type === 'item.completed' && event.item?.type === 'agent_message' && typeof event.item.text === 'string') lastMessage = event.item.text;
       } catch { /* Other provider events are ignored. */ }
@@ -123,7 +130,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
     };
     signal?.addEventListener('abort', terminate, { once: true });
     const stopWatch = leaseMonitored ? () => {} : watchLease(root, record.provider, record.session, current => {
-      if (current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) terminate();
+      if (hasPendingUserStop(root, current) || current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) terminate();
     }, terminate);
     child.stdout.on('data', chunk => {
       onActivity();
@@ -138,7 +145,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
       cleanup(); if (pending) consumeLine(pending);
       const output = [...startedSessions].map(thread_id => JSON.stringify({ type: 'thread.started', thread_id })).join('\n') + '\n' +
         (lastMessage === null ? '' : JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: lastMessage } }));
-      if (spawnError) reject(spawnError); else resolve({ code, output, error });
+      if (spawnError) reject(spawnError); else resolve({ code, dispatchAttemptId: leaseId, output, error });
     });
   });
 }
@@ -159,6 +166,13 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
     record = await recoverOutcomeAuditLease(record, { root, inspectProcess });
     let run = record.run;
     if (!run?.managed) continue;
+    if (hasPendingUserStop(root, record)) {
+      await updateRecord(root, record.provider, record.session, current => {
+        if (hasPendingUserStop(root, current)) { current.run.state = 'stopped'; current.run.reason = 'User interrupted the provider.'; current.run.updatedAt = now; }
+        return current;
+      });
+      continue;
+    }
     // The audit must retain a stable target until its result is settled, even
     // when no token ceiling is configured. Its own timeout/owner recovery
     // releases this lease; a worker never takes it over.
@@ -169,7 +183,7 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
       // A live/unknown owner is never taken over merely because time passed.
       if (!ownerDead && (owner || claimNow - run.managed.resumeLease?.claimedAt <= 5 * 60_000)) continue;
       await updateRecord(root, record.provider, record.session, current => {
-        if (current?.run?.state !== 'auto_resuming' || current.run.managed.resumeLease?.id !== run.managed.resumeLease?.id) return current;
+        if (hasPendingUserStop(root, current) || current?.run?.state !== 'auto_resuming' || current.run.managed.resumeLease?.id !== run.managed.resumeLease?.id) return current;
         current.run.state = 'recovery_required'; current.run.recoveryCause = 'interrupted_owner'; current.run.managed.autoRecovery = false;
         recordRecoveryIncident(current.run, { code: 'interrupted_owner', subject: current.run.managed.executionAttempt?.id || '', now: claimNow });
         recordRecoveryStage(current.run, 'interrupted', { now: claimNow, attemptId: current.run.managed.executionAttempt?.id });
@@ -268,7 +282,7 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
     if (signal?.aborted) controller.abort();
     else signal?.addEventListener('abort', abort, { once: true });
     const stopWatch = watchLease(root, record.provider, record.session, current => {
-      if (current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId ||
+      if (hasPendingUserStop(root, current) || current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId ||
         managedBudgetReason(current.run, currentTime(), { checkProgress: false }) || !waitingForTool && currentTime() - lastActivityAt >= 5 * 60_000) controller.abort();
     }, () => controller.abort());
     try {
@@ -381,6 +395,7 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
         if (result.verification) await settlePurposeVerification({ root, provider: record.provider, session: record.session, expectedLease: leaseId, review: result.verification, verifySnapshot: current => reviewWorkspaceIdentity(current, root, result.verification, { signal: controller.signal }), now: Date.now() });
         else await checkpointDelivery({ root, provider: record.provider, session: record.session, cwd: record.cwd,
           checkpoint: result.checkpoint || parseAgentCheckpoint(result.output, record.session), expectedLease: leaseId, toolEvidence: result.toolEvidence || [], sourceContext: result.sourceContext, controllerEvidence: result.controllerEvidence, now: Date.now() });
+        if (result.dispatchAttemptId) queueDispatchReceipt({ root: rootFromDelivery(root), attemptId: result.dispatchAttemptId, receiptId: `checkpoint:${leaseId}`, resultRef: `delivery-record:${record.provider}:${record.session}:${leaseId}` });
         await updateRecord(root, record.provider, record.session, current => {
           if (current?.run?.managed?.executionAttempt?.id !== leaseId) return current;
           current.run.managed.executionAttempt.phase = 'checkpointed';
@@ -404,7 +419,7 @@ export async function tickManagedTasks({ root, webOrigin, now = Date.now(), exec
         });
       } catch (error) { result = { ...result, code: -1, errorCode: 'checkpoint_rejected', diagnostic: safeCheckpointDiagnostic(error) }; }
     }
-    await updateRecord(root, record.provider, record.session, async current => {
+    await updateRecordAfterControl(root, record.provider, record.session, async current => {
       const live = current?.run;
       if (live?.managed?.resumeLease?.id !== leaseId) return current;
       delete live.managed.resumeLease;
@@ -526,3 +541,17 @@ export function createManagedSupervisor(options) {
     async close() { closed = true; controller.abort(); await Promise.allSettled([running, auditing]); },
   };
 }
+
+
+// Stop/pause can wake the owned turn before its control transaction releases
+// the record lock. Retry only acquisition conflicts; never steal a live lock.
+async function updateRecordAfterControl(root, provider, session, mutate) {
+  const until = Date.now() + 5000;
+  while (true) {
+    try { return await updateRecord(root, provider, session, mutate); }
+    catch (error) {
+      if (error.message !== 'Delivery state is busy; retry the command.' || Date.now() >= until) throw error;
+      await new Promise(resolve => setTimeout(resolve, 25));
+    }
+  }
+}

package/src/desktop-host.js

@@ -1,3 +1,9 @@
+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';
 import { PROVIDER_LINKS, readProviderLinks, writeProviderLink, requireProviderLink } from "./provider-links.js";
 import { randomUUID } from "node:crypto";
@@ -11,7 +17,7 @@ import { stopDesktopWorkForUpdate } from './desktop-update-stop.js';
 import { desktopAccessReady, desktopActionAllowed, requireDesktopAccess, validDesktopAccessPath } from './desktop-access.js';
 import { createActionDeadlineService } from './session-supervision/action-deadline.js';
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
-import { controlDelivery, verifyDelivery, createRecordReader, updateRecord, TERMINAL } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
+import { controlDelivery, verifyDelivery, createRecordReader, updateRecord, recordProviderArchive, TERMINAL } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
 import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 import { createActionAssociationHost } from "./session-supervision/action-association-host.js";
 import { createStopNotifier } from "./session-supervision/stop-notifications.js";
@@ -101,7 +107,7 @@ function desktopActionError(action, error) {
   if (action === "session_deadline_decide") return error?.code === "conflict"
     ? "Deadline changed; refresh before deciding." : "The deadline is unavailable. Refresh this conversation before deciding.";
   if (typeof action === "string" && action.startsWith("session_")) {
-    return action.startsWith("session_action_") ? associationActionError(error) : sessionActionError(error);
+    return action.startsWith("session_action_") ? associationActionError(error) : sessionActionError(error, action);
   }
   if (["organization_select", "organization_cancel", "organizations_refresh"].includes(action)) {
     return error?.code === "desktop_organization_busy"
@@ -192,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;
@@ -411,6 +426,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     });
     unfinishedDesktopWork = false;
   })();
+  const observePullRequests = dependencies.observePullRequests || createPullRequestObserver();
   const refreshSessions = (force = false) => {
     if (discoveryStopped && !closed && !relay) return sessionStatus;
     if (closed || relay || !desktopAccessReady(currentAccess)) return { sessions: [], providers: {}, refreshedAt: null };
@@ -428,8 +444,12 @@ export async function startDesktopHost({ input = process.stdin, output = process
             sessionRefreshAgain = desktopAccessReady(latestAccess);
             return;
           }
-          const sessions = linkedSessions(value.sessions);
-          await analysisManager.update(analysisSessions(sessions));
+          const sessions = await observePullRequests(linkedSessions(value.sessions), { signal: controller.signal });
+          const afterObservation = await accessSnapshot();
+          if (controller.signal.aborted || !desktopAccessReady(afterObservation) || accessScope(afterObservation) !== requestedScope) {
+            await analysisManager.update([]); sessionRefreshAgain = desktopAccessReady(afterObservation); return;
+          }
+          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(); })
@@ -612,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);
@@ -626,7 +648,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       // Cached enrichment must follow the current connection preference even
       // while a full projection is waiting on records or remote metadata.
       status.deliveryHooks.runs = linkedSessions(status.deliveryHooks.runs || []);
-      status.sessionSupervision.sessions = linkedSessions(status.sessionSupervision.sessions || []);
+      status.sessionSupervision.sessions = linkedSessions(status.sessionSupervision.sessions || []).map(candidate => expireSessionWorkState(candidate)).sort(compareSessionWork);
       status.sessionSupervision.providers ||= {};
       for (const provider of PROVIDER_LINKS) {
         if (!providerLinks[provider].connected) status.sessionSupervision.providers[provider] = { discovery: 'disconnected', reason: null };
@@ -660,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();
@@ -702,9 +726,10 @@ 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]));
       const runsBySession = new Map((status.deliveryHooks.runs || []).map(run => [`${run.provider}:${run.session}`, run]));
       for (const session of sessions) {
         const key = `${session.provider}:${session.session}`;
@@ -727,8 +752,9 @@ 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: sessions.map(candidate => ({ ...candidate,
-        decisionRequest: sessionDecisionPresentation(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`)) })) };
+      status.sessionSupervision = { ...discovery, refreshing: Boolean(sessionRefresh), sessions: reconcileFamilyCompletion(sessions.map(candidate => ({ ...candidate,
+        decisionRequest: sessionDecisionPresentation(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`)),
+        workState: sessionWorkState(candidate, runsBySession.get(`${candidate.provider}:${candidate.session}`) || stateRunsBySession.get(`${candidate.provider}:${candidate.session}`), { provider: discovery.providers?.[candidate.provider] }) }))).sort(compareSessionWork) };
       const latestAccess = await accessSnapshot();
       if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks ||
         !desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope ||
@@ -782,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) {
@@ -794,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,
@@ -803,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;
@@ -817,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;
         }
@@ -860,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); }
             }
@@ -870,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);
@@ -883,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);
     };
@@ -990,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;
@@ -1005,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.');
@@ -1039,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;
@@ -1046,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)) {
@@ -1128,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);
@@ -1339,6 +1394,25 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await authorizeWork(commandScope);
           const result = await deadlines.decide(context, { ...command, requestId: command.requestId || command.decisionId });
           if (result.status === 'conflict') throw Object.assign(new Error('Deadline changed; refresh before deciding.'), { code: 'conflict' });
+        } else if (action === "session_archive" || action === "session_restore") {
+          const candidate = await selectedSession(command, { preferObserved: true });
+          await authorizeWork(commandScope);
+          if (!['local', 'provider'].includes(command.scope)) throw new Error('Choose local or provider archive explicitly.');
+          const archived = action === 'session_archive';
+          if (command.scope === 'provider') {
+            if (command.provider !== 'codex') throw new Error('Archive or restore this conversation in Claude, then refresh SIMY.');
+            const client = await (dependencies.openCodexAppServer || openCodexAppServer)();
+            try { await client.request(archived ? 'thread/archive' : 'thread/unarchive', { threadId: command.session });
+              if (archived) await recordProviderArchive(deliveryRoot, command.provider, command.session, true, Date.now());
+            }
+            finally { await client.close(); }
+          } else {
+            await updateRecord(deliveryRoot, command.provider, command.session, previous => ({
+              ...(previous || { schemaVersion: 1, provider: command.provider, session: command.session, cwd: candidate.cwd, observedAt: Date.now() }),
+              listHidden: archived,
+            }));
+          }
+          refreshSessions(true);
         } else if (action === "session_track" || action === "session_untrack") {
           const candidate = await selectedSession(command);
           if (candidate.capabilities?.canMonitor !== true) throw new Error('Tracking is unavailable for this conversation.');
@@ -1439,7 +1513,7 @@ function associationActionError(error) {
   return 'The Action service is unavailable. Your conversation continues with its existing settings.';
 }
 
-function sessionActionError(error) {
+function sessionActionError(error, action) {
   if (error instanceof AutoContinueUnavailableError) return error.message.replace(/[\r\n\x00-\x1f]/g, ' ').slice(0, 600);
   const message = String(error?.message || "");
   if (/already has a Delivery Loop|budgets cannot be reset/i.test(message)) return "This conversation already has a task. Open its existing supervision instead.";
@@ -1447,6 +1521,7 @@ function sessionActionError(error) {
   if (/workspace changed|metadata.*unavailable|session.*changed/i.test(message)) return "The conversation identity or workspace changed. Refresh and select it again.";
   if (/objective|acceptance|autonomy policy|budget/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);
   if (/question changed|answer is empty|session understanding|context/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);
+  if (action === "session_answer") return "Answer acceptance is unconfirmed. Check the original conversation before sending again.";
   return "This conversation could not be enrolled. Refresh its provider status and try again.";
 }
 

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;
+}