@awak-app/simy-cli 0.6.1 → 0.6.4

package/src/delivery-hooks/desktop.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { canReplanDelivery, deliveryBudgetState, managedBudgetReason, reconcileRecords, rootDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { canReplanDelivery, deliveryStop, deliveryStopBlocksResume, reconcileRecords, rootDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { originalSessionTarget } from '../session-supervision/original-session-target.js';
 
 export const HOOK_SETUP = Object.freeze({
@@ -31,17 +31,11 @@ export async function deliveryHookStatus({ root = rootDirectory(), now = Date.no
     runs: records.filter(r => r.run).sort((a, b) => b.run.updatedAt - a.run.updatedAt).slice(0, 30).map(r => ({
       provider: r.provider, session: r.session, originalSessionTarget: originalSessionTarget(r.provider, r.session),
       objective: r.run.objective, state: r.run.state, reason: r.run.reason,
-      continuations: r.run.continuations, maxContinuations: null, deadline: null,
-      localExecutionLimits: false,
+      continuations: r.run.continuations,
       continuationPolicy: r.run.managed?.continuationPolicy || 'bounded',
       startedAt: r.run.startedAt,
-      continuationLimits: deliveryBudgetState(r.run, now),
-      canChangeContinuation: false,
-      hardDeadline: null, hardMaxContinuations: null,
-      budgetWarnings: deliveryBudgetState(r.run, now).warnings,
-      budgetCapability: r.run.managed?.budgetCapability || null,
+      stopCode: deliveryStop(r.run, now)?.code ?? null,
       outcomeProgress: r.run.managed?.outcomeProgress || null,
-      budgetExtensionHistory: r.run.budgetExtensionHistory || [],
       needsAttention: ['blocked', 'failed', 'recovery_required', 'budget_exhausted', 'verification_pending'].includes(r.run.state), updatedAt: r.run.updatedAt,
       managed: Boolean(r.run.managed), taskId: r.run.managed?.taskId || null, actionId: r.run.managed?.actionId || null,
       actionDueAt: r.run.managed?.actionDueAt ?? null,
@@ -56,8 +50,6 @@ export async function deliveryHookStatus({ root = rootDirectory(), now = Date.no
       handoff: r.run.managed?.handoff || null, threadHistory: r.run.managed?.threadHistory || [],
       progressBudget: r.run.managed ? { minutes: r.run.managed.maxNoProgressMinutes, lastVerifiedProgressAt: r.run.managed.lastVerifiedProgressAt,
         attempts: r.run.managed.noProgress, maxAttempts: r.run.managed.maxNoProgress } : null,
-      tokenBudget: r.run.managed?.maxTokens ? { limit: r.run.managed.maxTokens, used: r.run.managed.tokensUsed,
-        usageAvailable: r.run.managed.usageAvailable, source: 'provider_observed', dollarCost: null } : null,
       pendingApproval: r.run.managed?.pendingApproval || null,
       autonomyPolicy: r.run.managed?.autonomyPolicy || null, plan: r.run.managed?.plan || null,
       decision: r.run.managed?.decision || null, decisionHistory: r.run.managed?.decisionHistory || [],
@@ -77,14 +69,14 @@ export async function deliveryHookStatus({ root = rootDirectory(), now = Date.no
         r.run.managed.resumeChannel === 'codex_app_server' && r.run.managed.autoRecovery),
       canResume: ['blocked', 'recovery_required', 'paused'].includes(r.run.state) && r.run.managed?.phase !== 'needs_clarification' &&
         !r.run.managed?.pendingApproval && !r.run.managed?.dependencyWait && !['pending', 'pending_received', 'transferred'].includes(r.run.managed?.handoff?.status) &&
-        !managedBudgetReason(r.run, now),
+        !deliveryStopBlocksResume(r.run, now),
       canApprove: r.run.state === 'blocked' && Boolean(r.run.managed?.pendingApproval) && !r.run.managed.pendingApproval.denied,
       canReject: r.run.state === 'blocked' && Boolean(r.run.managed?.pendingApproval) && !r.run.managed.pendingApproval.denied,
       canReplan: canReplanDelivery(r.run, r.provider, now),
       canAnswer: r.run.managed?.phase === 'needs_clarification' && r.run.state === 'blocked' && Boolean(r.run.managed.understandingQuestion?.id) &&
-        !managedBudgetReason(r.run, now),
+        !deliveryStopBlocksResume(r.run, now),
       canResolveDependency: r.run.state === 'blocked' && r.run.blocker === 'external_dependency' && Boolean(r.run.managed?.dependencyWait?.id) &&
-        !managedBudgetReason(r.run, now) && !['pending', 'pending_received', 'transferred'].includes(r.run.managed?.handoff?.status),
+        !deliveryStopBlocksResume(r.run, now) && !['pending', 'pending_received', 'transferred'].includes(r.run.managed?.handoff?.status),
       canSetPolicy: Boolean(r.run.managed?.autonomyPolicy) && !['completed', 'reported_done', 'stopped', 'failed', 'budget_exhausted'].includes(r.run.state),
     })),
   };

package/src/delivery-hooks/supervisor.js

@@ -1,14 +1,14 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
-import { automaticContinuationAllowed, assessedCheckpointContract, checkpointDelivery, decideStop, deliveryBudgetState, listRecords, readRecord, managedBudgetReason, managedDispatchDeadline, notifyState, processIdentity, reconcileRecords, updateRecord, verifyAutomaticCriteria } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { automaticContinuationAllowed, assessedCheckpointContract, checkpointDelivery, decideStop, deliveryProgressContext, deliveryStop, listRecords, readRecord, 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';
 
 const MAX_OUTPUT = 64 * 1024;
 const SAFE_PROVIDER_CODES = new Set(['identity', 'permission_narrowed', 'permission_restore', 'turn_failed', 'checkpoint',
-  'closed', 'timeout', 'unsupported', 'unavailable', 'manual_provider_action', 'checkpoint_rejected', 'provider_approval', 'usage_unavailable']);
+  'closed', 'timeout', 'unsupported', 'unavailable', 'manual_provider_action', 'checkpoint_rejected', 'provider_approval']);
 function safeProviderCode(code) { return SAFE_PROVIDER_CODES.has(code) ? code : 'provider_error'; }
 function providerFailureReason(code) {
   if (code === 'permission_restore') return 'Codex sandbox restoration could not be confirmed; inspect the original conversation before resuming.';
@@ -40,9 +40,8 @@ async function assertActiveLease(root, provider, session, leaseId, signal, curre
   if (signal?.aborted || current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId) {
     throw new Error('Managed recovery lease changed before provider dispatch.');
   }
-  if (currentTime() >= managedDispatchDeadline(current.run)) 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.');
+  if (managedBudgetReason(current.run, currentTime())) throw new Error('Managed task stopped before provider dispatch.');
   const managed = current.run.managed;
   const approvedWait = managed.decision?.outcome === 'wait' && managed.approvedAction?.id === managed.decision.id && !managed.approvedAction.dispatchedAt;
   if (managed.autonomyPolicy && ((managed.decision?.outcome === 'wait' && !approvedWait) || managed.resumeLease.decisionId !== managed.decision?.id)) throw new Error('Assessed action changed before provider dispatch.');
@@ -80,13 +79,11 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
     lastDependencyResolution: run.managed.lastDependencyResolution,
     remainingWork: run.managed.remainingWork, acceptanceCriteria: run.managed.acceptanceCriteria, proposedAction: run.managed.proposedAction,
     currentDecision: run.managed.autonomyPolicy ? run.managed.decision : undefined, diagnosis: run.managed.plan?.diagnosis,
-    budgets: { ...deliveryBudgetState(run), continuations: run.continuations, failures: run.failures, maxFailures: run.maxFailures,
-      localExecutionLimits: false } };
+    progress: deliveryProgressContext(run) };
   const prompt = run.managed.autonomyPolicy ? `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\nExecute ONLY currentDecision.action. Its expectedVerification and rollback apply to this turn. Stay within provider permissions. End with ONLY one JSON checkpoint. ${assessedCheckpointContract(run.managed.decision)} Do not write SIMY state directly.` : `Continue the existing SIMY managed task in this exact session. Context: ${JSON.stringify(context)}\nStay within the original task and provider permissions. End with ONLY one JSON object: {"status":"in_progress|completed|blocked|error","summary":"...","nextStep":"...","remainingWork":"...","proposedAction":{"kind":"read|local_edit|local_test|external|destructive|scope_change|unknown","scope":"...","summary":"..."},"evidence":[],"acceptanceMet":false}. For blocked include blocker (authorization, missing_information, external_dependency), and for authorization include approval {kind,scope,summary}. Do not claim completion without checking frozen acceptance. SIMY independently verifies supported criteria. Do not write SIMY state directly. If approval or input is needed, return blocked and stop.`;
   const sandbox = run.managed.autonomyPolicy && run.managed.decision?.action.kind === 'read' ? 'read-only' : run.managed.autoRecoverySandbox;
   const args = ['exec', '--json', '--skip-git-repo-check', '-s', sandbox, '-m', run.managed.resumeModel, 'resume', record.session, prompt];
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
-  if (currentTime() >= managedDispatchDeadline(run)) throw new Error('Managed recovery deadline expired before provider dispatch.');
   await beforeDispatch();
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
 
@@ -196,9 +193,9 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       const approved = live?.managed?.decision?.outcome === 'wait' && ['read', 'local_edit', 'local_test'].includes(live.managed.decision.action?.kind) &&
         live.managed.approvedAction?.id === live.managed.decision.id && !live.managed.approvedAction.dispatchedAt;
       if (!live?.managed?.autoRecovery || live.state !== 'recovery_required' || !allowedCause || live.managed.pendingApproval || live.managed.autonomyPolicy && (!live.managed.decision || live.managed.decision.outcome === 'wait' && !approved) || appChannel && live.managed.nextAttemptAt > currentTime()) return current;
-      const budgetReason = managedBudgetReason(live, currentTime());
-      if (budgetReason) {
-        live.state = budgetReason.startsWith('No verified') ? 'paused' : 'failed'; live.reason = budgetReason; live.updatedAt = currentTime(); notifyState(live, live.updatedAt); return current;
+      const stop = deliveryStop(live, currentTime());
+      if (stop) {
+        live.state = stop.code === 'failure_limit' ? 'failed' : 'paused'; live.reason = stop.reason; live.updatedAt = currentTime(); notifyState(live, live.updatedAt); return current;
       }
       live.state = 'auto_resuming'; live.managed.resumeLease = { id: leaseId, claimedAt: currentTime(), checkpointRevision: live.revision, decisionId: live.managed.decision?.id || null,
         owner: { pid: process.pid, identity: ownerIdentity } };
@@ -217,7 +214,6 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     let result;
     let resource;
     let lastActivityAt = currentTime();
-    let usage = null;
     let dispatched = false, waitingForTool = false;
     const controller = new AbortController();
     const abort = () => controller.abort();
@@ -262,10 +258,6 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         const runner = execute || (appServer ? executeCodexAppServer : executeCodexResume);
         result = await runner(claimed, { signal: controller.signal, root, leaseId, currentTime, leaseMonitored: true,
           onActivity: observation => { lastActivityAt = currentTime(); waitingForTool = observation?.waitingForTool === true; },
-          onUsage: observed => {
-            usage = observed;
-
-          },
           beforeDispatch: async providerSandbox => {
             await assertActiveLease(root, record.provider, record.session, leaseId, controller.signal, currentTime);
             await updateRecord(root, record.provider, record.session, current => {
@@ -298,9 +290,6 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }
     finally { stopWatch(); signal?.removeEventListener('abort', abort); }
     if (controller.signal.aborted) result = { ...result, code: -2, cancelled: true };
-    if (deliveryBudgetState(claimed.run).tokenCeiling && !usage && !result.busy && dispatched) {
-      result = { ...result, usageUnavailable: true };
-    }
     if (result.code === 0) {
       try {
         await checkpointDelivery({ root, provider: record.provider, session: record.session, cwd: record.cwd,
@@ -327,14 +316,6 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       const live = current?.run;
       if (live?.managed?.resumeLease?.id !== leaseId) return current;
       delete live.managed.resumeLease;
-      delete live.managed.usageBlocked;
-      if (usage) {
-        live.managed.tokensUsed = (live.managed.tokensUsed || 0) + usage.tokens;
-        live.managed.usageAvailable = true;
-        live.managed.lastUsage = { ...usage, attemptId: leaseId };
-      } else if (!result.busy && deliveryBudgetState(live).tokenCeiling && dispatched) {
-        live.managed.usageAvailable = false; live.managed.usageBlocked = true;
-      }
       const attempt = live.managed.executionAttempt;
       if (!result.busy && attempt?.phase === 'dispatching' && attempt.action?.kind !== 'read') live.managed.executionUncertain = {
         attemptId: leaseId, decisionId: attempt.decisionId, action: attempt.action, at: Date.now() };
@@ -351,13 +332,8 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         if (live.state !== 'auto_resuming') live.reason = `${String(live.reason || '').slice(0, 400)} ${live.managed.providerWarning}`.trim();
       }
       if (live.state !== 'auto_resuming') {
-        if (live.managed.usageBlocked && !['stopped', 'paused', 'completed', 'reported_done'].includes(live.state)) {
-          live.managed.autoRecovery = false;
-          live.reason = `${live.reason} Provider token usage is unavailable; further budgeted turns are blocked.`;
-        }
         live.updatedAt = Date.now(); notifyState(live, live.updatedAt); return current;
       }
-      live.budgetWarnings = deliveryBudgetState(live).warnings;
       if (result.busy) {
         if (result.accessDenied && dispatched) {
           // The final guard rejected before the provider call. Keep its one-shot approval unused.

package/src/desktop-host.js

@@ -9,6 +9,7 @@ import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
 import { controlDelivery, verifyDelivery, createRecordReader } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
 import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 import { createActionAssociationHost } from "./session-supervision/action-association-host.js";
+import { createStopNotifier } from "./session-supervision/stop-notifications.js";
 import { answerSession, continueSession, discoverSessions, enrollSession, monitorSession, trackSession, setSessionAutoContinue } from "./session-supervision/index.js";
 import { createContinuationAnalysisManager } from "./session-supervision/analysis-manager.js";
 import { analyzeContinuation, readContinuationContext } from "./session-supervision/continuation-analysis.js";
@@ -23,7 +24,8 @@ import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { startAgent } from "./agent.js";
-import { createRuntimeDiagnostics } from "./runtime-diagnostics.js";
+import { createRuntimeDiagnostics, captureRuntimeOutput } from "./runtime-diagnostics.js";
+import { applyLoginShellPath } from "./login-shell-path.js";
 import { createCliAutoUpdater, readCliPackageInfo } from "./auto-update.js";
 import { createAgentShutdown } from "./shutdown.js";
 import { resolveWebOrigin } from "./web-origin.js";
@@ -94,6 +96,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin, list: () => recordReader.list(), onChange: () => { if (!closed) setImmediate(() => { void publish().catch(() => {}); }); } });
   let actionAssociations = makeActionAssociations();
   const statisticsCache = new Map();
+  const stopNotifier = createStopNotifier({ emit: event => { if (!closed && !relay) emit(event); } });
   let currentAccess = { state: 'checking', organizationId: null, organizationName: null };
   const accessScope = access => JSON.stringify([access?.revision ?? null, access?.organizationId ?? null]);
   const setAccessSnapshot = async access => {
@@ -104,7 +107,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       discoveryController?.abort();
       sessionRefreshAgain = Boolean(sessionRefresh) && desktopAccessReady(currentAccess);
       for (const item of sessionStatus.sessions) automaticContinuation?.revoke(item.provider, item.session);
-      sessionStatus = { sessions: [], providers: {}, refreshedAt: null }; sessionRefreshedAt = 0;
+      sessionStatus = { sessions: [], providers: {}, refreshedAt: null, initialLoading: true }; sessionRefreshedAt = 0;
       await analysisManager?.update([]);
     }
     return currentAccess;
@@ -133,7 +136,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     beforeClaim: record => actionAssociations.prepareCached?.(record) || record });
   let shuttingDown = null;
   let commands;
-  let sessionStatus = { sessions: [], providers: { codex: { discovery: "loading", reason: null }, claude: { discovery: "loading", reason: null } }, refreshedAt: null };
+  let sessionStatus = { sessions: [], providers: { codex: { discovery: "loading", reason: null }, claude: { discovery: "loading", reason: null } }, refreshedAt: null, initialLoading: true };
   let sessionRefresh = null, sessionRefreshedAt = 0, sessionRefreshAgain = false, discoveryController = null, discoveryStopped = false;
   const stopDiscovery = async ({ drain = false } = {}) => {
     discoveryController?.abort();
@@ -157,8 +160,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
             sessionRefreshAgain = desktopAccessReady(latestAccess);
             return;
           }
-          await analysisManager.update(value.sessions); sessionStatus = value; sessionRefreshedAt = Date.now(); })
-        .catch(() => { if (closed || relay || controller.signal.aborted) return; sessionStatus = { ...sessionStatus, providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
+          await analysisManager.update(value.sessions); sessionStatus = { ...value, initialLoading: false }; sessionRefreshedAt = Date.now(); })
+        .catch(() => { if (closed || relay || controller.signal.aborted) return; sessionStatus = { ...sessionStatus, initialLoading: false, providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
         .finally(() => { if (discoveryController === controller) discoveryController = null; sessionRefresh = null; if (sessionRefreshAgain && !closed && !relay) { sessionRefreshAgain = false; refreshSessions(true); }
           if (!closed) setImmediate(() => { void publish().catch(() => {}); }); });
     }
@@ -243,6 +246,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       }
       await analysisManager.updateProviderStatuses?.(status.providers);
       const records = await recordReader.list();
+      stopNotifier.observe(records);
       const projection = await actionAssociations.beginProjection?.({ records });
       status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: deliveryRoot, records: projection?.records || records }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
       await actionAssociations.decorate(status.deliveryHooks, projection);
@@ -572,9 +576,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
         else if (action === "codex_hooks" || action === "claude_hooks") {
           const provider = action === "codex_hooks" ? "codex" : "claude";
           await (dependencies.openHookSettings || openHookSetup)(provider);
-        } else if (["delivery_stop", "delivery_resume", "delivery_pause", "delivery_approve", "delivery_reject", "delivery_replan", "delivery_set_policy", "delivery_dependency_ready", "delivery_extend", "delivery_continuation_policy"].includes(action)) {
+        } else if (["delivery_stop", "delivery_resume", "delivery_pause", "delivery_approve", "delivery_reject", "delivery_replan", "delivery_set_policy", "delivery_dependency_ready", "delivery_continuation_policy"].includes(action)) {
           await controlDelivery({ root: join(root, "delivery-hooks"), provider: command.provider, session: command.session,
-            taskId: command.taskId, approvalId: command.approvalId, autonomyPolicy: command.autonomyPolicy, limits: command.limits, continuationPolicy: command.continuationPolicy, waitId: command.waitId, answer: command.answer, action: action.slice("delivery_".length) });
+            taskId: command.taskId, approvalId: command.approvalId, autonomyPolicy: command.autonomyPolicy, continuationPolicy: command.continuationPolicy, waitId: command.waitId, answer: command.answer, action: action.slice("delivery_".length) });
         } else if (action === "delivery_verify") {
           await verifyDelivery({ root: join(root, "delivery-hooks"), provider: command.provider, session: command.session,
             taskId: command.taskId, criterionId: command.criterionId });
@@ -590,7 +594,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           }
           if (command.enabled) await authorizeWork(commandScope);
           await (dependencies.setSessionAutoContinue || setSessionAutoContinue)({ root: join(root, 'delivery-hooks'),
-            provider: command.provider, session: command.session, enabled: command.enabled, continuationPolicy: command.continuationPolicy, hardMaxMinutes: command.hardMaxMinutes, hardMaxContinuations: command.hardMaxContinuations, providerTokenCeiling: command.providerTokenCeiling });
+            provider: command.provider, session: command.session, enabled: command.enabled, continuationPolicy: command.continuationPolicy });
           if (!command.enabled) automaticContinuation.revoke(command.provider, command.session);
           // Acknowledge the durable preference before discovery or analysis.
           emit({ type: "result", id: command.id, ok: true });
@@ -625,8 +629,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         } else if (action === "session_enroll") {
           await (dependencies.enrollSession || enrollSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
             session: command.session, objective: command.objective, acceptanceCriteria: command.acceptanceCriteria,
-            autonomyPolicy: command.autonomyPolicy, maxMinutes: command.maxMinutes,
-            maxContinuations: command.maxContinuations, maxFailures: command.maxFailures, maxNoProgressMinutes: command.maxNoProgressMinutes, maxTokens: command.maxTokens, continuationPolicy: command.continuationPolicy, hardMaxMinutes: command.hardMaxMinutes, hardMaxContinuations: command.hardMaxContinuations, providerTokenCeiling: command.providerTokenCeiling });
+            autonomyPolicy: command.autonomyPolicy, maxFailures: command.maxFailures, maxNoProgressMinutes: command.maxNoProgressMinutes, continuationPolicy: command.continuationPolicy });
           await refreshSessions(true);
         } else if (action === "session_analyze") {
           const candidate = await selectedSession(command, { reuseDiscovery: true });
@@ -638,9 +641,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await continueAnalyzedSession({ root: join(root, 'delivery-hooks'), candidate, manager,
             readContext: dependencies.readContinuationContext || readContinuationContext,
             enroll: async options => { await authorizeWork(commandScope); return guardedEnroll(options); }, beforeEnroll: () => authorizeWork(commandScope),
-            settings: { autonomyPolicy: command.autonomyPolicy, maxMinutes: command.maxMinutes,
-              maxContinuations: command.maxContinuations, maxFailures: command.maxFailures,
-              maxNoProgressMinutes: command.maxNoProgressMinutes, maxTokens: command.maxTokens, continuationPolicy: command.continuationPolicy, hardMaxMinutes: command.hardMaxMinutes, hardMaxContinuations: command.hardMaxContinuations, providerTokenCeiling: command.providerTokenCeiling } });
+            settings: { autonomyPolicy: command.autonomyPolicy, maxFailures: command.maxFailures,
+              maxNoProgressMinutes: command.maxNoProgressMinutes, continuationPolicy: command.continuationPolicy } });
           await refreshSessions(true);
         } else if (action === "session_answer") {
           await (dependencies.answerSession || answerSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
@@ -735,7 +737,7 @@ export async function openProviderLogin(provider, root, {
   const directory = await mkdtemp(join(root, `${provider}-login-`));
   const script = join(directory, `Sign in to ${label}.command`);
   const quote = (s) => `'${s.replaceAll("'", "'\\''")}'`;
-  await writeFile(script, `#!/bin/bash\nexport PATH="/opt/homebrew/bin:/usr/local/bin:$HOME/.local/bin:$PATH"\n${quote(executable.executable)} ${args.join(" ")}\nresult=$?\nrm -f -- ${quote(script)}\nrmdir -- ${quote(directory)}\nexit "$result"\n`, { mode: 0o700 });
+  await writeFile(script, `#!/bin/bash\nexport PATH=${quote(env.PATH || "/usr/bin:/bin")}\n${quote(executable.executable)} ${args.join(" ")}\nresult=$?\nrm -f -- ${quote(script)}\nrmdir -- ${quote(directory)}\nexit "$result"\n`, { mode: 0o700 });
   await chmod(script, 0o700);
   try { await execFileImpl("/usr/bin/open", ["-a", "Terminal", script], { timeout: 10_000 }); }
   catch (error) { await rm(directory, { recursive: true, force: true }); throw error; }
@@ -750,8 +752,12 @@ if (isDesktopHostEntry()) {
   let host;
   const stop = () => { void host?.close().finally(() => process.exit(0)); };
   process.once("SIGTERM", stop); process.once("SIGINT", stop);
-  startDesktopHost().then((value) => { host = value; }).catch((error) => {
-    createRuntimeDiagnostics(process.env.SIMY_HOME?.trim() || join(homedir(), ".simy"), { name: "desktop-host" }).write(`startup failed: ${error?.stack || error}`);
+  const diagnostics = createRuntimeDiagnostics(process.env.SIMY_HOME?.trim() || join(homedir(), ".simy"), { name: "desktop-host" });
+  // stdout is the native JSONL channel; stderr is the only unstructured output
+  // and the native window does not display it, so keep it for support.
+  captureRuntimeOutput(diagnostics, { stderr: process.stderr });
+  applyLoginShellPath({ diagnostics }).catch(() => {}).then(() => startDesktopHost()).then((value) => { host = value; }).catch((error) => {
+    diagnostics.write(`startup failed: ${error?.stack || error}`);
     const conflict = error?.code === PROCESS_CONFLICT_CODE;
     process.stdout.write(`${JSON.stringify({
       type: "error",

package/src/hook-runtime.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+
+// Version-specific runtimes are replaced by the stable alias that follows
+// upgrades: the installer's `current` release link and Homebrew's `opt` link.
+const STABLE_RUNTIME_ALIASES = [
+  [/^(.*)\/installer\/releases\/[^/]+\/[^/]+\.app\/(Contents\/Resources\/runtime\/bin\/node)$/, "$1/installer/current/$2"],
+  [/^(.*)\/Cellar\/([^/]+)\/[^/]+\/(bin\/node)$/, "$1/opt/$2/$3"],
+];
+
+// Provider hooks are persisted into Codex/Claude configuration and run long
+// after this process exits, often from GUI apps without the user's shell PATH.
+// They must therefore name an absolute runtime that survives SIMY and Node updates.
+export function stableHookRuntime({ execPath = process.execPath, fileExists = existsSync } = {}) {
+  for (const [pattern, replacement] of STABLE_RUNTIME_ALIASES) {
+    if (!pattern.test(execPath)) continue;
+    const alias = execPath.replace(pattern, replacement);
+    if (fileExists(alias)) return alias;
+  }
+  return execPath;
+}
+
+export function hookRuntimeCommand(command, { platform = process.platform, ...options } = {}) {
+  if (typeof command !== "string" || !command.startsWith("node ")) return command;
+  return `${quoteRuntime(stableHookRuntime(options), platform)} ${command.slice("node ".length)}`;
+}
+
+function quoteRuntime(value, platform) {
+  return platform === "win32" ? `"${value.replaceAll('"', '""')}"` : `'${value.replaceAll("'", "'\\''")}'`;
+}

package/src/login-shell-path.js

@@ -0,0 +1,67 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+const START = "__SIMY_LOGIN_PATH_START__";
+const END = "__SIMY_LOGIN_PATH_END__";
+
+// Apps opened from Finder or the Dock inherit launchd's minimal PATH, not the
+// user's shell profile. Provider CLIs installed through nvm, volta, fnm, asdf,
+// pnpm or custom prefixes are therefore invisible unless we ask the user's own
+// login shell once. A slow or broken profile must never prevent startup.
+export async function resolveLoginShellPath({
+  platform = process.platform,
+  env = process.env,
+  execFileImpl = execFile,
+  fileExists = existsSync,
+  timeoutMs = 5_000,
+} = {}) {
+  if (platform === "win32") return null;
+  const shell = loginShell({ platform, env, fileExists });
+  if (!shell) return null;
+  const output = await new Promise((resolve) => {
+    // Read the exported environment rather than expanding $PATH in the shell:
+    // fish expands a quoted $PATH with spaces, but exports it colon-separated.
+    const child = execFileImpl(shell, ["-l", "-i", "-c", `echo ${START}; /usr/bin/env; echo ${END}`], {
+      env: { ...env, TERM: "dumb", DISABLE_AUTO_UPDATE: "true" },
+      timeout: timeoutMs,
+      killSignal: "SIGKILL",
+      maxBuffer: 1024 * 1024,
+    }, (_error, stdout) => resolve(String(stdout || "")));
+    child?.stdin?.end();
+  });
+  const start = output.lastIndexOf(START);
+  const end = output.indexOf(END, start);
+  if (start < 0 || end < 0) return null;
+  const line = output.slice(start + START.length, end).split(/\r?\n/).find((item) => item.startsWith("PATH="));
+  return line?.slice("PATH=".length) || null;
+}
+
+// Login-shell entries take priority, matching what the user sees in Terminal.
+// Existing entries (including the launcher's fallback directories) are kept.
+export function mergePathEntries(...values) {
+  const entries = [];
+  for (const value of values) {
+    for (const entry of String(value || "").split(path.delimiter)) {
+      if (path.isAbsolute(entry) && !entries.includes(entry)) entries.push(entry);
+    }
+  }
+  return entries.join(path.delimiter);
+}
+
+export async function applyLoginShellPath({ env = process.env, platform = process.platform, diagnostics, ...options } = {}) {
+  if (platform === "win32") return false;
+  const loginPath = await resolveLoginShellPath({ env, platform, ...options });
+  if (!loginPath) {
+    diagnostics?.write("login shell PATH unavailable; using launcher PATH");
+    return false;
+  }
+  env.PATH = mergePathEntries(loginPath, env.PATH);
+  diagnostics?.write(`login shell PATH applied (${env.PATH.split(path.delimiter).length} entries)`);
+  return true;
+}
+
+function loginShell({ platform, env, fileExists }) {
+  const candidates = [env.SHELL, platform === "darwin" ? "/bin/zsh" : null, "/bin/sh"];
+  return candidates.find((candidate) => candidate && path.isAbsolute(candidate) && fileExists(candidate)) || null;
+}

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

@@ -160,7 +160,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
       if (closed) return;
       const managed = record.run.managed, job = managed.actionAssociation?.job;
       if (job && !managed.resumeLease && (!expected || TERMINAL.has(record.run.state) || ['paused', 'blocked'].includes(record.run.state) || record.run.state === 'recovery_required' && record.run.recoveryCause !== 'session_supervision' ||
-          managedBudgetReason(record.run, now()) || now() >= record.run.deadline || record.run.continuations >= record.run.maxContinuations ||
+          managedBudgetReason(record.run, now()) ||
           managed.understandingRevision !== job.understandingRevision || record.run.revision !== job.runRevision || managed.actionAssociation.invalidated)) {
         await cancelActionAssociation({ root, ...identity(record), expectedJobId: job.id, now: now() });
       }

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

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { listRecords, updateRecord, TERMINAL } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { listRecords, managedBudgetReason, updateRecord, TERMINAL } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { associationSignals, associationRevision } from '../codex-plugins/simy/hooks/action-association.mjs';
 export { associationSignals, associationRevision, associationContract, validateAssociationResult } from '../codex-plugins/simy/hooks/action-association.mjs';
 
@@ -25,7 +25,7 @@ export async function queueActionAssociation({ root, provider, session, taskId,
     await assertScope(validate);
     const run = record?.run, managed = run?.managed;
     if (!managed || managed.taskId !== taskId || run.revision !== expectedRevision) return record;
-    if (!stable(run) || now >= run.deadline || run.continuations >= run.maxContinuations) {
+    if (!stable(run) || managedBudgetReason(run, now)) {
       if (!managed.actionAssociation?.job && !managed.actionAssociation?.outbox && !managed.actionAssociation?.manualOverride) managed.actionAssociation = { ...managed.actionAssociation, status: 'waiting_boundary', retryOn: 'original_session_safe_boundary', updatedAt: now };
       return record;
     }

package/src/session-supervision/codex-app-server.js

@@ -2,7 +2,7 @@ import { associationContract } from '../codex-plugins/simy/hooks/action-associat
 import { spawn } from 'node:child_process';
 import { realpath } from 'node:fs/promises';
 import { CODEX_WRITER_LOCK_MINIMUM_VERSION, compareVersions, inspectBackendExecutable } from '../backend-executable.js';
-import { assessedCheckpointContract, deliveryBudgetState, understandingCheckpointContract } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { assessedCheckpointContract, deliveryProgressContext, understandingCheckpointContract } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { boundConversation, boundProviderGoal, textContent } from './conversation-context.js';
 import { JsonDataUrlFilter } from './json-data-url-filter.js';
 
@@ -394,7 +394,7 @@ export function isCodexWriterBusy(error) {
   return error instanceof CodexAppServerError && error.code === -32600 && /already has an active writer/i.test(error.message);
 }
 
-export async function executeCodexAppServer(record, { openClient = openCodexAppServer, signal, beforeDispatch = async () => {}, onActivity = () => {}, onUsage = () => {} } = {}) {
+export async function executeCodexAppServer(record, { openClient = openCodexAppServer, signal, beforeDispatch = async () => {}, onActivity = () => {} } = {}) {
   const run = record.run, decision = run.managed?.decision;
   if (!decision || !run.managed.autonomyPolicy) throw new CodexAppServerError('decision', 'An assessed action is required before Codex dispatch.');
   if (!['read', 'local_edit', 'local_test'].includes(decision.action?.kind)) throw new CodexAppServerError('manual_provider_action', 'This action must be completed in the original provider conversation.');
@@ -405,7 +405,6 @@ export async function executeCodexAppServer(record, { openClient = openCodexAppS
   const client = await openClient({ signal });
   let originalSandbox = null, overrideStarted = false, activeTurnId = null, turnCompleted = false, turnStart = null;
   let primaryError = null;
-  let usage = null, lastTotal = null;
   try {
     const metadata = await readCodexSession(client, record.session);
     if (await realpath(metadata.cwd) !== record.cwd || metadata.model !== run.managed.resumeModel) throw new CodexAppServerError('identity', 'Codex session workspace or model changed.');
@@ -422,8 +421,7 @@ export async function executeCodexAppServer(record, { openClient = openCodexAppS
       enrolledScopes: run.managed.approvalScopes,
       lastDependencyResolution: run.managed.lastDependencyResolution,
       ...(authorizedWait ? { approvedAction: { approvalId: approved.id, action: approved.action, oneShot: true } } : {}),
-      budgets: { ...deliveryBudgetState(run), continuations: run.continuations, failures: run.failures, maxFailures: run.maxFailures,
-        localExecutionLimits: false } };
+      progress: deliveryProgressContext(run) };
     const approvalInstruction = authorizedWait ? `SIMY recorded a matching, one-shot scoped user approval ${approved.id} for this exact selected action. The decision outcome "wait" describes its pre-approval assessment; the approved action is authorized now. Execute it once, then report what actually happened. ` : '';
     const prompt = run.managed.phase === 'action_association' ? associationContract(run.managed.actionAssociation.job) : run.managed.phase === 'understanding' ? `Understand the ORIGINAL user request in this exact Codex conversation. This first/clarifying turn is read-only and must not perform task work. Context: ${JSON.stringify({ ...context, priorUnderstanding: run.managed.sessionUnderstanding, userAnswer: run.managed.understandingAnswer })}\n${understandingCheckpointContract(decision)} Do not write SIMY state directly.` : `Continue this existing SIMY managed task in the exact Codex conversation. Context: ${JSON.stringify(context)}\n${approvalInstruction}Execute ONLY the selected decision action. Do not perform any action from the NEXT plan in this turn. For a next local action within the enrolled task use the exact scope "task"; do not relabel external, broad, or destructive work as local. Preserve provider permissions. End with one JSON checkpoint. ${assessedCheckpointContract(decision)} Do not write SIMY state directly.`;
     const initialSandbox = run.managed.providerSandbox || resumed.sandbox;
@@ -439,21 +437,12 @@ export async function executeCodexAppServer(record, { openClient = openCodexAppS
       let turnId = null, completion = null, settled = false;
       const messages = new Map();
       const activeTools = new Set();
-      const earlyUsage = [];
       const earlyActivity = [];
       const observeActivity = (method, params) => {
         if (method === 'item/started' && ['commandExecution', 'mcpToolCall', 'webSearch', 'fileChange'].includes(params.item?.type)) activeTools.add(params.item.id);
         if (method === 'item/completed') activeTools.delete(params.item?.id);
         onActivity({ waitingForTool: activeTools.size > 0 });
       };
-      const observeUsage = params => {
-        const total = params.tokenUsage?.total?.totalTokens, last = params.tokenUsage?.last?.totalTokens;
-        if (!Number.isSafeInteger(total) || total < 0 || !Number.isSafeInteger(last) || last < 0 || last > total) return;
-        if (lastTotal === null) usage = { source: 'codex_app_server', tokens: last, observedAt: Date.now() };
-        else usage.tokens += Math.max(0, total - lastTotal);
-        lastTotal = Math.max(lastTotal ?? 0, total);
-        onUsage({ ...usage });
-      };
       const cleanup = () => { unsubscribe(); signal?.removeEventListener('abort', cancelled); client.child.removeListener('close', closed); };
       const finish = (error, value) => { if (settled) return; settled = true; cleanup(); if (error) reject(error); else resolve(value); };
       const cancelled = () => finish(new CodexAppServerError('cancelled', 'Codex turn was cancelled.'));
@@ -474,10 +463,6 @@ export async function executeCodexAppServer(record, { openClient = openCodexAppS
           if (turnId) observeActivity(method, params);
         } else if (!turnId && typeof params.turnId === 'string' && earlyActivity.length < 100) earlyActivity.push({ method, turnId: params.turnId,
           item: { id: params.item?.id, type: params.item?.type } });
-        if (method === 'thread/tokenUsage/updated') {
-          if (turnId && params.turnId === turnId) observeUsage(params);
-          else if (!turnId && earlyUsage.length < 100) earlyUsage.push({ turnId: params.turnId, tokenUsage: params.tokenUsage });
-        }
         if (method === 'item/completed' && params.item?.type === 'agentMessage' && typeof params.item.text === 'string' && typeof params.turnId === 'string') messages.set(params.turnId, params.item.text);
         if (method === 'turn/completed') { completion = params; if (params.turn?.id === turnId) turnCompleted = true; complete(); }
       });
@@ -487,14 +472,13 @@ export async function executeCodexAppServer(record, { openClient = openCodexAppS
       turnStart = client.request('turn/start', { threadId: record.session, input: [{ type: 'text', text: prompt }], cwd: record.cwd,
         model: run.managed.resumeModel, sandboxPolicy })
         .then(response => { turnId = response?.turn?.id; activeTurnId = turnId; if (!turnId) finish(new CodexAppServerError('turn_failed', 'Codex did not start a turn.')); else {
-          for (const params of earlyUsage) if (params.turnId === turnId) observeUsage(params);
           for (const params of earlyActivity) if (params.turnId === turnId) observeActivity(params.method, params);
           complete();
         } })
         .catch(error => finish(error));
     });
     const checkpoint = await done;
-    return { code: 0, checkpoint, usage };
+    return { code: 0, checkpoint };
   } catch (error) {
     primaryError = error;
     throw error;

package/src/session-supervision/handoff.js

@@ -12,7 +12,8 @@ function unsettled(managed) {
 }
 function exactSource(record, taskId, targetSession, now, allowStoppedPending = false) {
   if (!record?.run?.managed || !record.admission || record.admission.session !== record.session || record.admission.cwd !== record.cwd || record.run.managed.taskId !== taskId) throw new Error('Exact managed task is unavailable.');
-  if (now !== undefined && managedBudgetReason(record.run, now)) throw new Error('Original task budget exhausted; handoff cannot restore it.');
+  const stopReason = now === undefined ? null : managedBudgetReason(record.run, now);
+  if (stopReason) throw new Error(`${stopReason} Resume it in its original conversation before handing it off.`);
   const prior = record.run.managed.handoff;
   const transfer = prior?.status === 'received' ? null : prior;
   if (transfer && transfer.targetSession !== targetSession) throw new Error('A different handoff is already recorded.');

package/src/session-supervision/index.js

@@ -144,7 +144,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
 }
 
 // Explicit execution authority: legacy monitor/tracked records stay read-only.
-export async function setSessionAutoContinue({ root, provider, session, enabled, continuationPolicy, hardMaxMinutes, hardMaxContinuations, providerTokenCeiling, ...options }) {
+export async function setSessionAutoContinue({ root, provider, session, enabled, continuationPolicy, ...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 => {
@@ -155,18 +155,13 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
     if (enabled && provider === 'claude') await requireClaudeChannel(previous,
       { session, cwd: previous.cwd, observation: { source: previous.admission?.source } }, options.inspectProcess || processIdentity);
     const epoch = previous.autoContinue === enabled && previous.autoContinueEpoch ? previous.autoContinueEpoch : randomUUID();
-    const settings = { autonomyPolicy: 'balanced', maxMinutes: 30, maxContinuations: 6, maxFailures: 3,
-      ...previous.autoContinueSettings,
-      ...(continuationPolicy === undefined ? {} : { continuationPolicy }),
-      ...(hardMaxMinutes === undefined ? {} : { hardMaxMinutes }),
-      ...(hardMaxContinuations === undefined ? {} : { hardMaxContinuations }),
-      ...(providerTokenCeiling === undefined ? {} : { providerTokenCeiling }) };
+    // Settings persisted by older versions may carry removed time, turn and
+    // token caps; only the fields that still govern a task are forwarded.
+    const { autonomyPolicy = 'balanced', maxFailures = 3, continuationPolicy: savedPolicy } = previous.autoContinueSettings || {};
+    const settings = { autonomyPolicy, maxFailures,
+      ...(continuationPolicy ?? savedPolicy) === undefined ? {} : { continuationPolicy: continuationPolicy ?? savedPolicy } };
     if (settings.continuationPolicy !== undefined && !['bounded', 'progress'].includes(settings.continuationPolicy)) throw new Error('Choose a continuation policy.');
-    for (const [key, maximum] of [['hardMaxMinutes', 1440], ['hardMaxContinuations', 50], ['providerTokenCeiling', 15_000_000]]) {
-      if (settings[key] !== undefined && (!Number.isSafeInteger(settings[key]) || settings[key] < 1 || settings[key] > maximum)) throw new Error('Invalid continuation ceiling.');
-    }
-    if (providerTokenCeiling !== undefined && provider !== 'codex') throw new Error('Token ceilings require host-observed Codex usage.');
-    if (previous.run && [continuationPolicy, hardMaxMinutes, hardMaxContinuations, providerTokenCeiling].some(value => value !== undefined)) throw new Error('Change an existing task through its explicit continuation controls.');
+    if (previous.run && continuationPolicy !== undefined) throw new Error('Change an existing task through its explicit continuation controls.');
     const next = { ...previous, autoContinue: enabled, autoContinueEpoch: epoch,
       ...(enabled ? { tracked: true, monitor: true, autoContinueSettings: settings } : { tracked: false, monitor: false }) };
     // Adopt existing supervision without restarting it or renewing its budgets.
@@ -224,7 +219,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, continuationPolicy, hardMaxMinutes, hardMaxContinuations, providerTokenCeiling, autoContinueEpoch, openClient = openCodexAppServer,
+  maxFailures = 3, maxNoProgressMinutes, continuationPolicy, 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 (typeof objective !== 'string' || !objective.trim() || objective.length > 4000) throw new Error('A concrete objective is required.');
@@ -249,13 +244,13 @@ 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 readRecord(root, provider, 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, continuationPolicy, hardMaxMinutes, hardMaxContinuations, providerTokenCeiling, now, admission, inspectProcess, autoContinueEpoch,
+    maxFailures, continuationPolicy, 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',
+    managed: { acceptanceCriteria, contextBootstrap, autonomyPolicy, maxNoProgressMinutes, approvalScopes: ['task'], approvalPolicy: 'wait',
       initialAction: initialPlan.alternatives[0].action, initialPlan, remainingWork: objective.trim(),
       autoRecovery: provider === 'codex', resumeChannel: provider === 'codex' ? 'codex_app_server' : null,
       resumeModel: metadata.model } });
-  return { provider, session, taskId: run.run.managed.taskId, state: run.run.state, deadline: run.run.deadline };
+  return { provider, session, taskId: run.run.managed.taskId, state: run.run.state };
 }
 
 export async function continueSession(options) {