omnius 1.0.554 → 1.0.555

package/dist/index.js

@@ -566247,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;
@@ -566286,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";
@@ -566295,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;
   }
 });
@@ -566513,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(),
@@ -578644,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)) {
@@ -578654,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")
@@ -578701,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);
@@ -578724,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()}`;
@@ -578739,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;
@@ -578932,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 });
@@ -579110,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;
@@ -579727,6 +579779,9 @@ 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";
   }
@@ -579864,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;
@@ -584623,6 +584678,7 @@ function buildBranchExtractionBrief(input) {
       maxWindowsPerRound: 3,
       maxTotalWindows: MAX_WINDOWS,
       maxPresentedLines: MAX_SNIPPET_LINES,
+      maxPresentedChars: MAX_PRESENTED_CHARS,
       maxInjectedChars: 2400
     }
   };
@@ -584962,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 {
@@ -584999,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++) {
@@ -585013,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) => ({
@@ -585215,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";
@@ -585223,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",
@@ -588139,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");
@@ -588238,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;
@@ -588612,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();
@@ -597176,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,
@@ -597184,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,
@@ -597239,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
         });
@@ -597258,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)
         };
@@ -597268,9 +597307,17 @@ ${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);
         }
@@ -597319,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() {
@@ -597393,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,
@@ -597427,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;
@@ -597463,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) {
@@ -597519,33 +597588,38 @@ ${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);
@@ -597576,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
@@ -597783,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;
         }
@@ -597846,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);
@@ -597875,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)
+              }
             }
           };
         }
@@ -597892,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]`,
@@ -597913,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]`
@@ -597932,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()
         });
@@ -597958,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)
+            }
           }
         };
       }
@@ -598017,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]`,
@@ -598035,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)
+            }
           }
         };
       }
@@ -600926,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;
           }
@@ -601338,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,
@@ -601726,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) {
@@ -601827,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({
@@ -602476,12 +602745,11 @@ Read the current file if needed, make a different concrete edit, or move to veri
               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));
-              const exactReadEvidenceEntry = tc.name === "file_read" && exactReadPath ? this._evidenceLedger.get(this._normalizeEvidencePath(exactReadPath)) : void 0;
-              const exactReadHasCuratedPayload = exactReadEvidenceEntry?.fidelity === "extract";
-              if (tc.name === "file_read" && exactReadEvidenceFresh && exactReadHasCuratedPayload && exactReadEvidence?.taskEpoch === this._taskEpoch && exactReadEvidence.mutationEpoch === fileMutationEpoch) {
+              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 curated = this._branchEvidenceByPath.get(path16) ?? [...this._branchEvidenceByPath.entries()].find(([candidate]) => this._normalizeEvidencePath(candidate) === path16)?.[1];
+                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,
@@ -602581,11 +602849,12 @@ Read the current file if needed, make a different concrete edit, or move to veri
                   }
                 }
                 const exactReadEvidence2 = exactReadEvidenceEpochs.get(toolFingerprint);
-                const exactFileReadReference = tc.name === "file_read" && exactReadEvidenceFresh2 && exactReadHasCuratedPayload && exactReadEvidence2?.taskEpoch === this._taskEpoch && exactReadEvidence2.mutationEpoch === fileMutationEpoch;
+                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 curated = this._branchEvidenceByPath.get(path16) ?? [...this._branchEvidenceByPath.entries()].find(([candidate]) => this._normalizeEvidencePath(candidate) === path16)?.[1];
+                  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,
@@ -602918,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);
@@ -602935,7 +603204,7 @@ ${cachedResult}`,
                                     payload: canonicalPayload,
                                     turn
                                   });
-                                  branchPreempted = {
+                                  branchEvidenceResult = {
                                     success: true,
                                     output: rehydrated,
                                     llmContent: rehydrated,
@@ -602962,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,
@@ -602995,8 +603264,8 @@ ${cachedResult}`,
                               }
                             }
                           }
-                          if (!branchPreempted) {
-                            branchPreempted = await this._preemptFileReadWithBranch({
+                          if (!branchEvidenceResult) {
+                            branchEvidenceResult = await this._extractFileReadEvidence({
                               callId: tc.id,
                               toolName: normalizedDispatchName,
                               args: tc.arguments,
@@ -603005,8 +603274,8 @@ ${cachedResult}`,
                               batchBudget: branchReadBatchBudget
                             });
                           }
-                          if (branchPreempted) {
-                            result = branchPreempted;
+                          if (branchEvidenceResult) {
+                            result = branchEvidenceResult;
                             fileReadSafetyChecked = true;
                           } else {
                             if (typeof tool.executeStream === "function") {
@@ -603261,6 +603530,7 @@ ${cachedResult}`,
                       taskEpoch: this._taskEpoch,
                       mutationEpoch: fileMutationEpoch
                     });
+                    this._registerReadCoverage("file_read", tc.arguments, toolFingerprint);
                   }
                   if (this._fileSummaryStore && result.success && result.output && result.output.length > 100) {
                     try {
@@ -605316,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)) {
@@ -605378,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;
               }
             }
@@ -605417,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)}...`,
@@ -605478,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);
@@ -605641,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) {
@@ -605680,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,
@@ -605804,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;
@@ -607012,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)
@@ -609359,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;
@@ -612350,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 = {
@@ -612486,7 +612759,7 @@ ${description}`
             }
           }
           if (shouldRetryThinkGuard || shouldRecoverFromEmpty) {
-            const retryMessages = injectNoThinkDirective(requestMessages);
+            const retryMessages = requestMessages;
             const retryBody = {
               model: this.model,
               messages: retryMessages,
@@ -612567,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,
@@ -612751,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,
@@ -613036,6 +613309,7 @@ var NexusAgenticBackend;
 var init_nexusBackend = __esm({
   "packages/orchestrator/dist/nexusBackend.js"() {
     "use strict";
+    init_textSanitize();
     NexusAgenticBackend = class _NexusAgenticBackend {
       sendFn;
       model;
@@ -613066,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;
@@ -619640,6 +619892,7 @@ __export(dist_exports3, {
   classifyHandoff: () => classifyHandoff,
   classifyKind: () => classifyKind,
   classifyOllamaProcesses: () => classifyOllamaProcesses,
+  classifySteeringIntent: () => classifySteeringIntent,
   cleanForStorage: () => cleanForStorage,
   cleanScaffolding: () => cleanScaffolding,
   cleanupStaleOllamaProcesses: () => cleanupStaleOllamaProcesses,
@@ -619858,6 +620111,9 @@ __export(dist_exports3, {
   skillShouldShow: () => skillShouldShow,
   specificityScore: () => specificityScore,
   stabilityFilePath: () => stabilityFilePath,
+  steeringGatesOldPlan: () => steeringGatesOldPlan,
+  steeringRequiresReconciliation: () => steeringRequiresReconciliation,
+  stripNoThinkPromptDirectives: () => stripNoThinkPromptDirectives,
   stripThinkTags: () => stripThinkTags,
   stripXmlControlBlocks: () => stripXmlControlBlocks,
   stripYamlFrontmatter: () => stripYamlFrontmatter,
@@ -635229,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}`,
@@ -635296,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:")) {
@@ -663866,6 +664122,7 @@ var daemon_exports = {};
 __export(daemon_exports, {
   claimDaemonEndpoint: () => claimDaemonEndpoint,
   ensureDaemon: () => ensureDaemon,
+  ensureDaemonVersion: () => ensureDaemonVersion,
   forceKillDaemon: () => forceKillDaemon,
   getDaemonPid: () => getDaemonPid,
   getDaemonReportedVersion: () => getDaemonReportedVersion,
@@ -664029,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");
@@ -664039,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;
@@ -664246,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) {
@@ -664280,16 +664545,16 @@ async function ensureDaemon() {
   if (!pid) {
     for (let i2 = 0; i2 < 20; i2++) {
       await new Promise((r2) => setTimeout(r2, 500));
-      if (await isDaemonRunning(port)) return true;
-    }
-    return false;
-  }
-  for (let i2 = 0; i2 < 20; i2++) {
-    await new Promise((r2) => setTimeout(r2, 500));
-    if (await isDaemonRunning(port)) {
-      return true;
+      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 {
@@ -664299,7 +664564,10 @@ async function ensureDaemon() {
   } catch {
   }
   releaseDaemonEndpointForCurrentProcess(port);
-  return false;
+  return finish(false, "failed", ready.observedVersion);
+}
+async function ensureDaemon() {
+  return (await ensureDaemonVersion()).ok;
 }
 async function getDaemonStatus() {
   const port = getDaemonPort();
@@ -687908,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;
@@ -703031,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 = {}) {
@@ -703511,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
   ];
@@ -706879,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);
@@ -707051,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) {
@@ -711612,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(
@@ -712112,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(
@@ -712190,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(
@@ -744452,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;
@@ -744605,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,
@@ -744918,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({
@@ -746593,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"]
     );
   }
@@ -750547,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();
@@ -758085,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();
@@ -761122,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);
@@ -764328,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",