@awak-app/simy-cli 0.5.75 → 0.5.76

package/README.md

@@ -29,38 +29,25 @@ actions together. Environment-only calls remain supported. Task checks reuse the
 execution charter policy; model entitlement, external test resources and assurance
 selection evidence are not guessed from a successful login or recommendation.
 
-### Explicit progress continuation
-
-Existing tasks use **Bounded** continuation. Select **Progress** before starting
-an Agentic Loop or Local Task, or when enrolling an App session, to treat the
-ordinary token/attempt/time limits as warning thresholds. New independently
-verified acceptance criteria permit further work within finite hard ceilings;
-repeated work without new proof pauses the same task. Approval requests, explicit
-stops and authorization failures still pause execution. Provider text claiming
-success does not count as verification.
-
-Local Tasks retain valid output after a soft token warning and stop at their
-explicit hard ceiling (at most 10 million reported provider tokens). The Agentic
-controller limits a whole progress run to its approved allocation, at most
-15 million tokens, and persists the allocation with canonical receipts. Missing
-reliable usage is charged conservatively against the reserved allocation. The
-Web controller supports this mode for the connected local Codex/Claude engines;
-unsupported cloud execution is refused before dispatch.
-
-In the App, pause a managed Delivery task before changing its continuation
-policy or extending its bounds. Extension keeps usage, task identity, acceptance
-and approvals, and requires a separate resume action. Delivery hard ceilings are
-24 hours and 50 continuations; host-observed Codex usage can also impose a token
-ceiling. A Claude live-hook session without reliable token telemetry explicitly
-uses time/continuation bounds instead of inventing usage.
+### Local continuation
+
+The recorded **Bounded** and **Progress** policy fields remain readable for
+compatibility. Independently verified acceptance criteria permit further work. Local token usage, elapsed time
+and attempt counters do not stop execution, including old tasks restored from
+bounded policies. Repeated work without new proof pauses the same task. Approval
+requests, explicit stops and authorization failures still pause execution.
+Provider text claiming success does not count as verification. Token records
+remain available for history and usage warnings. The Web controller supports
+connected local Codex/Claude engines; unsupported cloud execution is refused
+before dispatch.
 
 For interrupted Agentic work, `GET /v1/agentic-loop/:id/recovery` provides a
 read-only objective and checkout fingerprint. Reconcile an uncertain side effect
 with `POST` to that endpoint (`action: reconcile`, authoritative
 `operation_status`, `observation`, `evidence_refs`) before resuming. A paused
-progress run accepts explicit increases through
-`POST /v1/agentic-loop/:id/continuation-ceilings`; it never resets already used
-tokens or automatically resumes. Both routes require the original authorized
+run retains the legacy metadata endpoint
+`POST /v1/agentic-loop/:id/continuation-ceilings` for compatibility. These fields
+no longer impose local limits and changing them never resets usage or resumes work. Both routes require the original authorized
 account, organization and device throughout the request.
 
 ## Apple Silicon Mac app
@@ -186,7 +173,7 @@ tasks are not restarted. Missing or disabled plugins are not enabled automatical
 Failed refreshes retry on the next check without blocking daemon startup.
 The desktop Sessions page discovers existing provider conversations and lets users
 choose monitoring or supported session supervision with a goal, acceptance
-criteria, an autonomy policy, and finite budgets. Codex enrollment uses an exact
+criteria and an autonomy policy. Local time, token and continuation counters do not stop work. Codex enrollment uses an exact
 app-server session and checks writer ownership before each continuation. Claude
 can continue through a verified live SIMY hook in its original process; sessions
 without that hook support monitoring only, and cold takeover remains unavailable. See [session supervision](docs/session-supervision.md).
@@ -259,8 +246,7 @@ chat message creates the remote audit ledger and starts the local Agentic Loop
 state machine; SIMY Web mirrors the lifecycle but is not required as the task
 entry point. The CLI also accepts backend-issued launch challenges for Web-led
 runs. It builds the requirement charter, runs Codex or Claude Code, audits
-structured completion evidence, and re-instructs the executor within the
-configured attempt budget.
+structured completion evidence, and re-instructs the executor while verification shows useful progress.
 
 Before Web creates an Agentic Loop, it classifies whether the request actually
 needs a managed PR, verification, evidence, and merge lifecycle. A bounded
@@ -321,8 +307,8 @@ Local Tasks provide:
 - `GET /v1/local-tasks/<id>/stream` for live Server-Sent Events;
 - `POST /v1/local-tasks/<id>/control` with `{"action":"stop"}`;
 - `GET /v1/local-tasks/<id>/artifacts/<artifact-id>` for a verified output;
-- one Provider invocation, a configurable Provider-token safety budget, and a
-  bounded runtime timeout;
+- one Provider invocation with recorded token usage; local token, elapsed-time
+  and attempt counters do not interrupt execution, including restored tasks;
 - restart-safe terminal persistence. An interrupted active task fails closed
   after CLI restart and is never replayed automatically.
 
@@ -706,9 +692,9 @@ evaluated action and marks evidence pending when the code or runtime context
 changes. A non-green table is a checkpoint, not completion: the executor must
 perform feasible authorized repairs, missing verification and bounded waits,
 then re-observe and update the same criteria until the requested endpoint passes.
-A genuine safety/authority/dependency/budget stop remains explicitly unfinished
-with affected IDs and a concrete resumption condition; no automatic budget increase
-or background monitor is implied. Both executor and independent auditor receive
+A genuine safety, authority, dependency or no-progress stop remains explicitly
+unfinished with affected IDs and a concrete resumption condition. No background
+monitor is implied. Both executor and independent auditor receive
 this continuation contract. The [acceptance evidence guide](src/orchestrator/delivery/references/acceptance-evidence.md)
 documents the offline validator shipped inside the CLI runtime. Its result establishes
 record completeness and artifact integrity, not overall delivery or deployment.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.75",
+  "version": "0.5.76",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/cli-contract.js

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

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

@@ -415,8 +415,6 @@ function managedSpec(spec, session, provider, observedProcess, admission, now) {
   const appServerChannel = config.resumeChannel === 'codex_app_server' && admission?.source === 'codex_app_server' && admission.session === session;
   const autoRecovery = config.autoRecovery === true && exactCodexSession && Boolean(resumeModel) &&
     (appServerChannel || config.resumeChannel === 'codex_exec' && Boolean(observedProcess?.identity));
-  if (config.maxTokens !== undefined && !(provider === 'codex' && appServerChannel)) throw new Error('Provider token budgets require the host-observed Codex app-server channel.');
-  if (config.providerTokenCeiling !== undefined && !(provider === 'codex' && appServerChannel)) throw new Error('Provider token ceilings require the host-observed Codex app-server channel.');
   const managed = { taskId: randomUUID(), thread: { provider, id: session },
     actionId: text(config.actionId, 200) || null, actionDueAt, acceptanceCriteria: criteria, verified: {}, remainingWork: text(config.remainingWork, 4000) || null,
     initialAction, proposedAction: initialAction, approvalPolicy, approvalScopes: [...new Set(scopes)].slice(0, 20),
@@ -426,7 +424,7 @@ function managedSpec(spec, session, provider, observedProcess, admission, now) {
     noProgress: 0, verifiedRevision: 0, consumedVerifiedRevision: 0, notification: null, notificationKey: null,
     continuationPolicy: continuationMode(config.continuationPolicy),
     providerTokenCeiling: appServerChannel ? positive(config.providerTokenCeiling, MAX_COMPLETION_TOKENS, MAX_COMPLETION_TOKENS) : null,
-    budgetCapability: { time: true, continuations: true, providerTokens: appServerChannel },
+    budgetCapability: { time: false, continuations: false, providerTokens: appServerChannel, localExecutionLimits: false },
     autoRecovery, resumeModel, autoRecoveryUnavailableReason: config.autoRecovery === true && !autoRecovery ? 'Exact Codex process, session UUID, and resumeModel are required.' : null,
     autoRecoverySandbox: config.autoRecoverySandbox || 'read-only', resumeChannel: config.resumeChannel || null,
     capability: appServerChannel && autoRecovery ? 'codex_app_server' : autoRecovery ? 'codex_exec_resume' : 'live_hook',
@@ -777,9 +775,11 @@ export function prepareRecoveryDiagnosis(run, now = Date.now()) {
 export function deliveryBudgetState(run, now = Date.now(), { checkProgress = true } = {}) {
   const managed = run.managed;
   const progress = managed?.continuationPolicy === 'progress';
-  const deadline = progress ? run.hardDeadline ?? run.startedAt + 1440 * 60_000 : run.deadline;
-  const maxContinuations = progress ? run.hardMaxContinuations ?? 50 : run.maxContinuations;
-  const tokenCeiling = progress ? managed.providerTokenCeiling : managed?.maxTokens;
+  // Historical policies/counters remain immutable, but local elapsed time,
+  // turn count and token usage no longer limit either new or restored tasks.
+  const deadline = Infinity;
+  const maxContinuations = Infinity;
+  const tokenCeiling = null;
   const warnings = [];
   const checkpointDetail = run.checkpoint ? '' : ' No progress checkpoint was recorded.';
   if (progress) {
@@ -788,22 +788,14 @@ export function deliveryBudgetState(run, now = Date.now(), { checkProgress = tru
     if (managed.maxTokens && managed.tokensUsed >= managed.maxTokens) warnings.push('soft_token_limit');
   }
   let reason = null;
-  if (now >= deadline) {
-    reason = progress ? 'Delivery hard time ceiling reached.' : `Delivery time limit exhausted.${checkpointDetail}`;
-  } else if (run.continuations >= maxContinuations) {
-    reason = progress ? 'Delivery hard continuation ceiling reached.' : `Delivery continuation limit exhausted (${run.continuations}/${maxContinuations}).${checkpointDetail}`;
-  } else if (run.failures >= run.maxFailures) {
+  if (run.failures >= run.maxFailures) {
     reason = `Delivery failure limit exhausted (${run.failures}/${run.maxFailures}).${checkpointDetail}`;
-  } else if (managed?.usageBlocked) {
-    reason = `Reliable provider token usage is unavailable; budgeted continuation is blocked.${checkpointDetail}`;
-  } else if (tokenCeiling && managed.tokensUsed >= tokenCeiling) {
-    reason = progress ? 'Provider hard token ceiling reached.' : `Provider token budget exhausted (${managed.tokensUsed}/${tokenCeiling}).${checkpointDetail}`;
   } else if (checkProgress && managed && now - (managed.lastVerifiedProgressAt ?? run.startedAt) >= (managed.maxNoProgressMinutes ?? 30) * 60_000) {
     reason = 'No verified acceptance progress within the configured time limit.';
   } else if (checkProgress && managed && managed.noProgress >= managed.maxNoProgress) {
     reason = 'No verified acceptance progress within the configured continuation limit.';
   }
-  return { continuationPolicy: progress ? 'progress' : 'bounded', deadline, maxContinuations, tokenCeiling, warnings, reason };
+  return { continuationPolicy: progress ? 'progress' : 'bounded', localLimitsRemoved: true, deadline, maxContinuations, tokenCeiling, warnings, reason };
 }
 export function managedBudgetReason(run, now = Date.now(), options) {
   return deliveryBudgetState(run, now, options).reason;
@@ -866,7 +858,7 @@ export function decideStop(run, now = Date.now()) {
     } else { escalate(next, cp.summary); return finish('blocked', cp.summary); }
   }
   const budgetReason = managedBudgetReason(next, now);
-  if (budgetReason) return finish(next.managed?.continuationPolicy === 'progress' && budgetReason.startsWith('No verified') ? 'paused' : 'budget_exhausted', budgetReason);
+  if (budgetReason) return finish(budgetReason.startsWith('No verified') ? 'paused' : 'budget_exhausted', budgetReason);
   const initialHook = next.managed?.awaitingInitialHook && next.revision === 0 && !next.checkpoint;
   const replanHook = next.managed?.capability === 'live_hook' && next.managed.awaitingReplanHook === true;
   const understandingHook = next.managed?.capability === 'live_hook' && (next.managed.awaitingUnderstandingHook === true || next.managed.awaitingAssociationHook === true);
@@ -927,7 +919,7 @@ export function decideStop(run, now = Date.now()) {
   next.reason = fresh ? 'continue_pending_work' : 'checkpoint_missing';
   const selected = next.managed?.autonomyPolicy ? next.managed.decision : null;
   const instruction = selected && next.managed.phase === 'action_association' ? `${associationContract(next.managed.actionAssociation.job)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping.` : selected && next.managed.phase === 'understanding' ? `Understand the current user request in this ORIGINAL conversation. ${next.managed.understandingAnswer ? `The user answered question ${next.managed.understandingAnswer.questionId}: ${next.managed.understandingAnswer.text}. ` : ''}${understandingCheckpointContract(selected)} Submit the JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable. This updates SIMY metadata only; do not create a checkpoint file in the task workspace.` : selected ? `${initialHook ? `Managed objective: ${next.objective}. Frozen acceptance criteria: ${JSON.stringify(next.managed.acceptanceCriteria)}. ` : ''}${replanHook ? `Replan context: ${next.managed.plan.diagnosis}. ` : ''}Execute only selected ${selected.action.kind} action in scope ${selected.action.scope}: ${selected.action.summary}. Expected verification: ${selected.expectedVerification}. Rollback: ${selected.rollback || 'none needed'}. ${assessedCheckpointContract(selected)} Submit that JSON checkpoint through standard input using simy delivery checkpoint --provider ${next.managed.thread.provider} --session ${next.managed.thread.id} --file - before stopping. A shell heredoc is suitable; do not create a task-workspace checkpoint file.` : fresh ? next.nextStep : `Check the actual delivery status first. Record an honest checkpoint with simy delivery checkpoint before stopping; do not claim completion without verification. Pending step: ${next.nextStep}`;
-  return { run: next, output: { decision: 'block', reason: `SIMY Delivery Loop (${next.continuations}/${next.maxContinuations}). ${instruction}\nStay within the original request and permissions. If authorization or information is missing, record a blocked checkpoint and stop. Do not reset budgets or start a replacement loop.` } };
+  return { run: next, output: { decision: 'block', reason: `SIMY Delivery Loop (${next.continuations} continuations). ${instruction}\nStay within the original request and permissions. If authorization or information is missing, record a blocked checkpoint and stop. Resume this same task; do not start a replacement loop.` } };
 }
 // A process signature protects against PID reuse. Never treat a stale timer alone
 // as a crash; an idle provider may be waiting for its user.
@@ -1101,6 +1093,18 @@ export function canChangeDeliveryContinuation(run) {
   return Boolean(run?.managed && ['paused', 'blocked', 'failed', 'budget_exhausted', 'verification_pending', 'recovery_required'].includes(run.state) &&
     !['pending', 'pending_received', 'transferred'].includes(run.managed.handoff?.status));
 }
+function reopenLegacyLimitStop(run, now) {
+  if (run?.state !== 'budget_exhausted' ||
+      managedBudgetReason(run, now, { checkProgress: false }) ||
+      /No verified|failure limit/i.test(run.reason || '') ||
+      run.managed?.noProgress >= run.managed?.maxNoProgress) return;
+  if (run.managed) {
+    run.managed.localLimitMigration ??= { at: now, previousLastVerifiedProgressAt: run.managed.lastVerifiedProgressAt };
+    // Time spent stopped at an obsolete cap is not failed execution progress.
+    run.managed.lastVerifiedProgressAt = now;
+  }
+  run.state = 'paused'; run.reason = 'Local limits removed; resume this same task.';
+}
 export async function controlDelivery({ root = rootDirectory(), provider, session, taskId, approvalId, autonomyPolicy, continuationPolicy, limits, questionId, waitId, answer, action, now = Date.now() }) {
   for (let retry = 0; ; retry += 1) {
     try { return await updateRecord(root, provider, session, record => {
@@ -1109,6 +1113,7 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
     if (run.managed && taskId !== run.managed.taskId) throw new Error('Managed task identity changed; refresh its status.');
     if (['pending', 'pending_received'].includes(run.managed?.handoff?.status)) throw new Error('Task handoff is locked; use delivery handoff_cancel or retry the same target to complete the transfer.');
     if (action !== 'stop' && run.managed?.handoff?.status === 'transferred') throw new Error('Task handoff is locked; continue in the received target session.');
+    reopenLegacyLimitStop(run, now);
     if (action === 'extend' || action === 'continuation_policy') {
       if (!canChangeDeliveryContinuation(run)) throw new Error('Pause a managed task before changing its continuation bounds.');
       if (action === 'continuation_policy') {
@@ -1297,10 +1302,11 @@ export async function reconcileRecords({ root = rootDirectory(), now = Date.now(
     // Paused runs have no reconciliation transition: budget enforcement excludes
     // them, process-exit checks only apply to active runs, and no notification
     // is generated. Resume/control still reread and validate the exact record.
-    if (!record.run || TERMINAL.has(record.run.state) || record.run.state === 'paused') { reconciled.push(record); continue; }
+    if (!record.run || TERMINAL.has(record.run.state) && record.run.state !== 'budget_exhausted' || record.run.state === 'paused') { reconciled.push(record); continue; }
     const observed = record.process ? await inspectProcess(record.process.pid) : null;
     const next = await updateRecord(root, record.provider, record.session, async current => {
-      if (!current?.run || TERMINAL.has(current.run.state)) return current;
+      reopenLegacyLimitStop(current?.run, now);
+      if (!current?.run || TERMINAL.has(current.run.state) || current.run.state === 'paused') return current;
       const run = current.run;
       if (run.state === 'verification_pending' && run.managed) {
         await verifyAutomaticCriteria(current, now);
@@ -1308,12 +1314,12 @@ export async function reconcileRecords({ root = rootDirectory(), now = Date.now(
           run.state = 'completed'; run.reason = run.checkpoint.summary; run.updatedAt = now;
         }
       }
-      const activeTurn = run.managed?.continuationPolicy === 'progress' &&
+      const activeTurn = run.managed &&
         (run.state === 'auto_resuming' || current.runtime?.isRunning === true || run.managed.executionAttempt?.phase === 'dispatching');
       const budgetState = deliveryBudgetState(run, now, { checkProgress: !activeTurn });
       run.budgetWarnings = budgetState.warnings;
       if (budgetState.reason && !TERMINAL.has(run.state) && !['verification_pending', 'paused'].includes(run.state)) {
-        run.state = run.managed?.continuationPolicy === 'progress' && budgetState.reason.startsWith('No verified') ? 'paused' : 'budget_exhausted';
+        run.state = budgetState.reason.startsWith('No verified') ? 'paused' : 'budget_exhausted';
         run.reason = budgetState.reason; run.updatedAt = now;
       }
       else if (run.state === 'active' && observed !== null && observed !== current.process?.identity && current.process?.identity === record.process?.identity) {

package/src/codex-plugins/simy/skills/delivery-loop/SKILL.md

@@ -24,8 +24,8 @@ For missing information use `blocker: "missing_information"`. For a failed attem
 
 For completed work use `{"status":"completed","summary":"Actual result","acceptanceMet":true,"evidence":["Exact checks and observed results"]}` only after checking the user's acceptance criteria. Evidence is a report, not independent certification: preserve failed checks and deployment gaps. The hook must not infer success from optimistic closing text.
 
-4. The Stop hook evaluates checkpoints and supplies the next instruction within the original budgets. Missing checkpoints consume the failure budget. A human interrupt stops the loop. Approval/input events block it. Provider errors/exits may require reopening the existing conversation; these hooks cannot restart a dead provider process.
-5. After the user explicitly resolves the blocker and requests continuation, `simy delivery resume --provider <provider> --session <id>` retains all budgets. `simy delivery stop` permanently ends this loop. `simy delivery status` shows observed hook activity and loop states; old observations do not prove hooks remain enabled today.
+4. The Stop hook evaluates checkpoints and supplies the next instruction within the original scope while progress is verified. Missing checkpoints count toward the repeated-failure circuit. A human interrupt stops the loop. Approval/input events block it. Provider errors/exits may require reopening the existing conversation; these hooks cannot restart a dead provider process.
+5. After the user explicitly resolves the blocker and requests continuation, `simy delivery resume --provider <provider> --session <id>` retains usage, failure and progress history; local time, turn and token counters do not stop work. `simy delivery stop` permanently ends this loop. `simy delivery status` shows observed hook activity and loop states; old observations do not prove hooks remain enabled today.
 
 If the user selected **Continue this conversation** in SIMY desktop, the exact session already has a managed task. Do not run `delivery start` or ask the user to restate its goal. Follow the Stop hook's distinct `session_understanding` contract first: inspect only the original conversation context, report the original user goal and grounded progress, and submit the JSON checkpoint via `--file -`. Do not execute the next assessed work action during understanding. If context is materially unclear, report one focused question and wait for a matching `session_answer`; generic Resume is insufficient. A model-reported finished goal without an independent check is shown as `reported_done`, not verified `completed`.
 
@@ -41,6 +41,6 @@ File checks prove only the stated file predicate: `file_equals` compares complet
 
 Cold recovery is **off by default**. Only when the user explicitly authorizes exact-session Codex CLI recovery, add `"autoRecovery":true,"resumeChannel":"codex_exec","resumeModel":"<exact model>","autoRecoverySandbox":"read-only"` (or an explicitly authorized `workspace-write`). An exact Codex UUID and observed process identity are also required; otherwise recovery stays manual. The recovered process returns a structured final checkpoint that SIMY validates and persists. It must not edit SIMY state directly. Claude and ordinary SessionEnd remain manual paths. Token usage is not measured by these hooks.
 
-For an explicitly requested autonomous managed task, also enroll `"autonomyPolicy":"strict"|"balanced"|"autonomous"` and an `initialPlan` before work begins. Example initialPlan: `{"diagnosis":"Inspect input before repair","alternatives":[{"id":"inspect","action":{"kind":"read","scope":"repository","summary":"Inspect input.json"},"assessment":{"risk":"low","reversibility":"reversible","externalEffect":"none","blastRadius":"single_file","uncertainty":"low","inObjective":true,"userChoice":false},"expectedVerification":"Observe ready field","rollback":"No changes"}],"selectedOptionId":"inspect","recommendation":{"optionId":"inspect","reason":"Need evidence before editing"}}`. `initialAction` must exactly match the selected option and its scope must be enrolled in `approvalScopes`. For each subsequent action, report `actionResult:{decisionId,status:"observed"|"failed"|"not_run",summary,evidence}` for the current decision and a `plan` with diagnosis, one to five assessed alternatives, selectedOptionId, and recommendation for the **next** action. Never execute the next alternative in the current turn. Use only action kinds `read`, `local_edit`, `local_test`, `external`, `destructive`, `scope_change`, `unknown`; use `local_edit` for writing local files. Missing assessment facts, external/destructive effects, user choice, or unapproved scope wait. A recommendation is advisory, not an authorization. Worker reports are not independent acceptance verification. If an automatic file criterion is missing after claimed completion, SIMY schedules bounded read-only diagnosis; manual criteria still require the user. Task policy can be changed with `simy delivery set_policy --provider ... --session ... --task-id ... --autonomy-policy strict|balanced|autonomous`, which preserves budgets and scopes. Provider permissions remain authoritative.
+For an explicitly requested autonomous managed task, also enroll `"autonomyPolicy":"strict"|"balanced"|"autonomous"` and an `initialPlan` before work begins. Example initialPlan: `{"diagnosis":"Inspect input before repair","alternatives":[{"id":"inspect","action":{"kind":"read","scope":"repository","summary":"Inspect input.json"},"assessment":{"risk":"low","reversibility":"reversible","externalEffect":"none","blastRadius":"single_file","uncertainty":"low","inObjective":true,"userChoice":false},"expectedVerification":"Observe ready field","rollback":"No changes"}],"selectedOptionId":"inspect","recommendation":{"optionId":"inspect","reason":"Need evidence before editing"}}`. `initialAction` must exactly match the selected option and its scope must be enrolled in `approvalScopes`. For each subsequent action, report `actionResult:{decisionId,status:"observed"|"failed"|"not_run",summary,evidence}` for the current decision and a `plan` with diagnosis, one to five assessed alternatives, selectedOptionId, and recommendation for the **next** action. Never execute the next alternative in the current turn. Use only action kinds `read`, `local_edit`, `local_test`, `external`, `destructive`, `scope_change`, `unknown`; use `local_edit` for writing local files. Missing assessment facts, external/destructive effects, user choice, or unapproved scope wait. A recommendation is advisory, not an authorization. Worker reports are not independent acceptance verification. If an automatic file criterion is missing after claimed completion, SIMY schedules bounded read-only diagnosis; manual criteria still require the user. Task policy can be changed with `simy delivery set_policy --provider ... --session ... --task-id ... --autonomy-policy strict|balanced|autonomous`, which preserves usage history, approvals and scopes. Provider permissions remain authoritative.
 
 In assessed mode, a blocked authorization checkpoint must also include an assessed `plan` whose selected action exactly matches `approval:{kind,scope,summary}` and a concrete `nextStep`. A missing-information blocker must include a specific `question` for the user. Do not turn a provider approval prompt into an automatic scheduling grant, even for a normally low-risk action. Resume only after the exact user decision; low-risk enrolled actions already allowed by the policy do not need an additional SIMY approval.

package/src/console/app.js

@@ -991,9 +991,8 @@ function buildRunDetailRows(run, width) {
   };
 
   const attemptNumber = run.snapshot.attempts.length + (run.child ? 1 : 0);
-  const maxAttempts = run.snapshot.charter?.max_attempts;
   add(
-    `${executorLabel(run.request.backend)} · Attempt ${attemptNumber}${maxAttempts ? `/${maxAttempts}` : ""} · PID ${run.child?.pid ?? "—"}`,
+    `${executorLabel(run.request.backend)} · Attempt ${attemptNumber} · PID ${run.child?.pid ?? "—"}`,
     { dimColor: true },
   );
   add(`${run.request.repository} · ${run.request.base_branch || run.snapshot.charter?.base_branch || "dev"}`, {

package/src/delivery-hooks/command.js

@@ -22,7 +22,7 @@ export async function runDeliveryCommand(argv, { root = rootDirectory(), cwd = p
     output('simy delivery continuation_policy --provider PROVIDER --session ID --task-id ID --continuation-policy bounded|progress');
     output('simy delivery extend --provider PROVIDER --session ID --task-id ID --hard-max-minutes N|--hard-max-continuations N|--provider-token-ceiling N');
     output('simy delivery continue --provider codex|claude --session ID [--max-no-progress-minutes 30] [--max-tokens N (Codex only)]\nsimy delivery dependency_ready --provider PROVIDER --session ID --task-id ID --wait-id ID --answer TEXT\nsimy delivery handoff|handoff_cancel --provider codex --session ID --task-id ID --target-session ID');
-    output('simy delivery start --provider codex|claude --session ID --objective TEXT --next-step TEXT [--managed-file task.json] [--max-continuations 6] [--max-failures 3] [--max-minutes 30]\nsimy delivery checkpoint --provider codex|claude --session ID --file checkpoint.json|-\nsimy delivery status\nsimy delivery stop|pause|resume --provider codex|claude --session ID [--task-id ID]\nsimy delivery replan --provider PROVIDER --session ID --task-id ID\nsimy delivery approve|reject --provider PROVIDER --session ID --task-id ID --approval-id ID\nsimy delivery verify --provider PROVIDER --session ID --task-id ID --criterion-id ID\nsimy delivery set_policy --provider PROVIDER --session ID --task-id ID --autonomy-policy strict|balanced|autonomous\nEnable and review SIMY hooks in your provider first. Manual managed start requires an acceptance specification. Desktop Continue infers the original conversation goal first. Resume preserves original budgets.');
+    output('simy delivery start --provider codex|claude --session ID --objective TEXT --next-step TEXT [--managed-file task.json] [--max-continuations 6] [--max-failures 3] [--max-minutes 30]\nsimy delivery checkpoint --provider codex|claude --session ID --file checkpoint.json|-\nsimy delivery status\nsimy delivery stop|pause|resume --provider codex|claude --session ID [--task-id ID]\nsimy delivery replan --provider PROVIDER --session ID --task-id ID\nsimy delivery approve|reject --provider PROVIDER --session ID --task-id ID --approval-id ID\nsimy delivery verify --provider PROVIDER --session ID --task-id ID --criterion-id ID\nsimy delivery set_policy --provider PROVIDER --session ID --task-id ID --autonomy-policy strict|balanced|autonomous\nEnable and review SIMY hooks in your provider first. Manual managed start requires an acceptance specification. Desktop Continue infers the original conversation goal first. Resume preserves original task identity, usage history and approvals; local time, turn and token counters do not stop work.');
     return 0;
   }
   const options = {};

package/src/delivery-hooks/desktop.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { canChangeDeliveryContinuation, canReplanDelivery, deliveryBudgetState, managedBudgetReason, reconcileRecords, rootDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { canReplanDelivery, deliveryBudgetState, managedBudgetReason, 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,12 +31,13 @@ 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: r.run.maxContinuations, deadline: r.run.deadline,
+      continuations: r.run.continuations, maxContinuations: null, deadline: null,
+      localExecutionLimits: false,
       continuationPolicy: r.run.managed?.continuationPolicy || 'bounded',
       startedAt: r.run.startedAt,
       continuationLimits: deliveryBudgetState(r.run, now),
-      canChangeContinuation: canChangeDeliveryContinuation(r.run),
-      hardDeadline: r.run.hardDeadline || null, hardMaxContinuations: r.run.hardMaxContinuations || null,
+      canChangeContinuation: false,
+      hardDeadline: null, hardMaxContinuations: null,
       budgetWarnings: deliveryBudgetState(r.run, now).warnings,
       budgetCapability: r.run.managed?.budgetCapability || null,
       outcomeProgress: r.run.managed?.outcomeProgress || null,

package/src/delivery-hooks/supervisor.js

@@ -29,7 +29,9 @@ function watchLease(root, provider, session, inspect, onFailure) {
       if (!stopped) inspect(record);
     }).catch(() => { if (!stopped) onFailure(); }).finally(() => { reading = false; });
   }, 500);
-  timer.unref();
+  // An owned turn must stay alive until it settles or the lease cancels it.
+  // This watch is cleared in the execution's finally block; unlike the removed
+  // budget deadline, it does not impose a time limit on active work.
   return () => { stopped = true; clearInterval(timer); };
 }
 async function assertActiveLease(root, provider, session, leaseId, signal, currentTime = Date.now) {
@@ -79,7 +81,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
     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,
-      softDeadline: run.deadline, softMaxContinuations: run.maxContinuations } };
+      localExecutionLimits: false } };
   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];
@@ -87,7 +89,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
   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.');
-  if (currentTime() >= run.deadline) throw new Error('Managed recovery deadline expired before provider dispatch.');
+
   return new Promise((resolve, reject) => {
     const child = spawn(binary, args, { cwd: record.cwd, stdio: ['ignore', 'pipe', 'pipe'], signal,
       env: { ...process.env, SIMY_HOME: dirname(root) } });
@@ -196,7 +198,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       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 = 'budget_exhausted'; live.reason = budgetReason; live.updatedAt = currentTime(); notifyState(live, live.updatedAt); return current;
+        live.state = budgetReason.startsWith('No verified') ? 'paused' : 'failed'; live.reason = budgetReason; 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 } };
@@ -216,13 +218,11 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     let resource;
     let lastActivityAt = currentTime();
     let usage = null;
-    let tokenBudgetExceeded = false;
     let dispatched = false, waitingForTool = false;
     const controller = new AbortController();
     const abort = () => controller.abort();
     if (signal?.aborted) controller.abort();
     else signal?.addEventListener('abort', abort, { once: true });
-    const timeout = setTimeout(abort, Math.max(1, managedDispatchDeadline(claimed.run) - currentTime()));
     const stopWatch = watchLease(root, record.provider, record.session, current => {
       if (current?.run?.state !== 'auto_resuming' || current.run.managed?.resumeLease?.id !== leaseId ||
         managedBudgetReason(current.run, currentTime(), { checkProgress: false }) || !waitingForTool && currentTime() - lastActivityAt >= 5 * 60_000) controller.abort();
@@ -264,10 +264,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
           onActivity: observation => { lastActivityAt = currentTime(); waitingForTool = observation?.waitingForTool === true; },
           onUsage: observed => {
             usage = observed;
-            const tokenCeiling = deliveryBudgetState(claimed.run).tokenCeiling;
-            if (tokenCeiling && (claimed.run.managed.tokensUsed || 0) + observed.tokens >= tokenCeiling) {
-              tokenBudgetExceeded = true; controller.abort();
-            }
+
           },
           beforeDispatch: async providerSandbox => {
             await assertActiveLease(root, record.provider, record.session, leaseId, controller.signal, currentTime);
@@ -299,7 +296,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
       ? { code: -3, busy: true, accessDenied: true }
       : { code: controller.signal.aborted ? -2 : -1, cancelled: controller.signal.aborted,
         errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }
-    finally { clearTimeout(timeout); stopWatch(); signal?.removeEventListener('abort', abort); }
+    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 };
@@ -330,6 +327,7 @@ 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;
@@ -360,14 +358,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         live.updatedAt = Date.now(); notifyState(live, live.updatedAt); return current;
       }
       live.budgetWarnings = deliveryBudgetState(live).warnings;
-      const tokenCeiling = deliveryBudgetState(live).tokenCeiling;
-      if (tokenBudgetExceeded || tokenCeiling && live.managed.tokensUsed >= tokenCeiling) {
-        live.state = 'budget_exhausted'; live.managed.autoRecovery = false;
-        live.reason = 'Observed provider token budget exhausted; inspect any interrupted action in the original conversation.';
-      } else if (live.managed.usageBlocked) {
-        live.state = 'recovery_required'; live.managed.autoRecovery = false;
-        live.reason = 'Provider usage was unavailable; token-budgeted continuation cannot safely start another turn.';
-      } else if (result.busy) {
+      if (result.busy) {
         if (result.accessDenied && dispatched) {
           // The final guard rejected before the provider call. Keep its one-shot approval unused.
           if (live.managed.approvedAction?.id === live.managed.decision?.id) delete live.managed.approvedAction.dispatchedAt;

package/src/local-task.js

@@ -568,7 +568,6 @@ export async function startLocalTask(
 
   return new Promise((resolve, reject) => {
     let settled = false;
-    let timeout = null;
     const rawStdout = [];
     const tokenRecords = [];
     let child;
@@ -617,21 +616,12 @@ export async function startLocalTask(
         continuation_policy: task.continuation_policy || "bounded",
         provider_token_ceiling: localTaskTokenCeiling(task),
       });
-      if (task.continuation_policy === "progress" && task.provider_tokens_used >= task.provider_token_budget && !task.token_warning_emitted) {
+      if (task.provider_tokens_used >= task.provider_token_budget && !task.token_warning_emitted) {
         task.token_warning_emitted = true;
-        task.warnings.push("Provider token notification threshold reached. Work continues within the approved task and hard safety ceiling.");
+        task.warnings.push("Provider token notification threshold reached. Work continues within the approved task; local usage does not stop execution.");
         emitTaskEvent(task, "budget_warning", { provider_tokens_used: task.provider_tokens_used, provider_token_budget: task.provider_token_budget, provider_token_ceiling: localTaskTokenCeiling(task) });
       }
-      if (
-        localTaskTokensExhausted(task) &&
-        !task.stop_requested
-      ) {
-        task.reason_code = "provider_token_budget_exhausted";
-        task.error = `Provider token ${task.continuation_policy === "progress" ? "hard ceiling" : "budget"} exceeded (${task.provider_tokens_used} / ${localTaskTokenCeiling(task)}).`;
-        task.stop_requested = true;
-        task.control_state = "stopping";
-        signalExecutorProcess(child, "SIGINT");
-      }
+
     };
     const stdoutDecoder = createProviderStreamDecoder({
       backend: task.backend,
@@ -656,28 +646,12 @@ export async function startLocalTask(
     });
     child.stderr?.on("data", (chunk) => stderrDecoder.push(chunk.toString("utf8")));
 
-    timeout = setTimeout(() => {
-      if (settled || task.stop_requested) return;
-      task.reason_code = "provider_timeout";
-      task.error = `Local Task exceeded its ${task.timeout_ms}ms timeout.`;
-      task.stop_requested = true;
-      task.control_state = "stopping";
-      emitTaskEvent(task, "status", {
-        state: "stopping",
-        reason_code: task.reason_code,
-        message: "The Local Task timed out and is stopping.",
-      });
-      signalExecutorProcess(child, "SIGINT");
-      setTimeout(() => {
-        if (!settled && task.child === child) signalExecutorProcess(child, "SIGTERM");
-      }, 1_500).unref?.();
-    }, task.timeout_ms);
-    timeout.unref?.();
+    // timeout_ms is retained as legacy request metadata. Elapsed local execution
+    // no longer cancels a task; explicit user cancellation remains authoritative.
 
     const finish = async ({ exitCode = null, error = null } = {}) => {
       if (settled) return;
       settled = true;
-      if (timeout) clearTimeout(timeout);
       stdoutDecoder.flush();
       stderrDecoder.flush();
       task.child = null;
@@ -740,8 +714,7 @@ export async function startLocalTask(
       const failed =
         Boolean(error) ||
         exitCode !== 0 ||
-        Boolean(task.error) ||
-        localTaskTokensExhausted(task);
+        Boolean(task.error);
       task.status = manuallyStopped ? "stopped" : failed ? "failed" : "succeeded";
       task.control_state = task.status === "stopped" ? "stopped" : "complete";
       task.error ||= error || (exitCode !== 0 ? `Provider exited with code ${exitCode}.` : null);
@@ -1299,13 +1272,8 @@ function normalizeExpectedOutputs(value) {
     }));
 }
 
-function localTaskTokenCeiling(task) {
-  return task.continuation_policy === "progress" ? normalizeTokenBudget(task.provider_token_ceiling ?? MAX_LOCAL_TASK_TOKEN_BUDGET) : task.provider_token_budget;
-}
-
-function localTaskTokensExhausted(task) {
-  const ceiling = localTaskTokenCeiling(task);
-  return task.continuation_policy === "progress" ? task.provider_tokens_used >= ceiling : task.provider_tokens_used > ceiling;
+function localTaskTokenCeiling() {
+  return null;
 }
 
 function normalizeTokenBudget(value) {

package/src/orchestrator/budget.js

@@ -67,7 +67,7 @@ export function extendProgressCeilings(snapshot, changes = {}) {
   const provided = Object.entries(changes).filter(([, value]) => value !== undefined);
   if (!provided.length) throw new Error("Explicitly increase at least one hard ceiling.");
   for (const [field, value] of provided) {
-    const previous = field === "provider_token_ceiling" ? current.hard_token_ceiling : current.hard_attempt_ceiling;
+    const previous = field === "provider_token_ceiling" ? snapshot.charter.provider_token_ceiling : snapshot.charter.attempt_ceiling;
     const used = field === "provider_token_ceiling" ? current.tokens_used : (snapshot.attempts || []).length;
     if (!Number.isSafeInteger(value) || value <= previous || value <= used) {
       throw new Error("Each requested hard ceiling must be an integer higher than its current limit and recorded usage.");
@@ -97,11 +97,12 @@ export function budgetState(snapshot, pendingAttempt = null) {
   const attemptsUsed = attempts.length;
   const retriesUsed = Math.max(attemptsUsed - 1, 0);
   const policy = progressLimits(snapshot?.charter);
-  const progress = policy.continuation_policy === "progress";
-  const hardTokenCeiling = progress ? policy.provider_token_ceiling : tokenBudget;
-  const hardAttemptCeiling = progress ? policy.attempt_ceiling : retryBudget + 1;
-  const tokenExhausted = tokensUsed >= hardTokenCeiling;
-  const retryExhausted = attemptsUsed >= hardAttemptCeiling;
+  // Persisted thresholds remain readable for old contracts and usage reports.
+  // Local work stops on failed progress/approval, never on consumption counters.
+  const hardTokenCeiling = null;
+  const hardAttemptCeiling = null;
+  const tokenExhausted = false;
+  const retryExhausted = false;
   return {
     schema_version: 1,
     token_budget: tokenBudget,
@@ -119,11 +120,12 @@ export function budgetState(snapshot, pendingAttempt = null) {
         ? "retry_budget_exhausted"
         : null,
     continuation_policy: policy.continuation_policy,
-    token_warning: progress && tokensUsed >= tokenBudget,
-    retry_warning: progress && attemptsUsed >= retryBudget + 1,
+    local_limits_removed: true,
+    token_warning: tokensUsed >= tokenBudget,
+    retry_warning: attemptsUsed >= retryBudget + 1,
     hard_token_ceiling: hardTokenCeiling,
     hard_attempt_ceiling: hardAttemptCeiling,
-    hard_tokens_remaining: Math.max(hardTokenCeiling - tokensUsed, 0),
+    hard_tokens_remaining: null,
   };
 }
 
@@ -144,19 +146,12 @@ export function refreshBudgetState(snapshot, pendingAttempt = null) {
   return state;
 }
 
-export function canStartProvider(snapshot, { attemptNumber, phase }) {
-  const state = refreshBudgetState(snapshot);
-  if (state.token_exhausted) {
-    return { allowed: false, reason: "token_budget_exhausted", budget: state };
-  }
-  if (phase === "executor" && attemptNumber > state.hard_attempt_ceiling) {
-    return { allowed: false, reason: "retry_budget_exhausted", budget: state };
-  }
-  return { allowed: true, reason: null, budget: state };
+export function canStartProvider(snapshot) {
+  return { allowed: true, reason: null, budget: refreshBudgetState(snapshot) };
 }
 
-export function codingAttemptCeiling(snapshot) {
-  return snapshot?.charter?.continuation_policy === "progress" ? budgetState(snapshot).hard_attempt_ceiling : snapshot?.charter?.max_attempts;
+export function codingAttemptCeiling() {
+  return Infinity;
 }
 
 export function tokenUsageTotal(value) {

package/src/orchestrator/checklist-continuation.js

@@ -10,10 +10,10 @@ export function buildChecklistContinuationInstruction({ auditor = false } = {})
     `The table is a progress checkpoint, not the deliverable or a stopping condition. Read: ${ACCEPTANCE_EVIDENCE_PATH}`,
     "Maintain the complete 依頼チェックリスト with columns #, ご依頼, 現状, 判定 in the evidence record after chartering, each evaluated attempt, and in the final receipt. User-facing reporting follows workflow_reporting_contract; show the full table only when requested or when it is the most useful requested answer, never as mandatory commentary. Preserve stable criterion IDs, all rows and both applicable evidence layers. ✅ requires current valid passing evidence for every applicable layer; ❌ means an observed failure; 🟡 means pending, missing, stale, blocked or unverifiable evidence. Retain counts and highest proven state in that record.",
     "After observing any non-green row, classify its cause and immediately take the next safe authorized action: implement missing behavior, repair a failure, exercise an untested path, collect missing evidence, or rerun stale verification. Re-observe the same criterion against the current candidate, run the validator, update the table, and repeat until every applicable requested outcome and gate for the authorized endpoint is verified. A next-action list without performing feasible actions is not completion. Never require another continue request merely because a table was shown.",
-    "For CI or other in-progress dependencies, use the available bounded wait/recheck or approved monitoring mechanism and maintain progress communication. Unchanged external state is not itself a blocker. Do not start duplicate jobs or busy-poll. Recheck current revision/results, repair authorized failures, and keep waiting only within the existing time, attempt and cost limits. If waiting cannot continue, report the concrete limit and explicit resumption condition; do not silently abandon it or promise an unscheduled follow-up.",
-    "If a row genuinely requires new authority, credentials, a user/product decision, an unavailable dependency or an exhausted safety budget, retain it as non-green and record affected IDs, evidence of the blocker, safe alternatives attempted, exact missing input, owner and resumption trigger. Continue independent in-scope work. Stop with blocked, best_available, failed or cancelled as appropriate, explicitly unfinished, not verified_complete. Never raise budgets, bypass a stop, or expand authority to force green.",
+    "For CI or other in-progress dependencies, use the available bounded wait/recheck or approved monitoring mechanism and maintain progress communication. Unchanged external state is not itself a blocker. Do not start duplicate jobs or busy-poll. Recheck current revision/results, repair authorized failures, and keep waiting only within the authorized scope and external service availability. If waiting cannot continue, report the concrete limit and explicit resumption condition; do not silently abandon it or promise an unscheduled follow-up.",
+    "If a row genuinely requires new authority, credentials, a user/product decision, an unavailable dependency or a repeated-failure or no-progress safety circuit, retain it as non-green and record affected IDs, evidence of the blocker, safe alternatives attempted, exact missing input, owner and resumption trigger. Continue independent in-scope work. Stop with blocked, best_available, failed or cancelled as appropriate, explicitly unfinished, not verified_complete. Never bypass a manual stop, approval, or expand authority to force green.",
     "Do not end successfully while a safe authorized repair, verification or bounded wait remains. All-green applies to the frozen authorized endpoint: PR-only work does not authorize merge/deploy, but a PR URL, an improvement PR, an issue, a narrower test or a future plan does not satisfy an unmet outcome. Never drop/merge away rows, weaken criteria, relabel applicable checks as not_applicable, recolor unknowns, or copy new digests onto old evidence to force green. Do not change the requested endpoint to match the work already completed.",
-    "Before the final response, independently reconcile the original request with all criterion IDs and current evidence, check remaining endpoint gates, and preserve the full table and explicit disposition in the evidence record. Distinguish a partial artifact from verified completion and disclose material remaining outcomes in the requested response format; keep yellow/red counts in the record. A pr_ready_for_review or blocked controller state is not proof of overall completion. These instructions strengthen continuation and reporting; they do not add a background scheduler or remove controller limits.",
+    "Before the final response, independently reconcile the original request with all criterion IDs and current evidence, check remaining endpoint gates, and preserve the full table and explicit disposition in the evidence record. Distinguish a partial artifact from verified completion and disclose material remaining outcomes in the requested response format; keep yellow/red counts in the record. A pr_ready_for_review or blocked controller state is not proof of overall completion. These instructions strengthen continuation and reporting; they do not add a background scheduler or remove approval, manual-stop and progress protections.",
     auditor
       ? "Remain read-only. Check that the executor performed feasible follow-up actions after non-green tables. Report premature stopping, omitted rows, unsupported green claims, or a blocker without evidence as findings, alongside exact criterion IDs and the necessary next action. Do not approve from a table's colors or the executor's completion wording."
       : "Execute the continuation within this attempt instead of merely returning a yellow table or delegating feasible remaining work to the requester. Return control honestly at a genuine boundary; never fabricate completion evidence.",

package/src/orchestrator/delivery/WORKFLOW.md

@@ -119,8 +119,9 @@ Before material action, record:
 - exclusions and authority boundaries, especially commit, push, Draft PR
   creation or update, Ready transitions, merge, deployment, production writes,
   paid APIs, external messages, and fixture cleanup;
-- attempt, time, and cost budgets. Default to at most three evaluated repair
-  attempts when the user has not set a budget.
+- recorded usage and any external service limits. Local execution has no token,
+  elapsed-time or attempt ceiling, including restored tasks. Continue while
+  making verified progress; respect approvals, manual stops and failure circuits.
 
 Do not silently weaken explicit conditions. Add discoveries as a charter patch.
 A scope or success-condition change needs user direction when it materially
@@ -194,7 +195,7 @@ JSON authority or evidence. Finish the visible table with counts for green,
 yellow, and red rows plus the highest proven state. In a terminal
 receipt, add the controller's disposition immediately below it.
 Treat making every applicable row green as the repair target within the frozen
-scope and attempt budget, but never recolor, omit, merge away, or relax a row to
+scope and permissions, but never recolor, omit, merge away, or relax a row to
 make the presentation green.
 
 ### Continue after the table; do not stop at yellow
@@ -212,19 +213,19 @@ not completion; do not wait for the requester to say “continue” after each t
 
 For in-progress CI or dependencies, use available bounded wait/recheck or an
 approved monitor, with progress updates and no duplicate jobs or busy-polling.
-Unchanged external state alone is not a blocker. Honor existing time, attempt and
-cost limits; record a reached limit and resumption condition instead of promising
+Unchanged external state alone is not a blocker. Local token, elapsed-time and attempt counters do not stop work. Respect
+external service availability and record any actual blocker and resumption condition instead of promising
 an unscheduled follow-up. This workflow does not itself install a scheduler.
 
-When genuinely blocked by authority, access, a decision, dependency or safety
-budget, preserve each affected ID, observed blocker, attempted safe alternatives,
+When genuinely blocked by authority, access, a decision, dependency or triggered no-progress/repeated-failure
+circuit, preserve each affected ID, observed blocker, attempted safe alternatives,
 exact missing input, owner and resumption trigger. Continue independent authorized
 work. Any terminal non-green table is explicitly unfinished with a justified
 blocked/best_available/failed/cancelled disposition, never verified_complete.
 Do not use best_available merely because a table, PR or plan now exists. A new
 remediation PR transfers ownership, not acceptance; the original unmet row stays
 non-green. All-green targets only the authorized endpoint, not unrequested merge
-or deployment. Never weaken criteria or raise budgets to force green.
+or deployment. Never weaken acceptance criteria to force green. Local token, time and attempt counters do not stop work; continue while verified progress improves.
 
 Before the final response, reconcile original requirements, all IDs, current
 evidence and endpoint gates; retain the full table, counts, highest proven state
@@ -454,7 +455,7 @@ For a Codex Desktop task whose requested outcome must be checked after the
 conversation ends, register a Codex app heartbeat against that task before
 claiming it is monitored. Preserve the original outcome, acceptance evidence,
 the exact task or operation identity, the requested completion boundary, and
-the response preferences, cadence, time/attempt/cost limits, and stop or
+the response preferences, cadence, progress protections and external service limits, and stop or
 ask-user conditions in the heartbeat prompt. Verify that the automation
 is active and bound to the intended task. On each run, use the Codex app's
 supported task status and wait/read operations to distinguish a queued creation
@@ -464,7 +465,7 @@ operation before any retry; do not create a replacement while its fate is
 unknown. Report an actionable blocker if identity, access, or evidence cannot
 be resolved. Stay quiet on unchanged non-actionable state, and stop the
 heartbeat when the accepted outcome is proved or monitoring is explicitly
-cancelled. On authoritative failure, exhausted limits, or an unresolved
+cancelled. On authoritative failure, external service limits or repeated failures, or an unresolved
 terminal identity/access blocker, report the evidence and pause or stop the
 heartbeat pending a human decision. This is a separately registered,
 task-scoped Codex app monitor;
@@ -495,7 +496,7 @@ For each attempt:
 6. **Reduce:** append a typed receipt and atomically advance the snapshot.
 
 An LLM may propose hypotheses, repairs, or verdicts, but it must not directly
-override state transitions, retry budgets, authorization, or evidence gates.
+override state transitions, progress protections, authorization, or evidence gates.
 Only the controller promotes a candidate or terminalizes the run.
 
 Read [state and receipts](references/state-and-receipts.md) when the task has
@@ -712,13 +713,13 @@ action planning belongs to a separate workflow.
 Use exactly one disposition:
 
 - `verified_complete`: every applicable gate passed with evidence;
-- `best_available`: the bounded loop produced a safe useful result but named
+- `best_available`: the loop produced a safe useful result but named
   criteria remain unmet;
 - `blocked`: missing authority, input, dependency, or safety precondition
   prevents progress;
-- `failed`: no safe useful candidate remains within budget;
+- `failed`: no safe useful candidate can make further verified progress;
 - `cancelled`: the user stopped or replaced the task.
 
-Stop after the attempt budget, two consecutive non-improving candidates, or an
+Stop after two consecutive non-improving candidates or an
 A-B-A failure pattern without a materially different safe repair. Deliver the
 best verified candidate, not merely the latest attempt.

package/src/orchestrator/delivery/references/acceptance-evidence.md

@@ -80,16 +80,16 @@ After every evaluated action (test, repair, review or changed inputs):
 
 Yellow and red tables are progress, not successful delivery. For in-progress
 dependencies use available bounded waits/rechecks or approved monitoring without
-busy-polling or duplicate jobs. Preserve time/attempt/cost limits and keep the
+busy-polling or duplicate jobs. Preserve authorization and progress checks; local time/attempt/token counters are informational and keep the
 requester informed. If progress genuinely requires new authority, access, a
-decision, dependency availability or budget, retain affected rows and record
+decision, dependency availability or a triggered no-progress/failure circuit, retain affected rows and record
 observed blocker, safe alternatives tried, exact missing input, owner and resume
 trigger. Continue independent work; end only with an explicitly unfinished
 disposition when no further safe in-scope action remains or a safety/user stop
 applies. Do not require another “continue” for already authorized feasible work.
 An issue or remediation PR does not satisfy the row it tracks. Do not weaken
-criteria, hide rows, invent evidence, change the endpoint or raise budgets to
-force green. Reconcile the final full table against the original request and all
+criteria, hide rows, invent evidence or change the endpoint to
+force green. Local execution counters do not impose a completion limit. Reconcile the final full table against the original request and all
 current endpoint gates before reporting verified_complete.
 
 All rows, including pending/failed ones, stay visible. A green matrix cannot advance

package/src/orchestrator/delivery/references/chrome-user-verification.md

@@ -101,7 +101,7 @@ Codex may orchestrate the full sequence in one task:
    queue/worker activity, and artifact hashes.
 7. Evaluate the evidence against the frozen charter.
 8. On failure, classify the boundary, add a pre-fix regression, patch the
-   smallest surface, rebuild changed images, and repeat within budget.
+   smallest surface, rebuild changed images, and repeat within the authorized scope while verification improves.
 
 The same Codex task may perform actor and verifier phases, but the verifier must
 use recorded observable evidence rather than accepting the actor's completion

package/src/orchestrator/delivery/references/desktop-monitor-triggers.md

@@ -14,7 +14,7 @@ registration. A scheduler firing is an observation, not delivery progress.
 | Pending creation remains unresolved after the provider's own timeout, or two scheduled observations when no timeout is available | The original operation still has no authoritative resource mapping. | Report unresolved identity and the owner; keep the original operation for recovery. Do not create another task on an absent list entry. |
 | A previously documented external wait changes or reaches its deadline | Recheck the exact dependency and its owner/resumption condition. | Resume only when the dependency is cleared and the original authority permits it; otherwise report a material blocker once. Unchanged waiting is quiet. |
 | Task reaches a terminal turn or a claimed result | Check the result and original acceptance evidence independently. | Continue authorized unmet work, report a concrete blocker, or stop monitoring only after the accepted outcome is proven. |
-| Monitor or authority limit reached | Check scheduler status, task identity, retry/time/cost budget, and any stop request. | Pause or stop and report what remains. The monitor cannot detect its own missed scheduler runs without another external observer. |
+| Monitor or authority limit reached | Check scheduler status, task identity, no-progress/failure state, observation allowance, and any stop request. Local task usage counters do not impose execution ceilings. | Pause or stop and report what remains. The monitor cannot detect its own missed scheduler runs without another external observer. |
 
 For an hourly heartbeat, the first confirmed idle observation is actionable;
 the active/no-progress comparison needs two consecutive hourly snapshots.

package/src/orchestrator/delivery/references/minimum-completion.md

@@ -125,7 +125,7 @@ execution remains subject to existing runner/host ownership controls.
 PR recheck clears prior completion flags and reruns the floor. Missing evidence
 never promotes an old successful audit. The old history is retained; do not rewrite
 it as verified under the new floor. Fix the named criterion, collect fresh evidence
-and resume within the retry budget. Reconcile ambiguous external side effects
+and resume with the same task identity and progress checks. Reconcile ambiguous external side effects
 before retrying. The minimum pass is a prerequisite for existing CI/review/authority
 gates, not merge, deployment or a complete production delivery.
 

package/src/orchestrator/instruction.js

@@ -39,14 +39,10 @@ export function buildCodingInstruction(
         `Risk level: ${charter.risk.level}`,
         `Design summary: ${charter.design_review.summary || "not required"}`,
         `Design approved by: ${charter.design_review.approved_by || "not required"}`,
-        `Attempt: ${attemptNumber}/${budget?.hard_attempt_ceiling ?? charter.max_attempts}`,
-        `Retry budget: ${Math.max(attemptNumber - 1, 0)}/${charter.retry_budget}`,
-        `Token budget remaining: ${budget?.tokens_remaining ?? charter.token_budget}/${charter.token_budget}`,
-        ...(charter.continuation_policy === "progress" ? [
-          "Continuation policy: verified acceptance progress. Token/retry thresholds notify; they do not relax acceptance or authorize new work.",
-          `Hard Provider token ceiling: ${budget?.hard_token_ceiling}; remaining: ${budget?.hard_tokens_remaining}. Hard attempt ceiling: ${budget?.hard_attempt_ceiling}.`,
-          "Report human/external blockers as soon as observed; continue independent work within the approved objective. Changed metadata alone is not progress.",
-        ] : []),
+        `Attempt: ${attemptNumber}`,
+        `Provider tokens recorded: ${budget?.tokens_used ?? 0}`,
+        "Local execution has no token, elapsed-time or attempt cap, including restored tasks. Continue while verified acceptance improves; stop for unresolved approval, missing input, repeated identical failure or absent progress.",
+        "Report human/external blockers as soon as observed; continue independent work within the approved objective. Changed metadata alone is not progress.",
         `Local evidence root: ${charter.ui_evidence_root || "not required"}`,
       ].join("\n"),
     ),

package/src/orchestrator/loop.js

@@ -77,8 +77,7 @@ async function runCodingLoopOwned({
 
   let previousFindings = resume ? snapshot.final_audit?.findings || [] : [];
   const firstAttempt = resume ? snapshot.attempts.length + 1 : 1;
-  const progressPolicy = snapshot.charter.continuation_policy === "progress";
-  const lastAttempt = progressPolicy ? codingAttemptCeiling(snapshot) : resume ? firstAttempt : snapshot.charter.max_attempts;
+  const lastAttempt = codingAttemptCeiling(snapshot);
   for (
     let attemptNumber = firstAttempt;
     attemptNumber <= lastAttempt;

package/src/orchestrator/outcome-monitor.js

@@ -133,8 +133,8 @@ export function assessOutcomeProgress(charter, attempt, previousAttempt = null,
     previous: previousAttempt?.outcome_progress || null,
     maxNoProgressAttempts: options.maxNoProgressAttempts ?? 3,
   });
-  // Existing runs keep their original stopping policy until the controller opts
-  // into progress continuation. The richer measurement is persisted in both.
+  // Legacy runs retain their stricter independently assessed two-candidate
+  // circuit, plus the shared no-progress circuit when verification is missing.
   if (options.policy !== "progress") {
     const criteria = acceptanceCriterionRows(charter);
     const rows = Array.isArray(assessment?.criterion_results) ? assessment.criterion_results : [];
@@ -143,7 +143,7 @@ export function assessOutcomeProgress(charter, attempt, previousAttempt = null,
         rows.filter((row) => row.criterion_id === criterion.id).length === 1);
     const previous = previousAttempt?.outcome_progress;
     result.status = completeAssessment ? "assessed" : "insufficient_evidence";
-    result.stalled = Boolean(completeAssessment && previous?.status === "assessed" &&
+    result.stalled = (!completeAssessment && result.stalled) || Boolean(completeAssessment && previous?.status === "assessed" &&
       previous.objective_digest === result.objective_digest && result.unproven_ids.length > 0 &&
       result.assessed_ids.every((id) => previous.assessed_ids.includes(id)) &&
       result.unproven_ids.every((id) => previous.unproven_ids.includes(id)));

package/src/orchestrator/pr-closure.js

@@ -13,7 +13,7 @@ export function buildPrClosureInstruction({ auditor = false } = {}) {
     `Before a closure decision, read the packaged Web/CLI procedure: ${PR_CLOSURE_GUIDE_PATH}`,
     "Freeze the original outcome criteria and exact old head/base, current target base, successor heads, integrated candidate and deployed identity. Preserve intended, observed and unknown behavior separately.",
     "Persist a criterion-ID before/after table: old PR, current base alone, integrated successors and deployed target. Account for all changed files and unintended added behavior; file counts, ancestry and green CI are not UX equivalence.",
-    "For every unresolved yellow/red row, create a new remediation PR within explicit implementation/commit/push/PR authority, grouping only coherent changes. Reuse an exact existing open remediation PR rather than duplicating it. Map every criterion ID to a real PR URL, owner and acceptance tests; a broad successor link or uncreated PR plan is insufficient for transfer_ready. Missing authority, unresolved product decisions or budget blocks remain explicit blockers. PR creation alone never makes a row green.",
+    "For every unresolved yellow/red row, create a new remediation PR within explicit implementation/commit/push/PR authority, grouping only coherent changes. Reuse an exact existing open remediation PR rather than duplicating it. Map every criterion ID to a real PR URL, owner and acceptance tests; a broad successor link or uncreated PR plan is insufficient for transfer_ready. Missing authority, unresolved product decisions or repeated-failure/no-progress blocks remain explicit blockers. PR creation alone never makes a row green.",
     "Verify normal production reachability and the complete trigger-to-usable-result path, with independent technical postconditions and recovery. Code surviving only in fixtures is not inherited UX. Distinguish reuse, composition, conversational design, immediate ad-hoc work and background learning, including the no-workflow/no-match fallback.",
     "Unknown, failed or stale applicable evidence blocks close_ready. Require independent review of original requirements and raw evidence before an authorized close. Preserve initial failures; tests changed to pass do not validate the unchanged original candidate.",
     "Unfinished successors require transfer_ready with explicit informed administrative-close authorization, accepted owner, open tracking and remaining gates; never claim full inheritance. Intentional removal requires an explicit retirement decision and safe data/migration handling.",

package/src/orchestrator/presentation.js

@@ -12,7 +12,6 @@ export function summarizeCodingLoopEvent(snapshot, event) {
 
   const charter = objectValue(snapshot?.charter);
   const attemptNumber = numberValue(detail.attempt_number) || latestAttemptNumber(snapshot);
-  const maxAttempts = numberValue(charter.max_attempts) || 1;
   const executor = executorLabel(detail.backend || charter.backend);
   const repository = cleanString(charter.repository) || "the selected repository";
   const branch = cleanString(detail.branch_name || charter.base_branch) || "the selected branch";
@@ -42,17 +41,17 @@ export function summarizeCodingLoopEvent(snapshot, event) {
       return {
         summary: `Execution scope set for: ${requirement}`,
         result: `${countLabel(charter.acceptance_criteria, "acceptance criterion")}, ${countLabel(charter.expected_tests, "expected test")}, and ${countLabel(charter.expected_evidence, "evidence requirement")}.`,
-        next: `Attempt 1 of ${maxAttempts} will be handed to ${executor}.`,
+        next: `Attempt 1 will be handed to ${executor}.`,
       };
     case "dispatching":
       return {
-        summary: `Preparing ${executor} attempt ${attemptNumber}/${maxAttempts} for ${branch}.`,
+        summary: `Preparing ${executor} attempt ${attemptNumber} for ${branch}.`,
         result: "The executor instruction now includes the task, constraints, checks, and prior findings.",
         next: `${executor} will start the local coding process.`,
       };
     case "coding":
       return {
-        summary: `${executor} is implementing attempt ${attemptNumber}/${maxAttempts} on ${branch}.`,
+        summary: `${executor} is implementing attempt ${attemptNumber} on ${branch}.`,
         result: "Live provider output is shown below as the local process works.",
         next: "When execution finishes, SIMY will collect code, test, PR, and UI evidence.",
       };
@@ -84,7 +83,7 @@ export function summarizeCodingLoopEvent(snapshot, event) {
       return {
         summary: `Attempt ${attemptNumber} needs another coding pass before review.`,
         result: findingResult(findings),
-        next: `SIMY will give the findings to ${executor} for attempt ${Math.min(attemptNumber + 1, maxAttempts)}/${maxAttempts}.`,
+        next: `SIMY will give the findings to ${executor} for attempt ${attemptNumber + 1}.`,
       };
     case "pr_ready_for_review":
       return {
@@ -106,7 +105,7 @@ export function summarizeCodingLoopEvent(snapshot, event) {
       };
     case "blocked":
       return {
-        summary: "The run cannot continue automatically with its current token, retry, or evidence budget.",
+        summary: "The run cannot continue automatically with its remaining evidence or approval requirements.",
         result: findings.length ? findingResult(findings) : cleanString(event?.message),
         next: "Review the findings, adjust the request or evidence, and resume the run.",
       };

package/src/runner.js

@@ -239,7 +239,7 @@ export function restoreRun({ snapshot, session, apiOrigin, localPath = null, loc
   restoredSnapshot.charter.retry_budget = run.snapshot.charter.retry_budget;
   restoredSnapshot.charter.token_budget = run.snapshot.charter.token_budget;
   restoredSnapshot.charter.max_attempts = run.snapshot.charter.max_attempts;
-  refreshBudgetState(restoredSnapshot);
+  refreshRecoveryBudgetAudit(restoredSnapshot, refreshBudgetState(restoredSnapshot));
   const lifecycleState = restoredSnapshot.metadata?.pr_lifecycle_state;
   const persistedState =
     typeof lifecycleState === "string" && RESTORABLE_STATES.has(lifecycleState)
@@ -418,12 +418,8 @@ function assertRunCanContinue(run) {
   }
 
   const budget = refreshBudgetState(run.snapshot);
-  if (budget.token_exhausted) {
-    throw new Error("The Agentic Loop run used its token budget. Start a new run to continue.");
-  }
-  if (budget.retry_exhausted) {
-    throw new Error("The Agentic Loop run used its retry budget. Start a new run to continue.");
-  }
+  refreshRecoveryBudgetAudit(run.snapshot, budget);
+
 }
 
 export async function increaseLocalCodingRunProviderTokenBudget(run, value) {
@@ -1051,20 +1047,7 @@ export async function executeProcessAttempt({
         if (run.localStateRoot) checkpointWrites.push(saveCodingRunSnapshot(run.localStateRoot, run.snapshot).catch(() => {
           emitOutput(run, "The Provider usage checkpoint could not be persisted; recovery usage remains unverified.", { backend });
         }));
-        if (currentUsed < initialBudget.hard_token_ceiling || terminalErrorCode || run.stopRequested) return;
-        terminalErrorCode = "TOKEN_BUDGET_EXHAUSTED";
-        terminalError = `Provider token hard ceiling reached (${currentUsed} / ${initialBudget.hard_token_ceiling}). Extend the same run's ceiling explicitly before continuing.`;
-        appendEvent(run.snapshot, run.status, terminalError, {
-          code: "provider_token_ceiling_reached", phase, attempt_number: attemptNumber,
-          provider_tokens_used: currentUsed, provider_token_ceiling: initialBudget.hard_token_ceiling,
-        });
-        if (!settled) {
-          run.controlState = "stopping";
-          void signalAndWaitForClose(child, "SIGINT", 1_500).then(async result => {
-            if (result === "timeout" && !settled && run.child === child) result = await signalAndWaitForClose(child, "SIGTERM", 1_500);
-            if (result === "timeout" && !settled && run.child === child) await signalAndWaitForClose(child, "SIGKILL", 750);
-          }).catch(() => {});
-        }
+
       },
     });
     const stderrDecoder = createProviderStreamDecoder({

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

@@ -423,7 +423,7 @@ export async function executeCodexAppServer(record, { openClient = openCodexAppS
       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,
-        softDeadline: run.deadline, softMaxContinuations: run.maxContinuations } };
+        localExecutionLimits: false } };
     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;

package/src/session-supervision/index.js

@@ -9,8 +9,8 @@ import { readCodexTitles, sessionTitle } from './session-titles.js';
 function autoContinueState(record, isRunning, supported) {
   if (record?.autoContinue !== true) return { autoContinueStatus: 'off', autoContinueReason: null };
   const state = record.run?.state;
-  if (state === 'budget_exhausted') return { autoContinueStatus: 'limit', autoContinueReason: 'This conversation reached its continuation limit. Its budgets cannot be reset.' };
-  if (['completed', 'reported_done'].includes(state)) return { autoContinueStatus: 'finished', autoContinueReason: 'Bounded continuation finished for this conversation.' };
+  if (state === 'budget_exhausted') return { autoContinueStatus: 'needs_user', autoContinueReason: 'Local execution limits have been removed. Resume this same conversation to continue.' };
+  if (['completed', 'reported_done'].includes(state)) return { autoContinueStatus: 'finished', autoContinueReason: 'Continuation finished for this conversation.' };
   const managed = record.run?.managed;
   const recoverableCause = record.run?.recoveryCause === 'process_exit' || managed?.resumeChannel === 'codex_app_server' && ['session_supervision', 'approved_action'].includes(record.run?.recoveryCause);
   if (state === 'recovery_required' && (!managed?.autoRecovery || !recoverableCause || managed.pendingApproval)) return {
@@ -19,7 +19,7 @@ function autoContinueState(record, isRunning, supported) {
   if (['paused', 'blocked', 'stopped', 'failed', 'verification_pending'].includes(state)) return { autoContinueStatus: 'needs_user', autoContinueReason: 'Existing supervision needs your attention before more work can continue.' };
   if (!supported) return { autoContinueStatus: 'unavailable', autoContinueReason: 'The original provider continuation channel is unavailable.' };
   return { autoContinueStatus: record.run ? 'supervising' : isRunning ? 'waiting' : 'watching',
-    autoContinueReason: record.run ? 'Continuing within the existing task budget.' : isRunning ? 'Waiting for the original turn to finish.' : 'Checking settled requests for worthwhile remaining work.' };
+    autoContinueReason: record.run ? 'Continuing the original task with progress and approval checks.' : isRunning ? 'Waiting for the original turn to finish.' : 'Checking settled requests for worthwhile remaining work.' };
 }
 
 function initialDiagnosisPlan(objective, contextBootstrap = false) {
@@ -147,7 +147,7 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
   return updateRecord(root, provider, session, async previous => {
     if (!previous) throw new Error('Refresh this conversation before changing automatic continuation.');
     if (enabled && previous.run && !previous.run.managed) throw new Error('Automatic continuation is unavailable for this conversation.');
-    if (enabled && TERMINAL_RUNS.has(previous.run?.state)) throw new Error('Bounded continuation finished or reached its limit; budgets cannot be reset.');
+    if (enabled && TERMINAL_RUNS.has(previous.run?.state)) throw new Error('This conversation is settled. Resume an eligible existing task after refreshing its status.');
     if (enabled && provider === 'codex' && !previous.admission?.model) throw new Error('Automatic continuation is unavailable for this conversation.');
     if (enabled && provider === 'claude' && !await liveClaudeHook(previous,
       { session, cwd: previous.cwd, observation: { source: previous.admission?.source } }, options.inspectProcess || processIdentity)) throw new Error('Claude needs a live matching SIMY SessionStart hook; cold CLI takeover is unavailable.');
@@ -224,7 +224,6 @@ export async function enrollSession({ root, provider, session, objective, accept
   maxMinutes = 30, maxContinuations = 6, maxFailures = 3, maxNoProgressMinutes, maxTokens, continuationPolicy, hardMaxMinutes, hardMaxContinuations, providerTokenCeiling, autoContinueEpoch, openClient = openCodexAppServer,
   readClaude = readClaudeSession, inspectProcess = processIdentity, now = Date.now() }) {
   if (!['codex', 'claude'].includes(provider)) throw new Error('This provider does not have a verified exact-session enrollment channel.');
-  if (maxTokens !== undefined && provider !== 'codex') throw new Error('Token-budgeted supervision requires host-observed Codex usage; Claude live hooks cannot enforce this budget.');
   if (typeof objective !== 'string' || !objective.trim() || objective.length > 4000) throw new Error('A concrete objective is required.');
   if (!['autonomous', 'balanced', 'strict'].includes(autonomyPolicy)) throw new Error('Choose an autonomy policy.');
   let metadata;

package/src/sqm/bundle-store.js

@@ -206,6 +206,7 @@ async function fetchBundle({ endpoint, repository, cliVersion, token, organizati
     const error = new Error(`SQM Cloud returned HTTP ${response.status}${body ? `: ${body.slice(0, 300)}` : ""}.`);
     error.status = response.status;
     Object.assign(error, safeSqmDiagnostic({ status: response.status, code: parsed?.error?.code || parsed?.detail?.code,
+      reasonCode: parsed?.error?.reason_code || parsed?.detail?.reason_code,
       requestId: response.headers?.get?.("x-request-id") }, "knowledge_bundle", "knowledge_bundle_http_error"));
     error.fallbackAllowed = response.status >= 500 && response.status <= 599;
     throw error;

package/src/sqm/diagnostics.js

@@ -8,16 +8,30 @@ export function safeSqmDiagnostic(error, stage = "check", code = "sqm_check_fail
   return {
     stage: machine(value.stage ?? value.errorStage ?? value.error_stage, stage),
     code: machine(value.code ?? value.errorCode ?? value.error_code, code),
+    ...(value.reasonCode || value.reason_code ? { reasonCode: machine(value.reasonCode ?? value.reason_code, "access_denied") } : {}),
     ...(Number.isInteger(status) && status >= 400 && status <= 599 ? { status } : {}),
     ...(typeof requestId === "string" && /^(?:[a-f0-9]{16,64}|[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})$/i.test(requestId) ? { requestId } : {}),
   };
 }
 
+const ACCESS_HINTS = {
+  entitlement_denied: "The selected organization lacks an active SQM entitlement. Ask its administrator to check the subscription and IT Engineer package.",
+  organization_inactive: "The selected organization is inactive. Ask its administrator to restore it or select an active organization.",
+  membership_required: "Your account is not an active member of the selected organization. Ask its administrator to restore membership.",
+  membership_inactive: "Your membership in the selected organization is inactive. Ask its administrator to reactivate it.",
+  permission_denied: "Your organization role does not permit SQM. Ask its administrator to grant SQM access.",
+  tenant_mismatch: "This resource belongs to another organization. Select the resource's organization before retrying.",
+  actor_forbidden: "Your account cannot use SQM in the selected organization. Ask its administrator to verify membership and permissions.",
+  resource_scope_mismatch: "The resource belongs to another organization. Select its original organization; do not retry under the current scope.",
+};
+
 export function formatSqmDiagnostic(value) {
-  const hint = value.status === 401 ? "Reconnect your SIMY session."
-    : value.status === 403 ? "Check access to SQM in the selected organization."
-    : value.code === "repository_scope_unresolved" ? "Connect this repository to a system in SIMY."
+  const hint = ACCESS_HINTS[value.reasonCode] || (value.status === 401 ? "Reconnect your SIMY session."
+    : value.code === "sqm_entitlement_required" ? ACCESS_HINTS.entitlement_denied
+    : value.code === "repository_scope_unresolved" ? "SQM cannot resolve this repository to a connected system in the selected organization. Check the repository remote, select the correct organization and ask its administrator to connect the repository in SQM Systems. Then run min-check again."
+    : value.status === 403 ? "SQM access was denied in the selected organization. Ask its administrator to check active membership, organization status and SQM entitlement."
     : value.code === "knowledge_bundle_changed" || value.code === "repository_identity_changed" ? "Run min-check again for the current repository and knowledge version."
-    : "Inspect the command diagnostics for this stage before retrying.";
-  return `${value.stage} · ${value.code}${value.status ? ` · HTTP ${value.status}` : ""}${value.requestId ? ` · Request ${value.requestId}` : ""}\n${hint}`;
+    : value.status === 409 ? "The SQM request conflicts with the current repository, task or lease state. Refresh its current status before retrying."
+    : "Inspect the command diagnostics for this stage before retrying.");
+  return `${value.stage} · ${value.code}${value.reasonCode ? ` · ${value.reasonCode}` : ""}${value.status ? ` · HTTP ${value.status}` : ""}${value.requestId ? ` · Request ${value.requestId}` : ""}\n${hint}`;
 }

package/src/sqm/evidence-client.js

@@ -22,6 +22,7 @@ export async function uploadRunEvidence({ endpoint, token, proof, signedEvidence
     error.stage = "evidence_upload";
     error.retryable = false;
     Object.assign(error, safeSqmDiagnostic({ status: response.status, code: payload?.error?.code,
+      reasonCode: payload?.error?.reason_code,
       requestId: response.headers?.get?.("x-request-id") }, "evidence_upload", "evidence_upload_failed"));
     throw error;
   }

package/src/sqm/review-worker.js

@@ -3,6 +3,7 @@ import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import { safeSqmDiagnostic, formatSqmDiagnostic } from "./diagnostics.js";
 import { inspectProviderStatus } from "../desktop-status.js";
 import { inspectDesktopExecutor } from "../desktop-executor.js";
 import { safeProviderDiagnostic, PROVIDER_FAILURE_HINTS } from "./provider-diagnostics.js";
@@ -22,11 +23,12 @@ export const SQM_CODEX_MODELS = Object.freeze(["gpt-6-astra", "gpt-6.1-sol"]);
 export const SQM_CODEX_MODEL = SQM_CODEX_MODELS[0];
 
 export class SqmLocalReviewError extends Error {
-  constructor(message, { status = null, code = "sqm_local_review_error", stage = null, jobId = null, failureRecorded = false, validationFeedback = "", providerDiagnostic } = {}) {
+  constructor(message, { status = null, code = "sqm_local_review_error", stage = null, jobId = null, failureRecorded = false, validationFeedback = "", providerDiagnostic, reasonCode } = {}) {
     super(message);
     this.name = "SqmLocalReviewError";
     this.status = status;
     this.code = code;
+    if (reasonCode) this.reasonCode = safeSqmDiagnostic({ reasonCode }).reasonCode;
     this.stage = stage; this.jobId = jobId; this.failureRecorded = failureRecorded;
     this.validationFeedback = typeof validationFeedback === "string" ? validationFeedback.slice(0, 2000) : "";
     if (providerDiagnostic) this.providerDiagnostic = safeProviderDiagnostic(providerDiagnostic);
@@ -75,7 +77,8 @@ export function createSqmLocalReviewApi({
       if (!response.ok) {
         throw new SqmLocalReviewError(webApiErrorMessage(payload, response.status), {
           status: response.status,
-          code: machineCode(payload?.code || payload?.detail?.code),
+          code: machineCode(payload?.code || payload?.error?.code || payload?.detail?.code),
+          reasonCode: payload?.error?.reason_code || payload?.detail?.reason_code,
           stage: payload?.detail?.stage, jobId: payload?.detail?.job_id, failureRecorded: payload?.detail?.failure_recorded === true,
           validationFeedback: payload?.detail?.validation_feedback,
         });
@@ -703,14 +706,15 @@ function reviewFailure(error, stage, provider) {
     else if (providerSignInRequired(message)) code = "provider_sign_in_required";
     else if (stage === "analysis" || stage === "adjudication") code = `${provider}_local_review_failed`;
   }
-  return { stage: /^[a-z_]{1,40}$/.test(error?.stage || "") ? error.stage : stage, code,
+  return { ...safeSqmDiagnostic(error), stage: /^[a-z_]{1,40}$/.test(error?.stage || "") ? error.stage : stage, code,
     status: Number.isInteger(error?.status) && error.status >= 400 && error.status <= 599 ? error.status : null,
     providerDiagnostic: safeProviderDiagnostic(error?.providerDiagnostic) };
 }
 
 function formatFailure(failure, failureReported = null) {
   if (!failure) return "SQM analysis failed. No failure diagnostics were recorded.";
-  const hint = failure.code === "provider_sign_in_required" ? "Sign in to the local AI app again."
+  const hint = [403, 409].includes(failure.status) ? formatSqmDiagnostic(failure).split("\n").slice(1).join("\n")
+    : failure.code === "provider_sign_in_required" ? "Sign in to the local AI app again."
     : failure.code === "provider_model_unsupported" ? "The local Codex account rejected the configured SQM models. Update Codex or check this account's available models."
     : failure.code === "analysis_timeout" ? "The local AI analysis exceeded its time limit."
     : failure.code === "sqm_source_loading_failed" ? "SIMY could not load evidence for this analysis."