omnius 1.0.689 → 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();
@@ -664559,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);
@@ -664591,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(),
@@ -664616,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,
@@ -664629,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. */
@@ -665097,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));
@@ -674042,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") {
@@ -674965,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;
       }
       /**
@@ -674997,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",
@@ -676829,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();
@@ -676861,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");
@@ -676874,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,
@@ -677151,7 +677257,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this._fileRegistry.clear();
         this._memexArchive.clear();
         this._todoOutputLedger.clear();
-        setTodoSessionId(this._sessionId);
+        this._supersededTodoIds.clear();
         const continuesPriorTask = this._allowImplicitContinuation || this._resumeInterrupted;
         if (!continuesPriorTask) {
           this._hidePriorSessionTodosForFreshTask(persistentTaskGoal);
@@ -677658,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;
@@ -677727,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;
@@ -679447,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") {
@@ -680786,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,
@@ -682997,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;
@@ -683367,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") {
@@ -683919,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) {
@@ -684277,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(),
@@ -684288,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) {
@@ -684296,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;
@@ -684306,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;
@@ -702479,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,
@@ -702603,6 +702750,7 @@ __export(dist_exports3, {
   checkMilestoneComplete: () => checkMilestoneComplete,
   chooseCheapModelRoute: () => chooseCheapModelRoute,
   claimAssertion: () => claimAssertion,
+  classifyAuthoritativeProgress: () => classifyAuthoritativeProgress,
   classifyBreadth: () => classifyBreadth,
   classifyClaimKind: () => classifyClaimKind,
   classifyCompletionClaim: () => classifyCompletionClaim,
@@ -702961,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();
@@ -715459,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();
   }
@@ -803468,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);
@@ -803486,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);
-        }
       }
     }
   });

package/docs/DISCOVERY.json

@@ -33824,6 +33824,46 @@
         }
       ]
     },
+    {
+      "id": "guide.work-orders-runtime-health-remediation-wo-21-task-convergence-and-todo-scope-uppercase",
+      "kind": "guide",
+      "title": "WO-21: Task convergence and todo scope",
+      "summary": "On 2026-09-03, a user reported that Omnius remained at task 2/8 for about 40 turns. The report did not include a screenshot or run artifact, so the exact label remains unverified. Omnius has two similar counters:",
+      "keywords": [
+        "work",
+        "orders",
+        "runtime",
+        "health",
+        "remediation",
+        "WO",
+        "21",
+        "task",
+        "convergence",
+        "and",
+        "todo",
+        "scope",
+        "md"
+      ],
+      "maturity": "internal",
+      "audiences": [
+        "maintainer",
+        "large-context-agent"
+      ],
+      "layer": "documentation",
+      "interfaces": [
+        {
+          "type": "file",
+          "target": "docs/work-orders/runtime-health-remediation/WO-21-task-convergence-and-todo-scope.md"
+        }
+      ],
+      "references": [
+        {
+          "type": "documentation",
+          "target": "docs/work-orders/runtime-health-remediation/WO-21-task-convergence-and-todo-scope.md",
+          "relation": "canonical-artifact"
+        }
+      ]
+    },
     {
       "id": "guide.work-orders-telegram-dropbear-context-rca-workorder",
       "kind": "guide",

package/docs/DISCOVERY.md

@@ -559,6 +559,7 @@ Daemon equivalents are `GET /v1/discovery/bootstrap`, `GET /v1/discovery?q=<inte
 | `guide.work-orders-runtime-health-remediation-wo-19-clean-build-evidence-uppercase` | WO-19 Clean Build Evidence | WO-19 is implemented in commit 5f253c05. |
 | `guide.work-orders-runtime-health-remediation-wo-19-clean-build-reproducibility-uppercase` | WO-19: Clean Build and Optional-Dependency Reproducibility | Status: deterministic acceptance complete Risk: medium Depends on: WO-00 |
 | `guide.work-orders-runtime-health-remediation-wo-20-exact-session-continuation-uppercase` | WO-20: Exact session continuation across exit and restart | On 2026-09-03, the telegramtest TUI displayed the latest pentest task during startup, but the first restored model context combined a completed breach.py handoff with an unrelated, older page.tsx todo tree. The user then entered continue, and Omnius continued the stale tree instead of the task that was active before /quit. |
+| `guide.work-orders-runtime-health-remediation-wo-21-task-convergence-and-todo-scope-uppercase` | WO-21: Task convergence and todo scope | On 2026-09-03, a user reported that Omnius remained at task 2/8 for about 40 turns. The report did not include a screenshot or run artifact, so the exact label remains unverified. Omnius has two similar counters: |
 | `guide.work-orders-telegram-dropbear-context-rca-workorder` | Telegram Dropbear Context Engineering RCA Work Order | Observed run: /home/roko/Documents/Projects/Adjacent/telegramtest/.omnius, run id 1782873796963-i5r7mv. |
 | `guide.work-orders-wo-am-gaps-uppercase` | Associative Memory Gap Work Orders | Generated: 2026-04-13 Source: Deep audit of multimodal associative memory systems Status: READY FOR IMPLEMENTATION |
 | `guide.work-orders-world-class-memory-compiler-readme-uppercase` | World-Class Memory Compiler Program | Status: active implementation program Owner: Omnius orchestration and memory packages Last updated: 2026-07-13 |

package/docs/work-orders/runtime-health-remediation/TRACKER.md

@@ -311,3 +311,15 @@ deterministically repaired P0 or P1 defect.
   pass cancellation, restart, ownership, external-effect, and isolation tests.
 - [x] WO-20 exit and restart preserve one exact typed task continuation. Generic
   context restoration cannot mix or activate unrelated historical artifacts.
+- [x] WO-21 task convergence and todo scope prevent stale `tasks N/M` displays,
+  cross-runner todo leakage, and activity-only re-engagement.
+  - [x] Bind todo tools to immutable runner-owned sessions.
+  - [x] Clear the active persisted checklist at a fresh task boundary after
+    archival.
+  - [x] Count only typed authoritative advancement as progress.
+  - [x] Latch an advisory convergence review when the leaf frontier is static.
+  - [x] Make loop, reminder, budget, and workboard progress semantics truthful.
+  - [x] Pass deterministic race, stasis, display, typecheck, and build tests.
+- [x] A recovered pause no longer strands its session. Submitting a new task
+  retires the superseded generation instead of refusing every later prompt,
+  while unreconciled external effects still fence admission.

package/docs/work-orders/runtime-health-remediation/WO-21-task-convergence-and-todo-scope.md

@@ -0,0 +1,115 @@
+# WO-21: Task convergence and todo scope
+
+## Incident
+
+On 2026-09-03, a user reported that Omnius remained at `task 2/8` for about
+40 turns. The report did not include a screenshot or run artifact, so the
+exact label remains unverified. Omnius has two similar counters:
+
+- `tasks 2/8` is the completed-leaf count in the pinned TUI checklist.
+- `Loop intervention 2/8` is the second repetition intervention in a
+  model-tier-specific series.
+
+The source audit found defects in both paths. These defects are sufficient to
+produce the reported symptom even though they do not prove which counter the
+reporter saw.
+
+## Root causes
+
+- A TUI process reuses one todo session across tasks. A fresh runner hides old
+  todo IDs in its private view but leaves the persisted checklist unchanged.
+  The TUI reads that unchanged file and can display a stale `tasks 2/8` row.
+- Todo tools fall back to one mutable process-global session ID. Concurrent
+  parent, Telegram, background, and child runners can redirect one another's
+  unscoped reads and writes.
+- Any unique non-noop tool result increments the counter used to permit turn
+  extension and brute-force re-engagement. Varying reads, searches, and error
+  text therefore masquerade as task advancement.
+- The repeated-loop counter resets after its maximum intervention even though
+  no task state changed. Its status says that user guidance was requested, but
+  it does not create a user-input boundary.
+- A failed `todo_write` advances the reminder clock. The visible checklist can
+  remain unchanged for ten more turns without a reminder.
+- Small-model budget text says that a todo update resets the phase budget, but
+  the implementation resets only after a context-tree phase transition.
+- Workboard `lastSubstantiveProgress` treats successful discovery reads as
+  progress. This conflicts with the task and completion ledgers, where a read
+  is evidence but not advancement.
+
+## Required invariants
+
+- [x] Every runner binds todo tools to its own immutable session scope.
+- [x] Model-supplied todo session IDs cannot override the host scope.
+- [x] Concurrent runners cannot redirect one another's todo reads or writes.
+- [x] A fresh task archives the prior checklist and clears the active persisted
+  projection so the TUI, runner, REST, and Telegram views agree.
+- [x] Only a confirmed mutation, todo transition, workboard transition,
+  assertive verifier receipt, or delivery receipt counts as authoritative task
+  progress.
+- [x] Reads, searches, runtime-authored blocks, no-ops, and changing errors do
+  not extend the run or re-arm brute-force execution. Entry into the first
+  re-engagement cycle is deliberately not gated on prior authoritative
+  progress: that cycle is the rescue attempt for a run that has only read.
+  If it also advances nothing, re-engagement stops at cycle 2.
+- [x] Repeated stasis creates one latched, model-visible convergence review.
+- [x] The convergence review remains advisory. It does not infer completion,
+  manufacture a blocker, or force a user question.
+- [x] The loop intervention maximum does not silently reset without
+  authoritative progress.
+- [x] Todo reminders advance only after a successful state-changing write.
+- [x] Budget exhaustion text describes the actual reset condition.
+- [x] Workboard progress metadata uses the same authoritative distinction.
+- [x] Todo stagnation compares completed leaves, matching the TUI counter.
+
+## Status
+
+Implemented and verified on 2026-09-03.
+
+| Invariant | Implementation | Test |
+| --- | --- | --- |
+| Immutable runner-owned todo scope | `packages/execution/src/tools/todo-write.ts` `bindExecutionScope` | `todo-store.test.ts` "binds todo tools to a host session that model arguments cannot replace" |
+| Concurrent runner isolation | `AgenticRunner` constructor resolves one immutable `_sessionId`; `registerTool` binds it | `todo-store.test.ts` "keeps concurrent runner-scoped todo writes isolated" |
+| Fresh task clears the active projection | `_hidePriorSessionTodosForFreshTask` writes an empty active checklist after archival | `fresh-task-todo-boundary.test.ts` |
+| Typed authoritative progress only | `packages/orchestrator/src/convergence-progress.ts` | `task-convergence-progress.test.ts` (8 cases) |
+| Latched advisory convergence review | `agenticRunner.ts` convergence review block | `task-convergence-progress.test.ts` "latches one advisory review and clears it only after typed progress" |
+| Loop intervention maximum stays latched | `Math.min(maxInterventions, loopInterventionCount + 1)` | `agenticRunner-context-behavior.test.ts` "latches the loop-intervention maximum instead of cycling it back to one" |
+| Workboard progress uses the same distinction | `recordWorkboardToolCall` returns a status-fingerprint transition | `workboard-run-continuity.test.ts` "does not record a successful discovery read as task advancement" |
+
+Full suites run green: `@omnius/execution` 1507 passed, `@omnius/orchestrator`
+2303 passed (200 files, 2 skipped), `omnius` CLI 2428 passed (258 files).
+Typecheck passes for all three packages and `pnpm -r build` completes.
+
+The reported counter was never attributed to a specific field run. The evidence
+request below stays open.
+
+One correction was made during verification. An earlier draft of this work also
+refused to enter brute-force cycle 1 whenever the primary run recorded no
+authoritative advancement. That inverted the purpose of re-engagement and broke
+eight existing brute-force tests, because a run that has only read is exactly
+the run that still needs one push to act. The cycle-2 gate already bounds the
+thrash this work order set out to stop, so the cycle-1 refusal was removed.
+
+## Deterministic verification
+
+- [x] Scoped todo tools ignore conflicting model-supplied session IDs.
+- [x] Concurrent scoped todo tools write isolated session files.
+- [x] A same-session fresh task clears the old visible todo projection after
+  archiving it.
+- [x] Forty distinct reads produce zero authoritative progress.
+- [x] Changing failures produce zero authoritative progress.
+- [x] Mutations, todo transitions, workboard transitions, assertive verifiers,
+  and delivery receipts produce typed progress.
+- [x] A convergence review latches after the configured unchanged frontier and
+  clears only after typed progress.
+- [x] The loop intervention maximum stays latched instead of cycling to one.
+- [x] Focused execution, orchestrator, and CLI tests pass.
+- [x] Affected package typechecks and builds pass.
+
+## Evidence request for exact field attribution
+
+If the original run is available, collect only a redacted structural slice:
+the exact counter line or screenshot, Omnius version, model/backend, launch
+surface, incident time and timezone, session/run IDs, five turns before the
+stall through ten turns after it, todo IDs/statuses/revisions, workboard card
+statuses, and completion-ledger statuses. Do not copy a complete `.omnius`
+directory because debug previews can contain user text and source fragments.

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.689",
+  "version": "1.0.690",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.689",
+      "version": "1.0.690",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.689",
+  "version": "1.0.690",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/library.js",