omnius 1.0.688 → 1.0.690

package/dist/index.js

@@ -360167,6 +360167,7 @@ var init_todo_write = __esm({
     init_todo_store();
     _currentSessionId = "";
     TodoWriteTool = class {
+      executionScope = null;
       name = "todo_write";
       description = `Update the session task checklist. To be used proactively and often to track progress and pending tasks. Make sure that at least one task is in_progress at all times. 
 
@@ -360306,6 +360307,24 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
           }
         }
       };
+      constructor(scope) {
+        if (scope)
+          this.bindExecutionScope(scope);
+      }
+      bindExecutionScope(scope) {
+        const sessionId = String(scope.sessionId ?? "").trim();
+        if (!sessionId)
+          throw new TypeError("todo_write requires a non-empty host session scope");
+        if (this.executionScope && this.executionScope.sessionId !== sessionId) {
+          throw new Error(`todo_write is already bound to session '${this.executionScope.sessionId}'`);
+        }
+        this.executionScope = Object.freeze({ ...scope, sessionId });
+      }
+      resolveSessionId(args) {
+        if (this.executionScope)
+          return this.executionScope.sessionId;
+        return typeof args["session_id"] === "string" && args["session_id"].trim() ? args["session_id"].trim() : typeof args["sessionId"] === "string" && args["sessionId"].trim() ? args["sessionId"].trim() : getTodoSessionId();
+      }
       async execute(args) {
         const start2 = performance.now();
         try {
@@ -360406,7 +360425,7 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
             };
           }
           enforceActiveLeafTodo(incoming, repairNotes);
-          const sessionId = typeof args["session_id"] === "string" && args["session_id"].trim() ? args["session_id"].trim() : typeof args["sessionId"] === "string" && args["sessionId"].trim() ? args["sessionId"].trim() : getTodoSessionId();
+          const sessionId = this.resolveSessionId(args);
           const oldTodos = readTodos(sessionId);
           const canonicalize4 = (todos) => JSON.stringify(todos.map((t2) => ({
             content: t2.content,
@@ -360517,6 +360536,7 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
       "acceptance"
     ]);
     TodoReadTool = class {
+      executionScope = null;
       name = "todo_read";
       description = "Read the current task checklist for this session.";
       parameters = {
@@ -360528,10 +360548,28 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
           }
         }
       };
+      constructor(scope) {
+        if (scope)
+          this.bindExecutionScope(scope);
+      }
+      bindExecutionScope(scope) {
+        const sessionId = String(scope.sessionId ?? "").trim();
+        if (!sessionId)
+          throw new TypeError("todo_read requires a non-empty host session scope");
+        if (this.executionScope && this.executionScope.sessionId !== sessionId) {
+          throw new Error(`todo_read is already bound to session '${this.executionScope.sessionId}'`);
+        }
+        this.executionScope = Object.freeze({ ...scope, sessionId });
+      }
+      resolveSessionId(args) {
+        if (this.executionScope)
+          return this.executionScope.sessionId;
+        return typeof args["session_id"] === "string" && args["session_id"].trim() ? args["session_id"].trim() : typeof args["sessionId"] === "string" && args["sessionId"].trim() ? args["sessionId"].trim() : getTodoSessionId();
+      }
       async execute(args) {
         const start2 = performance.now();
         try {
-          const sessionId = typeof args["session_id"] === "string" && args["session_id"].trim() ? args["session_id"].trim() : typeof args["sessionId"] === "string" && args["sessionId"].trim() ? args["sessionId"].trim() : getTodoSessionId();
+          const sessionId = this.resolveSessionId(args);
           const todos = readTodos(sessionId);
           return {
             success: true,
@@ -630245,6 +630283,58 @@ var init_contextBudget = __esm({
   }
 });
 
+// packages/orchestrator/dist/convergence-progress.js
+function classifyAuthoritativeProgress(input) {
+  if (!input.success || input.noop || input.runtimeAuthored)
+    return null;
+  const kind = input.confirmedMutation ? "mutation" : input.todoTransition ? "todo_transition" : input.workboardTransition ? "workboard_transition" : input.assertiveVerifier ? "verifier_receipt" : input.deliveryReceipt ? "delivery_receipt" : null;
+  return kind ? { kind, fingerprint: `${kind}:${input.fingerprint}` } : null;
+}
+var ConvergenceProgressTracker;
+var init_convergence_progress = __esm({
+  "packages/orchestrator/dist/convergence-progress.js"() {
+    "use strict";
+    ConvergenceProgressTracker = class {
+      fingerprints = /* @__PURE__ */ new Set();
+      progressCount = 0;
+      lastProgressTurn = 0;
+      lastKind;
+      reviewLatched = false;
+      record(turn, signal) {
+        if (!signal || this.fingerprints.has(signal.fingerprint))
+          return false;
+        this.fingerprints.add(signal.fingerprint);
+        this.progressCount += 1;
+        this.lastProgressTurn = Math.max(0, turn);
+        this.lastKind = signal.kind;
+        this.reviewLatched = false;
+        return true;
+      }
+      shouldLatchReview(input) {
+        if (this.reviewLatched || input.openLeafCount <= 0)
+          return false;
+        const threshold = Math.max(1, Math.floor(input.thresholdTurns));
+        if (input.turn - this.lastProgressTurn < threshold)
+          return false;
+        this.reviewLatched = true;
+        return true;
+      }
+      hasRecentProgress(turn, windowTurns) {
+        return this.progressCount > 0 && turn - this.lastProgressTurn <= Math.max(1, Math.floor(windowTurns));
+      }
+      snapshot(turn) {
+        return {
+          count: this.progressCount,
+          lastProgressTurn: this.lastProgressTurn,
+          turnsSinceProgress: Math.max(0, turn - this.lastProgressTurn),
+          reviewLatched: this.reviewLatched,
+          ...this.lastKind ? { lastKind: this.lastKind } : {}
+        };
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/inference-pressure.js
 function getInferencePressureCoordinator() {
   processCoordinator ??= new InferencePressureCoordinator({
@@ -662510,6 +662600,7 @@ var init_agenticRunner = __esm({
   "packages/orchestrator/dist/agenticRunner.js"() {
     "use strict";
     init_contextBudget();
+    init_convergence_progress();
     init_inference_pressure();
     init_interruption_lifecycle();
     init_tool_exposure_policy();
@@ -663967,7 +664058,7 @@ ${loadPrompt("agentic/system-small.md")}`;
         if (this.options.subAgent || this.options.recursionDepth > 0)
           return [];
         const normalizedGoal = goal.replace(/\s+/g, " ").trim();
-        if (normalizedGoal.length < 120 && !this._isContinuationResumeGoal(normalizedGoal))
+        if (normalizedGoal.length < 120 && !this._resumeInterrupted)
           return [];
         return [
           {
@@ -664035,44 +664126,6 @@ ${loadPrompt("agentic/system-small.md")}`;
           }
         ];
       }
-      _isContinuationResumeGoal(goal) {
-        const tokens3 = goal.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter(Boolean);
-        if (tokens3.length === 0 || tokens3.length > 14)
-          return false;
-        const continuationTerms = /* @__PURE__ */ new Set([
-          "again",
-          "and",
-          "back",
-          "carry",
-          "complete",
-          "continue",
-          "finish",
-          "from",
-          "last",
-          "latest",
-          "left",
-          "my",
-          "off",
-          "please",
-          "previous",
-          "prior",
-          "proceed",
-          "request",
-          "resume",
-          "task",
-          "that",
-          "the",
-          "this",
-          "to",
-          "try",
-          "work"
-        ]);
-        const hasResumeVerb = tokens3.some((token) => token === "continue" || token === "resume" || token === "proceed" || token === "complete" || token === "finish");
-        if (!hasResumeVerb)
-          return false;
-        const continuationTokenCount = tokens3.filter((token) => continuationTerms.has(token)).length;
-        return continuationTokenCount / tokens3.length >= 0.7;
-      }
       /**
        * Build a compact workboard context string for injection into the
        * system prompt. Returns null when no active board exists or when
@@ -664597,18 +664650,20 @@ ${parts.join("\n")}
       recordWorkboardToolCall(toolName, args, success, output2, result, meta = {}) {
         const board = this._currentWorkboardSnapshotForFrame() ?? this.getOrCreateWorkboard();
         if (!board)
-          return;
+          return false;
         if (toolName === "task_complete" || toolName === "workboard_create")
-          return;
+          return false;
         if (meta.repeatShortCircuit || result?.runtimeAuthored)
-          return;
+          return false;
         if (meta.focusDecisionKind === "block_tool_call")
-          return;
+          return false;
         if (result?.success === true && this._isProjectEditTool(toolName) && !this._isRealProjectMutation(toolName, result) && result.alreadyApplied !== true) {
-          return;
+          return false;
         }
         const dir = this._workboardDir();
         try {
+          const statusFingerprint = (snapshot) => snapshot.cards.filter((card) => !card.supersededBy).map((card) => `${card.id}:${card.status}:${card.lane ?? ""}`).sort().join("|");
+          const beforeStatus = statusFingerprint(board);
           const evidenceSummary = toolName === "shell" && meta.shellFilesystemMutation ? `shell filesystem mutation ${success ? "ok" : "fail"}` : `${toolName} ${success ? "ok" : "fail"}`;
           const rawEvidenceOutput = typeof output2 === "string" && output2.length > 0 ? output2 : result?.output || result?.error || "";
           const evidenceContent = rawEvidenceOutput.slice(0, 1e3);
@@ -664629,14 +664684,15 @@ ${parts.join("\n")}
           };
           const actor = this.options.subAgent ? "sub-agent" : "agent";
           const advanced = this._advanceWorkboardForTool(board, toolName, result, actor, meta);
+          const workboardTransition = statusFingerprint(advanced) !== beforeStatus;
           const targetCardId = this._workboardTargetCardId(advanced, toolName, args, result, meta);
           if (!targetCardId)
-            return;
+            return workboardTransition;
           const targetCard = advanced.cards.find((card) => card.id === targetCardId);
           if (!targetCard)
-            return;
+            return workboardTransition;
           if (targetCard.assignee && targetCard.assignee !== actor && targetCard.assignee !== "any") {
-            return;
+            return workboardTransition;
           }
           const evidenced = result?.executionReceipt ? attachTrustedWorkboardCommandEvidence(dir, {
             runId: this.currentArtifactRunId(),
@@ -664654,7 +664710,7 @@ ${parts.join("\n")}
             evidence
           });
           const persistedEvidence = evidenced.cards.find((card) => card.id === targetCard.id)?.evidence.find((item) => item.summary === evidence.summary && item.content === evidence.content);
-          const substantive = success === true && result?.runtimeAuthored !== true;
+          const substantive = success === true && result?.runtimeAuthored !== true && (workboardTransition || this._isRealProjectMutation(toolName, result) || meta.shellFilesystemMutation === true || toolName === "shell" && result !== void 0 && this._shellResultLooksLikeVerification(args, result) || Boolean(result?.completionDeliveryReceipt));
           this._workboard = updateWorkboardMetadata(dir, {
             runId: this.currentArtifactRunId(),
             actor,
@@ -664667,7 +664723,9 @@ ${parts.join("\n")}
               occurredAt: (/* @__PURE__ */ new Date()).toISOString()
             } : void 0
           });
+          return workboardTransition;
         } catch {
+          return false;
         }
       }
       /** Persist the workboard snapshot before run teardown. */
@@ -665135,6 +665193,9 @@ runtime_module_sha256=${record.runtimeProvenance.module.sha256 ?? "unknown"}`
           workboardDir: options2?.workboardDir ?? "",
           skipCrossTaskHandoff: options2?.skipCrossTaskHandoff ?? false
         };
+        const explicitSessionId = String(options2?.sessionId ?? "").trim();
+        const inheritedSessionId = String(process.env["OMNIUS_SESSION_ID"] ?? "").trim();
+        this._sessionId = explicitSessionId || !options2?.subAgent && inheritedSessionId || `session-${Date.now()}-${crypto.randomUUID()}`;
         this.setCanonicalToolExposureContracts(this.options.canonicalToolExposureContracts);
         this._adversaryMode = this.options.adversaryMode;
         this._streamingExecutor.setConcurrencyResolver((name10, args) => this.resolveToolConcurrencySafe(name10, args));
@@ -674080,6 +674141,11 @@ ${blob}
         }
         if (!this.isToolAllowedByProfile(tool.name, tool.aliases))
           return;
+        tool.bindExecutionScope?.({
+          sessionId: this._sessionId,
+          taskEpoch: this._taskEpoch,
+          ownerId: this._interruptionOwnerId
+        });
         const registeredTool = withTaskCompleteCloseoutContract(tool);
         this.tools.set(registeredTool.name, registeredTool);
         if (registeredTool.name === "generate_image") {
@@ -675003,8 +675069,8 @@ ${notice}`;
           _fsWriteFileSync(_pathJoin(dir, `${this._activeRunId || this._sessionId}-epoch-${taskEpoch}.json`), JSON.stringify(archive, null, 2), "utf8");
         } catch {
         }
-        for (const todo of todos)
-          this._supersededTodoIds.add(todo.id);
+        writeTodos(this._sessionId, []);
+        this._supersededTodoIds.clear();
         this._workboard = null;
       }
       /**
@@ -675035,8 +675101,8 @@ ${notice}`;
           }, null, 2), "utf8");
         } catch {
         }
-        for (const todo of todos)
-          this._supersededTodoIds.add(todo.id);
+        writeTodos(this._sessionId, []);
+        this._supersededTodoIds.clear();
         this._workboard = null;
         this.emit({
           type: "status",
@@ -676867,7 +676933,6 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this.aborted = false;
         this._abortController = new AbortController();
         this._turnAbortController = new AbortController();
-        this._sessionId = this.options.sessionId && String(this.options.sessionId) || process.env["OMNIUS_SESSION_ID"] && String(process.env["OMNIUS_SESSION_ID"]) || `session-${Date.now()}`;
         this._taskEpoch += 1;
         this._contextMemoryTaskRecordId = null;
         this._contextMemoryArtifactByPath.clear();
@@ -676899,10 +676964,8 @@ Respond with the assessment and take the selected evidence-backed action.`;
           }
           this._interruptionLifecycle = null;
         } else {
-          if (recovered.phase === "paused" && recovered.recovered) {
-            if (!this._resumeInterrupted) {
-              throw new Error(`Run ${recovered.runId} is paused after recovery. Resume that exact generation instead of starting new work.`);
-            }
+          const recoveredPause = recovered.phase === "paused" && recovered.recovered;
+          if (recoveredPause && this._resumeInterrupted) {
             this._taskEpoch = recovered.taskEpoch;
             this._activeRunId = recovered.runId;
             const resumed = lifecycle.requestResume(recovered.owner, "explicit restart recovery requested");
@@ -676912,6 +676975,11 @@ Respond with the assessment and take the selected evidence-backed action.`;
             if (!acknowledged.accepted)
               throw new Error(acknowledged.reason);
           } else {
+            if (recoveredPause) {
+              const superseded = lifecycle.requestStop(recovered.owner, `superseded by a new task submitted after recovery of run ${recovered.runId}`);
+              if (!superseded.accepted)
+                throw new Error(superseded.reason);
+            }
             lifecycle.beginRun({
               sessionId: this._sessionId,
               runId: this._activeRunId,
@@ -677189,8 +677257,8 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this._fileRegistry.clear();
         this._memexArchive.clear();
         this._todoOutputLedger.clear();
-        setTodoSessionId(this._sessionId);
-        const continuesPriorTask = this._allowImplicitContinuation || this._isContinuationResumeGoal(persistentTaskGoal);
+        this._supersededTodoIds.clear();
+        const continuesPriorTask = this._allowImplicitContinuation || this._resumeInterrupted;
         if (!continuesPriorTask) {
           this._hidePriorSessionTodosForFreshTask(persistentTaskGoal);
         }
@@ -677696,7 +677764,7 @@ ${dynamicProjectContext}`
         let estimatedTokens = 0;
         let toolCallCount = 0;
         let substantiveProgressCount = 0;
-        const substantiveProgressFingerprints = /* @__PURE__ */ new Set();
+        const convergenceProgress = new ConvergenceProgressTracker();
         let completed = false;
         let summary = "";
         let acceptedTaskCompleteStatus;
@@ -677765,6 +677833,7 @@ ${dynamicProjectContext}`
         let consecutiveTextOnly = 0;
         let consecutiveThinkOnly = 0;
         let loopInterventionCount = 0;
+        let loopCircuitBreakerLatched = false;
         const MAX_CONSECUTIVE_TEXT_ONLY = 3;
         const MAX_CONSECUTIVE_THINK_ONLY = 6;
         let narratedToolCallCount = 0;
@@ -679485,34 +679554,32 @@ Respond with EXACTLY this structure before your next tool call:
             nextSelfEval = now2 + selfEvalInterval;
           }
           const turnsRemaining = this.options.maxTurns - turn;
-          if (this.options.allowTurnExtension && turnsRemaining <= 3 && turnsRemaining > 0 && this._adversaryToolOutcomes.length >= 2) {
+          if (this.options.allowTurnExtension && turnsRemaining <= 3 && turnsRemaining > 0 && convergenceProgress.hasRecentProgress(turn, 6)) {
+            const extension3 = 30;
+            const progress = convergenceProgress.snapshot(turn);
+            this.options.maxTurns += extension3;
+            this.emit({
+              type: "status",
+              content: `Convergence triage: recent ${progress.lastKind ?? "task"} advancement (${progress.turnsSinceProgress} turn(s) ago) extended the limit by ${extension3} (now ${this.options.maxTurns})`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
             const recentOutcomes = this._adversaryToolOutcomes.slice(-6);
             const recentSuccesses = recentOutcomes.filter((o2) => o2.succeeded).length;
             const uniqueResults = new Set(recentOutcomes.map((o2) => o2.preview.slice(0, 40))).size;
-            const isActive = recentSuccesses >= 2 && uniqueResults >= 2;
-            if (isActive) {
-              const extension3 = 30;
-              this.options.maxTurns += extension3;
-              this.emit({
-                type: "status",
-                content: `Adversary triage: activity detected (${recentSuccesses} recent successes, ${uniqueResults} unique results) — extending turn limit by ${extension3} (now ${this.options.maxTurns})`,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-              const detailsLines = recentOutcomes.map((o2) => `- ${o2.tool}: ${o2.succeeded ? "OK" : "ERR"} — ${o2.preview}`);
-              this.emit({
-                type: "debug_adversary",
-                turn,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                content: `Timeout triage: EXTENDED by ${extension3} turns (active session detected)`,
-                adversaryAction: {
-                  detection: "none",
-                  recentSuccesses,
-                  recentFailures: recentOutcomes.length - recentSuccesses,
-                  intervention: `Extended maxTurns to ${this.options.maxTurns}`,
-                  details: [`Recent outcomes:`, ...detailsLines].join("\n")
-                }
-              });
-            }
+            const detailsLines = recentOutcomes.map((o2) => `- ${o2.tool}: ${o2.succeeded ? "OK" : "ERR"} — ${o2.preview}`);
+            this.emit({
+              type: "debug_adversary",
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              content: `Timeout triage: EXTENDED by ${extension3} turns after typed task advancement`,
+              adversaryAction: {
+                detection: "none",
+                recentSuccesses,
+                recentFailures: recentOutcomes.length - recentSuccesses,
+                intervention: `Extended maxTurns to ${this.options.maxTurns}`,
+                details: [`Recent outcomes:`, ...detailsLines].join("\n")
+              }
+            });
           }
           const steeringBoundary = await this._applySteeringAtSafeBoundary(messages2, turn);
           if (steeringBoundary !== "continue") {
@@ -680824,7 +680891,7 @@ Corrective action: try a different approach first: read relevant files, adjust a
                     turn,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
-                  const budgetMsg = `[BUDGET EXHAUSTED] You have used all ${toolBudgets[tc.name]} allowed ${tc.name} calls for the current phase. You ALREADY have enough information from previous calls. DO NOT try to call ${tc.name} again — it will be blocked. ` + (this._todoWriteAvailable() ? `If your todo list shows more phases pending: mark the current phase completed via todo_write so a new budget allowance kicks in. ` : `If more phases remain, continue with a different available tool instead of repeating the exhausted one. `) + `If all phases are done: call task_complete with your final summary.`;
+                  const budgetMsg = `[BUDGET EXHAUSTED] You have used all ${toolBudgets[tc.name]} allowed ${tc.name} calls for the current phase. You ALREADY have enough information from previous calls. DO NOT try to call ${tc.name} again — it will be blocked. ` + (this._todoWriteAvailable() ? `If the current phase is complete, update the todo truth and take an action from the next phase; the detected context-tree phase transition resets the allowance. ` : `If more phases remain, continue with a different available tool instead of repeating the exhausted one. `) + `If all phases are done: call task_complete with your final summary.`;
                   this.emit({
                     type: "tool_result",
                     toolName: tc.name,
@@ -683035,22 +683102,6 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                 turn,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
-              const branchCacheHit = result.completionEvidenceMetrics?.["branchCacheHit"] === true;
-              const nonSubstantiveResult = result.noop === true || branchCacheHit || repeatShortCircuit !== null && result.runtimeAuthored === true;
-              if (!nonSubstantiveResult) {
-                const observationFingerprint = [
-                  this._buildToolFingerprint(tc.name, tc.arguments ?? {}),
-                  result.success ? "ok" : "error",
-                  result.beforeHash ?? "",
-                  result.afterHash ?? "",
-                  realMutationPaths.join(","),
-                  this.quickHash(String(result.output ?? result.error ?? result.llmContent ?? ""))
-                ].join("|");
-                if (!substantiveProgressFingerprints.has(observationFingerprint)) {
-                  substantiveProgressFingerprints.add(observationFingerprint);
-                  substantiveProgressCount++;
-                }
-              }
               this._taskState.toolCallCount++;
               if (realFileMutation) {
                 this._lastFileWriteTurn = turn;
@@ -683405,13 +683456,36 @@ ${delegateDir}` : delegateDir;
                 });
               } catch {
               }
-              this.recordWorkboardToolCall(tc.name, tc.arguments, result.success, result.output || result.error || output2, result, {
+              const workboardTransition = this.recordWorkboardToolCall(tc.name, tc.arguments, result.success, result.output || result.error || output2, result, {
                 repeatShortCircuit: Boolean(repeatShortCircuit),
                 focusDecisionKind: focusDecision?.kind,
                 shellFilesystemMutation,
                 turn
               });
-              if (tc.name === "todo_write" && !this._isTodoWriteNoopResult(result)) {
+              const progressSignal = classifyAuthoritativeProgress({
+                toolName: tc.name,
+                fingerprint: [
+                  toolFingerprint,
+                  result.afterHash ?? "",
+                  realMutationPaths.join(","),
+                  result.completionDeliveryReceipt?.receiptId ?? "",
+                  workboardTransition ? "workboard-transition" : ""
+                ].join("|"),
+                success: result.success,
+                noop: result.noop === true,
+                runtimeAuthored: result.runtimeAuthored === true,
+                confirmedMutation: realFileMutation || shellFilesystemMutation || result.success === true && result.mutated === true,
+                todoTransition: tc.name === "todo_write" && result.success === true && !this._isTodoWriteNoopResult(result),
+                workboardTransition,
+                assertiveVerifier: tc.name === "shell" && result.success === true && this._shellResultLooksLikeVerification(tc.arguments, result),
+                deliveryReceipt: Boolean(result.completionDeliveryReceipt)
+              });
+              if (convergenceProgress.record(turn, progressSignal)) {
+                substantiveProgressCount = convergenceProgress.snapshot(turn).count;
+                loopInterventionCount = 0;
+                loopCircuitBreakerLatched = false;
+              }
+              if (tc.name === "todo_write" && result.success === true && !this._isTodoWriteNoopResult(result)) {
                 this._lastTodoWriteTurn = turn;
               }
               if (tc.name === "file_read" || tc.name === "list_directory" || tc.name === "find_files" || tc.name === "grep_search") {
@@ -683957,21 +684031,19 @@ ${sr.result.output}`;
                 freqMap.set(key2, (freqMap.get(key2) ?? 0) + 1);
               }
               const topRepeated = [...freqMap.entries()].sort((a2, b) => b[1] - a2[1]).slice(0, 2).map(([k, v]) => `${k} (${v}x)`).join(", ");
-              loopInterventionCount++;
               const loopTier2 = this.options.modelTier ?? "large";
               const maxInterventions = loopTier2 === "small" ? 3 : loopTier2 === "medium" ? 5 : 8;
+              loopInterventionCount = Math.min(maxInterventions, loopInterventionCount + 1);
               let loopCircuitBreakerFired = false;
               const loopInterventionOrdinal = loopInterventionCount;
-              if (loopInterventionCount >= maxInterventions) {
+              if (loopInterventionCount >= maxInterventions && !loopCircuitBreakerLatched) {
                 loopCircuitBreakerFired = true;
+                loopCircuitBreakerLatched = true;
                 this.emit({
                   type: "status",
-                  content: `Loop circuit breaker: ${loopInterventionCount} interventions — requesting user guidance`,
+                  content: `Loop circuit breaker latched after ${loopInterventionCount} interventions; awaiting authoritative task advancement or an agent-selected blocker/clarification decision`,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
-                const partialResults = this._taskState.completedSteps.length > 0 ? this._taskState.completedSteps.join(". ") : `Progress made before loop: ${topRepeated}`;
-                void partialResults;
-                loopInterventionCount = 0;
               }
               const findings = [];
               for (const [key2, entry] of recentToolResults) {
@@ -684315,7 +684387,9 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
               }
             }
             const todosNow = this.readSessionTodos() || [];
-            const completedNow = todosNow.filter((t2) => t2.status === "completed").length;
+            const parentIds = new Set(todosNow.map((todo) => todo.parentId).filter((id2) => Boolean(id2)));
+            const leavesNow = todosNow.filter((todo) => !parentIds.has(todo.id));
+            const completedNow = leavesNow.filter((t2) => t2.status === "completed").length;
             stagnationWindow.push({
               turn,
               ts: Date.now(),
@@ -684326,6 +684400,40 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
             });
           } catch {
           }
+          try {
+            const todosNow = this.readSessionTodos() || [];
+            const parentIds = new Set(todosNow.map((todo) => todo.parentId).filter((id2) => Boolean(id2)));
+            const leaves = todosNow.filter((todo) => !parentIds.has(todo.id));
+            const openLeaves = leaves.filter((todo) => todo.status !== "completed");
+            const configuredThreshold = Number.parseInt(process.env["OMNIUS_CONVERGENCE_REVIEW_TURNS"] ?? "", 10);
+            const defaultThreshold = this.options.modelTier === "small" ? 6 : this.options.modelTier === "medium" ? 8 : 10;
+            const thresholdTurns = Number.isFinite(configuredThreshold) && configuredThreshold > 0 ? configuredThreshold : defaultThreshold;
+            if (convergenceProgress.shouldLatchReview({
+              turn,
+              openLeafCount: openLeaves.length,
+              thresholdTurns
+            })) {
+              const progress = convergenceProgress.snapshot(turn);
+              const activeLeaf = openLeaves.find((todo) => todo.status === "in_progress") ?? openLeaves[0];
+              const review = [
+                "[CONVERGENCE REVIEW REQUIRED]",
+                `The task leaf frontier has not advanced for ${progress.turnsSinceProgress} turns.`,
+                `Leaf progress: ${leaves.length - openLeaves.length}/${leaves.length}.`,
+                activeLeaf ? `Current leaf: ${activeLeaf.id} (${activeLeaf.status}) ${activeLeaf.content}` : "Current leaf: none.",
+                "Reads, searches, and changed error text are evidence, not task advancement.",
+                "Choose the next action from current evidence. You may continue with one specific action and its expected evidence, update or block the leaf truthfully, ask for missing input, or call task_complete only if completion is already proven.",
+                "This review is advisory. The host does not infer the decision for you."
+              ].join("\n");
+              messages2.push({ role: "system", content: review });
+              this.emit({
+                type: "status",
+                content: `Convergence review latched at leaf progress ${leaves.length - openLeaves.length}/${leaves.length} after ${progress.turnsSinceProgress} turns without authoritative advancement`,
+                turn,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          } catch {
+          }
         }
         let prevCycleSubstantiveProgress = substantiveProgressCount;
         while (!completed && !this.aborted && !this._completionIncompleteVerification && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles) {
@@ -684334,7 +684442,7 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
           if (bruteForceCycle > 1 && substantiveProgressCount === prevCycleSubstantiveProgress) {
             this.emit({
               type: "status",
-              content: `Stopping re-engagement — cycle ${bruteForceCycle - 1} produced no new executed fingerprint, mutation, todo transition, or verifier evidence (${toolCallCount} attempted tool calls; ${substantiveProgressCount} substantive observations).`,
+              content: `Stopping re-engagement — cycle ${bruteForceCycle - 1} produced no authoritative mutation, todo/workboard transition, verifier receipt, or delivery receipt (${toolCallCount} attempted tool calls; ${substantiveProgressCount} authoritative advancements).`,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
             break;
@@ -684344,7 +684452,7 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
           consecutiveThinkOnly = 0;
           this.emit({
             type: "status",
-            content: `Re-engaging — cycle ${bruteForceCycle} (${totalTurns} turns, ${toolCallCount} attempted calls / ${substantiveProgressCount} substantive observations)`,
+            content: `Re-engaging — cycle ${bruteForceCycle} (${totalTurns} turns, ${toolCallCount} attempted calls / ${substantiveProgressCount} authoritative advancements)`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
           this._reg61CooldownUntilTurn = -1;
@@ -702517,6 +702625,7 @@ __export(dist_exports3, {
   CoherenceGate: () => CoherenceGate,
   ContentAddressedArtifactStore: () => ContentAddressedArtifactStore,
   ConvergenceBreaker: () => ConvergenceBreaker,
+  ConvergenceProgressTracker: () => ConvergenceProgressTracker,
   CoordinatorManager: () => CoordinatorManager,
   CostTracker: () => CostTracker,
   DEFAULT_ADAPTIVE_POLICY_CONFIG: () => DEFAULT_ADAPTIVE_POLICY_CONFIG,
@@ -702641,6 +702750,7 @@ __export(dist_exports3, {
   checkMilestoneComplete: () => checkMilestoneComplete,
   chooseCheapModelRoute: () => chooseCheapModelRoute,
   claimAssertion: () => claimAssertion,
+  classifyAuthoritativeProgress: () => classifyAuthoritativeProgress,
   classifyBreadth: () => classifyBreadth,
   classifyClaimKind: () => classifyClaimKind,
   classifyCompletionClaim: () => classifyCompletionClaim,
@@ -702999,6 +703109,7 @@ var init_dist8 = __esm({
     init_mergeRunner();
     init_retryController();
     init_agenticRunner();
+    init_convergence_progress();
     init_inference_pressure();
     init_canonical_context_projection();
     init_runtime_rollout();
@@ -715497,6 +715608,9 @@ function adaptExecutionTool(tool, options2 = {}) {
       return mapExecutionToolResult(result);
     }
   };
+  if (typeof tool.bindExecutionScope === "function") {
+    adapted.bindExecutionScope = (scope) => tool.bindExecutionScope(scope);
+  }
   if (typeof tool.cancel === "function") {
     adapted.cancel = () => tool.cancel();
   }
@@ -731239,6 +731353,7 @@ __export(omnius_directory_exports, {
   appendCompactionAudit: () => appendCompactionAudit,
   buildContextRestorePrompt: () => buildContextRestorePrompt,
   buildContextRestoreSnapshot: () => buildContextRestoreSnapshot,
+  buildExactContinuationSnapshot: () => buildExactContinuationSnapshot,
   buildHandoffPrompt: () => buildHandoffPrompt,
   cleanPromptForDiary: () => cleanPromptForDiary,
   clearTaskHandoff: () => clearTaskHandoff,
@@ -731260,6 +731375,8 @@ __export(omnius_directory_exports, {
   loadSessionHistory: () => loadSessionHistory,
   loadTuiSessionState: () => loadTuiSessionState,
   loadUsageHistory: () => loadUsageHistory,
+  pendingTaskMatchesInterruptionIdentity: () => pendingTaskMatchesInterruptionIdentity,
+  pendingTaskMatchesRunningInterruption: () => pendingTaskMatchesRunningInterruption,
   readIndexData: () => readIndexData,
   readIndexMeta: () => readIndexMeta,
   readTaskHandoff: () => readTaskHandoff2,
@@ -731659,21 +731776,64 @@ function loadRecentSessions(repoRoot, limit2 = 5) {
     return [];
   }
 }
+function isValidPendingTask(value2, repoRoot) {
+  if (!value2 || typeof value2 !== "object") return false;
+  const task = value2;
+  if (typeof task.prompt !== "string" || !task.prompt.trim() || typeof task.progressSummary !== "string" || !Array.isArray(task.filesModified) || !task.filesModified.every((item) => typeof item === "string") || typeof task.bruteForce !== "boolean" || typeof task.savedAt !== "string" || !Number.isFinite(Date.parse(task.savedAt)) || typeof task.toolCallCount !== "number" || !Number.isFinite(task.toolCallCount) || task.toolCallCount < 0) {
+    return false;
+  }
+  if (task.schema !== void 0 && task.schema !== "omnius.pending-task.v2") {
+    return false;
+  }
+  if (task.projectRoot !== void 0 && resolve77(task.projectRoot) !== resolve77(repoRoot)) {
+    return false;
+  }
+  if (task.interruption !== void 0) {
+    const interruption = task.interruption;
+    if (typeof interruption.sessionId !== "string" || !interruption.sessionId.trim() || typeof interruption.runId !== "string" || !interruption.runId.trim() || !Number.isInteger(interruption.taskEpoch) || interruption.taskEpoch < 1 || !Number.isInteger(interruption.ownerGeneration) || interruption.ownerGeneration < 1 || interruption.phase !== "pausing" && interruption.phase !== "paused") {
+      return false;
+    }
+  }
+  if (task.resumeOnStartup === true && !task.interruption) return false;
+  return true;
+}
+function pendingTaskMatchesRunningInterruption(pendingTask, candidate) {
+  return candidate?.phase === "running" && pendingTaskMatchesInterruptionIdentity(pendingTask, candidate);
+}
+function pendingTaskMatchesInterruptionIdentity(pendingTask, candidate) {
+  const expected = pendingTask.interruption;
+  return Boolean(
+    expected && candidate && candidate.sessionId === expected.sessionId && candidate.runId === expected.runId && candidate.taskEpoch === expected.taskEpoch && candidate.ownerGeneration === expected.ownerGeneration
+  );
+}
 function savePendingTask(repoRoot, task) {
   const historyDir = join162(repoRoot, OMNIUS_DIR2, "history");
   mkdirSync95(historyDir, { recursive: true });
-  writeFileSync85(
-    join162(historyDir, PENDING_TASK_FILE),
-    JSON.stringify(task, null, 2) + "\n",
-    "utf-8"
-  );
+  const filePath = join162(historyDir, PENDING_TASK_FILE);
+  const tempPath = `${filePath}.tmp-${process.pid}`;
+  const checkpoint = {
+    ...task,
+    schema: "omnius.pending-task.v2",
+    projectRoot: resolve77(repoRoot)
+  };
+  const payload = JSON.stringify(checkpoint, null, 2) + "\n";
+  writeFileSync85(tempPath, payload, "utf-8");
+  try {
+    renameSync30(tempPath, filePath);
+  } catch {
+    writeFileSync85(filePath, payload, "utf-8");
+    try {
+      unlinkSync37(tempPath);
+    } catch {
+    }
+  }
 }
 function loadPendingTask(repoRoot) {
   const filePath = join162(repoRoot, OMNIUS_DIR2, "history", PENDING_TASK_FILE);
   try {
     if (!existsSync148(filePath)) return null;
     const data = JSON.parse(readFileSync124(filePath, "utf-8"));
-    return data;
+    return isValidPendingTask(data, repoRoot) ? data : null;
   } catch {
     return null;
   }
@@ -732047,6 +732207,13 @@ function saveSessionContext(repoRoot, entry) {
         ctx3.entries.push(normalizedEntry);
       }
     }
+    ctx3.entries = ctx3.entries.map((item, index) => ({ item, index })).sort((a2, b) => {
+      const left = Date.parse(a2.item.savedAt || "");
+      const right = Date.parse(b.item.savedAt || "");
+      const leftTime = Number.isFinite(left) ? left : 0;
+      const rightTime = Number.isFinite(right) ? right : 0;
+      return leftTime - rightTime || a2.index - b.index;
+    }).map(({ item }) => item);
     if (ctx3.entries.length > ctx3.maxEntries) {
       ctx3.entries = ctx3.entries.slice(-ctx3.maxEntries);
     }
@@ -732180,80 +732347,12 @@ function isManualSessionEntry(entry) {
   const summary = normalizeSessionText(entry.summary || entry.assistantResponse, 160).toLowerCase();
   return entry.source === "manual" || task === "(manual save)" || entry.toolCalls === 0 && summary.startsWith("manual context save");
 }
-function isDeicticContinuationGoal(goal) {
-  const tokens3 = normalizeSessionText(cleanPromptForDiary(goal), 180).toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter(Boolean);
-  if (tokens3.length === 0 || tokens3.length > 14) return false;
-  const hasResumeVerb = tokens3.some(
-    (token) => token === "continue" || token === "resume" || token === "proceed" || token === "complete" || token === "finish"
-  );
-  if (!hasResumeVerb) return false;
-  const deicticCount = tokens3.filter((token) => DEICTIC_CONTINUATION_TERMS.has(token)).length;
-  return deicticCount / tokens3.length >= 0.7;
-}
 function readRestoreWorkboard(repoRoot, runId) {
   if (!runId) return null;
   return readJsonOrNull(
     join162(repoRoot, OMNIUS_DIR2, "workboards", runId, "active.json")
   );
 }
-function scoreRestoreLedger(ledger, workboard) {
-  const status = ledger.status || "open";
-  if (status === "approved") return -1e3;
-  const evidence = ledger.evidence ?? [];
-  const unresolvedCount = ledger.unresolved?.length ?? 0;
-  const activeCards = (workboard?.cards ?? []).filter(
-    (card) => card.status === "open" || card.status === "in_progress" || card.status === "needs_changes" || card.status === "blocked"
-  ).length;
-  const mutationTools = /* @__PURE__ */ new Set(["file_edit", "file_patch", "batch_edit", "file_write"]);
-  const mutationEvidence = evidence.filter((item) => mutationTools.has(item.toolName || "")).length;
-  const failedMutationEvidence = evidence.filter(
-    (item) => mutationTools.has(item.toolName || "") && item.success === false
-  ).length;
-  const targetPathEvidence = evidence.filter((item) => (item.targetPaths?.length ?? 0) > 0).length;
-  const blockedEvidence = evidence.filter((item) => {
-    const summary = String(item.summary ?? "").toLowerCase();
-    return summary.includes("[focus supervisor block]") || summary.includes("stale") || summary.includes("blocked");
-  }).length;
-  let score = 0;
-  if (status === "open") score += 10;
-  else if (status === "incomplete_verification") score += 18;
-  else if (status === "request_changes" || status === "blocked") score += 16;
-  else score += 4;
-  score += Math.min(evidence.length, 20);
-  score += Math.min(unresolvedCount, 10) * 4;
-  score += Math.min(activeCards, 8) * 3;
-  score += Math.min(mutationEvidence, 8) * 5;
-  score += Math.min(failedMutationEvidence, 8) * 3;
-  score += Math.min(targetPathEvidence, 6) * 2;
-  score += Math.min(blockedEvidence, 6) * 2;
-  const goal = normalizeSessionText(ledger.goal, 260);
-  if (goal.length >= 80) score += 5;
-  if (isDeicticContinuationGoal(goal) && mutationEvidence === 0 && unresolvedCount === 0 && activeCards === 0) {
-    score -= 25;
-  }
-  return score;
-}
-function selectActiveTaskAnchor(repoRoot) {
-  const ledgerDir = join162(repoRoot, OMNIUS_DIR2, "completion-ledgers");
-  try {
-    if (!existsSync148(ledgerDir)) return null;
-    const candidates = readdirSync48(ledgerDir).filter((name10) => name10.endsWith(".json")).map((name10) => {
-      const filePath = join162(ledgerDir, name10);
-      const ledger = readJsonOrNull(filePath);
-      if (!ledger || !ledger.goal) return null;
-      const runId = ledger.runId || name10.replace(/\.json$/, "");
-      const workboard = readRestoreWorkboard(repoRoot, runId);
-      const score = scoreRestoreLedger(ledger, workboard);
-      const mtimeMs = statSync58(filePath).mtimeMs;
-      return { ledger: { ...ledger, runId }, workboard, score, mtimeMs };
-    }).filter((item) => Boolean(item));
-    candidates.sort((a2, b) => b.score - a2.score || b.mtimeMs - a2.mtimeMs);
-    const selected = candidates.find((candidate) => candidate.score >= 18);
-    return selected ?? null;
-  } catch {
-    return null;
-  }
-}
 function formatActiveTaskAnchor(selected) {
   const ledger = selected.ledger;
   const evidence = ledger.evidence ?? [];
@@ -732285,31 +732384,9 @@ ${evidenceLines.join("\n")}
 ${unresolvedLines.join("\n")}
 ` : "") + (boardCards.length > 0 ? `Active workboard cards:
 ${boardCards.join("\n")}
-` : "") + `Continuation rule: when the user asks to continue, resume this active task unless the new prompt names a different target.
+` : "") + `Continuation rule: this frontier is active only because its exact durable interruption identity was selected.
 </active-task-anchor>`;
 }
-function uniqueSessionIds(ids) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const raw of ids) {
-    const id2 = String(raw || "").trim();
-    if (!id2 || seen.has(id2)) continue;
-    seen.add(id2);
-    out.push(id2);
-  }
-  return out;
-}
-function collectRestoreSessionIds(ctx3, activeTask, historySessionId) {
-  const entries2 = ctx3?.entries ?? [];
-  const usefulEntries = entries2.filter((entry) => !isManualSessionEntry(entry));
-  const chronological = usefulEntries.length > 0 ? usefulEntries : entries2;
-  return uniqueSessionIds([
-    activeTask?.ledger.runId,
-    ...[...chronological].reverse().map((entry) => entry.sessionId),
-    ...[...entries2].reverse().map((entry) => entry.sessionId),
-    historySessionId
-  ]);
-}
 function childMapForTodos(todos) {
   const byId = new Set(todos.map((todo) => todo.id));
   const byParent = /* @__PURE__ */ new Map();
@@ -732382,20 +732459,8 @@ ${treeLines.join("\n")}${omitted > 0 ? `
 Continuation contract: this is the live checklist from the restored run. Continue it and update it with todo_write; do not recreate a parallel plan unless the new user request explicitly changes direction.
 </restored-todo-state>`;
 }
-function findRestoredTodoState(sessionIds) {
-  for (const sessionId of sessionIds) {
-    const todos = readTodos(sessionId).filter((todo) => todo && todo.id && todo.content);
-    if (todos.length === 0) continue;
-    return {
-      sessionId,
-      todos,
-      block: buildRestoredTodoBlock(sessionId, todos)
-    };
-  }
-  return null;
-}
-function buildRestoreHistoryAnchor(repoRoot) {
-  const [latest] = listSessions(repoRoot);
+function buildRestoreHistoryAnchor(repoRoot, exactSessionId) {
+  const latest = exactSessionId ? listSessions(repoRoot).find((entry) => entry.id === exactSessionId) : listSessions(repoRoot)[0];
   if (!latest?.id) return null;
   const lines = loadSessionHistory(repoRoot, latest.id) ?? [];
   const recordedLineCount = lines.filter((line) => String(line ?? "").trim()).length;
@@ -732411,6 +732476,76 @@ Recall contract: do not replay or ingest the transcript wholesale. Use the struc
 </restored-interface-history>`;
   return { sessionId: latest.id, path: path16, lineCount: recordedLineCount, block };
 }
+function buildExactContinuationSnapshot(repoRoot, pendingTask) {
+  const identity3 = pendingTask.interruption;
+  if (!identity3) return null;
+  if (pendingTask.projectRoot && resolve77(pendingTask.projectRoot) !== resolve77(repoRoot)) {
+    return null;
+  }
+  const ledgerPath2 = join162(
+    repoRoot,
+    OMNIUS_DIR2,
+    "completion-ledgers",
+    `${identity3.runId}.json`
+  );
+  const rawLedger = readJsonOrNull(ledgerPath2);
+  const ledger = rawLedger && (!rawLedger.runId || rawLedger.runId === identity3.runId) && (!rawLedger.taskEpoch || rawLedger.taskEpoch === identity3.taskEpoch) ? { ...rawLedger, runId: identity3.runId } : null;
+  const rawWorkboard = readRestoreWorkboard(repoRoot, identity3.runId);
+  const workboard = rawWorkboard && (!rawWorkboard.runId || rawWorkboard.runId === identity3.runId) && (!rawWorkboard.taskEpoch || rawWorkboard.taskEpoch === identity3.taskEpoch) ? rawWorkboard : null;
+  const activeTaskAnchor = ledger ? formatActiveTaskAnchor({ ledger, workboard }) : null;
+  const exactTodos = readTodos(identity3.sessionId).filter(
+    (todo) => todo && todo.id && todo.content
+  );
+  const restoredTodos = exactTodos.length > 0 ? {
+    sessionId: identity3.sessionId,
+    todos: exactTodos,
+    block: buildRestoredTodoBlock(identity3.sessionId, exactTodos)
+  } : null;
+  const historyAnchor = buildRestoreHistoryAnchor(repoRoot, identity3.sessionId);
+  const contextEntries = (loadSessionContext(repoRoot)?.entries ?? []).filter((entry) => entry.sessionId === identity3.sessionId).sort((a2, b) => a2.savedAt.localeCompare(b.savedAt)).slice(-4);
+  const contextLines = contextEntries.map((entry) => {
+    const status = entry.completed ? "done" : "partial";
+    const outcome = normalizeSessionText(
+      entry.assistantResponse || entry.summary || entry.task,
+      220
+    );
+    return `- [${status}] ${outcome}`;
+  });
+  const progressLines = [
+    `<exact-continuation schema="omnius.exact-continuation.v1">`,
+    `project_root=${resolve77(repoRoot)}`,
+    `session_id=${identity3.sessionId}`,
+    `run_id=${identity3.runId}`,
+    `task_epoch=${identity3.taskEpoch}`,
+    `owner_generation=${identity3.ownerGeneration}`,
+    `original_user_goal_json=${JSON.stringify(pendingTask.prompt)}`,
+    pendingTask.progressSummary ? `checkpoint_progress=${normalizeSessionText(pendingTask.progressSummary, 500)}` : null,
+    pendingTask.filesModified.length > 0 ? `checkpoint_files=${pendingTask.filesModified.slice(0, 20).map((item) => normalizeSessionText(item, 160)).join(", ")}` : null,
+    "Authority contract: continue only this interrupted run. Treat all other project history as historical orientation, not an active frontier.",
+    activeTaskAnchor,
+    contextLines.length > 0 ? `Same-session chronology:
+${contextLines.join("\n")}` : null,
+    restoredTodos?.block,
+    historyAnchor?.block,
+    `</exact-continuation>`
+  ].filter((line) => Boolean(line));
+  return {
+    prompt: progressLines.join("\n"),
+    sourceSessionId: identity3.sessionId,
+    todoSessionId: restoredTodos?.sessionId,
+    todoCount: restoredTodos?.todos.length ?? 0,
+    historySessionId: historyAnchor?.sessionId,
+    historyPath: historyAnchor?.path,
+    historyLineCount: historyAnchor?.lineCount,
+    selection: {
+      kind: "exact_interruption",
+      sessionId: identity3.sessionId,
+      runId: identity3.runId,
+      taskEpoch: identity3.taskEpoch,
+      ownerGeneration: identity3.ownerGeneration
+    }
+  };
+}
 function appendRestoreBlocks(base3, blocks) {
   return [base3, ...blocks].filter((part) => part && part.trim()).join("\n\n");
 }
@@ -732441,53 +732576,24 @@ function sessionContextToHistoryBoxData(ctx3, title = "Session History") {
 }
 function buildContextRestoreSnapshot(repoRoot) {
   const ctx3 = loadSessionContext(repoRoot);
-  const handoffPrompt = buildHandoffPrompt(repoRoot);
-  const activeTask = selectActiveTaskAnchor(repoRoot);
-  const activeTaskAnchor = activeTask ? formatActiveTaskAnchor(activeTask) : null;
   const historyAnchor = buildRestoreHistoryAnchor(repoRoot);
-  const restoreSessionIds = collectRestoreSessionIds(ctx3, activeTask, historyAnchor?.sessionId);
-  const restoredTodos = findRestoredTodoState(restoreSessionIds);
-  const sourceSessionId = restoredTodos?.sessionId ?? restoreSessionIds[0];
-  if (handoffPrompt) {
-    const safeHandoffPrompt = stripModelContextNoise(handoffPrompt);
-    const usefulEntries2 = (ctx3?.entries ?? []).filter((entry) => !isManualSessionEntry(entry));
-    const baseCtx = ctx3 && ctx3.entries.length > 0 ? `
-
-<session-recap>
-Recent tasks: ${(usefulEntries2.length > 0 ? usefulEntries2 : ctx3.entries).slice(-3).map(
-      (e2) => `[${e2.completed ? "done" : "partial"}] ${normalizeSessionText(e2.summary || e2.task, 80)}`
-    ).join(", ")}
-</session-recap>` : "";
-    const prompt2 = appendRestoreBlocks(
-      safeHandoffPrompt + (activeTaskAnchor ? `
-
-${activeTaskAnchor}` : "") + baseCtx,
-      [restoredTodos?.block, historyAnchor?.block]
-    );
-    return {
-      prompt: prompt2,
-      sourceSessionId,
-      todoSessionId: restoredTodos?.sessionId,
-      todoCount: restoredTodos?.todos.length ?? 0,
-      historySessionId: historyAnchor?.sessionId,
-      historyPath: historyAnchor?.path,
-      historyLineCount: historyAnchor?.lineCount
-    };
-  }
+  const usefulEntries = (ctx3?.entries ?? []).filter(
+    (entry) => !isManualSessionEntry(entry)
+  );
+  const chronological = usefulEntries.length > 0 ? usefulEntries : ctx3?.entries ?? [];
+  const sourceSessionId = chronological.at(-1)?.sessionId ?? historyAnchor?.sessionId;
   if (!ctx3 || ctx3.entries.length === 0) {
-    const prompt2 = appendRestoreBlocks(activeTaskAnchor ?? "", [restoredTodos?.block, historyAnchor?.block]);
+    const prompt2 = appendRestoreBlocks("", [historyAnchor?.block]);
     if (!prompt2.trim()) return null;
     return {
       prompt: prompt2,
       sourceSessionId,
-      todoSessionId: restoredTodos?.sessionId,
-      todoCount: restoredTodos?.todos.length ?? 0,
+      todoCount: 0,
       historySessionId: historyAnchor?.sessionId,
       historyPath: historyAnchor?.path,
       historyLineCount: historyAnchor?.lineCount
     };
   }
-  const usefulEntries = ctx3.entries.filter((entry) => !isManualSessionEntry(entry));
   const recent = (usefulEntries.length > 0 ? usefulEntries : ctx3.entries).slice(-20);
   const chronology = recent.map((e2) => {
     const status = e2.completed ? "done" : "partial";
@@ -732511,9 +732617,7 @@ Provenance: ${last2.provenance} (file_read to expand)` : "";
 KG summary: .omnius/context/kg-summary/latest.md (file_read to expand; legacy pointer: .omnius/context/kg-summary-latest.md)`;
   const prompt = appendRestoreBlocks(
     `<session-recap>
-` + (activeTaskAnchor ? `${activeTaskAnchor}
-
-` : "") + `Project chronology (older to newer):
+Project chronology (older to newer):
 Scope: full retained rolling window (${recent.length} entr${recent.length === 1 ? "y" : "ies"}).
 ${chronology.join("\n")}
 ` + (latestCompleted ? `
@@ -732521,16 +732625,14 @@ ${latestCompleted}
 ` : "\n") + `
 Recent structured task state (older to newer; transcript omitted from model context):
 ${recentTaskState}
-` + (activeTaskAnchor ? `For continuation prompts, resume the active task anchor above; use chronology only to avoid repeating completed work.${prov}${kg}
-` : `Continue from the latest exchange and do not repeat completed work.${prov}${kg}
-`) + `</session-recap>`,
-    [restoredTodos?.block, historyAnchor?.block]
+This chronology is historical orientation only. It does not select an active task, todo tree, or run. Use an exact interruption checkpoint or an explicit lifecycle command for continuation authority.${prov}${kg}
+</session-recap>`,
+    [historyAnchor?.block]
   );
   return {
     prompt,
     sourceSessionId,
-    todoSessionId: restoredTodos?.sessionId,
-    todoCount: restoredTodos?.todos.length ?? 0,
+    todoCount: 0,
     historySessionId: historyAnchor?.sessionId,
     historyPath: historyAnchor?.path,
     historyLineCount: historyAnchor?.lineCount
@@ -732982,7 +733084,7 @@ function deleteUsageRecord(kind, value2, repoRoot) {
     remove(join162(repoRoot, OMNIUS_DIR2, USAGE_HISTORY_FILE));
   }
 }
-var OMNIUS_DIR2, LEGACY_DIRS, SUBDIRS, gitignoreWatchers, gitignoreRetryTimers, CONTEXT_FILES, PENDING_TASK_FILE, HANDOFF_FILE, CONTEXT_SAVE_FILE, CONTEXT_LEDGER_FILE, COMPACTION_AUDIT_FILE, MAX_CONTEXT_ENTRIES, MAX_SESSION_DIARY_ENTRIES, MAX_SESSION_DIARY_DETAILED_ENTRIES, MAX_CONTEXT_LEDGER_LINES, MAX_CONTEXT_LEDGER_BYTES, SAME_TASK_REPLACE_WINDOW_MS, LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_RETRY_MAX, MODEL_CONTEXT_NOISE_LINE_RE, DEFAULT_RESTORED_SESSION_HISTORY_MAX_LINES, DEICTIC_CONTINUATION_TERMS, SESSIONS_DIR, SESSIONS_INDEX, TUI_STATE_SUFFIX, AUTHORED_SESSION_LINE, VISUAL_CHROME_LINE, SESSION_TITLE_STATUS_LINE, SKIP_DIRS2, HOME_SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
+var OMNIUS_DIR2, LEGACY_DIRS, SUBDIRS, gitignoreWatchers, gitignoreRetryTimers, CONTEXT_FILES, PENDING_TASK_FILE, HANDOFF_FILE, CONTEXT_SAVE_FILE, CONTEXT_LEDGER_FILE, COMPACTION_AUDIT_FILE, MAX_CONTEXT_ENTRIES, MAX_SESSION_DIARY_ENTRIES, MAX_SESSION_DIARY_DETAILED_ENTRIES, MAX_CONTEXT_LEDGER_LINES, MAX_CONTEXT_LEDGER_BYTES, SAME_TASK_REPLACE_WINDOW_MS, LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_RETRY_MAX, MODEL_CONTEXT_NOISE_LINE_RE, DEFAULT_RESTORED_SESSION_HISTORY_MAX_LINES, SESSIONS_DIR, SESSIONS_INDEX, TUI_STATE_SUFFIX, AUTHORED_SESSION_LINE, VISUAL_CHROME_LINE, SESSION_TITLE_STATUS_LINE, SKIP_DIRS2, HOME_SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
 var init_omnius_directory = __esm({
   "packages/cli/src/tui/omnius-directory.ts"() {
     init_dist5();
@@ -733019,34 +733121,6 @@ var init_omnius_directory = __esm({
     LOCK_RETRY_MAX = 100;
     MODEL_CONTEXT_NOISE_LINE_RE = /^\s*(?:🔊|E Task timeout reached|E Incomplete:|⚠ Task incomplete|Tokens:\s*[\d,]+|▹\s*continue\b|·\s*(?:Starting fresh|Context (?:auto-)?restored|Nexus P2P network connected|REST API:|Voice feedback enabled|Memory maintenance:|Memory:|reclaimed\s+(?:\d|space\b)|physical footprint:)|.*\bSHELL TRANSCRIPT\b.*).*$/i;
     DEFAULT_RESTORED_SESSION_HISTORY_MAX_LINES = 600;
-    DEICTIC_CONTINUATION_TERMS = /* @__PURE__ */ new Set([
-      "again",
-      "and",
-      "back",
-      "carry",
-      "complete",
-      "continue",
-      "finish",
-      "from",
-      "last",
-      "latest",
-      "left",
-      "my",
-      "off",
-      "please",
-      "previous",
-      "prior",
-      "proceed",
-      "request",
-      "resume",
-      "task",
-      "that",
-      "the",
-      "this",
-      "to",
-      "try",
-      "work"
-    ]);
     SESSIONS_DIR = "sessions";
     SESSIONS_INDEX = "sessions-index.json";
     TUI_STATE_SUFFIX = ".tui-state.json";
@@ -767195,7 +767269,7 @@ sleep 1
       }
       const paused = ctx3.pauseTask?.() ?? false;
       if (interruptionAccepted(paused)) {
-        ctx3.savePendingTaskState?.();
+        ctx3.savePendingTaskState?.({ reason: "pause", resumeOnStartup: false });
         renderInfo(interruptionMessage(paused, "Task paused."));
       } else {
         renderWarning(interruptionMessage(paused, "Could not pause the task."));
@@ -777335,7 +777409,7 @@ async function handleUpdate(subcommand, ctx3) {
         `Updated Omnius v${currentVersion} → v${terminal.installed_version ?? info.latestVersion}; daemon v${terminal.daemon_version ?? info.latestVersion}${terminal.tray_was_running ? ", indicator restarted" : ""}.`
       );
       ctx3.contextSave?.();
-      ctx3.savePendingTaskState?.();
+      ctx3.savePendingTaskState?.({ reason: "update", resumeOnStartup: true });
       if (ctx3.hasActiveTask?.()) ctx3.abortActiveTask?.({ preserveResume: true });
       ctx3.killEphemeral?.({ preserveInfrastructure: true });
       process.exit(120);
@@ -777924,7 +777998,7 @@ async function handleUpdate(subcommand, ctx3) {
     !daemonUpgrade.ok ? `Daemon still at ${daemonUpgrade.observedVersion ?? "unknown"} — restarting client anyway` : daemonUpgrade.action === "restarted" ? `Daemon upgraded to ${expectedDaemonVersion}` : `Daemon verified at ${expectedDaemonVersion}`
   );
   ctx3.contextSave?.();
-  const hadActiveTask = ctx3.savePendingTaskState?.() ?? false;
+  const hadActiveTask = ctx3.savePendingTaskState?.({ reason: "update", resumeOnStartup: true }) ?? false;
   const resumeFlag = hadActiveTask ? "1" : "update-only";
   installOverlay.stop("Restarting with new version...");
   await new Promise((r2) => setTimeout(r2, 1500));
@@ -803546,13 +803620,12 @@ function normalizeTelegramCallbackQuery(update2) {
   };
 }
 function adaptTool5(tool, todoSessionId, progress) {
+  if (todoSessionId && (tool.name === "todo_write" || tool.name === "todo_read")) {
+    tool.bindExecutionScope?.({ sessionId: todoSessionId });
+  }
   return adaptExecutionTool(tool, {
     onProgress: (toolName, event) => progress?.onProgress(toolName, event),
-    execute: async (_tool, args, invoke) => {
-      const previousTodoSession = todoSessionId ? getTodoSessionId() : "";
-      if (todoSessionId && (tool.name === "todo_write" || tool.name === "todo_read")) {
-        setTodoSessionId(todoSessionId);
-      }
+    execute: async (_tool, _args, invoke) => {
       try {
         const result = await invoke();
         progress?.complete(tool.name, result);
@@ -803564,10 +803637,6 @@ function adaptTool5(tool, todoSessionId, progress) {
           error: err instanceof Error ? err.message : String(err)
         });
         throw err;
-      } finally {
-        if (todoSessionId && (tool.name === "todo_write" || tool.name === "todo_read")) {
-          setTodoSessionId(previousTodoSession);
-        }
       }
     }
   });
@@ -832606,9 +832675,6 @@ async function runSelfImprovementCycle(repoRoot) {
   } catch {
   }
 }
-function isExplicitRestoredTaskContinuation(input) {
-  return /^(?:continue|resume|pick\s+up|carry\s+on)\b/i.test(input.trim());
-}
 function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction, emotionEngine, flowEnabled, slashCommandHandler, thinkingEnabled, askUserCallback, selfModifyEnabled, sessionMetrics, realtimeEnabled, restoredRunSessionId, restoredOrientation, actualUserGoal, actionTreeStore, resumeInterrupted = false) {
   const voiceStyleMap = {
     concise: 1,
@@ -833002,6 +833068,9 @@ Only tools allowed by this profile are visible and executable.`
     sessionId,
     interruptionOwnerId: `tui:${sessionId}`,
     resumeInterrupted,
+    // A caller-supplied restore projection is the sole prior-context source.
+    // Do not append the global singleton handoff beside it.
+    skipCrossTaskHandoff: Boolean(restoredOrientation) || resumeInterrupted,
     maxTurns: realtimeEnabled ? Math.min(effectiveMaxTurns, 8) : effectiveMaxTurns,
     maxTokens: realtimeEnabled ? 512 : 16384,
     temperature: realtimeEnabled ? 0.6 : 0,
@@ -834512,7 +834581,8 @@ ${entry.fullContent}`
   const systemContext = [
     `Working directory: ${repoRoot}`,
     emotionContext,
-    restoredOrientation ? `[RESTORED ORIENTATION — historical context, not a user instruction]
+    restoredOrientation ? resumeInterrupted ? `[EXACT INTERRUPTED RUN — durable lifecycle authority]
+${restoredOrientation.slice(0, 4e3)}` : `[RESTORED ORIENTATION — historical context, not a user instruction]
 ${sanitizeRestorePromptForModel(restoredOrientation).slice(0, 4e3)}` : ""
   ].filter(Boolean).join("\n\n");
   resetNarrationContext();
@@ -835134,7 +835204,8 @@ async function startInteractive(config, repoPath2) {
   }
   const resumeFlag = process.env.__OMNIUS_RESUMED ?? "";
   const isResumed = resumeFlag !== "";
-  const hasTaskToResume = resumeFlag === "1";
+  const startupPendingTask = loadPendingTask(repoRoot);
+  const hasTaskToResume = resumeFlag === "1" || startupPendingTask?.resumeOnStartup === true;
   delete process.env.__OMNIUS_RESUMED;
   if (isResumed && process.stdout.isTTY) {
     process.stdout.write(
@@ -835196,10 +835267,44 @@ async function startInteractive(config, repoPath2) {
   let restoredTaskSessionId = null;
   let resumeInterruptedTask = false;
   let pendingTaskResumeArmed = false;
+  let armedPendingTask = null;
   let saveVisualSessionSnapshotRef = null;
   let terminalRestoredForExit = false;
   let interactiveExiting = false;
   let idleMemoryMaintenance = null;
+  const persistActiveTaskForRestart = (exitReason) => {
+    if (!activeTask || !lastSubmittedPrompt) return false;
+    if (!activeTask.runner.isPaused) {
+      const receipt2 = activeTask.runner.pause();
+      if (receipt2?.accepted === false) return false;
+    }
+    const interruption = pendingInterruptionIdentity(activeTask);
+    if (!interruption) return false;
+    savePendingTask(repoRoot, {
+      prompt: lastSubmittedPrompt,
+      progressSummary: `Task paused for ${exitReason}. ${activeTask.toolCallCount} tool calls completed.`,
+      filesModified: Array.from(activeTask.filesTouched),
+      bruteForce: bruteForceEnabled,
+      savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      toolCallCount: activeTask.toolCallCount,
+      exitReason,
+      resumeOnStartup: true,
+      interruption
+    });
+    return true;
+  };
+  const armPendingTaskResume = (pendingTask) => {
+    restoredTaskSessionId = pendingTask.interruption?.sessionId ?? null;
+    resumeInterruptedTask = Boolean(pendingTask.interruption);
+    pendingTaskResumeArmed = true;
+    armedPendingTask = pendingTask;
+    const exactSnapshot = buildExactContinuationSnapshot(repoRoot, pendingTask);
+    restoredSessionContext = exactSnapshot?.prompt ?? [
+      `Original user goal: ${pendingTask.prompt}`,
+      pendingTask.progressSummary,
+      pendingTask.filesModified.length > 0 ? `Modified: ${pendingTask.filesModified.slice(0, 20).join(", ")}` : ""
+    ].filter(Boolean).join("\n");
+  };
   const restoreTerminalForExit = () => {
     if (!process.stdout.isTTY || terminalRestoredForExit) return;
     terminalRestoredForExit = true;
@@ -835231,18 +835336,7 @@ async function startInteractive(config, repoPath2) {
       }
       if (activeTask) {
         if (interruption === "pause") {
-          const receipt2 = activeTask.runner.pause();
-          if (receipt2?.accepted !== false && lastSubmittedPrompt) {
-            savePendingTask(repoRoot, {
-              prompt: lastSubmittedPrompt,
-              progressSummary: `Task paused during process shutdown. ${activeTask.toolCallCount} tool calls completed.`,
-              filesModified: Array.from(activeTask.filesTouched),
-              bruteForce: bruteForceEnabled,
-              savedAt: (/* @__PURE__ */ new Date()).toISOString(),
-              toolCallCount: activeTask.toolCallCount,
-              interruption: pendingInterruptionIdentity(activeTask)
-            });
-          }
+          persistActiveTaskForRestart("shutdown");
         } else {
           activeTask.runner.abort();
           discardPendingTask(repoRoot);
@@ -837089,9 +837183,9 @@ This is an independent background session started from /background.`
     if (options2.injectNextTask !== false) {
       restoredSessionContext = snapshot.prompt;
     }
-    const restoredId = snapshot.todoSessionId || snapshot.sourceSessionId || null;
-    restoredTaskSessionId = restoredId;
-    if (restoredId) {
+    const restoredId = options2.bindTaskIdentity && snapshot.selection ? snapshot.selection.sessionId : null;
+    if (restoredId && snapshot.selection?.kind === "exact_interruption") {
+      restoredTaskSessionId = restoredId;
       try {
         process.env["OMNIUS_SESSION_ID"] = restoredId;
       } catch {
@@ -838195,8 +838289,14 @@ The user pasted a clipboard image saved at ${relPath}. Use the OCR, vision analy
       } catch {
       }
     },
-    savePendingTaskState() {
+    savePendingTaskState(options2) {
       if (lastSubmittedPrompt && activeTask) {
+        if (!activeTask.runner.isPaused) {
+          const receipt2 = activeTask.runner.pause();
+          if (receipt2?.accepted === false) return false;
+        }
+        const interruption = pendingInterruptionIdentity(activeTask);
+        if (!interruption) return false;
         const activeToolCallCount = activeTask.toolCallCount;
         const activeFilesTouched = Array.from(activeTask.filesTouched);
         savePendingTask(repoRoot, {
@@ -838206,7 +838306,9 @@ The user pasted a clipboard image saved at ${relPath}. Use the OCR, vision analy
           bruteForce: bruteForceEnabled,
           savedAt: (/* @__PURE__ */ new Date()).toISOString(),
           toolCallCount: activeToolCallCount,
-          interruption: pendingInterruptionIdentity(activeTask)
+          exitReason: options2?.reason ?? "pause",
+          resumeOnStartup: options2?.resumeOnStartup === true,
+          interruption
         });
         return true;
       }
@@ -839881,19 +839983,11 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     resumeTask() {
       const pendingTask = loadPendingTask(repoRoot);
       if (!pendingTask) return false;
-      restoredTaskSessionId = pendingTask.interruption?.sessionId ?? null;
-      resumeInterruptedTask = Boolean(pendingTask.interruption);
-      pendingTaskResumeArmed = true;
+      armPendingTaskResume(pendingTask);
       setTimeout(() => {
-        const resumeContext = [
-          `Continuing previous task: ${pendingTask.prompt}`,
-          pendingTask.progressSummary ? `Progress: ${pendingTask.progressSummary}` : "",
-          pendingTask.filesModified.length > 0 ? `Modified: ${pendingTask.filesModified.slice(0, 5).join(", ")}` : "",
-          "Continue where you left off."
-        ].filter(Boolean).join("\n");
         const shortPrompt = pendingTask.prompt.slice(0, 40) + (pendingTask.prompt.length > 40 ? "..." : "");
         writeContent(() => renderInfo(`Picking up: ${shortPrompt}`));
-        rl.emit("line", resumeContext);
+        rl.emit("line", pendingTask.prompt);
       }, 100);
       return true;
     },
@@ -840151,7 +840245,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
   }
   statusBar.ensureMonitorTimer();
   showPrompt();
-  if (!isResumed) {
+  if (!isResumed && !hasTaskToResume) {
     const savedCtx = loadSessionContext(repoRoot);
     if (savedCtx && savedCtx.entries.length > 0) {
       const lastEntry = savedCtx.entries[savedCtx.entries.length - 1];
@@ -840277,30 +840371,13 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
   }
   startReminderDispatcher();
   if (hasTaskToResume) {
-    const pendingTask = loadPendingTask(repoRoot);
+    const pendingTask = startupPendingTask ?? loadPendingTask(repoRoot);
     if (pendingTask) {
-      restoredTaskSessionId = pendingTask.interruption?.sessionId ?? null;
-      resumeInterruptedTask = Boolean(pendingTask.interruption);
-      pendingTaskResumeArmed = true;
+      armPendingTaskResume(pendingTask);
       setTimeout(() => {
-        const restoreSnapshot = buildContextRestoreSnapshot(repoRoot);
-        if (restoreSnapshot) {
-          applyRestoreSnapshot(restoreSnapshot, {
-            replayVisual: false,
-            injectNextTask: false
-          });
-        }
-        const sessionCtx = restoreSnapshot?.prompt ?? buildContextRestorePrompt(repoRoot);
-        const resumeContext = [
-          sessionCtx || "",
-          `Continuing task after update: ${pendingTask.prompt}`,
-          pendingTask.progressSummary ? `Progress: ${pendingTask.progressSummary}` : "",
-          pendingTask.filesModified.length > 0 ? `Modified: ${pendingTask.filesModified.slice(0, 5).join(", ")}` : "",
-          "Continue where you left off."
-        ].filter(Boolean).join("\n");
         const shortPrompt = pendingTask.prompt.slice(0, 40) + (pendingTask.prompt.length > 40 ? "..." : "");
         writeContent(() => renderInfo(`Picking up: ${shortPrompt}`));
-        rl.emit("line", resumeContext);
+        rl.emit("line", pendingTask.prompt);
       }, 100);
     }
   }
@@ -840492,10 +840569,7 @@ ${result.content.slice(0, 2e3)}${result.content.length > 2e3 ? "\n[truncated]" :
       if (quitMatch === "quit" || quitMatch === "exit" || quitMatch === "q") {
         interactiveExiting = true;
         saveVisualSessionSnapshot();
-        if (activeTask) {
-          activeTask.runner.abort();
-          discardPendingTask(repoRoot);
-        }
+        if (activeTask) persistActiveTaskForRestart("quit");
         idleMemoryMaintenance?.stop();
         taskManager.stopAll();
         if (blessEngine?.isActive) blessEngine.stop();
@@ -840513,10 +840587,7 @@ ${result.content.slice(0, 2e3)}${result.content.length > 2e3 ? "\n[truncated]" :
       if (cmdResult === "exit") {
         interactiveExiting = true;
         saveVisualSessionSnapshot();
-        if (activeTask) {
-          activeTask.runner.abort();
-          discardPendingTask(repoRoot);
-        }
+        if (activeTask) persistActiveTaskForRestart("quit");
         idleMemoryMaintenance?.stop();
         taskManager.stopAll();
         if (telegramBridge) await telegramBridge.stopAndWait();
@@ -841078,6 +841149,10 @@ ${formatTaskCompletionMeta(previousMetaForIntake)}`
       );
     }
     if (promptRecallCancelled) return;
+    const pendingTaskForAdmission = pendingTaskResumeArmed ? armedPendingTask : null;
+    if (pendingTaskForAdmission) {
+      fullInput = pendingTaskForAdmission.prompt;
+    }
     lastSubmittedPrompt = fullInput;
     const taskPreview = fullInput.length > 100 ? fullInput.slice(0, 100) + "..." : fullInput;
     emotionEngine.setCurrentTask(taskPreview);
@@ -841094,18 +841169,19 @@ ${formatTaskCompletionMeta(previousMetaForIntake)}`
     } catch {
     }
     let taskInput = fullInput;
-    const reuseRestoredTaskSession = Boolean(restoredTaskSessionId) && (resumeInterruptedTask || isExplicitRestoredTaskContinuation(fullInput));
+    const reuseRestoredTaskSession = Boolean(restoredTaskSessionId) && resumeInterruptedTask && Boolean(pendingTaskForAdmission?.interruption);
     let taskSessionId = reuseRestoredTaskSession ? restoredTaskSessionId : null;
     const adoptInterruptedGeneration = reuseRestoredTaskSession && resumeInterruptedTask;
     const consumePendingTaskAfterAdmission = pendingTaskResumeArmed;
     let restoredOrientation = null;
     if (restoredSessionContext) {
-      restoredOrientation = sanitizeRestorePromptForModel(restoredSessionContext);
+      restoredOrientation = pendingTaskForAdmission ? restoredSessionContext : sanitizeRestorePromptForModel(restoredSessionContext);
       restoredSessionContext = null;
     }
     restoredTaskSessionId = null;
     resumeInterruptedTask = false;
     pendingTaskResumeArmed = false;
+    armedPendingTask = null;
     if (taskIntakePacket) {
       taskInput = `${taskIntakePacket}
 
@@ -841162,14 +841238,23 @@ ${taskInput}`;
         realtimeEnabled,
         taskSessionId,
         restoredOrientation,
-        fullInput,
+        pendingTaskForAdmission?.prompt ?? fullInput,
         idleActionTree,
         adoptInterruptedGeneration
       );
       activeTask = task;
       if (consumePendingTaskAfterAdmission) {
         const adopted = task.runner.interruptionState;
-        if (!adoptInterruptedGeneration || adopted?.phase === "running" && adopted.sessionId === taskSessionId) {
+        if (pendingTaskForAdmission && !pendingTaskForAdmission.interruption || pendingTaskForAdmission && pendingTaskMatchesRunningInterruption(
+          pendingTaskForAdmission,
+          adopted ? {
+            sessionId: adopted.sessionId,
+            runId: adopted.runId,
+            taskEpoch: adopted.taskEpoch,
+            ownerGeneration: adopted.owner.generation,
+            phase: adopted.phase
+          } : null
+        )) {
           discardPendingTask(repoRoot);
         }
       }
@@ -841227,6 +841312,21 @@ ${taskInput}`;
         scheduleAgentSNREval(lastSubmittedPrompt);
       }
       if (activeTask) {
+        if (pendingTaskForAdmission?.interruption) {
+          const state5 = activeTask.runner.interruptionState;
+          if (state5 && state5.phase !== "running" && state5.phase !== "pausing" && state5.phase !== "paused" && state5.phase !== "resuming" && pendingTaskMatchesInterruptionIdentity(
+            pendingTaskForAdmission,
+            {
+              sessionId: state5.sessionId,
+              runId: state5.runId,
+              taskEpoch: state5.taskEpoch,
+              ownerGeneration: state5.owner.generation,
+              phase: state5.phase
+            }
+          )) {
+            discardPendingTask(repoRoot);
+          }
+        }
         sessionFilesTouched = Array.from(activeTask.filesTouched);
         sessionToolCallCount = activeTask.toolCallCount;
         sessionAvailableTools = Array.from(activeTask.availableTools);
@@ -841506,7 +841606,7 @@ Rationale: ${proposal.rationale}${provenanceNote}${dmnDevDiscipline(proposal.cat
       peerMesh = null;
       inferenceRouter = null;
     }
-    if (activeTask) activeTask.runner.abort();
+    if (activeTask) persistActiveTaskForRestart("shutdown");
     taskManager.stopAll();
     killAllFullSubAgents();
     idleMemoryMaintenance?.stop();
@@ -841600,6 +841700,8 @@ ${c3.dim("(Use /quit to exit)")}
         bruteForce: bruteForceEnabled,
         savedAt: (/* @__PURE__ */ new Date()).toISOString(),
         toolCallCount: activeTask.toolCallCount,
+        exitReason: "pause",
+        resumeOnStartup: false,
         interruption: pendingInterruptionIdentity(activeTask)
       });
     }