@awak-app/simy-cli 0.6.2 → 0.6.5

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";
@@ -95,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 => {
@@ -105,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;
@@ -134,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();
@@ -158,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(() => {}); }); });
     }
@@ -244,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);
@@ -459,7 +462,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           if (command.force !== true) throw new Error("Confirm before stopping this task.");
           await agent.stopDesktopTask(command.taskKey);
           emit({ type: "result", id: command.id, ok: true });
-          void publish(); return;
+          void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." })); return;
         }
         const access = await accessSnapshot();
         const commandScope = accessScope(access);
@@ -479,7 +482,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           statisticsCache.clear(); // Only the selected conversation needs chart data.
           statisticsCache.set(`${candidate.provider}:${candidate.session}`, statistics);
           emit({ type: "result", id: command.id, ok: true });
-          void publish(); return;
+          void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." })); return;
         }
         if (action === "my_ai_session") {
           const ticket = await agent.createDesktopWebSession();
@@ -573,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 });
@@ -591,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 });
@@ -626,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 });
@@ -639,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,

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() });
       }
@@ -200,7 +200,10 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
     async decorateSessions(sessions, projection) {
       await ordinary.decorate(sessions, projection);
       const records = projection?.byKey || new Map((await list(root)).map(record => [`${record.provider}:${record.session}`, record]));
-      const status = { runs: sessions.filter(item => records.get(`${item.provider}:${item.session}`)?.run?.managed).map(item => {
+      const status = { runs: sessions.filter(item => {
+        const record = records.get(`${item.provider}:${item.session}`);
+        return record?.run?.managed && record.cwd === item.cwd;
+      }).map(item => {
         const record = records.get(`${item.provider}:${item.session}`);
         return { managed: true, taskId: record.run.managed.taskId, actionAssociation: record.run.managed.actionAssociation, candidate: item };
       }) };
@@ -212,6 +215,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
       const expected = projection ? projection.authRevision : await current(), record = projection
         ? projection.byKey.get(`${candidate.provider}:${candidate.session}`)
         : await read(root, candidate.provider, candidate.session);
+      if (record?.cwd !== candidate.cwd) return null;
       const local = record?.run?.managed?.actionAssociation || record?.actionAssociation;
       if (!expected || projection && auth !== expected || local?.authRevision !== expected || !(candidate.actionAssociation?.canCorrect || candidate.actionAssociation?.canReadBinding)) return null;
       const binding = candidate.actionAssociation.binding;
@@ -224,7 +228,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
           const latest = await read(root, candidate.provider, candidate.session);
           const scoped = latest?.run?.managed?.actionAssociation || latest?.actionAssociation;
           if (!await valid(expected)) return false;
-          return (latest?.run?.managed?.taskId || latest?.associationTaskId) === candidate.taskId && scoped?.namespace === local.namespace && scoped?.authRevision === expected && fingerprint(scoped.binding) === fingerprint(binding);
+          return latest?.cwd === candidate.cwd && (latest?.run?.managed?.taskId || latest?.associationTaskId) === candidate.taskId && scoped?.namespace === local.namespace && scoped?.authRevision === expected && fingerprint(scoped.binding) === fingerprint(binding);
         } };
 
     },

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/association-store.js

@@ -212,11 +212,20 @@ export function createOrdinaryAssociationStore({
       for (const taskId of views.keys()) if (!taskIds.has(taskId) && !inFlight.has(taskId)) views.delete(taskId);
       const pending = [];
       for (const candidate of sessions) {
-        const record = await ensure(
+        let record;
+        try {
+          record = await ensure(
             candidate,
             records.get(`${candidate.provider}:${candidate.session}`) || null,
-          ),
-          taskId = record.run?.managed?.taskId || record.associationTaskId;
+          );
+        } catch (error) {
+          // A stale workspace or unreadable local record affects only this
+          // optional association. Never rewrite its identity or stop the host.
+          candidate.actionAssociation = { status: error?.code === 'conflict' ? 'conflict' : 'unavailable',
+            binding: null, candidates: [], canCorrect: false, canReadBinding: false };
+          continue;
+        }
+        const taskId = record.run?.managed?.taskId || record.associationTaskId;
         candidate.taskId = taskId;
         candidate.binding = { ...candidate.binding, taskId };
         if (record.run?.managed) continue;

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

@@ -5,6 +5,7 @@ import { homedir } from 'node:os';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { boundConversation, CONVERSATION_LIMITS, textContent } from './conversation-context.js';
 import { sessionTitle } from './session-titles.js';
+import { RECENT_SESSION_LIMIT, recentSessionWindow } from './discovery-window.js';
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const MAX_PROJECTS = 256;
@@ -147,14 +148,14 @@ async function inspectTranscript(root, projectName, fileName, observedAt, includ
   finally { await handle?.close(); }
 }
 
-async function collect({ home = homedir(), limit = 100, session = null, includeContext = false, cacheMetadata = false, includeStatistics = false, signal } = {}) {
+async function collect({ home = homedir(), limit = 100, session = null, prioritySessions = [], includeContext = false, cacheMetadata = false, includeStatistics = false, signal } = {}) {
   if (signal?.aborted) return [];
   const root = await projectsRoot(home);
   if (!root) return [];
-  const maximum = Number.isInteger(limit) ? Math.max(1, Math.min(limit, 200)) : 100;
+  const maximum = Number.isInteger(limit) ? Math.max(1, Math.min(limit, RECENT_SESSION_LIMIT)) : 100;
   const observedAt = Date.now();
   const result = new Map();
-  let inspected = 0;
+  const descriptors = [], priorities = new Set(prioritySessions);
   let projects;
   try { projects = await readdir(root, { withFileTypes: true }); } catch { return []; }
   for (const entry of projects.filter(item => item.isDirectory() && !item.isSymbolicLink()).slice(0, MAX_PROJECTS)) {
@@ -162,32 +163,47 @@ async function collect({ home = homedir(), limit = 100, session = null, includeC
     const project = join(root, entry.name);
     let files;
     try { files = await readdir(project, { withFileTypes: true }); } catch { continue; }
-    for (const file of files) {
-      if (signal?.aborted) return [];
-      if (inspected >= MAX_TRANSCRIPTS) break;
-      if (!file.isFile() || file.isSymbolicLink() || !UUID.test(file.name.replace(/\.jsonl$/, '')) || !file.name.endsWith('.jsonl')) continue;
-      const id = file.name.slice(0, -'.jsonl'.length);
-      if (session && id !== session) continue;
-      inspected++;
-      const candidate = await inspectTranscript(root, entry.name, file.name, observedAt, includeContext, cacheMetadata, includeStatistics);
-      if (!candidate) continue;
-      const key = `${candidate.session}\0${candidate.cwd}${includeContext || includeStatistics ? `\0${entry.name}\0${file.name}` : ''}`;
-      if (!result.has(key) || candidate.lastActivityAt > result.get(key).lastActivityAt) result.set(key, candidate);
-    }
-    if (inspected >= MAX_TRANSCRIPTS) break;
+    const candidates = files.filter(file => file.isFile() && !file.isSymbolicLink() &&
+      file.name.endsWith('.jsonl') && UUID.test(file.name.slice(0, -'.jsonl'.length)) &&
+      (!session || file.name === `${session}.jsonl`));
+    let next = 0;
+    // Ranking uses file metadata only. Opening every transcript before slicing
+    // made a small visible catalog scan thousands of message prefixes at startup.
+    await Promise.all(Array.from({ length: Math.min(8, candidates.length) }, async () => {
+      while (next < candidates.length && !signal?.aborted) {
+        const file = candidates[next++];
+        try {
+          const info = await lstat(join(project, file.name));
+          if (info.isFile() && !info.isSymbolicLink() && info.size <= MAX_FILE_BYTES)
+            descriptors.push({ projectName: entry.name, fileName: file.name,
+              session: file.name.slice(0, -'.jsonl'.length), lastActivityAt: info.mtimeMs });
+        } catch { /* A disappearing transcript does not stop discovery. */ }
+      }
+    }));
+  }
+  if (signal?.aborted) return [];
+  const selected = session ? descriptors : recentSessionWindow(descriptors, {
+    limit: maximum, priority: item => priorities.has(item.session),
+  });
+  for (const file of selected.slice(0, MAX_TRANSCRIPTS)) {
+    if (signal?.aborted) return [];
+    const candidate = await inspectTranscript(root, file.projectName, file.fileName, observedAt, includeContext, cacheMetadata, includeStatistics);
+    if (!candidate) continue;
+    const key = `${candidate.session}\0${candidate.cwd}${includeContext || includeStatistics ? `\0${file.projectName}\0${file.fileName}` : ''}`;
+    if (!result.has(key) || candidate.lastActivityAt > result.get(key).lastActivityAt) result.set(key, candidate);
   }
   const sorted = [...result.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt || a.session.localeCompare(b.session));
-  return session ? sorted : sorted.slice(0, maximum);
+  return session ? sorted : recentSessionWindow(sorted, { limit: maximum, priority: item => priorities.has(item.session) });
 }
 
-export async function listClaudeSessions({ home, limit, signal } = {}) {
-  return collect({ home, limit, signal, cacheMetadata: true });
+export async function listClaudeSessions({ home, limit, prioritySessions, signal } = {}) {
+  return collect({ home, limit, prioritySessions, signal, cacheMetadata: true });
 }
 
 export async function readClaudeSession(session, { home } = {}) {
   const id = typeof session === 'string' ? session : session?.session;
   if (typeof id !== 'string' || !UUID.test(id)) return null;
-  const matches = await collect({ home, limit: 200, session: id });
+  const matches = await collect({ home, limit: RECENT_SESSION_LIMIT, session: id });
   const selected = typeof session === 'object' && typeof session.cwd === 'string'
     ? matches.filter(item => item.cwd === session.cwd) : matches;
   return selected.length === 1 ? selected[0] : null;

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

@@ -2,9 +2,10 @@ 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';
+import { RECENT_SESSION_LIMIT } from './discovery-window.js';
 
 const REQUEST_TIMEOUT = 15_000;
 const MAX_LINE = 256 * 1024;
@@ -187,14 +188,15 @@ export function codexThreadMetadata(thread) {
   };
 }
 
-export async function listCodexSessions({ client, maxPages = 40, pageSize = 25, maxSessions = 200, inspectState = false, prioritySessions = [], observationBudgetMs = 3000 } = {}) {
+export async function listCodexSessions({ client, maxPages = 40, pageSize = 25, maxSessions = RECENT_SESSION_LIMIT, inspectState = false, prioritySessions = [], observationBudgetMs = 3000 } = {}) {
   const sessions = [];
   const windowSize = Math.min(maxSessions, maxPages * pageSize);
   let cursor = null, listed = 0, pages = 0, batchSize = pageSize;
   while (pages < Math.max(maxPages, Math.ceil(windowSize / batchSize)) && listed < windowSize) {
     const limit = Math.min(batchSize, windowSize - listed);
     let response;
-    try { response = await client.request('thread/list', { cursor, limit, sourceKinds: SOURCE_KINDS, archived: false }); }
+    try { response = await client.request('thread/list', { cursor, limit, sourceKinds: SOURCE_KINDS,
+      archived: false, sortKey: 'updated_at', sortDirection: 'desc' }); }
     catch (error) {
       // Keep the transport's byte limit. Retry the same cursor in smaller
       // batches rather than dropping discovery for large metadata envelopes.
@@ -394,7 +396,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 +407,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 +423,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 +439,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 +465,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 +474,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/discovery-window.js

@@ -0,0 +1,15 @@
+import { TERMINAL } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+export const RECENT_SESSION_LIMIT = 200;
+
+// Explicit tracking and unsettled work remain visible outside recent history.
+// Completed, untracked records are history, not an unlimited extra catalog.
+export const retainedSession = record => Boolean(record?.autoContinue || record?.monitor || record?.tracked ||
+  record?.run && !TERMINAL.has(record.run.state));
+
+export function recentSessionWindow(items, { limit = RECENT_SESSION_LIMIT, priority = () => false } = {}) {
+  const recent = [...items].sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0) || a.session.localeCompare(b.session));
+  const retained = [], history = [];
+  for (const item of recent) (priority(item) ? retained : history).push(item);
+  return [...retained, ...history.slice(0, Math.max(0, limit - retained.length))];
+}

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.');