@awak-app/simy-cli 0.5.41 → 0.5.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.41",
+  "version": "0.5.43",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -42,7 +42,7 @@
     "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.41";
+export const CLI_VERSION = "0.5.43";
 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,7 @@ 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 (liveHookAdmission && managedState) managedState.liveHookOwner = { pid: liveHookAdmission.pid,
       identity: liveHookAdmission.identity, hookStartedAt: liveHookAdmission.hookStartedAt };
     const waiting = managedState?.decision?.outcome === 'wait';
@@ -653,6 +655,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 +834,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

@@ -2,9 +2,10 @@ 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,7 +47,7 @@ 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;
+  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 });
   let actionAssociations = makeActionAssociations();
   const managedSupervisor = (dependencies.createManagedSupervisor || createManagedSupervisor)({ root: join(root, "delivery-hooks"),
@@ -75,6 +76,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 +104,8 @@ 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);
+      status.sessionSupervision = { ...discovery, sessions: discovery.sessions.map(candidate => automaticContinuation.project(analysisManager.project(candidate))) };
       if (!closed && !relay) emit({ type: "status", status });
     }).finally(() => { publishing = null; if (publishAgain && !closed) { publishAgain = false; setImmediate(() => { void publish().catch(() => {}); }); } });
     return publishing;
@@ -104,6 +113,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 +136,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 +159,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 +171,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 +216,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;
       }
@@ -290,6 +302,20 @@ export async function startDesktopHost({ input = process.stdin, output = process
             taskId: command.taskId, criterionId: command.criterionId });
         } else if (["session_action_select", "session_action_unlink", "session_action_refresh"].includes(action)) {
           await actionAssociations.correct(command);
+        } 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_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 +333,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/automatic-continuation.js

@@ -0,0 +1,81 @@
+import { continueSession, readSessionAutoContinue } from './index.js';
+import { readContinuationContext } from './continuation-analysis.js';
+
+// Shared by explicit Continue and automatic enrollment. Analysis alone never
+// dispatches work: the exact current provider context is checked again here.
+export async function continueAnalyzedSession({ candidate, manager, root, settings = {}, signal,
+  readContext = readContinuationContext, enroll = continueSession, beforeEnroll = () => {} }) {
+  const recommendation = manager.requireRecommendation(candidate);
+  if (candidate.isRunning || candidate.capabilities?.canContinue !== true) throw new Error('Automatic continuation is unavailable for this conversation.');
+  const context = await readContext(candidate, { signal });
+  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.');
+  }
+  manager.requireRecommendation(candidate);
+  await beforeEnroll();
+  if (signal?.aborted) throw new Error('Automatic continuation was cancelled before enrollment.');
+  return enroll({ root, provider: candidate.provider, session: candidate.session, ...settings });
+}
+
+// One pending enrollment per identity. A failed attempt is retried only after
+// context/opt-in changes; an existing (including terminal) run is never reset.
+export function createAutomaticContinuation({ root, getManager, selectCandidate,
+  readSetting = readSessionAutoContinue, readContext = readContinuationContext, enroll = continueSession,
+  onChange = () => {} }) {
+  const pending = new Map(), attempted = new Map(), errors = new Map();
+  let closed = false;
+  const tick = candidates => {
+    if (closed) return;
+    for (const candidate of candidates) {
+      if (pending.size >= 3) break;
+      if (candidate.autoContinue !== true || !candidate.autoContinueEpoch || candidate.isRunning ||
+          candidate.capabilities?.canAutoContinue !== true || candidate.capabilities?.canContinue !== true) continue;
+      const key = `${candidate.provider}:${candidate.session}`;
+      if (pending.has(key)) continue;
+      let recommendation;
+      const manager = getManager();
+      try { recommendation = manager.requireRecommendation(candidate); } catch { continue; }
+      const attempt = `${candidate.autoContinueEpoch}:${recommendation.contextDigest}`;
+      if (attempted.get(key) === attempt) continue;
+      attempted.set(key, attempt);
+      errors.delete(key);
+      const controller = new AbortController();
+      const guard = async () => {
+        const setting = await readSetting({ root, provider: candidate.provider, session: candidate.session });
+        if (closed || controller.signal.aborted || !setting.enabled || setting.epoch !== candidate.autoContinueEpoch || setting.hasRun) throw new Error('Automatic continuation was disabled or already enrolled.');
+        return setting;
+      };
+      const job = Promise.resolve().then(async () => {
+        const setting = await guard();
+        const fresh = await selectCandidate(candidate);
+        if (!fresh.autoContinue || fresh.autoContinueEpoch !== candidate.autoContinueEpoch) throw new Error('Automatic continuation setting changed.');
+        await continueAnalyzedSession({ root, candidate: fresh, manager, signal: controller.signal,
+          readContext, enroll, beforeEnroll: guard,
+          settings: { ...setting.settings, autoContinueEpoch: candidate.autoContinueEpoch } });
+      }).catch(error => {
+        if (!closed && !controller.signal.aborted && !/disabled|already enrolled|setting changed|conversation changed; wait|needs a current recommendation/i.test(error?.message || '')) {
+          errors.set(key, { epoch: candidate.autoContinueEpoch, reason: 'Could not start auto-continue. Check the original conversation and retry.' });
+        }
+      }).finally(() => { pending.delete(key); if (!closed) onChange(); });
+      pending.set(key, { job, controller });
+    }
+  };
+  return { tick,
+    retry(provider, session) {
+      const key = `${provider}:${session}`;
+      if (!closed && !pending.has(key)) { attempted.delete(key); errors.delete(key); }
+    },
+    project(candidate) {
+      const error = errors.get(`${candidate.provider}:${candidate.session}`);
+      if (candidate.autoContinue === true && candidate.autoContinueEpoch === error?.epoch && candidate.capabilities?.canContinue === true &&
+          !['no_action', 'needs_user', 'waiting', 'uncertain'].includes(candidate.analysis?.state)) return {
+        ...candidate, autoContinueStatus: 'error', autoContinueReason: error.reason,
+      };
+      return candidate;
+    },
+    revoke(provider, session) { pending.get(`${provider}:${session}`)?.controller.abort(); },
+    async whenIdle() { await Promise.allSettled([...pending.values()].map(entry => entry.job)); },
+    async close() { closed = true; for (const entry of pending.values()) entry.controller.abort(); await Promise.allSettled([...pending.values()].map(entry => entry.job)); },
+  };
+}

package/src/session-supervision/index.js

@@ -1,9 +1,26 @@
 import { realpath } from 'node:fs/promises';
-import { controlDelivery, listRecords, processIdentity, startDelivery, updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { randomUUID } from 'node:crypto';
+import { TERMINAL as TERMINAL_RUNS, controlDelivery, listRecords, processIdentity, startDelivery, updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { listCodexSessions, openCodexAppServer, readCodexSession } from './codex-app-server.js';
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { originalSessionTarget } from './original-session-target.js';
 
+function autoContinueState(record, isRunning, supported) {
+  if (record?.autoContinue !== true) return { autoContinueStatus: 'off', autoContinueReason: null };
+  const state = record.run?.state;
+  if (state === 'budget_exhausted') return { autoContinueStatus: 'limit', autoContinueReason: 'This conversation reached its continuation limit. Its budgets cannot be reset.' };
+  if (['completed', 'reported_done'].includes(state)) return { autoContinueStatus: 'finished', autoContinueReason: 'Bounded continuation finished for this conversation.' };
+  const managed = record.run?.managed;
+  const recoverableCause = record.run?.recoveryCause === 'process_exit' || managed?.resumeChannel === 'codex_app_server' && ['session_supervision', 'approved_action'].includes(record.run?.recoveryCause);
+  if (state === 'recovery_required' && (!managed?.autoRecovery || !recoverableCause || managed.pendingApproval)) return {
+    autoContinueStatus: 'needs_user', autoContinueReason: 'Existing supervision needs your attention before more work can continue.',
+  };
+  if (['paused', 'blocked', 'stopped', 'failed', 'verification_pending'].includes(state)) return { autoContinueStatus: 'needs_user', autoContinueReason: 'Existing supervision needs your attention before more work can continue.' };
+  if (!supported) return { autoContinueStatus: 'unavailable', autoContinueReason: 'The original provider continuation channel is unavailable.' };
+  return { autoContinueStatus: record.run ? 'supervising' : isRunning ? 'waiting' : 'watching',
+    autoContinueReason: record.run ? 'Continuing within the existing task budget.' : isRunning ? 'Waiting for the original turn to finish.' : 'Checking settled requests for worthwhile remaining work.' };
+}
+
 function initialDiagnosisPlan(objective, contextBootstrap = false) {
   const action = { kind: 'read', scope: 'task', summary: contextBootstrap ? 'Understand the original user request and current progress without changing files' : 'Inspect the selected conversation and acceptance evidence without changing files' };
   return {
@@ -36,7 +53,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   const records = await listRecords(root);
   let discovered = [], codexError = null, claude = [], claudeError = null;
   try { discovered = await withClient(openClient, client => listCodexSessions({ client, inspectState: true,
-    prioritySessions: records.filter(record => record.provider === 'codex' && (record.monitor || record.tracked || record.run)).map(record => record.session) })); }
+    prioritySessions: records.filter(record => record.provider === 'codex' && (record.autoContinue || record.monitor || record.tracked || record.run)).map(record => record.session) })); }
   catch (error) { codexError = error?.code === 'unavailable' ? 'Codex executable unavailable.' : error?.code === 'unsupported' ? 'This Codex version lacks a verified app-server writer lock; update before enrollment.' : 'Codex conversation discovery unavailable.'; }
   try { claude = await listClaude(); } catch { claudeError = 'Claude conversation discovery unavailable.'; }
   const byKey = new Map();
@@ -70,13 +87,17 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       ...(item.providerGoal !== undefined ? { providerGoal: item.providerGoal } : {}),
       ...(item.goalReadState ? { goalReadState: item.goalReadState } : {}),
       tracked: typeof record?.tracked === 'boolean' ? record.tracked : record?.monitor === true,
+      autoContinue: record?.autoContinue === true,
+      autoContinueEpoch: record?.autoContinue === true ? record.autoContinueEpoch : null,
+      ...autoContinueState(record, isRunning, supported || liveHook),
       lastActivityAt: item.lastActivityAt, observation: item.observation, availability: item.availability,
       binding: { mode, taskId: run?.managed?.taskId || null },
       originalSessionTarget: originalSessionTarget(item.provider, item.session),
       continuationMode: item.provider === 'claude' ? liveHook ? 'live_hook' : 'manual' : supported ? 'codex_app_server' : 'manual',
       capabilities: { canMonitor: item.capabilities?.canMonitor ?? true,
         canAnalyze: !run && (item.provider === 'codex' ? item.observation.source === 'codex_app_server' && !codexError : item.observation.source === 'claude_local_index' && !claudeError),
-        canEnroll: (supported || liveHook) && !run, canContinue: (supported || liveHook) && !run, canAutoContinue: supported || liveHook },
+        canEnroll: (supported || liveHook) && !run, canContinue: (supported || liveHook) && !run,
+        canAutoContinue: (supported || liveHook) && (!run || Boolean(run.managed) && !TERMINAL_RUNS.has(run.state)) },
       reason: item.provider === 'claude' ? liveHook ? 'Live SIMY hook can continue this Claude session at its next Stop boundary; cold CLI takeover is unavailable.' :
         process.platform === 'win32' ? 'Claude live hook enrollment is unavailable on Windows because provider process identity cannot be verified; monitoring remains available.' :
           'Claude enrollment needs a live matching SIMY SessionStart hook and provider process; cold CLI takeover is unavailable.' :
@@ -85,11 +106,37 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   }))).sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
   // Keep existing bindings visible during a truncated discovery or provider
   // outage, even when newer unbound conversations fill the candidate window.
-  const bound = projected.filter(item => item.binding.mode !== 'unmanaged');
-  const sessions = [...bound, ...projected.filter(item => item.binding.mode === 'unmanaged').slice(0, Math.max(0, 200 - bound.length))];
+  const bound = projected.filter(item => item.autoContinue || item.binding.mode !== 'unmanaged');
+  const sessions = [...bound, ...projected.filter(item => !item.autoContinue && item.binding.mode === 'unmanaged').slice(0, Math.max(0, 200 - bound.length))];
   return { sessions, providers: { codex: { discovery: codexError ? 'unavailable' : 'ready', reason: codexError }, claude: { discovery: claudeError ? 'unavailable' : 'local_index', reason: claudeError } }, refreshedAt: now };
 }
 
+// Explicit execution authority: legacy monitor/tracked records stay read-only.
+export async function setSessionAutoContinue({ root, provider, session, enabled, ...options }) {
+  if (!['codex', 'claude'].includes(provider) || typeof enabled !== 'boolean') throw new Error('Unsupported automatic continuation request.');
+  if (enabled) await trackSession({ root, provider, session, tracked: true, ...options });
+  return updateRecord(root, provider, session, async previous => {
+    if (!previous) throw new Error('Refresh this conversation before changing automatic continuation.');
+    if (enabled && previous.run && !previous.run.managed) throw new Error('Automatic continuation is unavailable for this conversation.');
+    if (enabled && TERMINAL_RUNS.has(previous.run?.state)) throw new Error('Bounded continuation finished or reached its limit; budgets cannot be reset.');
+    if (enabled && provider === 'codex' && !previous.admission?.model) throw new Error('Automatic continuation is unavailable for this conversation.');
+    if (enabled && provider === 'claude' && !await liveClaudeHook(previous,
+      { session, cwd: previous.cwd, observation: { source: previous.admission?.source } }, options.inspectProcess || processIdentity)) throw new Error('Claude needs a live matching SIMY SessionStart hook; cold CLI takeover is unavailable.');
+    const epoch = previous.autoContinue === enabled && previous.autoContinueEpoch ? previous.autoContinueEpoch : randomUUID();
+    const next = { ...previous, autoContinue: enabled, autoContinueEpoch: epoch,
+      ...(enabled ? { tracked: true, monitor: true, autoContinueSettings: { autonomyPolicy: 'balanced', maxMinutes: 30, maxContinuations: 6, maxFailures: 3 } } : { tracked: false, monitor: false }) };
+    // Adopt existing supervision without restarting it or renewing its budgets.
+    if (next.run?.managed) next.run.managed.autoContinueEpoch = epoch;
+    return next;
+  });
+}
+
+export async function readSessionAutoContinue({ root, provider, session }) {
+  const record = (await listRecords(root)).find(item => item.provider === provider && item.session === session);
+  return { enabled: record?.autoContinue === true, epoch: record?.autoContinueEpoch || null,
+    settings: record?.autoContinueSettings, hasRun: Boolean(record?.run) };
+}
+
 // Tracking is local observation metadata. It neither starts nor stops the
 // original provider task and never grants automatic continuation authority.
 export async function trackSession({ root, provider, session, tracked = true, openClient = openCodexAppServer, readClaude = readClaudeSession, now = Date.now() }) {
@@ -133,7 +180,7 @@ export async function monitorSession({ root, provider, session, monitor = true,
 }
 
 export async function enrollSession({ root, provider, session, objective, acceptanceCriteria, contextBootstrap = false, autonomyPolicy = 'balanced',
-  maxMinutes = 30, maxContinuations = 6, maxFailures = 3, maxNoProgressMinutes, maxTokens, openClient = openCodexAppServer,
+  maxMinutes = 30, maxContinuations = 6, maxFailures = 3, maxNoProgressMinutes, maxTokens, autoContinueEpoch, openClient = openCodexAppServer,
   readClaude = readClaudeSession, inspectProcess = processIdentity, now = Date.now() }) {
   if (!['codex', 'claude'].includes(provider)) throw new Error('This provider does not have a verified exact-session enrollment channel.');
   if (maxTokens !== undefined && provider !== 'codex') throw new Error('Token-budgeted supervision requires host-observed Codex usage; Claude live hooks cannot enforce this budget.');
@@ -159,7 +206,7 @@ export async function enrollSession({ root, provider, session, objective, accept
   const admission = provider === 'codex' ? { source: 'codex_app_server', provider, session, cwd, model: metadata.model } : undefined;
   const liveRecord = provider === 'claude' ? (await listRecords(root)).find(item => item.provider === provider && item.session === session) : null;
   const run = await startDelivery({ root, provider, session, cwd, objective: objective.trim(), nextStep: 'Inspect current evidence and propose the next assessed action.',
-    maxMinutes, maxContinuations, maxFailures, now, admission, inspectProcess,
+    maxMinutes, maxContinuations, maxFailures, now, admission, inspectProcess, autoContinueEpoch,
     liveHookAdmission: liveRecord ? { hookStartedAt: liveRecord.hookStartedAt, pid: liveRecord.process.pid, identity: liveRecord.process.identity } : undefined,
     managed: { acceptanceCriteria, contextBootstrap, autonomyPolicy, maxNoProgressMinutes, maxTokens, approvalScopes: ['task'], approvalPolicy: 'wait',
       initialAction: initialPlan.alternatives[0].action, initialPlan, remainingWork: objective.trim(),