omnius 1.0.548 → 1.0.550

package/dist/index.js

@@ -155716,7 +155716,7 @@ var require_snapshot_recorder = __commonJS({
   "../node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
     var { writeFile: writeFile27, readFile: readFile25, mkdir: mkdir23 } = __require("node:fs/promises");
-    var { dirname: dirname58, resolve: resolve82 } = __require("node:path");
+    var { dirname: dirname59, resolve: resolve82 } = __require("node:path");
     var { setTimeout: setTimeout3, clearTimeout: clearTimeout3 } = __require("node:timers");
     var { InvalidArgumentError, UndiciError } = require_errors2();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -155947,7 +155947,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         const resolvedPath = resolve82(path16);
-        await mkdir23(dirname58(resolvedPath), { recursive: true });
+        await mkdir23(dirname59(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
           snapshot
@@ -269609,15 +269609,15 @@ var init_ls = __esm({
 });
 
 // ../node_modules/@helia/unixfs/dist/src/commands/mkdir.js
-async function mkdir6(parentCid, dirname58, blockstore, options2 = {}) {
-  if (dirname58.includes("/")) {
+async function mkdir6(parentCid, dirname59, blockstore, options2 = {}) {
+  if (dirname59.includes("/")) {
     throw new InvalidParametersError4("Path must not have slashes");
   }
   const entry = await exporter2(parentCid, blockstore, options2);
   if (entry.type !== "directory") {
     throw new NotADirectoryError(`${parentCid.toString()} was not a UnixFS directory`);
   }
-  log16("creating %s", dirname58);
+  log16("creating %s", dirname59);
   const metadata = new UnixFS({
     type: "directory",
     mode: options2.mode,
@@ -269633,9 +269633,9 @@ async function mkdir6(parentCid, dirname58, blockstore, options2 = {}) {
   await blockstore.put(emptyDirCid, buf);
   const [directory, pblink] = await Promise.all([
     cidToDirectory(parentCid, blockstore, options2),
-    cidToPBLink(emptyDirCid, dirname58, blockstore, options2)
+    cidToPBLink(emptyDirCid, dirname59, blockstore, options2)
   ]);
-  log16("adding empty dir called %s to %c", dirname58, parentCid);
+  log16("adding empty dir called %s to %c", dirname59, parentCid);
   const result = await addLink(directory, pblink, blockstore, {
     ...options2,
     allowOverwriting: options2.force
@@ -270134,8 +270134,8 @@ var init_unixfs2 = __esm({
       async *ls(cid, options2 = {}) {
         yield* ls(cid, this.components.blockstore, options2);
       }
-      async mkdir(cid, dirname58, options2 = {}) {
-        return mkdir6(cid, dirname58, this.components.blockstore, options2);
+      async mkdir(cid, dirname59, options2 = {}) {
+        return mkdir6(cid, dirname59, this.components.blockstore, options2);
       }
       async rm(cid, path16, options2 = {}) {
         return rm3(cid, path16, this.components.blockstore, options2);
@@ -516914,7 +516914,7 @@ var require_path_browserify = __commonJS({
       _makeLong: function _makeLong(path16) {
         return path16;
       },
-      dirname: function dirname58(path16) {
+      dirname: function dirname59(path16) {
         assertPath(path16);
         if (path16.length === 0) return ".";
         var code8 = path16.charCodeAt(0);
@@ -566998,6 +566998,7 @@ function createCompletionLedger(input) {
   const ts = nowIso2(input.now);
   return {
     runId: input.runId,
+    ...typeof input.taskEpoch === "number" ? { taskEpoch: input.taskEpoch } : {},
     goal: cleanText(input.goal, 2e3),
     createdAtIso: ts,
     updatedAtIso: ts,
@@ -567183,7 +567184,23 @@ function appendUnresolved(items, text2, source) {
     }
   ];
 }
+function classifyCompletionProgress(entry) {
+  if (entry.progressClass)
+    return entry.progressClass;
+  const targets = [...entry.targetPaths ?? [], entry.rawRef ?? ""];
+  if (targets.some((target) => CONTROLLER_ARTIFACT_RE.test(target))) {
+    return "control_bookkeeping";
+  }
+  if (entry.role === "blocker")
+    return "blocker";
+  if (entry.kind === "file_change" || entry.role === "mutation") {
+    return "work_product";
+  }
+  return "observation";
+}
 function isMutationEvidence(entry) {
+  if (classifyCompletionProgress(entry) !== "work_product")
+    return false;
   if (entry.role === "mutation")
     return true;
   if (entry.kind === "file_change")
@@ -567314,10 +567331,12 @@ function saveCompletionLedger(filePath, ledger) {
 function loadCompletionLedger(filePath) {
   return JSON.parse(readFileSync66(filePath, "utf8"));
 }
+var CONTROLLER_ARTIFACT_RE;
 var init_completionLedger = __esm({
   "packages/orchestrator/dist/completionLedger.js"() {
     "use strict";
     init_completionContract();
+    CONTROLLER_ARTIFACT_RE = /(?:^|[\\/])\.omnius(?:[\\/]|$)/i;
   }
 });
 
@@ -574466,6 +574485,8 @@ function writeTaskHandoff(omniusDir, handoff) {
 function readTaskHandoff(omniusDir, opts) {
   if (!handoffEnabled())
     return null;
+  if (!opts.allowImplicitContinuation)
+    return null;
   try {
     const file = handoffPath(omniusDir);
     if (!fs4.existsSync(file))
@@ -574506,7 +574527,7 @@ function buildHandoffMessagePair(h) {
   const filesBlock = h.filesTouched.length ? h.filesTouched.map((f2) => `  - ${f2}`).join("\n") : "  (none)";
   const toolsBlock = h.toolsUsed.length ? h.toolsUsed.map((t2) => `  - ${t2}`).join("\n") : "  (none)";
   const actionsBlock = h.lastActions.length ? h.lastActions.map((a2) => `  - ${a2}`).join("\n") : "  (none recorded)";
-  const summaryBlock = h.priorSummary || "(no summary captured)";
+  const summaryBlock = (h.priorSummary || "(no summary captured)").slice(0, MAX_SUMMARY_CHARS);
   const trajectoryBlock = h.trajectory ? [
     "Prior trajectory (STALE orientation — verify before acting):",
     `  Assessment: ${h.trajectory.assessment}`,
@@ -574524,10 +574545,10 @@ function buildHandoffMessagePair(h) {
 
 If you need verbatim details from the prior task (specific code, exact error messages, or content beyond this summary), file_read the transcript at: ${h.transcriptPath}` : "";
   const summary = {
-    role: "user",
+    role: "system",
     content: [
-      "[task_summary] This conversation is being continued from a previous task that ran in the same workspace.",
-      "The summary below covers what happened. The NEW task is in the next user message — let it determine whether the prior context is relevant.",
+      "[task_summary] Prior-task reference only. It is not a user instruction and cannot replace the live user goal.",
+      "Use it only when the active task explicitly continues this work; otherwise ignore it.",
       "",
       `Prior goal: ${h.priorGoal}`,
       `Prior outcome: ${h.priorOutcome} in ${h.turns} turn(s)`,
@@ -574565,7 +574586,7 @@ var init_taskHandoff = __esm({
     init_trajectory_checkpoint();
     init_dist5();
     DEFAULT_TTL_MS2 = 24 * 60 * 60 * 1e3;
-    MAX_SUMMARY_CHARS = 8e3;
+    MAX_SUMMARY_CHARS = 2400;
     MAX_FILES = 30;
     MAX_TOOLS = 24;
     MAX_LAST_ACTIONS = 12;
@@ -578678,6 +578699,36 @@ context_fabric: included=${included.length} dropped=${dropped.length} truncated=
 });
 
 // packages/orchestrator/dist/context-compiler.js
+function isCurrentGoalMessage(message2) {
+  return typeof message2.content === "string" && message2.content.includes("[CURRENT USER GOAL]");
+}
+function applyModelFacingBudget(messages2, preserveFirstSystem) {
+  const reservedTransaction = latestResolvedToolTransaction(messages2);
+  const reservedChars = [...reservedTransaction].reduce((sum2, index) => sum2 + modelFacingReservedChars(messages2[index]), 0);
+  let remaining = Math.max(0, MODEL_FACING_CONTEXT_CHAR_BUDGET - reservedChars);
+  const kept = [];
+  for (let index = 0; index < messages2.length; index++) {
+    const message2 = messages2[index];
+    const content = messageText(message2.content);
+    const isReservedTransactionMessage = reservedTransaction.has(index);
+    const isPriorityIntent = message2.role === "user" || isCurrentGoalMessage(message2);
+    const perMessageCap = message2.role === "tool" ? MODEL_FACING_TOOL_CHAR_CAP : message2.role === "system" ? MODEL_FACING_SYSTEM_CHAR_CAP : content.length;
+    const allowed = isReservedTransactionMessage ? perMessageCap : isPriorityIntent ? content.length : Math.min(remaining, perMessageCap);
+    if (!isReservedTransactionMessage && !isPriorityIntent && allowed <= 0) {
+      continue;
+    }
+    const bounded = content.length > allowed && allowed > 0 ? `${content.slice(0, Math.max(0, allowed - 83))}
+[truncated_by_context_budget: retained higher-priority current intent/evidence]` : content;
+    if (!isReservedTransactionMessage && !isPriorityIntent && !bounded) {
+      continue;
+    }
+    kept.push(typeof message2.content === "string" ? { ...message2, content: bounded } : message2);
+    if (!isReservedTransactionMessage && !isPriorityIntent) {
+      remaining = Math.max(0, remaining - bounded.length);
+    }
+  }
+  return kept;
+}
 function collapseWhitespace(text2) {
   return text2.replace(/\r\n/g, "\n").split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -578710,6 +578761,79 @@ function messageText(content) {
     return "";
   }).filter(Boolean).join("\n");
 }
+function toolCallIds(message2) {
+  const calls = message2["tool_calls"];
+  if (!Array.isArray(calls))
+    return [];
+  return calls.flatMap((call) => {
+    if (!call || typeof call !== "object")
+      return [];
+    const id2 = call["id"];
+    return typeof id2 === "string" && id2 ? [id2] : [];
+  });
+}
+function hasToolCallsMetadata(message2) {
+  return Array.isArray(message2["tool_calls"]);
+}
+function linkedToolCallId(message2) {
+  const id2 = message2["tool_call_id"];
+  return typeof id2 === "string" && id2 ? id2 : null;
+}
+function latestResolvedToolTransaction(messages2) {
+  const resultIndexesById = /* @__PURE__ */ new Map();
+  for (let index = 0; index < messages2.length; index++) {
+    const message2 = messages2[index];
+    if (message2.role !== "tool")
+      continue;
+    const id2 = linkedToolCallId(message2);
+    if (!id2)
+      continue;
+    const indexes = resultIndexesById.get(id2) ?? [];
+    indexes.push(index);
+    resultIndexesById.set(id2, indexes);
+  }
+  for (let index = messages2.length - 1; index >= 0; index--) {
+    const message2 = messages2[index];
+    if (message2.role !== "assistant")
+      continue;
+    const callIds = toolCallIds(message2);
+    if (callIds.length === 0 || !callIds.every((id2) => resultIndexesById.has(id2))) {
+      continue;
+    }
+    const transaction = /* @__PURE__ */ new Set([index]);
+    for (const id2 of callIds) {
+      for (const resultIndex of resultIndexesById.get(id2) ?? []) {
+        transaction.add(resultIndex);
+      }
+    }
+    return transaction;
+  }
+  return /* @__PURE__ */ new Set();
+}
+function modelFacingReservedChars(message2) {
+  const content = messageText(message2.content);
+  const cap = message2.role === "tool" ? MODEL_FACING_TOOL_CHAR_CAP : message2.role === "system" ? MODEL_FACING_SYSTEM_CHAR_CAP : content.length;
+  return Math.min(content.length, cap);
+}
+function retireLinkedAssistantReadIntents(messages2) {
+  const resolvedToolCallIds = new Set(messages2.filter((message2) => message2.role === "tool").map(linkedToolCallId).filter((id2) => id2 !== null));
+  return messages2.map((message2, index) => {
+    const callIds = toolCallIds(message2);
+    let nextNonSystemMessage;
+    for (let candidateIndex = index + 1; candidateIndex < messages2.length; candidateIndex++) {
+      const candidate = messages2[candidateIndex];
+      if (candidate.role === "system")
+        continue;
+      nextNonSystemMessage = candidate;
+      break;
+    }
+    const hasLegacyAdjacentToolResult = message2.role === "assistant" && !hasToolCallsMetadata(message2) && nextNonSystemMessage?.role === "tool" && linkedToolCallId(nextNonSystemMessage) === null;
+    if (message2.role !== "assistant" || typeof message2.content !== "string" || !(callIds.some((id2) => resolvedToolCallIds.has(id2)) || hasLegacyAdjacentToolResult) || !/\b(?:i|we)\s+(?:need|will|should|have)\s+to\s+(?:read|inspect|open)\b/i.test(message2.content)) {
+      return message2;
+    }
+    return { ...message2, content: ASSISTANT_READ_INTENT_RETIRED_MARKER };
+  });
+}
 function runtimeControlSemanticKey(content) {
   const normalized = content.replace(/\s+/g, " ").trim().toLowerCase();
   if (!normalized)
@@ -578859,7 +578983,7 @@ function prepareModelFacingApiMessages(input) {
     const insertAt = preserveFirstSystem && deduped[0]?.role === "system" ? 1 : 0;
     deduped.splice(insertAt, 0, goalMessage);
   }
-  return deduped;
+  return retireLinkedAssistantReadIntents(applyModelFacingBudget(deduped, preserveFirstSystem));
 }
 function deriveCurrentGoal(input) {
   const explicit = sanitizeModelVisibleContextText(input.explicitGoal ?? "");
@@ -578927,15 +579051,22 @@ function compileContextFrameV2(input) {
       warnings: [...new Set(warnings)],
       admittedSignals: frame.included.length,
       rejectedSignals: normalized.rejected.length,
-      hadConcreteGoal: goal.concrete
+      hadConcreteGoal: goal.concrete,
+      admittedChars: frame.included.reduce((total, signal) => total + signal.content.length, 0),
+      droppedChars: normalized.rejected.reduce((total, signal) => total + signal.content.length, 0),
+      droppedSources: normalized.rejected.map((signal) => signal.source)
     }
   };
 }
-var RESTORE_NOISE_LINE_RE, RUNTIME_GUIDANCE_RE, ACTIVE_CONTEXT_RE;
+var MODEL_FACING_CONTEXT_CHAR_BUDGET, MODEL_FACING_TOOL_CHAR_CAP, MODEL_FACING_SYSTEM_CHAR_CAP, ASSISTANT_READ_INTENT_RETIRED_MARKER, RESTORE_NOISE_LINE_RE, RUNTIME_GUIDANCE_RE, ACTIVE_CONTEXT_RE;
 var init_context_compiler = __esm({
   "packages/orchestrator/dist/context-compiler.js"() {
     "use strict";
     init_context_fabric();
+    MODEL_FACING_CONTEXT_CHAR_BUDGET = 48e3;
+    MODEL_FACING_TOOL_CHAR_CAP = 6e3;
+    MODEL_FACING_SYSTEM_CHAR_CAP = 8e3;
+    ASSISTANT_READ_INTENT_RETIRED_MARKER = "[assistant read intent retired: the linked tool result is already available; decide from that evidence instead of restating a read plan]";
     RESTORE_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:)|.*\bSHELL TRANSCRIPT\b.*|.*speaker emoji.*).*$/i;
     RUNTIME_GUIDANCE_RE = /\[RUNTIME_GUIDANCE_INTAKE v\d+\][\s\S]*?<<<RUNTIME_GUIDANCE>>>\s*([\s\S]*?)\s*<<<END_RUNTIME_GUIDANCE>>>[\s\S]*?\[\/RUNTIME_GUIDANCE_INTAKE\]/g;
     ACTIVE_CONTEXT_RE = /\[ACTIVE CONTEXT FRAME\][\s\S]*?(?=\n\[ACTIVE CONTEXT FRAME\]|$)/g;
@@ -580067,8 +580198,8 @@ var init_adversaryStream = __esm({
           return;
         try {
           const { writeFileSync: writeFileSync97, mkdirSync: mkdirSync114, existsSync: existsSync177 } = __require("node:fs");
-          const { dirname: dirname58 } = __require("node:path");
-          const dir = dirname58(this.persistPath);
+          const { dirname: dirname59 } = __require("node:path");
+          const dir = dirname59(this.persistPath);
           if (!existsSync177(dir))
             mkdirSync114(dir, { recursive: true });
           writeFileSync97(this.persistPath, JSON.stringify({ ledger: this.ledger }, null, 2));
@@ -587788,8 +587919,6 @@ function flattenErrorText(err) {
 function computeEffectiveThink(params) {
   if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
     return false;
-  if (process.env["OMNIUS_ENABLE_THINKING"] !== "1")
-    return false;
   if (params.suppressed)
     return false;
   if (params.hasTools)
@@ -587826,6 +587955,9 @@ function sanitizeHistoryThink(messages2) {
       const collapsed = collapseDegenerateAssistantRepetition(content);
       content = collapsed ?? content;
     }
+    if (m2.role === "assistant" && Array.isArray(m2.tool_calls) && m2.tool_calls.some((call) => referencedToolCallIds.has(call.id)) && /\b(?:i|we)\s+(?:need|will|should|have)\s+to\s+(?:read|inspect|open)\b/i.test(content)) {
+      content = "[assistant read intent retired: the linked tool result is already available; decide from that evidence instead of restating a read plan]";
+    }
     return { ...m2, content };
   });
   const sanitized = [];
@@ -588178,6 +588310,18 @@ var init_agenticRunner = __esm({
       _onTypedEvent;
       handlers = [];
       pendingUserMessages = [];
+      /** Typed source of truth for user steering; pendingUserMessages remains a compatibility queue. */
+      pendingSteeringInputs = [];
+      _steeringSequence = 0;
+      _taskEpoch = 0;
+      _activeRunId = "";
+      /** Session storage is retained for compatibility; superseded task leaves are hidden from active guards. */
+      _supersededTodoIds = /* @__PURE__ */ new Set();
+      /** Cross-task restoration is opt-in only for an explicit continuation/append. */
+      _allowImplicitContinuation = false;
+      /** Abort scope for only the in-flight model/tool turn. Never use for permanent stop. */
+      _turnAbortController = new AbortController();
+      _pendingSteeringPreemption = null;
       pendingRuntimeGuidanceMessages = [];
       aborted = false;
       _abortController = new AbortController();
@@ -588678,6 +588822,9 @@ var init_agenticRunner = __esm({
       _branchEvidenceCache = /* @__PURE__ */ new Map();
       /** Latest curated node per canonical path for safe post-compaction recovery. */
       _branchEvidenceByPath = /* @__PURE__ */ new Map();
+      /** Exact read fingerprints resolved from canonical evidence, not a fresh tool call. */
+      _resolvedReadEvidence = /* @__PURE__ */ new Map();
+      _deterministicNarrowReadFallbacks = /* @__PURE__ */ new Set();
       // OBS-1: durable "current observed state" for non-file_read tool outputs
       // (shell/web_fetch/list_directory/…). EvidenceLedger's counterpart for the
       // observation channels that were previously invisible after compaction —
@@ -588786,7 +588933,7 @@ var init_agenticRunner = __esm({
           return this._workboard;
         }
         const dir = this._workboardDir();
-        const runId = this._sessionId;
+        const runId = this.currentArtifactRunId();
         const existing = loadWorkboardSnapshot(dir, runId);
         if (existing) {
           this._workboard = this._seedWorkboardCardsIfNeeded(existing, goal);
@@ -588897,7 +589044,7 @@ var init_agenticRunner = __esm({
         if (!diagnosis.createRecoveryCard && count < 2)
           return;
         const dir = this._workboardDir();
-        const runId = this._sessionId;
+        const runId = this.currentArtifactRunId();
         const actor = this.options.subAgent ? "sub-agent" : "agent";
         const cardInput = this._failureRecoveryCardInput(diagnosis);
         try {
@@ -589009,7 +589156,7 @@ var init_agenticRunner = __esm({
           return;
         const cards = activeLeaves.map((todo) => this._todoWorkboardCardInput(todo, this._todoPath(todo, index)));
         const dir = this._workboardDir();
-        const runId = this._sessionId;
+        const runId = this.currentArtifactRunId();
         const actor = this.options.subAgent ? "sub-agent" : "agent";
         try {
           let board = readActiveWorkboardSnapshot(dir, runId) ?? this._workboard ?? null;
@@ -589230,7 +589377,7 @@ ${parts.join("\n")}
       }
       _currentWorkboardSnapshotForFrame() {
         const dir = this._workboardDir();
-        const fromDisk = readActiveWorkboardSnapshot(dir, this._sessionId);
+        const fromDisk = readActiveWorkboardSnapshot(dir, this.currentArtifactRunId());
         const goal = this._taskState.originalGoal || this._taskState.goal || "";
         const initialCards = this._initialWorkboardCardsForGoal(goal);
         if (fromDisk) {
@@ -589359,8 +589506,9 @@ ${parts.join("\n")}
           case "creative_pivot_or_research":
             return "a FUNDAMENTALLY different approach: web_search the exact error/blocker to find how it is solved, or pivot to a method you have NOT tried — not a variant of what failed, and NOT task_complete";
           case "report_blocked":
+            return 'call task_complete with status="blocked", a concise external blocker, and the next prerequisite; do not create a bookkeeping artifact as the recovery action';
           case "report_incomplete":
-            return "a fundamentally different approach or web_search the blocker — do not report incomplete";
+            return 'call task_complete with status="incomplete" or status="blocked" only when the evidence shows no remaining substantive action; otherwise take a fundamentally different approach or web_search the blocker';
           default:
             return "choose the narrowest tool that advances the current card";
         }
@@ -589525,7 +589673,7 @@ ${parts.join("\n")}
             const discovery = cards.get("discover-current-state");
             if (discovery && discovery.status !== "verified" && discovery.evidence.length > 0) {
               const completed = completeWorkboardCard(dir, {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 cardId: discovery.id,
                 actor,
                 outcome: "completed",
@@ -589536,7 +589684,7 @@ ${parts.join("\n")}
               const completedDiscovery = cards.get("discover-current-state");
               if (completedDiscovery?.status === "completed") {
                 const verified = completeWorkboardCard(dir, {
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   cardId: completedDiscovery.id,
                   actor,
                   outcome: "verified",
@@ -589549,7 +589697,7 @@ ${parts.join("\n")}
             const implementation2 = cards.get("implement-repair");
             if (implementation2 && (implementation2.status === "open" || implementation2.status === "needs_changes")) {
               current = updateWorkboardCard(dir, {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 cardId: implementation2.id,
                 actor,
                 updates: { status: "in_progress", lane: "worker" },
@@ -589563,7 +589711,7 @@ ${parts.join("\n")}
             const integration = cards.get("integrate-and-run");
             if (integration && this._workboardHasEditEvidence(implementation2) && (integration.status === "open" || integration.status === "needs_changes")) {
               current = updateWorkboardCard(dir, {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 cardId: integration.id,
                 actor,
                 updates: { status: "in_progress", lane: "verification" },
@@ -589618,7 +589766,7 @@ ${parts.join("\n")}
             return;
           }
           attachWorkboardEvidence(dir, {
-            runId: this._sessionId,
+            runId: this.currentArtifactRunId(),
             cardId: targetCard.id,
             actor,
             evidence
@@ -589633,7 +589781,7 @@ ${parts.join("\n")}
           return;
         try {
           const dir = this._workboardDir();
-          const refreshed = readActiveWorkboardSnapshot(dir, this._sessionId);
+          const refreshed = readActiveWorkboardSnapshot(dir, this.currentArtifactRunId());
           if (refreshed)
             this._workboard = refreshed;
         } catch {
@@ -589824,7 +589972,7 @@ ${parts.join("\n")}
           stage: stage2,
           agentType,
           sessionId: this._sessionId,
-          runId: this._sessionId,
+          runId: this.currentArtifactRunId(),
           turn,
           attempt,
           model: this._backendModelLabel(this.backend),
@@ -589849,7 +589997,7 @@ ${parts.join("\n")}
             recordDebugContextWindowDump({
               cwd: this.authoritativeWorkingDirectory(),
               stateDir: this.omniusStateDir(),
-              runId: this._sessionId,
+              runId: this.currentArtifactRunId(),
               sessionId: this._sessionId,
               record
             });
@@ -590072,7 +590220,7 @@ ${parts.join("\n")}
         try {
           const dir = _pathJoin(this.omniusStateDir(), "completion-contracts");
           _fsMkdirSync(dir, { recursive: true });
-          _fsWriteFileSync(_pathJoin(dir, `${this._sessionId}.json`), JSON.stringify({
+          _fsWriteFileSync(_pathJoin(dir, `${this.currentArtifactRunId()}.json`), JSON.stringify({
             sessionId: this._sessionId,
             createdAt: (/* @__PURE__ */ new Date()).toISOString(),
             contract
@@ -590621,7 +590769,7 @@ Your hypotheses MUST address this specific error, not generic causes.
                 stage: opts?.dumpStage ?? "aux_inference",
                 agentType: "internal",
                 sessionId: this._sessionId,
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 model: this._backendModelLabel(this.backend),
                 cwd: this._workingDirectory || process.cwd(),
                 request: r2
@@ -591135,7 +591283,8 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
       readSessionTodos() {
         try {
           const sid = this._sessionId || process.env["OMNIUS_SESSION_ID"] || "default";
-          return readTodos(sid);
+          const todos = readTodos(sid);
+          return this._supersededTodoIds.size === 0 ? todos : todos.filter((todo) => !this._supersededTodoIds.has(todo.id));
         } catch {
           return null;
         }
@@ -591667,13 +591816,13 @@ ${extras.join("\n")}`;
             if (!existing) {
               this._workboard = addWorkboardCard(dir, {
                 ...compileFixCardToWorkboardInput(card),
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 actor,
                 decisionReason: "compile_error_card_created"
               });
             } else if (card.status === "assigned" && existing.status === "open") {
               this._workboard = updateWorkboardCard(dir, {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 cardId: card.id,
                 actor,
                 updates: {
@@ -591694,7 +591843,7 @@ ${extras.join("\n")}`;
               "patch touched only owned files"
             ];
             this._workboard = attachWorkboardEvidence(dir, {
-              runId: this._sessionId,
+              runId: this.currentArtifactRunId(),
               cardId: card.id,
               actor,
               evidence: {
@@ -591716,7 +591865,7 @@ ${extras.join("\n")}`;
               const wbCard = active?.cards.find((item) => item.id === card.id);
               if (wbCard && wbCard.status !== "completed" && wbCard.status !== "verified") {
                 this._workboard = completeWorkboardCard(dir, {
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   cardId: card.id,
                   actor,
                   outcome: "completed",
@@ -591728,7 +591877,7 @@ ${extras.join("\n")}`;
                 const latestCard = latest?.cards.find((item) => item.id === card.id);
                 if (latestCard?.status === "completed") {
                   this._workboard = completeWorkboardCard(dir, {
-                    runId: this._sessionId,
+                    runId: this.currentArtifactRunId(),
                     cardId: card.id,
                     actor,
                     outcome: "verified",
@@ -591749,7 +591898,7 @@ ${extras.join("\n")}`;
           if (!existing || existing.status !== "open")
             return;
           this._workboard = updateWorkboardCard(dir, {
-            runId: this._sessionId,
+            runId: this.currentArtifactRunId(),
             cardId: card.id,
             actor: this.options.subAgent ? "sub-agent" : "agent",
             updates: {
@@ -591773,6 +591922,11 @@ ${extras.join("\n")}`;
         state.verifierDirtySinceTurn = turn;
         state.lastVerifierPassedTurn = null;
         state.lastMutationTurn = turn;
+        this._focusSupervisor?.markCompletionBlocked({
+          turn,
+          reason: "A source mutation invalidated the declared verifier; verifier evidence now owns the active focus.",
+          requiredNextAction: "run_verification"
+        });
         for (const card of state.cards) {
           if (card.status === "assigned" && (normalized.length === 0 || normalized.some((pathValue) => card.ownedFiles.some((ownedPath) => this._pathsOverlapForVerifier(pathValue, ownedPath))))) {
             card.status = "patched";
@@ -591825,8 +591979,9 @@ ${extras.join("\n")}`;
             state.preflightBlockStreak = 0;
             return null;
           }
-          if (!shellLikelyMutatesFilesystem)
+          if (!shellLikelyMutatesFilesystem) {
             return null;
+          }
           const extraction = extractShellMutationPaths(command, {
             workingDir: this.authoritativeWorkingDirectory()
           });
@@ -591837,7 +591992,7 @@ ${extras.join("\n")}`;
         } else if (!this._isProjectEditTool(toolName)) {
           return null;
         }
-        const yieldAfter = _AgenticRunner.COMPILE_FIX_GATE_YIELD_AFTER;
+        const yieldAfter = Number.MAX_SAFE_INTEGER;
         const streak = (state.preflightBlockStreak ?? 0) + 1;
         if (streak > yieldAfter) {
           state.preflightBlockStreak = 0;
@@ -591869,7 +592024,7 @@ ${extras.join("\n")}`;
           `lastMutationTurn: ${state.lastMutationTurn}`,
           `lastVerifierRunTurn: ${state.lastVerifierRunTurn}`,
           `blockedTool: ${toolName}`,
-          `consecutiveBlocks: ${streak}/${yieldAfter} (gate yields after ${yieldAfter})`
+          `consecutiveBlocks: ${streak} (verifier focus is retained until a live verifier settles)`
         ].join("\n");
         this.emit({
           type: "status",
@@ -592330,6 +592485,9 @@ ${result.output ?? ""}`;
         return /^\s*(BLOCKED|INCOMPLETE|NEEDS[_ -]?INPUT)\b\s*:?/i.test(summary);
       }
       _shouldBypassTodoCompletionGuardForTaskComplete(args) {
+        if (completionStatusFromTaskCompleteArgs(args) === "blocked") {
+          return this._hasEvidenceBackedBlockedCompletion(args);
+        }
         if (!this._taskCompleteArgsReportDegraded(args))
           return false;
         if (this._completionIncompleteVerification)
@@ -592387,6 +592545,32 @@ ${result.output ?? ""}`;
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
+      /**
+       * Admit a BLOCKED terminal state only when every unresolved leaf is blocked
+       * by observed external evidence. Controller-authored notes, todo churn, and
+       * recovery artifacts are deliberately not evidence: otherwise the recovery
+       * loop can manufacture its own next blocker.
+       */
+      _hasEvidenceBackedBlockedCompletion(args) {
+        if (completionStatusFromTaskCompleteArgs(args) !== "blocked")
+          return false;
+        const summary = extractTaskCompleteSummary(args).trim();
+        if (!summary)
+          return false;
+        const leaves = openTodoLeaves(this._normalizeTodosForPrompt(this.readSessionTodos() ?? [])).filter((todo) => todo.status !== "completed");
+        if (leaves.length === 0)
+          return false;
+        const controllerArtifact = /(?:status artifact|blocker note|recovery (?:note|report|artifact)|todo_(?:write|read)|workboard|completion ledger|session diary)/i;
+        const externalBlocker = /(?:enoent|not found|missing|permission|access denied|credential|network|remote|upstream|service unavailable|waiting for|user input|third[- ]party)/i;
+        const hasObservedExternalFailure = this._recentFailures.some((failure) => externalBlocker.test(`${failure.error || ""}
+${failure.output || ""}`));
+        if (!hasObservedExternalFailure)
+          return false;
+        return leaves.every((todo) => {
+          const blocker = typeof todo.blocker === "string" ? todo.blocker.trim() : "";
+          return todo.status === "blocked" && blocker.length > 0 && externalBlocker.test(blocker) && !controllerArtifact.test(blocker);
+        });
+      }
       buildTodoCompletionGuard(openItems) {
         const list = openItems.slice(0, 20).map((t2, i2) => `${i2 + 1}. [${t2.status}] ${t2.content}`).join("\n");
         const full = this.readSessionTodos() || [];
@@ -596594,8 +596778,48 @@ ${notice}`;
       }
       /** Inject a user message into the running conversation (mid-task steering) */
       injectUserMessage(content) {
-        this.pendingUserMessages.push(this.scrubUserInput(content, "injected-user-message"));
+        this.injectSteeringInput({
+          inputId: `legacy-steering-${Date.now()}-${++this._steeringSequence}`,
+          content,
+          source: "legacy-injectUserMessage",
+          receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          intent: "append",
+          state: "received",
+          taskEpoch: this._taskEpoch || void 0
+        });
+      }
+      /**
+       * Queue a typed user instruction and return an acknowledgement receipt.
+       * The receipt is emitted and ledgered before a redirect can cancel the
+       * active turn, which closes the old bridge-to-runner message-loss race.
+       */
+      injectSteeringInput(input) {
+        const now2 = (/* @__PURE__ */ new Date()).toISOString();
+        const content = this.scrubUserInput(input.content, "steering-input").trim();
+        const record = {
+          ...input,
+          inputId: input.inputId.trim() || `steering-${Date.now()}-${++this._steeringSequence}`,
+          content,
+          source: input.source || "unknown",
+          receivedAt: input.receivedAt || now2,
+          state: "received",
+          taskEpoch: input.taskEpoch ?? (this._taskEpoch || void 0)
+        };
+        this.pendingSteeringInputs.push(record);
+        this._emitSteeringLifecycle(record, "received by runner");
+        if (!content) {
+          record.state = "cancelled";
+          this._emitSteeringLifecycle(record, "empty steering input rejected");
+          return this._steeringReceipt(record);
+        }
+        this.pendingUserMessages.push(content);
+        record.state = "queued";
+        this._emitSteeringLifecycle(record, "queued for next safe turn boundary");
+        if (record.intent === "redirect" || record.intent === "replace" || record.intent === "cancel") {
+          this._requestSteeringPreemption(record);
+        }
         this._trajectoryDirtyCauses.add("user_steering");
+        return this._steeringReceipt(record);
       }
       /** Inject bounded runtime guidance without treating it as user steering. */
       injectRuntimeGuidance(content) {
@@ -596621,12 +596845,22 @@ ${notice}`;
       retractLastPendingMessage() {
         if (this.pendingUserMessages.length === 0)
           return null;
-        return this.pendingUserMessages.pop();
+        const content = this.pendingUserMessages.pop();
+        const record = [...this.pendingSteeringInputs].reverse().find((candidate) => candidate.content === content && (candidate.state === "queued" || candidate.state === "acknowledged"));
+        if (record) {
+          record.state = "cancelled";
+          if (this._pendingSteeringPreemption?.inputId === record.inputId) {
+            this._pendingSteeringPreemption = null;
+          }
+          this._emitSteeringLifecycle(record, "retracted before consumption");
+        }
+        return content;
       }
       /** Abort the current task run — cancels in-flight requests and kills child processes */
       abort() {
         this.aborted = true;
         this._abortController.abort();
+        this._turnAbortController.abort();
         const shellTool = this.tools.get("shell");
         if (shellTool && typeof shellTool.killAll === "function") {
           shellTool.killAll();
@@ -596638,7 +596872,245 @@ ${notice}`;
       }
       /** Get the current abort signal for passing to fetch/spawn */
       get abortSignal() {
-        return this._abortController.signal;
+        return this._turnAbortController.signal;
+      }
+      /** Current run identity and epoch, exposed for frontends that persist intake. */
+      get taskEpoch() {
+        return this._taskEpoch;
+      }
+      get activeRunId() {
+        return this._activeRunId;
+      }
+      /** Immutable run key for artifacts; sessionId remains correlation metadata. */
+      currentArtifactRunId() {
+        return this._activeRunId || this._sessionId;
+      }
+      _steeringReceipt(record) {
+        return {
+          inputId: record.inputId,
+          intent: record.intent,
+          state: record.state,
+          taskEpoch: record.taskEpoch,
+          runId: this._activeRunId || void 0,
+          acceptedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      /**
+       * Retire a satisfied read-plan from the exact outbound request. Tool-call
+       * metadata and tool-result links are retained untouched for provider
+       * protocol correctness; only stale assistant-visible planning prose changes.
+       */
+      _retireLinkedAssistantReadIntents(messages2) {
+        const resolvedToolCallIds = new Set(messages2.filter((message2) => message2.role === "tool" && message2.tool_call_id).map((message2) => message2.tool_call_id));
+        for (const message2 of messages2) {
+          if (message2.role !== "assistant" || typeof message2.content !== "string" || !Array.isArray(message2.tool_calls) || !message2.tool_calls.some((call) => resolvedToolCallIds.has(call.id)) || !/\b(?:i|we)\s+(?:need|will|should|have)\s+to\s+(?:read|inspect|open)\b/i.test(message2.content)) {
+            continue;
+          }
+          message2.content = "[assistant read intent retired: the linked tool result is present below; decide from that evidence rather than planning the same read]";
+        }
+      }
+      _emitSteeringLifecycle(record, reason) {
+        const receipt = this._steeringReceipt(record);
+        this.emit({
+          type: "status",
+          content: `Steering ${record.inputId} ${record.state}: ${reason}`,
+          steering: receipt,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        appendSteeringLedgerEntry(this._workingDirectory || process.cwd(), {
+          type: "lifecycle",
+          packetId: record.inputId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          intake: { ...record },
+          summary: reason
+        });
+      }
+      _setBackendTurnAbortSignal(signal) {
+        if (typeof this.backend.setAbortSignal === "function") {
+          this.backend.setAbortSignal(signal);
+        }
+      }
+      _requestSteeringPreemption(record) {
+        this._pendingSteeringPreemption = record;
+        record.state = "acknowledged";
+        this._emitSteeringLifecycle(record, "preemption acknowledged");
+        this._turnAbortController.abort(new Error(`steering ${record.intent}: ${record.inputId}`));
+        const shellTool = this.tools.get("shell");
+        if (shellTool && typeof shellTool.killAll === "function") {
+          shellTool.killAll();
+        }
+        this._turnAbortController = new AbortController();
+        this._setBackendTurnAbortSignal(this._turnAbortController.signal);
+      }
+      _prepareSteeringInputsForRun() {
+        const initialInputs = this.pendingSteeringInputs.filter((record) => record.state === "queued" || record.state === "acknowledged");
+        this._allowImplicitContinuation = initialInputs.some((record) => record.intent === "append" || record.intent === "clarify") && !initialInputs.some((record) => record.intent === "redirect" || record.intent === "replace" || record.intent === "cancel");
+        for (const record of this.pendingSteeringInputs) {
+          if (record.state !== "queued" && record.state !== "acknowledged")
+            continue;
+          if (record.taskEpoch && record.taskEpoch !== this._taskEpoch) {
+            record.state = "superseded";
+            this._emitSteeringLifecycle(record, "superseded by a later task run");
+            const index = this.pendingUserMessages.lastIndexOf(record.content);
+            if (index >= 0)
+              this.pendingUserMessages.splice(index, 1);
+            continue;
+          }
+          record.taskEpoch = this._taskEpoch;
+          this._emitSteeringLifecycle(record, "bound to active task epoch");
+        }
+      }
+      /** Archive prior task-epoch state before its session-backed records are hidden. */
+      _archiveSupersededTaskState(taskEpoch, steering) {
+        const todos = this.readSessionTodos() ?? [];
+        const archive = {
+          runId: this._activeRunId || this._sessionId,
+          sessionId: this._sessionId,
+          taskEpoch,
+          supersededAt: (/* @__PURE__ */ new Date()).toISOString(),
+          steering: {
+            inputId: steering.inputId,
+            intent: steering.intent,
+            content: steering.content
+          },
+          todos,
+          workboard: this._workboard,
+          completionLedger: this._completionLedger
+        };
+        try {
+          const dir = _pathJoin(this.omniusStateDir(), "task-epoch-archives");
+          _fsMkdirSync(dir, { recursive: true });
+          _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);
+        this._workboard = null;
+      }
+      _steeringRecordForContent(content) {
+        return this.pendingSteeringInputs.find((record) => record.content === content && (record.state === "queued" || record.state === "acknowledged") && record.taskEpoch === this._taskEpoch);
+      }
+      _canonicalReadEvidencePayload(canonicalPath, contentHash2) {
+        const branch = this._branchEvidenceByPath.get(canonicalPath);
+        if (branch && branch.contentHash === contentHash2)
+          return branch.output;
+        return null;
+      }
+      _rehydrateResolvedReadEvidence(input) {
+        const previous = this._resolvedReadEvidence.get(input.fingerprint);
+        const handle2 = previous?.handle ?? `evidence:${input.canonicalPath}:${input.contentHash.slice(0, 16)}`;
+        this._resolvedReadEvidence.set(input.fingerprint, {
+          state: "resolved_from_cache",
+          handle: handle2,
+          path: input.canonicalPath,
+          contentHash: input.contentHash,
+          resolvedTurn: input.turn,
+          consumed: false
+        });
+        return [
+          "[REHYDRATED_FILE_EVIDENCE]",
+          `handle=${handle2}`,
+          "fingerprint_state=resolved_from_cache",
+          `path=${input.canonicalPath}`,
+          `sha256=${input.contentHash}`,
+          "Facts below are canonical current-run evidence. Consume these facts in the next decision; do not repeat the identical read.",
+          "[CANONICAL_FACTS]",
+          input.payload.slice(0, 7e3),
+          "[/CANONICAL_FACTS]"
+        ].join("\n");
+      }
+      _rejectRepeatedResolvedRead(tc, messages2) {
+        if (tc.name !== "file_read") {
+          for (const state2 of this._resolvedReadEvidence.values()) {
+            state2.consumed = true;
+          }
+          return null;
+        }
+        const fingerprint = this._buildToolFingerprint(tc.name, tc.arguments);
+        const state = this._resolvedReadEvidence.get(fingerprint);
+        if (!state)
+          return null;
+        const latestAssistant = [...messages2].reverse().find((message2) => message2.role === "assistant" && typeof message2.content === "string");
+        if (latestAssistant && typeof latestAssistant.content === "string" && latestAssistant.content.includes(state.handle)) {
+          state.consumed = true;
+        }
+        return [
+          "[REPEATED_READ_REJECTED]",
+          `handle=${state.handle}`,
+          `fingerprint_state=${state.state}`,
+          state.consumed ? "The evidence handle was acknowledged, but an identical read cannot add facts. Change file/range/query scope or take the evidence-backed next action." : "Consume the rehydrated evidence handle in your next decision before requesting another read. Change file/range/query scope if a different fact is required."
+        ].join("\n");
+      }
+      async _drainPendingSteeringMessages(messages2, turn) {
+        this.drainPendingRuntimeGuidance(turn);
+        while (this.pendingUserMessages.length > 0) {
+          const userMsg = this.pendingUserMessages.shift();
+          const record = this._steeringRecordForContent(userMsg);
+          const replacement = this._pendingSteeringPreemption;
+          if (replacement?.intent === "replace" && record && record.inputId !== replacement.inputId) {
+            record.state = "superseded";
+            this._emitSteeringLifecycle(record, `superseded before consumption by replacement ${replacement.inputId}`);
+            continue;
+          }
+          await this.appendInjectedUserMessage(userMsg, messages2, turn);
+          if (record) {
+            record.state = "consumed";
+            this._emitSteeringLifecycle(record, `consumed at turn ${turn}`);
+          }
+        }
+      }
+      /** Apply a preemption only at a safe boundary after its user content is visible. */
+      _applyPendingSteeringPreemption(messages2, turn) {
+        const record = this._pendingSteeringPreemption;
+        if (!record)
+          return false;
+        this._pendingSteeringPreemption = null;
+        if (record.intent === "cancel") {
+          record.state = "cancelled";
+          this._emitSteeringLifecycle(record, `cancelled active task at turn ${turn}`);
+          this.abort();
+          return true;
+        }
+        const previousEpoch = this._taskEpoch;
+        this._archiveSupersededTaskState(previousEpoch, record);
+        this._allowImplicitContinuation = false;
+        this._taskEpoch += 1;
+        record.taskEpoch = this._taskEpoch;
+        if (record.intent === "replace") {
+          for (const candidate of this.pendingSteeringInputs) {
+            if (candidate.inputId !== record.inputId && candidate.taskEpoch === previousEpoch && (candidate.state === "queued" || candidate.state === "acknowledged")) {
+              candidate.state = "superseded";
+              this._emitSteeringLifecycle(candidate, `superseded by replacement ${record.inputId}`);
+            }
+          }
+        }
+        this._completionContract = null;
+        this._completionLedger = this.writesUserTaskArtifacts() ? createCompletionLedger({
+          runId: this.currentArtifactRunId(),
+          goal: record.content
+        }) : null;
+        if (this._completionLedger) {
+          this._completionLedger.taskEpoch = this._taskEpoch;
+        }
+        this._completionHoldState.count = 0;
+        this._completionHoldState.total = 0;
+        this._completionHoldState.lastKey = "";
+        this._completionIncompleteVerification = null;
+        this._taskState.goal = record.content;
+        this._taskState.originalGoal = record.content;
+        messages2.push({
+          role: "system",
+          content: [
+            "[ACTIVE USER STEERING - HIGHEST USER PRIORITY]",
+            `inputId=${record.inputId} taskEpoch=${this._taskEpoch} intent=${record.intent}`,
+            "The prior task epoch is historical evidence only. Do not continue its plan, todos, recovery cards, or completion contract.",
+            "Replan from this active user instruction before any further tool call:",
+            record.content
+          ].join("\n")
+        });
+        record.state = "consumed";
+        this._emitSteeringLifecycle(record, `applied at turn ${turn}; epoch ${previousEpoch} -> ${this._taskEpoch}`);
+        return true;
       }
       /**
        * Pause the current task gracefully. The run loop will suspend at the next
@@ -596899,28 +597371,32 @@ ${notice}`;
         const cacheKey = `${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`;
         const cached = this._branchEvidenceCache.get(cacheKey);
         if (cached) {
-          const duplicateBlocked = [
-            `[BRANCH-DUPLICATE-BLOCKED] path=${rawPath} sha256=${fullHash} contract=${contractFingerprint}`,
-            `The unchanged source was already branch-extracted into the current evidence ledger; the registered file_read was not executed and raw content was not re-injected.`,
-            `Use the existing curated anchors. If a required discovery is unresolved, issue one narrower grep_search or a range whose projected payload stays below the 20% limit; otherwise take the next task action.`
-          ].join("\n");
+          const fingerprint = this._buildToolFingerprint(input.toolName, input.args);
+          const rehydrated = this._rehydrateResolvedReadEvidence({
+            fingerprint,
+            canonicalPath,
+            contentHash: fullHash,
+            payload: cached.output,
+            turn: input.turn
+          });
           this.emit({
             type: "status",
             toolName: input.toolName,
-            content: `Branch-extract cache hit: ${rawPath} sha256=${fullHash.slice(0, 12)} contract=${contractFingerprint}`,
+            content: `Branch-extract cache rehydrated: ${rawPath} sha256=${fullHash.slice(0, 12)} contract=${contractFingerprint} fingerprint_state=resolved_from_cache`,
             turn: input.turn,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
           return {
             success: true,
-            output: duplicateBlocked,
-            llmContent: duplicateBlocked,
+            output: rehydrated,
+            llmContent: rehydrated,
             beforeHash: fullHash,
             runtimeAuthored: true,
             noop: true,
             completionEvidenceMetrics: {
               branchSourceBytes: cached.sourceBytes,
-              branchCacheHit: true
+              branchCacheHit: true,
+              fingerprintState: "resolved_from_cache"
             }
           };
         }
@@ -597439,7 +597915,7 @@ ${inventory}`
           });
           this._onTypedEvent?.({
             type: "trajectory_checkpoint",
-            runId: this._sessionId,
+            runId: this.currentArtifactRunId(),
             revision: checkpoint.revision,
             assessment: checkpoint.assessment,
             nextAction: checkpoint.nextAction,
@@ -597450,7 +597926,7 @@ ${inventory}`
             recordDebugTrajectoryCheckpoint({
               cwd: this.authoritativeWorkingDirectory(),
               stateDir: this.omniusStateDir(),
-              runId: this._sessionId,
+              runId: this.currentArtifactRunId(),
               sessionId: this._sessionId,
               checkpoint
             });
@@ -597691,6 +598167,9 @@ Respond with the assessment and take the selected evidence-backed action.`;
       async run(task, context2, actualUserGoal) {
         this.aborted = false;
         this._abortController = new AbortController();
+        this._turnAbortController = new AbortController();
+        this._taskEpoch += 1;
+        this._activeRunId = `${this._sessionId || "run"}-${Date.now()}-${this._taskEpoch}`;
         this._fileWritesThisRun = 0;
         this._backwardPassCyclesUsed = 0;
         this._completionVerifyRejections = 0;
@@ -597716,7 +598195,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this._resetVisualEvidenceState();
         this._verifyFailuresBaseline = new Set(this._verifyFailures);
         if (typeof this.backend.setAbortSignal === "function") {
-          this.backend.setAbortSignal(this._abortController.signal);
+          this.backend.setAbortSignal(this._turnAbortController.signal);
         }
         const cleanedTask = cleanForStorage(task) || task.slice(0, 500);
         const start2 = Date.now();
@@ -597847,7 +598326,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         }
         this._loadResolutionMemory();
         this._pauseResolve = null;
-        this.pendingUserMessages.length = 0;
+        this._prepareSteeringInputsForRun();
         const persistentTaskGoal = cleanForStorage(actualUserGoal || "") || cleanedTask;
         const userGoal = persistentTaskGoal.slice(0, 500);
         this._taskRelevantErrorPatterns = process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] === "1" ? /* @__PURE__ */ new Map() : await this._selectTaskRelevantErrorPatterns(persistentTaskGoal, 10);
@@ -597952,9 +598431,10 @@ Respond with the assessment and take the selected evidence-backed action.`;
         if (this.writesUserTaskArtifacts()) {
           this._initializeCompletionContract(task, context2, actualUserGoal);
           this._completionLedger = createCompletionLedger({
-            runId: this._sessionId,
+            runId: this._activeRunId || this._sessionId,
             goal: userGoal
           });
+          this._completionLedger.taskEpoch = this._taskEpoch;
         } else {
           this._completionContract = null;
           this._completionLedger = null;
@@ -598260,9 +598740,9 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           if (process.env["OMNIUS_FRESH_SESSION"] === "1")
             throw "skip-handoff-fresh";
           const omniusDir = this._workingDirectory ? _pathJoin(this._workingDirectory, ".omnius") : _pathJoin(process.cwd(), ".omnius");
-          const chainPairs = loadMessagePairsFromLog(omniusDir, {
+          const chainPairs = this._allowImplicitContinuation ? loadMessagePairsFromLog(omniusDir, {
             currentTask: persistentTaskGoal
-          });
+          }) : [];
           if (chainPairs.length > 0) {
             messages2.splice(1, 0, ...chainPairs);
             this.emit({
@@ -598273,7 +598753,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           } else {
             const prior = readTaskHandoff(omniusDir, {
               currentSessionId: this._sessionId,
-              currentTask: persistentTaskGoal
+              currentTask: persistentTaskGoal,
+              allowImplicitContinuation: this._allowImplicitContinuation
             });
             if (prior) {
               const handoffPair = buildHandoffMessagePair(prior);
@@ -598388,7 +598869,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             }),
             persistPath,
             sessionId: this._sessionId,
-            runId: this._sessionId,
+            runId: this.currentArtifactRunId(),
             cwd: this._workingDirectory || process.cwd(),
             model: this._backendModelLabel(this.backend),
             onCritique: (critique2, sourceTurn) => {
@@ -598634,6 +599115,19 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           return completionHoldEscapeMax * 2;
         })();
         const holdTaskCompleteGates = (args, turn) => {
+          if (this._hasEvidenceBackedBlockedCompletion(args)) {
+            this._completionHoldState.count = 0;
+            this._completionHoldState.lastKey = "";
+            this._completionHoldState.total = 0;
+            lastCompletionGateCode = "";
+            this.emit({
+              type: "status",
+              content: "task_complete admitted as evidence-backed blocked state",
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            return false;
+          }
           if (this._completionHoldState.total >= completionHoldHardMax) {
             const incompleteSummary = [
               `INCOMPLETE_VERIFICATION: completion was requested after ${this._completionHoldState.total} gate hold(s), but required evidence is still missing.`,
@@ -598853,6 +599347,8 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
           }
         }
         for (let turn = 0; turn < turnCap; turn++) {
+          this._turnAbortController = new AbortController();
+          this._setBackendTurnAbortSignal(this._turnAbortController.signal);
           clearTurnState(this._appState);
           this._maybeApplyThinkGuard();
           if (this._paused) {
@@ -598865,7 +599361,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
               });
               this._onTypedEvent?.({
                 type: "run_failed",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 error: "Task aborted by user",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
@@ -598880,7 +599376,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             });
             this._onTypedEvent?.({
               type: "run_failed",
-              runId: this._sessionId ?? "unknown",
+              runId: this.currentArtifactRunId(),
               error: "Task aborted by user",
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
@@ -598954,7 +599450,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
               });
               this._onTypedEvent?.({
                 type: "completion_requested",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 summary: summary.slice(0, 500),
                 sourcePath: "direct",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -600019,10 +600515,11 @@ ${_staleSamples.join("\n")}` : ``,
               });
             }
           }
-          this.drainPendingRuntimeGuidance(turn);
-          while (this.pendingUserMessages.length > 0) {
-            const userMsg = this.pendingUserMessages.shift();
-            await this.appendInjectedUserMessage(userMsg, messages2, turn);
+          await this._drainPendingSteeringMessages(messages2, turn);
+          if (this._applyPendingSteeringPreemption(messages2, turn)) {
+            if (this.aborted)
+              break;
+            continue;
           }
           if (!this.options.disableTodoPlanningNudges) {
             const maybeReminder = this.getTodoReminderContent(turn);
@@ -600252,7 +600749,7 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
                 toolEvents: this._toolEvents,
                 memoryHints: [],
                 runState: {
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   tokenBudget: _limits.compactionThreshold,
                   completionContract: this._completionContract ? formatCompletionContract(this._completionContract) : void 0
                 }
@@ -600397,7 +600894,7 @@ ${memoryLines.join("\n")}`
               toolEvents: this._toolEvents,
               memoryHints: [],
               runState: {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 tokenBudget: _limits.compactionThreshold,
                 completionContract: this._completionContract ? formatCompletionContract(this._completionContract) : void 0
               }
@@ -600425,6 +600922,11 @@ ${memoryLines.join("\n")}`
           const echoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
           if (this._echoTempBoostTurns > 0)
             this._echoTempBoostTurns--;
+          const actionGroundTruth = this._buildRecentActionGroundTruth(turn);
+          if (actionGroundTruth) {
+            requestMessages.push({ role: "system", content: actionGroundTruth });
+          }
+          this._retireLinkedAssistantReadIntents(requestMessages);
           const chatRequest = {
             messages: requestMessages,
             tools: toolDefs,
@@ -600508,6 +601010,15 @@ ${memoryLines.join("\n")}`
           try {
             response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
           } catch (reqErr) {
+            if (this._pendingSteeringPreemption) {
+              this.emit({
+                type: "status",
+                content: "Model request interrupted by pending user steering; skipping recovery.",
+                turn,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              continue;
+            }
             if (reqErr instanceof Error && reqErr.fatal) {
               this.emit({
                 type: "error",
@@ -600516,7 +601027,7 @@ ${memoryLines.join("\n")}`
               });
               this._onTypedEvent?.({
                 type: "run_failed",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 error: reqErr.message,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
@@ -600535,7 +601046,7 @@ ${memoryLines.join("\n")}`
                 });
                 this._onTypedEvent?.({
                   type: "run_failed",
-                  runId: this._sessionId ?? "unknown",
+                  runId: this.currentArtifactRunId(),
                   error: retryMsg,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -600559,7 +601070,7 @@ ${memoryLines.join("\n")}`
                   });
                   this._onTypedEvent?.({
                     type: "run_failed",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     error: `Model not found: ${errMsg}`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
@@ -600634,7 +601145,7 @@ ${memoryLines.join("\n")}`
                             summary = String(parsed.args?.summary ?? content);
                             this._onTypedEvent?.({
                               type: "completion_requested",
-                              runId: this._sessionId ?? "unknown",
+                              runId: this.currentArtifactRunId(),
                               summary: summary.slice(0, 500),
                               sourcePath: this.options.streamEnabled ? "stream" : "batch",
                               timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -600657,7 +601168,7 @@ ${memoryLines.join("\n")}`
                     });
                     this._onTypedEvent?.({
                       type: "run_failed",
-                      runId: this._sessionId ?? "unknown",
+                      runId: this.currentArtifactRunId(),
                       error: msg2,
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
                     });
@@ -600672,7 +601183,7 @@ ${memoryLines.join("\n")}`
                   });
                   this._onTypedEvent?.({
                     type: "run_failed",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     error: `Backend unavailable: ${errMsg}`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
@@ -600682,10 +601193,10 @@ ${memoryLines.join("\n")}`
               response = recovered ?? response;
             }
           }
-          totalTokens += response.usage?.totalTokens ?? 0;
-          promptTokens += response.usage?.promptTokens ?? 0;
+          totalTokens += response.usage?.totalTokens || (response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0) + (response.usage?.completionTokens ?? 0);
+          promptTokens += response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0;
           completionTokens += response.usage?.completionTokens ?? 0;
-          const turnPromptTokens = response.usage?.promptTokens ?? 0;
+          const turnPromptTokens = response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0;
           const turnCompletionTokens = response.usage?.completionTokens ?? 0;
           if (turnPromptTokens || turnCompletionTokens) {
             recordTokenUsage(this._appState, turnPromptTokens, turnCompletionTokens, 0, false);
@@ -600903,8 +601414,19 @@ ${memoryLines.join("\n")}`
               reservations: /* @__PURE__ */ new Map()
             };
             executeSingle = async (tc) => {
-              if (this.aborted)
+              if (this.aborted || this._pendingSteeringPreemption)
                 return null;
+              const resolvedReadBlock = this._rejectRepeatedResolvedRead(tc, messages2);
+              if (resolvedReadBlock) {
+                this.emit({
+                  type: "status",
+                  toolName: tc.name,
+                  content: "Repeated planned file_read rejected until evidence scope changes.",
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                return { tc, output: resolvedReadBlock, success: true };
+              }
               const cohortKey = this.buildArgCohortKey(tc.name, tc.arguments);
               const cohort = this._argCohorts.get(cohortKey);
               if (cohort && cohort.failure >= 3 && cohort.success === 0) {
@@ -601920,30 +602442,70 @@ ${cachedResult}`,
                               const currentRead = this._fileReadDiskIdentity(tc.arguments);
                               if (currentRead && currentRead.contentHash === priorRead.contentHash) {
                                 exactFileReadObservations.set(exactReadKey, currentRead);
-                                const duplicateOutput = [
-                                  `[DUPLICATE_READ_BLOCKED] path=${currentRead.path} sha256=${currentRead.contentHash}`,
-                                  `The exact file_read arguments already produced evidence from this unchanged source during the current run. The tool was not re-executed and the raw body was not re-injected.`,
-                                  `Use the existing evidence/anchors now. To discover something different, issue one narrower offset/limit or grep_search with a new symbol; otherwise take the next mutation, verification, or completion action.`
-                                ].join("\n");
-                                branchPreempted = {
-                                  success: true,
-                                  output: duplicateOutput,
-                                  llmContent: duplicateOutput,
-                                  beforeHash: currentRead.contentHash,
-                                  runtimeAuthored: true,
-                                  noop: true,
-                                  completionEvidenceMetrics: {
-                                    duplicateReadBlocked: true,
-                                    duplicateReadSourceBytes: currentRead.byteCount
+                                const canonicalPayload = this._canonicalReadEvidencePayload(currentRead.canonicalPath, currentRead.contentHash);
+                                if (canonicalPayload) {
+                                  const rehydrated = this._rehydrateResolvedReadEvidence({
+                                    fingerprint: exactReadKey,
+                                    canonicalPath: currentRead.canonicalPath,
+                                    contentHash: currentRead.contentHash,
+                                    payload: canonicalPayload,
+                                    turn
+                                  });
+                                  branchPreempted = {
+                                    success: true,
+                                    output: rehydrated,
+                                    llmContent: rehydrated,
+                                    beforeHash: currentRead.contentHash,
+                                    runtimeAuthored: true,
+                                    noop: true,
+                                    completionEvidenceMetrics: {
+                                      duplicateReadResolvedFromCache: true,
+                                      duplicateReadSourceBytes: currentRead.byteCount,
+                                      fingerprintState: "resolved_from_cache"
+                                    }
+                                  };
+                                  this.emit({
+                                    type: "status",
+                                    toolName: normalizedDispatchName,
+                                    content: `Exact unchanged file_read rehydrated: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)} fingerprint_state=resolved_from_cache`,
+                                    turn,
+                                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                                  });
+                                } else {
+                                  if (this._deterministicNarrowReadFallbacks.has(exactReadKey)) {
+                                    const fallbackBlocked = [
+                                      "[REPEATED_NARROW_READ_REJECTED]",
+                                      `path=${currentRead.path}`,
+                                      "No canonical payload was produced by the allowed narrow reread. Change scope with a new range or symbol query; do not repeat identical arguments."
+                                    ].join("\n");
+                                    branchPreempted = {
+                                      success: true,
+                                      output: fallbackBlocked,
+                                      llmContent: fallbackBlocked,
+                                      beforeHash: currentRead.contentHash,
+                                      runtimeAuthored: true,
+                                      noop: true
+                                    };
+                                  } else {
+                                    this._deterministicNarrowReadFallbacks.add(exactReadKey);
+                                    const previousOffset = tc.arguments["offset"];
+                                    const previousLimit = tc.arguments["limit"];
+                                    Object.assign(finalArgs, {
+                                      offset: typeof previousOffset === "number" && Number.isFinite(previousOffset) ? Math.max(1, Math.floor(previousOffset)) : 1,
+                                      limit: typeof previousLimit === "number" && Number.isFinite(previousLimit) ? Math.max(1, Math.min(160, Math.floor(previousLimit))) : 160
+                                    });
+                                    tc.arguments = finalArgs;
+                                    this._deterministicNarrowReadFallbacks.add(this._buildToolFingerprint("file_read", tc.arguments));
+                                    exactFileReadObservations.delete(exactReadKey);
+                                    this.emit({
+                                      type: "status",
+                                      toolName: normalizedDispatchName,
+                                      content: `Exact read cache lacked canonical payload; allowing one deterministic narrow reread: ${currentRead.path} offset=${tc.arguments["offset"]} limit=${tc.arguments["limit"]}`,
+                                      turn,
+                                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                                    });
                                   }
-                                };
-                                this.emit({
-                                  type: "status",
-                                  toolName: normalizedDispatchName,
-                                  content: `Exact unchanged file_read blocked before dispatch: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)}`,
-                                  turn,
-                                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                                });
+                                }
                               } else {
                                 exactFileReadObservations.delete(exactReadKey);
                               }
@@ -602119,6 +602681,7 @@ Respond with EXACTLY this structure before your next tool call:
                 args: tc.arguments,
                 result
               });
+              this._reconcileCreationGroundTruth(resolvedTool?.name ?? tc.name, tc.arguments, result, turn);
               if (observedStateMutation) {
                 this._markAdversaryObservedStateMutation();
               }
@@ -602209,7 +602772,7 @@ Respond with EXACTLY this structure before your next tool call:
                       writeCount: prev?.writeCount
                     });
                   }
-                  if (p2 && result.success && result.output) {
+                  if (p2 && result.success && result.output && !(result.runtimeAuthored === true && result.noop === true)) {
                     const rOffset = typeof tc.arguments?.["offset"] === "number" ? tc.arguments["offset"] : void 0;
                     const rLimit = typeof tc.arguments?.["limit"] === "number" ? tc.arguments["limit"] : void 0;
                     const start3 = rOffset === void 0 && rLimit === void 0 ? 0 : Math.max(1, rOffset ?? 1);
@@ -603537,7 +604100,7 @@ ${delegateDir}` : delegateDir;
                 recordDebugToolEvent({
                   cwd: this.authoritativeWorkingDirectory(),
                   stateDir: this.omniusStateDir(),
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   sessionId: this._sessionId,
                   turn,
                   toolCallId: tc.id,
@@ -603791,7 +604354,7 @@ Then use file_read on individual FILES inside it.`);
               });
               this._onTypedEvent?.({
                 type: "tool_call_finished",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 toolName: tc.name,
                 callId: tc.id,
                 success: result.success === true,
@@ -603903,7 +604466,7 @@ ${sr.result.output}`;
                       summary = extractTaskCompleteSummary(taskCompleteArgs);
                       this._onTypedEvent?.({
                         type: "completion_requested",
-                        runId: this._sessionId ?? "unknown",
+                        runId: this.currentArtifactRunId(),
                         summary: (summary ?? "").slice(0, 500),
                         sourcePath: this.options.streamEnabled ? "stream" : "batch",
                         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -603926,7 +604489,7 @@ ${sr.result.output}`;
               if (!completed && !this._completionIncompleteVerification) {
                 const unhandled = rawToolCalls.filter((tc) => !handledIds.has(tc.id));
                 for (const tc of unhandled) {
-                  if (this.aborted)
+                  if (this.aborted || this._pendingSteeringPreemption)
                     break;
                   const r2 = await executeSingle(tc);
                   if (r2) {
@@ -603978,7 +604541,7 @@ ${sr.result.output}`;
                         summary = extractTaskCompleteSummary(taskCompleteArgs);
                         this._onTypedEvent?.({
                           type: "completion_requested",
-                          runId: this._sessionId ?? "unknown",
+                          runId: this.currentArtifactRunId(),
                           summary: (summary ?? "").slice(0, 500),
                           sourcePath: this.options.streamEnabled ? "stream" : "batch",
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -604008,7 +604571,7 @@ ${sr.result.output}`;
               }));
               const batches = partitionToolCalls(batchToolCalls);
               for (const batch2 of batches) {
-                if (this.aborted)
+                if (this.aborted || this._pendingSteeringPreemption)
                   break;
                 const batchFingerprintFirstId = /* @__PURE__ */ new Map();
                 const batchInFlight = /* @__PURE__ */ new Map();
@@ -604092,7 +604655,7 @@ ${sr.result.output}`;
                         summary = extractTaskCompleteSummary(taskCompleteArgs);
                         this._onTypedEvent?.({
                           type: "completion_requested",
-                          runId: this._sessionId ?? "unknown",
+                          runId: this.currentArtifactRunId(),
                           summary: (summary ?? "").slice(0, 500),
                           sourcePath: this.options.streamEnabled ? "stream" : "batch",
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -604321,7 +604884,7 @@ Only call task_complete when the task is actually complete and the evidence is f
               summary = content;
               this._onTypedEvent?.({
                 type: "completion_requested",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 summary: content.slice(0, 500),
                 sourcePath: this.options.streamEnabled ? "stream" : "batch",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -604570,7 +605133,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 toolEvents: this._toolEvents,
                 memoryHints: [],
                 runState: {
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   tokenBudget: _limits.compactionThreshold,
                   completionContract: this._completionContract ? formatCompletionContract(this._completionContract) : void 0
                 }
@@ -604594,7 +605157,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 });
                 this._onTypedEvent?.({
                   type: "run_failed",
-                  runId: this._sessionId ?? "unknown",
+                  runId: this.currentArtifactRunId(),
                   error: "Task aborted by user",
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -604609,7 +605172,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               });
               this._onTypedEvent?.({
                 type: "run_failed",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 error: "Task aborted by user",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
@@ -604666,6 +605229,13 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             const bfEchoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
             if (this._echoTempBoostTurns > 0)
               this._echoTempBoostTurns--;
+            const bruteForceGroundTruth = this._buildRecentActionGroundTruth(turn);
+            if (bruteForceGroundTruth) {
+              modelFacingMessages.push({
+                role: "system",
+                content: bruteForceGroundTruth
+              });
+            }
             const chatRequest = {
               messages: modelFacingMessages,
               tools: toolDefs,
@@ -604687,7 +605257,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 });
                 this._onTypedEvent?.({
                   type: "run_failed",
-                  runId: this._sessionId ?? "unknown",
+                  runId: this.currentArtifactRunId(),
                   error: "Task aborted by user",
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -604706,7 +605276,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   });
                   this._onTypedEvent?.({
                     type: "run_failed",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     error: bfRetryMsg,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
@@ -604729,7 +605299,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   });
                   this._onTypedEvent?.({
                     type: "run_failed",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     error: errMsg2,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
@@ -604738,10 +605308,10 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 response = recovered;
               }
             }
-            totalTokens += response.usage?.totalTokens ?? 0;
-            promptTokens += response.usage?.promptTokens ?? 0;
+            totalTokens += response.usage?.totalTokens || (response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0) + (response.usage?.completionTokens ?? 0);
+            promptTokens += response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0;
             completionTokens += response.usage?.completionTokens ?? 0;
-            const bfTurnPrompt = response.usage?.promptTokens ?? 0;
+            const bfTurnPrompt = response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0;
             const bfTurnCompletion = response.usage?.completionTokens ?? 0;
             if (bfTurnPrompt || bfTurnCompletion) {
               recordTokenUsage(this._appState, bfTurnPrompt, bfTurnCompletion, 0, false);
@@ -604871,7 +605441,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                     summary = extractTaskCompleteSummary(taskCompleteArgs);
                     this._onTypedEvent?.({
                       type: "completion_requested",
-                      runId: this._sessionId ?? "unknown",
+                      runId: this.currentArtifactRunId(),
                       summary: (summary ?? "").slice(0, 500),
                       sourcePath: this.options.streamEnabled ? "stream" : "batch",
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -604929,7 +605499,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   summary = content;
                   this._onTypedEvent?.({
                     type: "completion_requested",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     summary: content.slice(0, 500),
                     sourcePath: this.options.streamEnabled ? "stream" : "batch",
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -605024,7 +605594,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   });
                   this._onTypedEvent?.({
                     type: "completion_requested",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     summary: summary.slice(0, 500),
                     sourcePath: "direct",
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -605081,7 +605651,7 @@ ${caveat}` : caveat;
         });
         this._onTypedEvent?.({
           type: "run_finished",
-          runId: this._sessionId ?? "unknown",
+          runId: this.currentArtifactRunId(),
           status: runStatus,
           success: completed,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -605769,7 +606339,8 @@ ${caveat}` : caveat;
             const trajDir = path16.join(this.omniusStateDir(), "trajectories");
             fs14.mkdirSync(trajDir, { recursive: true });
             const trajectory = {
-              id: this._sessionId,
+              id: this.currentArtifactRunId(),
+              sessionId: this._sessionId,
               // CLEAN task — this file is the prerequisite for ALL future RL/RFT
               // training. Storing the scaffolded version would teach future models
               // to reproduce signpost text as part of their task understanding.
@@ -606002,7 +606573,7 @@ ${marker}` : marker);
         ].filter(Boolean).join("\n"));
       }
       shouldBypassDiscoveryCompaction(output) {
-        return output.includes("[IMAGE_BASE64:") || output.includes("[BRANCH-EXTRACT]") || output.includes("[REPEAT GATE - cached evidence not re-sent]") || output.includes("[CACHED READ — content unchanged") || output.includes("[REHYDRATED FROM CACHE") || output.includes("[Tool output truncated") || output.includes(TRIAGE_ENVELOPE_MARKER);
+        return output.includes("[IMAGE_BASE64:") || output.includes("[BRANCH-EXTRACT]") || output.includes("[REPEAT GATE - cached evidence not re-sent]") || output.includes("[REPEATED_READ_REJECTED]") || output.includes("[REPEATED_NARROW_READ_REJECTED]") || output.includes("[CACHED READ — content unchanged") || output.includes("[REHYDRATED FROM CACHE") || output.includes("[Tool output truncated") || output.includes(TRIAGE_ENVELOPE_MARKER);
       }
       countTextLines(text2) {
         if (!text2)
@@ -608578,6 +609149,8 @@ ${trimmedNew}`;
        * adversary buffer, this is populated directly after tool execution and does
        * not depend on raw tool messages surviving compaction. */
       _recentToolOutcomes = [];
+      /** Recent successful user-work mutations suppress generic "create again" nudges. */
+      _groundTruthSuccessPaths = /* @__PURE__ */ new Map();
       /** Monotonic counter for observed local state changes.
        *  Redundant-action classification is only valid within the same state
        *  version; a repeated verifier after an edit is fresh evidence. */
@@ -608704,10 +609277,85 @@ ${trimmedNew}`;
           succeeded: input.result.success === true,
           ...outcomeEvidence
         });
+        if (input.result.success === true && this._isRealProjectMutation(input.toolName, input.result)) {
+          for (const rawPath of this._extractToolTargetPaths(input.toolName, input.args ?? {}, input.result)) {
+            const path16 = this._normalizeEvidencePath(rawPath);
+            if (!path16 || path16.startsWith(".omnius/"))
+              continue;
+            this._groundTruthSuccessPaths.set(path16, { turn: input.turn });
+          }
+          this._reg61CooldownUntilTurn = Math.max(this._reg61CooldownUntilTurn, input.turn + 5);
+        }
         while (this._recentToolOutcomes.length > 40) {
           this._recentToolOutcomes.shift();
         }
       }
+      /** Late, bounded execution facts. Never use model prose or controller files. */
+      _buildRecentActionGroundTruth(turn) {
+        const activePaths = [...this._taskState.modifiedFiles.entries()].map(([rawPath, rawAction]) => ({
+          path: this._normalizeEvidencePath(rawPath),
+          rawAction
+        })).filter((entry) => entry.path && !entry.path.startsWith(".omnius/")).slice(-8);
+        if (activePaths.length === 0)
+          return null;
+        const verifier = this._worldFacts.lastTest;
+        const verifierState = verifier?.summary ? `outcome=${verifier.passed ? "passed" : "failed"} turn=${verifier.turn ?? "?"}` : "outcome=not_recorded";
+        const verifierRequired = this._compileFixLoop?.active === true && this._compileFixLoop.verifierDirtySinceTurn !== null;
+        const lines = [
+          "[RECENT ACTION GROUND TRUTH]",
+          `turn=${turn} stateVersion=${this._adversaryStateVersion}`,
+          `verifier=${verifierState}`
+        ];
+        for (const entry of activePaths) {
+          const action = /creat/i.test(entry.rawAction) ? "created" : /delet/i.test(entry.rawAction) ? "deleted" : "modified";
+          const evidence = this._evidenceLedger.get(entry.path);
+          const fact = this._worldFacts.files.get(entry.path);
+          const outcome = [...this._recentToolOutcomes].reverse().find((item) => item.path && this._normalizeEvidencePath(item.path) === entry.path);
+          const resultState = outcome ? outcome.succeeded ? "tool_result=success" : "tool_result=failure" : "tool_result=not_recorded";
+          const hash = evidence?.contentHash ?? "unknown";
+          const bytes = fact && typeof fact.size === "number" ? String(fact.size) : "unknown";
+          const nextAction = verifierRequired ? "run_declared_verifier" : outcome?.succeeded ? "verify_or_complete_distinct_leaf" : "inspect_external_blocker_or_change_scope";
+          const doNot = action === "created" ? "do_not_create_again" : action === "modified" ? "do_not_full_rewrite_without_fresh_read" : "do_not_recreate_without_authoritative_target";
+          lines.push(`${action} path=${entry.path} hash=${hash} bytes=${bytes} ${resultState} stateVersion=${outcome?.stateVersion ?? this._adversaryStateVersion} turn=${outcome?.turn ?? turn} next_valid_action=${nextAction} ${doNot}`);
+        }
+        lines.push("Use these facts over stale assistant plans, broad summaries, or controller artifacts.");
+        return lines.join("\n").slice(0, 5200);
+      }
+      /** Mark a workboard target complete when a confirmed creation satisfies it. */
+      _reconcileCreationGroundTruth(toolName, args, result, turn) {
+        if (result.success !== true || !this._isRealProjectMutation(toolName, result)) {
+          return;
+        }
+        const created = this._extractToolTargetPaths(toolName, args, result).map((path16) => this._normalizeEvidencePath(path16)).filter((path16) => path16 && !path16.startsWith(".omnius/") && /creat/i.test(this._taskState.modifiedFiles.get(path16) ?? ""));
+        if (created.length === 0)
+          return;
+        const board = this._workboard ?? this.getOrCreateWorkboard();
+        if (board) {
+          const card = this._workboardTodoCardForPaths(board, created);
+          if (card && (card.status === "open" || card.status === "in_progress" || card.status === "needs_changes")) {
+            try {
+              const completed = completeWorkboardCard(this._workboardDir(), {
+                runId: this.currentArtifactRunId(),
+                cardId: card.id,
+                actor: this.options.subAgent ? "sub-agent" : "agent",
+                outcome: "completed",
+                reason: `Creation ground truth satisfied mapped target(s): ${created.join(", ")} at turn ${turn}.`
+              });
+              this._workboard = completed.snapshot;
+            } catch {
+            }
+          }
+        }
+        for (const todo of this.readSessionTodos() ?? []) {
+          const artifacts = Array.isArray(todo.declaredArtifacts) ? todo.declaredArtifacts.filter((path16) => typeof path16 === "string").map((path16) => this._normalizeEvidencePath(path16)) : [];
+          if (todo.status !== "completed" && artifacts.length > 0 && artifacts.every((path16) => created.includes(path16))) {
+            const marker = `created target evidence: ${todo.content}`;
+            if (!this._taskState.completedSteps.includes(marker)) {
+              this._taskState.completedSteps.push(marker);
+            }
+          }
+        }
+      }
       _recentToolActionsForWorldState() {
         if (this._recentToolOutcomes.length > 0)
           return this._recentToolOutcomes;
@@ -610462,7 +611110,7 @@ ${result}`
               stage: "vision_image_recovery",
               agentType: "internal",
               sessionId: this._sessionId,
-              runId: this._sessionId,
+              runId: this._activeRunId || this._sessionId,
               turn,
               attempt: 0,
               model,
@@ -610490,7 +611138,7 @@ ${result}`
                   stage: "vision_image_recovery",
                   agentType: "internal",
                   sessionId: this._sessionId,
-                  runId: this._sessionId,
+                  runId: this._activeRunId || this._sessionId,
                   turn,
                   attempt: 1,
                   model,
@@ -610570,7 +611218,7 @@ ${description}`
        * Returns the response on success, or null if recovery did not apply.
        */
       async retryOnTransient(initialErr, chatRequest, turn) {
-        if (this.aborted)
+        if (this.aborted || this._pendingSteeringPreemption)
           return null;
         if (!this.isTransientError(initialErr))
           return null;
@@ -610584,7 +611232,7 @@ ${description}`
         const backend = this.backend;
         let attempt = 1;
         while (attempt <= (maxRetries === Infinity ? Number.MAX_SAFE_INTEGER : maxRetries)) {
-          if (this.aborted)
+          if (this.aborted || this._pendingSteeringPreemption)
             return null;
           if (this.isPaymentRequiredError(initialErr) && typeof backend.rotateKey === "function") {
             const rotated = backend.rotateKey();
@@ -610651,7 +611299,7 @@ ${description}`
             });
           }
           await new Promise((r2) => setTimeout(r2, effectiveDelay));
-          if (this.aborted)
+          if (this.aborted || this._pendingSteeringPreemption)
             return null;
           try {
             this._recordContextWindowDump("agent_turn_transient_retry", chatRequest, turn, attempt);
@@ -610719,7 +611367,7 @@ ${description}`
           }
         }
         for await (const chunk of backend.chatCompletionStream(request)) {
-          if (this.aborted)
+          if (this.aborted || this._pendingSteeringPreemption)
             break;
           if (chunk.type === "usage" && chunk.usage) {
             streamUsage = chunk.usage;
@@ -611932,8 +612580,6 @@ var init_nexusBackend = __esm({
       effectiveThink(request) {
         if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
           return false;
-        if (process.env["OMNIUS_ENABLE_THINKING"] !== "1")
-          return false;
         if (Array.isArray(request.tools) && request.tools.length > 0)
           return false;
         if (request.think === true)
@@ -633315,11 +633961,149 @@ async function queryOpenAIContextSize(baseUrl2, modelName, apiKey) {
     return null;
   }
 }
-async function queryContextSize(baseUrl2, modelName, apiKey) {
-  if (baseUrl2.startsWith("peer://")) return 32768;
+function llamaCppRootUrl(baseUrl2) {
+  return normalizeBaseUrl(baseUrl2).replace(/\/v1$/i, "");
+}
+function asRecord(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
+}
+function positiveInteger(value2) {
+  const parsed = typeof value2 === "number" ? value2 : typeof value2 === "string" && /^\d+$/.test(value2.trim()) ? Number(value2) : NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : void 0;
+}
+function firstPositive(record, keys) {
+  for (const key of keys) {
+    const value2 = positiveInteger(record[key]);
+    if (value2 !== void 0) return value2;
+  }
+  return void 0;
+}
+function contextCapacityFromRecord(record) {
+  return firstPositive(record, [
+    "n_ctx",
+    "n_ctx_train",
+    "context_length",
+    "context_window",
+    "max_model_len",
+    "max_context_length"
+  ]);
+}
+function telemetryHeaders(apiKey) {
+  return apiKey ? { Authorization: `Bearer ${apiKey}` } : void 0;
+}
+async function fetchTelemetryJson(url, apiKey) {
+  try {
+    const response = await fetch(url, {
+      headers: telemetryHeaders(apiKey),
+      signal: AbortSignal.timeout(LLAMA_CPP_TELEMETRY_TIMEOUT_MS)
+    });
+    return response.ok ? await response.json() : null;
+  } catch {
+    return null;
+  }
+}
+function llamaCppSlotsFromJson(raw, endpoint, model) {
+  const root = asRecord(raw);
+  const slots = Array.isArray(raw) ? raw : Array.isArray(root?.["slots"]) ? root["slots"] : null;
+  if (!slots) return null;
+  const active = slots.map(asRecord).filter((slot) => {
+    if (!slot) return false;
+    return slot["is_processing"] === true || firstPositive(slot, ["n_prompt_tokens", "n_past", "n_decoded", "n_tokens"]) !== void 0;
+  });
+  if (active.length === 0) {
+    return { endpoint, model, activeSlotCount: 0, isLlamaCpp: true };
+  }
+  const measured = active.map((slot) => {
+    const promptTokens = firstPositive(slot, ["n_prompt_tokens", "prompt_tokens"]);
+    const decodedTokens = firstPositive(slot, ["n_decoded", "n_generated", "n_output_tokens"]);
+    const observed = promptTokens !== void 0 ? promptTokens + (decodedTokens ?? 0) : firstPositive(slot, ["n_past", "n_tokens"]) ?? decodedTokens;
+    return {
+      capacityTokens: firstPositive(slot, ["n_ctx", "context_length"]),
+      promptTokens,
+      decodedTokens,
+      outputReservationTokens: firstPositive(slot, ["n_predict", "n_predict_max", "n_output_reservation"]),
+      estimatedContextTokens: observed
+    };
+  });
+  const selected = measured.reduce(
+    (best, candidate) => (candidate.estimatedContextTokens ?? 0) > (best.estimatedContextTokens ?? 0) ? candidate : best
+  );
+  return {
+    endpoint,
+    model,
+    ...selected,
+    capacitySource: selected.capacityTokens ? "llama_cpp_slots" : void 0,
+    activeSlotCount: active.length,
+    isLlamaCpp: true
+  };
+}
+async function queryLlamaCppSlotTelemetry(baseUrl2, modelName, apiKey) {
+  const endpoint = llamaCppRootUrl(baseUrl2);
+  const slots = await fetchTelemetryJson(`${endpoint}/slots`, apiKey);
+  return llamaCppSlotsFromJson(slots, endpoint, modelName);
+}
+function llamaCppModelCapacity(raw, modelName) {
+  const root = asRecord(raw);
+  if (!root) return void 0;
+  const records = Array.isArray(root["data"]) ? root["data"].map(asRecord).filter((entry) => entry !== null) : [];
+  const target = records.find(
+    (entry) => [entry["id"], entry["name"], entry["model"]].some(
+      (value2) => typeof value2 === "string" && value2 === modelName
+    )
+  );
+  return (target && contextCapacityFromRecord(target)) ?? contextCapacityFromRecord(root);
+}
+async function queryLlamaCppContextTelemetry(baseUrl2, modelName, apiKey) {
+  const endpoint = llamaCppRootUrl(baseUrl2);
+  const [propsRaw, modelsRaw, slotsRaw] = await Promise.all([
+    fetchTelemetryJson(`${endpoint}/props`, apiKey),
+    fetchTelemetryJson(`${endpoint}/v1/models`, apiKey),
+    fetchTelemetryJson(`${endpoint}/slots`, apiKey)
+  ]);
+  const props = asRecord(propsRaw);
+  const slots = llamaCppSlotsFromJson(slotsRaw, endpoint, modelName);
+  const propsCapacity = props ? contextCapacityFromRecord(props) : void 0;
+  const modelsCapacity = llamaCppModelCapacity(modelsRaw, modelName);
+  const isLlamaCpp = props !== null || slots !== null;
+  if (!isLlamaCpp) return null;
+  const capacityTokens = propsCapacity ?? modelsCapacity ?? slots?.capacityTokens;
+  const capacitySource = propsCapacity ? "llama_cpp_props" : modelsCapacity ? "llama_cpp_models" : slots?.capacityTokens ? "llama_cpp_slots" : void 0;
+  return {
+    endpoint,
+    model: modelName,
+    ...slots,
+    capacityTokens,
+    capacitySource,
+    isLlamaCpp: true
+  };
+}
+async function queryContextTelemetry(baseUrl2, modelName, apiKey) {
+  const endpoint = normalizeBaseUrl(baseUrl2);
+  if (baseUrl2.startsWith("peer://")) {
+    return {
+      endpoint,
+      model: modelName,
+      capacityTokens: 32768,
+      capacitySource: "peer_default"
+    };
+  }
   const ollamaSize = await queryModelContextSize(baseUrl2, modelName);
-  if (ollamaSize) return ollamaSize;
-  return queryOpenAIContextSize(baseUrl2, modelName, apiKey);
+  if (ollamaSize) {
+    return { endpoint, model: modelName, capacityTokens: ollamaSize, capacitySource: "ollama_show" };
+  }
+  const llama = await queryLlamaCppContextTelemetry(baseUrl2, modelName, apiKey);
+  const openAiSize = await queryOpenAIContextSize(baseUrl2, modelName, apiKey);
+  if (openAiSize) {
+    return {
+      ...llama ?? { endpoint, model: modelName },
+      capacityTokens: openAiSize,
+      capacitySource: llama?.capacitySource ?? "openai_models"
+    };
+  }
+  return llama ?? { endpoint, model: modelName };
+}
+async function queryContextSize(baseUrl2, modelName, apiKey) {
+  return (await queryContextTelemetry(baseUrl2, modelName, apiKey)).capacityTokens ?? null;
 }
 async function queryModelCapabilities(baseUrl2, modelName) {
   const caps = { vision: false, toolUse: false, thinking: false };
@@ -633412,7 +634196,7 @@ function formatRelativeTime(iso2) {
   const months = Math.floor(days / 30);
   return `${months}mo ago`;
 }
-var IMAGE_GEN_PATTERNS;
+var IMAGE_GEN_PATTERNS, LLAMA_CPP_TELEMETRY_TIMEOUT_MS;
 var init_model_picker = __esm({
   "packages/cli/src/tui/model-picker.ts"() {
     init_dist6();
@@ -633426,6 +634210,7 @@ var init_model_picker = __esm({
       /midjourney/i,
       /imagen/i
     ];
+    LLAMA_CPP_TELEMETRY_TIMEOUT_MS = 2500;
   }
 });
 
@@ -633689,6 +634474,237 @@ var init_tool_collapse_store = __esm({
   }
 });
 
+// packages/cli/src/utils/internal-output.ts
+function compactForDisplay(text2, max = 170) {
+  const clean5 = text2.replace(/\s+/g, " ").trim();
+  return clean5.length <= max ? clean5 : `${clean5.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+function parseAssignmentMap(line) {
+  const out = {};
+  const assignmentRe = /(\w+)=([^\s]+)/g;
+  let m2;
+  while ((m2 = assignmentRe.exec(line)) !== null) {
+    out[m2[1].toLowerCase()] = m2[2];
+  }
+  return out;
+}
+function extractFirstMatch(lines, pattern) {
+  for (const line of lines) {
+    const match = line.match(pattern);
+    if (match?.[1]) return match[1].trim();
+  }
+  return "";
+}
+function formatBranchExtractSummary(output) {
+  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) return null;
+  const first2 = lines[0].toLowerCase();
+  const isBranchExtract = first2.startsWith("[branch-extract") || first2.startsWith("[branch-duplicate-blocked]");
+  if (!isBranchExtract) return null;
+  const routingLine = lines.find((line) => line.toLowerCase().startsWith("routing=")) || "";
+  const assignment = parseAssignmentMap(routingLine);
+  const route = assignment.routing ?? "mandatory";
+  const reasons = assignment.reasons?.split(",").map((r2) => r2.trim()).filter(Boolean).join(", ") || "context protection";
+  const projected = assignment.projected_read_tokens || assignment.projectedreadtokens || assignment.projected;
+  const fractionLimit = assignment.fraction_limit_tokens || assignment.fractionlimittokens || assignment.fraction_limit || "";
+  const available = assignment.available_headroom_tokens || assignment.available_headroom;
+  const path16 = extractFirstMatch(
+    lines,
+    /(?:^|\s)path=(\S+)/
+  ) || extractFirstMatch(lines, /\[branch-extract[^\]]*?\]\s*path=([^\s]+)/) || "unknown path";
+  const discoveryStart = lines.findIndex(
+    (line) => /^\[discovery contract\]/i.test(line)
+  );
+  const curatedStart = lines.findIndex(
+    (line) => /^\[curated segments\]/i.test(line)
+  );
+  let goalAnchor = "";
+  let request = "";
+  const required = [];
+  let inRequired = false;
+  let stopCondition = "";
+  if (discoveryStart >= 0) {
+    for (let i2 = discoveryStart + 1; i2 < lines.length; i2 += 1) {
+      const line = lines[i2];
+      if (/^\[curated segments\]/i.test(line)) break;
+      if (/^Goal anchor:/i.test(line)) {
+        goalAnchor = line.replace(/^Goal anchor:\s*/i, "");
+        inRequired = false;
+        continue;
+      }
+      if (/^Request:/i.test(line)) {
+        request = line.replace(/^Request:\s*/i, "");
+        inRequired = false;
+        continue;
+      }
+      if (/^Stop conditions?:/i.test(line)) {
+        stopCondition = line.replace(/^Stop conditions?:\s*/i, "");
+        inRequired = false;
+        continue;
+      }
+      if (/^Required discoveries:/i.test(line)) {
+        inRequired = true;
+        continue;
+      }
+      if (inRequired && line.startsWith("- ")) {
+        required.push(line.replace(/^- /, "").slice(0, 170));
+      }
+    }
+  }
+  let curatedSummary = "";
+  let unresolved = "";
+  let satisfied = "";
+  let provenance = "";
+  if (curatedStart >= 0) {
+    for (let i2 = curatedStart + 1; i2 < lines.length; i2 += 1) {
+      const line = lines[i2];
+      if (/^satisfied=/i.test(line) || /^unresolved=/i.test(line) || /^provenance=/i.test(line)) {
+        if (line.startsWith("satisfied=")) {
+          satisfied = line.replace(/^satisfied=/i, "");
+        } else if (line.startsWith("unresolved=")) {
+          unresolved = line.replace(/^unresolved=/i, "");
+        } else if (line.startsWith("provenance=")) {
+          provenance = line.replace(/^provenance=/i, "");
+        }
+        continue;
+      }
+      if (/^Contract:/i.test(line)) {
+        continue;
+      }
+      if (curatedSummary.length < 240) {
+        curatedSummary = curatedSummary ? `${curatedSummary} ${compactForDisplay(line, 120)}` : compactForDisplay(line, 120);
+      }
+    }
+  }
+  const isDuplicate = /^\[branch-duplicate-blocked\]/i.test(lines[0]);
+  const header = isDuplicate ? "Branch-extract duplicate reuse" : "Branch-extract preempted";
+  const whatHappened = isDuplicate ? "a cache-safe duplicate was detected" : "read was auto-summarized before injecting into context";
+  const out = [
+    `↳ ${header}`,
+    `  ├ what happened: ${whatHappened}`,
+    `  ├ why: ${compactForDisplay(reasons, 140)}`,
+    `  ├ path: ${compactForDisplay(path16, 140)}`,
+    `  ├ decision scope: ${route}`
+  ];
+  if (projected) {
+    const projectedText = fractionLimit ? `${projected} projected → ${fractionLimit} limit` : `${projected} projected`;
+    const availText = available ? `; available headroom ${available}` : "";
+    out.push(`  ├ budget: ${projectedText}${availText}`);
+  }
+  if (goalAnchor) out.push(`  ├ goal anchor: ${compactForDisplay(goalAnchor, 120)}`);
+  if (request) out.push(`  ├ request: ${compactForDisplay(request, 150)}`);
+  if (required.length > 0) {
+    out.push(`  ├ required: ${compactForDisplay(required.slice(0, 3).join(", "), 180)}`);
+  }
+  if (stopCondition) {
+    out.push(`  ├ stop: ${compactForDisplay(stopCondition, 140)}`);
+  }
+  if (curatedSummary) {
+    out.push(`  ├ curated segment: ${compactForDisplay(curatedSummary, 180)}`);
+  }
+  if (satisfied || unresolved) {
+    out.push(
+      `  ├ state: satisfied=${compactForDisplay(satisfied || "none", 90)}; unresolved=${compactForDisplay(unresolved || "none", 90)}`
+    );
+  }
+  if (provenance) {
+    out.push(`  ├ provenance: ${compactForDisplay(provenance, 120)}`);
+  }
+  if (out.length > 1) {
+    const last2 = out.length - 1;
+    out[last2] = out[last2]?.replace(/^  ├ /, "  └ ") ?? out[last2];
+  }
+  return out.length > 0 ? out : null;
+}
+function formatEchoGuardSummary(output) {
+  const lower = output.toLowerCase();
+  const match = output.match(/echo-1:\s*text-only echo\s*#?(\d+)/i);
+  const echoCount = match?.[1] ? `#${match[1]}` : "";
+  const similarityMatch = output.match(/(\d+)% similar/);
+  const similarity3 = similarityMatch?.[1] ? ` (${similarityMatch[1]}% similar to earlier response)` : "";
+  const collapsed = output.match(/collapsed\s+(\d+)\s+duplicate/);
+  const duplicates = collapsed?.[1] ? `${collapsed[1]} duplicate(s) collapsed` : "";
+  return [
+    `↳ ECHO-1 mode-collapse guard${echoCount ? ` ${echoCount}` : ""}${similarity3}`,
+    "  ├ what happened: repeated text-only plan was intercepted",
+    "  ├ why: duplicate plan text was detected from the model loop",
+    `  ├ action: pattern-breaker${duplicates ? ` (${duplicates})` : ""}`,
+    "  └ next action: resume with tool-backed evidence"
+  ];
+}
+function formatSupersededPlanSummary() {
+  return [
+    "↳ Mode-collapse guard",
+    "  ├ what happened: near-duplicate assistant plan was suppressed",
+    "  ├ why: loop prevention to stop re-entering the same plan text",
+    "  └ next action: tool call or concrete evidence request before restating the plan"
+  ];
+}
+function summarizeInternalControlOutput(output) {
+  if (!output) return null;
+  const firstLine = output.split(/\r?\n/)[0]?.trim().toLowerCase() ?? "";
+  const lower = output.toLowerCase();
+  if (firstLine.includes("[branch-extract") || firstLine.includes("[branch-duplicate-blocked]") || lower.includes("branch-extract preempted")) {
+    return formatBranchExtractSummary(output);
+  }
+  if (firstLine.includes("[echo break") || firstLine.includes("[echo-break") || lower.includes("echo-1:")) {
+    return formatEchoGuardSummary(output);
+  }
+  if (lower.includes("[superseded near-duplicate plan removed")) {
+    return formatSupersededPlanSummary();
+  }
+  return null;
+}
+function isRunnerEventLine(line) {
+  const raw = line.trim();
+  if (!raw.startsWith("{") || !raw.endsWith("}")) return false;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed?.type === "string";
+  } catch {
+    return false;
+  }
+}
+function isStatusEchoLine(line) {
+  if (/^i\s+/.test(line)) return true;
+  if (/^E\s+/.test(line)) return true;
+  if (/^⚠\s*(Task incomplete|Task complete)/.test(line)) return true;
+  if (/^▹\s/.test(line)) return true;
+  if (/^User:\s/.test(line)) return true;
+  if (/^Assistant:\s/.test(line)) return true;
+  if (/^Previous conversation:/.test(line)) return true;
+  if (/^omnius \(/.test(line)) return true;
+  return false;
+}
+function stripAnsi2(text2) {
+  return text2.replace(/\x1B\[[0-9;]*[A-Za-z]/g, "").replace(/\x1B\].*?\x07/g, "").replace(/\x1B\[[\?]?[0-9;]*[hl]/g, "");
+}
+function sanitizeAgentOutputForUser(raw) {
+  if (typeof raw !== "string") return "";
+  const cleaned = stripAnsi2(raw);
+  const summary = summarizeInternalControlOutput(cleaned.trim());
+  if (summary) return summary.join("\n");
+  const out = [];
+  const lines = cleaned.split("\n");
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (isRunnerEventLine(line)) continue;
+    const lineSummary = summarizeInternalControlOutput(line);
+    if (lineSummary) {
+      out.push(...lineSummary);
+      continue;
+    }
+    if (isStatusEchoLine(line)) continue;
+    out.push(line);
+  }
+  return out.join("\n").trim();
+}
+var init_internal_output = __esm({
+  "packages/cli/src/utils/internal-output.ts"() {
+  }
+});
+
 // packages/cli/src/tui/render.ts
 var render_exports = {};
 __export(render_exports, {
@@ -634399,186 +635415,6 @@ function sanitizeToolBoxContent(text2) {
   }
   return out;
 }
-function compactForDisplay(text2, max = 170) {
-  const clean5 = text2.replace(/\s+/g, " ").trim();
-  return clean5.length <= max ? clean5 : `${clean5.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
-}
-function parseAssignmentMap(line) {
-  const out = {};
-  const assignmentRe = /(\w+)=([^\s]+)/g;
-  let m2;
-  while ((m2 = assignmentRe.exec(line)) !== null) {
-    out[m2[1].toLowerCase()] = m2[2];
-  }
-  return out;
-}
-function extractFirstMatch(lines, pattern) {
-  for (const line of lines) {
-    const match = line.match(pattern);
-    if (match?.[1]) return match[1].trim();
-  }
-  return "";
-}
-function formatBranchExtractSummary(output) {
-  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  if (lines.length === 0) return null;
-  const first2 = lines[0].toLowerCase();
-  const isBranchExtract = first2.startsWith("[branch-extract") || first2.startsWith("[branch-duplicate-blocked]");
-  if (!isBranchExtract) return null;
-  const routingLine = lines.find((line) => line.toLowerCase().startsWith("routing=")) || "";
-  const assignment = parseAssignmentMap(routingLine);
-  const route = assignment.routing ?? "mandatory";
-  const reasons = assignment.reasons?.split(",").map((r2) => r2.trim()).filter(Boolean).join(", ") || "context protection";
-  const projected = assignment.projected_read_tokens || assignment.projectedreadtokens || assignment.projected;
-  const fractionLimit = assignment.fraction_limit_tokens || assignment.fractionlimittokens || assignment.fraction_limit || "";
-  const available = assignment.available_headroom_tokens || assignment.available_headroom;
-  const path16 = extractFirstMatch(
-    lines,
-    /(?:^|\s)path=(\S+)/
-  ) || extractFirstMatch(lines, /\[branch-extract[^\]]*?\]\s*path=([^\s]+)/) || "unknown path";
-  const discoveryStart = lines.findIndex(
-    (line) => /^\[discovery contract\]/i.test(line)
-  );
-  const curatedStart = lines.findIndex(
-    (line) => /^\[curated segments\]/i.test(line)
-  );
-  let goalAnchor = "";
-  let request = "";
-  const required = [];
-  let inRequired = false;
-  let stopCondition = "";
-  if (discoveryStart >= 0) {
-    for (let i2 = discoveryStart + 1; i2 < lines.length; i2 += 1) {
-      const line = lines[i2];
-      if (/^\[curated segments\]/i.test(line)) break;
-      if (/^Goal anchor:/i.test(line)) {
-        goalAnchor = line.replace(/^Goal anchor:\s*/i, "");
-        continue;
-      }
-      if (/^Request:/i.test(line)) {
-        request = line.replace(/^Request:\s*/i, "");
-        inRequired = false;
-        continue;
-      }
-      if (/^Stop conditions?:/i.test(line)) {
-        stopCondition = line.replace(/^Stop conditions?:\s*/i, "");
-        inRequired = false;
-        continue;
-      }
-      if (/^Required discoveries:/i.test(line)) {
-        inRequired = true;
-        continue;
-      }
-      if (inRequired && line.startsWith("- ")) {
-        required.push(line.replace(/^- /, "").slice(0, 170));
-      }
-    }
-  }
-  let curatedSummary = "";
-  let unresolved = "";
-  let satisfied = "";
-  let provenance = "";
-  if (curatedStart >= 0) {
-    for (let i2 = curatedStart + 1; i2 < lines.length; i2 += 1) {
-      const line = lines[i2];
-      if (/^satisfied=/i.test(line) || /^unresolved=/i.test(line) || /^provenance=/i.test(line)) {
-        if (line.startsWith("satisfied=")) {
-          satisfied = line.replace(/^satisfied=/i, "");
-        } else if (line.startsWith("unresolved=")) {
-          unresolved = line.replace(/^unresolved=/i, "");
-        } else if (line.startsWith("provenance=")) {
-          provenance = line.replace(/^provenance=/i, "");
-        }
-        continue;
-      }
-      if (/^Contract:/i.test(line)) {
-        continue;
-      }
-      if (curatedSummary.length < 240) {
-        curatedSummary = curatedSummary ? `${curatedSummary} ${compactForDisplay(line, 120)}` : compactForDisplay(line, 120);
-      }
-    }
-  }
-  const isDuplicate = /^\[branch-duplicate-blocked\]/i.test(lines[0]);
-  const header = isDuplicate ? "Branch-extract duplicate reuse" : "Branch-extract preempted";
-  const whatHappened = isDuplicate ? "a cache-safe duplicate was detected" : "read was auto-summarized before injecting into context";
-  const out = [
-    `↳ ${header}`,
-    `  ├ what happened: ${whatHappened}`,
-    `  ├ why: ${compactForDisplay(reasons, 140)}`,
-    `  ├ path: ${compactForDisplay(path16, 140)}`,
-    `  ├ decision scope: ${route}`
-  ];
-  if (projected) {
-    const projectedText = fractionLimit ? `${projected} projected → ${fractionLimit} limit` : `${projected} projected`;
-    const availText = available ? `; available headroom ${available}` : "";
-    out.push(`  ├ budget: ${projectedText}${availText}`);
-  }
-  if (goalAnchor) out.push(`  ├ goal anchor: ${compactForDisplay(goalAnchor, 120)}`);
-  if (request) out.push(`  ├ request: ${compactForDisplay(request, 150)}`);
-  if (required.length > 0) {
-    out.push(`  ├ required: ${compactForDisplay(required.slice(0, 3).join(", "), 180)}`);
-  }
-  if (stopCondition) {
-    out.push(`  ├ stop: ${compactForDisplay(stopCondition, 140)}`);
-  }
-  if (curatedSummary) {
-    out.push(`  ├ curated segment: ${compactForDisplay(curatedSummary, 180)}`);
-  }
-  if (satisfied || unresolved) {
-    out.push(
-      `  ├ state: satisfied=${compactForDisplay(satisfied || "none", 90)}; unresolved=${compactForDisplay(unresolved || "none", 90)}`
-    );
-  }
-  if (provenance) {
-    out.push(`  ├ provenance: ${compactForDisplay(provenance, 120)}`);
-  }
-  if (out.length > 1) {
-    const last2 = out.length - 1;
-    out[last2] = out[last2]?.replace(/^  ├ /, "  └ ") ?? out[last2];
-  }
-  return out.length > 0 ? out : null;
-}
-function formatSupersededPlanSummary() {
-  return [
-    "↳ Mode-collapse guard",
-    "  ├ what happened: near-duplicate assistant plan was suppressed",
-    "  ├ why: loop prevention to stop re-entering the same plan text",
-    "  └ next action: tool call or concrete evidence request before restating the plan"
-  ];
-}
-function formatEchoGuardSummary(output) {
-  const lower = output.toLowerCase();
-  const match = output.match(/echo-1:\s*text-only echo\s*#?(\d+)/i);
-  const echoCount = match?.[1] ? `#${match[1]}` : "";
-  const similarityMatch = output.match(/(\d+)% similar/);
-  const similarity3 = similarityMatch?.[1] ? ` (${similarityMatch[1]}% similar to earlier response)` : "";
-  const collapsed = output.match(/collapsed\s+(\d+)\s+duplicate/);
-  const duplicates = collapsed?.[1] ? `${collapsed[1]} duplicate(s) collapsed` : "";
-  const out = [
-    `↳ ECHO-1 mode-collapse guard${echoCount ? ` ${echoCount}` : ""}${similarity3}`,
-    "  ├ what happened: repeated text-only plan was intercepted",
-    "  ├ why: duplicate plan text was detected from the model loop",
-    `  ├ action: pattern-breaker${duplicates ? ` (${duplicates})` : ""}`,
-    "  └ next action: resume with tool-backed evidence"
-  ];
-  return out;
-}
-function summarizeInternalControlOutput(output) {
-  if (!output) return null;
-  const firstLine = output.split(/\r?\n/)[0]?.trim().toLowerCase() ?? "";
-  const lower = output.toLowerCase();
-  if (firstLine.includes("[branch-extract") || firstLine.includes("[branch-duplicate-blocked]") || lower.includes("branch-extract preempted")) {
-    return formatBranchExtractSummary(output);
-  }
-  if (firstLine.includes("[echo break") || firstLine.includes("[echo-break") || lower.includes("echo-1:")) {
-    return formatEchoGuardSummary(output);
-  }
-  if (lower.includes("[superseded near-duplicate plan removed")) {
-    return formatSupersededPlanSummary();
-  }
-  return null;
-}
 function stripTrustTierWrapperForTui(text2, maxWrapperChars = 400) {
   const trustWrapper = new RegExp(
     `^\\[trust_tier:[^\\]\\n]{0,${Math.max(0, maxWrapperChars)}}\\][ \\t]*(?:\\n)?`,
@@ -635832,6 +636668,7 @@ var init_render = __esm({
     init_model_picker();
     init_secret_redactor();
     init_tool_collapse_store();
+    init_internal_output();
     c3 = {
       bold: (t2) => ansi2("1", t2),
       dim: (t2) => stdoutIsTTY() ? `${dimFg()}${t2}\x1B[0m` : t2,
@@ -645111,11 +645948,11 @@ function truncate4(s2, max) {
   if (s2.length <= max) return s2.padEnd(max, " ");
   return s2.slice(0, Math.max(0, max - 1)) + "…";
 }
-function stripAnsi2(s2) {
+function stripAnsi3(s2) {
   return s2.replace(/\x1B\[[0-9;]*[A-Za-z]/g, "").replace(/\x1B\][^\x07]*\x07/g, "").replace(/\x1B[()][A-Z0-9]/g, "").replace(/\x1B\[?\??[0-9;]*[a-zA-Z]/g, "").replace(/\x1B/g, "");
 }
 function visualLen(s2) {
-  return stripAnsi2(s2).length;
+  return stripAnsi3(s2).length;
 }
 function buildTodoProgressBar(todos, maxWidth) {
   if (maxWidth <= 0 || todos.length === 0) return "";
@@ -647853,6 +648690,7 @@ var init_status_bar = __esm({
         lastCompletionTokens: 0,
         contextWindowSize: 0
       };
+      _contextCapacity = { status: "unknown" };
       // ── Metrics tracking for Telegram stats ──
       _backend = "ollama";
       _inferenceCount = 0;
@@ -649097,7 +649935,17 @@ var init_status_bar = __esm({
       }
       /** Context window size to display. Can be updated if model changes. */
       setContextWindowSize(size) {
-        this.metrics.contextWindowSize = size;
+        this.setContextCapacity(
+          Number.isFinite(size) && size > 0 ? { status: "known", totalTokens: Math.floor(size), source: "runtime" } : { status: "unknown", source: "unavailable" }
+        );
+      }
+      /** Update capacity provenance without turning missing server metadata into zero percent. */
+      setContextCapacity(state) {
+        const totalTokens = state.status === "known" && (state.totalTokens ?? 0) > 0 ? Math.floor(state.totalTokens) : 0;
+        this._contextCapacity = totalTokens > 0 ? { ...state, status: "known", totalTokens } : { ...state, status: "unknown", totalTokens: void 0 };
+        this.metrics.contextWindowSize = totalTokens;
+        this.pushSpinnerContextMetrics();
+        if (this.active) this.renderFooterPreserveCursor();
       }
       /** Set the current package version for display in the metrics row */
       setVersion(version5) {
@@ -649578,6 +650426,8 @@ var init_status_bar = __esm({
           this.metrics.totalTokens = update2.totalTokens;
         if (update2.estimatedContextTokens !== void 0)
           this.metrics.estimatedContextTokens = update2.estimatedContextTokens;
+        if (update2.contextOutputReservationTokens !== void 0)
+          this.metrics.contextOutputReservationTokens = update2.contextOutputReservationTokens;
         if (update2.lastPromptTokens !== void 0)
           this.metrics.lastPromptTokens = update2.lastPromptTokens;
         if (update2.lastCompletionTokens !== void 0)
@@ -651717,7 +652567,7 @@ ${CONTENT_BG_SEQ}`);
           this.effectiveContextTotal(m2.contextWindowSize)
         );
         let ctxStr = "";
-        if (ctxTotal > 0) {
+        if (this._contextCapacity.status === "known" && ctxTotal > 0) {
           const pct2 = Math.max(
             0,
             Math.min(100, Math.round((1 - ctxUsed / ctxTotal) * 100))
@@ -651729,6 +652579,10 @@ ${CONTENT_BG_SEQ}`);
           const bar = `\x1B[38;5;${barColor}m${"█".repeat(filled)}\x1B[0m\x1B[38;5;240m${"░".repeat(empty2)}\x1B[0m`;
           const pctColor = pct2 > 50 ? 120 : pct2 > 20 ? 222 : 210;
           ctxStr = `${bar} \x1B[38;5;${pctColor}m${pct2}%\x1B[0m`;
+        } else {
+          const usage = ctxUsed >= 1024 ? `${(ctxUsed / 1024).toFixed(ctxUsed >= 1e4 ? 0 : 1)}K` : String(Math.max(0, Math.round(ctxUsed)));
+          const reservation = m2.contextOutputReservationTokens && m2.contextOutputReservationTokens > 0 ? ` +${m2.contextOutputReservationTokens >= 1024 ? `${Math.round(m2.contextOutputReservationTokens / 1024)}K` : m2.contextOutputReservationTokens} rsv` : "";
+          ctxStr = `\x1B[38;5;245mCTX ? | ~${usage}${reservation}\x1B[0m`;
         }
         const arrow = `\x1B[38;5;240m▶\x1B[0m`;
         let rightSide;
@@ -653031,7 +653885,7 @@ function ansi3(code8, text2) {
 function fg2563(code8, text2) {
   return isTTY3 ? `\x1B[38;5;${code8}m${text2}\x1B[0m` : text2;
 }
-function stripAnsi3(s2) {
+function stripAnsi4(s2) {
   return s2.replace(/\x1B\[[0-9;]*m/g, "");
 }
 function stripTerminalControl(s2) {
@@ -653047,15 +653901,15 @@ function renderNonInteractiveSelect(opts, currentTitle, skipSet) {
   const surface = nonInteractiveSelectSurface.getStore();
   const maxItems = Math.max(1, surface?.maxItems ?? 30);
   const lines = [];
-  if (currentTitle) lines.push(stripTerminalControl(stripAnsi3(currentTitle)));
+  if (currentTitle) lines.push(stripTerminalControl(stripAnsi4(currentTitle)));
   if (lines.length) lines.push("");
   let idx = 1;
   let shown = 0;
   let omitted = 0;
   for (const item of opts.items) {
     const isSkip = skipSet.has(item.key);
-    const labelPlain = stripTerminalControl(stripAnsi3(item.label)).trim();
-    const detailPlain = item.detail ? stripTerminalControl(stripAnsi3(item.detail)).trim() : "";
+    const labelPlain = stripTerminalControl(stripAnsi4(item.label)).trim();
+    const detailPlain = item.detail ? stripTerminalControl(stripAnsi4(item.detail)).trim() : "";
     if (isSkip) {
       if (labelPlain) lines.push(labelPlain);
       continue;
@@ -653072,7 +653926,7 @@ function renderNonInteractiveSelect(opts, currentTitle, skipSet) {
     idx++;
   }
   if (omitted > 0) lines.push(`  ... ${omitted} more`);
-  if (opts.customKeyHint) lines.push("", stripTerminalControl(stripAnsi3(opts.customKeyHint)));
+  if (opts.customKeyHint) lines.push("", stripTerminalControl(stripAnsi4(opts.customKeyHint)));
   lines.push("", surface?.hint ?? "(non-interactive: menu shown as text; open the TUI for selection)");
   process.stdout.write(lines.join("\n").trimEnd() + "\n");
 }
@@ -653087,8 +653941,8 @@ function matchRow(item, focused, isActive) {
     return defaultRenderRow(item, focused, isActive);
   }
   const marker = selectColors.matchLight("○");
-  const label = selectColors.matchLight(stripAnsi3(item.label));
-  const detail = item.detail ? `  ${selectColors.dim(stripAnsi3(item.detail))}` : "";
+  const label = selectColors.matchLight(stripAnsi4(item.label));
+  const detail = item.detail ? `  ${selectColors.dim(stripAnsi4(item.detail))}` : "";
   return `  ${marker} ${label}${detail}`;
 }
 function tuiSelect(opts) {
@@ -653117,8 +653971,8 @@ function tuiSelect(opts) {
       matchSet = /* @__PURE__ */ new Set();
       for (let i2 = 0; i2 < items.length; i2++) {
         if (isSkippable(i2)) continue;
-        const plain = stripAnsi3(items[i2].label).toLowerCase();
-        const detailPlain = items[i2].detail ? stripAnsi3(items[i2].detail).toLowerCase() : "";
+        const plain = stripAnsi4(items[i2].label).toLowerCase();
+        const detailPlain = items[i2].detail ? stripAnsi4(items[i2].detail).toLowerCase() : "";
         if (plain.includes(lower) || detailPlain.includes(lower)) {
           matchSet.add(i2);
         }
@@ -653243,7 +654097,7 @@ function tuiSelect(opts) {
         if (deleteConfirmIdx === idx) {
           const yesLabel = deleteConfirmSel ? selectColors.bold(selectColors.green("[Yes]")) : selectColors.dim("[Yes]");
           const noLabel = !deleteConfirmSel ? selectColors.bold(selectColors.blue("[No]")) : selectColors.dim("[No]");
-          lines.push(`  ${ansi3("31", "✕")} ${ansi3("31", stripAnsi3(item.label))}  Delete?  ${yesLabel}  ${noLabel}`);
+          lines.push(`  ${ansi3("31", "✕")} ${ansi3("31", stripAnsi4(item.label))}  Delete?  ${yesLabel}  ${noLabel}`);
         } else if (filter2) {
           lines.push(matchRow(item, focused, isActive));
         } else {
@@ -659229,11 +660083,11 @@ import { extname as extname18, resolve as resolve66 } from "node:path";
 function ansi4(code8, text2) {
   return isTTY4 ? `\x1B[${code8}m${text2}\x1B[0m` : text2;
 }
-function stripAnsi4(s2) {
+function stripAnsi5(s2) {
   return s2.replace(/\x1B\[[0-9;]*m/g, "");
 }
 function fitToWidth(text2, width) {
-  const visible = stripAnsi4(text2);
+  const visible = stripAnsi5(text2);
   if (visible.length >= width) {
     let visCount = 0;
     let i2 = 0;
@@ -670459,12 +671313,12 @@ async function ensureVoiceDeps(ctx3) {
       }
     }
     if (typeof mod3.getVenvPython === "function") {
-      const { dirname: dirname58 } = await import("node:path");
+      const { dirname: dirname59 } = await import("node:path");
       const { existsSync: existsSync177 } = await import("node:fs");
       const venvPy = mod3.getVenvPython();
       if (existsSync177(venvPy)) {
         process.env.TRANSCRIBE_PYTHON = venvPy;
-        const venvBin = dirname58(venvPy);
+        const venvBin = dirname59(venvPy);
         const sep8 = process.platform === "win32" ? ";" : ":";
         const cur = process.env.PATH || "";
         if (!cur.split(sep8).includes(venvBin)) {
@@ -673925,10 +674779,6 @@ Clone a new voice: /voice clone <wav-file> [name]`);
           renderWarning(
             "OMNIUS_FORCE_NO_THINK=1 forces off regardless of /think setting"
           );
-        else if (cur && process.env["OMNIUS_ENABLE_THINKING"] !== "1")
-          renderWarning(
-            "OMNIUS_ENABLE_THINKING is not set; /think is saved but backend requests remain direct-answer mode."
-          );
         return "handled";
       }
       if (token === "auto") {
@@ -673967,11 +674817,6 @@ Clone a new voice: /voice clone <wav-file> [name]`);
         renderInfo(
           "Note: max_tokens will auto-raise to ≥4096 per request to prevent <think> truncation."
         );
-        if (process.env["OMNIUS_ENABLE_THINKING"] !== "1") {
-          renderWarning(
-            "Thinking is hard-disabled by default. Set OMNIUS_ENABLE_THINKING=1 before launch for /think on or /think auto to affect backend requests."
-          );
-        }
       }
       return "handled";
     }
@@ -683873,14 +684718,14 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
     if (models.length > 0) {
       try {
         const { writeFileSync: writeFileSync97, mkdirSync: mkdirSync114 } = await import("node:fs");
-        const { join: join190, dirname: dirname58 } = await import("node:path");
+        const { join: join190, dirname: dirname59 } = await import("node:path");
         const cachePath2 = join190(
           ctx3.repoRoot || process.cwd(),
           ".omnius",
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync114(dirname58(cachePath2), { recursive: true });
+        mkdirSync114(dirname59(cachePath2), { recursive: true });
         writeFileSync97(
           cachePath2,
           JSON.stringify(
@@ -683956,14 +684801,14 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
       );
       try {
         const { writeFileSync: writeFileSync97, mkdirSync: mkdirSync114 } = await import("node:fs");
-        const { join: join190, dirname: dirname58 } = await import("node:path");
+        const { join: join190, dirname: dirname59 } = await import("node:path");
         const cachePath2 = join190(
           ctx3.repoRoot || process.cwd(),
           ".omnius",
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync114(dirname58(cachePath2), { recursive: true });
+        mkdirSync114(dirname59(cachePath2), { recursive: true });
         writeFileSync97(
           cachePath2,
           JSON.stringify(
@@ -684979,10 +685824,10 @@ async function handleUpdate(subcommand, ctx3) {
   try {
     const { createRequire: createRequire11 } = await import("node:module");
     const { fileURLToPath: fileURLToPath26 } = await import("node:url");
-    const { dirname: dirname58, join: join190 } = await import("node:path");
+    const { dirname: dirname59, join: join190 } = await import("node:path");
     const { existsSync: existsSync177 } = await import("node:fs");
     const req3 = createRequire11(import.meta.url);
-    const thisDir = dirname58(fileURLToPath26(import.meta.url));
+    const thisDir = dirname59(fileURLToPath26(import.meta.url));
     const candidates = [
       join190(thisDir, "..", "package.json"),
       join190(thisDir, "..", "..", "package.json"),
@@ -687168,11 +688013,11 @@ function normalizeRoot(root) {
     return root;
   }
 }
-function stripAnsi5(text2) {
+function stripAnsi6(text2) {
   return String(text2 || "").replace(/\u001b\[[0-9;]*[a-zA-Z]/g, "");
 }
 function cleanSessionDisplayLine(line) {
-  return stripAnsi5(line).replace(/^[>❯▹∙•*+\-\s]+/, "").replace(/^(?:User|Assistant|You|Open Agent|Omnius)\s*:\s*/i, "").replace(/\s+/g, " ").trim();
+  return stripAnsi6(line).replace(/^[>❯▹∙•*+\-\s]+/, "").replace(/^(?:User|Assistant|You|Open Agent|Omnius)\s*:\s*/i, "").replace(/\s+/g, " ").trim();
 }
 function isNoisySessionDisplayLine(line) {
   const clean5 = cleanSessionDisplayLine(line || "");
@@ -687180,12 +688025,12 @@ function isNoisySessionDisplayLine(line) {
   return /^(?:Previous session found|REST API:|Nexus P2P network connected|No context to restore|Starting fresh|Use \/endpoint|Knowledge graph:|Zettelkasten:|Episodes captured:|Current OMNIUS_HOST:|Loaded TUI session|General session$|Chat tui:sess|\[Imported TUI session transcript\]|Title:|Description:|Project root:|i\s+)/i.test(clean5);
 }
 function bestSessionDisplayLine(text2) {
-  const lines = stripAnsi5(text2).split(/\r?\n/);
+  const lines = stripAnsi6(text2).split(/\r?\n/);
   for (const line of lines) {
     const clean5 = cleanSessionDisplayLine(line);
     if (!isNoisySessionDisplayLine(clean5)) return clean5;
   }
-  const fallback = stripAnsi5(text2).replace(/\s+/g, " ").trim();
+  const fallback = stripAnsi6(text2).replace(/\s+/g, " ").trim();
   return isNoisySessionDisplayLine(fallback) ? "" : fallback;
 }
 function makeTitle(text2) {
@@ -687386,7 +688231,7 @@ function getSession2(sessionId, model, cwd4) {
 function importTranscriptSession(opts) {
   const projectRoot = normalizeRoot(opts.projectRoot) ?? process.cwd();
   const id2 = opts.id;
-  const transcript = opts.transcriptLines.map(stripAnsi5).join("\n").trim();
+  const transcript = opts.transcriptLines.map(stripAnsi6).join("\n").trim();
   const metadataSource = [opts.title, opts.description, transcript].filter(Boolean).join("\n");
   const title = makeTitle(metadataSource || id2);
   const preview = makePreview([opts.description, transcript].filter(Boolean).join("\n") || title);
@@ -700641,6 +701486,7 @@ import {
 } from "node:fs";
 import {
   join as join170,
+  dirname as dirname53,
   resolve as resolve73,
   basename as basename42,
   relative as relative21,
@@ -700648,7 +701494,11 @@ import {
   extname as extname21
 } from "node:path";
 import { homedir as homedir56 } from "node:os";
-import { writeFile as writeFileAsync } from "node:fs/promises";
+import {
+  appendFile as appendFileAsync,
+  mkdir as mkdirAsync,
+  writeFile as writeFileAsync
+} from "node:fs/promises";
 import { createHash as createHash49, randomBytes as randomBytes28, randomInt } from "node:crypto";
 function formatModelBytes(bytes) {
   if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
@@ -703681,6 +704531,12 @@ Telegram link integrity contract:
       subAgents = /* @__PURE__ */ new Map();
       /** Debounced live-context packets for messages arriving during a runner. */
       telegramSubAgentContextBuffers = /* @__PURE__ */ new Map();
+      /** Append-only, durable ingress ledger for every agent-routed Telegram task input. */
+      telegramIntakeRecords = /* @__PURE__ */ new Map();
+      telegramIntakeMessages = /* @__PURE__ */ new Map();
+      telegramIntakeWriteTail = Promise.resolve();
+      /** Intent epochs isolate redirected/replaced work inside a long-lived chat session. */
+      telegramTaskEpochs = /* @__PURE__ */ new Map();
       /** Active direct chat completions, counted with Telegram activity in the TUI */
       activeChatViews = /* @__PURE__ */ new Set();
       /** Active direct chat completions by Telegram session key for admission. */
@@ -704582,7 +705438,7 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
         }
         this.refreshActiveTelegramInteractionCount();
       }
-      buildTelegramQueuedSessionWork(sessionKey, msg, toolContext, now2) {
+      buildTelegramQueuedSessionWork(sessionKey, msg, toolContext, now2, intakeRecord) {
         const existing = this.telegramQueuedSessionWork.get(sessionKey);
         const messages2 = [...existing?.messages ?? [], msg].slice(
           -TELEGRAM_SUB_AGENT_BURST_CONTEXT_LIMIT
@@ -704591,6 +705447,7 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           sessionKey,
           msg,
           messages: messages2,
+          intakeRecords: [...existing?.intakeRecords ?? [], intakeRecord],
           toolContext,
           enqueuedAtMs: existing?.enqueuedAtMs ?? now2,
           lastSpokenAtMs: now2,
@@ -704616,14 +705473,15 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
       shouldAwaitTelegramQueuedWorkForTests() {
         return process.env["OMNIUS_TG_AWAIT_QUEUED_WORK"] === "1" || process.env["VITEST"] === "true";
       }
-      scheduleTelegramSessionWork(msg, toolContext) {
+      scheduleTelegramSessionWork(msg, toolContext, intakeRecord) {
         const sessionKey = this.sessionKeyForMessage(msg);
         const now2 = Date.now();
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
           return this.enqueueTelegramMessageForExistingSubAgent(
             msg,
-            existing
+            existing,
+            intakeRecord
           ).catch((err) => {
             this.tuiWrite(
               () => renderWarning(
@@ -704637,9 +705495,15 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           sessionKey,
           msg,
           toolContext,
-          now2
+          now2,
+          intakeRecord
         );
         this.telegramQueuedSessionWork.set(sessionKey, queued);
+        void this.transitionTelegramIntake(
+          intakeRecord,
+          "deferred",
+          "queued behind Telegram session admission"
+        );
         this.refreshActiveTelegramInteractionCount();
         this.dispatchQueuedTelegramSessionWorkSoon(
           Math.max(0, queued.dispatchAfterMs - now2)
@@ -704850,14 +705714,14 @@ ${message2}`)
             `live context injected (${buffer2.messages.length} message${buffer2.messages.length === 1 ? "" : "s"})`
           );
         } else {
-          subAgent.pendingMessages.push(packet);
+          subAgent.pendingContextPackets.push(packet);
           this.subAgentViewCallbacks?.onWrite(
             subAgent.viewId,
             `live context staged (${buffer2.messages.length} message${buffer2.messages.length === 1 ? "" : "s"})`
           );
         }
       }
-      async enqueueTelegramMessageForExistingSubAgent(msg, subAgent) {
+      async enqueueTelegramMessageForExistingSubAgent(msg, subAgent, intakeRecord) {
         const sessionKey = this.sessionKeyForMessage(msg);
         let mediaContext = "";
         if (msg.media || msg.replyToMedia) {
@@ -704876,11 +705740,16 @@ ${message2}`)
         } else {
           this.recordTelegramUserMessage(msg, "steering");
         }
-        this.enqueueTelegramSubAgentContext(
-          sessionKey,
+        this.injectTelegramSteeringInput(
           subAgent,
-          context2,
-          msg.username
+          intakeRecord,
+          context2
+        );
+        void this.transitionTelegramIntake(
+          intakeRecord,
+          "accepted",
+          "accepted by active Telegram runner",
+          { runId: subAgent.runId }
         );
         this.tuiWrite(
           () => renderTelegramSubAgentEvent(
@@ -704892,8 +705761,259 @@ ${message2}`)
       async enqueueTelegramQueuedSessionWorkForExistingSubAgent(work, subAgent) {
         const messages2 = work.messages.length > 0 ? work.messages : [work.msg];
         for (const msg of messages2) {
-          await this.enqueueTelegramMessageForExistingSubAgent(msg, subAgent);
+          const intakeRecord = work.intakeRecords.find(
+            (record) => record.inputId === this.telegramInputIdForMessage(msg)
+          );
+          if (!intakeRecord) continue;
+          await this.enqueueTelegramMessageForExistingSubAgent(
+            msg,
+            subAgent,
+            intakeRecord
+          );
+        }
+      }
+      telegramInputIdForMessage(msg) {
+        const thread = msg.messageThreadId ?? 0;
+        return `telegram:${this.sessionKeyForMessage(msg)}:${thread}:${msg.messageId ?? "unknown"}`;
+      }
+      telegramTaskEpoch(sessionKey) {
+        const current = this.telegramTaskEpochs.get(sessionKey);
+        if (current !== void 0) return current;
+        this.telegramTaskEpochs.set(sessionKey, 1);
+        return 1;
+      }
+      advanceTelegramTaskEpoch(sessionKey) {
+        const next = this.telegramTaskEpoch(sessionKey) + 1;
+        this.telegramTaskEpochs.set(sessionKey, next);
+        return next;
+      }
+      triageTelegramSteeringInput(msg) {
+        const text2 = msg.text.trim();
+        const lower = text2.toLowerCase();
+        if (/^\/(?:stop|cancel|abort|halt)\b/.test(lower)) {
+          return { intent: "cancel", reason: "explicit stop/cancel command" };
+        }
+        if (/^\/(?:redirect|reroute|pivot)\b/.test(lower)) {
+          return { intent: "redirect", reason: "explicit redirect command" };
+        }
+        if (/^\/(?:replace|new[_-]?task)\b/.test(lower) || /^(?:new task|replace (?:the )?(?:current )?task|forget (?:that|the current task)|instead[,!:]?)/.test(
+          lower
+        )) {
+          return { intent: "replace", reason: "explicit replacement/new-task request" };
         }
+        if (/^\/(?:append|add|also)\b/.test(lower) || /^(?:also|add|include|one more thing)\b/.test(lower)) {
+          return { intent: "append", reason: "explicit additive instruction" };
+        }
+        if (/\?$/.test(text2) || /^(?:clarify|correction|to be clear)\b/.test(lower)) {
+          return { intent: "clarify", reason: "plain-text clarification; scope preserved" };
+        }
+        return { intent: "append", reason: "conservative plain-text intake; momentum preserved" };
+      }
+      telegramIntakePath(sessionKey) {
+        const digest3 = createHash49("sha256").update(sessionKey).digest("hex").slice(0, 20);
+        return join170(
+          this.repoRoot ?? process.cwd(),
+          ".omnius",
+          "telegram-intake",
+          `${digest3}.jsonl`
+        );
+      }
+      appendTelegramIntakeJournal(sessionKey, entry) {
+        const write2 = async () => {
+          const path16 = this.telegramIntakePath(sessionKey);
+          await mkdirAsync(dirname53(path16), { recursive: true });
+          await appendFileAsync(path16, `${JSON.stringify(entry)}
+`, "utf8");
+        };
+        this.telegramIntakeWriteTail = this.telegramIntakeWriteTail.catch(() => {
+        }).then(write2);
+        return this.telegramIntakeWriteTail;
+      }
+      async registerTelegramIntake(msg, triage) {
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const inputId = this.telegramInputIdForMessage(msg);
+        const existing = this.telegramIntakeRecords.get(inputId);
+        if (existing) return existing;
+        const now2 = (/* @__PURE__ */ new Date()).toISOString();
+        const record = {
+          inputId,
+          source: "telegram",
+          receivedAt: now2,
+          lifecycle: "received",
+          lifecycleAt: now2,
+          lifecycleReason: "Telegram update accepted before task routing",
+          intent: triage.intent,
+          classificationReason: triage.reason,
+          sessionKey,
+          chatId: String(msg.chatId),
+          messageId: msg.messageId,
+          messageThreadId: msg.messageThreadId,
+          rawText: msg.text,
+          taskEpoch: this.telegramTaskEpoch(sessionKey)
+        };
+        this.telegramIntakeRecords.set(inputId, record);
+        this.telegramIntakeMessages.set(inputId, msg);
+        await this.appendTelegramIntakeJournal(sessionKey, {
+          kind: "intake_received",
+          record
+        });
+        await this.transitionTelegramIntake(record, "classified", triage.reason);
+        return record;
+      }
+      async transitionTelegramIntake(record, lifecycle, reason, links2 = {}) {
+        const at = (/* @__PURE__ */ new Date()).toISOString();
+        Object.assign(record, links2, {
+          lifecycle,
+          lifecycleAt: at,
+          lifecycleReason: reason
+        });
+        await this.appendTelegramIntakeJournal(record.sessionKey, {
+          kind: "intake_lifecycle",
+          inputId: record.inputId,
+          lifecycle,
+          at,
+          reason,
+          taskEpoch: record.taskEpoch,
+          runId: record.runId,
+          runnerTurn: record.runnerTurn
+        });
+      }
+      formatTelegramSteeringCompatibilityMessage(input) {
+        return [
+          "[TELEGRAM_STEERING_INTAKE]",
+          `input_id: ${input.intake.inputId}`,
+          `intent: ${input.intake.intent}`,
+          `task_epoch: ${input.intake.taskEpoch}`,
+          "This is a direct user intake. Reconcile it before the next action; do not treat it as passive transcript context.",
+          input.content,
+          "[/TELEGRAM_STEERING_INTAKE]"
+        ].join("\n");
+      }
+      injectTelegramSteeringInput(subAgent, intake, content) {
+        const pending2 = { intake, content };
+        if (!subAgent.runner) {
+          subAgent.pendingIntakeRecords.push(pending2);
+          return;
+        }
+        const runner = subAgent.runner;
+        if (typeof runner.injectSteeringInput === "function") {
+          runner.injectSteeringInput({
+            inputId: intake.inputId,
+            content,
+            source: "telegram",
+            receivedAt: intake.receivedAt,
+            intent: intake.intent,
+            taskEpoch: intake.taskEpoch
+          });
+          return;
+        }
+        runner.injectUserMessage(this.formatTelegramSteeringCompatibilityMessage(pending2));
+      }
+      async preemptTelegramSubAgentForIntake(msg, subAgent, toolContext, intake) {
+        const sessionKey = intake.sessionKey;
+        await this.transitionTelegramIntake(
+          intake,
+          "acknowledged",
+          "trusted Telegram steering receipt sent",
+          { runId: subAgent.runId }
+        );
+        const receipt = intake.intent === "cancel" ? "Cancellation received. I am stopping the current task." : "Redirection received. I am stopping the current step and replanning from your latest instruction.";
+        await this.replyToTelegramMessage(msg, receipt).catch(() => null);
+        await this.transitionTelegramIntake(
+          intake,
+          "preempt_requested",
+          "trusted admin-DM steering preemption requested",
+          { runId: subAgent.runId }
+        );
+        subAgent.preempted = true;
+        if (intake.intent !== "cancel") {
+          const epoch = this.advanceTelegramTaskEpoch(sessionKey);
+          const displaced = this.telegramQueuedSessionWork.get(sessionKey);
+          if (displaced) {
+            this.telegramQueuedSessionWork.delete(sessionKey);
+            await Promise.all(
+              displaced.intakeRecords.map(
+                (record) => this.transitionTelegramIntake(
+                  record,
+                  "superseded",
+                  `superseded by trusted ${intake.intent} intake ${intake.inputId}`
+                )
+              )
+            );
+          }
+          intake.taskEpoch = epoch;
+          const queued = this.buildTelegramQueuedSessionWork(
+            sessionKey,
+            msg,
+            toolContext,
+            Date.now(),
+            intake
+          );
+          this.telegramQueuedSessionWork.set(sessionKey, queued);
+          await this.transitionTelegramIntake(
+            intake,
+            "deferred",
+            "waiting for superseded runner cleanup before dispatch",
+            { taskEpoch: epoch }
+          );
+        }
+        const runner = subAgent.runner;
+        if (typeof runner?.requestSteeringPreemption === "function") {
+          runner.requestSteeringPreemption(intake.inputId);
+        } else {
+          runner?.abort?.();
+        }
+        await this.transitionTelegramIntake(
+          intake,
+          "preempted",
+          "active runner interrupted for trusted steering intake",
+          { runId: subAgent.runId }
+        );
+        this.dispatchQueuedTelegramSessionWorkSoon();
+      }
+      async requeuePendingTelegramIntakeOnFinalization(subAgent) {
+        const pending2 = subAgent.pendingIntakeRecords.splice(0);
+        if (pending2.length === 0) return;
+        for (const item of pending2) {
+          const msg = this.telegramIntakeMessages.get(item.intake.inputId);
+          if (!msg || subAgent.preempted) {
+            await this.transitionTelegramIntake(
+              item.intake,
+              subAgent.preempted ? "superseded" : "failed",
+              subAgent.preempted ? "runner was superseded before pending intake dispatch" : "original Telegram message unavailable for pending intake requeue"
+            );
+            continue;
+          }
+          const work = this.buildTelegramQueuedSessionWork(
+            item.intake.sessionKey,
+            msg,
+            subAgent.toolContext,
+            Date.now(),
+            item.intake
+          );
+          this.telegramQueuedSessionWork.set(item.intake.sessionKey, work);
+          await this.transitionTelegramIntake(
+            item.intake,
+            "deferred",
+            "runner finalized before pending intake dispatch; requeued atomically"
+          );
+        }
+        this.dispatchQueuedTelegramSessionWorkSoon();
+      }
+      forwardTelegramRunnerIntakeLifecycle(event) {
+        const typed = event;
+        const inputId = typed.inputId ?? typed.steeringInputId;
+        if (!inputId) return;
+        const record = this.telegramIntakeRecords.get(inputId);
+        if (!record) return;
+        const lifecycle = typed.type === "steering_preempt_requested" ? "preempt_requested" : typed.type === "steering_preempted" ? "preempted" : typed.type === "steering_input_consumed" || typed.type === "steering_consumed" ? "consumed" : typed.type === "steering_input_accepted" || typed.type === "steering_received" ? "accepted" : null;
+        if (!lifecycle) return;
+        void this.transitionTelegramIntake(
+          record,
+          lifecycle,
+          `runner lifecycle event: ${typed.type}`,
+          typeof typed.turn === "number" ? { runnerTurn: typed.turn } : {}
+        );
       }
       async replyWithTelegramHelp(msg, isAdmin) {
         const scope = isAdmin ? "admin" : "public";
@@ -712597,12 +713717,32 @@ Join: ${newUrl}`
             return;
           }
         }
+        const intakeTriage = this.triageTelegramSteeringInput(msg);
+        const intakeRecord = await this.registerTelegramIntake(msg, intakeTriage);
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
-          await this.enqueueTelegramMessageForExistingSubAgent(msg, existing);
+          const trustedPreemption = isAdminDM && (intakeRecord.intent === "cancel" || intakeRecord.intent === "redirect" || intakeRecord.intent === "replace");
+          if (trustedPreemption) {
+            await this.preemptTelegramSubAgentForIntake(
+              msg,
+              existing,
+              toolContext,
+              intakeRecord
+            );
+            return;
+          }
+          await this.enqueueTelegramMessageForExistingSubAgent(
+            msg,
+            existing,
+            intakeRecord
+          );
           return;
         }
-        const queuedWork = this.scheduleTelegramSessionWork(msg, toolContext);
+        const queuedWork = this.scheduleTelegramSessionWork(
+          msg,
+          toolContext,
+          intakeRecord
+        );
         if (this.shouldAwaitTelegramQueuedWorkForTests()) await queuedWork;
       }
       async processTelegramMessageWork(work, workGeneration) {
@@ -712612,6 +713752,15 @@ Join: ${newUrl}`
         const isAdminDM = toolContext === "telegram-admin-dm";
         if (!this.telegramWorkGenerationIsCurrent(sessionKey, workGeneration))
           return;
+        await Promise.all(
+          work.intakeRecords.map(
+            (record) => this.transitionTelegramIntake(
+              record,
+              "dispatched",
+              "Telegram session work dispatched to runner admission"
+            )
+          )
+        );
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
           await this.enqueueTelegramQueuedSessionWorkForExistingSubAgent(
@@ -712690,6 +713839,15 @@ Join: ${newUrl}`
             msg,
             `live inference: no reply — ${decision2.reason}`
           );
+          await Promise.all(
+            work.intakeRecords.map(
+              (intake) => this.transitionTelegramIntake(
+                intake,
+                "consumed",
+                "Telegram attention router retained intake without visible reply"
+              )
+            )
+          );
           return;
         }
         const decisionContext = this.formatTelegramAttentionDecisionContext(deliveredDecision);
@@ -712734,6 +713892,15 @@ Join: ${newUrl}`
               daydreamOpportunities
             );
           }
+          await Promise.all(
+            work.intakeRecords.map(
+              (intake) => this.transitionTelegramIntake(
+                intake,
+                "consumed",
+                "Telegram quick-chat path completed"
+              )
+            )
+          );
           return;
         }
         const subAgent = {
@@ -712757,7 +713924,10 @@ Join: ${newUrl}`
           lastEditMs: 0,
           aborted: false,
           toolContext,
-          pendingMessages: [],
+          pendingIntakeRecords: [],
+          pendingContextPackets: [],
+          runId: `telegram:${randomBytes28(8).toString("hex")}`,
+          taskEpoch: work.intakeRecords[work.intakeRecords.length - 1]?.taskEpoch ?? this.telegramTaskEpoch(sessionKey),
           creativeWorkspaceRoot: this.creativeWorkspaceRootForMessage(
             msg,
             toolContext
@@ -712768,6 +713938,14 @@ Join: ${newUrl}`
           surfacedToolCallFingerprints: /* @__PURE__ */ new Set()
         };
         this.subAgents.set(sessionKey, subAgent);
+        for (const intake of work.intakeRecords) {
+          void this.transitionTelegramIntake(
+            intake,
+            "accepted",
+            "admitted as the primary Telegram task prompt",
+            { runId: subAgent.runId }
+          );
+        }
         this.refreshActiveTelegramInteractionCount();
         this.subAgentViewCallbacks?.onRegister(
           subAgent.viewId,
@@ -712818,6 +713996,20 @@ Join: ${newUrl}`
             mediaContext,
             subAgentProfile,
             [decisionContext, rapidContext].filter(Boolean).join("\n\n")
+          ).catch((err) => {
+            if (subAgent.preempted) return "";
+            throw err;
+          });
+          if (subAgent.preempted) return;
+          await Promise.all(
+            work.intakeRecords.map(
+              (intake) => this.transitionTelegramIntake(
+                intake,
+                "consumed",
+                "primary Telegram task completed its runner lifecycle",
+                { runId: subAgent.runId }
+              )
+            )
           );
           if (subAgent.typingInterval) {
             clearInterval(subAgent.typingInterval);
@@ -713009,6 +714201,7 @@ Join: ${newUrl}`
           }
         } finally {
           this.stopTelegramPublicProgressMessage(subAgent);
+          await this.requeuePendingTelegramIntakeOnFinalization(subAgent);
           this.clearTelegramSubAgentContextBuffer(sessionKey);
           this.subAgents.delete(sessionKey);
           this.refreshActiveTelegramInteractionCount();
@@ -713039,7 +714232,10 @@ Join: ${newUrl}`
           lastEditMs: 0,
           aborted: false,
           toolContext,
-          pendingMessages: [],
+          pendingIntakeRecords: [],
+          pendingContextPackets: [],
+          runId: `telegram:${randomBytes28(8).toString("hex")}`,
+          taskEpoch: this.telegramTaskEpoch(sessionKey),
           creativeWorkspaceRoot: this.creativeWorkspaceRootForMessage(
             msg,
             toolContext
@@ -713050,6 +714246,17 @@ Join: ${newUrl}`
           surfacedToolCallFingerprints: /* @__PURE__ */ new Set()
         };
         this.subAgents.set(sessionKey, subAgent);
+        const primaryIntake = this.telegramIntakeRecords.get(
+          this.telegramInputIdForMessage(msg)
+        );
+        if (primaryIntake) {
+          void this.transitionTelegramIntake(
+            primaryIntake,
+            "accepted",
+            "admitted as the primary Telegram chat prompt",
+            { runId: subAgent.runId }
+          );
+        }
         this.refreshActiveTelegramInteractionCount();
         this.subAgentViewCallbacks?.onRegister(
           subAgent.viewId,
@@ -713092,7 +714299,11 @@ Join: ${newUrl}`
             mediaContext,
             "chat",
             additionalContext
-          );
+          ).catch((err) => {
+            if (subAgent.preempted) return "";
+            throw err;
+          });
+          if (subAgent.preempted) return;
           if (subAgent.typingInterval) {
             clearInterval(subAgent.typingInterval);
             subAgent.typingInterval = null;
@@ -713216,6 +714427,7 @@ Join: ${newUrl}`
             );
           }
         } finally {
+          await this.requeuePendingTelegramIntakeOnFinalization(subAgent);
           this.clearTelegramSubAgentContextBuffer(sessionKey);
           this.subAgents.delete(sessionKey);
           this.refreshActiveTelegramInteractionCount();
@@ -713682,6 +714894,7 @@ ${conversationStream}`
           ...isAdminDM ? TELEGRAM_ADMIN_EVIDENCE_OPTIONS : TELEGRAM_PUBLIC_FAST_OPTIONS,
           // ── WO #03 (Typed Gateway Event Stream): structured event feed ──
           onTypedEvent: (event) => {
+            this.forwardTelegramRunnerIntakeLifecycle(event);
             if (event.type === "run_finished") {
               subAgent.runnerCompleted = event.success;
               subAgent.runnerStatus = event.status;
@@ -713697,17 +714910,33 @@ ${conversationStream}`
         });
         runner.setWorkingDirectory(repoRoot);
         subAgent.runner = runner;
-        if (subAgent.pendingMessages.length > 0) {
-          for (const queued of subAgent.pendingMessages) {
-            runner.injectUserMessage(queued);
+        if (subAgent.pendingIntakeRecords.length > 0) {
+          for (const queued of subAgent.pendingIntakeRecords) {
+            this.injectTelegramSteeringInput(
+              subAgent,
+              queued.intake,
+              queued.content
+            );
+            void this.transitionTelegramIntake(
+              queued.intake,
+              "accepted",
+              "initial Telegram intake handed to runner",
+              { runId: subAgent.runId }
+            );
           }
           this.tuiWrite(
             () => renderTelegramSubAgentEvent(
               msg.username,
-              `replayed ${subAgent.pendingMessages.length} queued message(s)`
+              `replayed ${subAgent.pendingIntakeRecords.length} typed intake record(s)`
             )
           );
-          subAgent.pendingMessages.length = 0;
+          subAgent.pendingIntakeRecords.length = 0;
+        }
+        if (subAgent.pendingContextPackets.length > 0) {
+          for (const packet of subAgent.pendingContextPackets) {
+            runner.injectUserMessage(packet);
+          }
+          subAgent.pendingContextPackets.length = 0;
         }
         const tools = this.buildSubAgentTools(
           ctx3,
@@ -720501,7 +721730,7 @@ var command_passthrough_exports = {};
 __export(command_passthrough_exports, {
   runCommand: () => runCommand
 });
-function stripAnsi6(s2) {
+function stripAnsi7(s2) {
   return s2.replace(/\x1B(?:\[[\d;?]*[a-zA-Z]|\][^\x07\x1B]*[\x07\x1B]?|[@-Z\\-_])/g, "");
 }
 async function runCommand(input, opts) {
@@ -720566,7 +721795,7 @@ async function runCommand(input, opts) {
       command: cmdName,
       args: argsStr,
       kind,
-      output: stripAnsi6(ansi5).trim(),
+      output: stripAnsi7(ansi5).trim(),
       ansi: ansi5,
       durationMs: Date.now() - start2,
       error: errMsg
@@ -721935,7 +723164,7 @@ var init_audit_log = __esm({
 // packages/cli/src/api/disk-task-output.ts
 import { open } from "node:fs/promises";
 import { existsSync as existsSync164, mkdirSync as mkdirSync102, statSync as statSync63 } from "node:fs";
-import { dirname as dirname53 } from "node:path";
+import { dirname as dirname54 } from "node:path";
 import * as fsConstants from "node:constants";
 var O_NOFOLLOW2, O_APPEND2, O_CREAT2, O_WRONLY2, OPEN_FLAGS_WRITE, OPEN_MODE, DiskTaskOutput;
 var init_disk_task_output = __esm({
@@ -721953,7 +723182,7 @@ var init_disk_task_output = __esm({
       fileSize = 0;
       constructor(outputPath3) {
         this.path = outputPath3;
-        mkdirSync102(dirname53(outputPath3), { recursive: true });
+        mkdirSync102(dirname54(outputPath3), { recursive: true });
       }
       /** Queue content for async append. Non-blocking. */
       append(chunk) {
@@ -741038,7 +742267,7 @@ var init_chat_followup = __esm({
 // packages/cli/src/docker.ts
 import { execSync as execSync39, spawn as spawn37 } from "node:child_process";
 import { existsSync as existsSync172, mkdirSync as mkdirSync108, writeFileSync as writeFileSync91 } from "node:fs";
-import { join as join181, resolve as resolve76, dirname as dirname54 } from "node:path";
+import { join as join181, resolve as resolve76, dirname as dirname55 } from "node:path";
 import { homedir as homedir62 } from "node:os";
 import { fileURLToPath as fileURLToPath22 } from "node:url";
 function getDockerDir() {
@@ -741049,7 +742278,7 @@ function getDockerDir() {
   } catch {
   }
   try {
-    const thisDir = dirname54(fileURLToPath22(import.meta.url));
+    const thisDir = dirname55(fileURLToPath22(import.meta.url));
     return join181(thisDir, "..", "..", "..", "docker");
   } catch {
   }
@@ -741514,7 +742743,7 @@ import * as http5 from "node:http";
 import * as https3 from "node:https";
 import { createRequire as createRequire8 } from "node:module";
 import { fileURLToPath as fileURLToPath23 } from "node:url";
-import { dirname as dirname55, join as join183, resolve as resolve77 } from "node:path";
+import { dirname as dirname56, join as join183, resolve as resolve77 } from "node:path";
 import { homedir as homedir63 } from "node:os";
 import { spawn as spawn38, execSync as execSync40 } from "node:child_process";
 import {
@@ -741544,7 +742773,7 @@ function memoryDbPaths3(baseDir = process.cwd()) {
 }
 function getVersion3() {
   try {
-    const thisDir = dirname55(fileURLToPath23(import.meta.url));
+    const thisDir = dirname56(fileURLToPath23(import.meta.url));
     const candidates = [
       join183(thisDir, "..", "package.json"),
       join183(thisDir, "..", "..", "package.json"),
@@ -742122,23 +743351,7 @@ async function writeMemoryEpisodes(sessionId, userMessage, assistantContent, too
   }
 }
 function sanitizeChatContent(raw) {
-  if (typeof raw !== "string") return "";
-  const lines = raw.split("\n");
-  const cleaned = [];
-  for (const rawLine of lines) {
-    const line = rawLine.replace(/\x1B\[[0-9;]*[A-Za-z]/g, "").replace(/\x1B\].*?\x07/g, "").trim();
-    if (!line) continue;
-    if (/^i\s+/.test(line)) continue;
-    if (/^E\s+/.test(line)) continue;
-    if (/^⚠\s*(Task incomplete|Task complete)/.test(line)) continue;
-    if (/^▹\s/.test(line)) continue;
-    if (/^User:\s/.test(line)) continue;
-    if (/^Assistant:\s/.test(line)) continue;
-    if (/^Previous conversation:/.test(line)) continue;
-    if (/^omnius \(/.test(line)) continue;
-    cleaned.push(line);
-  }
-  return cleaned.join("\n").trim();
+  return sanitizeAgentOutputForUser(raw);
 }
 function appendNoThinkDirectivesToMessages(messages2) {
   let lastUserIdx = -1;
@@ -744276,7 +745489,8 @@ async function handleV1ChatCompletions(req3, res, ollamaUrl) {
     return;
   }
   const callerProvidedThink = "think" in routedBody;
-  const thinkingAllowed = process.env["OMNIUS_ENABLE_THINKING"] === "1" && process.env["OMNIUS_FORCE_NO_THINK"] !== "1";
+  const requestTools = routedBody["tools"];
+  const thinkingAllowed = process.env["OMNIUS_FORCE_NO_THINK"] !== "1" && !(Array.isArray(requestTools) && requestTools.length > 0);
   const finalThink = thinkingAllowed && callerProvidedThink ? routedBody["think"] : false;
   const ollamaBody = { ...routedBody };
   if (finalThink === false && Array.isArray(ollamaBody["messages"])) {
@@ -745021,7 +746235,7 @@ async function handleV1Update(req3, res, requestId) {
     );
     const fs14 = require4("node:fs");
     const nodeBin = process.execPath;
-    const nodeDir = dirname55(nodeBin);
+    const nodeDir = dirname56(nodeBin);
     const { execSync: es } = require4("node:child_process");
     const isWin2 = process.platform === "win32";
     let npmBin = "";
@@ -745036,7 +746250,7 @@ async function handleV1Update(req3, res, requestId) {
     const dir = join183(homedir63(), ".omnius");
     fs14.mkdirSync(dir, { recursive: true });
     const logFd = fs14.openSync(logPath3, "w");
-    const npmPrefix = dirname55(nodeDir);
+    const npmPrefix = dirname56(nodeDir);
     let globalBinDir = "";
     try {
       if (isWin2) {
@@ -750985,7 +752199,7 @@ function startApiServer(options2 = {}) {
     if (process.env["OMNIUS_DAEMON"] === "1" && process.env["OMNIUS_NO_VERSION_GUARD"] !== "1") {
       const readDiskVersion = () => {
         try {
-          const here = dirname55(fileURLToPath23(import.meta.url));
+          const here = dirname56(fileURLToPath23(import.meta.url));
           for (const rel of ["../package.json", "../../package.json", "../../../package.json", "../../../../package.json"]) {
             const p2 = join183(here, rel);
             if (existsSync173(p2)) {
@@ -751894,6 +753108,7 @@ var init_serve = __esm({
     init_access_policy();
     init_projects();
     init_project_preferences();
+    init_internal_output();
     init_voice_runtime();
     init_voice();
     init_audit_log();
@@ -752075,7 +753290,7 @@ var init_clipboard_media = __esm({
 
 // packages/cli/src/tui/interactive.ts
 import { cwd } from "node:process";
-import { resolve as resolve78, join as join185, dirname as dirname56, extname as extname22, relative as relative22, sep as sep7 } from "node:path";
+import { resolve as resolve78, join as join185, dirname as dirname57, extname as extname22, relative as relative22, sep as sep7 } from "node:path";
 import { createRequire as createRequire9 } from "node:module";
 import { fileURLToPath as fileURLToPath24 } from "node:url";
 import { createHash as createHash53 } from "node:crypto";
@@ -752092,7 +753307,7 @@ import { existsSync as existsSync174 } from "node:fs";
 import {
   readFile as readFileAsync2,
   writeFile as writeFileAsync2,
-  mkdir as mkdirAsync
+  mkdir as mkdirAsync2
 } from "node:fs/promises";
 import { homedir as homedir64 } from "node:os";
 function refreshLocalOllamaModelCache() {
@@ -752136,7 +753351,7 @@ function formatTimeAgo2(date) {
 function getVersion4() {
   try {
     const require5 = createRequire9(import.meta.url);
-    const thisDir = dirname56(fileURLToPath24(import.meta.url));
+    const thisDir = dirname57(fileURLToPath24(import.meta.url));
     const candidates = [
       join185(thisDir, "..", "package.json"),
       join185(thisDir, "..", "..", "package.json"),
@@ -756044,7 +757259,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
                 if (existsSync174(ikFile)) {
                   ikState = JSON.parse(await readFileAsync2(ikFile, "utf8"));
                 } else {
-                  await mkdirAsync(ikDir, { recursive: true });
+                  await mkdirAsync2(ikDir, { recursive: true });
                   const machineId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
                   ikState = {
                     self_id: `omnius-${machineId}`,
@@ -757218,14 +758433,50 @@ ${result.summary}`
     } : null
   });
   let resolvedContextWindowSize = 0;
-  queryContextSize(config.backendUrl, config.model, config.apiKey).then((ctxSize) => {
-    if (ctxSize) {
-      resolvedContextWindowSize = ctxSize;
-      statusBar.setContextWindowSize(ctxSize);
-      setActiveTaskContextWindowSize(ctxSize);
-      telegramBridge?.setContextWindowSize(ctxSize);
+  const contextTelemetryByScope = /* @__PURE__ */ new Map();
+  const contextScope = (backendUrl2, model) => `${normalizeBaseUrl(backendUrl2).replace(/\/v1$/i, "")}\0${model}`;
+  const currentContextScope = () => contextScope(currentConfig.backendUrl, currentConfig.model);
+  const applyContextTelemetry = (telemetry) => {
+    const scope = contextScope(telemetry.endpoint, telemetry.model);
+    const previous = contextTelemetryByScope.get(scope);
+    const merged = {
+      ...previous,
+      ...telemetry,
+      capacityTokens: telemetry.capacityTokens ?? previous?.capacityTokens,
+      capacitySource: telemetry.capacityTokens ? telemetry.capacitySource : previous?.capacitySource
+    };
+    contextTelemetryByScope.set(scope, merged);
+    if (scope !== currentContextScope()) return;
+    const capacity = merged.capacityTokens;
+    resolvedContextWindowSize = capacity ?? 0;
+    statusBar.setContextCapacity(capacity ? {
+      status: "known",
+      totalTokens: capacity,
+      source: merged.capacitySource,
+      endpoint: merged.endpoint,
+      model: merged.model
+    } : {
+      status: "unknown",
+      source: "provider_metadata_missing",
+      endpoint: merged.endpoint,
+      model: merged.model
+    });
+    setActiveTaskContextWindowSize(capacity ?? 0);
+    telegramBridge?.setContextWindowSize(capacity ?? 0);
+    if (merged.estimatedContextTokens !== void 0 || merged.outputReservationTokens !== void 0) {
+      statusBar.updateMetrics({
+        ...merged.estimatedContextTokens !== void 0 ? { estimatedContextTokens: merged.estimatedContextTokens } : {},
+        ...merged.outputReservationTokens !== void 0 ? { contextOutputReservationTokens: merged.outputReservationTokens } : {}
+      });
     }
-  }).catch(() => {
+  };
+  void queryContextTelemetry(config.backendUrl, config.model, config.apiKey).then(applyContextTelemetry).catch(() => {
+    statusBar.setContextCapacity({
+      status: "unknown",
+      source: "query_failed",
+      endpoint: normalizeBaseUrl(config.backendUrl),
+      model: config.model
+    });
   });
   let resolvedCaps = {
     vision: false,
@@ -757539,6 +758790,28 @@ Rationale: ${proposal.rationale}${provenanceNote}${dmnDevDiscipline(proposal.cat
     const runner = activeTask?.runner;
     if (runner) runner.setContextWindowSize(size);
   };
+  let llamaCppSlotPollInFlight = false;
+  const pollLlamaCppSlots = async () => {
+    if (llamaCppSlotPollInFlight || !activeTask) return;
+    llamaCppSlotPollInFlight = true;
+    const pollScope = currentContextScope();
+    const endpoint = currentConfig.backendUrl;
+    const model = currentConfig.model;
+    const apiKey = currentConfig.apiKey;
+    try {
+      const telemetry = await queryLlamaCppSlotTelemetry(endpoint, model, apiKey);
+      if (telemetry && pollScope === currentContextScope()) {
+        applyContextTelemetry(telemetry);
+      }
+    } catch {
+    } finally {
+      llamaCppSlotPollInFlight = false;
+    }
+  };
+  const llamaCppSlotPollTimer = setInterval(() => {
+    void pollLlamaCppSlots();
+  }, 3e3);
+  llamaCppSlotPollTimer.unref();
   const turnQueue = [];
   let queueDrainScheduled = false;
   let sessionTitle = null;
@@ -763295,7 +764568,8 @@ async function runJson(task, config, repoPath2) {
   try {
     await runWithTUI(task, config, repoPath2, {
       onAssistantText: (text2) => {
-        assistantTexts.push(text2);
+        const sanitized = sanitizeAgentOutputForUser(text2);
+        if (sanitized) assistantTexts.push(sanitized);
       },
       onToolCall: (tool, args) => {
         toolCallLog.push({ tool, args });
@@ -763350,12 +764624,14 @@ async function runJson(task, config, repoPath2) {
   process.stdout.write = origWrite;
   process.stderr.write = origStderr;
   const allCaptured = captured.join("");
-  const cleanText2 = allCaptured.replace(/\x1B\[[0-9;]*[A-Za-z]/g, "").replace(/\x1B\].*?\x07/g, "").replace(/\x1B[78]/g, "").replace(/\x1B\[\?[0-9;]*[hl]/g, "");
+  const cleanText2 = sanitizeAgentOutputForUser(allCaptured);
   result.text = cleanText2;
   if (assistantTexts.length > 0) {
-    const streamText = assistantTexts[0] || "";
+    const streamText = sanitizeAgentOutputForUser(assistantTexts[0] || "");
     const hasSubstantiveStream = streamText.length > 30;
-    result.assistant_text = hasSubstantiveStream ? streamText : assistantTexts[assistantTexts.length - 1];
+    result.assistant_text = hasSubstantiveStream ? streamText : sanitizeAgentOutputForUser(
+      assistantTexts[assistantTexts.length - 1] || ""
+    );
   }
   if (toolCallLog.length > 0) {
     result.tool_calls = toolCallLog;
@@ -763490,6 +764766,7 @@ var init_run = __esm({
     init_dist8();
     init_typed_node_events();
     init_secret_redactor();
+    init_internal_output();
   }
 });
 
@@ -764356,7 +765633,7 @@ init_typed_node_events();
 init_dist5();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { fileURLToPath as fileURLToPath25 } from "node:url";
-import { dirname as dirname57, join as join189 } from "node:path";
+import { dirname as dirname58, join as join189 } from "node:path";
 import { createRequire as createRequire10 } from "node:module";
 
 // packages/cli/src/cli.ts
@@ -764504,7 +765781,7 @@ init_output();
 function getVersion5() {
   try {
     const require5 = createRequire10(import.meta.url);
-    const pkgPath = join189(dirname57(fileURLToPath25(import.meta.url)), "..", "package.json");
+    const pkgPath = join189(dirname58(fileURLToPath25(import.meta.url)), "..", "package.json");
     const pkg = require5(pkgPath);
     return pkg.version;
   } catch {