@awak-app/simy-cli 0.5.42 → 0.5.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.42",
+  "version": "0.5.44",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -37,12 +37,12 @@
     "test:e2e:console:real-provider": "node ./scripts/real-provider-console-e2e.js",
     "test:e2e:console:fullstack": "node ./scripts/fullstack-cli-smoke.js",
     "check": "npm run check:auto-update && node --check ./src/desktop-executor.js && node --check ./src/local-task.js && node --check ./scripts/desktop-executor-e2e.js && node --check ./scripts/pre-guardrail-e2e.js && node --check ./scripts/fixtures/fake-desktop-provider.js && npm run check:syntax && npm run check:session-supervision-syntax && npm run check:real-provider-syntax && npm test && npm run check:package",
-    "check:session-supervision-syntax": "node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs",
+    "check:session-supervision-syntax": "node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs",
     "check:auto-update": "node --check ./src/auto-update.js && node --check ./scripts/auto-update-e2e.js && npm run check:sqm",
     "check:workflow-observation-sender": "node --check ./src/workflow-observation-sender.js",
     "check:sqm": "node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",
     "check:real-provider-syntax": "node --check ./scripts/real-codex-probe.js && node --check ./scripts/real-claude-probe.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/claude-parity-runtime-e2e.js && node --check ./scripts/claude-plugin-runtime-e2e.js",
-    "check:syntax": "node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/connection-discovery.js && node --check ./src/codex-plugins/simy/hooks/connection-reminder.mjs && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/pr-preparation.js && node --check ./src/orchestrator/minimum-completion.js && node --check ./src/orchestrator/delivery/scripts/check-minimum-completion.mjs && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./src/coding-run-store.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js && node --check ./src/codex-plugins/simy/hooks/delivery-loop.mjs && node --check ./src/delivery-hooks/command.js && node --check ./src/delivery-hooks/desktop.js && node --check ./src/delivery-hooks/supervisor.js",
+    "check:syntax": "node --check ./src/index.js && node --check ./src/install-update.js && node --check ./src/agent.js && node --check ./src/connection-discovery.js && node --check ./src/codex-plugins/simy/hooks/connection-reminder.mjs && node --check ./src/browser.js && node --check ./src/web-api.js && node --check ./src/durable-local-task-worker.js && node --check ./src/durable-local-task-steps-contract.js && node --check ./src/bounded-local-task-subtasks-contract.js && node --check ./src/bounded-local-task-subtask-pool.js && node --check ./src/local-task-artifact-contract.js && node --check ./src/execution-capability-contract.js && node --check ./src/shutdown.js && node --check ./src/run-registry.js && node --check ./src/direct-executor.js && node --check ./src/execution-guardrail.js && node --check ./src/backend-executable.js && node --check ./src/provider-stream.js && node --check ./src/console/index.js && node --check ./src/console/app.js && node --check ./src/console/commands.js && node --check ./src/local-attachments.js && node --check ./src/repository-inventory.js && node --check ./src/session-store.js && node --check ./src/web-origin.js && node --check ./src/workspace-context.js && node --check ./src/orchestrator/index.js && node --check ./src/orchestrator/shared.js && node --check ./src/orchestrator/recovery.js && node --check ./src/orchestrator/risk.js && node --check ./src/orchestrator/contract.js && node --check ./src/orchestrator/completion-contract.js && node --check ./src/orchestrator/pr-preparation.js && node --check ./src/orchestrator/minimum-completion.js && node --check ./src/orchestrator/delivery/scripts/check-minimum-completion.mjs && node --check ./src/orchestrator/instruction.js && node --check ./src/orchestrator/problem-solving.js && node --check ./src/orchestrator/budget.js && node --check ./src/orchestrator/execution-io.js && node --check ./src/orchestrator/presentation.js && node --check ./src/orchestrator/result.js && node --check ./src/orchestrator/retry.js && node --check ./src/orchestrator/evidence.js && node --check ./src/orchestrator/independent-audit.js && node --check ./src/orchestrator/audit.js && node --check ./src/orchestrator/loop.js && node --check ./src/runner.js && node --check ./src/coding-run-store.js && node --check ./scripts/fixtures/completion-contract-fixture.js && node --check ./scripts/fixtures/fake-coding-backend.js && node --check ./scripts/e2e-terminal-evidence.js && node --check ./scripts/audit-gate-e2e.js && node --check ./scripts/completion-contract-e2e.js && node --check ./scripts/retry-circuit-e2e.js && node --check ./scripts/follow-up-charter-e2e.js && node --check ./scripts/task-routing-e2e.js && node --check ./scripts/executor-version-preflight-e2e.js && node --check ./scripts/blocked-recovery-e2e.js && node --check ./scripts/process-localization-e2e.js && node --check ./scripts/hypothesis-retries-e2e.js && node --check ./scripts/budget-enforcement-e2e.js && node --check ./scripts/local-task-default-workspace-e2e.js && node --check ./scripts/local-task-idempotency-e2e.js && node --check ./scripts/console-e2e-fixture.js && node --check ./scripts/console-e2e.js && node --check ./scripts/console-recovery-e2e-fixture.js && node --check ./scripts/console-recovery-e2e.js && node --check ./scripts/real-provider-console-fixture.js && node --check ./scripts/real-provider-console-e2e.js && node --check ./scripts/fullstack-cli-smoke.js && node --check ./scripts/check-package-contents.js && node --check ./src/codex-plugins/simy/hooks/delivery-loop.mjs && node --check ./src/delivery-hooks/command.js && node --check ./src/delivery-hooks/desktop.js && node --check ./src/delivery-hooks/supervisor.js && node --check ./src/session-supervision/automatic-continuation.js",
     "check:package": "node ./scripts/check-package-contents.js",
     "build:macos-installer:dev": "bash packaging/build-macos-arm64.sh --unsigned-dev",
     "build:macos-installer": "bash packaging/build-macos-arm64.sh --production",

package/src/agent.js

@@ -27,6 +27,7 @@ import {
 } from "./runner.js";
 import { codingRunsRoot, loadCodingRunSnapshots, saveCodingRunSnapshot } from "./coding-run-store.js";
 import {
+  defaultSessionRoot,
   expiresAtFromNow,
   isSessionValid,
   readSession,
@@ -177,6 +178,9 @@ export async function startAgent({
     install: (options) => installSqmAgentSkill({ home: dependencies.home, ...options }),
   };
   let session = await readSession(apiOrigin, sessionRoot);
+  // The last session the Web stopped accepting. A fresh sign-in may continue
+  // as its device (see /v1/auth/complete), so keep it after it is cleared.
+  let reclaimableSession = null;
   if (session && sessionRequiresWebAuthorization(session, apiOrigin)) session = null;
   await cleanupExpiredRuns();
   for (const task of await restoreLocalTasks({ root: taskStorageRoot })) {
@@ -215,6 +219,7 @@ export async function startAgent({
   };
   refreshAvailableCapabilities();
   const heartbeatDevice = dependencies.heartbeatDevice || heartbeatLocalDevice;
+  const reclaimDevice = dependencies.reclaimDevice || reclaimLocalDevice;
   const runOptions = dependencies.runOptions || {};
   const repositoryScanRoot = resolve(
     String(
@@ -258,6 +263,10 @@ export async function startAgent({
       if (dependencies.codexWorkPatternSync) {
         codexWorkPatternSync = dependencies.codexWorkPatternSync;
       } else {
+        // Callers usually leave sessionRoot unset and rely on the session-store
+        // default (SIMY_HOME or ~/.simy); the sync needs that concrete root for
+        // its cursor, otherwise it reports not_connected forever.
+        const syncRoot = sessionRoot ?? defaultSessionRoot();
         const homes = workPatternHistoryHomes({
           codexHome: dependencies.codexHome,
           claudeHome: dependencies.claudeHome,
@@ -265,10 +274,10 @@ export async function startAgent({
         reportCodexWorkPatternSyncStatus(
           `reading history roots CODEX_HOME=${homes.codexHome} `
             + `(sessions/, archived_sessions/) and CLAUDE_CONFIG_DIR=${homes.claudeHome} (projects/); `
-            + `state under ${sessionRoot}.`,
+            + `state under ${syncRoot}.`,
           quiet,
         );
-        codexWorkPatternSync = createCodexWorkPatternSync({ sessionRoot, ...homes });
+        codexWorkPatternSync = createCodexWorkPatternSync({ sessionRoot: syncRoot, ...homes });
       }
     }
     let syncPromise;
@@ -559,6 +568,7 @@ export async function startAgent({
           const state = connectionStatus.failure(error);
           notifyDesktopStatusChange();
           if (state === "unauthorized") {
+            if (session?.device_id && session.token) reclaimableSession = session;
             session = null;
             loginUrl = null;
             refreshAvailableCapabilities();
@@ -933,6 +943,8 @@ export async function startAgent({
           });
           return;
         }
+        const previousSession = session ?? reclaimableSession;
+        reclaimableSession = null;
         session = {
           token: String(body.token || ""),
           device_id: typeof body.device_id === "string" ? body.device_id : null,
@@ -950,6 +962,37 @@ export async function startAgent({
             : null,
           expires_at: typeof body.expires_at === "string" ? body.expires_at : expiresAtFromNow(),
         };
+        // A fresh sign-in issues a new device. Keep running as the device used
+        // before (its desktop WorkFlow evidence stays resumable) when this agent
+        // still holds that device's token. Otherwise continue as the new device.
+        if (
+          previousSession?.device_id &&
+          previousSession.token &&
+          session.device_id &&
+          previousSession.device_id !== session.device_id &&
+          previousSession.api_origin &&
+          previousApiBaseUrl(previousSession) === session.api_base_url
+        ) {
+          try {
+            const reclaimed = await reclaimDevice({
+              apiOrigin,
+              apiBaseUrl: session.api_base_url,
+              token: session.token,
+              previousDeviceId: previousSession.device_id,
+              previousToken: previousSession.token,
+            });
+            if (reclaimed?.device_id === previousSession.device_id) {
+              session.device_id = reclaimed.device_id;
+              if (typeof reclaimed.expires_at === "string") session.expires_at = reclaimed.expires_at;
+            }
+          } catch (error) {
+            if (!quiet) {
+              console.error(
+                `SIMY could not continue as the previous device: ${error instanceof Error ? error.message : String(error)}`,
+              );
+            }
+          }
+        }
         await writeSession(apiOrigin, session, sessionRoot);
         startHeartbeatTimer();
         loginUrl = null;
@@ -2212,6 +2255,54 @@ export async function heartbeatLocalDevice({
   }
 }
 
+// The previous token is only ever presented to the Web API it was issued by.
+function previousApiBaseUrl(previousSession) {
+  try {
+    return resolveWebApiBaseUrl(previousSession.api_origin, previousSession.api_base_url);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Moves a fresh sign-in onto the device this agent used before. Returns the
+ * receipt, or null when the Web refuses the reclaim (the fresh device stays).
+ */
+export async function reclaimLocalDevice({
+  apiOrigin,
+  apiBaseUrl,
+  token,
+  previousDeviceId,
+  previousToken,
+}) {
+  const response = await fetch(
+    webApiUrl("devices/reclaim", { webOrigin: apiOrigin, apiBaseUrl }),
+    {
+      method: "POST",
+      headers: webApiHeaders(
+        { token },
+        { "Content-Type": "application/json" },
+      ),
+      body: JSON.stringify({
+        previous_device_id: previousDeviceId,
+        previous_token: previousToken,
+      }),
+      signal: AbortSignal.timeout(5_000),
+    },
+  );
+  if (response.status === 409) return null;
+  if (!response.ok) {
+    const payload = await response.json().catch(() => null);
+    const error = new Error(webApiErrorMessage(payload, response.status));
+    error.status = response.status;
+    throw error;
+  }
+  const payload = await response.json();
+  return payload && typeof payload.device_id === "string"
+    ? { device_id: payload.device_id, expires_at: payload.expires_at }
+    : null;
+}
+
 function reportHeartbeatError(error, quiet) {
   if (quiet) return;
   console.error(

package/src/cli-contract.js

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

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

@@ -340,10 +340,11 @@ function managedSpec(spec, session, provider, observedProcess, admission, now) {
   return managed;
 }
 export async function startDelivery({ root = rootDirectory(), provider, session, cwd = process.cwd(), objective, nextStep, maxContinuations, maxFailures, maxMinutes, managed, admission,
-  liveHookAdmission, inspectProcess = processIdentity, now = Date.now() }) {
+  liveHookAdmission, autoContinueEpoch, inspectProcess = processIdentity, now = Date.now() }) {
   cwd = await realpath(cwd);
   if (!text(objective) || !text(nextStep)) throw new Error('Objective and concrete next step are required.');
   return updateRecord(root, provider, session, async previous => {
+    if (autoContinueEpoch && (previous?.autoContinue !== true || previous.autoContinueEpoch !== autoContinueEpoch)) throw new Error('Automatic continuation was disabled before enrollment.');
     const admitted = admission?.source === 'codex_app_server' && admission.provider === provider && admission.session === session && admission.cwd === cwd && previous?.admission?.source === admission.source && previous.admission.session === session && previous.cwd === cwd;
     if (liveHookAdmission) {
       const process = previous?.process;
@@ -355,6 +356,11 @@ export async function startDelivery({ root = rootDirectory(), provider, session,
     if ((!previous?.observedAt && !admitted) || previous.cwd !== cwd) throw new Error('No matching verified provider session observed here. Select an exact discovered session or enable SIMY hooks.');
     if (previous.run) throw new Error('This session already has a Delivery Loop. Resume or stop it; budgets cannot be reset by starting again.');
     const managedState = managedSpec(managed, session, provider, previous.process, admitted ? admission : null, now);
+    if (autoContinueEpoch && managedState) managedState.autoContinueEpoch = autoContinueEpoch;
+    if (managedState && previous.associationTaskId) {
+      managedState.taskId = previous.associationTaskId;
+      if (previous.actionAssociation) managedState.actionAssociation = structuredClone(previous.actionAssociation);
+    }
     if (liveHookAdmission && managedState) managedState.liveHookOwner = { pid: liveHookAdmission.pid,
       identity: liveHookAdmission.identity, hookStartedAt: liveHookAdmission.hookStartedAt };
     const waiting = managedState?.decision?.outcome === 'wait';
@@ -653,6 +659,12 @@ export function managedBudgetReason(run, now = Date.now()) {
   if (managed && managed.noProgress >= managed.maxNoProgress) return 'No verified acceptance progress within the configured continuation limit.';
   return null;
 }
+// Manual/legacy runs have no marker and retain their existing controls.
+export function automaticContinuationAllowed(record) {
+  const epoch = record?.run?.managed?.autoContinueEpoch;
+  return !epoch || record.autoContinue === true && record.autoContinueEpoch === epoch;
+}
+
 export function decideStop(run, now = Date.now()) {
   if (TERMINAL.has(run.state) || ['blocked', 'recovery_required', 'paused', 'verification_pending'].includes(run.state)) return { run, output: {} };
   const next = structuredClone(run);
@@ -826,6 +838,9 @@ export async function handleHook({ input, provider, root = rootDirectory(), now
       run.reason = RETRYABLE.has(input.error) ? 'Transient provider error. Resume the existing conversation after the provider recovers.' : 'Provider error requires attention before resuming.';
       run.errorCode = text(input.error, 100); run.retryable = RETRYABLE.has(input.error);
     } else if (event === 'Stop') {
+      // OFF suppresses future Stop blocking; it never interrupts the provider
+      // turn. Lease settlement and runtime observation above still run.
+      if (!automaticContinuationAllowed(record)) return record;
       // Codex turn IDs make re-delivered Stop events idempotent. Claude has no
       // stable event ID; never dedupe on text (identical text can be a new turn).
       const key = input.turn_id ? `${input.turn_id}:${Boolean(input.stop_hook_active)}:${run.revision}` : null;

package/src/delivery-hooks/supervisor.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
-import { assessedCheckpointContract, checkpointDelivery, decideStop, listRecords, managedBudgetReason, notifyState, processIdentity, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { automaticContinuationAllowed, assessedCheckpointContract, checkpointDelivery, decideStop, listRecords, managedBudgetReason, notifyState, processIdentity, 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';
@@ -25,6 +25,7 @@ async function assertActiveLease(root, provider, session, leaseId, signal, curre
     throw new Error('Managed recovery lease changed before provider dispatch.');
   }
   if (currentTime() >= current.run.deadline) throw new Error('Managed recovery deadline expired before provider dispatch.');
+  if (!automaticContinuationAllowed(current)) throw new Error('Automatic continuation was disabled before provider dispatch.');
   if (managedBudgetReason(current.run, currentTime())) throw new Error('Managed progress budget expired before provider dispatch.');
   const managed = current.run.managed;
   const approvedWait = managed.decision?.outcome === 'wait' && managed.approvedAction?.id === managed.decision.id && !managed.approvedAction.dispatchedAt;
@@ -143,6 +144,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       });
       continue;
     }
+    if (!automaticContinuationAllowed(record)) continue;
     const appServer = run.managed.resumeChannel === 'codex_app_server';
     const causeAllowed = run.recoveryCause === 'process_exit' || appServer && ['session_supervision', 'approved_action'].includes(run.recoveryCause);
     const approvedWait = run.managed.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test'].includes(run.managed.decision.action?.kind) &&
@@ -162,6 +164,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     let claimed;
     try { claimed = await updateRecord(root, record.provider, record.session, current => {
       const live = current?.run;
+      if (!automaticContinuationAllowed(current)) return current;
       const appChannel = live?.managed?.resumeChannel === 'codex_app_server';
       const allowedCause = live?.recoveryCause === 'process_exit' || appChannel && ['session_supervision', 'approved_action'].includes(live?.recoveryCause);
       const approved = live?.managed?.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test'].includes(live.managed.decision.action?.kind) &&
@@ -248,6 +251,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
             await updateRecord(root, record.provider, record.session, current => {
               const live = current?.run;
               if (live?.state !== 'auto_resuming' || live.managed?.resumeLease?.id !== leaseId) throw new Error('Managed recovery lease changed before provider dispatch.');
+              if (!automaticContinuationAllowed(current)) throw new Error('Automatic continuation was disabled before provider dispatch.');
               if (appServer && !live.managed.providerSandbox) {
                 if (!providerSandbox || !['readOnly', 'workspaceWrite', 'dangerFullAccess', 'externalSandbox'].includes(providerSandbox.type)) throw new Error('Original Codex sandbox policy is unavailable.');
                 live.managed.providerSandbox = { type: providerSandbox.type,

package/src/desktop-host.js

@@ -1,10 +1,12 @@
+import { createActionDeadlineService } from './session-supervision/action-deadline.js';
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
 import { controlDelivery, verifyDelivery } 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 { answerSession, continueSession, discoverSessions, enrollSession, monitorSession, trackSession } from "./session-supervision/index.js";
+import { answerSession, continueSession, discoverSessions, enrollSession, monitorSession, trackSession, setSessionAutoContinue } from "./session-supervision/index.js";
 import { createContinuationAnalysisManager } from "./session-supervision/analysis-manager.js";
 import { readContinuationContext } from "./session-supervision/continuation-analysis.js";
+import { continueAnalyzedSession, createAutomaticContinuation } from "./session-supervision/automatic-continuation.js";
 import { createWindowsDesktopUpdater } from "./windows-desktop-updater.js";
 import { spawn, execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -46,9 +48,10 @@ export async function startDesktopHost({ input = process.stdin, output = process
   }
   const lock = candidate ? null : await acquireDesktopProcessLock(root, { webOrigin });
   const supervisorToken = lock?.nonce || env.SIMY_DESKTOP_SUPERVISOR_TOKEN;
-  let agent, updater, analysisManager, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null, publishAgain = false;
-  const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin });
+  let agent, updater, analysisManager, automaticContinuation, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null, publishAgain = false;
+  const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin, onChange: () => { if (!closed) setImmediate(() => { void publish().catch(() => {}); }); } });
   let actionAssociations = makeActionAssociations();
+  const deadlines = createActionDeadlineService({ root: join(root, "action-deadlines") });
   const managedSupervisor = (dependencies.createManagedSupervisor || createManagedSupervisor)({ root: join(root, "delivery-hooks"),
     beforeClaim: record => actionAssociations.prepareCached?.(record) || record });
   let shuttingDown = null;
@@ -75,6 +78,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
     if (!candidate) throw new Error('This conversation is unavailable; refresh its provider.');
     return candidate;
   };
+  const makeAutomaticContinuation = () => createAutomaticContinuation({ root: join(root, 'delivery-hooks'),
+    getManager: () => analysisManager, selectCandidate: selectedSession,
+    readSetting: dependencies.readSessionAutoContinue,
+    readContext: dependencies.readContinuationContext || readContinuationContext,
+    enroll: dependencies.continueSession || continueSession,
+    onChange: () => { if (!closed && !relay) refreshSessions(true); },
+  });
   let pluginSetup = { state: "unknown" };
   const inspectPlugins = dependencies.inspectPlugins || inspectSqmAgentSkill;
   const refreshPlugins = async () => {
@@ -96,7 +106,17 @@ export async function startDesktopHost({ input = process.stdin, output = process
       status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: join(root, "delivery-hooks") }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
       await actionAssociations.decorate(status.deliveryHooks);
       const discovery = refreshSessions();
-      status.sessionSupervision = { ...discovery, sessions: discovery.sessions.map(candidate => analysisManager.project(candidate)) };
+      automaticContinuation?.tick(discovery.sessions);
+      const sessions = discovery.sessions.map(candidate => automaticContinuation.project(analysisManager.project(candidate)));
+      await actionAssociations.decorateSessions?.(sessions);
+      for (const session of sessions) {
+        const context = await actionAssociations.deadlineContext?.(session);
+        if (context) session.actionDeadline = await deadlines.reconcile(context);
+        else session.actionDeadline = { status: 'unavailable', online: false, reminder: null };
+        const run = status.deliveryHooks.runs?.find(item => item.provider === session.provider && item.session === session.session);
+        if (run) run.actionDeadline = session.actionDeadline;
+      }
+      status.sessionSupervision = { ...discovery, sessions };
       if (!closed && !relay) emit({ type: "status", status });
     }).finally(() => { publishing = null; if (publishAgain && !closed) { publishAgain = false; setImmediate(() => { void publish().catch(() => {}); }); } });
     return publishing;
@@ -104,6 +124,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   const stopAgent = async () => {
     clearInterval(timer);
     await actionAssociations.close();
+    await automaticContinuation?.close();
     await analysisManager?.close();
     await managedSupervisor.close();
     await stopWorkflows();
@@ -126,6 +147,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
 
   try {
     analysisManager = await makeAnalysisManager();
+    automaticContinuation = makeAutomaticContinuation();
     if (!candidate) {
       await (dependencies.assertNoLegacyDaemon || assertNoLegacyCliDaemon)(webOrigin);
     }
@@ -148,6 +170,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       if (!installation?.entryPath || !installation?.executablePath) throw new Error("Signed update runtime is unavailable.");
       // The candidate shares this cache. Stop inference before it starts so a
       // signed handoff cannot create two analysis writers or duplicate calls.
+      await automaticContinuation.close();
       await analysisManager.close();
       // The candidate also shares association records and their sync outbox.
       // Drain the old writer before starting its replacement.
@@ -159,7 +182,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           env: { ...env, SIMY_DESKTOP_SUPERVISOR_TOKEN: supervisorToken },
         }); } catch (error) {
           actionAssociations = makeActionAssociations();
-          analysisManager = await makeAnalysisManager(); refreshSessions(true); throw error;
+          analysisManager = await makeAnalysisManager(); automaticContinuation = makeAutomaticContinuation(); refreshSessions(true); throw error;
         }
       const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
       let accepted = false;
@@ -204,7 +227,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         lines.close(); await stopUpdateCandidate(child);
         if (!closed && !relay) {
           actionAssociations = makeActionAssociations();
-          analysisManager = await makeAnalysisManager(); refreshSessions(true);
+          analysisManager = await makeAnalysisManager(); automaticContinuation = makeAutomaticContinuation(); refreshSessions(true);
         }
         throw error;
       }
@@ -289,7 +312,33 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await verifyDelivery({ root: join(root, "delivery-hooks"), provider: command.provider, session: command.session,
             taskId: command.taskId, criterionId: command.criterionId });
         } else if (["session_action_select", "session_action_unlink", "session_action_refresh"].includes(action)) {
-          await actionAssociations.correct(command);
+          const candidate = await selectedSession(command);
+          await actionAssociations.correct(command, analysisManager.project(candidate));
+        } else if (action === "session_set_auto_continue") {
+          if (typeof command.enabled !== 'boolean') throw new Error('Choose whether automatic continuation is enabled.');
+          if (command.enabled) {
+            const candidate = await selectedSession(command);
+            if (candidate.capabilities?.canAutoContinue !== true) throw new Error('Automatic continuation is unavailable for this conversation.');
+          }
+          await (dependencies.setSessionAutoContinue || setSessionAutoContinue)({ root: join(root, 'delivery-hooks'),
+            provider: command.provider, session: command.session, enabled: command.enabled });
+          if (!command.enabled) automaticContinuation.revoke(command.provider, command.session);
+          refreshSessions(true);
+          if (command.enabled) {
+            const fresh = await selectedSession(command);
+            if (fresh.capabilities?.canAnalyze === true) await analysisManager.request(fresh);
+          }
+        } else if (action === "session_deadline_decide") {
+          if (command.cancel === true) { emit({ type: "result", id: command.id, ok: true }); return; }
+          const candidate = await selectedSession(command);
+          await actionAssociations.correct({ ...command, action: 'session_action_refresh' }, analysisManager.project(candidate));
+          const projected = analysisManager.project(candidate);
+          await actionAssociations.decorateSessions?.([projected]);
+          const context = await actionAssociations.deadlineContext?.(projected);
+          if (!context || context.taskId !== command.taskId) throw new Error('Refresh this conversation before deciding its deadline.');
+          await deadlines.reconcile(context);
+          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_track" || action === "session_untrack") {
           const candidate = await selectedSession(command);
           if (candidate.capabilities?.canMonitor !== true) throw new Error('Tracking is unavailable for this conversation.');
@@ -307,25 +356,18 @@ export async function startDesktopHost({ input = process.stdin, output = process
             maxContinuations: command.maxContinuations, maxFailures: command.maxFailures, maxNoProgressMinutes: command.maxNoProgressMinutes, maxTokens: command.maxTokens });
           await refreshSessions(true);
         } else if (action === "session_analyze") {
-          await analysisManager.request(await selectedSession(command));
+          const candidate = await selectedSession(command);
+          await analysisManager.request(candidate);
+          if (candidate.autoContinue === true && candidate.capabilities?.canContinue === true) automaticContinuation.retry(candidate.provider, candidate.session);
         } else if (action === "session_continue") {
           const candidate = await selectedSession(command);
           const manager = analysisManager;
-          const recommendation = manager.requireRecommendation(candidate);
-          if (candidate.capabilities?.canContinue !== true) throw new Error('Automatic continuation is unavailable for this conversation.');
-          const context = await (dependencies.readContinuationContext || readContinuationContext)(candidate);
-          // Provider activity timestamps can have one-second precision. Re-read
-          // the bounded context before enrollment to reject same-second edits.
-          if (context.awaitingTurn || context.incomplete || !recommendation.contextDigest || context.contextDigest !== recommendation.contextDigest) {
-            await manager.invalidate(candidate);
-            throw new Error('This conversation changed; wait for its updated analysis.');
-          }
-          // Reading provider context can overlap an update handoff. The old
-          // manager must still be active before task enrollment is dispatched.
-          manager.requireRecommendation(candidate);
-          await (dependencies.continueSession || continueSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
-            session: command.session, autonomyPolicy: command.autonomyPolicy, maxMinutes: command.maxMinutes,
-            maxContinuations: command.maxContinuations, maxFailures: command.maxFailures, maxNoProgressMinutes: command.maxNoProgressMinutes, maxTokens: command.maxTokens });
+          await continueAnalyzedSession({ root: join(root, 'delivery-hooks'), candidate, manager,
+            readContext: dependencies.readContinuationContext || readContinuationContext,
+            enroll: dependencies.continueSession || continueSession,
+            settings: { autonomyPolicy: command.autonomyPolicy, maxMinutes: command.maxMinutes,
+              maxContinuations: command.maxContinuations, maxFailures: command.maxFailures,
+              maxNoProgressMinutes: command.maxNoProgressMinutes, maxTokens: command.maxTokens } });
           await refreshSessions(true);
         } else if (action === "session_answer") {
           await (dependencies.answerSession || answerSession)({ root: join(root, "delivery-hooks"), provider: command.provider,

package/src/session-store.js

@@ -43,7 +43,7 @@ export async function writeSession(webOrigin, session, sessionRoot = defaultSess
   });
 }
 
-function defaultSessionRoot() {
+export function defaultSessionRoot() {
   return process.env.SIMY_HOME?.trim() || join(homedir(), ".simy");
 }
 

package/src/session-supervision/action-association-host.js

@@ -1,3 +1,4 @@
+import { createOrdinaryAssociationStore } from './association-store.js';
 import { listRecords, updateRecord, TERMINAL, managedBudgetReason } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { createActionAssociationApi, ActionAssociationApiError } from './action-association-api.js';
 import { actionCandidateRequest, prepareActionAssociation, importActionBinding,
@@ -14,8 +15,9 @@ const hardFailure = code => ['unauthorized', 'unavailable', 'invalid_request', '
 // Association is optional metadata. Network failures never control the task's
 // work state; provider turns and their budgets remain owned by the supervisor.
 export function createActionAssociationHost({ root, sessionRoot, webOrigin, api = createActionAssociationApi({ webOrigin, sessionRoot }),
-  now = Date.now, refreshMs = 60_000, list = listRecords } = {}) {
+  now = Date.now, refreshMs = 60_000, list = listRecords, onChange = () => {} } = {}) {
   const abort = new AbortController(), views = new Map();
+  const ordinary = createOrdinaryAssociationStore({ root, api, webOrigin, now, onChange });
   let auth = null, closed = false, running = null, serial = Promise.resolve();
   const enqueue = work => {
     const result = serial.then(work); serial = result.catch(() => {}); return result;
@@ -144,6 +146,34 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
     }));
   }
   return {
+    async decorateSessions(sessions) {
+      await ordinary.decorate(sessions);
+      const records = await list(root);
+      const status = { runs: sessions.filter(item => records.some(record => record.provider === item.provider && record.session === item.session && record.run?.managed)).map(item => {
+        const record = records.find(record => record.provider === item.provider && record.session === item.session);
+        return { managed: true, taskId: record.run.managed.taskId, actionAssociation: record.run.managed.actionAssociation, candidate: item };
+      }) };
+      await this.decorate(status);
+      for (const run of status.runs) run.candidate.actionAssociation = run.actionAssociation;
+      return sessions;
+    },
+    async deadlineContext(candidate) {
+      const expected = await current(), record = (await list(root)).find(item => item.provider === candidate.provider && item.session === candidate.session);
+      const local = record?.run?.managed?.actionAssociation || record?.actionAssociation;
+      if (!expected || local?.authRevision !== expected || !candidate.actionAssociation?.canCorrect) return null;
+      const binding = candidate.actionAssociation.binding;
+      const fingerprint = value => JSON.stringify([value?.revision, value?.action?.id, value?.action?.revision, value?.action?.dueAt, value?.action?.timeZone, value?.action?.status]);
+      return { namespace: local.namespace, provider: candidate.provider, session: candidate.session, taskId: candidate.taskId, binding,
+        taskStatus: null, remainingWork: record.run?.managed?.sessionUnderstanding?.remaining || record.run?.managed?.remainingWork || candidate.analysis?.remaining || candidate.analysis?.remainingWork || null,
+        plan: record.run?.managed?.plan || candidate.analysis?.plan || null, blocker: record.run?.blocker || candidate.analysis?.blocker || null, online: true,
+        validate: async () => {
+          if (!await valid(expected)) return false;
+          const latest = (await list(root)).find(item => item.provider === candidate.provider && item.session === candidate.session);
+          const scoped = latest?.run?.managed?.actionAssociation || latest?.actionAssociation;
+          return (latest?.run?.managed?.taskId || latest?.associationTaskId) === candidate.taskId && scoped?.namespace === local.namespace && scoped?.authRevision === expected && fingerprint(scoped.binding) === fingerprint(binding);
+        } };
+
+    },
     async prepareCached(record) {
       const view = views.get(record?.run?.managed?.taskId), request = actionCandidateRequest(record);
       if (closed || !auth || !view || view.auth !== auth || view.error || !view.snapshot || !request || view.contextRevision !== request.context.revision || view.snapshot.contextRevision !== request.context.revision || view.namespace !== namespaceFor(webOrigin, view.snapshot.scope)) return record;
@@ -170,7 +200,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
             status: view.error || local?.status || 'waiting_boundary',
             binding: view.namespace && local?.namespace === view.namespace ? publicBinding(local.binding) : null,
             candidates: (view.candidates || []).slice(0,5), canCorrect: !view.error,
-            retryOn: local?.retryOn || null, truncated: view.candidateTruncated || false,
+            contextRevision: view.contextRevision, candidateRevision: view.snapshot?.candidateRevision || null, retryOn: local?.retryOn || null, truncated: view.candidateTruncated || false,
           };
         let bytes = Buffer.byteLength(JSON.stringify(run.actionAssociation));
         if (bytes > Math.min(remainingBytes,perRunBytes)) { run.actionAssociation.candidates = []; run.actionAssociation.truncated = true; bytes = Buffer.byteLength(JSON.stringify(run.actionAssociation)); }
@@ -183,7 +213,8 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
       }
       return status;
     },
-    correct(command) {
+    correct(command, candidate) {
+      if (candidate && candidate.binding?.mode !== 'managed' && candidate.binding?.mode !== 'pending_takeover') return ordinary.correct(command, candidate);
       return enqueue(async () => {
         const expected = await current(), record = await fresh(command);
         if (!expected) throw new ActionAssociationApiError('signed_out');
@@ -192,9 +223,11 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
         const view = views.get(command.taskId);
         if (!await valid(expected) || !view?.namespace || view.error) throw new ActionAssociationApiError(view?.error || 'unavailable');
         if (command.action === 'session_action_refresh') { view.nextRefresh = 0; return; }
+        if (command.expectedContextRevision && command.expectedContextRevision !== view.contextRevision || command.expectedCandidateRevision && command.expectedCandidateRevision !== view.snapshot?.candidateRevision) throw new ActionAssociationApiError('conflict');
         const latest = await fresh(command), binding = latest?.run.managed.actionAssociation?.binding;
         if ((binding?.revision ?? null) !== command.expectedBindingRevision) throw new ActionAssociationApiError('conflict');
         const selected = command.action === 'session_action_select' ? view.snapshot?.candidates.find(item => item.id === command.actionId) || (!view.snapshot && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(command.actionId || '') ? { id: command.actionId, revision: null } : null) : null;
+        if (selected && command.expectedActionRevision && command.expectedActionRevision !== selected.revision) throw new ActionAssociationApiError('conflict');
         if (command.action !== 'session_action_unlink' && !selected) throw new ActionAssociationApiError('invalid_request');
         const envelope = await api.saveBinding(command.taskId, {
           expectedRevision: command.expectedBindingRevision, contextRevision: view.contextRevision,
@@ -208,6 +241,6 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
         view.error = null; view.nextRefresh = 0;
       });
     },
-    async close() { closed = true; abort.abort(); await Promise.allSettled([serial, running]); views.clear(); },
+    async close() { closed = true; abort.abort(); await Promise.allSettled([serial, running, ordinary.close()]); views.clear(); },
   };
 }

package/src/session-supervision/action-deadline-store.js

@@ -0,0 +1,57 @@
+import { mkdir, readFile, writeFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+
+// All instances in a host share a queue; every transaction reloads disk so a
+// newly created host sees durable decisions instead of an in-memory snapshot.
+const queues = new Map();
+export function createActionDeadlineStore({ root }) {
+  const directory = join(root, "action-deadlines");
+  const pathFor = (identity) =>
+    join(
+      directory,
+      `${createHash("sha256").update(JSON.stringify(identity)).digest("hex")}.json`,
+    );
+  const read = async (identity) => {
+    try {
+      return JSON.parse(await readFile(pathFor(identity), "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  };
+  return {
+    read,
+    transact(identity, update, validate = async () => true) {
+      const path = pathFor(identity);
+      const result = (queues.get(path) || Promise.resolve()).then(async () => {
+        const previous = await read(identity);
+        const assertCurrent = async () => {
+          if (!(await validate()))
+            throw Object.assign(new Error("Deadline context changed."), {
+              code: "conflict",
+            });
+        };
+        await assertCurrent();
+        const next = await update(previous);
+        if (next !== previous && next !== undefined) {
+          await mkdir(directory, { recursive: true, mode: 0o700 });
+          const temporary = `${path}.${randomUUID()}.tmp`;
+          await writeFile(temporary, JSON.stringify(next), { mode: 0o600 });
+          try {
+            await assertCurrent();
+            await rename(temporary, path);
+          } finally {
+            await rm(temporary, { force: true });
+          }
+        }
+        return next === undefined ? previous : next;
+      });
+      queues.set(
+        path,
+        result.catch(() => {}),
+      );
+      return result;
+    },
+  };
+}