omnius 1.0.553 → 1.0.555

package/dist/index.js

@@ -7256,6 +7256,22 @@ var init_file_write = __esm({
 import { execFile as execFile2 } from "node:child_process";
 import { promisify } from "node:util";
 import { resolve as resolve6 } from "node:path";
+function partialGrepOutput(input) {
+  const raw = input.stdout ?? "";
+  const lines = raw.split("\n").filter(Boolean);
+  const sample = lines.slice(0, MAX_OUTPUT_LINES).join("\n");
+  const narrowing = JSON.stringify({
+    pattern: input.pattern,
+    path: input.searchPath,
+    ...input.include ? { include: input.include } : {}
+  });
+  return [
+    `[GREP_PARTIAL] output reached the ${input.capBytes}-byte capture cap; matching succeeded but this is only a prefix (${lines.length} captured lines).`,
+    `provenance=tool:grep_search cap_bytes=${input.capBytes} path=${input.searchPath}${input.include ? ` include=${input.include}` : ""}`,
+    `narrow_next=add an include/path or a more specific pattern, e.g. grep_search(${narrowing})`,
+    sample
+  ].filter(Boolean).join("\n");
+}
 var _a, execFileAsync, MAX_OUTPUT_LINES, DEFAULT_SEARCH_TIMEOUT_MS, RG_EXCLUDED_GLOBS, GREP_EXCLUDED_DIRS, GrepSearchTool;
 var init_grep_search = __esm({
   "packages/execution/dist/tools/grep-search.js"() {
@@ -7374,10 +7390,25 @@ var init_grep_search = __esm({
             output: truncated ? `${output}
 
 [Output truncated to ${MAX_OUTPUT_LINES} lines. ${lines.length - MAX_OUTPUT_LINES} more matches exist.]` : output,
+            partial: truncated,
             durationMs: performance.now() - start2
           };
         } catch (error) {
           const err = error;
+          if (err.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || /maxbuffer|max buffer/i.test(err.message)) {
+            return {
+              success: true,
+              partial: true,
+              output: partialGrepOutput({
+                stdout: err.stdout,
+                pattern,
+                searchPath,
+                include,
+                capBytes: 1024 * 1024
+              }),
+              durationMs: performance.now() - start2
+            };
+          }
           if (err.code === 1) {
             return {
               success: true,
@@ -274007,11 +274038,11 @@ var require_out = __commonJS({
       async.read(path16, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports.stat = stat9;
-    function statSync70(path16, optionsOrSettings) {
+    function statSync71(path16, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path16, settings);
     }
-    exports.statSync = statSync70;
+    exports.statSync = statSync71;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -297514,6 +297545,10 @@ function replayWorkboardEvents(events) {
         goal: event.payload.goal,
         scope: event.payload.scope,
         title: event.payload.title,
+        taskEpoch: event.payload.taskEpoch,
+        rawUserIntent: event.payload.rawUserIntent,
+        artifactEvidence: event.payload.artifactEvidence,
+        lastSubstantiveProgress: event.payload.lastSubstantiveProgress,
         createdAt: event.createdAt,
         updatedAt: event.createdAt,
         eventCount: 0,
@@ -297538,7 +297573,11 @@ function replayWorkboardEvents(events) {
             status: event.payload.status,
             goal: event.payload.goal,
             scope: event.payload.scope,
-            title: event.payload.title
+            title: event.payload.title,
+            taskEpoch: event.payload.taskEpoch,
+            rawUserIntent: event.payload.rawUserIntent,
+            artifactEvidence: event.payload.artifactEvidence,
+            lastSubstantiveProgress: event.payload.lastSubstantiveProgress
           })
         };
         break;
@@ -297705,7 +297744,11 @@ function createWorkboard(workingDir, input = {}) {
           status: "active",
           goal: cleanString(input.goal),
           scope: cleanString(input.scope),
-          title: cleanString(input.title)
+          title: cleanString(input.title),
+          taskEpoch: typeof input.taskEpoch === "number" && Number.isFinite(input.taskEpoch) ? input.taskEpoch : void 0,
+          rawUserIntent: cleanString(input.rawUserIntent),
+          artifactEvidence: input.artifactEvidence ? normalizeEvidenceCollection(input.artifactEvidence, input.actor).slice(-12) : void 0,
+          lastSubstantiveProgress: input.lastSubstantiveProgress
         }
       }
     ];
@@ -297777,6 +297820,25 @@ function addWorkboardCard(workingDir, input) {
   }
   return appendWorkboardEvents(workingDir, runId, events);
 }
+function updateWorkboardMetadata(workingDir, input) {
+  const runId = normalizeWorkboardRunId(input.runId);
+  const snapshot = requireWorkboard(workingDir, runId);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  return appendWorkboardEvents(workingDir, runId, [{
+    schemaVersion: WORKBOARD_SCHEMA_VERSION,
+    id: newEventId("board"),
+    runId,
+    type: "board.updated",
+    createdAt: now2,
+    actor: cleanString(input.actor),
+    payload: {
+      taskEpoch: typeof input.taskEpoch === "number" && Number.isFinite(input.taskEpoch) ? input.taskEpoch : void 0,
+      rawUserIntent: cleanString(input.rawUserIntent),
+      artifactEvidence: input.artifactEvidence ? appendUniqueEvidence(snapshot.artifactEvidence ?? [], normalizeEvidenceCollection(input.artifactEvidence, input.actor)).slice(-12) : void 0,
+      lastSubstantiveProgress: input.lastSubstantiveProgress
+    }
+  }]);
+}
 function updateWorkboardCard(workingDir, input) {
   const runId = normalizeWorkboardRunId(input.runId);
   const snapshot = requireWorkboard(workingDir, runId);
@@ -297881,9 +297943,9 @@ function completeWorkboardCard(workingDir, input) {
   if (outcome === "request_changes") {
     const evidence2 = input.evidence === void 0 ? [] : normalizeEvidenceCollection(input.evidence, input.actor);
     const uniqueEvidence2 = evidence2.length > 0 ? filterNewEvidence(card.evidence, evidence2) : [];
-    const events = [];
+    const events2 = [];
     if (uniqueEvidence2.length > 0) {
-      events.push({
+      events2.push({
         schemaVersion: WORKBOARD_SCHEMA_VERSION,
         id: newEventId("evidence"),
         runId,
@@ -297895,7 +297957,7 @@ function completeWorkboardCard(workingDir, input) {
     }
     const missingEvidence = normalizeStringArray(input.missingEvidence);
     const reason2 = cleanString(input.reason) || cleanString(input.notes) || "Verifier requested changes.";
-    events.push({
+    events2.push({
       schemaVersion: WORKBOARD_SCHEMA_VERSION,
       id: newEventId("changes"),
       runId,
@@ -297909,7 +297971,7 @@ function completeWorkboardCard(workingDir, input) {
         decision: makeDecision("needs_changes", reason2, { cardId: card.id, actor: input.actor, createdAt: now2 })
       }
     });
-    snapshot = appendWorkboardEvents(workingDir, runId, events);
+    snapshot = appendWorkboardEvents(workingDir, runId, events2);
     return {
       accepted: true,
       snapshot,
@@ -297954,20 +298016,8 @@ function completeWorkboardCard(workingDir, input) {
     };
   }
   const evidence = input.evidence === void 0 ? [] : normalizeEvidenceCollection(input.evidence, input.actor);
-  let evidenceSnapshot = snapshot;
   const uniqueEvidence = evidence.length > 0 ? filterNewEvidence(card.evidence, evidence) : [];
-  if (uniqueEvidence.length > 0) {
-    evidenceSnapshot = appendWorkboardEvents(workingDir, runId, [{
-      schemaVersion: WORKBOARD_SCHEMA_VERSION,
-      id: newEventId("evidence"),
-      runId,
-      type: "evidence.attached",
-      createdAt: now2,
-      actor: cleanString(input.actor),
-      payload: { cardId: card.id, evidence: uniqueEvidence }
-    }]);
-  }
-  const currentCard = evidenceSnapshot.cards.find((existing) => existing.id === card.id) ?? card;
+  const currentCard = uniqueEvidence.length > 0 ? { ...card, evidence: appendUniqueEvidence(card.evidence, uniqueEvidence) } : card;
   const evidenceCheck = verifyCardEvidence(currentCard);
   if (!evidenceCheck.valid) {
     const diagnostic = makeDiagnostic("completion_without_evidence", "error", `card '${card.id}' cannot be ${outcome} without required evidence`, {
@@ -298012,7 +298062,20 @@ function completeWorkboardCard(workingDir, input) {
       decision: makeDecision("completed", reason, { cardId: card.id, actor: input.actor, createdAt: now2 })
     }
   };
-  snapshot = appendWorkboardEvents(workingDir, runId, [event]);
+  const events = [];
+  if (uniqueEvidence.length > 0) {
+    events.push({
+      schemaVersion: WORKBOARD_SCHEMA_VERSION,
+      id: newEventId("evidence"),
+      runId,
+      type: "evidence.attached",
+      createdAt: now2,
+      actor: cleanString(input.actor),
+      payload: { cardId: card.id, evidence: uniqueEvidence }
+    });
+  }
+  events.push(event);
+  snapshot = appendWorkboardEvents(workingDir, runId, events);
   return {
     accepted: true,
     snapshot,
@@ -298267,7 +298330,9 @@ function normalizeCardInput(input, timestamp) {
     diagnosticFingerprint: cleanString(input.diagnosticFingerprint),
     ownedFiles: normalizeStringArray(input.ownedFiles),
     verifierCommand: cleanString(input.verifierCommand),
-    rank: typeof input.rank === "number" && Number.isFinite(input.rank) ? input.rank : void 0
+    rank: typeof input.rank === "number" && Number.isFinite(input.rank) ? input.rank : void 0,
+    canonicalKey: cleanString(input.canonicalKey),
+    sourceTodoIds: normalizeStringArray(input.sourceTodoIds)
   };
   validateSpecialCardAdmission(card);
   return card;
@@ -298308,6 +298373,12 @@ function normalizeCardUpdates(input) {
     updates.verifierCommand = cleanString(input.verifierCommand);
   if (input.rank !== void 0 && Number.isFinite(input.rank))
     updates.rank = input.rank;
+  if (input.canonicalKey !== void 0)
+    updates.canonicalKey = cleanString(input.canonicalKey);
+  if (input.sourceTodoIds !== void 0)
+    updates.sourceTodoIds = normalizeStringArray(input.sourceTodoIds);
+  if (input.supersededBy !== void 0)
+    updates.supersededBy = cleanString(input.supersededBy);
   if (Object.keys(updates).length === 0)
     throw new WorkboardError("empty_update", "at least one card field must be updated");
   return updates;
@@ -311942,7 +312013,7 @@ ${lanes.join("\n")}
               return process.memoryUsage().heapUsed;
             },
             getFileSize(path16) {
-              const stat9 = statSync70(path16);
+              const stat9 = statSync71(path16);
               if (stat9 == null ? void 0 : stat9.isFile()) {
                 return stat9.size;
               }
@@ -311986,7 +312057,7 @@ ${lanes.join("\n")}
             }
           };
           return nodeSystem;
-          function statSync70(path16) {
+          function statSync71(path16) {
             try {
               return _fs.statSync(path16, statSyncOptions);
             } catch {
@@ -312045,7 +312116,7 @@ ${lanes.join("\n")}
               activeSession.post("Profiler.stop", (err, { profile }) => {
                 var _a2;
                 if (!err) {
-                  if ((_a2 = statSync70(profilePath)) == null ? void 0 : _a2.isDirectory()) {
+                  if ((_a2 = statSync71(profilePath)) == null ? void 0 : _a2.isDirectory()) {
                     profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
                   }
                   try {
@@ -312165,7 +312236,7 @@ ${lanes.join("\n")}
                 let stat9;
                 if (typeof dirent === "string" || dirent.isSymbolicLink()) {
                   const name10 = combinePaths(path16, entry);
-                  stat9 = statSync70(name10);
+                  stat9 = statSync71(name10);
                   if (!stat9) {
                     continue;
                   }
@@ -312189,7 +312260,7 @@ ${lanes.join("\n")}
             return matchFiles(path16, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
           }
           function fileSystemEntryExists(path16, entryKind) {
-            const stat9 = statSync70(path16);
+            const stat9 = statSync71(path16);
             if (!stat9) {
               return false;
             }
@@ -312231,7 +312302,7 @@ ${lanes.join("\n")}
           }
           function getModifiedTime3(path16) {
             var _a2;
-            return (_a2 = statSync70(path16)) == null ? void 0 : _a2.mtime;
+            return (_a2 = statSync71(path16)) == null ? void 0 : _a2.mtime;
           }
           function setModifiedTime(path16, time) {
             try {
@@ -562249,6 +562320,7 @@ __export(dist_exports2, {
   unifiedPythonEnv: () => unifiedPythonEnv,
   unifiedRuntimeDir: () => unifiedRuntimeDir,
   updateWorkboardCard: () => updateWorkboardCard,
+  updateWorkboardMetadata: () => updateWorkboardMetadata,
   validateCustomToolDefinition: () => validateCustomToolDefinition,
   validateMediaModelAdapter: () => validateMediaModelAdapter,
   validateMutationWorkerContract: () => validateMutationWorkerContract,
@@ -566175,12 +566247,18 @@ function stripThinkTags(text2) {
     return "";
   return String(text2).replace(THINK_BLOCK_RE, "").trim();
 }
+function stripNoThinkPromptDirectives(text2) {
+  if (text2 == null)
+    return "";
+  return String(text2).replace(NO_THINK_PROMPT_DIRECTIVE_RE, "").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
 function cleanForStorage(text2) {
   if (text2 == null)
     return "";
   let out = String(text2);
   out = cleanScaffolding(out);
   out = stripThinkTags(out);
+  out = stripNoThinkPromptDirectives(out);
   out = out.replace(ANSI_ESCAPE_RE, "");
   out = out.replace(/\s+/g, " ").trim();
   return out;
@@ -566214,7 +566292,7 @@ function extractTaskCompleteSummary(args) {
   }
   return "";
 }
-var SIGNPOST_RE, NEW_TASK_RE, RESTORED_BLOCK_RE, SYSTEM_BLOCK_RE, THINK_BLOCK_RE, ANSI_ESCAPE_RE;
+var SIGNPOST_RE, NEW_TASK_RE, RESTORED_BLOCK_RE, SYSTEM_BLOCK_RE, THINK_BLOCK_RE, NO_THINK_PROMPT_DIRECTIVE_RE, ANSI_ESCAPE_RE;
 var init_textSanitize = __esm({
   "packages/orchestrator/dist/textSanitize.js"() {
     "use strict";
@@ -566223,6 +566301,7 @@ var init_textSanitize = __esm({
     RESTORED_BLOCK_RE = /^[\s\S]*?\n---\s*\n\s*NEW TASK:\s*/m;
     SYSTEM_BLOCK_RE = /^<system>[\s\S]*?<\/system>\s*\n*/m;
     THINK_BLOCK_RE = /<think>[\s\S]*?<\/think>/g;
+    NO_THINK_PROMPT_DIRECTIVE_RE = /\/(?:no[_-]?think)\b/gi;
     ANSI_ESCAPE_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07/g;
   }
 });
@@ -566441,6 +566520,28 @@ import { randomUUID as randomUUID16 } from "node:crypto";
 import { appendFileSync as appendFileSync6, existsSync as existsSync88, mkdirSync as mkdirSync50, readFileSync as readFileSync65 } from "node:fs";
 import { join as join98 } from "node:path";
 import { z as z16 } from "zod";
+function classifySteeringIntent(content, requestedIntent) {
+  if (requestedIntent === "redirect" || requestedIntent === "replace" || requestedIntent === "cancel") {
+    return requestedIntent;
+  }
+  const normalized = content.toLowerCase().replace(/\s+/g, " ").trim();
+  const constraint = /\b(?:do not|don't|never|must not|forbid|forbidden|avoid|read[ -]?only|no (?:file )?(?:writes?|mutations?)|without modifying|scope|safety|safe(?:ty)?|only modify|do not publish)\b/.test(normalized);
+  if (constraint || requestedIntent === "constraint")
+    return "constraint";
+  const priority = /\b(?:prioriti[sz]e|priority|urgent|first|before .*?(?:else|anything)|defer|hold|focus on|instead of)\b/.test(normalized);
+  if (priority || requestedIntent === "priority_change") {
+    return "priority_change";
+  }
+  if (requestedIntent === "context_only")
+    return "context_only";
+  return "context_only";
+}
+function steeringRequiresReconciliation(intent) {
+  return intent !== "cancel";
+}
+function steeringGatesOldPlan(intent) {
+  return intent === "constraint" || intent === "priority_change";
+}
 function createSteeringIngress(input) {
   return {
     id: randomUUID16(),
@@ -572353,14 +572454,17 @@ function collectDiff(opts) {
     }
     return { files, strategy: "explicit" };
   }
+  if (opts.explicitFilesOnly)
+    return { files: [], strategy: "explicit" };
   const since = Date.now() - opts.mtimeWindowMs;
   const scan = scanWorkspace({ root: opts.workingDir, maxFiles: cap * 4 });
   const recent = scan.files.filter((f2) => f2.mtimeMs >= since).sort((a2, b) => b.mtimeMs - a2.mtimeMs).slice(0, cap).map((f2) => ({ path: f2.rel, bytes: f2.bytes, status: "modified" }));
   return { files: recent, strategy: "mtime" };
 }
 async function collectDiffAsync(opts) {
-  if (opts.explicitFiles && opts.explicitFiles.length > 0)
+  if (opts.explicitFilesOnly || opts.explicitFiles && opts.explicitFiles.length > 0) {
     return collectDiff(opts);
+  }
   const cap = Math.max(1, opts.maxFiles);
   if (existsSync96(join106(opts.workingDir, ".git"))) {
     try {
@@ -572423,7 +572527,8 @@ async function runBackwardPass(opts) {
     workingDir: opts.workingDir,
     maxFiles,
     mtimeWindowMs,
-    explicitFiles: opts.explicitFiles
+    explicitFiles: opts.explicitFiles,
+    explicitFilesOnly: opts.explicitFilesOnly
   });
   const diff = collected.files.map((f2) => {
     const abs = isAbsolute14(f2.path) ? f2.path : join106(opts.workingDir, f2.path);
@@ -578568,8 +578673,11 @@ function isControllerStateMessage(message2) {
 function isActionGroundTruthMessage(message2) {
   return typeof message2.content === "string" && message2.content.includes(ACTION_GROUND_TRUTH_MARKER);
 }
+function isActiveSteeringMessage(message2) {
+  return typeof message2.content === "string" && message2.content.includes("[ACTIVE USER STEERING]");
+}
 function isProtectedControllerMessage(message2) {
-  return isControllerStateMessage(message2) || isActionGroundTruthMessage(message2);
+  return isControllerStateMessage(message2) || isActionGroundTruthMessage(message2) || isActiveSteeringMessage(message2);
 }
 function modelFacingMessageCap(message2) {
   if (isControllerStateMessage(message2)) {
@@ -578578,6 +578686,9 @@ function modelFacingMessageCap(message2) {
   if (isActionGroundTruthMessage(message2)) {
     return MODEL_FACING_ACTION_GROUND_TRUTH_CHAR_CAP;
   }
+  if (isActiveSteeringMessage(message2)) {
+    return Math.max(MODEL_FACING_ACTION_GROUND_TRUTH_CHAR_CAP, 7e3);
+  }
   if (message2.role === "tool")
     return MODEL_FACING_TOOL_CHAR_CAP;
   if (message2.role === "system")
@@ -578625,7 +578736,7 @@ function applyModelFacingBudget(messages2, preserveFirstSystem) {
     const message2 = messages2[index];
     const content = messageText(message2.content);
     const isReservedTransactionMessage = reservedTransaction.has(index);
-    const isPriorityIntent = message2.role === "user" || isCurrentGoalMessage(message2);
+    const isPriorityIntent = message2.role === "user" || isCurrentGoalMessage(message2) || isActiveSteeringMessage(message2);
     const perMessageCap = modelFacingMessageCap(message2);
     const isProtectedController = isProtectedControllerMessage(message2);
     const allowed = isReservedTransactionMessage ? perMessageCap : isPriorityIntent ? content.length : isProtectedController ? perMessageCap : Math.min(remaining, perMessageCap);
@@ -578648,7 +578759,7 @@ 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();
 }
 function sanitizeModelVisibleContextText(text2) {
-  let out = String(text2 ?? "");
+  let out = stripNoThinkPromptDirectives(String(text2 ?? ""));
   out = out.replace(RUNTIME_GUIDANCE_RE, (_match, inner) => {
     return `[runtime_guidance]
 ${String(inner ?? "").trim()}`;
@@ -578663,6 +578774,18 @@ ${out}`.trim();
   }
   return collapseWhitespace(out);
 }
+function stripNoThinkFromMessageContent(content) {
+  if (typeof content === "string")
+    return stripNoThinkPromptDirectives(content);
+  if (!Array.isArray(content))
+    return content;
+  return content.map((part) => {
+    if (!part || typeof part !== "object")
+      return part;
+    const rec = part;
+    return rec["type"] === "text" && typeof rec["text"] === "string" ? { ...rec, text: stripNoThinkPromptDirectives(rec["text"]) } : part;
+  });
+}
 function messageText(content) {
   if (typeof content === "string")
     return content;
@@ -578836,7 +578959,10 @@ function retireDuplicateToolFailures(messages2) {
     }
     out[index] = {
       ...message2,
-      content: "[retired_duplicate_tool_failure] a newer matching result appears later. Use that latest diagnostic; retry only after refreshing prerequisite evidence or correcting the arguments."
+      // Keep the protocol message (some providers require every tool call to
+      // retain a response) but make retired duplicate failures token-empty.
+      // The newest result is the sole model-visible recovery record.
+      content: ""
     };
   }
   return out;
@@ -578853,7 +578979,11 @@ function prepareModelFacingApiMessages(input) {
   });
   const independentlyBounded = splitOversizedSystemMessages(withoutLegacyControl);
   for (let index = 0; index < independentlyBounded.length; index++) {
-    const message2 = independentlyBounded[index];
+    const rawMessage = independentlyBounded[index];
+    const message2 = {
+      ...rawMessage,
+      content: stripNoThinkFromMessageContent(rawMessage.content)
+    };
     if (message2.role === "system" && typeof message2.content === "string") {
       if (preserveFirstSystem && sanitized.length === 0) {
         sanitized.push({ ...message2 });
@@ -578877,10 +579007,22 @@ function prepareModelFacingApiMessages(input) {
     }
     sanitized.push({ ...message2 });
   }
-  const keep = new Array(sanitized.length).fill(true);
+  const activeUserEpoch = sanitized.reduce((latest, message2) => {
+    if (message2.role !== "user")
+      return latest;
+    const epoch = Number(message2["taskEpoch"]);
+    return Number.isInteger(epoch) && epoch >= 0 && (latest === null || epoch > latest) ? epoch : latest;
+  }, null);
+  const epochScoped = activeUserEpoch === null ? sanitized : sanitized.filter((message2) => {
+    if (message2.role !== "user")
+      return true;
+    const epoch = Number(message2["taskEpoch"]);
+    return Number.isInteger(epoch) && epoch === activeUserEpoch;
+  });
+  const keep = new Array(epochScoped.length).fill(true);
   const seenSystemKeys = /* @__PURE__ */ new Set();
-  for (let index = sanitized.length - 1; index >= 0; index--) {
-    const message2 = sanitized[index];
+  for (let index = epochScoped.length - 1; index >= 0; index--) {
+    const message2 = epochScoped[index];
     if (message2.role !== "system" || typeof message2.content !== "string")
       continue;
     if (preserveFirstSystem && index === 0)
@@ -578894,7 +579036,7 @@ function prepareModelFacingApiMessages(input) {
     }
     seenSystemKeys.add(key);
   }
-  const deduped = retireDuplicateToolFailures(sanitized.filter((_message, index) => keep[index]));
+  const deduped = retireDuplicateToolFailures(epochScoped.filter((_message, index) => keep[index]));
   if (!hasUserMessage(deduped) && !hasConcreteGoalMessage(deduped)) {
     const goal = deriveCurrentGoal({
       explicitGoal: input.currentGoal,
@@ -579019,6 +579161,7 @@ var init_context_compiler = __esm({
   "packages/orchestrator/dist/context-compiler.js"() {
     "use strict";
     init_context_fabric();
+    init_textSanitize();
     MODEL_FACING_CONTEXT_CHAR_BUDGET = 48e3;
     MODEL_FACING_TOOL_CHAR_CAP = 6e3;
     MODEL_FACING_SYSTEM_CHAR_CAP = 8e3;
@@ -579026,7 +579169,7 @@ var init_context_compiler = __esm({
     MODEL_FACING_ACTION_GROUND_TRUTH_CHAR_CAP = 5500;
     CONTROLLER_STATE_MARKER = "[CONTROLLER STATE v1]";
     ACTION_GROUND_TRUTH_MARKER = "[RECENT ACTION GROUND TRUTH]";
-    LEGACY_RUNTIME_CONTROL_FRAGMENT_RE = /(?:\bREG-\d+\b|\bfocus supervisor\b|\bworld[ -]state\b|\brecent tool failures\b|\bstop\s*[—-]\s*retry loop\b|\bstagnation replan\b|\bfirst-edit nudge\b|\bintra-run lesson\b|\blocal error-informed nudge\b|\b(?:failure|failing)\s+(?:recovery|replan|loop)\b|\bdoom-loop\b|\b(?:prior\s+)?failure reflection\b|\breflexion\b|\b(?:cross-session|prior)\s+lessons?\b|\bprogress gate\b|\bforecast\b)/i;
+    LEGACY_RUNTIME_CONTROL_FRAGMENT_RE = /(?:\bREG-\d+\b|\bfocus supervisor\b|\bworld[ -]state\b|\brecent tool failures\b|\bstop\s*[—-]\s*retry loop\b|\bstagnation replan\b|\bfirst-edit nudge\b|\bintra-run lesson\b|\blocal error-informed nudge\b|\b(?:failure|failing)\s+(?:recovery|replan|loop|recap)\b|\b(?:controller|admin)\s+(?:summary|recap|reflection)\b|\bdoom-loop\b|\b(?:prior\s+)?failure reflection\b|\breflexion\b|\b(?:cross-session|prior)\s+lessons?\b|\bprogress gate\b|\bforecast\b)/i;
     LEGACY_RUNTIME_CONTROL_BLOCK_START_RE = /(?:\[(?:REG-\d+|FOCUS SUPERVISOR[^\]]*|WORLD[ -]STATE[^\]]*|RECENT TOOL FAILURES|STOP\s*[—-]\s*RETRY LOOP|STAGNATION REPLAN[^\]]*|FIRST-EDIT NUDGE[^\]]*|INTRA-RUN LESSON[^\]]*|LOCAL ERROR-INFORMED NUDGE[^\]]*|FORECAST[^\]]*|PROGRESS GATE[^\]]*|FAIL(?:URE|ING)[^\]]*(?:RECOVERY|REPLAN|LOOP)[^\]]*|DOOM-LOOP[^\]]*)\]|<(?:world-state|focus-supervisor|failure-recovery|reflection|lessons?)[^>]*>)/i;
     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;
@@ -579459,6 +579602,7 @@ function recordContextWindowDump(input) {
     ...input.note ? { note: input.note } : {},
     ...input.focusSupervisor ? { focusSupervisor: compactFocusSupervisor(input.focusSupervisor) } : {},
     metrics: metrics2,
+    contextAccounting: buildContextAccounting(input.request, metrics2),
     apiView: summarizeApiView(input.request, metrics2),
     request: input.request
   };
@@ -579634,6 +579778,60 @@ function analyzeContextWindowDumpRequest(request) {
     }
   };
 }
+function contextSourceForMessage(role, text2) {
+  if (/\[ACTIVE USER STEERING\]/.test(text2)) {
+    return "active_user_steering";
+  }
+  if (/\[ACTIVE USER INTENT\]|\[CURRENT USER GOAL\]/.test(text2)) {
+    return "current_user_intent";
+  }
+  if (/\[CONTROLLER STATE v1\]|\[RECENT ACTION GROUND TRUTH\]/.test(text2)) {
+    return "current_controller_state";
+  }
+  if (/\[ACTIVE CONTEXT FRAME\]|Evidence already gathered this run/.test(text2)) {
+    return "active_evidence";
+  }
+  if (role === "tool")
+    return "tool_result";
+  if (role === "system")
+    return "system_instruction";
+  if (role === "user")
+    return "user_history";
+  if (role === "assistant")
+    return "assistant_history";
+  return `role:${role}`;
+}
+function buildContextAccounting(request, metrics2) {
+  const buckets = /* @__PURE__ */ new Map();
+  const add3 = (source, chars) => {
+    const bucket = buckets.get(source) ?? { messageCount: 0, chars: 0 };
+    bucket.messageCount++;
+    bucket.chars += chars;
+    buckets.set(source, bucket);
+  };
+  const messages2 = Array.isArray(request["messages"]) ? request["messages"] : [];
+  for (const message2 of messages2) {
+    const record = message2 && typeof message2 === "object" ? message2 : {};
+    const role = typeof record["role"] === "string" ? record["role"] : "unknown";
+    const extracted = textAndImagesFromContent(record["content"]);
+    const toolCallChars = Array.isArray(record["tool_calls"]) ? JSON.stringify(record["tool_calls"]).length : 0;
+    add3(contextSourceForMessage(role, extracted.textWithoutImages), extracted.textWithoutImages.length + toolCallChars);
+  }
+  if (metrics2.toolSchemaChars > 0)
+    add3("tool_schema", metrics2.toolSchemaChars);
+  const sources = [...buckets.entries()].map(([source, bucket]) => ({
+    source,
+    ...bucket,
+    estimatedTokens: Math.ceil(bucket.chars / 4)
+  })).sort((a2, b) => a2.source.localeCompare(b.source));
+  return {
+    schemaVersion: 1,
+    totalMessageChars: metrics2.totalChars,
+    toolSchemaChars: metrics2.toolSchemaChars,
+    estimatedTokens: metrics2.estimatedTokens,
+    sources
+  };
+}
 function summarizeApiView(request, metrics2) {
   const messages2 = Array.isArray(request["messages"]) ? request["messages"] : [];
   const previews = [];
@@ -579721,7 +579919,7 @@ function isRawDiscoveryToolResult(text2) {
   const isDiscovery = DISCOVERY_SOURCE_TOOLS.some((t2) => text2.includes(t2));
   if (!isDiscovery)
     return false;
-  return !text2.includes("[DISCOVERY COMPACTED") && !text2.includes("[DISCOVERY BOUNDED") && !text2.includes("[STOP RE-READING") && !text2.includes("[BRANCH-EXTRACT]");
+  return !text2.includes("[DISCOVERY COMPACTED") && !text2.includes("[DISCOVERY BOUNDED") && !text2.includes("[STOP RE-READING") && !/^\[BRANCH-EXTRACT(?:\s+v\d+)?\]/m.test(text2);
 }
 function toSummary(record, path16) {
   const { request: _request, ...summary } = record;
@@ -581453,6 +581651,9 @@ var init_focusSupervisor = __esm({
         }
         this.taskEpoch = next;
         this.state = "observe";
+        this.failureFamilies.clear();
+        this.convergenceFamilyCounts.clear();
+        this.sawMutationSinceFailure = false;
         this.ignoredDirectiveStreak = 0;
         this.lastIgnoredDirectiveTurn = null;
         this.repeatedViolationCounts.clear();
@@ -581746,6 +581947,8 @@ var init_focusSupervisor = __esm({
       }
       observeToolResult(input) {
         this.lastObservedTurn = Math.max(this.lastObservedTurn, input.turn);
+        if (input.taskEpoch !== void 0)
+          this.setTaskEpoch(input.taskEpoch, input.turn);
         this.expireDirectiveIfNeeded(input.turn);
         if (!this.enabled)
           return;
@@ -581767,7 +581970,7 @@ var init_focusSupervisor = __esm({
         if (input.toolName === "shell" && input.success) {
           if (this.convergenceBreaker) {
             const fam = actionFamily(input.toolName, input.args, this.familyCwd);
-            this.convergenceBreaker.resolve(fam);
+            this.convergenceBreaker.resolve(`${this.taskEpoch}:${fam}`);
             this.convergenceFamilyCounts.delete(fam);
           }
           if (this.directive?.requiredNextAction === "run_verification") {
@@ -581855,7 +582058,7 @@ var init_focusSupervisor = __esm({
           const convCount = (this.convergenceFamilyCounts.get(convergenceFamily) ?? 0) + 1;
           this.convergenceFamilyCounts.set(convergenceFamily, convCount);
           const verdict = this.convergenceBreaker.observe({
-            family: convergenceFamily,
+            family: `${this.taskEpoch}:${convergenceFamily}`,
             sessionCount: convCount,
             turn: input.turn,
             sample: next.sample,
@@ -581882,7 +582085,15 @@ var init_focusSupervisor = __esm({
               ]
             });
           } else if (verdict.tier === "abandon") {
-            this.markTerminalIncomplete(verdict.reason, input.turn);
+            this.setDirective({
+              turn: input.turn,
+              state: "forced_replan",
+              reason: verdict.reason,
+              requiredNextAction: this.resolveRequiredNextAction("creative_pivot_or_research"),
+              forbiddenActionFamilies: [
+                actionFamily(input.toolName, input.args, this.familyCwd)
+              ]
+            });
           } else if (verdict.tier === "stalled") {
             this.setDirective({
               turn: input.turn,
@@ -584467,6 +584678,7 @@ function buildBranchExtractionBrief(input) {
       maxWindowsPerRound: 3,
       maxTotalWindows: MAX_WINDOWS,
       maxPresentedLines: MAX_SNIPPET_LINES,
+      maxPresentedChars: MAX_PRESENTED_CHARS,
       maxInjectedChars: 2400
     }
   };
@@ -584806,7 +585018,8 @@ async function extractEvidence(opts) {
   });
   const requiredIds = requirements.filter((requirement) => requirement.required).map((requirement) => requirement.id);
   const deterministicSatisfied = new Set(deterministic.satisfied);
-  if (deterministic.segments.length > 0 && requiredIds.every((id2) => deterministicSatisfied.has(id2))) {
+  const deterministicComplete = deterministic.segments.length > 0 && requiredIds.every((id2) => deterministicSatisfied.has(id2));
+  if (deterministicComplete && !backend) {
     const claim = renderSegments(deterministic.segments, maxInjectedChars);
     const legacySpan = legacyContiguousSpan(deterministic.segments);
     return {
@@ -584843,6 +585056,7 @@ async function extractEvidence(opts) {
   const searchRounds = [...deterministic.rounds];
   let remainingWindows = Math.min(MAX_WINDOWS, brief.discoveryContract?.budget.maxTotalWindows ?? MAX_WINDOWS);
   let remainingPresentedLines = Math.min(MAX_SNIPPET_LINES, brief.discoveryContract?.budget.maxPresentedLines ?? MAX_SNIPPET_LINES);
+  let remainingPresentedChars = Math.min(MAX_PRESENTED_CHARS, brief.discoveryContract?.budget.maxPresentedChars ?? MAX_PRESENTED_CHARS);
   if (backend) {
     const maxSemanticRounds = Math.max(0, (brief.discoveryContract?.budget.maxRounds ?? 3) - searchRounds.length);
     for (let attempt = 0; attempt < Math.min(2, maxSemanticRounds); attempt++) {
@@ -584857,10 +585071,13 @@ async function extractEvidence(opts) {
         if (selectedWindows.length >= perRound)
           break;
         const windowLines = window2.end - window2.start + 1;
-        if (windowLines > remainingPresentedLines)
+        const windowChars = window2.text.length;
+        if (windowLines > remainingPresentedLines || windowChars > remainingPresentedChars) {
           continue;
+        }
         selectedWindows.push(window2);
         remainingPresentedLines -= windowLines;
+        remainingPresentedChars -= windowChars;
       }
       remainingWindows -= selectedWindows.length;
       const relativeWindows = selectedWindows.map((window2) => ({
@@ -585059,7 +585276,7 @@ function assessBranchRead(input) {
     ...input.requestedRange ? { requestedRange: input.requestedRange } : {}
   };
 }
-var MAX_WINDOWS, SNIPPET_CONTEXT, HEAD_LINES2, MAX_SNIPPET_LINES, EXTRACT_CONFIDENCE_FLOOR, STOPWORDS2, DEFAULT_BRANCH_READ_CONTEXT_FRACTION;
+var MAX_WINDOWS, SNIPPET_CONTEXT, HEAD_LINES2, MAX_SNIPPET_LINES, MAX_PRESENTED_CHARS, EXTRACT_CONFIDENCE_FLOOR, STOPWORDS2, DEFAULT_BRANCH_READ_CONTEXT_FRACTION;
 var init_evidenceBranch = __esm({
   "packages/orchestrator/dist/evidenceBranch.js"() {
     "use strict";
@@ -585067,6 +585284,7 @@ var init_evidenceBranch = __esm({
     SNIPPET_CONTEXT = 4;
     HEAD_LINES2 = 10;
     MAX_SNIPPET_LINES = 220;
+    MAX_PRESENTED_CHARS = 24e3;
     EXTRACT_CONFIDENCE_FLOOR = 0.3;
     STOPWORDS2 = /* @__PURE__ */ new Set([
       "the",
@@ -587983,34 +588201,6 @@ function stripThinkBlocks(s2) {
     return s2;
   return s2.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
-function injectNoThinkDirective(messages2) {
-  if (!Array.isArray(messages2) || messages2.length === 0)
-    return messages2;
-  let lastUserIdx = -1;
-  for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
-    if (messages2[i2]?.role === "user") {
-      lastUserIdx = i2;
-      break;
-    }
-  }
-  if (lastUserIdx === -1)
-    return messages2;
-  const target = messages2[lastUserIdx];
-  if (!target || typeof target.content !== "string")
-    return messages2;
-  const hasOllamaNoThink = /\/nothink\b/i.test(target.content);
-  const hasQwenNoThink = /\/no[_-]think\b/i.test(target.content);
-  if (hasOllamaNoThink && hasQwenNoThink)
-    return messages2;
-  const suffix = [
-    hasOllamaNoThink ? null : "/nothink",
-    hasQwenNoThink ? null : "/no_think"
-  ].filter(Boolean).join("\n");
-  const annotated = `${target.content}
-
-${suffix}`;
-  return messages2.map((m2, i2) => i2 === lastUserIdx ? { ...m2, content: annotated } : m2);
-}
 function backendHttpErrorDetail(text2) {
   const trimmed = text2.trimStart();
   const isHtml = trimmed.startsWith("<!") || trimmed.startsWith("<html");
@@ -588082,7 +588272,7 @@ function sanitizeHistoryThink(messages2) {
     if (m2.role === "assistant") {
       content = stripThinkBlocks(content);
     }
-    content = content.replace(/\/nothink\b/gi, "").replace(/\/no[_-]think\b/gi, "");
+    content = stripNoThinkPromptDirectives(content);
     if (m2.role === "assistant") {
       const collapsed = collapseDegenerateAssistantRepetition(content);
       content = collapsed ?? content;
@@ -588446,6 +588636,8 @@ var init_agenticRunner = __esm({
       pendingSteeringInputs = [];
       _steeringSequence = 0;
       _taskEpoch = 0;
+      /** First tool-log turn belonging to the active task epoch. */
+      _taskEpochStartTurn = 0;
       _activeRunId = "";
       /** Session storage is retained for compatibility; superseded task leaves are hidden from active guards. */
       _supersededTodoIds = /* @__PURE__ */ new Set();
@@ -588454,6 +588646,10 @@ var init_agenticRunner = __esm({
       /** Abort scope for only the in-flight model/tool turn. Never use for permanent stop. */
       _turnAbortController = new AbortController();
       _pendingSteeringPreemption = null;
+      /** One authoritative, request-protected steering state; never reconstructed from transcript. */
+      _activeSteering = null;
+      /** Logical turn currently making a model/tool decision across both run loops. */
+      _currentSteeringTurn = 0;
       pendingRuntimeGuidanceMessages = [];
       aborted = false;
       _abortController = new AbortController();
@@ -589044,6 +589240,10 @@ var init_agenticRunner = __esm({
       _workboardDir() {
         return this.options.workboardDir || this._workingDirectory || process.cwd();
       }
+      /** One immutable execution run owns every workboard read and mutation. */
+      _workboardRunId() {
+        return this.currentArtifactRunId();
+      }
       _todoWriteAvailable() {
         return this.tools.has("todo_write");
       }
@@ -589065,7 +589265,7 @@ var init_agenticRunner = __esm({
           return this._workboard;
         }
         const dir = this._workboardDir();
-        const runId = this.currentArtifactRunId();
+        const runId = this._workboardRunId();
         const existing = loadWorkboardSnapshot(dir, runId);
         if (existing) {
           this._workboard = this._seedWorkboardCardsIfNeeded(existing, goal);
@@ -589082,6 +589282,8 @@ var init_agenticRunner = __esm({
             runId,
             owner: this.options.subAgent ? "sub-agent" : "agent",
             goal: goal || void 0,
+            rawUserIntent: goal || void 0,
+            taskEpoch: this._taskEpoch,
             title: (this._taskState.goal || "").slice(0, 120) || void 0,
             cards: initialCards
           });
@@ -589186,6 +589388,8 @@ var init_agenticRunner = __esm({
               runId,
               owner: actor,
               goal: this._taskState.originalGoal || this._taskState.goal || void 0,
+              rawUserIntent: this._taskState.originalGoal || this._taskState.goal || void 0,
+              taskEpoch: this._taskEpoch,
               title: (this._taskState.goal || diagnosis.workboardTitle).slice(0, 120) || void 0,
               actor,
               cards: [cardInput]
@@ -589244,6 +589448,52 @@ var init_agenticRunner = __esm({
         const safe = todoId.replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
         return `todo-${safe || "item"}`;
       }
+      /**
+       * Todo ids are transport identifiers, not task identity.  Prefer declared
+       * artifacts, then an explicit verifier, and only then a normalized title so
+       * repeated todo_write calls cannot fork semantic workboard cards.
+       */
+      _todoWorkboardCanonicalKey(todo) {
+        const artifacts = (todo.declaredArtifacts ?? []).filter((path16) => typeof path16 === "string").map((path16) => this._normalizeEvidencePath(path16)).filter(Boolean).sort();
+        if (artifacts.length > 0)
+          return `artifacts:${[...new Set(artifacts)].join("|")}`;
+        const verifier = normalizeShellCommand(String(todo.verifyCommand ?? ""));
+        if (verifier)
+          return `verifier:${verifier}`;
+        const words = todo.content.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((word2) => word2.length > 2).filter((word2) => !(/* @__PURE__ */ new Set(["the", "and", "for", "with", "from", "that", "this", "then", "into", "todo"])).has(word2));
+        return `text:${[...new Set(words)].sort().join("|")}`;
+      }
+      _todoCardsSemanticallyMatch(existing, input) {
+        if (existing.canonicalKey && input.canonicalKey) {
+          return existing.canonicalKey === input.canonicalKey;
+        }
+        const existingVerifier = normalizeShellCommand(existing.verifierCommand ?? "");
+        const inputVerifier = normalizeShellCommand(input.verifierCommand ?? "");
+        if (existingVerifier && inputVerifier)
+          return existingVerifier === inputVerifier;
+        const existingFiles = new Set((existing.ownedFiles ?? []).map((path16) => this._normalizeEvidencePath(path16)));
+        const inputFiles = (input.ownedFiles ?? []).map((path16) => this._normalizeEvidencePath(path16));
+        if (existingFiles.size > 0 && inputFiles.length > 0) {
+          return inputFiles.some((path16) => existingFiles.has(path16));
+        }
+        const words = (value2) => new Set(value2.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((word2) => word2.length > 3));
+        const left = words(`${existing.title} ${existing.description}`);
+        const right = words(`${input.title} ${input.description ?? ""}`);
+        let shared = 0;
+        for (const word2 of left)
+          if (right.has(word2))
+            shared++;
+        return shared >= 5 && shared / Math.max(left.size, right.size, 1) >= 0.62;
+      }
+      _mergeTodoCardInputs(target, incoming) {
+        target.sourceTodoIds = [.../* @__PURE__ */ new Set([...target.sourceTodoIds ?? [], ...incoming.sourceTodoIds ?? []])];
+        target.ownedFiles = [.../* @__PURE__ */ new Set([...target.ownedFiles ?? [], ...incoming.ownedFiles ?? []])];
+        target.evidenceRequirements = [.../* @__PURE__ */ new Set([...target.evidenceRequirements ?? [], ...incoming.evidenceRequirements ?? []])];
+        if (incoming.status === "in_progress") {
+          target.status = "in_progress";
+          target.lane = "worker";
+        }
+      }
       _todoWorkboardCardInput(todo, path16) {
         const requirements = [];
         if (todo.verifyCommand) {
@@ -589268,6 +589518,8 @@ var init_agenticRunner = __esm({
         const status = todo.status === "blocked" ? "blocked" : todo.status === "pending" ? "open" : "in_progress";
         return {
           id: this._todoWorkboardCardId(todo.id),
+          canonicalKey: this._todoWorkboardCanonicalKey(todo),
+          sourceTodoIds: [todo.id],
           title: todo.content.slice(0, 120),
           description: path16.map((item) => item.content).join(" > ").slice(0, 800),
           lane,
@@ -589275,7 +589527,9 @@ var init_agenticRunner = __esm({
           assignee: todo.owner || "any",
           role: "worker",
           evidenceRequired: true,
-          evidenceRequirements: requirements
+          evidenceRequirements: requirements,
+          ownedFiles: (todo.declaredArtifacts ?? []).filter((path17) => typeof path17 === "string").map((path17) => this._normalizeEvidencePath(path17)).filter(Boolean),
+          verifierCommand: todo.verifyCommand
         };
       }
       _mirrorTodosToWorkboard(todos) {
@@ -589286,7 +589540,15 @@ var init_agenticRunner = __esm({
         const activeLeaves = this._todoLeaves(normalized, index).filter((todo) => todo.status !== "completed").slice(0, 20);
         if (activeLeaves.length === 0)
           return;
-        const cards = activeLeaves.map((todo) => this._todoWorkboardCardInput(todo, this._todoPath(todo, index)));
+        const cards = [];
+        for (const todo of activeLeaves) {
+          const incoming = this._todoWorkboardCardInput(todo, this._todoPath(todo, index));
+          const equivalent = cards.find((card) => this._todoCardsSemanticallyMatch(card, incoming));
+          if (equivalent)
+            this._mergeTodoCardInputs(equivalent, incoming);
+          else
+            cards.push(incoming);
+        }
         const dir = this._workboardDir();
         const runId = this.currentArtifactRunId();
         const actor = this.options.subAgent ? "sub-agent" : "agent";
@@ -589297,6 +589559,8 @@ var init_agenticRunner = __esm({
               runId,
               owner: actor,
               goal: this._taskState.originalGoal || this._taskState.goal || void 0,
+              rawUserIntent: this._taskState.originalGoal || this._taskState.goal || void 0,
+              taskEpoch: this._taskEpoch,
               title: (this._taskState.goal || "Active todo work").slice(0, 120),
               actor,
               cards
@@ -589305,7 +589569,7 @@ var init_agenticRunner = __esm({
             return;
           }
           for (const cardInput of cards) {
-            const existing = board.cards.find((card) => card.id === cardInput.id);
+            let existing = board.cards.find((card) => card.id === cardInput.id) ?? board.cards.find((card) => !card.supersededBy && this._todoCardsSemanticallyMatch(card, cardInput));
             if (!existing) {
               board = addWorkboardCard(dir, {
                 ...cardInput,
@@ -589315,6 +589579,28 @@ var init_agenticRunner = __esm({
               });
               continue;
             }
+            const duplicates = board.cards.filter((card) => card.id !== existing.id && !card.supersededBy && this._todoCardsSemanticallyMatch(card, cardInput));
+            for (const duplicate of duplicates) {
+              if (duplicate.evidence.length > 0) {
+                attachWorkboardEvidence(dir, {
+                  runId,
+                  cardId: existing.id,
+                  actor,
+                  evidence: duplicate.evidence
+                });
+              }
+              board = updateWorkboardCard(dir, {
+                runId,
+                cardId: duplicate.id,
+                actor,
+                updates: {
+                  supersededBy: existing.id,
+                  blocker: `Superseded by canonical card '${existing.id}'.`
+                },
+                decisionReason: `Merged duplicate todo card into canonical '${existing.id}'.`
+              });
+              existing = board.cards.find((card) => card.id === existing.id) ?? existing;
+            }
             if (existing.status === "verified")
               continue;
             board = updateWorkboardCard(dir, {
@@ -589326,7 +589612,11 @@ var init_agenticRunner = __esm({
                 description: cardInput.description,
                 lane: cardInput.lane,
                 status: existing.status === "completed" ? "needs_changes" : cardInput.status,
-                evidenceRequirements: cardInput.evidenceRequirements
+                evidenceRequirements: cardInput.evidenceRequirements,
+                canonicalKey: cardInput.canonicalKey,
+                sourceTodoIds: [.../* @__PURE__ */ new Set([...existing.sourceTodoIds ?? [], ...cardInput.sourceTodoIds ?? []])],
+                ownedFiles: cardInput.ownedFiles,
+                verifierCommand: cardInput.verifierCommand
               },
               decisionReason: "Synchronized workboard card from current todo state."
             });
@@ -589452,12 +589742,12 @@ var init_agenticRunner = __esm({
       injectWorkboardContext() {
         if (this._workboard || this.options.subAgent) {
           const dir = this._workboardDir();
-          let snapshot = readActiveWorkboardSnapshot(dir, this._sessionId);
+          let snapshot = readActiveWorkboardSnapshot(dir, this._workboardRunId());
           if (!snapshot)
             return null;
           snapshot = this._seedWorkboardCardsIfNeeded(snapshot, this._taskState.originalGoal || this._taskState.goal || "");
           this._workboard = snapshot;
-          const activeCards = snapshot.cards.filter((c9) => c9.status === "in_progress" || c9.status === "open" || c9.status === "needs_changes");
+          const activeCards = snapshot.cards.filter((c9) => !c9.supersededBy && (c9.status === "in_progress" || c9.status === "open" || c9.status === "needs_changes"));
           if (activeCards.length === 0 && snapshot.cards.every((c9) => c9.status === "verified" || c9.status === "completed"))
             return null;
           const synthesis = buildWorkboardSynthesisContext(snapshot);
@@ -589558,7 +589848,7 @@ ${parts.join("\n")}
       _deriveWorkboardActionContract(snapshot) {
         if (snapshot.cards.length === 0)
           return null;
-        const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
+        const byId = new Map(snapshot.cards.filter((card) => !card.supersededBy).map((card) => [card.id, card]));
         const discovery = byId.get("discover-current-state");
         const implementation2 = byId.get("implement-repair");
         const integration = byId.get("integrate-and-run");
@@ -589598,7 +589888,7 @@ ${parts.join("\n")}
             ])
           };
         }
-        const active = snapshot.cards.find((card) => card.status === "in_progress") ?? snapshot.cards.find((card) => card.status === "needs_changes") ?? snapshot.cards.find((card) => card.status === "open") ?? discovery;
+        const active = snapshot.cards.find((card) => !card.supersededBy && card.status === "in_progress") ?? snapshot.cards.find((card) => !card.supersededBy && card.status === "needs_changes") ?? snapshot.cards.find((card) => !card.supersededBy && card.status === "open") ?? discovery;
         if (!active)
           return null;
         return {
@@ -589738,6 +590028,8 @@ ${parts.join("\n")}
         for (const card of snapshot.cards) {
           if (!card.id.startsWith("todo-"))
             continue;
+          if (card.supersededBy)
+            continue;
           if (card.status === "completed" || card.status === "verified")
             continue;
           const text2 = [
@@ -589760,6 +590052,19 @@ ${parts.join("\n")}
         }
         return best?.card ?? null;
       }
+      _workboardTodoCardForVerifier(snapshot, args) {
+        const command = String(args["command"] ?? args["cmd"] ?? "").trim();
+        if (!command)
+          return null;
+        return snapshot.cards.find((card) => {
+          if (!card.id.startsWith("todo-") || card.supersededBy)
+            return false;
+          if (card.status === "completed" || card.status === "verified")
+            return false;
+          const verifier = card.verifierCommand || card.evidenceRequirements.find((item) => item.startsWith("verifyCommand:"))?.replace(/^verifyCommand:\s*/, "") || "";
+          return verifier.length > 0 && commandReliablySatisfiesVerifyCommand(command, verifier);
+        }) ?? null;
+      }
       _workboardTargetCardId(snapshot, toolName, args, result, meta = {}) {
         const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
         const targetPaths = this._extractToolTargetPaths(toolName, args, result);
@@ -589771,6 +590076,9 @@ ${parts.join("\n")}
           return matchingTodo?.id ?? (byId.has("implement-repair") ? "implement-repair" : null);
         }
         if (toolName === "shell" || toolName === "background_run") {
+          const verifierTodo = this._workboardTodoCardForVerifier(snapshot, args);
+          if (verifierTodo)
+            return verifierTodo.id;
           const implementation2 = byId.get("implement-repair");
           const target = this._workboardHasEditEvidence(implementation2) ? "integrate-and-run" : "discover-current-state";
           return byId.has(target) ? target : null;
@@ -589784,7 +590092,7 @@ ${parts.join("\n")}
         return active?.id ?? null;
       }
       _refreshWorkboardSnapshot(snapshot) {
-        const refreshed = readActiveWorkboardSnapshot(this._workboardDir(), this._sessionId) ?? snapshot;
+        const refreshed = readActiveWorkboardSnapshot(this._workboardDir(), this._workboardRunId()) ?? snapshot;
         this._workboard = refreshed;
         return refreshed;
       }
@@ -589855,7 +590163,7 @@ ${parts.join("\n")}
        * Non-fatal: failures to attach evidence are silently caught.
        */
       recordWorkboardToolCall(toolName, args, success, output, result, meta = {}) {
-        const board = this._workboard ?? this.getOrCreateWorkboard();
+        const board = this._currentWorkboardSnapshotForFrame() ?? this.getOrCreateWorkboard();
         if (!board)
           return;
         if (toolName === "task_complete" || toolName === "workboard_create")
@@ -589891,13 +590199,26 @@ ${parts.join("\n")}
           if (targetCard.assignee && targetCard.assignee !== actor && targetCard.assignee !== "any") {
             return;
           }
-          attachWorkboardEvidence(dir, {
+          const evidenced = attachWorkboardEvidence(dir, {
             runId: this.currentArtifactRunId(),
             cardId: targetCard.id,
             actor,
             evidence
           });
-          this._refreshWorkboardSnapshot(advanced);
+          const persistedEvidence = evidenced.cards.find((card) => card.id === targetCard.id)?.evidence.find((item) => item.summary === evidence.summary && item.content === evidence.content);
+          const substantive = success === true && result?.runtimeAuthored !== true;
+          this._workboard = updateWorkboardMetadata(dir, {
+            runId: this.currentArtifactRunId(),
+            actor,
+            taskEpoch: this._taskEpoch,
+            artifactEvidence: persistedEvidence ? [persistedEvidence] : [evidence],
+            lastSubstantiveProgress: substantive ? {
+              turn: this._taskState.toolCallCount,
+              signature: this._buildToolFingerprint(toolName, args),
+              evidenceIds: persistedEvidence ? [persistedEvidence.id] : [],
+              occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+            } : void 0
+          });
         } catch {
         }
       }
@@ -590362,7 +590683,12 @@ ${parts.join("\n")}
         try {
           const dir = _pathJoin(this.omniusStateDir(), "completion-ledgers");
           _fsMkdirSync(dir, { recursive: true });
-          saveCompletionLedger(_pathJoin(dir, `${this._sessionId}.json`), this._completionLedger);
+          saveCompletionLedger(
+            // A session can contain several steering epochs. Persist by immutable
+            // artifact run so recovery never hydrates evidence from a retired goal.
+            _pathJoin(dir, `${this.currentArtifactRunId()}.json`),
+            this._completionLedger
+          );
         } catch {
         }
       }
@@ -590807,7 +591133,20 @@ Your hypotheses MUST address this specific error, not generic causes.
           messages: messages2,
           currentGoal: this._taskState.originalGoal || this._taskState.goal || this._taskState.currentStep || this._taskState.nextAction || ""
         });
-        return sanitizeHistoryThink(prepared);
+        const withCurrentUserIntent = sanitizeHistoryThink(prepared);
+        if (!withCurrentUserIntent.some((message2) => message2.role === "user")) {
+          const currentIntent = this._taskState.originalGoal || this._taskState.goal || this._taskState.currentStep || this._taskState.nextAction || "";
+          if (currentIntent.trim()) {
+            const insertAt = withCurrentUserIntent[0]?.role === "system" ? 1 : 0;
+            withCurrentUserIntent.splice(insertAt, 0, {
+              role: "user",
+              content: `[ACTIVE USER INTENT]
+${currentIntent.trim().slice(0, 6e3)}`,
+              taskEpoch: this._taskEpoch
+            });
+          }
+        }
+        return withCurrentUserIntent;
       }
       // ── Failing-approach detector (the "stop retrying variants" reflex) ───────
       // Encodes the behavior an effective agent uses and the dropbear 27× loop
@@ -590875,7 +591214,7 @@ Your hypotheses MUST address this specific error, not generic causes.
                 stage: opts?.dumpStage ?? "aux_inference",
                 agentType: "internal",
                 sessionId: this._sessionId,
-                runId: this.currentArtifactRunId(),
+                runId: this._workboardRunId(),
                 model: this._backendModelLabel(this.backend),
                 cwd: this._workingDirectory || process.cwd(),
                 request: r2
@@ -591769,6 +592108,13 @@ ${extras.join("\n")}`;
           existingCards
         }) : existingCards;
         const delta = diffDiagnosticSets(previousDiagnostics, diagnostics);
+        const verifierActionSignature = normalizeShellCommand(verifierCommand);
+        const verifierResultSignature = [
+          input.success ? "success" : "failure",
+          ...diagnostics.map((diagnostic) => diagnostic.fingerprint).sort()
+        ].join("|");
+        const unchangedVerifierRound = this._compileFixLoop?.verifierActionSignature === verifierActionSignature && this._compileFixLoop?.verifierResultSignature === verifierResultSignature;
+        const verifierStasisCount = unchangedVerifierRound ? (this._compileFixLoop?.verifierStasisCount ?? 0) + 1 : 0;
         const nextCards = this._mergeCompileFixCardsAfterVerifier({
           existingCards,
           observedCards: cards,
@@ -591788,8 +592134,21 @@ ${extras.join("\n")}`;
           cards: nextCards,
           // A live verifier run resolves the gate's demand — the block streak
           // is over regardless of pass/fail.
-          preflightBlockStreak: 0
-        };
+          preflightBlockStreak: 0,
+          verifierActionSignature,
+          verifierResultSignature,
+          verifierStasisCount,
+          verifierStasisBlocked: verifierStasisCount >= 3 && !(input.success && diagnostics.length === 0),
+          prerequisiteRecoverySignature: void 0
+        };
+        if (this._compileFixLoop.verifierStasisBlocked) {
+          this.emit({
+            type: "status",
+            content: `compile_error_verifier_stasis: action/result unchanged for ${verifierStasisCount} rounds; block unchanged verifier/read retries until a scoped fix or fresh prerequisite evidence changes state`,
+            turn: input.turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
         this._mirrorCompileFixCardsToWorkboard(nextCards, {
           command: verifierCommand,
           success: input.success && diagnostics.length === 0,
@@ -591918,7 +592277,7 @@ ${extras.join("\n")}`;
           const dir = this._workboardDir();
           const actor = this.options.subAgent ? "sub-agent" : "agent";
           for (const card of cards) {
-            const existing = (readActiveWorkboardSnapshot(dir, this._sessionId) ?? this._workboard)?.cards.find((item) => item.id === card.id);
+            const existing = (readActiveWorkboardSnapshot(dir, this._workboardRunId()) ?? this._workboard)?.cards.find((item) => item.id === card.id);
             if (!existing) {
               this._workboard = addWorkboardCard(dir, {
                 ...compileFixCardToWorkboardInput(card),
@@ -591967,7 +592326,7 @@ ${extras.join("\n")}`;
               }
             });
             if (card.status === "dismissed" || card.status === "verified") {
-              const active = readActiveWorkboardSnapshot(dir, this._sessionId);
+              const active = readActiveWorkboardSnapshot(dir, this._workboardRunId());
               const wbCard = active?.cards.find((item) => item.id === card.id);
               if (wbCard && wbCard.status !== "completed" && wbCard.status !== "verified") {
                 this._workboard = completeWorkboardCard(dir, {
@@ -591979,7 +592338,7 @@ ${extras.join("\n")}`;
                 }).snapshot;
               }
               if (card.status === "verified") {
-                const latest = readActiveWorkboardSnapshot(dir, this._sessionId);
+                const latest = readActiveWorkboardSnapshot(dir, this._workboardRunId());
                 const latestCard = latest?.cards.find((item) => item.id === card.id);
                 if (latestCard?.status === "completed") {
                   this._workboard = completeWorkboardCard(dir, {
@@ -591999,7 +592358,7 @@ ${extras.join("\n")}`;
       _mirrorCompileFixCardAssigned(card, turn) {
         try {
           const dir = this._workboardDir();
-          const active = readActiveWorkboardSnapshot(dir, this._sessionId);
+          const active = readActiveWorkboardSnapshot(dir, this._workboardRunId());
           const existing = active?.cards.find((item) => item.id === card.id);
           if (!existing || existing.status !== "open")
             return;
@@ -592028,6 +592387,9 @@ ${extras.join("\n")}`;
         state.verifierDirtySinceTurn = turn;
         state.lastVerifierPassedTurn = null;
         state.lastMutationTurn = turn;
+        state.verifierStasisCount = 0;
+        state.verifierStasisBlocked = false;
+        state.prerequisiteRecoverySignature = void 0;
         this._focusSupervisor?.markCompletionBlocked({
           turn,
           reason: "A source mutation invalidated the declared verifier; verifier evidence now owns the active focus.",
@@ -592077,68 +592439,67 @@ ${extras.join("\n")}`;
         if (!state?.active)
           return null;
         const action = compileFixLoopNextRequiredAction(state);
-        if (action !== "run_declared_verifier")
+        const verifierLocked = action === "run_declared_verifier" || state.verifierStasisBlocked === true;
+        if (!verifierLocked)
           return null;
+        const blocked = (reason) => {
+          const streak = (state.preflightBlockStreak ?? 0) + 1;
+          state.preflightBlockStreak = streak;
+          return {
+            kind: "block",
+            message: [
+              `[COMPILE ERROR FIX LOOP BLOCKED — verifier action locked]`,
+              reason,
+              `declared_verifier=${state.verifierCommand}`,
+              `dirtySinceTurn=${state.verifierDirtySinceTurn}`,
+              `lastVerifierRunTurn=${state.lastVerifierRunTurn}`,
+              `stasisRounds=${state.verifierStasisCount ?? 0}`,
+              `blockedTool=${toolName} consecutiveBlocks=${streak}`,
+              `Allowed next actions: the declared verifier; one narrow prerequisite read of an owned file; or a scoped source fix that changes verifier inputs.`
+            ].join("\n")
+          };
+        };
         if (toolName === "shell") {
           const command = String(args["command"] ?? args["cmd"] ?? "").trim();
           if (commandReliablySatisfiesVerifyCommand(command, state.verifierCommand)) {
+            if (state.verifierStasisBlocked) {
+              return blocked("The same verifier action/result is in stasis. Change the owned source or obtain fresh prerequisite evidence before rerunning this unchanged verifier.");
+            }
             state.preflightBlockStreak = 0;
             return null;
           }
-          if (!shellLikelyMutatesFilesystem) {
+          void shellLikelyMutatesFilesystem;
+          return blocked("Only the declared verifier shell command is admitted while verifier evidence is locked.");
+        }
+        const readLike = /* @__PURE__ */ new Set([
+          "file_read",
+          "grep_search",
+          "find_files",
+          "list_directory",
+          "file_explore"
+        ]);
+        if (readLike.has(toolName)) {
+          const target = String(args["path"] ?? args["file"] ?? args["file_path"] ?? "");
+          const owned = state.cards.flatMap((card) => card.ownedFiles);
+          const scoped = target.length > 0 && owned.some((path16) => this._pathsOverlapForVerifier(target, path16));
+          const signature = `${toolName}:${this._buildExactArgsKey(args)}`;
+          if (scoped && state.prerequisiteRecoverySignature !== signature) {
+            state.prerequisiteRecoverySignature = signature;
+            state.preflightBlockStreak = 0;
             return null;
           }
-          const extraction = extractShellMutationPaths(command, {
-            workingDir: this.authoritativeWorkingDirectory()
-          });
-          const mutationPaths = extraction.paths.map((p2) => this._normalizeEvidencePath(p2)).filter(Boolean);
-          if (mutationPaths.length === 0 || !this._compileFixPathsTouchProjectSources(mutationPaths, state)) {
+          return blocked(scoped ? "The one prerequisite-recovery read has already been used; act on its evidence instead of reading again." : "Prerequisite recovery must be a narrow read of a compile-card owned file.");
+        }
+        if (this._isProjectEditTool(toolName)) {
+          const targetPaths = this._extractToolTargetPaths(toolName, args);
+          const scoped = targetPaths.some((path16) => this._compileFixPathsTouchProjectSources([this._normalizeEvidencePath(path16)], state));
+          if (scoped) {
+            state.preflightBlockStreak = 0;
             return null;
           }
-        } else if (!this._isProjectEditTool(toolName)) {
-          return null;
-        }
-        const yieldAfter = Number.MAX_SAFE_INTEGER;
-        const streak = (state.preflightBlockStreak ?? 0) + 1;
-        if (streak > yieldAfter) {
-          state.preflightBlockStreak = 0;
-          this.emit({
-            type: "status",
-            content: `compile_error_verifier_dirty: gate yielded to ${toolName} after ${yieldAfter} consecutive blocks at turn ${turn}`,
-            turn,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          return {
-            kind: "yield",
-            notice: [
-              `[COMPILE FIX GATE YIELDED — verifier still required]`,
-              `The verifier-required gate blocked ${yieldAfter} consecutive tool calls and is yielding so work can continue.`,
-              `Verifier evidence is still stale. Run the verifier as your next evidence step:`,
-              `  ${state.verifierCommand}`,
-              `Any real build/test command whose output shows current compiler diagnostics is also accepted as the live verifier.`,
-              `task_complete remains blocked until a verifier run passes after the last mutation.`
-            ].join("\n")
-          };
+          return blocked("A repair mutation must target a file owned by the active compile-fix card.");
         }
-        state.preflightBlockStreak = streak;
-        const message2 = [
-          `[COMPILE ERROR FIX LOOP BLOCKED — declared verifier required]`,
-          `A compile-fix card was patched, so the next mutation/evidence step must be the live verifier.`,
-          `Run this now: ${state.verifierCommand}`,
-          `Any real build/test command whose output shows current compiler diagnostics is also accepted.`,
-          `dirtySinceTurn: ${state.verifierDirtySinceTurn}`,
-          `lastMutationTurn: ${state.lastMutationTurn}`,
-          `lastVerifierRunTurn: ${state.lastVerifierRunTurn}`,
-          `blockedTool: ${toolName}`,
-          `consecutiveBlocks: ${streak} (verifier focus is retained until a live verifier settles)`
-        ].join("\n");
-        this.emit({
-          type: "status",
-          content: `compile_error_verifier_dirty: blocked ${toolName} at turn ${turn} (${streak}/${yieldAfter})`,
-          turn,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        return { kind: "block", message: message2 };
+        return blocked("This tool is unrelated to the locked verifier action.");
       }
       _compileFixLoopCompletionBlocker(turn) {
         const state = this._compileFixLoop;
@@ -593350,8 +593711,8 @@ ${_checks}`
           return { proceed: true };
         const maxCycles = parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_CYCLES"] || "2", 10) || 2;
         if (this._backwardPassCyclesUsed >= maxCycles) {
-          const lastCritique2 = this._lastBackwardPassCritique;
-          const evidenceAfterCritique = lastCritique2 ? toolCallLog.slice(lastCritique2.toolLogLength) : [];
+          const lastCritique = this._lastBackwardPassCritique;
+          const evidenceAfterCritique = lastCritique ? toolCallLog.slice(lastCritique.toolLogLength) : [];
           const freshVerification = evidenceAfterCritique.filter((entry) => {
             if (entry.success !== true)
               return false;
@@ -593361,7 +593722,7 @@ ${_checks}`
           const concern = freshVerification.length > 0 ? [
             "Prior reviewer concern may be stale; fresh verification evidence was recorded after that critique.",
             ...freshVerification.map((entry) => `${entry.name}: ${(entry.outputPreview ?? entry.argsKey).slice(0, 220)}`)
-          ].join(" ") : lastCritique2?.rationale?.trim() || this._lastBackwardPassVerdict || "unspecified";
+          ].join(" ") : lastCritique?.rationale?.trim() || this._lastBackwardPassVerdict || "unspecified";
           this._completionCaveat = [
             `[COMPLETION CAVEAT] Backward-pass review did not fully approve after ${this._backwardPassCyclesUsed}/${maxCycles} cycle(s).`,
             `${freshVerification.length > 0 ? "Reviewer reconciliation note" : "Unresolved reviewer concern"}: ${concern.slice(0, 600)}`,
@@ -593413,7 +593774,7 @@ ${_checks}`
             });
           }
         };
-        const todos = (() => {
+        const allTodos = (() => {
           try {
             const _t = this.readSessionTodos();
             return Array.isArray(_t) ? _t : [];
@@ -593421,17 +593782,15 @@ ${_checks}`
             return [];
           }
         })();
+        const todos = allTodos.filter((todo) => !this._supersededTodoIds.has(todo.id));
         const wd = this._workingDirectory || process.cwd();
         let reconciled = [];
         try {
           reconciled = reconcilePlan(todos, [], { workingDir: wd });
         } catch {
         }
-        const recentFailures = Array.from(this._failureReflections.entries()).map(([stem, entry]) => ({
-          stem,
-          attempts: entry.attempts,
-          preview: (entry.wentWrong || "").slice(0, 200)
-        })).sort((a2, b) => b.attempts - a2.attempts).slice(0, 5);
+        const recentFailures = [];
+        const activeEpochToolLog = toolCallLog.filter((entry) => typeof entry.turn === "number" && entry.turn >= this._taskEpochStartTurn);
         const toCriticEvidence = (entries, limit) => entries.filter((entry) => entry.name !== "task_complete").slice(-limit).map((entry) => ({
           name: entry.name,
           argsKey: entry.argsKey.slice(0, 300),
@@ -593440,9 +593799,7 @@ ${_checks}`
           turn: entry.turn,
           mutated: entry.mutated === true
         }));
-        const criticToolEvidence = toCriticEvidence(toolCallLog, 40);
-        const lastCritique = this._lastBackwardPassCritique;
-        const evidenceSincePriorCritique = lastCritique ? toCriticEvidence(toolCallLog.slice(lastCritique.toolLogLength), 20) : [];
+        const criticToolEvidence = toCriticEvidence(activeEpochToolLog, 40);
         const completionContract = this._completionContractForClaims(proposedSummary);
         const openLoops = [
           ...todos.filter((todo) => todo.status !== "completed" && todo.status !== "blocked").slice(0, 12).map((todo) => `todo still ${todo.status}: ${todo.content}`),
@@ -593451,7 +593808,7 @@ ${_checks}`
         const modifiedFileDigest = (() => {
           const seen = /* @__PURE__ */ new Set();
           const files = [];
-          for (const entry of toolCallLog) {
+          for (const entry of activeEpochToolLog) {
             if (!Array.isArray(entry.mutatedFiles))
               continue;
             for (const filePath of entry.mutatedFiles) {
@@ -593492,20 +593849,13 @@ ${_checks}`
             ].join("\n\n");
           }
         }
-        const reviewReconciliation = lastCritique ? {
-          previousVerdict: lastCritique.verdict,
-          previousRationale: lastCritique.rationale,
-          previousFeedback: lastCritique.feedback,
-          previousCompletionSummary: lastCritique.completionSummary,
-          previousCycle: lastCritique.cycle,
-          recordedAtIso: lastCritique.recordedAtIso,
-          evidenceSincePreviousReview: evidenceSincePriorCritique
-        } : void 0;
+        const reviewReconciliation = void 0;
+        const activeWorkboard = this._currentWorkboardSnapshotForFrame();
         let result;
         try {
           result = await runBackwardPass({
             workingDir: wd,
-            goal: this._taskState.originalGoal || this._taskState.goal || "",
+            goal: this._taskState.goal || this._taskState.originalGoal || "",
             planStatus: reconciled.map((t2) => ({
               id: t2.id,
               content: t2.content,
@@ -593518,9 +593868,9 @@ ${_checks}`
             completionScenarioDecomposition: _ledgerScenarioDecomposition,
             reviewReconciliation,
             openLoops,
-            workboardSynthesisContext: this._workboard ? (() => {
+            workboardSynthesisContext: activeWorkboard ? (() => {
               try {
-                return buildWorkboardSynthesisContext(this._workboard).excludedUnverifiedCardIds.length > 0 ? `Verified: ${this._workboard.cards.filter((c9) => c9.status === "verified").length}, Unverified remaining: ${this._workboard.cards.filter((c9) => c9.status !== "verified").length}, Blockers: ${this._workboard.cards.filter((c9) => c9.status === "blocked" || c9.status === "needs_changes").length}` : void 0;
+                return buildWorkboardSynthesisContext(activeWorkboard).excludedUnverifiedCardIds.length > 0 ? `Verified: ${activeWorkboard.cards.filter((c9) => c9.status === "verified").length}, Unverified remaining: ${activeWorkboard.cards.filter((c9) => c9.status !== "verified").length}, Blockers: ${activeWorkboard.cards.filter((c9) => c9.status === "blocked" || c9.status === "needs_changes").length}` : void 0;
               } catch {
                 return void 0;
               }
@@ -593529,35 +593879,23 @@ ${_checks}`
             maxFiles: parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_FILES"] || "60", 10) || 60,
             maxFilePreviewBytes: parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_FILE_PREVIEW"] || "8000", 10) || 8e3,
             explicitFiles: modifiedFileDigest.length > 0 ? modifiedFileDigest.map((file) => file.path) : void 0,
+            explicitFilesOnly: true,
             cycle: this._backwardPassCyclesUsed,
             maxCycles
           });
         } catch (e2) {
           const reason = `backward-pass runner failed: ${e2 instanceof Error ? e2.message : String(e2)}`;
-          this._completionIncompleteVerification = {
-            reason,
-            summary: [
-              "INCOMPLETE_VERIFICATION: backward-pass review could not verify completion.",
-              "",
-              `Attempted summary: ${proposedSummary || "(no summary)"}`,
-              "",
-              "Not verified / blocked:",
-              reason,
-              "",
-              "Evidence:",
-              completionScenarioDecomposition
-            ].join("\n")
-          };
-          this._focusSupervisor?.markTerminalIncomplete(reason, turn);
+          this._completionCaveat = [
+            this._completionCaveat || "",
+            `[BACKWARD-PASS ADVISORY] ${reason}`,
+            "Completion authority remains with deterministic verifier and current completion-ledger evidence."
+          ].filter(Boolean).join("\n");
           this.emit({
             type: "status",
-            content: `REG-47 backward-pass runner threw: ${e2 instanceof Error ? e2.message : String(e2)}. Ending as incomplete_verification instead of completing.`,
+            content: `Backward-pass review unavailable; preserved as advisory telemetry: ${reason}`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
-          return {
-            proceed: false,
-            feedback: "Backward-pass review failed before completion could be verified. Report incomplete_verification rather than claiming success."
-          };
+          return { proceed: true, feedback: this._completionCaveat };
         }
         this._backwardPassCyclesUsed++;
         this._lastBackwardPassVerdict = result.verdict.verdict;
@@ -593579,7 +593917,15 @@ ${_checks}`
           return { proceed: true };
         }
         const feedback = result.feedbackMessage;
-        if (this._completionLedger) {
+        const currentArtifactPaths = modifiedFileDigest.map((file) => file.path.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase());
+        const criticReferencesCurrentArtifact = result.verdict.issues.some((issue) => {
+          const issueText = [issue.file, issue.problem, issue.suggested_fix].filter((value2) => typeof value2 === "string").join(" ").replace(/\\/g, "/").toLowerCase();
+          return currentArtifactPaths.some((path16) => {
+            const basename46 = path16.slice(path16.lastIndexOf("/") + 1);
+            return issueText.includes(path16) || basename46.length > 0 && issueText.includes(basename46);
+          });
+        });
+        if (this._completionLedger && criticReferencesCurrentArtifact) {
           this._completionLedger = recordCompletionCritique(this._completionLedger, {
             verdict: result.verdict.verdict === "blocked" ? "blocked" : "request_changes",
             rationale: result.verdict.rationale,
@@ -593587,16 +593933,18 @@ ${_checks}`
           });
           this._saveCompletionLedgerSafe();
         }
-        this._lastBackwardPassCritique = {
-          verdict: result.verdict.verdict,
-          rationale: result.verdict.rationale,
-          feedback,
-          completionSummary: proposedSummary,
-          cycle: this._backwardPassCyclesUsed,
-          toolLogLength: toolCallLog.length,
-          recordedAtIso: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        if (result.verdict.verdict === "blocked") {
+        if (criticReferencesCurrentArtifact) {
+          this._lastBackwardPassCritique = {
+            verdict: result.verdict.verdict,
+            rationale: result.verdict.rationale,
+            feedback,
+            completionSummary: proposedSummary,
+            cycle: this._backwardPassCyclesUsed,
+            toolLogLength: toolCallLog.length,
+            recordedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        if (result.verdict.verdict === "blocked" && criticReferencesCurrentArtifact) {
           const reason = `backward-pass critic blocked completion: ${result.verdict.rationale.slice(0, 240)}`;
           this._completionIncompleteVerification = {
             reason,
@@ -593619,6 +593967,19 @@ ${_checks}`
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
+        if (!criticReferencesCurrentArtifact) {
+          this._completionCaveat = [
+            this._completionCaveat || "",
+            `[BACKWARD-PASS ADVISORY] ${result.verdict.verdict}: ${result.verdict.rationale.slice(0, 600)}`,
+            "The critic named no current-epoch artifact; current verifier and completion-ledger evidence remain authoritative."
+          ].filter(Boolean).join("\n");
+          this.emit({
+            type: "status",
+            content: `Backward-pass ${result.verdict.verdict} retained as advisory: no current artifact was referenced.`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return { proceed: true, feedback: this._completionCaveat };
+        }
         return { proceed: false, feedback };
       }
       /**
@@ -596198,6 +596559,20 @@ ${blob}
           if (covered)
             return cov.fingerprint;
         }
+        if (!iv.whole && Number.isFinite(iv.end)) {
+          let best = null;
+          const requestedLength = Math.max(1, iv.end - iv.start + 1);
+          for (const cov of intervals) {
+            if (cov.whole || !Number.isFinite(cov.end))
+              continue;
+            const overlap = Math.max(0, Math.min(iv.end, cov.end) - Math.max(iv.start, cov.start) + 1);
+            if (overlap / requestedLength >= 0.8 && (!best || overlap > best.overlap)) {
+              best = { fingerprint: cov.fingerprint, overlap };
+            }
+          }
+          if (best)
+            return best.fingerprint;
+        }
         return exactFingerprint;
       }
       /** Register a read's region under the fingerprint that cached its result. */
@@ -596839,7 +597214,7 @@ Rewrite it now for ${ctx3.model}.`;
             inlineTokens: 0,
             reservations: /* @__PURE__ */ new Map()
           };
-          const preempted = await this._preemptFileReadWithBranch({
+          const extracted = await this._extractFileReadEvidence({
             callId,
             toolName: resolved.name,
             args,
@@ -596847,8 +597222,8 @@ Rewrite it now for ${ctx3.model}.`;
             turn: this._taskState.toolCallCount,
             batchBudget
           });
-          if (preempted)
-            return preempted;
+          if (extracted)
+            return extracted;
           let result = await tool.execute(args);
           result = await this._guardMaterializedFileReadResult({
             callId,
@@ -596902,7 +597277,7 @@ ${notice}`;
           content,
           source: "legacy-injectUserMessage",
           receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          intent: "append",
+          intent: classifySteeringIntent(content, "append"),
           state: "received",
           taskEpoch: this._taskEpoch || void 0
         });
@@ -596921,6 +597296,7 @@ ${notice}`;
           content,
           source: input.source || "unknown",
           receivedAt: input.receivedAt || now2,
+          intent: classifySteeringIntent(content, input.intent),
           state: "received",
           taskEpoch: input.taskEpoch ?? (this._taskEpoch || void 0)
         };
@@ -596931,15 +597307,43 @@ ${notice}`;
           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 (steeringGatesOldPlan(record.intent)) {
+          this._activeSteering = {
+            input: record,
+            appliedTurn: this._currentSteeringTurn,
+            requiresReconciliation: true,
+            gatesOldPlan: true,
+            visibleRequestTurns: []
+          };
+        }
         if (record.intent === "redirect" || record.intent === "replace" || record.intent === "cancel") {
           this._requestSteeringPreemption(record);
         }
         this._trajectoryDirtyCauses.add("user_steering");
         return this._steeringReceipt(record);
       }
+      /**
+       * Request safe-boundary preemption for an already accepted typed input.
+       * Frontends use this after delivery so cancellation reaches an in-flight
+       * request without fabricating a second, disconnected runner.
+       */
+      requestSteeringPreemption(inputId) {
+        const normalizedInputId = inputId.trim();
+        if (!normalizedInputId)
+          return null;
+        const record = this.pendingSteeringInputs.find((candidate) => candidate.inputId === normalizedInputId);
+        if (!record)
+          return null;
+        if (record.intent !== "redirect" && record.intent !== "replace" && record.intent !== "cancel") {
+          return null;
+        }
+        if (this._pendingSteeringPreemption?.inputId !== record.inputId) {
+          this._requestSteeringPreemption(record);
+        }
+        return this._steeringReceipt(record);
+      }
       /** Inject bounded runtime guidance without treating it as user steering. */
       injectRuntimeGuidance(content) {
         this.enqueueRuntimeGuidance(content);
@@ -596962,18 +597366,15 @@ ${notice}`;
       /** Retract the last pending user message (Esc cancel).
        *  Returns the retracted text, or null if queue is empty or already consumed. */
       retractLastPendingMessage() {
-        if (this.pendingUserMessages.length === 0)
+        const record = [...this.pendingSteeringInputs].reverse().find((candidate) => candidate.state === "queued" || candidate.state === "acknowledged");
+        if (!record)
           return null;
-        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");
+        record.state = "cancelled";
+        if (this._pendingSteeringPreemption?.inputId === record.inputId) {
+          this._pendingSteeringPreemption = null;
         }
-        return content;
+        this._emitSteeringLifecycle(record, "retracted before admission at a safe boundary");
+        return record.content;
       }
       /** Abort the current task run — cancels in-flight requests and kills child processes */
       abort() {
@@ -597036,6 +597437,16 @@ ${notice}`;
           steering: receipt,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
+        this._onTypedEvent?.({
+          type: "steering_lifecycle",
+          runId: this.currentArtifactRunId(),
+          inputId: record.inputId,
+          intent: record.intent,
+          state: record.state,
+          taskEpoch: record.taskEpoch,
+          summary: reason,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
         appendSteeringLedgerEntry(this._workingDirectory || process.cwd(), {
           type: "lifecycle",
           packetId: record.inputId,
@@ -597070,9 +597481,6 @@ ${notice}`;
           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;
@@ -597106,13 +597514,31 @@ ${notice}`;
           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);
+      _activateSteering(record, turn) {
+        const requiresReconciliation = steeringRequiresReconciliation(record.intent);
+        const gatesOldPlan = steeringGatesOldPlan(record.intent);
+        const prior = this._activeSteering;
+        if (prior && prior.input.inputId !== record.inputId && !prior.reconciliation && (record.intent === "redirect" || record.intent === "replace")) {
+          prior.input.state = "superseded";
+          this._emitSteeringLifecycle(prior.input, `superseded by ${record.intent} ${record.inputId}`);
+        }
+        this._activeSteering = {
+          input: record,
+          appliedTurn: turn,
+          requiresReconciliation,
+          gatesOldPlan,
+          visibleRequestTurns: []
+        };
+        if (requiresReconciliation) {
+          record.state = "reconciliation_required";
+          this._emitSteeringLifecycle(record, gatesOldPlan ? `admitted at turn ${turn}; old-plan actions are gated pending structured reconciliation` : `admitted at turn ${turn}; awaiting structured reconciliation`);
+        }
       }
       _canonicalReadEvidencePayload(canonicalPath, contentHash2) {
         const branch = this._branchEvidenceByPath.get(canonicalPath);
-        if (branch && branch.contentHash === contentHash2)
+        if (branch && branch.contentHash === contentHash2 && branch.taskEpoch === this._taskEpoch) {
           return branch.output;
+        }
         return null;
       }
       _rehydrateResolvedReadEvidence(input) {
@@ -597162,38 +597588,45 @@ ${notice}`;
       }
       async _drainPendingSteeringMessages(messages2, turn) {
         this.drainPendingRuntimeGuidance(turn);
-        while (this.pendingUserMessages.length > 0) {
-          const userMsg = this.pendingUserMessages.shift();
-          const record = this._steeringRecordForContent(userMsg);
+        const pending2 = this.pendingSteeringInputs.filter((record) => (record.state === "queued" || record.state === "acknowledged") && (!record.taskEpoch || record.taskEpoch === this._taskEpoch));
+        for (const record of pending2) {
           const replacement = this._pendingSteeringPreemption;
-          if (replacement?.intent === "replace" && record && record.inputId !== replacement.inputId) {
+          if (replacement?.intent === "replace" && 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}`);
-          }
+          await this.appendInjectedUserMessage(record.content, messages2, turn);
+          this._activateSteering(record, turn);
+        }
+        while (this.pendingUserMessages.length > 0) {
+          await this.appendInjectedUserMessage(this.pendingUserMessages.shift(), messages2, turn);
         }
       }
-      /** Apply a preemption only at a safe boundary after its user content is visible. */
-      _applyPendingSteeringPreemption(messages2, turn) {
+      /**
+       * The only legal steering boundary for every runner loop.  It materializes
+       * typed input, applies epoch preemption, and deliberately never equates
+       * transcript insertion with model acknowledgement.
+       */
+      async _applySteeringAtSafeBoundary(messages2, turn) {
+        this._currentSteeringTurn = turn;
+        await this._drainPendingSteeringMessages(messages2, turn);
         const record = this._pendingSteeringPreemption;
         if (!record)
-          return false;
+          return "continue";
         this._pendingSteeringPreemption = null;
         if (record.intent === "cancel") {
           record.state = "cancelled";
           this._emitSteeringLifecycle(record, `cancelled active task at turn ${turn}`);
           this.abort();
-          return true;
+          return "abort";
         }
         const previousEpoch = this._taskEpoch;
         this._archiveSupersededTaskState(previousEpoch, record);
         this._allowImplicitContinuation = false;
         this._taskEpoch += 1;
+        this._taskEpochStartTurn = turn;
+        this._focusSupervisor?.setTaskEpoch(this._taskEpoch, turn);
         record.taskEpoch = this._taskEpoch;
         if (record.intent === "replace") {
           for (const candidate of this.pendingSteeringInputs) {
@@ -597217,19 +597650,155 @@ ${notice}`;
         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;
+        this._activateSteering(record, turn);
+        this._emitSteeringLifecycle(record, `epoch transition applied at turn ${turn}; ${previousEpoch} -> ${this._taskEpoch}`);
+        return "restart";
+      }
+      /** A single late, protected steering slot rendered for every request until acknowledgement. */
+      _renderActiveSteeringSlot() {
+        const active = this._activeSteering;
+        if (!active)
+          return null;
+        const { input, reconciliation } = active;
+        if (reconciliation && reconciliation.status !== "needs_clarification") {
+          return null;
+        }
+        const needsClarification = reconciliation?.status === "needs_clarification";
+        return [
+          "[ACTIVE USER STEERING]",
+          `input_id=${input.inputId}`,
+          `task_epoch=${input.taskEpoch ?? this._taskEpoch}`,
+          `kind=${input.intent}`,
+          `admission=${active.gatesOldPlan ? "old_plan_gated" : "context_active"}`,
+          "This is current user authority, not historical transcript context.",
+          input.intent === "redirect" || input.intent === "replace" ? "The prior task epoch is historical evidence only. Do not continue its plan, todos, recovery cards, or completion contract." : null,
+          needsClarification ? "You requested clarification. Do not call tools or resume the old plan; ask the user one concise question." : active.requiresReconciliation ? [
+            "Before any tool call, respond with exactly one structured reconciliation and no tool calls in that response:",
+            "[STEERING_RECONCILIATION]",
+            JSON.stringify({
+              inputId: input.inputId,
+              status: "applied | not_applicable | needs_clarification",
+              changedConstraints: ["concrete constraint or []"],
+              revisedNextAction: "one concrete next action"
+            }),
+            "[/STEERING_RECONCILIATION]"
+          ].join("\n") : null,
+          "User instruction:",
+          input.content.slice(0, 6e3),
+          "[/ACTIVE USER STEERING]"
+        ].filter(Boolean).join("\n");
+      }
+      _markActiveSteeringVisible(turn) {
+        const active = this._activeSteering;
+        if (!active || active.reconciliation || active.visibleRequestTurns.includes(turn))
+          return;
+        active.visibleRequestTurns.push(turn);
+        active.input.state = "visible_in_request";
+        this._emitSteeringLifecycle(active.input, `visible in model request at turn ${turn}`);
+      }
+      _firstJsonObject(text2) {
+        const start2 = text2.indexOf("{");
+        if (start2 < 0)
+          return null;
+        let depth = 0;
+        let quoted = false;
+        let escaped = false;
+        for (let index = start2; index < text2.length; index++) {
+          const char = text2[index];
+          if (quoted) {
+            if (escaped)
+              escaped = false;
+            else if (char === "\\")
+              escaped = true;
+            else if (char === '"')
+              quoted = false;
+            continue;
+          }
+          if (char === '"')
+            quoted = true;
+          else if (char === "{")
+            depth++;
+          else if (char === "}") {
+            depth--;
+            if (depth === 0)
+              return text2.slice(start2, index + 1);
+          }
+        }
+        return null;
+      }
+      /** Parse and validate the model's explicit acknowledgement, never a vague textual mention. */
+      _reconcileActiveSteeringFromModel(content, turn) {
+        const active = this._activeSteering;
+        if (!active || !active.requiresReconciliation || !content)
+          return false;
+        const tagged = content.match(/\[STEERING_RECONCILIATION\]([\s\S]*?)(?:\[\/STEERING_RECONCILIATION\]|$)/i);
+        if (!tagged)
+          return false;
+        const candidate = this._firstJsonObject(tagged[1] ?? "");
+        if (!candidate)
+          return false;
+        try {
+          const parsed = JSON.parse(candidate);
+          const status = parsed["status"];
+          const inputId = parsed["inputId"];
+          if (inputId !== active.input.inputId || status !== "applied" && status !== "not_applicable" && status !== "needs_clarification") {
+            return false;
+          }
+          const changedConstraints = Array.isArray(parsed["changedConstraints"]) ? parsed["changedConstraints"].filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean).slice(0, 12) : [];
+          const revisedNextAction = typeof parsed["revisedNextAction"] === "string" ? parsed["revisedNextAction"].trim().slice(0, 1e3) : "";
+          if (!revisedNextAction)
+            return false;
+          active.reconciliation = {
+            inputId: active.input.inputId,
+            status,
+            changedConstraints,
+            revisedNextAction
+          };
+          active.reconciledTurn = turn;
+          active.requiresReconciliation = status === "needs_clarification";
+          active.gatesOldPlan = status === "needs_clarification";
+          this._taskState.nextAction = revisedNextAction;
+          if (changedConstraints.length > 0) {
+            this._taskState.steeringConstraints = [
+              .../* @__PURE__ */ new Set([...this._taskState.steeringConstraints ?? [], ...changedConstraints])
+            ].slice(-20);
+          }
+          active.input.state = "reconciled";
+          this._emitSteeringLifecycle(active.input, `reconciled by model at turn ${turn}: ${status}`);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      _steeringToolGate(turn) {
+        const active = this._activeSteering;
+        if (!active || !active.gatesOldPlan)
+          return null;
+        if (!active.reconciliation) {
+          return `[STEERING_RECONCILIATION_REQUIRED]
+input_id=${active.input.inputId}
+Do not execute the old-plan tool call. First emit the exact [STEERING_RECONCILIATION] JSON required by ACTIVE USER STEERING.`;
+        }
+        if (active.reconciliation.status === "needs_clarification") {
+          return `[STEERING_CLARIFICATION_REQUIRED]
+input_id=${active.input.inputId}
+The model requested user clarification. Do not execute tools or resume the old plan.`;
+        }
+        if (active.reconciledTurn === turn) {
+          return `[STEERING_REPLAN_TURN_REQUIRED]
+input_id=${active.input.inputId}
+The steering reconciliation was emitted this turn. Wait for the next model decision before executing a tool.`;
+        }
+        return null;
+      }
+      _markFirstSteeringAffectedAction(toolName, turn) {
+        const active = this._activeSteering;
+        if (!active || !active.reconciliation || active.reconciliation.status === "needs_clarification" || active.firstAffectedAction || active.reconciledTurn === turn) {
+          return;
+        }
+        active.firstAffectedAction = { toolName, turn };
+        active.input.state = "first_affected_action";
+        this._emitSteeringLifecycle(active.input, `first affected action ${toolName} started at turn ${turn}`);
       }
       /**
        * Pause the current task gracefully. The run loop will suspend at the next
@@ -597424,12 +597993,13 @@ ${notice}`;
         }
       }
       /**
-       * Mandatory pre-dispatch router for local file reads. It resolves exactly
-       * once against the authoritative run directory, computes the actual selected
-       * range, and intercepts unsafe reads before registered tool code or any
-       * transcript/evidence consumer can observe raw content.
+       * Mandatory on-read extraction path for local file reads. It resolves
+       * exactly once against the authoritative run directory, creates an isolated
+       * inference frame when the selected range cannot safely enter the parent
+       * context, and returns only the verified evidence frame. Registered tool
+       * code and parent transcript consumers never observe the raw oversized body.
        */
-      async _preemptFileReadWithBranch(input) {
+      async _extractFileReadEvidence(input) {
         if (this.lookupRegisteredTool(input.toolName)?.name !== "file_read") {
           return null;
         }
@@ -597487,7 +598057,8 @@ ${notice}`;
         });
         const contractFingerprint = _createHash("sha256").update(JSON.stringify(branchBrief.discoveryContract ?? branchBrief)).digest("hex").slice(0, 20);
         const canonicalPath = this._normalizeEvidencePath(rawPath);
-        const cacheKey = `${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`;
+        const branchRequestId = `branch:${this._taskEpoch}:${_createHash("sha256").update(`${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`).digest("hex").slice(0, 20)}`;
+        const cacheKey = `${this._taskEpoch}|${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`;
         const cached2 = this._branchEvidenceCache.get(cacheKey);
         if (cached2) {
           const fingerprint = this._buildToolFingerprint(input.toolName, input.args);
@@ -597516,6 +598087,17 @@ ${notice}`;
               branchSourceBytes: cached2.sourceBytes,
               branchCacheHit: true,
               fingerprintState: "resolved_from_cache"
+            },
+            branchEvidence: {
+              schema: "omnius.branch-evidence.v1",
+              requestId: cached2.requestId,
+              taskEpoch: this._taskEpoch,
+              path: canonicalPath,
+              contentHash: fullHash,
+              sourceRange: {
+                startLine: startIndex + 1,
+                endLine: startIndex + Math.max(1, selectedLines.length)
+              }
             }
           };
         }
@@ -597533,6 +598115,7 @@ ${notice}`;
         });
         const verboseOutput = [
           `[BRANCH-EXTRACT v2] path=${rawPath}`,
+          `[VERIFIED_RUNTIME_FILE_READ] request_id=${branchRequestId} task_epoch=${this._taskEpoch}`,
           `routing=mandatory reasons=${decision2.reasons.join(",")} projected_read_tokens=${decision2.projectedReadTokens} fraction_limit_tokens=${decision2.fractionLimitTokens} available_headroom_tokens=${decision2.availableHeadroomTokens}`,
           `source=sha256:${fullHash} selected_lines=${selectedLines.length} selected_bytes=${selectedBytes}${hasRange ? ` range=${offset ?? 1}:${limit ?? "EOF"}` : " range=whole"}`,
           `[DISCOVERY CONTRACT]`,
@@ -597554,6 +598137,7 @@ ${notice}`;
           const required = (branchBrief.discoveryContract?.requirements ?? []).filter((requirement) => requirement.required).map((requirement) => `${requirement.id}:${requirement.question.slice(0, 180)}`).join(" | ");
           const prefix = [
             `[BRANCH-EXTRACT v2] path=${rawPath} sha256=${fullHash}`,
+            `[VERIFIED_RUNTIME_FILE_READ] request_id=${branchRequestId} task_epoch=${this._taskEpoch}`,
             `routing=${decision2.reasons.join(",")} projected=${decision2.projectedReadTokens}/${contextWindow}t limit=${decision2.fractionLimitTokens}t`,
             `[DISCOVERY CONTRACT] required=${required || "next narrow file-local fact"}`,
             `[CURATED SEGMENTS]`
@@ -597573,17 +598157,20 @@ ${suffix}`.slice(0, outputBudgetChars);
           path: canonicalPath,
           contentHash: fullHash,
           sourceBytes: stat9.size,
-          createdAt: Date.now()
+          createdAt: Date.now(),
+          taskEpoch: this._taskEpoch,
+          requestId: branchRequestId
         });
         this._branchEvidenceByPath.set(canonicalPath, {
           output,
           contentHash: fullHash,
-          mtimeMs: stat9.mtimeMs
+          mtimeMs: stat9.mtimeMs,
+          taskEpoch: this._taskEpoch
         });
         this.emit({
           type: "status",
           toolName: input.toolName,
-          content: `Branch-extract preempted ${rawPath}: ${decision2.projectedReadTokens}/${contextWindow} projected tokens (${(decision2.projectedFraction * 100).toFixed(1)}%); resident=${residentTokens}t reserve=${reservedTokens}t pending_reads=${input.batchBudget.inlineTokens}t; ${selectedBytes}B → ${output.length} curated chars; reasons=${decision2.reasons.join(",")}`,
+          content: `Branch extraction executed for file_read ${rawPath}: ${decision2.projectedReadTokens}/${contextWindow} projected tokens (${(decision2.projectedFraction * 100).toFixed(1)}%); resident=${residentTokens}t reserve=${reservedTokens}t pending_reads=${input.batchBudget.inlineTokens}t; ${selectedBytes}B → ${output.length} curated chars; reasons=${decision2.reasons.join(",")}`,
           turn: input.turn,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
@@ -597599,6 +598186,17 @@ ${suffix}`.slice(0, outputBudgetChars);
             branchSourceBytes: stat9.size,
             branchSelectedBytes: selectedBytes,
             branchProjectedTokens: decision2.projectedReadTokens
+          },
+          branchEvidence: {
+            schema: "omnius.branch-evidence.v1",
+            requestId: branchRequestId,
+            taskEpoch: this._taskEpoch,
+            path: canonicalPath,
+            contentHash: fullHash,
+            sourceRange: {
+              startLine: startIndex + 1,
+              endLine: startIndex + Math.max(1, selectedLines.length)
+            }
           }
         };
       }
@@ -597658,6 +598256,7 @@ ${suffix}`.slice(0, outputBudgetChars);
         });
         const output = [
           `[BRANCH-EXTRACT v2] path=${path16}`,
+          `[VERIFIED_RUNTIME_FILE_READ] request_id=branch:${this._taskEpoch}:${input.callId} task_epoch=${this._taskEpoch}`,
           `routing=post-execution-failsafe reasons=${decision2.reasons.join(",")} projected_read_tokens=${decision2.projectedReadTokens}`,
           `[DISCOVERY CONTRACT] ${brief.request}`,
           `[CURATED SEGMENTS]`,
@@ -597676,6 +598275,17 @@ ${suffix}`.slice(0, outputBudgetChars);
             branchSourceBytes: Buffer.byteLength(input.result.output, "utf8"),
             branchSelectedBytes: Buffer.byteLength(input.result.output, "utf8"),
             branchProjectedTokens: decision2.projectedReadTokens
+          },
+          branchEvidence: {
+            schema: "omnius.branch-evidence.v1",
+            requestId: `branch:${this._taskEpoch}:${input.callId}`,
+            taskEpoch: this._taskEpoch,
+            path: this._normalizeEvidencePath(path16),
+            contentHash: ev.provenance.contentHash,
+            sourceRange: {
+              startLine: 1,
+              endLine: Math.max(1, lines.length)
+            }
           }
         };
       }
@@ -598373,8 +598983,10 @@ Respond with the assessment and take the selected evidence-backed action.`;
           convergenceBreaker: this._longHaul?.convergenceBreaker ?? null,
           // WO-9: run cwd so shell family keys canonicalize absolute↔relative
           // path form and command variants collapse into one family.
-          cwd: this.authoritativeWorkingDirectory()
+          cwd: this.authoritativeWorkingDirectory(),
+          taskEpoch: this._taskEpoch
         });
+        this._focusSupervisor?.setTaskEpoch(this._taskEpoch);
         if (!this._workingDirectory) {
           this._workingDirectory = _pathResolve(process.cwd());
         }
@@ -599044,6 +599656,7 @@ ${dynamicProjectContext}`
         let lastShellPivotTurn = -1;
         const recentToolResults = /* @__PURE__ */ new Map();
         const exactFileReadObservations = /* @__PURE__ */ new Map();
+        const exactReadEvidenceEpochs = /* @__PURE__ */ new Map();
         let fileMutationEpoch = 0;
         const dedupHitCount = /* @__PURE__ */ new Map();
         const noopedMemoryWriteFingerprints = /* @__PURE__ */ new Set();
@@ -600564,9 +601177,9 @@ Respond with EXACTLY this structure before your next tool call:
               });
             }
           }
-          await this._drainPendingSteeringMessages(messages2, turn);
-          if (this._applyPendingSteeringPreemption(messages2, turn)) {
-            if (this.aborted)
+          const steeringBoundary = await this._applySteeringAtSafeBoundary(messages2, turn);
+          if (steeringBoundary !== "continue") {
+            if (steeringBoundary === "abort" || this.aborted)
               break;
             continue;
           }
@@ -600976,6 +601589,11 @@ ${memoryLines.join("\n")}`
             role: "system",
             content: this._buildRecentActionGroundTruth(turn)
           });
+          const activeSteeringSlot = this._renderActiveSteeringSlot();
+          if (activeSteeringSlot) {
+            requestMessages.push({ role: "system", content: activeSteeringSlot });
+            this._markActiveSteeringVisible(turn);
+          }
           this._retireLinkedAssistantReadIntents(requestMessages);
           const chatRequest = {
             messages: requestMessages,
@@ -601168,7 +601786,6 @@ ${memoryLines.join("\n")}`
                     "After seeing the tool result, continue or call another tool.",
                     'When done, output: {"tool": "task_complete", "args": {"summary": "what you did"}}'
                   ].join("\n");
-                  messages2.push({ role: "system", content: toolInjectMsg });
                   chatRequest.messages = this._prepareModelFacingMessages([
                     ...requestMessages,
                     { role: "system", content: toolInjectMsg }
@@ -601365,6 +601982,7 @@ ${memoryLines.join("\n")}`
           if (!choice)
             break;
           const msg = choice.message;
+          this._reconcileActiveSteeringFromModel(msg.content, turn);
           const isThinkOnly = response._thinkOnly === true;
           const isEmptyResponse = !isThinkOnly && (!msg.content || !msg.content.trim()) && (!msg.toolCalls || msg.toolCalls.length === 0);
           if (isEmptyResponse) {
@@ -601466,6 +602084,18 @@ ${memoryLines.join("\n")}`
             executeSingle = async (tc) => {
               if (this.aborted || this._pendingSteeringPreemption)
                 return null;
+              const steeringGate = this._steeringToolGate(this._currentSteeringTurn);
+              if (steeringGate) {
+                this.emit({
+                  type: "status",
+                  toolName: tc.name,
+                  content: `Tool call gated by active user steering ${this._activeSteering?.input.inputId ?? "unknown"}`,
+                  turn: this._currentSteeringTurn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                return { tc, output: steeringGate, success: false };
+              }
+              this._markFirstSteeringAffectedAction(tc.name, this._currentSteeringTurn);
               const resolvedReadBlock = this._rejectRepeatedResolvedRead(tc, messages2);
               if (resolvedReadBlock) {
                 this.emit({
@@ -602111,7 +602741,48 @@ Read the current file if needed, make a different concrete edit, or move to veri
                 adversaryRedundantSignal
               });
               let repeatShortCircuit = null;
-              if (criticDecision.decision === "guidance") {
+              const exactReadArgs = tc.arguments;
+              const exactReadPath = String(exactReadArgs?.["path"] ?? exactReadArgs?.["file"] ?? "");
+              const exactReadEvidence = exactReadEvidenceEpochs.get(toolFingerprint);
+              const exactReadEvidenceFresh = tc.name === "file_read" && exactReadPath.length > 0 && this._evidenceLedger.validateFreshness(this._normalizeEvidencePath(exactReadPath), this._absoluteToolPath(exactReadPath));
+              if (tc.name === "file_read" && exactReadEvidenceFresh && exactReadEvidence?.taskEpoch === this._taskEpoch && exactReadEvidence.mutationEpoch === fileMutationEpoch) {
+                const path16 = this._normalizeEvidencePath(exactReadPath);
+                const evidence = this._evidenceLedger.get(path16);
+                const rawCurated = this._branchEvidenceByPath.get(path16) ?? [...this._branchEvidenceByPath.entries()].find(([candidate]) => this._normalizeEvidencePath(candidate) === path16)?.[1];
+                const curated = rawCurated?.taskEpoch === this._taskEpoch ? rawCurated : void 0;
+                const curatedPayload = curated?.output ?? (evidence?.fidelity === "extract" && evidence.content.includes("[BRANCH-EXTRACT") ? evidence.content : null);
+                repeatShortCircuit = {
+                  success: true,
+                  output: curatedPayload ? this._rehydrateResolvedReadEvidence({
+                    fingerprint: toolFingerprint,
+                    canonicalPath: path16,
+                    contentHash: curated?.contentHash ?? evidence?.contentHash ?? "unknown",
+                    payload: curatedPayload,
+                    turn
+                  }) : [
+                    ...evidence?.fidelity === "extract" ? [
+                      "[REHYDRATED_FILE_EVIDENCE]",
+                      "source=active_context_frame fidelity=extract"
+                    ] : [],
+                    "[READ EVIDENCE REFERENCE]",
+                    `path=${path16 || "unknown"}`,
+                    `task_epoch=${this._taskEpoch}`,
+                    `freshness=${evidence?.stale ? "stale" : "fresh"}`,
+                    evidence?.contentHash ? `sha256=${evidence.contentHash}` : null,
+                    "Exact unchanged range was not re-executed. Use the existing evidence handle or request a newly uncovered range after identifying the missing fact."
+                  ].filter(Boolean).join("\n"),
+                  runtimeAuthored: true,
+                  noop: true
+                };
+                this.emit({
+                  type: "status",
+                  toolName: tc.name,
+                  content: `Exact unchanged file_read blocked before dispatch: ${path16}`,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+              if (criticDecision.decision === "guidance" && !repeatShortCircuit) {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
                 const _existingFp = recentToolResults.get(toolFingerprint);
                 if (_existingFp !== void 0) {
@@ -602156,12 +602827,14 @@ Read the current file if needed, make a different concrete edit, or move to veri
                 const suppressSuccessfulShellCacheGuidance = tc.name === "shell" && !isFailedShellRepeat;
                 if (suppressSuccessfulShellCacheGuidance)
                   criticGuidance = null;
+                let exactReadEvidenceFresh2 = true;
                 if (isReadLike && this._evidenceLedger) {
                   const readArgs = tc.arguments;
                   const readPath2 = String(readArgs?.["path"] ?? readArgs?.["file"] ?? "");
                   if (readPath2) {
                     const evidencePath = this._normalizeEvidencePath(readPath2);
                     const wasFresh = evidencePath && this._evidenceLedger.validateFreshness(evidencePath, this._absoluteToolPath(readPath2));
+                    exactReadEvidenceFresh2 = Boolean(wasFresh);
                     if (!wasFresh) {
                       recentToolResults.delete(toolFingerprint);
                       dedupHitCount.delete(toolFingerprint);
@@ -602175,7 +602848,42 @@ Read the current file if needed, make a different concrete edit, or move to veri
                     }
                   }
                 }
-                if (repeatGateEligible && _existingFp !== void 0 && _repeatGateMax > 0) {
+                const exactReadEvidence2 = exactReadEvidenceEpochs.get(toolFingerprint);
+                const exactFileReadReference = tc.name === "file_read" && exactReadEvidenceFresh2 && exactReadEvidence2?.taskEpoch === this._taskEpoch && exactReadEvidence2.mutationEpoch === fileMutationEpoch;
+                if (exactFileReadReference) {
+                  const path16 = this._normalizeEvidencePath(String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? ""));
+                  const evidence = this._evidenceLedger?.get(path16);
+                  const rawCurated = this._branchEvidenceByPath.get(path16) ?? [...this._branchEvidenceByPath.entries()].find(([candidate]) => this._normalizeEvidencePath(candidate) === path16)?.[1];
+                  const curated = rawCurated?.taskEpoch === this._taskEpoch ? rawCurated : void 0;
+                  const curatedPayload = curated?.output ?? (evidence?.fidelity === "extract" && evidence.content.includes("[BRANCH-EXTRACT") ? evidence.content : null);
+                  repeatShortCircuit = {
+                    success: true,
+                    // Curated branch output is the bounded authoritative payload
+                    // for this source version. Rehydrate it instead of replacing
+                    // it with a pointer; exact/overlap suppression must not force
+                    // the model to reread a large source merely to recover facts.
+                    output: curatedPayload ? this._rehydrateResolvedReadEvidence({
+                      fingerprint: toolFingerprint,
+                      canonicalPath: path16,
+                      contentHash: curated?.contentHash ?? evidence?.contentHash ?? "unknown",
+                      payload: curatedPayload,
+                      turn
+                    }) : [
+                      ...evidence?.fidelity === "extract" ? [
+                        "[REHYDRATED_FILE_EVIDENCE]",
+                        "source=active_context_frame fidelity=extract"
+                      ] : [],
+                      "[READ EVIDENCE REFERENCE]",
+                      `path=${path16 || "unknown"}`,
+                      `task_epoch=${this._taskEpoch}`,
+                      `freshness=${evidence?.stale ? "stale" : "fresh"}`,
+                      evidence?.contentHash ? `sha256=${evidence.contentHash}` : null,
+                      "Exact unchanged range was not re-executed. Use the existing evidence handle or request a newly uncovered range after identifying the missing fact."
+                    ].filter(Boolean).join("\n"),
+                    runtimeAuthored: true,
+                    noop: true
+                  };
+                } else if (repeatGateEligible && _existingFp !== void 0 && _repeatGateMax > 0) {
                   const _rehydrateArgs = tc.arguments;
                   const _rehydratePath = String(_rehydrateArgs?.["path"] ?? _rehydrateArgs?.["file"] ?? "");
                   const _visibleViaEvidenceFrame = _rehydratePath.length > 0 && (this._evidenceLedger?.renderedFullInLastBlock(this._normalizeEvidencePath(_rehydratePath)) ?? false);
@@ -602256,7 +602964,8 @@ ${cachedResult}`,
                 cachedResultFailed: tc.name === "shell" && typeof focusCachedEntry?.result === "string" && focusCachedEntry.result.includes("status: failure"),
                 duplicateHitCount: focusDuplicateHits,
                 context: this._buildFocusContextSnapshot(),
-                usesAuthoritativeTargetEvidence
+                usesAuthoritativeTargetEvidence,
+                taskEpoch: this._taskEpoch
               });
               if (focusDecision && focusDecision.kind !== "pass") {
                 this._emitFocusSupervisorEvent({
@@ -602478,7 +603187,7 @@ ${cachedResult}`,
                         try {
                           tc.arguments = finalArgs;
                           const normalizedDispatchName = resolvedTool?.name ?? tc.name;
-                          let branchPreempted = null;
+                          let branchEvidenceResult = null;
                           if (normalizedDispatchName === "file_read") {
                             const exactReadKey = this._buildToolFingerprint("file_read", tc.arguments);
                             const priorRead = exactFileReadObservations.get(exactReadKey);
@@ -602495,7 +603204,7 @@ ${cachedResult}`,
                                     payload: canonicalPayload,
                                     turn
                                   });
-                                  branchPreempted = {
+                                  branchEvidenceResult = {
                                     success: true,
                                     output: rehydrated,
                                     llmContent: rehydrated,
@@ -602522,7 +603231,7 @@ ${cachedResult}`,
                                       `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 = {
+                                    branchEvidenceResult = {
                                       success: true,
                                       output: fallbackBlocked,
                                       llmContent: fallbackBlocked,
@@ -602555,8 +603264,8 @@ ${cachedResult}`,
                               }
                             }
                           }
-                          if (!branchPreempted) {
-                            branchPreempted = await this._preemptFileReadWithBranch({
+                          if (!branchEvidenceResult) {
+                            branchEvidenceResult = await this._extractFileReadEvidence({
                               callId: tc.id,
                               toolName: normalizedDispatchName,
                               args: tc.arguments,
@@ -602565,8 +603274,8 @@ ${cachedResult}`,
                               batchBudget: branchReadBatchBudget
                             });
                           }
-                          if (branchPreempted) {
-                            result = branchPreempted;
+                          if (branchEvidenceResult) {
+                            result = branchEvidenceResult;
                             fileReadSafetyChecked = true;
                           } else {
                             if (typeof tool.executeStream === "function") {
@@ -602817,6 +603526,11 @@ ${cachedResult}`,
                       turn,
                       fidelity: result.runtimeAuthored === true && result.output.startsWith("[BRANCH-EXTRACT") ? "extract" : void 0
                     });
+                    exactReadEvidenceEpochs.set(toolFingerprint, {
+                      taskEpoch: this._taskEpoch,
+                      mutationEpoch: fileMutationEpoch
+                    });
+                    this._registerReadCoverage("file_read", tc.arguments, toolFingerprint);
                   }
                   if (this._fileSummaryStore && result.success && result.output && result.output.length > 100) {
                     try {
@@ -603822,6 +604536,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
               this._taskState.toolCallCount++;
               if (realFileMutation) {
                 this._lastFileWriteTurn = turn;
+                this._fileWritesThisRun += Math.max(1, realMutationPaths.length);
                 const writeEvents = Math.max(1, realMutationPaths.length);
                 for (let i2 = 0; i2 < writeEvents; i2++) {
                   this._fileWriteTimestamps.push(Date.now());
@@ -603951,7 +604666,8 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                   noop: tc.name === "todo_write" ? this._isTodoWriteNoopResult(result) : result.noop,
                   alreadyApplied: result.alreadyApplied === true,
                   runtimeAuthored: result.runtimeAuthored === true,
-                  usedAuthoritativeTargetEvidence: usesAuthoritativeTargetEvidence
+                  usedAuthoritativeTargetEvidence: usesAuthoritativeTargetEvidence,
+                  taskEpoch: this._taskEpoch
                 });
                 const focusSnapshotAfter = this._focusSupervisor?.snapshot();
                 focusAfterToolResult = focusSnapshotAfter ?? void 0;
@@ -604870,9 +605586,7 @@ Only call task_complete when the task is actually complete and the evidence is f
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
-            const pendingBeforeAdversary = this.pendingUserMessages.length;
             this.adversaryObserve(messages2, turn);
-            const adversaryAddedGuidance = this.pendingUserMessages.length > pendingBeforeAdversary;
             if (/task.?complete|all tests pass/i.test(content)) {
               const completionArgs = { summary: content };
               if (holdTaskCompleteGates(completionArgs, turn)) {
@@ -604932,13 +605646,6 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
                   role: "system",
                   content: this._textEchoGuard.buildIntervention(echoObs)
                 });
-                if (adversaryAddedGuidance) {
-                  this.drainPendingRuntimeGuidance(turn);
-                  while (this.pendingUserMessages.length > 0) {
-                    const userMsg = this.pendingUserMessages.shift();
-                    await this.appendInjectedUserMessage(userMsg, messages2, turn);
-                  }
-                }
                 continue;
               }
             }
@@ -604971,6 +605678,18 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
                 }
                 const shellTool = this.tools.get("shell");
                 if (shellTool) {
+                  const steeringGate = this._steeringToolGate(this._currentSteeringTurn);
+                  if (steeringGate) {
+                    messages2.push({ role: "system", content: steeringGate });
+                    this.emit({
+                      type: "status",
+                      content: "Narrated shell code block blocked by active user steering",
+                      turn,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                    continue;
+                  }
+                  this._markFirstSteeringAffectedAction("shell", this._currentSteeringTurn);
                   this.emit({
                     type: "status",
                     content: `Auto-executing code block: ${shellCommands.slice(0, 80)}...`,
@@ -605032,13 +605751,6 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
                 content: "Continue working. Use tools to read files, make changes, and run validation. Call task_complete when done."
               });
             }
-            if (adversaryAddedGuidance) {
-              this.drainPendingRuntimeGuidance(turn);
-              while (this.pendingUserMessages.length > 0) {
-                const userMsg = this.pendingUserMessages.shift();
-                await this.appendInjectedUserMessage(userMsg, messages2, turn);
-              }
-            }
           }
           try {
             const turnLogTail = toolCallLog.filter((t2) => t2.turn === turn || t2.turn === void 0);
@@ -605195,10 +605907,11 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               });
               nextSelfEval = bfNow + selfEvalInterval;
             }
-            this.drainPendingRuntimeGuidance(turn);
-            while (this.pendingUserMessages.length > 0) {
-              const userMsg = this.pendingUserMessages.shift();
-              await this.appendInjectedUserMessage(userMsg, messages2, turn);
+            const steeringBoundary = await this._applySteeringAtSafeBoundary(messages2, turn);
+            if (steeringBoundary !== "continue") {
+              if (steeringBoundary === "abort" || this.aborted)
+                break;
+              continue;
             }
             let compactedMsgs;
             if (this._pendingCompaction) {
@@ -605234,6 +605947,11 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               role: "system",
               content: this._buildRecentActionGroundTruth(turn)
             });
+            const activeSteeringSlot = this._renderActiveSteeringSlot();
+            if (activeSteeringSlot) {
+              modelFacingMessages.push({ role: "system", content: activeSteeringSlot });
+              this._markActiveSteeringVisible(turn);
+            }
             const chatRequest = {
               messages: modelFacingMessages,
               tools: toolDefs,
@@ -605358,6 +606076,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             if (!choice)
               break;
             const msg = choice.message;
+            this._reconcileActiveSteeringFromModel(msg.content, turn);
             const isThinkOnlyBF = response._thinkOnly === true;
             if (msg.toolCalls && msg.toolCalls.length > 0) {
               consecutiveTextOnly = 0;
@@ -606566,7 +607285,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("[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);
+        return output.includes("[IMAGE_BASE64:") || /^\[BRANCH-EXTRACT(?:\s+v\d+)?\]/m.test(output) || 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)
@@ -606633,9 +607352,8 @@ ${marker}` : marker);
           "oldText",
           "search",
           "expected_old_string",
-          "expectedHash",
-          "expected_hash",
-          "start_line"
+          "start_line",
+          "end_line"
         ];
         for (const key of directKeys) {
           const value2 = args[key];
@@ -607135,13 +607853,13 @@ ${marker}` : marker);
           "Next action: file_read the target file or range, then retry the edit with old_string copied exactly from that read and expected_hash set to the read's sha256."
         ].join("\n");
       }
-      staleEditFamilyKey(toolName, pathKey, errorKind, targetHash, latestFileHash) {
+      staleEditFamilyKey(toolName, pathKey, errorKind, targetHash) {
         return [
+          `epoch=${this._taskEpoch}`,
           toolName,
           pathKey || "(unknown)",
           errorKind,
-          targetHash,
-          latestFileHash || "unknown-file-hash"
+          targetHash
         ].join(":");
       }
       staleEditPreflightBlock(toolName, args) {
@@ -607157,11 +607875,8 @@ ${marker}` : marker);
           if (entry.count >= 2 && !hasFreshRead && !hasFreshMutation) {
             return [
               "[STALE EDIT LOOP BLOCKED] " + toolName + " has already failed " + entry.count + " times for " + entry.path + " (" + entry.errorKind + ").",
-              "Do not retry the same stale edit target again. First file_read the current file content once, then either:",
-              "1. confirm the desired change is already present and run verification,",
-              "2. build a new edit from the exact current text, or",
-              "3. choose a different target if this edit is no longer relevant.",
-              "Previous stale target preview: " + entry.preview
+              "Blocked until a fresh file read, a real mutation, or a changed semantic edit target is observed.",
+              "Previous target: " + entry.preview
             ].join("\n");
           }
         }
@@ -607354,7 +608069,7 @@ ${marker}` : marker);
         if (!errorKind)
           return;
         const latestFileHash = typeof result.beforeHash === "string" && result.beforeHash.trim() ? result.beforeHash.trim() : typeof result.afterHash === "string" && result.afterHash.trim() ? result.afterHash.trim() : "unknown-file-hash";
-        const key = this.staleEditFamilyKey(toolName, targetPathKey, errorKind, target.targetHash, latestFileHash);
+        const key = this.staleEditFamilyKey(toolName, targetPathKey, errorKind, target.targetHash);
         const existing = this._staleEditFamilies.get(key);
         this._staleEditFamilies.set(key, {
           count: (existing?.count ?? 0) + 1,
@@ -608182,6 +608897,11 @@ ${tail}`;
           });
           if (signal)
             this._contextLedger.upsert(signal);
+          messages2.push({
+            role: "user",
+            content: userMsg,
+            taskEpoch: this._taskEpoch
+          });
         }
         this.emit({
           type: "user_interrupt",
@@ -608912,7 +609632,7 @@ ${telegramPersonaHead}` : stripped
               const canonicalPath = this._normalizeEvidencePath(filePath);
               const branchNode = this._branchEvidenceByPath.get(canonicalPath);
               const currentMtime = this._statMtimeMsForToolPath(filePath) ?? 0;
-              if (branchNode && branchNode.mtimeMs === currentMtime) {
+              if (branchNode && branchNode.taskEpoch === this._taskEpoch && branchNode.mtimeMs === currentMtime) {
                 const nodeTokens = Math.ceil(branchNode.output.length / 4);
                 if (recoveredTokens + nodeTokens > fileRecoveryBudget)
                   continue;
@@ -609332,16 +610052,24 @@ ${trimmedNew}`;
         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();
+        const board = this._currentWorkboardSnapshotForFrame() ?? 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 runId = this._workboardRunId();
               const completed = completeWorkboardCard(this._workboardDir(), {
-                runId: this.currentArtifactRunId(),
+                runId,
                 cardId: card.id,
                 actor: this.options.subAgent ? "sub-agent" : "agent",
                 outcome: "completed",
+                evidence: {
+                  kind: "tool_result",
+                  summary: `creation ground truth: ${created.join(", ")}`,
+                  tool: toolName,
+                  ref: created[0],
+                  content: String(result.output ?? result.error ?? "").slice(0, 1e3)
+                },
                 reason: `Creation ground truth satisfied mapped target(s): ${created.join(", ")} at turn ${turn}.`
               });
               this._workboard = completed.snapshot;
@@ -610786,6 +611514,7 @@ ${catalog}`,
             parameters: {},
             execute: async (args) => {
               const query = String(args["query"] ?? "").toLowerCase().trim();
+              const queryTerms2 = query.split(/[^a-z0-9_]+/).filter((term) => term.length >= 3);
               const subsetMatch = subsetCatalog[query];
               if (subsetMatch && subsetMatch.length > 0) {
                 const newlyPromoted = [];
@@ -610828,7 +611557,15 @@ ${catalog}`,
                 }
                 return { success: true, output: lines.join("\n") };
               }
-              const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || (t2.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)) || getDesc(t2).toLowerCase().includes(query) || customToolSearchText(t2).toLowerCase().includes(query)).sort((a2, b) => {
+              const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || (t2.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)) || getDesc(t2).toLowerCase().includes(query) || customToolSearchText(t2).toLowerCase().includes(query) || queryTerms2.some((term) => {
+                const searchable = [
+                  t2.name,
+                  ...t2.aliases ?? [],
+                  getDesc(t2),
+                  customToolSearchText(t2)
+                ].join(" ").toLowerCase();
+                return searchable.includes(term);
+              })).sort((a2, b) => {
                 const scoreTool = (tool) => {
                   const meta = getCustomToolMetadata(tool);
                   let score = 0;
@@ -610836,6 +611573,16 @@ ${catalog}`,
                     score += 30;
                   if (tool.name.toLowerCase().includes(query))
                     score += 10;
+                  for (const term of queryTerms2) {
+                    if (tool.name.toLowerCase() === term)
+                      score += 30;
+                    else if (tool.name.toLowerCase().includes(term))
+                      score += 10;
+                    if (getDesc(tool).toLowerCase().includes(term))
+                      score += 4;
+                    if (customToolSearchText(tool).toLowerCase().includes(term))
+                      score += 6;
+                  }
                   if ((tool.aliases ?? []).some((alias) => alias.toLowerCase() === query))
                     score += 24;
                   if ((tool.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)))
@@ -611876,7 +612623,7 @@ ${description}`
         if (effectiveThink === true && (effectiveMaxTokens ?? 0) < 4096) {
           effectiveMaxTokens = 4096;
         }
-        const requestMessages = effectiveThink ? cleanedMessages : injectNoThinkDirective(cleanedMessages);
+        const requestMessages = cleanedMessages;
         const responseFormat = request.responseFormat ?? request.response_format;
         const isOllama = shouldUseOllamaPoolForBaseUrl(this.baseUrl);
         const body = {
@@ -612012,7 +612759,7 @@ ${description}`
             }
           }
           if (shouldRetryThinkGuard || shouldRecoverFromEmpty) {
-            const retryMessages = injectNoThinkDirective(requestMessages);
+            const retryMessages = requestMessages;
             const retryBody = {
               model: this.model,
               messages: retryMessages,
@@ -612093,7 +612840,7 @@ ${description}`
       }
       async nativeOllamaChatCompletion(request) {
         const cleanedMessages = applyMemoryPrefixToMessages(normalizeMessagesForStrictOpenAI(sanitizeHistoryThink(request.messages)), request.memoryPrefix);
-        const requestMessages = injectNoThinkDirective(cleanedMessages);
+        const requestMessages = cleanedMessages;
         const responseFormat = request.responseFormat ?? request.response_format;
         const options2 = {
           temperature: request.temperature,
@@ -612277,7 +613024,7 @@ ${description}`
         if (effectiveThink === true && (effectiveMaxTokens ?? 0) < 4096) {
           effectiveMaxTokens = 4096;
         }
-        const requestMessages = effectiveThink ? cleanedMessages : injectNoThinkDirective(cleanedMessages);
+        const requestMessages = cleanedMessages;
         const responseFormat = request.responseFormat ?? request.response_format;
         const body = {
           model: this.model,
@@ -612562,6 +613309,7 @@ var NexusAgenticBackend;
 var init_nexusBackend = __esm({
   "packages/orchestrator/dist/nexusBackend.js"() {
     "use strict";
+    init_textSanitize();
     NexusAgenticBackend = class _NexusAgenticBackend {
       sendFn;
       model;
@@ -612592,32 +613340,10 @@ var init_nexusBackend = __esm({
         return this.thinking === true;
       }
       noThinkMessages(messages2) {
-        let lastUserIdx = -1;
-        for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
-          if (messages2[i2]?.role === "user") {
-            lastUserIdx = i2;
-            break;
-          }
-        }
-        if (lastUserIdx < 0)
-          return messages2;
-        const target = messages2[lastUserIdx];
-        if (!target || typeof target.content !== "string")
-          return messages2;
-        const hasOllamaNoThink = /\/nothink\b/i.test(target.content);
-        const hasQwenNoThink = /\/no[_-]think\b/i.test(target.content);
-        if (hasOllamaNoThink && hasQwenNoThink)
-          return messages2;
-        const suffix = [
-          hasOllamaNoThink ? null : "/nothink",
-          hasQwenNoThink ? null : "/no_think"
-        ].filter(Boolean).join("\n");
-        return messages2.map((m2, i2) => i2 === lastUserIdx ? { ...m2, content: `${target.content}
-
-${suffix}` } : m2);
+        return messages2.map((message2) => typeof message2.content === "string" ? { ...message2, content: stripNoThinkPromptDirectives(message2.content) } : message2);
       }
       requestMessages(request, effectiveThink) {
-        return effectiveThink ? request.messages : this.noThinkMessages(request.messages);
+        return this.noThinkMessages(request.messages);
       }
       applyOptionalRequestFields(daemonArgs, request) {
         const responseFormat = request.responseFormat ?? request.response_format;
@@ -619166,6 +619892,7 @@ __export(dist_exports3, {
   classifyHandoff: () => classifyHandoff,
   classifyKind: () => classifyKind,
   classifyOllamaProcesses: () => classifyOllamaProcesses,
+  classifySteeringIntent: () => classifySteeringIntent,
   cleanForStorage: () => cleanForStorage,
   cleanScaffolding: () => cleanScaffolding,
   cleanupStaleOllamaProcesses: () => cleanupStaleOllamaProcesses,
@@ -619384,6 +620111,9 @@ __export(dist_exports3, {
   skillShouldShow: () => skillShouldShow,
   specificityScore: () => specificityScore,
   stabilityFilePath: () => stabilityFilePath,
+  steeringGatesOldPlan: () => steeringGatesOldPlan,
+  steeringRequiresReconciliation: () => steeringRequiresReconciliation,
+  stripNoThinkPromptDirectives: () => stripNoThinkPromptDirectives,
   stripThinkTags: () => stripThinkTags,
   stripXmlControlBlocks: () => stripXmlControlBlocks,
   stripYamlFrontmatter: () => stripYamlFrontmatter,
@@ -633849,7 +634579,7 @@ async function fetchOpenAIModels(baseUrl2, apiKey) {
     sizeBytes: 0,
     modified: m2.created ? formatRelativeTime(new Date(m2.created * 1e3).toISOString()) : "",
     parameterSize: m2.owned_by ?? void 0,
-    contextLength: m2.context_length ?? m2.max_model_len ?? void 0
+    contextLength: positiveInteger(m2.context_length) ?? positiveInteger(m2.max_model_len) ?? positiveInteger(m2.meta?.["n_ctx"]) ?? positiveInteger(m2.meta?.["context_length"]) ?? void 0
   })).sort((a2, b) => a2.name.localeCompare(b.name));
 }
 async function fetchPeerModels(peerId, authKey) {
@@ -634149,14 +634879,14 @@ function firstPositive(record, keys) {
   return void 0;
 }
 function contextCapacityFromRecord(record) {
-  return firstPositive(record, [
-    "n_ctx",
-    "n_ctx_train",
-    "context_length",
-    "context_window",
-    "max_model_len",
-    "max_context_length"
-  ]);
+  const direct = firstPositive(record, CONTEXT_CAPACITY_KEYS);
+  if (direct !== void 0) return direct;
+  const meta = asRecord(record["meta"]);
+  const metaCapacity = meta ? firstPositive(meta, CONTEXT_CAPACITY_KEYS) : void 0;
+  if (metaCapacity !== void 0) return metaCapacity;
+  const defaults3 = asRecord(record["default_generation_settings"]);
+  const params = defaults3 && asRecord(defaults3["params"]);
+  return params ? firstPositive(params, CONTEXT_CAPACITY_KEYS) : void 0;
 }
 function telemetryHeaders(apiKey) {
   return apiKey ? { Authorization: `Bearer ${apiKey}` } : void 0;
@@ -634366,7 +635096,7 @@ function formatRelativeTime(iso2) {
   const months = Math.floor(days / 30);
   return `${months}mo ago`;
 }
-var IMAGE_GEN_PATTERNS, LLAMA_CPP_TELEMETRY_TIMEOUT_MS;
+var IMAGE_GEN_PATTERNS, LLAMA_CPP_TELEMETRY_TIMEOUT_MS, CONTEXT_CAPACITY_KEYS;
 var init_model_picker = __esm({
   "packages/cli/src/tui/model-picker.ts"() {
     init_dist6();
@@ -634381,6 +635111,14 @@ var init_model_picker = __esm({
       /imagen/i
     ];
     LLAMA_CPP_TELEMETRY_TIMEOUT_MS = 2500;
+    CONTEXT_CAPACITY_KEYS = [
+      "n_ctx",
+      "n_ctx_train",
+      "context_length",
+      "context_window",
+      "max_model_len",
+      "max_context_length"
+    ];
   }
 });
 
@@ -634747,8 +635485,8 @@ function formatBranchExtractSummary(output) {
     }
   }
   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 header = isDuplicate ? "Branch-extract duplicate reuse" : "Branch extraction completed";
+  const whatHappened = isDuplicate ? "a cache-safe duplicate was detected" : "an isolated inference worker returned bounded, verified evidence";
   const out = [
     `↳ ${header}`,
     `  ├ what happened: ${whatHappened}`,
@@ -634814,7 +635552,7 @@ 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")) {
+  if (firstLine.includes("[branch-extract") || firstLine.includes("[branch-duplicate-blocked]") || lower.includes("branch extraction executed") || lower.includes("branch extraction completed")) {
     return formatBranchExtractSummary(output);
   }
   if (firstLine.includes("[echo break") || firstLine.includes("[echo-break") || lower.includes("echo-1:")) {
@@ -663382,19 +664120,23 @@ var init_runtime_keys = __esm({
 // packages/cli/src/daemon.ts
 var daemon_exports = {};
 __export(daemon_exports, {
+  claimDaemonEndpoint: () => claimDaemonEndpoint,
   ensureDaemon: () => ensureDaemon,
+  ensureDaemonVersion: () => ensureDaemonVersion,
   forceKillDaemon: () => forceKillDaemon,
   getDaemonPid: () => getDaemonPid,
   getDaemonReportedVersion: () => getDaemonReportedVersion,
   getDaemonStatus: () => getDaemonStatus,
   getLocalCliVersion: () => getLocalCliVersion,
   isDaemonRunning: () => isDaemonRunning,
+  releaseDaemonEndpointClaim: () => releaseDaemonEndpointClaim,
+  releaseDaemonEndpointForCurrentProcess: () => releaseDaemonEndpointForCurrentProcess,
   restartDaemon: () => restartDaemon,
   startDaemon: () => startDaemon,
   stopDaemon: () => stopDaemon
 });
 import { spawn as spawn35 } from "node:child_process";
-import { existsSync as existsSync140, readFileSync as readFileSync114, writeFileSync as writeFileSync70, mkdirSync as mkdirSync82, unlinkSync as unlinkSync27, openSync as openSync4, closeSync as closeSync4 } from "node:fs";
+import { existsSync as existsSync140, readFileSync as readFileSync114, writeFileSync as writeFileSync70, mkdirSync as mkdirSync82, unlinkSync as unlinkSync27, openSync as openSync4, closeSync as closeSync4, writeSync as writeSync2, statSync as statSync57 } from "node:fs";
 import { join as join149 } from "node:path";
 import { homedir as homedir51 } from "node:os";
 import { fileURLToPath as fileURLToPath20 } from "node:url";
@@ -663408,6 +664150,106 @@ function getDaemonPort() {
   }
   return parseInt(process.env["OMNIUS_PORT"] ?? String(DEFAULT_PORT2), 10);
 }
+function daemonEndpoint(port) {
+  return `127.0.0.1:${port}`;
+}
+function daemonLockFile(port) {
+  return join149(OMNIUS_DIR2, `daemon-${port}.lock`);
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function readDaemonLock(lockFile) {
+  try {
+    const value2 = JSON.parse(readFileSync114(lockFile, "utf8"));
+    if (typeof value2.endpoint !== "string" || typeof value2.pid !== "number" || !Number.isInteger(value2.pid) || value2.pid <= 0 || typeof value2.token !== "string" || typeof value2.startedAt !== "number") {
+      return null;
+    }
+    return value2;
+  } catch {
+    return null;
+  }
+}
+function daemonLockIsInitializing(lockFile) {
+  try {
+    return Date.now() - statSync57(lockFile).mtimeMs < LOCK_INITIALIZATION_GRACE_MS;
+  } catch {
+    return false;
+  }
+}
+function newDaemonLockToken() {
+  return `${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function claimDaemonEndpoint(port = getDaemonPort(), inheritedToken) {
+  mkdirSync82(OMNIUS_DIR2, { recursive: true });
+  const endpoint = daemonEndpoint(port);
+  const lockFile = daemonLockFile(port);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const token = inheritedToken ?? newDaemonLockToken();
+    const record = {
+      endpoint,
+      pid: process.pid,
+      token,
+      startedAt: Date.now()
+    };
+    let fd = null;
+    try {
+      fd = openSync4(lockFile, "wx", 384);
+      writeSync2(fd, JSON.stringify(record));
+      closeSync4(fd);
+      return { endpoint, lockFile, pid: process.pid, port, token };
+    } catch (error) {
+      if (fd !== null) {
+        try {
+          closeSync4(fd);
+        } catch {
+        }
+        try {
+          unlinkSync27(lockFile);
+        } catch {
+        }
+      }
+      const code8 = error.code;
+      if (code8 !== "EEXIST") return null;
+    }
+    const existing = readDaemonLock(lockFile);
+    if (existing?.endpoint === endpoint && inheritedToken && existing.token === inheritedToken) {
+      const transferred = { ...existing, pid: process.pid, startedAt: Date.now() };
+      writeFileSync70(lockFile, JSON.stringify(transferred), { encoding: "utf8", mode: 384 });
+      return { endpoint, lockFile, pid: process.pid, port, token: inheritedToken };
+    }
+    if (existing && processIsAlive(existing.pid) || !existing && daemonLockIsInitializing(lockFile)) {
+      return null;
+    }
+    try {
+      unlinkSync27(lockFile);
+    } catch {
+    }
+  }
+  return null;
+}
+function releaseDaemonEndpointClaim(claim) {
+  const existing = readDaemonLock(claim.lockFile);
+  if (existing?.pid !== claim.pid || existing.token !== claim.token) return;
+  try {
+    unlinkSync27(claim.lockFile);
+  } catch {
+  }
+}
+function releaseDaemonEndpointForCurrentProcess(port = getDaemonPort()) {
+  const lockFile = daemonLockFile(port);
+  const existing = readDaemonLock(lockFile);
+  if (existing?.pid !== process.pid) return;
+  try {
+    unlinkSync27(lockFile);
+  } catch {
+  }
+}
 async function isDaemonRunning(port) {
   const p2 = port ?? getDaemonPort();
   try {
@@ -663444,7 +664286,19 @@ async function getDaemonReportedVersion(port) {
     return null;
   }
 }
-async function restartDaemon(port) {
+async function waitForDaemonReady(port, expectedVersion, attempts = 24) {
+  let observedVersion = null;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    await new Promise((resolve82) => setTimeout(resolve82, 500));
+    if (!await isDaemonRunning(port)) continue;
+    observedVersion = await getDaemonReportedVersion(port);
+    if (!expectedVersion || expectedVersion === "0.0.0" || observedVersion === expectedVersion) {
+      return { ok: true, observedVersion };
+    }
+  }
+  return { ok: false, observedVersion };
+}
+async function restartDaemon(port, expectedVersion) {
   const p2 = port ?? getDaemonPort();
   try {
     const { spawnSync: spawnSync9 } = await import("node:child_process");
@@ -663454,12 +664308,14 @@ async function restartDaemon(port) {
     });
     if (enabled2.status === 0) {
       spawnSync9("systemctl", ["--user", "restart", "omnius-daemon.service"], { stdio: "ignore", timeout: 2e4 });
-      return;
+      return (await waitForDaemonReady(p2, expectedVersion)).ok;
     }
   } catch {
   }
   await forceKillDaemon(p2);
-  await startDaemon();
+  const pid = await startDaemon();
+  if (!pid) return false;
+  return (await waitForDaemonReady(p2, expectedVersion)).ok;
 }
 function getDaemonPid() {
   if (!existsSync140(PID_FILE2)) return null;
@@ -663518,9 +664374,15 @@ async function resolveDaemonCommand(nodeExe) {
 }
 async function startDaemon() {
   mkdirSync82(OMNIUS_DIR2, { recursive: true });
+  const daemonPort = getDaemonPort();
+  const endpointClaim = claimDaemonEndpoint(daemonPort);
+  if (!endpointClaim) return null;
   const nodeExe = process.execPath;
   const daemonCommand = await resolveDaemonCommand(nodeExe);
-  if (!daemonCommand) return null;
+  if (!daemonCommand) {
+    releaseDaemonEndpointClaim(endpointClaim);
+    return null;
+  }
   let outFd = null;
   let errFd = null;
   try {
@@ -663536,6 +664398,8 @@ async function startDaemon() {
         ...processLeaseEnv(leaseId, ownerId, process.cwd()),
         OMNIUS_DAEMON: "1",
         // signal to serve.ts that it's running as daemon
+        OMNIUS_DAEMON_LOCK_TOKEN: endpointClaim.token,
+        OMNIUS_DAEMON_LOCK_PORT: String(daemonPort),
         OMNIUS_PROCESS_OWNER_KIND: "daemon",
         OMNIUS_PROCESS_LIFECYCLE: "daemon",
         OMNIUS_PROCESS_PERSISTENT: "1"
@@ -663561,6 +664425,7 @@ async function startDaemon() {
     }
     return pid;
   } catch {
+    releaseDaemonEndpointClaim(endpointClaim);
     return null;
   } finally {
     if (outFd !== null) try {
@@ -663652,24 +664517,18 @@ async function forceKillDaemon(port) {
   }
   return killed;
 }
-async function ensureDaemon() {
-  const port = getDaemonPort();
+async function ensureDaemonVersion(expectedVersion = getLocalCliVersion(), port = getDaemonPort()) {
+  const finish = (ok3, action, observedVersion) => ({ ok: ok3, action, expectedVersion, observedVersion, port });
   if (await isDaemonRunning(port)) {
     if (process.env["OMNIUS_NO_VERSION_GUARD"] !== "1") {
       const running = await getDaemonReportedVersion(port);
-      const local = getLocalCliVersion();
-      if (running && local !== "0.0.0" && running !== local) {
-        await restartDaemon(port);
-        for (let i2 = 0; i2 < 24; i2++) {
-          await new Promise((r2) => setTimeout(r2, 500));
-          if (await isDaemonRunning(port) && await getDaemonReportedVersion(port) === local) {
-            return true;
-          }
-        }
-        return await isDaemonRunning(port);
+      if (expectedVersion !== "0.0.0" && running !== expectedVersion) {
+        const ok3 = await restartDaemon(port, expectedVersion);
+        const observedVersion = await getDaemonReportedVersion(port);
+        return finish(ok3 && observedVersion === expectedVersion, ok3 ? "restarted" : "failed", observedVersion);
       }
     }
-    return true;
+    return finish(true, "unchanged", await getDaemonReportedVersion(port));
   }
   const stalePid = getDaemonPid();
   if (stalePid) {
@@ -663683,13 +664542,19 @@ async function ensureDaemon() {
     }
   }
   const pid = await startDaemon();
-  if (!pid) return false;
-  for (let i2 = 0; i2 < 20; i2++) {
-    await new Promise((r2) => setTimeout(r2, 500));
-    if (await isDaemonRunning(port)) {
-      return true;
+  if (!pid) {
+    for (let i2 = 0; i2 < 20; i2++) {
+      await new Promise((r2) => setTimeout(r2, 500));
+      if (await isDaemonRunning(port)) {
+        const observedVersion = await getDaemonReportedVersion(port);
+        const versionMatches = expectedVersion === "0.0.0" || observedVersion === expectedVersion;
+        return finish(versionMatches, versionMatches ? "started" : "failed", observedVersion);
+      }
     }
+    return finish(false, "failed", null);
   }
+  const ready = await waitForDaemonReady(port, expectedVersion, 20);
+  if (ready.ok) return finish(true, "started", ready.observedVersion);
   try {
     process.kill(pid, "SIGTERM");
   } catch {
@@ -663698,7 +664563,11 @@ async function ensureDaemon() {
     unlinkSync27(PID_FILE2);
   } catch {
   }
-  return false;
+  releaseDaemonEndpointForCurrentProcess(port);
+  return finish(false, "failed", ready.observedVersion);
+}
+async function ensureDaemon() {
+  return (await ensureDaemonVersion()).ok;
 }
 async function getDaemonStatus() {
   const port = getDaemonPort();
@@ -663719,13 +664588,14 @@ async function getDaemonStatus() {
   }
   return { running, pid, port, uptime: uptime2, pidFile: PID_FILE2 };
 }
-var OMNIUS_DIR2, PID_FILE2, DEFAULT_PORT2;
+var OMNIUS_DIR2, PID_FILE2, DEFAULT_PORT2, LOCK_INITIALIZATION_GRACE_MS;
 var init_daemon = __esm({
   "packages/cli/src/daemon.ts"() {
     init_dist5();
     OMNIUS_DIR2 = join149(homedir51(), ".omnius");
     PID_FILE2 = join149(OMNIUS_DIR2, "daemon.pid");
     DEFAULT_PORT2 = 11435;
+    LOCK_INITIALIZATION_GRACE_MS = 5e3;
   }
 });
 
@@ -663883,7 +664753,7 @@ __export(kg_prune_exports, {
   pruneKnowledgeGraph: () => pruneKnowledgeGraph,
   pruneKnowledgeGraphWithInference: () => pruneKnowledgeGraphWithInference
 });
-import { existsSync as existsSync142, statSync as statSync57 } from "node:fs";
+import { existsSync as existsSync142, statSync as statSync58 } from "node:fs";
 import { join as join151 } from "node:path";
 function stateDirFor(workingDir) {
   return join151(workingDir, ".omnius");
@@ -663903,13 +664773,13 @@ function knowledgeGraphStats(workingDir) {
   };
   if (stats.exists) {
     try {
-      stats.sizeBytes = statSync57(dbPath).size;
+      stats.sizeBytes = statSync58(dbPath).size;
     } catch {
     }
   }
   if (existsSync142(archivePath)) {
     try {
-      stats.archiveSizeBytes = statSync57(archivePath).size;
+      stats.archiveSizeBytes = statSync58(archivePath).size;
     } catch {
     }
   }
@@ -666530,7 +667400,7 @@ import {
   readFileSync as readFileSync118,
   unlinkSync as unlinkSync30,
   readdirSync as readdirSync47,
-  statSync as statSync58,
+  statSync as statSync59,
   copyFileSync as copyFileSync6,
   rmSync as rmSync12
 } from "node:fs";
@@ -666664,7 +667534,7 @@ function mergeDir2(src2, dst) {
       if (entry.isDirectory()) {
         mergeDir2(s2, d2);
       } else if (entry.isFile()) {
-        if (!existsSync146(d2) || statSync58(s2).mtimeMs > statSync58(d2).mtimeMs) {
+        if (!existsSync146(d2) || statSync59(s2).mtimeMs > statSync59(d2).mtimeMs) {
           copyFileSync6(s2, d2);
         }
       }
@@ -668149,7 +669019,7 @@ except Exception as exc:
           const p2 = join155(dir, f2);
           let size = 0;
           try {
-            size = statSync58(p2).size;
+            size = statSync59(p2).size;
           } catch {
           }
           const entry = meta[f2];
@@ -671187,10 +672057,10 @@ import {
   mkdirSync as mkdirSync87,
   readdirSync as readdirSync48,
   lstatSync as lstatSync2,
-  statSync as statSync59,
+  statSync as statSync60,
   rmSync as rmSync13,
   appendFileSync as appendFileSync16,
-  writeSync as writeSync2
+  writeSync as writeSync3
 } from "node:fs";
 import { basename as basename32, dirname as dirname49, relative as relative19, join as join156 } from "node:path";
 function omniusPinnedDependencyVersion(name10) {
@@ -671442,7 +672312,7 @@ function parseTelegramMessageIdList(value2) {
 }
 function writeDirectTerminal(data) {
   try {
-    writeSync2(1, data);
+    writeSync3(1, data);
   } catch {
     try {
       overlayWrite(data);
@@ -674053,7 +674923,7 @@ async function handleSlashCommand(input, ctx3) {
           ipfsFiles = files.length;
           for (const f2 of files) {
             try {
-              ipfsBytes += statSync59(join156(ipfsLocalDir, f2)).size;
+              ipfsBytes += statSync60(join156(ipfsLocalDir, f2)).size;
             } catch {
             }
           }
@@ -674066,7 +674936,7 @@ async function handleSlashCommand(input, ctx3) {
               else {
                 heliaBlocks++;
                 try {
-                  heliaBytes += statSync59(join156(dir, entry.name)).size;
+                  heliaBytes += statSync60(join156(dir, entry.name)).size;
                 } catch {
                 }
               }
@@ -674209,7 +675079,7 @@ async function handleSlashCommand(input, ctx3) {
           lines.push(`
   ${c3.bold("Structured Memory (SQLite)")}`);
           lines.push(
-            `    Memories: ${c3.bold(String(count))}   DB: ${c3.dim(formatFileSize(statSync59(dbPath).size))}`
+            `    Memories: ${c3.bold(String(count))}   DB: ${c3.dim(formatFileSize(statSync60(dbPath).size))}`
           );
           cDb(db);
         }
@@ -674241,7 +675111,7 @@ async function handleSlashCommand(input, ctx3) {
               walkStorage(full, subCat);
             } else {
               try {
-                const sz = statSync59(full).size;
+                const sz = statSync60(full).size;
                 totalBytes += sz;
                 if (!categories[category])
                   categories[category] = { files: 0, bytes: 0 };
@@ -681393,7 +682263,7 @@ async function showCohereDashboard(ctx3) {
                 const snapItems = snaps.slice(0, 20).map((f2) => ({
                   key: f2,
                   label: f2.replace(".json", ""),
-                  detail: `${formatFileSize(statSync59(join156(snapDir, f2)).size)}`
+                  detail: `${formatFileSize(statSync60(join156(snapDir, f2)).size)}`
                 }));
                 if (snapItems.length > 0) {
                   await tuiSelect({
@@ -687306,6 +688176,23 @@ async function handleUpdate(subcommand, ctx3) {
     installOverlay.dismiss();
     return;
   }
+  installOverlay.setPhase("Daemon");
+  installOverlay.setStatus("Gracefully upgrading shared daemon...");
+  const { ensureDaemonVersion: ensureDaemonVersion2, getLocalCliVersion: getLocalCliVersion2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  const expectedDaemonVersion = getLocalCliVersion2();
+  const daemonUpgrade = await ensureDaemonVersion2(expectedDaemonVersion);
+  if (!daemonUpgrade.ok) {
+    installOverlay.stop("Update installed, but daemon upgrade was not verified");
+    await new Promise((r2) => setTimeout(r2, 1200));
+    installOverlay.dismiss();
+    renderError(
+      `Updated CLI to ${expectedDaemonVersion}, but the shared daemon still reports ${daemonUpgrade.observedVersion ?? "unavailable"}. The TUI will remain open; retry /update after resolving the daemon service.`
+    );
+    return;
+  }
+  installOverlay.setStatus(
+    daemonUpgrade.action === "restarted" ? `Daemon upgraded to ${expectedDaemonVersion}` : `Daemon verified at ${expectedDaemonVersion}`
+  );
   registry2.killAll();
   ctx3.contextSave?.();
   const hadActiveTask = ctx3.savePendingTaskState?.() ?? false;
@@ -696286,48 +697173,86 @@ var init_emotion_engine = __esm({
         }
         return { allowed: true };
       }
+      /** Auxiliary stages share one non-queuing backend slot. */
+      auxiliaryInferenceInFlight = false;
+      /** Failed stages cool down independently; a successful nonempty reply resets them. */
+      internalInferenceCircuit = /* @__PURE__ */ new Map();
+      noteInternalInferenceFailure(stage2, now2 = Date.now()) {
+        const prior = this.internalInferenceCircuit.get(stage2);
+        const failureCount = Math.min(6, (prior?.failureCount ?? 0) + 1);
+        const cooldownMs = Math.min(10 * 6e4, 3e4 * 2 ** (failureCount - 1));
+        this.internalInferenceCircuit.set(stage2, {
+          failureCount,
+          openUntil: now2 + cooldownMs
+        });
+      }
+      resetInternalInferenceCircuit(stage2) {
+        this.internalInferenceCircuit.delete(stage2);
+      }
       async runDirectInternalInference(opts) {
         const cwd4 = resolve71(process.cwd());
         const startedAt2 = Date.now();
-        const admission = await this.admitInternalInference();
-        if (!admission.allowed) {
+        const circuit = this.internalInferenceCircuit.get(opts.stage);
+        if (circuit && circuit.openUntil > startedAt2) {
           this.recordInternalDecision({
             stage: opts.stage,
             status: "skipped",
             elapsedMs: Date.now() - startedAt2,
-            skipReason: admission.reason,
+            skipReason: `internal_inference_circuit_open:${opts.stage}:retry_after_ms=${circuit.openUntil - startedAt2}`,
             promptChars: opts.system.length + opts.user.length
           });
           return null;
         }
-        const request = {
-          messages: [
-            { role: "system", content: opts.system },
-            { role: "user", content: opts.user }
-          ],
-          tools: [],
-          temperature: opts.temperature,
-          maxTokens: opts.maxTokens,
-          timeoutMs: opts.timeoutMs,
-          think: false,
-          disableEmptyContentRecovery: true,
-          poolQueuePolicy: "skip",
-          poolQueueTimeoutMs: 1
-        };
-        recordContextWindowDump({
-          source: "emotionEngine",
-          stage: opts.stage,
-          agentType: "internal",
-          sessionId: process.env["OMNIUS_SESSION_ID"] || "emotion-engine",
-          runId: process.env["OMNIUS_SESSION_ID"] || "emotion-engine",
-          turn: 0,
-          attempt: 0,
-          model: this.config.model,
-          cwd: cwd4,
-          note: opts.note,
-          request
-        });
+        if (this.auxiliaryInferenceInFlight) {
+          this.recordInternalDecision({
+            stage: opts.stage,
+            status: "skipped",
+            elapsedMs: Date.now() - startedAt2,
+            skipReason: `auxiliary_inference_busy:${opts.stage}`,
+            promptChars: opts.system.length + opts.user.length
+          });
+          return null;
+        }
+        this.auxiliaryInferenceInFlight = true;
         try {
+          const admission = await this.admitInternalInference();
+          if (!admission.allowed) {
+            this.recordInternalDecision({
+              stage: opts.stage,
+              status: "skipped",
+              elapsedMs: Date.now() - startedAt2,
+              skipReason: admission.reason,
+              promptChars: opts.system.length + opts.user.length
+            });
+            return null;
+          }
+          const request = {
+            messages: [
+              { role: "system", content: opts.system },
+              { role: "user", content: opts.user }
+            ],
+            tools: [],
+            temperature: opts.temperature,
+            maxTokens: opts.maxTokens,
+            timeoutMs: opts.timeoutMs,
+            think: false,
+            disableEmptyContentRecovery: true,
+            poolQueuePolicy: "skip",
+            poolQueueTimeoutMs: 1
+          };
+          recordContextWindowDump({
+            source: "emotionEngine",
+            stage: opts.stage,
+            agentType: "internal",
+            sessionId: process.env["OMNIUS_SESSION_ID"] || "emotion-engine",
+            runId: process.env["OMNIUS_SESSION_ID"] || "emotion-engine",
+            turn: 0,
+            attempt: 0,
+            model: this.config.model,
+            cwd: cwd4,
+            note: opts.note,
+            request
+          });
           const backend = new OllamaAgenticBackend(
             this.config.backendUrl,
             this.config.model,
@@ -696338,6 +697263,19 @@ var init_emotion_engine = __esm({
           const output = String(
             result.choices?.[0]?.message?.content ?? ""
           ).trim();
+          if (!output) {
+            const error = "empty internal inference response";
+            this.noteInternalInferenceFailure(opts.stage);
+            this.recordInternalDecision({
+              stage: opts.stage,
+              status: "error",
+              elapsedMs: Date.now() - startedAt2,
+              error,
+              promptChars: opts.system.length + opts.user.length
+            });
+            return null;
+          }
+          this.resetInternalInferenceCircuit(opts.stage);
           this.recordInternalDecision({
             stage: opts.stage,
             status: "ok",
@@ -696347,14 +697285,18 @@ var init_emotion_engine = __esm({
           });
           return output;
         } catch (err) {
+          const error = err instanceof Error ? err.message : String(err);
+          this.noteInternalInferenceFailure(opts.stage);
           this.recordInternalDecision({
             stage: opts.stage,
             status: "error",
             elapsedMs: Date.now() - startedAt2,
-            error: err instanceof Error ? err.message : String(err),
+            error,
             promptChars: opts.system.length + opts.user.length
           });
           throw err;
+        } finally {
+          this.auxiliaryInferenceInFlight = false;
         }
       }
       recordInternalDecision(entry) {
@@ -697716,7 +698658,7 @@ import {
   existsSync as existsSync157,
   mkdirSync as mkdirSync96,
   readFileSync as readFileSync128,
-  statSync as statSync60,
+  statSync as statSync61,
   unlinkSync as unlinkSync33,
   writeFileSync as writeFileSync83
 } from "node:fs";
@@ -698229,7 +699171,7 @@ function materializeTelegramCreativeArtifactForSend(root, rawPath) {
 }
 function safeStatFile(path16) {
   try {
-    return statSync60(path16).isFile();
+    return statSync61(path16).isFile();
   } catch {
     return false;
   }
@@ -698500,7 +699442,7 @@ ${(result.error || result.output || "").slice(0, 1200)}`,
           for (const fn of cleanup) fn();
         }
         rememberCreated(this.root, guarded.path.abs);
-        const sizeKB = Math.round(statSync60(guarded.path.abs).size / 1024);
+        const sizeKB = Math.round(statSync61(guarded.path.abs).size / 1024);
         this.emitProgress(start2, {
           stage: "save",
           message: `Saved scoped audio file (${sizeKB}KB)`
@@ -701883,7 +702825,7 @@ import {
   existsSync as existsSync160,
   unlinkSync as unlinkSync36,
   readdirSync as readdirSync56,
-  statSync as statSync61,
+  statSync as statSync62,
   readFileSync as readFileSync131,
   writeFileSync as writeFileSync85,
   appendFileSync as appendFileSync20
@@ -702374,34 +703316,9 @@ function telegramRouterDiagnosticIsDualEmptyVisible(diag) {
   return diag.jsonModeStatus === "empty-after-strip" && diag.plainStatus === "empty-after-strip";
 }
 function telegramThinkSuppressedRequest(request) {
-  const messages2 = Array.isArray(request.messages) ? request.messages.slice() : [];
-  let appended = false;
-  for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
-    const m2 = messages2[i2];
-    if (!m2 || m2.role !== "user") continue;
-    const content = typeof m2.content === "string" ? m2.content : "";
-    const hasOllamaNoThink = /\/nothink\b/i.test(content);
-    const hasQwenNoThink = /\/no[_-]think\b/i.test(content);
-    if (hasOllamaNoThink && hasQwenNoThink) {
-      appended = true;
-      break;
-    }
-    const suffix = [
-      hasOllamaNoThink ? null : "/nothink",
-      hasQwenNoThink ? null : "/no_think"
-    ].filter(Boolean).join("\n");
-    messages2[i2] = {
-      ...m2,
-      content: content.endsWith("\n") ? `${content}${suffix}` : `${content}
-
-${suffix}`
-    };
-    appended = true;
-    break;
-  }
-  if (!appended) {
-    messages2.push({ role: "user", content: "/nothink\n/no_think" });
-  }
+  const messages2 = Array.isArray(request.messages) ? request.messages.map(
+    (message2) => message2 && typeof message2.content === "string" ? { ...message2, content: stripNoThinkPromptDirectives(message2.content) } : message2
+  ) : [];
   return { ...request, messages: messages2, think: false };
 }
 function parseTelegramInteractionDecision(text2, forcedRoute, options2 = {}) {
@@ -702854,7 +703771,7 @@ function isTelegramInternalControlText(text2) {
     /\[discovery contract\]/i,
     /\[curated segments\]/i,
     /\[branch-duplicate-blocked\]/i,
-    /branch-extract preempted/i,
+    /branch extraction (?:executed|completed)/i,
     /contract: use these anchors as evidence/i,
     /\becho break\b/i
   ];
@@ -705103,6 +706020,8 @@ Telegram link integrity contract:
        */
       telegramOwnerLockFile = null;
       telegramOwnerLockFiles = [];
+      /** Per-bridge ownership tokens prevent a second bridge from releasing our lock. */
+      telegramOwnerLockTokens = /* @__PURE__ */ new Map();
       /** Session keys loaded from persistent conversation memory */
       loadedConversationState = /* @__PURE__ */ new Set();
       /** True once persisted Telegram conversation scopes have been bulk-loaded. */
@@ -706194,11 +707113,20 @@ ${message2}`)
       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 (/^\/(?:stop|cancel|abort|halt)\b/.test(lower) || /^(?:stop|cancel|abort|halt)(?:[.!]?|\s+(?:the\s+)?(?:current\s+)?(?:task|work|run)\b)/.test(
+          lower
+        )) {
+          return { intent: "cancel", reason: "explicit cancellation request" };
         }
-        if (/^\/(?:redirect|reroute|pivot)\b/.test(lower)) {
-          return { intent: "redirect", reason: "explicit redirect command" };
+        if (/^\/(?:redirect|reroute|pivot)\b/.test(lower) || /^(?:please\s+)?(?:redirect|reroute|pivot)\s+(?:the\s+)?(?:current\s+)?(?:task|work|run)\b/.test(
+          lower
+        ) || /^(?:please\s+)?(?:switch|change|move)\s+(?:(?:focus|work|task)\s+)?to\b/.test(
+          lower
+        )) {
+          return {
+            intent: "redirect",
+            reason: "explicit natural-language redirect request"
+          };
         }
         if (/^\/(?:replace|new[_-]?task)\b/.test(lower) || /^(?:new task|replace (?:the )?(?:current )?task|forget (?:that|the current task)|instead[,!:]?)/.test(
           lower
@@ -706211,7 +707139,11 @@ ${message2}`)
         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" };
+        const classified = classifySteeringIntent(text2, "append");
+        return {
+          intent: classified,
+          reason: classified === "constraint" || classified === "priority_change" ? "shared safety/scope/priority steering classifier" : "conservative context-only intake; momentum preserved"
+        };
       }
       telegramIntakePath(sessionKey) {
         const digest3 = createHash49("sha256").update(sessionKey).digest("hex").slice(0, 20);
@@ -706306,14 +707238,13 @@ ${message2}`)
             content,
             source: "telegram",
             receivedAt: intake.receivedAt,
-            intent: intake.intent,
-            taskEpoch: intake.taskEpoch
+            intent: intake.intent
           });
           return;
         }
         runner.injectUserMessage(this.formatTelegramSteeringCompatibilityMessage(pending2));
       }
-      async preemptTelegramSubAgentForIntake(msg, subAgent, toolContext, intake) {
+      async preemptTelegramSubAgentForIntake(msg, subAgent, intake) {
         const sessionKey = intake.sessionKey;
         await this.transitionTelegramIntake(
           intake,
@@ -706321,59 +707252,33 @@ ${message2}`)
           "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.";
+        const receipt = intake.intent === "cancel" ? "Cancellation received. I am stopping the current task." : "Redirection received. I am interrupting the current step and replanning from your latest instruction at the next safe boundary.";
         await this.replyToTelegramMessage(msg, receipt).catch(() => null);
+        if (intake.intent !== "cancel") {
+          intake.taskEpoch = this.advanceTelegramTaskEpoch(sessionKey);
+        }
         await this.transitionTelegramIntake(
           intake,
           "preempt_requested",
-          "trusted admin-DM steering preemption requested",
+          "trusted admin-DM steering preemption requested for the active runner",
           { 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 }
-          );
-        }
+        await this.enqueueTelegramMessageForExistingSubAgent(msg, subAgent, intake);
         const runner = subAgent.runner;
-        if (typeof runner?.requestSteeringPreemption === "function") {
-          runner.requestSteeringPreemption(intake.inputId);
-        } else {
+        const preemptionReceipt = runner?.requestSteeringPreemption?.(
+          intake.inputId
+        );
+        if (!preemptionReceipt) {
+          subAgent.preempted = true;
           runner?.abort?.();
         }
+        if (intake.intent === "cancel") subAgent.preempted = true;
         await this.transitionTelegramIntake(
           intake,
           "preempted",
-          "active runner interrupted for trusted steering intake",
+          preemptionReceipt ? "active runner turn interrupted; typed steering will apply at its safe boundary" : "runner lacks typed preemption support; active run was cancelled",
           { runId: subAgent.runId }
         );
-        this.dispatchQueuedTelegramSessionWorkSoon();
       }
       async requeuePendingTelegramIntakeOnFinalization(subAgent) {
         const pending2 = subAgent.pendingIntakeRecords.splice(0);
@@ -706410,13 +707315,16 @@ ${message2}`)
         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;
+        const lifecycle = typed.type === "steering_lifecycle" ? typed.state === "received" ? "acknowledged" : typed.state === "visible_in_request" ? "visible_in_request" : typed.state === "reconciliation_required" ? "reconciliation_required" : typed.state === "reconciled" ? "reconciled" : typed.state === "first_affected_action" ? "first_affected_action" : typed.state === "cancelled" ? "cancelled" : typed.state === "superseded" ? "superseded" : null : typed.type === "steering_preempt_requested" ? "preempt_requested" : typed.type === "steering_preempted" ? "preempted" : 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 } : {}
+          typed.summary || `runner lifecycle event: ${typed.type}`,
+          {
+            ...typeof typed.turn === "number" ? { runnerTurn: typed.turn } : {},
+            ...typeof typed.taskEpoch === "number" ? { taskEpoch: typed.taskEpoch } : {}
+          }
         );
       }
       async replyWithTelegramHelp(msg, isAdmin) {
@@ -707137,7 +708045,7 @@ Model: <code>${escapeTelegramHTML(model.id)}</code>`
         }
         let sent = 0;
         for (const path16 of paths) {
-          if (!existsSync160(path16) || !statSync61(path16).isFile()) continue;
+          if (!existsSync160(path16) || !statSync62(path16).isFile()) continue;
           const kind = classifyMedia(path16) ?? "document";
           const messageId = await this.sendMediaReference(
             msg.chatId,
@@ -710971,9 +711879,7 @@ ${lines.join("\n")}`
           observationContext,
           "",
           `Current Telegram message text (untrusted user data):
-${this.quoteTelegramContextBlock(msg.text, 1200)}`,
-          "",
-          "/nothink\n/no_think"
+${this.quoteTelegramContextBlock(msg.text, 1200)}`
         ].filter(Boolean).join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(
@@ -711471,10 +712377,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
           TELEGRAM_INTERACTION_DECISION_REPAIR_SCHEMA,
           ``,
           `Original router output:`,
-          rawPreview,
-          ``,
-          `/nothink
-/no_think`
+          rawPreview
         ].join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(
@@ -711549,10 +712452,7 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
           invalidPreview,
           ``,
           `Router context (trailing-window):`,
-          trimmedUserPrompt,
-          ``,
-          `/nothink
-/no_think`
+          trimmedUserPrompt
         ].join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(
@@ -712852,8 +713752,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
             } catch (e2) {
               for (const lockFile of claimed)
                 this.releaseTelegramOwnerLock(lockFile);
-              if (e2 instanceof Error && e2.message.startsWith("Telegram bot @"))
-                throw e2;
+              throw e2;
             }
           }
           this.state = {
@@ -713012,47 +713911,97 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
       claimTelegramOwnerLock(lockDir, botUserId, botUsername) {
         mkdirSync98(lockDir, { recursive: true });
         const lockFile = join170(lockDir, `bot-${botUserId}.owner.lock`);
-        if (existsSync160(lockFile)) {
+        const ownerToken = randomBytes28(16).toString("hex");
+        const payload = JSON.stringify(
+          {
+            pid: process.pid,
+            cwd: this.repoRoot || process.cwd(),
+            botUsername,
+            botUserId,
+            ownerToken,
+            ts: Date.now()
+          },
+          null,
+          2
+        );
+        const recoveryFile = `${lockFile}.recovery`;
+        for (let attempt = 0; attempt < 4; attempt++) {
           try {
-            const prior = JSON.parse(readFileSync131(lockFile, "utf8"));
-            const priorAlive = typeof prior.pid === "number" && prior.pid !== process.pid ? this.processIsAlive(prior.pid) : false;
-            if (priorAlive) {
+            writeFileSync85(lockFile, payload, {
+              encoding: "utf-8",
+              mode: 384,
+              flag: "wx"
+            });
+            this.telegramOwnerLockTokens.set(lockFile, ownerToken);
+            return lockFile;
+          } catch (error) {
+            if (error?.code !== "EEXIST") throw error;
+          }
+          let prior = {};
+          try {
+            prior = JSON.parse(readFileSync131(lockFile, "utf8"));
+          } catch {
+          }
+          const priorAlive = typeof prior.pid === "number" && prior.pid !== process.pid ? this.processIsAlive(prior.pid) : typeof prior.pid === "number";
+          if (priorAlive) {
+            throw new Error(
+              `Telegram bot @${prior.botUsername || botUsername || "unknown"} is already being polled by pid ${prior.pid} (cwd ${prior.cwd || "?"}). Stop that instance or use a different bot token in this project.`
+            );
+          }
+          const recoveryToken = randomBytes28(12).toString("hex");
+          try {
+            writeFileSync85(recoveryFile, recoveryToken, {
+              encoding: "utf-8",
+              mode: 384,
+              flag: "wx"
+            });
+          } catch (error) {
+            if (error?.code === "EEXIST") continue;
+            throw error;
+          }
+          try {
+            let currentPid;
+            try {
+              currentPid = JSON.parse(readFileSync131(lockFile, "utf8"))?.pid;
+            } catch {
+            }
+            if (typeof currentPid === "number" && (currentPid === process.pid || this.processIsAlive(currentPid))) {
               throw new Error(
-                `Telegram bot @${prior.botUsername || botUsername || "unknown"} is already being polled by pid ${prior.pid} (cwd ${prior.cwd || "?"}). Stop that instance or use a different bot token in this project.`
+                `Telegram bot @${botUsername || "unknown"} acquired an owner while stale-lock recovery was pending.`
               );
             }
-          } catch (e2) {
-            if (e2 instanceof Error && e2.message.startsWith("Telegram bot @"))
-              throw e2;
+            try {
+              unlinkSync36(lockFile);
+            } catch (error) {
+              if (error?.code !== "ENOENT") throw error;
+            }
+          } finally {
+            try {
+              if (readFileSync131(recoveryFile, "utf8") === recoveryToken)
+                unlinkSync36(recoveryFile);
+            } catch {
+            }
           }
         }
-        writeFileSync85(
-          lockFile,
-          JSON.stringify(
-            {
-              pid: process.pid,
-              cwd: this.repoRoot || process.cwd(),
-              botUsername,
-              botUserId,
-              ts: Date.now()
-            },
-            null,
-            2
-          ),
-          { encoding: "utf-8", mode: 384 }
+        throw new Error(
+          `Could not atomically acquire Telegram owner lock for @${botUsername || botUserId}; retry after the current startup settles.`
         );
-        return lockFile;
       }
       releaseTelegramOwnerLock(lockFile) {
         try {
+          const ownerToken = this.telegramOwnerLockTokens.get(lockFile);
+          if (!ownerToken) return;
           if (!existsSync160(lockFile)) return;
           try {
             const prior = JSON.parse(readFileSync131(lockFile, "utf8"));
-            if (prior.pid !== process.pid) return;
+            if (prior.pid !== process.pid || prior.ownerToken !== ownerToken) return;
           } catch {
+            return;
           }
           unlinkSync36(lockFile);
         } catch {
+        } finally {
+          this.telegramOwnerLockTokens.delete(lockFile);
         }
       }
       /**
@@ -714130,7 +715079,6 @@ Join: ${newUrl}`
             await this.preemptTelegramSubAgentForIntake(
               msg,
               existing,
-              toolContext,
               intakeRecord
             );
             return;
@@ -719392,7 +720340,7 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
         const abs = isAbsolute17(trimmed) ? resolve73(trimmed) : resolve73(base3, trimmed);
         if (!existsSync160(abs))
           return { ok: false, error: `File does not exist: ${trimmed}` };
-        if (!statSync61(abs).isFile())
+        if (!statSync62(abs).isFile())
           return { ok: false, error: `Path is not a file: ${trimmed}` };
         return { ok: true, path: abs };
       }
@@ -719906,7 +720854,7 @@ ${text2}`.trim()
       }
       async sendTelegramFileToChat(chatId, path16, options2) {
         const abs = resolve73(path16);
-        if (!existsSync160(abs) || !statSync61(abs).isFile()) {
+        if (!existsSync160(abs) || !statSync62(abs).isFile()) {
           throw new Error(`File does not exist or is not a regular file: ${path16}`);
         }
         return this.sendMediaReferenceStrict(
@@ -720176,7 +721124,7 @@ Content-Type: ${contentType}\r
         for (const path16 of paths) {
           const abs = resolve73(path16);
           if (subAgent.deliveredArtifacts.includes(abs)) continue;
-          if (!existsSync160(abs) || !statSync61(abs).isFile()) continue;
+          if (!existsSync160(abs) || !statSync62(abs).isFile()) continue;
           subAgent.deliveredArtifacts.push(abs);
           await this.sendMediaReference(
             msg.chatId,
@@ -720218,7 +721166,7 @@ Content-Type: ${contentType}\r
             abs
           );
           if (!materialized.ok) continue;
-          if (!existsSync160(materialized.path) || !statSync61(materialized.path).isFile()) {
+          if (!existsSync160(materialized.path) || !statSync62(materialized.path).isFile()) {
             materialized.cleanup?.();
             continue;
           }
@@ -722407,7 +723355,7 @@ __export(projects_exports, {
   setCurrentProject: () => setCurrentProject,
   unregisterProject: () => unregisterProject
 });
-import { readFileSync as readFileSync132, writeFileSync as writeFileSync86, mkdirSync as mkdirSync99, existsSync as existsSync161, statSync as statSync62, renameSync as renameSync15 } from "node:fs";
+import { readFileSync as readFileSync132, writeFileSync as writeFileSync86, mkdirSync as mkdirSync99, existsSync as existsSync161, statSync as statSync63, renameSync as renameSync15 } from "node:fs";
 import { homedir as homedir58 } from "node:os";
 import { basename as basename43, join as join171, resolve as resolve74 } from "node:path";
 import { randomUUID as randomUUID19 } from "node:crypto";
@@ -722433,7 +723381,7 @@ function listProjects() {
   const alive = [];
   for (const p2 of projects) {
     try {
-      if (statSync62(p2.root).isDirectory()) alive.push(p2);
+      if (statSync63(p2.root).isDirectory()) alive.push(p2);
     } catch {
     }
   }
@@ -723573,7 +724521,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 { existsSync as existsSync164, mkdirSync as mkdirSync102, statSync as statSync64 } from "node:fs";
 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;
@@ -723671,7 +724619,7 @@ var init_disk_task_output = __esm({
           if (!existsSync164(this.path)) {
             return { content: "", nextOffset: offset, eof: true, size: 0 };
           }
-          const st = statSync63(this.path);
+          const st = statSync64(this.path);
           if (offset >= st.size) {
             return { content: "", nextOffset: offset, eof: true, size: st.size };
           }
@@ -723858,7 +724806,7 @@ data: ${JSON.stringify(ev)}
 });
 
 // packages/cli/src/api/routes-media.ts
-import { existsSync as existsSync165, mkdirSync as mkdirSync103, statSync as statSync64, copyFileSync as copyFileSync7, createReadStream } from "node:fs";
+import { existsSync as existsSync165, mkdirSync as mkdirSync103, statSync as statSync65, copyFileSync as copyFileSync7, createReadStream } from "node:fs";
 import { basename as basename44, join as join174, resolve as pathResolve2 } from "node:path";
 function mediaWorkDir() {
   return join174(omniusHomeDir(), "media", "_work");
@@ -724159,7 +725107,7 @@ async function runGeneration(ctx3, kind, buildTool, buildArgs) {
     const published = publishToGallery(srcPath, kind);
     const size = (() => {
       try {
-        return statSync64(published.path).size;
+        return statSync65(published.path).size;
       } catch {
         return 0;
       }
@@ -724266,7 +725214,7 @@ function handleFile(ctx3) {
   const ext = full.slice(full.lastIndexOf(".")).toLowerCase();
   ctx3.res.writeHead(200, {
     "Content-Type": MIME_BY_EXT[ext] || "application/octet-stream",
-    "Content-Length": statSync64(full).size,
+    "Content-Length": statSync65(full).size,
     "Cache-Control": "private, max-age=3600"
   });
   createReadStream(full).pipe(ctx3.res);
@@ -724850,7 +725798,7 @@ __export(aiwg_exports, {
   resolveAiwgRoot: () => resolveAiwgRoot,
   tryRouteAiwg: () => tryRouteAiwg
 });
-import { existsSync as existsSync167, readFileSync as readFileSync136, readdirSync as readdirSync57, statSync as statSync65 } from "node:fs";
+import { existsSync as existsSync167, readFileSync as readFileSync136, readdirSync as readdirSync57, statSync as statSync66 } from "node:fs";
 import { join as join176 } from "node:path";
 import { homedir as homedir60 } from "node:os";
 import { execSync as execSync38 } from "node:child_process";
@@ -724952,7 +725900,7 @@ function listAiwgFrameworks() {
   for (const name10 of readdirSync57(frameworksDir)) {
     const p2 = join176(frameworksDir, name10);
     try {
-      const st = statSync65(p2);
+      const st = statSync66(p2);
       if (!st.isDirectory()) continue;
       const agg = aggregateDir(p2);
       out.push({
@@ -724989,7 +725937,7 @@ function aggregateDir(dir, depth = 0) {
         out.commands += sub2.commands;
       } else if (e2.isFile()) {
         try {
-          const st = statSync65(p2);
+          const st = statSync66(p2);
           out.files++;
           out.bytes += st.size;
           if (e2.name.endsWith(".md")) {
@@ -725123,7 +726071,7 @@ function listAiwgAddons() {
   for (const name10 of readdirSync57(addonsDir)) {
     const p2 = join176(addonsDir, name10);
     try {
-      const st = statSync65(p2);
+      const st = statSync66(p2);
       if (!st.isDirectory()) continue;
       const agg = aggregateDir(p2);
       out.push({
@@ -725912,7 +726860,7 @@ import {
   mkdirSync as mkdirSync106,
   readFileSync as readFileSync138,
   readdirSync as readdirSync58,
-  statSync as statSync66
+  statSync as statSync67
 } from "node:fs";
 import { join as join179, resolve as pathResolve3 } from "node:path";
 import { homedir as homedir62 } from "node:os";
@@ -727374,7 +728322,7 @@ async function handleFilesRead(ctx3) {
       );
       return true;
     }
-    const st = statSync66(resolved);
+    const st = statSync67(resolved);
     if (st.isDirectory()) {
       sendProblem(
         res,
@@ -743166,7 +744114,7 @@ import {
   watch as fsWatch4,
   renameSync as renameSync18,
   unlinkSync as unlinkSync38,
-  statSync as statSync67,
+  statSync as statSync68,
   openSync as openSync7,
   readSync as readSync3,
   closeSync as closeSync7
@@ -743526,7 +744474,7 @@ function fileEntryMetadata(dir, entry) {
     kind: fileKindForPath(entry.name)
   };
   try {
-    const st = statSync67(target);
+    const st = statSync68(target);
     meta["size"] = st.size;
     meta["mtime"] = new Date(st.mtimeMs).toISOString();
   } catch {
@@ -743538,7 +744486,7 @@ function contentDispositionName(filePath) {
   return name10.replace(/["\r\n]/g, "");
 }
 function streamWorkspaceFile(req3, res, target) {
-  const st = statSync67(target);
+  const st = statSync68(target);
   if (!st.isFile()) {
     jsonResponse(res, 400, { error: "Path is not a file", path: target });
     return;
@@ -743763,29 +744711,11 @@ async function writeMemoryEpisodes(sessionId, userMessage, assistantContent, too
 function sanitizeChatContent(raw) {
   return sanitizeAgentOutputForUser(raw);
 }
-function appendNoThinkDirectivesToMessages(messages2) {
-  let lastUserIdx = -1;
-  for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
-    if (messages2[i2]?.role === "user") {
-      lastUserIdx = i2;
-      break;
-    }
-  }
-  if (lastUserIdx < 0) return messages2;
-  const target = messages2[lastUserIdx];
-  if (!target || typeof target.content !== "string") return messages2;
-  const hasOllamaNoThink = /\/nothink\b/i.test(target.content);
-  const hasQwenNoThink = /\/no[_-]think\b/i.test(target.content);
-  if (hasOllamaNoThink && hasQwenNoThink) return messages2;
-  const suffix = [
-    hasOllamaNoThink ? null : "/nothink",
-    hasQwenNoThink ? null : "/no_think"
-  ].filter(Boolean).join("\n");
-  return messages2.map(
-    (m2, i2) => i2 === lastUserIdx ? { ...m2, content: `${target.content}
-
-${suffix}` } : m2
-  );
+function sanitizeNoThinkTransportMessages(messages2) {
+  return messages2.map((message2) => ({
+    ...message2,
+    content: stripNoThinkPromptDirectives(message2.content)
+  }));
 }
 async function directChatBackend(opts) {
   const { model, messages: messages2, stream, res, sessionId, ollamaUrl, extraFields } = opts;
@@ -743916,7 +744846,7 @@ async function directChatBackend(opts) {
     const ollamaFormat = ollamaFormatFromOpenAIResponseFormat(
       ef["response_format"]
     );
-    const ollamaMessages = appendNoThinkDirectivesToMessages(messages2);
+    const ollamaMessages = sanitizeNoThinkTransportMessages(messages2);
     const reqBody = JSON.stringify({
       model: cleanModel,
       messages: ollamaMessages,
@@ -744229,7 +745159,7 @@ async function completeRealtimeTextOnly(opts) {
     ) ?? originalModel;
   }
   const makeOllamaChatBody = (modelName) => {
-    const rtMessages = Array.isArray(requestBody["messages"]) ? appendNoThinkDirectivesToMessages(
+    const rtMessages = Array.isArray(requestBody["messages"]) ? sanitizeNoThinkTransportMessages(
       requestBody["messages"]
     ) : requestBody["messages"];
     return JSON.stringify({
@@ -745904,7 +746834,7 @@ async function handleV1ChatCompletions(req3, res, ollamaUrl) {
   const finalThink = thinkingAllowed && callerProvidedThink ? routedBody["think"] : false;
   const ollamaBody = { ...routedBody };
   if (finalThink === false && Array.isArray(ollamaBody["messages"])) {
-    ollamaBody["messages"] = appendNoThinkDirectivesToMessages(
+    ollamaBody["messages"] = sanitizeNoThinkTransportMessages(
       ollamaBody["messages"]
     );
   }
@@ -747444,7 +748374,7 @@ function handleV1RunsById(res, id2) {
   const enriched = { ...job };
   if (outputFile && existsSync173(outputFile)) {
     try {
-      const size = statSync67(outputFile).size;
+      const size = statSync68(outputFile).size;
       const tailSize = Math.min(size, 4096);
       const buffer2 = Buffer.alloc(tailSize);
       const fd = openSync7(outputFile, "r");
@@ -748092,7 +749022,7 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
           const dir = path16.dirname(cssEntry);
           const fullPath = path16.join(dir, entry.path);
           if (fs14.existsSync(fullPath)) {
-            const stat9 = statSync67(fullPath);
+            const stat9 = statSync68(fullPath);
             res.writeHead(200, {
               "Content-Type": entry.ct,
               "Content-Length": String(stat9.size),
@@ -748644,17 +749574,17 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
             const child = join183(dir, e2.name);
             const omniusDir = join183(child, ".omnius");
             try {
-              if (statSync67(omniusDir).isDirectory()) {
+              if (statSync68(omniusDir).isDirectory()) {
                 const name10 = e2.name;
                 const prefsFile = join183(omniusDir, "config.json");
                 let lastSeen = 0;
                 try {
-                  lastSeen = statSync67(prefsFile).mtimeMs;
+                  lastSeen = statSync68(prefsFile).mtimeMs;
                 } catch {
                 }
                 if (!lastSeen) {
                   try {
-                    lastSeen = statSync67(omniusDir).mtimeMs;
+                    lastSeen = statSync68(omniusDir).mtimeMs;
                   } catch {
                   }
                 }
@@ -748702,17 +749632,17 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
             const child = join183(dir, e2.name);
             const omniusDir = join183(child, ".omnius");
             try {
-              if (statSync67(omniusDir).isDirectory()) {
+              if (statSync68(omniusDir).isDirectory()) {
                 const name10 = e2.name;
                 const prefsFile = join183(omniusDir, "config.json");
                 let lastSeen = 0;
                 try {
-                  lastSeen = statSync67(prefsFile).mtimeMs;
+                  lastSeen = statSync68(prefsFile).mtimeMs;
                 } catch {
                 }
                 if (!lastSeen) {
                   try {
-                    lastSeen = statSync67(omniusDir).mtimeMs;
+                    lastSeen = statSync68(omniusDir).mtimeMs;
                   } catch {
                   }
                 }
@@ -749858,25 +750788,6 @@ data: ${JSON.stringify(data)}
       jsonResponse(res, 200, { ok: true, enabled: config.torEnabled });
       return;
     }
-    if (pathname === "/v1/update" && method === "POST") {
-      const config = loadConfig();
-      config.updating = true;
-      try {
-        require4("./config").saveConfig?.(config);
-      } catch {
-      }
-      setImmediate(() => {
-        try {
-          const { execSync: execSync41 } = require4("node:child_process");
-          execSync41("npm update -g omnius 2>/dev/null || true", {
-            stdio: "pipe"
-          });
-        } catch {
-        }
-      });
-      jsonResponse(res, 200, { ok: true, message: "Update initiated" });
-      return;
-    }
     if (pathname === "/v1/share/generate" && method === "POST") {
       const body = await parseJsonBody(req3);
       const config = loadConfig();
@@ -753710,7 +754621,7 @@ import {
   appendFileSync as appendFileSync22,
   rmSync as rmSync17,
   readdirSync as readdirSync60,
-  statSync as statSync68,
+  statSync as statSync69,
   mkdirSync as mkdirSync111
 } from "node:fs";
 import { existsSync as existsSync174 } from "node:fs";
@@ -757396,6 +758307,17 @@ ${entry.fullContent}`
       case "status":
         if (_apiCallbacks?.onStatus)
           _apiCallbacks.onStatus(event.content ?? "");
+        if (event.steering) {
+          const stage2 = event.steering.state.replace(/_/g, " ");
+          const line = `Steering ${stage2}: ${event.content ?? event.steering.inputId}`;
+          if (isNeovimActive()) {
+            writeToNeovimOutput(`\x1B[38;5;81m${line}\x1B[0m\r
+`);
+          } else {
+            contentWrite(() => renderInfo(line));
+          }
+          break;
+        }
         if (event.toolName === "shell" && liveShellBlock && !isNeovimActive()) {
           appendShellLiveChunk(liveShellBlock.state, event.content ?? "");
           scheduleLiveShellRepaint();
@@ -759581,7 +760503,7 @@ This is an independent background session started from /background.`
             if (!entry.startsWith(partialName)) continue;
             const full = join185(searchDir, entry);
             try {
-              const st = statSync68(full);
+              const st = statSync69(full);
               const suffix = st.isDirectory() ? "/" : "";
               const display = isAbsolute18 ? full : full.startsWith(repoRoot + sep7) ? full.slice(repoRoot.length + 1) : full;
               completions.push(display + suffix);
@@ -760433,26 +761355,15 @@ Log: ${nexusLogPath}`
       currentConfig.backendUrl
     );
   });
-  Promise.resolve().then(() => (init_daemon(), daemon_exports)).then(async ({ ensureDaemon: ensureDaemon2, isDaemonRunning: isDaemonRunning2 }) => {
+  Promise.resolve().then(() => (init_daemon(), daemon_exports)).then(async ({ ensureDaemonVersion: ensureDaemonVersion2 }) => {
     const apiPort = parseInt(process.env["OMNIUS_PORT"] || "11435", 10);
-    if (await isDaemonRunning2(apiPort)) {
-      setTimeout(() => {
-        if (statusBar.isActive)
-          writeContent(
-            () => renderInfo(
-              `REST API: http://localhost:${apiPort} (shared daemon)`
-            )
-          );
-      }, 1500);
-      return;
-    }
-    const daemonOk = await ensureDaemon2();
-    if (daemonOk) {
+    const daemon = await ensureDaemonVersion2();
+    if (daemon.ok) {
       setTimeout(() => {
         if (statusBar.isActive)
           writeContent(
             () => renderInfo(
-              `REST API: http://localhost:${apiPort} (daemon started)`
+              `REST API: http://localhost:${apiPort} (${daemon.action === "restarted" ? "daemon upgraded" : daemon.action === "started" ? "daemon started" : "shared daemon"})`
             )
           );
       }, 1500);
@@ -762365,11 +763276,11 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
               }
               if (name10 === "voice_list_files") {
                 const baseDir = String(args?.dir ?? ".");
-                const { readdirSync: readdirSync62, statSync: statSync70 } = __require("node:fs");
+                const { readdirSync: readdirSync62, statSync: statSync71 } = __require("node:fs");
                 const { join: join190, resolve: resolve82 } = __require("node:path");
                 const base3 = baseDir.startsWith("/") ? baseDir : resolve82(join190(repoRoot, baseDir));
                 const items = readdirSync62(base3).slice(0, 200).map((f2) => {
-                  const s2 = statSync70(join190(base3, f2));
+                  const s2 = statSync71(join190(base3, f2));
                   return { name: f2, dir: s2.isDirectory(), size: s2.size };
                 });
                 return JSON.stringify({ dir: base3, items }, null, 2);
@@ -763639,7 +764550,14 @@ ${result.text}`;
           interpretation = null;
         }
         const packet = buildSteeringPacket(ingress, interpretation);
-        activeTask.runner.injectUserMessage(packet);
+        activeTask.runner.injectSteeringInput({
+          inputId: ingress.id,
+          content: packet,
+          source: "tui",
+          receivedAt: ingress.timestamp,
+          intent: isReplacement ? "replace" : classifySteeringIntent(input, "context_only"),
+          state: "received"
+        });
         activeTask.steeringPacketIds.add(ingress.id);
         appendSteeringLedgerEntry(repoRoot, {
           type: "ingress",
@@ -765202,7 +766120,7 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve80 } from "node:path";
-import { existsSync as existsSync176, statSync as statSync69 } from "node:fs";
+import { existsSync as existsSync176, statSync as statSync70 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config3) {
   const repoRoot = resolve80(opts.repoPath ?? cwd2());
@@ -765212,7 +766130,7 @@ async function indexRepoCommand(opts, _config3) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
-  const stat9 = statSync69(repoRoot);
+  const stat9 = statSync70(repoRoot);
   if (!stat9.isDirectory()) {
     printError(`Path is not a directory: ${repoRoot}`);
     process.exit(1);
@@ -765696,23 +766614,34 @@ async function serveCommand(opts, config) {
   const ollamaUrl = config.backendUrl || "http://127.0.0.1:11434";
   const isDaemon = opts.daemon || process.env["OMNIUS_DAEMON"] === "1";
   const isQuiet = opts.quiet || isDaemon;
+  let releaseDaemonClaim;
+  if (isDaemon) {
+    const { claimDaemonEndpoint: claimDaemonEndpoint2, releaseDaemonEndpointClaim: releaseDaemonEndpointClaim2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    const inheritedPort = parseInt(process.env["OMNIUS_DAEMON_LOCK_PORT"] ?? "", 10);
+    const claim = claimDaemonEndpoint2(
+      Number.isFinite(inheritedPort) && inheritedPort > 0 ? inheritedPort : port,
+      process.env["OMNIUS_DAEMON_LOCK_TOKEN"]
+    );
+    if (!claim) return;
+    releaseDaemonClaim = () => releaseDaemonEndpointClaim2(claim);
+  }
   if (!isQuiet) {
     printHeader("Omnius REST API");
     printInfo(`Starting API server on port ${port}...`);
     printInfo(`Backend: ${config.backendType} (${ollamaUrl})`);
   }
-  if (isDaemon) {
-    try {
-      const resp = await fetch(`http://127.0.0.1:${port}/health`, {
-        signal: AbortSignal.timeout(1500)
-      });
-      if (resp.ok) {
-        return;
+  try {
+    if (isDaemon) {
+      try {
+        const resp = await fetch(`http://127.0.0.1:${port}/health`, {
+          signal: AbortSignal.timeout(1500)
+        });
+        if (resp.ok) {
+          return;
+        }
+      } catch {
       }
-    } catch {
     }
-  }
-  try {
     const server2 = startApiServer({ port, ollamaUrl, quiet: isQuiet });
     if (isDaemon) {
       let lastActivity = Date.now();
@@ -765749,6 +766678,8 @@ async function serveCommand(opts, config) {
     } else {
       if (!isQuiet) printError(`API server failed: ${msg}`);
     }
+  } finally {
+    releaseDaemonClaim?.();
   }
 }
 var init_serve2 = __esm({
@@ -766246,6 +767177,8 @@ function parseCliArgs(argv) {
       live: { type: "boolean" },
       json: { type: "boolean", short: "j" },
       background: { type: "boolean" },
+      daemon: { type: "boolean" },
+      quiet: { type: "boolean" },
       "self-test": { type: "string" },
       help: { type: "boolean", short: "h" },
       version: { type: "boolean", short: "V" }
@@ -766269,6 +767202,8 @@ function parseCliArgs(argv) {
     local: values.local === true,
     json: values.json === true,
     background: values.background === true,
+    daemon: values.daemon === true,
+    quiet: values.quiet === true,
     selfTest: typeof values["self-test"] === "string" ? values["self-test"] : void 0,
     help: values.help === true,
     version: values.version === true
@@ -766494,8 +767429,8 @@ async function main() {
             port: parsed.servePort,
             model: parsed.model,
             verbose: parsed.verbose,
-            daemon: process.env["OMNIUS_DAEMON"] === "1",
-            quiet: process.argv.includes("--quiet") || process.env["OMNIUS_DAEMON"] === "1"
+            daemon: parsed.daemon === true || process.env["OMNIUS_DAEMON"] === "1",
+            quiet: parsed.quiet === true || process.env["OMNIUS_DAEMON"] === "1"
           },
           config
         );