omnius 1.0.549 → 1.0.551

package/dist/index.js

@@ -155716,7 +155716,7 @@ var require_snapshot_recorder = __commonJS({
   "../node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
     var { writeFile: writeFile27, readFile: readFile25, mkdir: mkdir23 } = __require("node:fs/promises");
-    var { dirname: dirname58, resolve: resolve82 } = __require("node:path");
+    var { dirname: dirname59, resolve: resolve82 } = __require("node:path");
     var { setTimeout: setTimeout3, clearTimeout: clearTimeout3 } = __require("node:timers");
     var { InvalidArgumentError, UndiciError } = require_errors2();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -155947,7 +155947,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         const resolvedPath = resolve82(path16);
-        await mkdir23(dirname58(resolvedPath), { recursive: true });
+        await mkdir23(dirname59(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
           snapshot
@@ -269609,15 +269609,15 @@ var init_ls = __esm({
 });
 
 // ../node_modules/@helia/unixfs/dist/src/commands/mkdir.js
-async function mkdir6(parentCid, dirname58, blockstore, options2 = {}) {
-  if (dirname58.includes("/")) {
+async function mkdir6(parentCid, dirname59, blockstore, options2 = {}) {
+  if (dirname59.includes("/")) {
     throw new InvalidParametersError4("Path must not have slashes");
   }
   const entry = await exporter2(parentCid, blockstore, options2);
   if (entry.type !== "directory") {
     throw new NotADirectoryError(`${parentCid.toString()} was not a UnixFS directory`);
   }
-  log16("creating %s", dirname58);
+  log16("creating %s", dirname59);
   const metadata = new UnixFS({
     type: "directory",
     mode: options2.mode,
@@ -269633,9 +269633,9 @@ async function mkdir6(parentCid, dirname58, blockstore, options2 = {}) {
   await blockstore.put(emptyDirCid, buf);
   const [directory, pblink] = await Promise.all([
     cidToDirectory(parentCid, blockstore, options2),
-    cidToPBLink(emptyDirCid, dirname58, blockstore, options2)
+    cidToPBLink(emptyDirCid, dirname59, blockstore, options2)
   ]);
-  log16("adding empty dir called %s to %c", dirname58, parentCid);
+  log16("adding empty dir called %s to %c", dirname59, parentCid);
   const result = await addLink(directory, pblink, blockstore, {
     ...options2,
     allowOverwriting: options2.force
@@ -270134,8 +270134,8 @@ var init_unixfs2 = __esm({
       async *ls(cid, options2 = {}) {
         yield* ls(cid, this.components.blockstore, options2);
       }
-      async mkdir(cid, dirname58, options2 = {}) {
-        return mkdir6(cid, dirname58, this.components.blockstore, options2);
+      async mkdir(cid, dirname59, options2 = {}) {
+        return mkdir6(cid, dirname59, this.components.blockstore, options2);
       }
       async rm(cid, path16, options2 = {}) {
         return rm3(cid, path16, this.components.blockstore, options2);
@@ -516914,7 +516914,7 @@ var require_path_browserify = __commonJS({
       _makeLong: function _makeLong(path16) {
         return path16;
       },
-      dirname: function dirname58(path16) {
+      dirname: function dirname59(path16) {
         assertPath(path16);
         if (path16.length === 0) return ".";
         var code8 = path16.charCodeAt(0);
@@ -566998,6 +566998,7 @@ function createCompletionLedger(input) {
   const ts = nowIso2(input.now);
   return {
     runId: input.runId,
+    ...typeof input.taskEpoch === "number" ? { taskEpoch: input.taskEpoch } : {},
     goal: cleanText(input.goal, 2e3),
     createdAtIso: ts,
     updatedAtIso: ts,
@@ -567183,7 +567184,23 @@ function appendUnresolved(items, text2, source) {
     }
   ];
 }
+function classifyCompletionProgress(entry) {
+  if (entry.progressClass)
+    return entry.progressClass;
+  const targets = [...entry.targetPaths ?? [], entry.rawRef ?? ""];
+  if (targets.some((target) => CONTROLLER_ARTIFACT_RE.test(target))) {
+    return "control_bookkeeping";
+  }
+  if (entry.role === "blocker")
+    return "blocker";
+  if (entry.kind === "file_change" || entry.role === "mutation") {
+    return "work_product";
+  }
+  return "observation";
+}
 function isMutationEvidence(entry) {
+  if (classifyCompletionProgress(entry) !== "work_product")
+    return false;
   if (entry.role === "mutation")
     return true;
   if (entry.kind === "file_change")
@@ -567314,10 +567331,12 @@ function saveCompletionLedger(filePath, ledger) {
 function loadCompletionLedger(filePath) {
   return JSON.parse(readFileSync66(filePath, "utf8"));
 }
+var CONTROLLER_ARTIFACT_RE;
 var init_completionLedger = __esm({
   "packages/orchestrator/dist/completionLedger.js"() {
     "use strict";
     init_completionContract();
+    CONTROLLER_ARTIFACT_RE = /(?:^|[\\/])\.omnius(?:[\\/]|$)/i;
   }
 });
 
@@ -571700,48 +571719,44 @@ function ago(ms) {
   const h = Math.floor(m2 / 60);
   return `${h}h ago`;
 }
-function computeNextActionHint(reconciled, recentFailures, focusDirective) {
-  if (focusDirective?.requiredNextAction) {
-    const reason = focusDirective.reason ? ` Reason: ${focusDirective.reason.slice(0, 180)}.` : "";
-    return `Active recovery directive requires ${focusDirective.requiredNextAction}.${reason} Follow that before completion or unrelated work.`;
-  }
+function computeNextActionHint(reconciled, recentFailures, _focusDirective) {
   if (recentFailures.length > 0) {
     const first2 = recentFailures[0];
-    return `Resolve or explicitly account for unresolved failure "${first2.stem}" (${first2.attempts} attempt${first2.attempts === 1 ? "" : "s"}). Do not infer completion from plan state while failures remain.`;
+    return `Unresolved failure: "${first2.stem}" (${first2.attempts} attempt${first2.attempts === 1 ? "" : "s"}).`;
   }
   const inProgress = reconciled.find((t2) => t2.reconciled === "in_progress");
   if (inProgress)
-    return `Continue your in-progress item: "${inProgress.content.slice(0, 100)}".`;
+    return `In-progress plan item: "${inProgress.content.slice(0, 100)}".`;
   const claimedMissing = reconciled.filter((t2) => t2.reconciled === "claimed_missing");
   if (claimedMissing.length > 0) {
     const first2 = claimedMissing[0];
     const missing = first2.artifactCheck?.find((c9) => c9.reason === "missing")?.path;
-    return `A completed todo claims an artifact that is missing on disk: "${first2.content.slice(0, 60)}" — expected ${missing ?? "an artifact"}. Either produce it or correct the todo.`;
+    return `Plan/disk mismatch: completed todo "${first2.content.slice(0, 60)}" claims missing ${missing ?? "artifact"}.`;
   }
   const claimedEmpty = reconciled.filter((t2) => t2.reconciled === "claimed_empty");
   if (claimedEmpty.length > 0) {
     const first2 = claimedEmpty[0];
-    return `A completed todo declares an empty artifact: "${first2.content.slice(0, 60)}". Fill it in or revise the todo.`;
+    return `Plan/disk mismatch: completed todo "${first2.content.slice(0, 60)}" declares an empty artifact.`;
   }
   const claimedNoProof = reconciled.filter((t2) => t2.reconciled === "claimed_no_proof");
   if (claimedNoProof.length > 0) {
     const first2 = claimedNoProof[0];
-    return `A completed todo has no on-disk evidence: "${first2.content.slice(0, 80)}". Add declaredArtifacts to the next todo_write so completion is verifiable.`;
+    return `Plan evidence gap: completed todo "${first2.content.slice(0, 80)}" has no declared on-disk evidence.`;
   }
   const pending2 = reconciled.filter((t2) => t2.reconciled === "pending");
   if (pending2.length > 0) {
     const first2 = pending2[0];
-    return `Next pending plan item: "${first2.content.slice(0, 100)}". Take direct action toward it.`;
+    return `Pending plan item: "${first2.content.slice(0, 100)}".`;
   }
   const completedUnverified = reconciled.filter((t2) => t2.reconciled === "completed_unverified");
   if (completedUnverified.length > 0) {
     const first2 = completedUnverified[0];
-    return `A completed todo has a verifyCommand that hasn't run during this snapshot: ${first2.rationale}`;
+    return `Verification evidence is absent for completed todo: ${first2.rationale}`;
   }
   if (reconciled.length === 0) {
-    return `No declared plan items are available. Continue from the active goal and evidence; report completion only with direct verification.`;
+    return `No declared plan items are available.`;
   }
-  return `Declared plan items have no visible gaps. Continue from the active goal and evidence; report completion only with direct verification.`;
+  return `Declared plan items have no visible disk gaps in this snapshot.`;
 }
 function regenerate(opts) {
   const startMs = Date.now();
@@ -571836,22 +571851,11 @@ function regenerate(opts) {
     }
   }
   lines.push(``);
-  if (opts.focusDirective?.requiredNextAction) {
-    lines.push(`ACTIVE RECOVERY DIRECTIVE:`);
-    lines.push(`  required_next_action=${opts.focusDirective.requiredNextAction}`);
-    if (opts.focusDirective.state) {
-      lines.push(`  state=${opts.focusDirective.state}`);
-    }
-    if (opts.focusDirective.reason) {
-      lines.push(`  reason=${opts.focusDirective.reason.slice(0, 240)}`);
-    }
-    lines.push(``);
-  }
   const nextActionHint = computeNextActionHint(reconciled, opts.recentFailures, opts.focusDirective);
-  lines.push(`SUGGESTED NEXT STEP (derived from gap analysis, not authoritative):`);
+  lines.push(`PLAN / FAILURE DIAGNOSTIC:`);
   lines.push(`  ${nextActionHint}`);
   lines.push(``);
-  lines.push(`This snapshot replaces re-derivation by tool calls. Prior <world-state> blocks have been stripped from this conversation. Re-listing the workspace or re-reading completed todos is unproductive — the data is in this block.`);
+  lines.push(`Snapshot scope: workspace scan, reconciled plan, and unresolved failures at generation time. Prior world-state snapshots are replaced on regeneration.`);
   lines.push(`</world-state>`);
   const block = lines.join("\n");
   return {
@@ -572696,35 +572700,8 @@ ${item.outputPreview ?? ""}`));
   return directive;
 }
 function renderDirectiveAsMessage(d2) {
-  if (d2.parseFallback) {
-    return "";
-  }
-  const lines = [];
-  lines.push(`[STUCK-STATE META-ANALYZER — REG-49]`);
-  lines.push(``);
-  lines.push(`A meta-analyzer sub-agent reviewed the recent tool-call pattern, the`);
-  lines.push(`current world state, and the plan; it produced a single concrete`);
-  lines.push(`unblocking action for you to take.`);
-  lines.push(``);
-  lines.push(`DIAGNOSIS: ${d2.diagnosis}`);
-  lines.push(``);
-  lines.push(`STOP DOING (anti-pattern): ${d2.anti_pattern}`);
-  lines.push(``);
-  lines.push(`DO NEXT:`);
-  lines.push(`  Tool: ${d2.next_action.tool}`);
-  const argsJson = JSON.stringify(d2.next_action.args_seed, null, 2);
-  lines.push(`  Args:`);
-  for (const ln of argsJson.split("\n"))
-    lines.push(`    ${ln}`);
-  lines.push(`  Rationale: ${d2.next_action.rationale}`);
-  lines.push(``);
-  lines.push(`AFTER THE ACTION, verify with: ${d2.verification}`);
-  lines.push(``);
-  lines.push(`This directive comes from a meta-analysis of YOUR recent activity. Treat`);
-  lines.push(`the args as a bounded recommendation, not permission to invent a target.`);
-  lines.push(`If its evidence is stale or insufficient, first refresh the cited target`);
-  lines.push(`or run the listed verification; do not repeat the anti-pattern.`);
-  return lines.join("\n");
+  void d2;
+  return "";
 }
 async function runStuckAnalyzer(opts) {
   const startMs = Date.now();
@@ -573102,42 +573079,8 @@ function parseFrameVerdict(rawResponse) {
   };
 }
 function renderVerdictAsMessage(v) {
-  if (v.parseFallback)
-    return "";
-  if (v.verdict === "continue")
-    return "";
-  const lines = [];
-  lines.push(`[PROBLEM-FRAME VALIDATION — REG-51 — ${v.verdict.toUpperCase()}]`);
-  lines.push(``);
-  lines.push(`A meta-strategy validator reviewed your goal, current sub-task, and recent`);
-  lines.push(`activity. Verdict:`);
-  lines.push(``);
-  lines.push(`  ${v.rationale}`);
-  lines.push(``);
-  if (v.verdict === "simplify" || v.verdict === "pivot") {
-    const rf = v.recommended_frame;
-    const verb = v.verdict === "simplify" ? "SHRINK YOUR CURRENT FRAME" : "PIVOT TO A DIFFERENT FRAME";
-    lines.push(`${verb}:`);
-    lines.push(``);
-    lines.push(`  New sub-task:       ${rf.new_subtask}`);
-    lines.push(`  Why this is better: ${rf.why_better}`);
-    lines.push(`  Done when:          ${rf.success_criterion}`);
-    lines.push(``);
-    lines.push(`Update your todo list to reflect this new framing on your next response.`);
-    lines.push(`Then take ONE concrete action toward the new sub-task. Do NOT continue`);
-    lines.push(`the previous approach — it has been judged ${v.verdict === "pivot" ? "wrong" : "too ambitious"} for`);
-    lines.push(`your current state.`);
-  } else if (v.verdict === "declare-blocked") {
-    lines.push(`DECLARE BLOCKED:`);
-    lines.push(``);
-    lines.push(`  ${v.blocker_summary}`);
-    lines.push(``);
-    lines.push(`Call task_complete with a summary that names this blocker EXPLICITLY. Do`);
-    lines.push(`not pretend the work is done; do not keep iterating. The validator has`);
-    lines.push(`determined no productive frame exists from this state. Surface the`);
-    lines.push(`blocker and let the user / next agent intervene.`);
-  }
-  return lines.join("\n");
+  void v;
+  return "";
 }
 async function runFrameValidator(opts) {
   const startMs = Date.now();
@@ -574029,9 +573972,8 @@ function buildTrajectoryCheckpoint(input) {
     doNotRepeat.push("Retrying the blocked action unchanged without new evidence.");
   } else if (focus) {
     assessment = "recovery_required";
-    nextAction = extractFocusNextAction(focus) || nextAction;
-    successEvidence = "The focus recovery requirement is satisfied by a fresh tool observation.";
-    doNotRepeat.push("Ignoring the active focus recovery directive.");
+    const focusDiagnostic = extractFocusNextAction(focus);
+    successEvidence = focusDiagnostic ? `Active controller directive remains unresolved: ${focusDiagnostic}` : "An active controller directive is unresolved; its evidence is recorded separately.";
   } else if (hasRecentFailure && !fullWriteRecoveredByMutation) {
     assessment = "recovery_required";
     nextAction = "Use the newest failure evidence to make one different, narrow diagnostic or repair action.";
@@ -574137,7 +574079,7 @@ function buildTrajectoryCheckpoint(input) {
 }
 function renderTrajectoryCheckpoint(checkpoint, maxChars = 1100) {
   const lines = [
-    "[TRAJECTORY CHECKPOINT]",
+    "[TRAJECTORY DIAGNOSTIC]",
     `revision=${checkpoint.revision} turn=${checkpoint.turn} trigger=${checkpoint.trigger}`,
     `Goal: ${checkpoint.goal}`,
     `Assessment: ${checkpoint.assessment}`,
@@ -574145,8 +574087,8 @@ function renderTrajectoryCheckpoint(checkpoint, maxChars = 1100) {
     checkpoint.currentStep ? `Current step: ${checkpoint.currentStep}` : null,
     // Keep the action contract ahead of explanatory evidence so truncation can
     // never hide the guard that the main agent must follow.
-    `Required next action: ${checkpoint.nextAction}`,
-    `Success evidence: ${checkpoint.successEvidence}`,
+    `Observed next action: ${checkpoint.nextAction}`,
+    `Observed success evidence: ${checkpoint.successEvidence}`,
     checkpoint.situationAssessment ? `${checkpoint.groundingSource === "model" ? "Reasoned situation" : "Safety orientation"}: ${checkpoint.situationAssessment}` : null,
     checkpoint.groundingEvidenceRefs?.length ? `Grounding evidence: ${checkpoint.groundingEvidenceRefs.join(", ")}` : null,
     checkpoint.completedWork.length > 0 ? `Completed evidence-backed work: ${checkpoint.completedWork.join("; ")}` : null,
@@ -574154,9 +574096,8 @@ function renderTrajectoryCheckpoint(checkpoint, maxChars = 1100) {
     ...checkpoint.groundedFacts.map((fact) => `- [${fact.evidence}; ${fact.freshness}] ${fact.statement}`),
     checkpoint.openQuestions.length > 0 ? "Open questions:" : null,
     ...checkpoint.openQuestions.map((question) => `- ${question}`),
-    checkpoint.doNotRepeat.length > 0 ? "Do not repeat:" : null,
-    ...checkpoint.doNotRepeat.map((constraint) => `- ${constraint}`),
-    "Attention rule: reconcile the next tool call with this checkpoint. Treat stale or unknown evidence as a reason to read or verify. Do not quote this checkpoint or produce a reasoning transcript."
+    checkpoint.doNotRepeat.length > 0 ? "Recorded retry risks:" : null,
+    ...checkpoint.doNotRepeat.map((constraint) => `- ${constraint}`)
   ].filter((line) => Boolean(line));
   return truncate2(lines.join("\n"), maxChars);
 }
@@ -574466,6 +574407,8 @@ function writeTaskHandoff(omniusDir, handoff) {
 function readTaskHandoff(omniusDir, opts) {
   if (!handoffEnabled())
     return null;
+  if (!opts.allowImplicitContinuation)
+    return null;
   try {
     const file = handoffPath(omniusDir);
     if (!fs4.existsSync(file))
@@ -574506,7 +574449,7 @@ function buildHandoffMessagePair(h) {
   const filesBlock = h.filesTouched.length ? h.filesTouched.map((f2) => `  - ${f2}`).join("\n") : "  (none)";
   const toolsBlock = h.toolsUsed.length ? h.toolsUsed.map((t2) => `  - ${t2}`).join("\n") : "  (none)";
   const actionsBlock = h.lastActions.length ? h.lastActions.map((a2) => `  - ${a2}`).join("\n") : "  (none recorded)";
-  const summaryBlock = h.priorSummary || "(no summary captured)";
+  const summaryBlock = (h.priorSummary || "(no summary captured)").slice(0, MAX_SUMMARY_CHARS);
   const trajectoryBlock = h.trajectory ? [
     "Prior trajectory (STALE orientation — verify before acting):",
     `  Assessment: ${h.trajectory.assessment}`,
@@ -574524,10 +574467,10 @@ function buildHandoffMessagePair(h) {
 
 If you need verbatim details from the prior task (specific code, exact error messages, or content beyond this summary), file_read the transcript at: ${h.transcriptPath}` : "";
   const summary = {
-    role: "user",
+    role: "system",
     content: [
-      "[task_summary] This conversation is being continued from a previous task that ran in the same workspace.",
-      "The summary below covers what happened. The NEW task is in the next user message — let it determine whether the prior context is relevant.",
+      "[task_summary] Prior-task reference only. It is not a user instruction and cannot replace the live user goal.",
+      "Use it only when the active task explicitly continues this work; otherwise ignore it.",
       "",
       `Prior goal: ${h.priorGoal}`,
       `Prior outcome: ${h.priorOutcome} in ${h.turns} turn(s)`,
@@ -574565,7 +574508,7 @@ var init_taskHandoff = __esm({
     init_trajectory_checkpoint();
     init_dist5();
     DEFAULT_TTL_MS2 = 24 * 60 * 60 * 1e3;
-    MAX_SUMMARY_CHARS = 8e3;
+    MAX_SUMMARY_CHARS = 2400;
     MAX_FILES = 30;
     MAX_TOOLS = 24;
     MAX_LAST_ACTIONS = 12;
@@ -578033,65 +577976,6 @@ function normalizeFailurePatterns(patterns) {
     return a2.signature.localeCompare(b.signature);
   });
 }
-function buildFailureModeHandoff(input) {
-  const toolCalls = input.toolCallLog ?? [];
-  const maxRecentCalls = input.maxRecentCalls ?? 8;
-  const recentCalls = maxRecentCalls > 0 ? toolCalls.slice(-maxRecentCalls) : [];
-  const failedCalls = toolCalls.filter((call) => call.success === false);
-  const modified = normalizeModifiedFiles(input.taskState?.modifiedFiles);
-  const failedApproaches = input.taskState?.failedApproaches ?? [];
-  const completedSteps = input.taskState?.completedSteps ?? [];
-  const pendingSteps = input.taskState?.pendingSteps ?? [];
-  const currentStep = cleanInline(input.taskState?.currentStep, 180);
-  const nextAction = cleanInline(input.taskState?.nextAction, 180);
-  const goal = cleanInline(input.taskGoal || input.taskState?.goal || input.taskState?.originalGoal || "", 260);
-  const patterns = normalizeFailurePatterns(input.errorPatterns).slice(0, input.maxPatterns ?? 10);
-  if (patterns.length === 0 && recentCalls.length === 0 && modified.length === 0 && failedApproaches.length === 0 && !goal) {
-    return null;
-  }
-  const lines = ["[FAILURE-MODE INTAKE]"];
-  if (goal)
-    lines.push(`Goal: ${goal}`);
-  if (patterns.length > 0) {
-    lines.push("Top persisted failure modes:");
-    for (const p2 of patterns) {
-      const guidance = p2.guidance ? ` - ${p2.guidance}` : "";
-      lines.push(`- ${p2.signature} x${p2.count}${guidance}`);
-    }
-  }
-  if (recentCalls.length > 0) {
-    const total = toolCalls.length;
-    const failed = failedCalls.length;
-    const mutations = toolCalls.filter((call) => call.mutated || (call.mutatedFiles?.length ?? 0) > 0).length;
-    lines.push(`Current run: ${total} tool calls, ${failed} failed, ${mutations} mutation calls.`);
-    const lastFailure = failedCalls[failedCalls.length - 1];
-    if (lastFailure) {
-      const preview = cleanInline(lastFailure.outputPreview, 240);
-      lines.push(`Last raw failure: ${lastFailure.name}${preview ? ` - ${preview}` : ""}`);
-    }
-  }
-  if (modified.length > 0) {
-    lines.push(`Files touched: ${modified.slice(-8).map(([path16, action]) => `${path16} (${action})`).join(", ")}`);
-  } else {
-    lines.push("Files touched: none recorded.");
-  }
-  if (completedSteps.length > 0) {
-    lines.push(`Recent completed steps: ${completedSteps.slice(-4).join("; ")}`);
-  }
-  if (currentStep)
-    lines.push(`Current step: ${currentStep}`);
-  if (failedApproaches.length > 0) {
-    lines.push(`Failed approaches: ${failedApproaches.slice(-4).join("; ")}`);
-  }
-  if (pendingSteps.length > 0) {
-    lines.push(`Remaining work: ${pendingSteps.slice(0, 5).join("; ")}`);
-  } else if (nextAction) {
-    lines.push(`Next action: ${nextAction}`);
-  }
-  lines.push("Operating rule: base the next move on the raw failure/output state above; do not repeat the same failed approach unchanged.");
-  lines.push("[/FAILURE-MODE INTAKE]");
-  return lines.join("\n");
-}
 function computeCommitProgressGate(input) {
   const cooldown = input.cooldownTurns ?? 4;
   if (typeof input.lastInjectedTurn === "number" && input.lastInjectedTurn >= 0 && input.turn - input.lastInjectedTurn < cooldown) {
@@ -578678,6 +578562,88 @@ context_fabric: included=${included.length} dropped=${dropped.length} truncated=
 });
 
 // packages/orchestrator/dist/context-compiler.js
+function isControllerStateMessage(message2) {
+  return typeof message2.content === "string" && message2.content.includes(CONTROLLER_STATE_MARKER);
+}
+function isActionGroundTruthMessage(message2) {
+  return typeof message2.content === "string" && message2.content.includes(ACTION_GROUND_TRUTH_MARKER);
+}
+function isProtectedControllerMessage(message2) {
+  return isControllerStateMessage(message2) || isActionGroundTruthMessage(message2);
+}
+function modelFacingMessageCap(message2) {
+  if (isControllerStateMessage(message2)) {
+    return MODEL_FACING_CONTROLLER_STATE_CHAR_CAP;
+  }
+  if (isActionGroundTruthMessage(message2)) {
+    return MODEL_FACING_ACTION_GROUND_TRUTH_CHAR_CAP;
+  }
+  if (message2.role === "tool")
+    return MODEL_FACING_TOOL_CHAR_CAP;
+  if (message2.role === "system")
+    return MODEL_FACING_SYSTEM_CHAR_CAP;
+  return messageText(message2.content).length;
+}
+function stripLegacyRuntimeControlFragments(content) {
+  let out = content;
+  out = out.replace(new RegExp(`(?:^|\\n)\\s*${LEGACY_RUNTIME_CONTROL_BLOCK_START_RE.source}[\\s\\S]*?(?=\\n\\s*\\n|\\n(?=\\s*#{1,6}\\s)|\\n(?=\\s*\\[(?:CONTROLLER STATE v1|RECENT ACTION GROUND TRUTH)\\])|$)`, "gim"), "\n");
+  const pieces = out.split(/(\n\s*\n)/);
+  out = pieces.map((piece) => LEGACY_RUNTIME_CONTROL_FRAGMENT_RE.test(piece) ? "" : piece).join("");
+  return collapseWhitespace(out);
+}
+function splitOversizedSystemMessages(messages2) {
+  const out = [];
+  for (const message2 of messages2) {
+    if (message2.role !== "system" || typeof message2.content !== "string" || isProtectedControllerMessage(message2) || message2.content.length <= MODEL_FACING_SYSTEM_CHAR_CAP) {
+      out.push(message2);
+      continue;
+    }
+    let remaining = message2.content.trim();
+    while (remaining.length > MODEL_FACING_SYSTEM_CHAR_CAP) {
+      const window2 = remaining.slice(0, MODEL_FACING_SYSTEM_CHAR_CAP);
+      const boundary = Math.max(window2.lastIndexOf("\n\n"), window2.lastIndexOf("\n"));
+      const cut = boundary >= Math.floor(MODEL_FACING_SYSTEM_CHAR_CAP * 0.5) ? boundary : MODEL_FACING_SYSTEM_CHAR_CAP;
+      const chunk = remaining.slice(0, cut).trim();
+      if (chunk)
+        out.push({ ...message2, content: chunk });
+      remaining = remaining.slice(cut).trimStart();
+    }
+    if (remaining)
+      out.push({ ...message2, content: remaining });
+  }
+  return out;
+}
+function isCurrentGoalMessage(message2) {
+  return typeof message2.content === "string" && message2.content.includes("[CURRENT USER GOAL]");
+}
+function applyModelFacingBudget(messages2, preserveFirstSystem) {
+  const reservedTransaction = latestResolvedToolTransaction(messages2);
+  const reservedChars = [...reservedTransaction].reduce((sum2, index) => sum2 + modelFacingReservedChars(messages2[index]), 0);
+  let remaining = Math.max(0, MODEL_FACING_CONTEXT_CHAR_BUDGET - reservedChars);
+  const kept = [];
+  for (let index = 0; index < messages2.length; index++) {
+    const message2 = messages2[index];
+    const content = messageText(message2.content);
+    const isReservedTransactionMessage = reservedTransaction.has(index);
+    const isPriorityIntent = message2.role === "user" || isCurrentGoalMessage(message2);
+    const perMessageCap = modelFacingMessageCap(message2);
+    const isProtectedController = isProtectedControllerMessage(message2);
+    const allowed = isReservedTransactionMessage ? perMessageCap : isPriorityIntent ? content.length : isProtectedController ? perMessageCap : Math.min(remaining, perMessageCap);
+    if (!isReservedTransactionMessage && !isPriorityIntent && !isProtectedController && allowed <= 0) {
+      continue;
+    }
+    const bounded = content.length > allowed && allowed > 0 ? `${content.slice(0, Math.max(0, allowed - 83))}
+[truncated_by_context_budget: retained higher-priority current intent/evidence]` : content;
+    if (!isReservedTransactionMessage && !isPriorityIntent && !isProtectedController && !bounded) {
+      continue;
+    }
+    kept.push(typeof message2.content === "string" ? { ...message2, content: bounded } : message2);
+    if (!isReservedTransactionMessage && !isPriorityIntent) {
+      remaining = Math.max(0, remaining - bounded.length);
+    }
+  }
+  return kept;
+}
 function collapseWhitespace(text2) {
   return text2.replace(/\r\n/g, "\n").split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -578710,10 +578676,89 @@ function messageText(content) {
     return "";
   }).filter(Boolean).join("\n");
 }
+function toolCallIds(message2) {
+  const calls = message2["tool_calls"];
+  if (!Array.isArray(calls))
+    return [];
+  return calls.flatMap((call) => {
+    if (!call || typeof call !== "object")
+      return [];
+    const id2 = call["id"];
+    return typeof id2 === "string" && id2 ? [id2] : [];
+  });
+}
+function hasToolCallsMetadata(message2) {
+  return Array.isArray(message2["tool_calls"]);
+}
+function linkedToolCallId(message2) {
+  const id2 = message2["tool_call_id"];
+  return typeof id2 === "string" && id2 ? id2 : null;
+}
+function latestResolvedToolTransaction(messages2) {
+  const resultIndexesById = /* @__PURE__ */ new Map();
+  for (let index = 0; index < messages2.length; index++) {
+    const message2 = messages2[index];
+    if (message2.role !== "tool")
+      continue;
+    const id2 = linkedToolCallId(message2);
+    if (!id2)
+      continue;
+    const indexes = resultIndexesById.get(id2) ?? [];
+    indexes.push(index);
+    resultIndexesById.set(id2, indexes);
+  }
+  for (let index = messages2.length - 1; index >= 0; index--) {
+    const message2 = messages2[index];
+    if (message2.role !== "assistant")
+      continue;
+    const callIds = toolCallIds(message2);
+    if (callIds.length === 0 || !callIds.every((id2) => resultIndexesById.has(id2))) {
+      continue;
+    }
+    const transaction = /* @__PURE__ */ new Set([index]);
+    for (const id2 of callIds) {
+      for (const resultIndex of resultIndexesById.get(id2) ?? []) {
+        transaction.add(resultIndex);
+      }
+    }
+    return transaction;
+  }
+  return /* @__PURE__ */ new Set();
+}
+function modelFacingReservedChars(message2) {
+  const content = messageText(message2.content);
+  const cap = modelFacingMessageCap(message2);
+  return Math.min(content.length, cap);
+}
+function retireLinkedAssistantReadIntents(messages2) {
+  const resolvedToolCallIds = new Set(messages2.filter((message2) => message2.role === "tool").map(linkedToolCallId).filter((id2) => id2 !== null));
+  return messages2.map((message2, index) => {
+    const callIds = toolCallIds(message2);
+    let nextNonSystemMessage;
+    for (let candidateIndex = index + 1; candidateIndex < messages2.length; candidateIndex++) {
+      const candidate = messages2[candidateIndex];
+      if (candidate.role === "system")
+        continue;
+      nextNonSystemMessage = candidate;
+      break;
+    }
+    const hasLegacyAdjacentToolResult = message2.role === "assistant" && !hasToolCallsMetadata(message2) && nextNonSystemMessage?.role === "tool" && linkedToolCallId(nextNonSystemMessage) === null;
+    if (message2.role !== "assistant" || typeof message2.content !== "string" || !(callIds.some((id2) => resolvedToolCallIds.has(id2)) || hasLegacyAdjacentToolResult) || !/\b(?:i|we)\s+(?:need|will|should|have)\s+to\s+(?:read|inspect|open)\b/i.test(message2.content)) {
+      return message2;
+    }
+    return { ...message2, content: ASSISTANT_READ_INTENT_RETIRED_MARKER };
+  });
+}
 function runtimeControlSemanticKey(content) {
   const normalized = content.replace(/\s+/g, " ").trim().toLowerCase();
   if (!normalized)
     return null;
+  if (content.includes(CONTROLLER_STATE_MARKER)) {
+    return "context.controller-state";
+  }
+  if (content.includes(ACTION_GROUND_TRUTH_MARKER)) {
+    return "context.action-ground-truth";
+  }
   if (content.includes("[ACTIVE CONTEXT FRAME]"))
     return "context.active-frame";
   if (content.includes("[TRAJECTORY CHECKPOINT]"))
@@ -578799,8 +578844,16 @@ function retireDuplicateToolFailures(messages2) {
 function prepareModelFacingApiMessages(input) {
   const preserveFirstSystem = input.preserveFirstSystem !== false;
   const sanitized = [];
-  for (let index = 0; index < input.messages.length; index++) {
-    const message2 = input.messages[index];
+  const withoutLegacyControl = input.messages.flatMap((message2) => {
+    if (message2.role !== "system" || typeof message2.content !== "string" || isProtectedControllerMessage(message2)) {
+      return [message2];
+    }
+    const stripped = stripLegacyRuntimeControlFragments(message2.content);
+    return stripped ? [{ ...message2, content: stripped }] : [];
+  });
+  const independentlyBounded = splitOversizedSystemMessages(withoutLegacyControl);
+  for (let index = 0; index < independentlyBounded.length; index++) {
+    const message2 = independentlyBounded[index];
     if (message2.role === "system" && typeof message2.content === "string") {
       if (preserveFirstSystem && sanitized.length === 0) {
         sanitized.push({ ...message2 });
@@ -578859,7 +578912,7 @@ function prepareModelFacingApiMessages(input) {
     const insertAt = preserveFirstSystem && deduped[0]?.role === "system" ? 1 : 0;
     deduped.splice(insertAt, 0, goalMessage);
   }
-  return deduped;
+  return retireLinkedAssistantReadIntents(applyModelFacingBudget(deduped, preserveFirstSystem));
 }
 function deriveCurrentGoal(input) {
   const explicit = sanitizeModelVisibleContextText(input.explicitGoal ?? "");
@@ -578892,9 +578945,36 @@ function normalizeContextSignalsForModel(signals) {
   }
   return { signals: normalized, rejected };
 }
+function typeControllerSignal(signal) {
+  if (signal.modelVisible === false)
+    return signal;
+  if (signal.content.includes(CONTROLLER_STATE_MARKER)) {
+    return {
+      ...signal,
+      id: "controller-state-v1",
+      dedupeKey: "context.controller_state_v1",
+      semanticKey: "context.controller_state_v1",
+      conflictGroup: "context.controller_state",
+      priority: Math.max(signal.priority ?? 0, PRIORITY.GOAL + 15),
+      ttlTurns: 1
+    };
+  }
+  if (signal.content.includes(ACTION_GROUND_TRUTH_MARKER)) {
+    return {
+      ...signal,
+      id: "recent-action-ground-truth",
+      dedupeKey: "context.recent_action_ground_truth",
+      semanticKey: "context.recent_action_ground_truth",
+      conflictGroup: "context.action_ground_truth",
+      priority: Math.max(signal.priority ?? 0, PRIORITY.GOAL + 14),
+      ttlTurns: 1
+    };
+  }
+  return signal;
+}
 function compileContextFrameV2(input) {
   const builder = input.builder ?? new ContextFrameBuilder();
-  const normalized = normalizeContextSignalsForModel(input.signals);
+  const normalized = normalizeContextSignalsForModel(input.signals.map(typeControllerSignal));
   const goal = deriveCurrentGoal({
     explicitGoal: input.currentGoal,
     signals: normalized.signals
@@ -578927,15 +579007,28 @@ function compileContextFrameV2(input) {
       warnings: [...new Set(warnings)],
       admittedSignals: frame.included.length,
       rejectedSignals: normalized.rejected.length,
-      hadConcreteGoal: goal.concrete
+      hadConcreteGoal: goal.concrete,
+      admittedChars: frame.included.reduce((total, signal) => total + signal.content.length, 0),
+      droppedChars: normalized.rejected.reduce((total, signal) => total + signal.content.length, 0),
+      droppedSources: normalized.rejected.map((signal) => signal.source)
     }
   };
 }
-var RESTORE_NOISE_LINE_RE, RUNTIME_GUIDANCE_RE, ACTIVE_CONTEXT_RE;
+var MODEL_FACING_CONTEXT_CHAR_BUDGET, MODEL_FACING_TOOL_CHAR_CAP, MODEL_FACING_SYSTEM_CHAR_CAP, MODEL_FACING_CONTROLLER_STATE_CHAR_CAP, MODEL_FACING_ACTION_GROUND_TRUTH_CHAR_CAP, CONTROLLER_STATE_MARKER, ACTION_GROUND_TRUTH_MARKER, LEGACY_RUNTIME_CONTROL_FRAGMENT_RE, LEGACY_RUNTIME_CONTROL_BLOCK_START_RE, ASSISTANT_READ_INTENT_RETIRED_MARKER, RESTORE_NOISE_LINE_RE, RUNTIME_GUIDANCE_RE, ACTIVE_CONTEXT_RE;
 var init_context_compiler = __esm({
   "packages/orchestrator/dist/context-compiler.js"() {
     "use strict";
     init_context_fabric();
+    MODEL_FACING_CONTEXT_CHAR_BUDGET = 48e3;
+    MODEL_FACING_TOOL_CHAR_CAP = 6e3;
+    MODEL_FACING_SYSTEM_CHAR_CAP = 8e3;
+    MODEL_FACING_CONTROLLER_STATE_CHAR_CAP = 4e3;
+    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_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;
     RUNTIME_GUIDANCE_RE = /\[RUNTIME_GUIDANCE_INTAKE v\d+\][\s\S]*?<<<RUNTIME_GUIDANCE>>>\s*([\s\S]*?)\s*<<<END_RUNTIME_GUIDANCE>>>[\s\S]*?\[\/RUNTIME_GUIDANCE_INTAKE\]/g;
     ACTIVE_CONTEXT_RE = /\[ACTIVE CONTEXT FRAME\][\s\S]*?(?=\n\[ACTIVE CONTEXT FRAME\]|$)/g;
@@ -580067,8 +580160,8 @@ var init_adversaryStream = __esm({
           return;
         try {
           const { writeFileSync: writeFileSync97, mkdirSync: mkdirSync114, existsSync: existsSync177 } = __require("node:fs");
-          const { dirname: dirname58 } = __require("node:path");
-          const dir = dirname58(this.persistPath);
+          const { dirname: dirname59 } = __require("node:path");
+          const dir = dirname59(this.persistPath);
           if (!existsSync177(dir))
             mkdirSync114(dir, { recursive: true });
           writeFileSync97(this.persistPath, JSON.stringify({ ledger: this.ledger }, null, 2));
@@ -580922,6 +581015,37 @@ var init_debugArtifactLibrary = __esm({
 });
 
 // packages/orchestrator/dist/focusSupervisor.js
+function satisfactionForRequiredAction(action) {
+  switch (action) {
+    case "read_authoritative_target":
+    case "disambiguate_edit_match":
+      return { kind: "fresh_read" };
+    case "run_verification":
+      return { kind: "verification" };
+    case "update_todos":
+      return { kind: "todo_update" };
+    case "report_blocked":
+    case "report_incomplete":
+      return { kind: "blocked_completion" };
+    default:
+      return { kind: "distinct_action" };
+  }
+}
+function inferDirectiveSource(input) {
+  if (/stale|hash|authoritative target|ambiguous/i.test(input.reason)) {
+    return "stale_write";
+  }
+  if (input.requiredNextAction === "run_verification") {
+    return "verification_failure";
+  }
+  if (input.requiredNextAction === "use_cached_evidence") {
+    return "duplicate_action";
+  }
+  if (input.requiredNextAction === "report_blocked" || input.requiredNextAction === "report_incomplete") {
+    return "completion_gate";
+  }
+  return "repeated_failure";
+}
 function resolveFocusSupervisorSilent(envValue = process.env["OMNIUS_FOCUS_SUPERVISOR_SILENT"]) {
   const normalized = String(envValue ?? "").trim().toLowerCase();
   if (normalized === "0" || normalized === "false" || normalized === "off") {
@@ -581294,6 +581418,10 @@ var init_focusSupervisor = __esm({
       availableTools = null;
       /** SILENCE: when true, block() downgrades to pass() (never stops a call). */
       silent;
+      taskEpoch;
+      directiveTtlTurns;
+      lastObservedTurn = 0;
+      onDirectiveLifecycle;
       constructor(options2 = {}) {
         this.mode = options2.mode ?? "auto";
         this.modelTier = options2.modelTier ?? "large";
@@ -581302,6 +581430,9 @@ var init_focusSupervisor = __esm({
         this.availableTools = options2.availableTools ? new Set(Array.from(options2.availableTools)) : null;
         this.convergenceBreaker = options2.convergenceBreaker ?? null;
         this.familyCwd = options2.cwd;
+        this.taskEpoch = Math.max(0, Math.floor(options2.taskEpoch ?? 0));
+        this.directiveTtlTurns = Math.max(1, Math.floor(options2.directiveTtlTurns ?? (this.modelTier === "large" ? 1 : 2)));
+        this.onDirectiveLifecycle = options2.onDirectiveLifecycle;
       }
       get enabled() {
         return this.mode !== "off";
@@ -581309,6 +581440,69 @@ var init_focusSupervisor = __esm({
       get currentDirective() {
         return this.directive;
       }
+      /**
+       * A task redirect/replacement is a control boundary. Old directives remain
+       * auditable through telemetry but cannot survive into the new task epoch.
+       */
+      setTaskEpoch(taskEpoch, turn = this.lastObservedTurn) {
+        const next = Math.max(0, Math.floor(taskEpoch));
+        if (next === this.taskEpoch)
+          return;
+        if (this.directive) {
+          this.transitionDirective("superseded", turn, `task epoch changed from ${this.taskEpoch} to ${next}`);
+        }
+        this.taskEpoch = next;
+        this.state = "observe";
+        this.ignoredDirectiveStreak = 0;
+        this.lastIgnoredDirectiveTurn = null;
+        this.repeatedViolationCounts.clear();
+      }
+      /**
+       * Controller integration point for structured detectors. It replaces the
+       * current directive only when the supplied evidence is newer or materially
+       * changes the recovery requirement; callers must not pass model prose alone.
+       */
+      activateEvidenceDirective(input) {
+        if (!this.enabled)
+          return null;
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, input.turn);
+        return this.setDirective({
+          turn: input.turn,
+          state: input.state ?? "single_next_action",
+          reason: input.reason,
+          requiredNextAction: input.requiredNextAction,
+          forbiddenActionFamilies: input.forbiddenActionFamilies ?? [],
+          source: input.source,
+          evidenceRefs: input.evidenceRefs,
+          evidenceStateVersion: input.evidenceStateVersion,
+          satisfaction: input.satisfaction
+        });
+      }
+      supersedeActiveDirective(reason, turn = this.lastObservedTurn, supersededBy) {
+        this.transitionDirective("superseded", turn, reason, supersededBy);
+      }
+      cancelActiveDirective(reason, turn = this.lastObservedTurn) {
+        this.transitionDirective("cancelled", turn, reason);
+      }
+      /** A compact, factual record for a controller frame; no directive history. */
+      compactDirective(turn = this.lastObservedTurn) {
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, turn);
+        this.expireDirectiveIfNeeded(this.lastObservedTurn);
+        const directive = this.directive;
+        if (!directive)
+          return null;
+        return {
+          id: directive.id,
+          taskEpoch: directive.taskEpoch ?? this.taskEpoch,
+          source: directive.source ?? "manual",
+          state: directive.state,
+          requiredNextAction: directive.requiredNextAction,
+          evidenceRefs: directive.evidenceRefs ?? [],
+          evidenceStateVersion: directive.evidenceStateVersion ?? 0,
+          expiresAfterTurn: directive.expiresAfterTurn,
+          satisfaction: directive.satisfaction
+        };
+      }
       /**
        * CE-A1: the runner rehydrated evicted evidence back into the model's
        * window. Any read-oriented directive is now satisfiable (or already
@@ -581345,7 +581539,10 @@ var init_focusSupervisor = __esm({
       shellFailureRequiredNextAction() {
         return this.silent && this.modelTier === "small" ? "creative_pivot_or_research" : "use_cached_evidence";
       }
-      snapshot() {
+      snapshot(turn) {
+        const observedTurn = turn === void 0 ? this.lastObservedTurn : Math.max(this.lastObservedTurn, Math.max(0, Math.floor(turn)));
+        this.lastObservedTurn = observedTurn;
+        this.expireDirectiveIfNeeded(observedTurn);
         return {
           mode: this.mode,
           enabled: this.enabled,
@@ -581359,22 +581556,36 @@ var init_focusSupervisor = __esm({
       observeContext(snapshot) {
         this.lastContext = snapshot;
       }
-      renderFrame() {
+      renderFrame(turn = this.lastObservedTurn) {
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, turn);
+        this.expireDirectiveIfNeeded(this.lastObservedTurn);
         if (!this.enabled || !this.directive)
           return null;
+        if (this.modelTier === "large")
+          return null;
         const d2 = this.directive;
         return [
-          "[FOCUS SUPERVISOR]",
+          "[ACTIVE DIRECTIVE STATE]",
+          `task_epoch=${d2.taskEpoch ?? this.taskEpoch}`,
           `state=${d2.state}`,
           `directive_id=${d2.id}`,
+          `lifecycle=${d2.lifecycleState ?? "active"}`,
+          `source=${d2.source ?? "manual"}`,
           `required_next_action=${d2.requiredNextAction}`,
-          `reason=${d2.reason}`,
+          `evidence_refs=${(d2.evidenceRefs ?? []).join(",") || "none"}`,
+          `evidence_state_version=${d2.evidenceStateVersion ?? 0}`,
+          d2.expiresAfterTurn !== void 0 ? `expires_after_turn=${d2.expiresAfterTurn}` : "expires_after_turn=unknown",
+          d2.satisfaction ? `satisfaction=${d2.satisfaction.kind}` : "",
+          `diagnosis=${d2.reason}`,
           d2.forbiddenActionFamilies.length ? `forbidden_action_families=${d2.forbiddenActionFamilies.join(", ")}` : "",
-          d2.ignoredCount > 0 ? `ignored_count=${d2.ignoredCount}` : "",
-          "Follow the required next action before returning to broad exploration or completion."
+          d2.ignoredCount > 0 ? `ignored_count=${d2.ignoredCount}` : ""
         ].filter(Boolean).join("\n");
       }
       evaluateProposedCall(input) {
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, input.turn);
+        if (input.taskEpoch !== void 0)
+          this.setTaskEpoch(input.taskEpoch, input.turn);
+        this.expireDirectiveIfNeeded(input.turn);
         this.lastContext = input.context ?? this.lastContext;
         if (!this.enabled)
           return this.pass();
@@ -581534,14 +581745,14 @@ var init_focusSupervisor = __esm({
         return this.pass();
       }
       observeToolResult(input) {
+        this.lastObservedTurn = Math.max(this.lastObservedTurn, input.turn);
+        this.expireDirectiveIfNeeded(input.turn);
         if (!this.enabled)
           return;
-        if (input.mutated) {
+        if (input.mutated)
           this.sawMutationSinceFailure = true;
-          this.clearSatisfiedDirective("mutation landed", input.turn);
-          return;
-        }
-        if (input.success && input.alreadyApplied) {
+        const satisfiesAlreadyApplied = this.directive?.satisfaction?.kind === "distinct_action" || this.directive?.satisfaction?.kind === "fresh_read" && input.usedAuthoritativeTargetEvidence === true && isEditTool(input.toolName);
+        if (input.success && input.alreadyApplied && satisfiesAlreadyApplied) {
           this.clearSatisfiedDirective("requested edit already applied", input.turn);
           return;
         }
@@ -581576,7 +581787,7 @@ var init_focusSupervisor = __esm({
           this.lastReason = "runtime-authored control result did not execute the requested tool";
           return;
         }
-        if (input.toolName === "todo_write" && input.success) {
+        if (input.toolName === "todo_write" && input.success && this.directive?.satisfaction?.kind === "todo_update") {
           if (input.noop) {
             this.lastDecision = "todo_noop_not_satisfied";
             this.lastReason = "todo_write returned no-op; checklist state did not change";
@@ -581709,10 +581920,11 @@ var init_focusSupervisor = __esm({
           return;
         this.setDirective({
           turn,
-          state: "forced_replan",
-          reason: `${reason} — do NOT report incomplete and do NOT repeat a variant of what failed. TRIAGE: web_search the exact error/blocker to find how it is solved, OR pivot to a fundamentally different approach you have not tried, then act on it.`,
-          requiredNextAction: "creative_pivot_or_research",
-          forbiddenActionFamilies: ["brute_force"]
+          state: "terminal_incomplete",
+          reason,
+          requiredNextAction: "report_incomplete",
+          forbiddenActionFamilies: ["brute_force"],
+          source: "completion_gate"
         });
       }
       shouldStrictlyIntervene(context2) {
@@ -581741,7 +581953,12 @@ var init_focusSupervisor = __esm({
       }
       setDirective(input) {
         const existing = this.directive;
-        const stable = existing && existing.state === input.state && existing.reason === input.reason && existing.requiredNextAction === input.requiredNextAction;
+        const evidenceStateVersion = input.evidenceStateVersion ?? 0;
+        const stable = existing && existing.state === input.state && existing.reason === input.reason && existing.requiredNextAction === input.requiredNextAction && (existing.evidenceStateVersion ?? 0) >= evidenceStateVersion;
+        if (existing && !stable) {
+          this.transitionDirective("superseded", input.turn, "replaced by newer evidence or a different recovery requirement");
+        }
+        const source = input.source ?? inferDirectiveSource(input);
         const directive = stable ? {
           ...existing,
           forbiddenActionFamilies: uniqueLimited([
@@ -581749,13 +581966,20 @@ var init_focusSupervisor = __esm({
             ...input.forbiddenActionFamilies
           ])
         } : {
-          id: `focus_${++directiveCounter}`,
+          id: `focus_${this.taskEpoch}_${++directiveCounter}`,
           state: input.state,
           reason: input.reason,
           requiredNextAction: input.requiredNextAction,
           forbiddenActionFamilies: uniqueLimited(input.forbiddenActionFamilies),
           createdTurn: input.turn,
-          ignoredCount: 0
+          ignoredCount: 0,
+          taskEpoch: this.taskEpoch,
+          lifecycleState: "active",
+          source,
+          evidenceRefs: uniqueLimited(input.evidenceRefs ?? [`turn:${input.turn}`]),
+          evidenceStateVersion,
+          expiresAfterTurn: input.turn + this.directiveTtlTurns,
+          satisfaction: input.satisfaction ?? satisfactionForRequiredAction(input.requiredNextAction)
         };
         if (!stable && (!existing || existing.state !== input.state || existing.requiredNextAction !== input.requiredNextAction)) {
           this.repeatedViolationCounts.clear();
@@ -581765,12 +581989,45 @@ var init_focusSupervisor = __esm({
         this.lastReason = directive.reason;
         if (!stable)
           this.lastIgnoredDirectiveTurn = null;
+        if (!stable) {
+          this.emitDirectiveLifecycle({
+            directive,
+            taskEpoch: this.taskEpoch,
+            transition: "created",
+            turn: input.turn,
+            reason: directive.reason
+          });
+        }
         return directive;
       }
-      clearSatisfiedDirective(reason, _turn) {
-        if (!this.directive)
+      clearSatisfiedDirective(reason, turn) {
+        this.transitionDirective("satisfied", turn, reason);
+      }
+      expireDirectiveIfNeeded(turn) {
+        const expires = this.directive?.expiresAfterTurn;
+        if (expires !== void 0 && turn >= expires) {
+          this.transitionDirective("expired", turn, "directive TTL elapsed without new evidence");
+        }
+      }
+      transitionDirective(transition, turn, reason, supersededBy) {
+        const directive = this.directive;
+        if (!directive)
           return;
-        this.lastDecision = "directive_satisfied";
+        const resolved = {
+          ...directive,
+          lifecycleState: transition,
+          resolvedTurn: turn,
+          resolutionReason: reason,
+          ...supersededBy ? { supersededBy } : {}
+        };
+        this.emitDirectiveLifecycle({
+          directive: resolved,
+          taskEpoch: this.taskEpoch,
+          transition,
+          turn,
+          reason
+        });
+        this.lastDecision = transition === "satisfied" ? "directive_satisfied" : `directive_${transition}`;
         this.lastReason = reason;
         this.directive = null;
         this.state = "observe";
@@ -581778,6 +582035,12 @@ var init_focusSupervisor = __esm({
         this.lastIgnoredDirectiveTurn = null;
         this.repeatedViolationCounts.clear();
       }
+      emitDirectiveLifecycle(event) {
+        try {
+          this.onDirectiveLifecycle?.(event);
+        } catch {
+        }
+      }
       pass() {
         return {
           kind: "pass",
@@ -587788,8 +588051,6 @@ function flattenErrorText(err) {
 function computeEffectiveThink(params) {
   if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
     return false;
-  if (process.env["OMNIUS_ENABLE_THINKING"] !== "1")
-    return false;
   if (params.suppressed)
     return false;
   if (params.hasTools)
@@ -587826,6 +588087,9 @@ function sanitizeHistoryThink(messages2) {
       const collapsed = collapseDegenerateAssistantRepetition(content);
       content = collapsed ?? content;
     }
+    if (m2.role === "assistant" && Array.isArray(m2.tool_calls) && m2.tool_calls.some((call) => referencedToolCallIds.has(call.id)) && /\b(?:i|we)\s+(?:need|will|should|have)\s+to\s+(?:read|inspect|open)\b/i.test(content)) {
+      content = "[assistant read intent retired: the linked tool result is already available; decide from that evidence instead of restating a read plan]";
+    }
     return { ...m2, content };
   });
   const sanitized = [];
@@ -588178,6 +588442,18 @@ var init_agenticRunner = __esm({
       _onTypedEvent;
       handlers = [];
       pendingUserMessages = [];
+      /** Typed source of truth for user steering; pendingUserMessages remains a compatibility queue. */
+      pendingSteeringInputs = [];
+      _steeringSequence = 0;
+      _taskEpoch = 0;
+      _activeRunId = "";
+      /** Session storage is retained for compatibility; superseded task leaves are hidden from active guards. */
+      _supersededTodoIds = /* @__PURE__ */ new Set();
+      /** Cross-task restoration is opt-in only for an explicit continuation/append. */
+      _allowImplicitContinuation = false;
+      /** Abort scope for only the in-flight model/tool turn. Never use for permanent stop. */
+      _turnAbortController = new AbortController();
+      _pendingSteeringPreemption = null;
       pendingRuntimeGuidanceMessages = [];
       aborted = false;
       _abortController = new AbortController();
@@ -588678,6 +588954,9 @@ var init_agenticRunner = __esm({
       _branchEvidenceCache = /* @__PURE__ */ new Map();
       /** Latest curated node per canonical path for safe post-compaction recovery. */
       _branchEvidenceByPath = /* @__PURE__ */ new Map();
+      /** Exact read fingerprints resolved from canonical evidence, not a fresh tool call. */
+      _resolvedReadEvidence = /* @__PURE__ */ new Map();
+      _deterministicNarrowReadFallbacks = /* @__PURE__ */ new Set();
       // OBS-1: durable "current observed state" for non-file_read tool outputs
       // (shell/web_fetch/list_directory/…). EvidenceLedger's counterpart for the
       // observation channels that were previously invisible after compaction —
@@ -588786,7 +589065,7 @@ var init_agenticRunner = __esm({
           return this._workboard;
         }
         const dir = this._workboardDir();
-        const runId = this._sessionId;
+        const runId = this.currentArtifactRunId();
         const existing = loadWorkboardSnapshot(dir, runId);
         if (existing) {
           this._workboard = this._seedWorkboardCardsIfNeeded(existing, goal);
@@ -588897,7 +589176,7 @@ var init_agenticRunner = __esm({
         if (!diagnosis.createRecoveryCard && count < 2)
           return;
         const dir = this._workboardDir();
-        const runId = this._sessionId;
+        const runId = this.currentArtifactRunId();
         const actor = this.options.subAgent ? "sub-agent" : "agent";
         const cardInput = this._failureRecoveryCardInput(diagnosis);
         try {
@@ -589009,7 +589288,7 @@ var init_agenticRunner = __esm({
           return;
         const cards = activeLeaves.map((todo) => this._todoWorkboardCardInput(todo, this._todoPath(todo, index)));
         const dir = this._workboardDir();
-        const runId = this._sessionId;
+        const runId = this.currentArtifactRunId();
         const actor = this.options.subAgent ? "sub-agent" : "agent";
         try {
           let board = readActiveWorkboardSnapshot(dir, runId) ?? this._workboard ?? null;
@@ -589230,7 +589509,7 @@ ${parts.join("\n")}
       }
       _currentWorkboardSnapshotForFrame() {
         const dir = this._workboardDir();
-        const fromDisk = readActiveWorkboardSnapshot(dir, this._sessionId);
+        const fromDisk = readActiveWorkboardSnapshot(dir, this.currentArtifactRunId());
         const goal = this._taskState.originalGoal || this._taskState.goal || "";
         const initialCards = this._initialWorkboardCardsForGoal(goal);
         if (fromDisk) {
@@ -589359,8 +589638,9 @@ ${parts.join("\n")}
           case "creative_pivot_or_research":
             return "a FUNDAMENTALLY different approach: web_search the exact error/blocker to find how it is solved, or pivot to a method you have NOT tried — not a variant of what failed, and NOT task_complete";
           case "report_blocked":
+            return 'call task_complete with status="blocked", a concise external blocker, and the next prerequisite; do not create a bookkeeping artifact as the recovery action';
           case "report_incomplete":
-            return "a fundamentally different approach or web_search the blocker — do not report incomplete";
+            return 'call task_complete with status="incomplete" or status="blocked" only when the evidence shows no remaining substantive action; otherwise take a fundamentally different approach or web_search the blocker';
           default:
             return "choose the narrowest tool that advances the current card";
         }
@@ -589389,12 +589669,6 @@ ${parts.join("\n")}
         const gitContract = renderGitProgressActionContract(this._gitProgress);
         if (gitContract)
           lines.push(gitContract);
-        const focus = this._focusSupervisor?.snapshot().directive ?? null;
-        if (focus) {
-          lines.push(`focus_required_next_action=${focus.requiredNextAction}`);
-          lines.push(`focus_valid_tools=${this._focusToolsForRequiredAction(focus.requiredNextAction)}`);
-          lines.push(`focus_reason=${focus.reason}`);
-        }
         const snapshot = this._currentWorkboardSnapshotForFrame();
         const action = snapshot ? this._deriveWorkboardActionContract(snapshot) : null;
         if (snapshot && action) {
@@ -589525,7 +589799,7 @@ ${parts.join("\n")}
             const discovery = cards.get("discover-current-state");
             if (discovery && discovery.status !== "verified" && discovery.evidence.length > 0) {
               const completed = completeWorkboardCard(dir, {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 cardId: discovery.id,
                 actor,
                 outcome: "completed",
@@ -589536,7 +589810,7 @@ ${parts.join("\n")}
               const completedDiscovery = cards.get("discover-current-state");
               if (completedDiscovery?.status === "completed") {
                 const verified = completeWorkboardCard(dir, {
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   cardId: completedDiscovery.id,
                   actor,
                   outcome: "verified",
@@ -589549,7 +589823,7 @@ ${parts.join("\n")}
             const implementation2 = cards.get("implement-repair");
             if (implementation2 && (implementation2.status === "open" || implementation2.status === "needs_changes")) {
               current = updateWorkboardCard(dir, {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 cardId: implementation2.id,
                 actor,
                 updates: { status: "in_progress", lane: "worker" },
@@ -589563,7 +589837,7 @@ ${parts.join("\n")}
             const integration = cards.get("integrate-and-run");
             if (integration && this._workboardHasEditEvidence(implementation2) && (integration.status === "open" || integration.status === "needs_changes")) {
               current = updateWorkboardCard(dir, {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 cardId: integration.id,
                 actor,
                 updates: { status: "in_progress", lane: "verification" },
@@ -589618,7 +589892,7 @@ ${parts.join("\n")}
             return;
           }
           attachWorkboardEvidence(dir, {
-            runId: this._sessionId,
+            runId: this.currentArtifactRunId(),
             cardId: targetCard.id,
             actor,
             evidence
@@ -589633,7 +589907,7 @@ ${parts.join("\n")}
           return;
         try {
           const dir = this._workboardDir();
-          const refreshed = readActiveWorkboardSnapshot(dir, this._sessionId);
+          const refreshed = readActiveWorkboardSnapshot(dir, this.currentArtifactRunId());
           if (refreshed)
             this._workboard = refreshed;
         } catch {
@@ -589824,7 +590098,7 @@ ${parts.join("\n")}
           stage: stage2,
           agentType,
           sessionId: this._sessionId,
-          runId: this._sessionId,
+          runId: this.currentArtifactRunId(),
           turn,
           attempt,
           model: this._backendModelLabel(this.backend),
@@ -589849,7 +590123,7 @@ ${parts.join("\n")}
             recordDebugContextWindowDump({
               cwd: this.authoritativeWorkingDirectory(),
               stateDir: this.omniusStateDir(),
-              runId: this._sessionId,
+              runId: this.currentArtifactRunId(),
               sessionId: this._sessionId,
               record
             });
@@ -590072,7 +590346,7 @@ ${parts.join("\n")}
         try {
           const dir = _pathJoin(this.omniusStateDir(), "completion-contracts");
           _fsMkdirSync(dir, { recursive: true });
-          _fsWriteFileSync(_pathJoin(dir, `${this._sessionId}.json`), JSON.stringify({
+          _fsWriteFileSync(_pathJoin(dir, `${this.currentArtifactRunId()}.json`), JSON.stringify({
             sessionId: this._sessionId,
             createdAt: (/* @__PURE__ */ new Date()).toISOString(),
             contract
@@ -590238,28 +590512,8 @@ ${parts.join("\n")}
         const pressureCue = pressureCheck(task);
         const rawPrompt = getSystemPromptForTier(this.options.modelTier);
         const basePrompt = rawPrompt + pressureCue;
-        const todoBatchGuidance = this._todoWriteAvailable() ? " Use todo_write between batches to mark progress." : "";
-        const _BATCH_GUIDANCE = {
-          small: `
-
-## Response batching
-
-Emit AT MOST 2 tool calls per response. After observing their results, plan the next 2 in your following response. Smaller batches let the orchestrator deliver cache/failure/progress signals to you between actions. Tool calls beyond the cap are dropped.${todoBatchGuidance}`,
-          medium: `
-
-## Response batching
-
-Emit AT MOST 4 tool calls per response. After observing their results, plan the next batch in your following response. Smaller batches let the orchestrator deliver cache/failure/progress signals to you between actions. Tool calls beyond the cap are dropped.${todoBatchGuidance}`,
-          large: `
-
-## Response batching
-
-Emit AT MOST 6 tool calls per response. Smaller batches receive better feedback (cache/failure/progress signals between actions). Tool calls beyond the cap are dropped.${todoBatchGuidance}`
-        };
-        const batchGuidance = _BATCH_GUIDANCE[this.options.modelTier ?? "large"] ?? _BATCH_GUIDANCE.large;
-        const shellGuidance = "\n\n## Shell command patterns\n\nWhen investigating a build/test/install failure, RUN THE COMMAND WITHOUT TRUNCATION FIRST to see the full error.\nAvoid `| tail -N` / `| head -N` / `| sed -n '1,Np'` on commands you don't yet trust — they drop the part of the output where errors usually appear.\nPipefail is on by default in this orchestrator: a pipeline's exit code reflects the FIRST failing stage, not just the last. So `<cmd> | tail -80` returns non-zero if `<cmd>` failed.\nWhen you DO want to limit context (after diagnosis), prefer `<cmd> 2>&1 | tail -300` (or larger) so you keep enough output to see the actual error block.\nIf your command exited 0 but produced suspiciously short output (~< 800 chars), the orchestrator will inject a [HINT — pipe-to-truncator detected] block telling you to re-run without truncation.";
-        const editTransportGuidance = "\n\n## Existing-file edit loop\n\nFor an existing non-trivial file, use this loop: (1) file_read the implicated range or whole small file, (2) file_patch a contiguous line range or file_edit exact current text, (3) inspect the resulting diff/changed range, and (4) run the declared verifier live. Use batch_edit only for multiple exact replacements built from one fresh read.\nfile_write is for new files, empty/placeholder files, and deliberate replacement of a genuinely small file. Never use file_write as a fallback for stale hashes, old_string mismatches, malformed patch arguments, or repeated edit failures. A 'different approach' means refresh evidence or change the diagnostic/patch shape; it does not mean broaden a local repair into a whole-file rewrite.\nPreviously observed or compacted results are orientation only. Re-run file_read whenever a freshness/hash guard asks for current text, and re-run the exact verifier after every relevant mutation; cached output never proves current file state or completion.";
-        const basePromptWithBatching = basePrompt + batchGuidance + shellGuidance + editTransportGuidance;
+        const toolProtocol = "\n\n## Tool protocol\nUse a bounded tool batch, inspect returned evidence before the next batch, and use structured tool calls. For an existing file, provide fresh target evidence for a mutation; hash and scope validation are enforced by the tools. Verify a claimed end state with current evidence.";
+        const basePromptWithBatching = basePrompt + toolProtocol;
         sections.push({
           label: "c_instr",
           content: basePromptWithBatching,
@@ -590621,7 +590875,7 @@ Your hypotheses MUST address this specific error, not generic causes.
                 stage: opts?.dumpStage ?? "aux_inference",
                 agentType: "internal",
                 sessionId: this._sessionId,
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 model: this._backendModelLabel(this.backend),
                 cwd: this._workingDirectory || process.cwd(),
                 request: r2
@@ -591135,7 +591389,8 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
       readSessionTodos() {
         try {
           const sid = this._sessionId || process.env["OMNIUS_SESSION_ID"] || "default";
-          return readTodos(sid);
+          const todos = readTodos(sid);
+          return this._supersededTodoIds.size === 0 ? todos : todos.filter((todo) => !this._supersededTodoIds.has(todo.id));
         } catch {
           return null;
         }
@@ -591667,13 +591922,13 @@ ${extras.join("\n")}`;
             if (!existing) {
               this._workboard = addWorkboardCard(dir, {
                 ...compileFixCardToWorkboardInput(card),
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 actor,
                 decisionReason: "compile_error_card_created"
               });
             } else if (card.status === "assigned" && existing.status === "open") {
               this._workboard = updateWorkboardCard(dir, {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 cardId: card.id,
                 actor,
                 updates: {
@@ -591694,7 +591949,7 @@ ${extras.join("\n")}`;
               "patch touched only owned files"
             ];
             this._workboard = attachWorkboardEvidence(dir, {
-              runId: this._sessionId,
+              runId: this.currentArtifactRunId(),
               cardId: card.id,
               actor,
               evidence: {
@@ -591716,7 +591971,7 @@ ${extras.join("\n")}`;
               const wbCard = active?.cards.find((item) => item.id === card.id);
               if (wbCard && wbCard.status !== "completed" && wbCard.status !== "verified") {
                 this._workboard = completeWorkboardCard(dir, {
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   cardId: card.id,
                   actor,
                   outcome: "completed",
@@ -591728,7 +591983,7 @@ ${extras.join("\n")}`;
                 const latestCard = latest?.cards.find((item) => item.id === card.id);
                 if (latestCard?.status === "completed") {
                   this._workboard = completeWorkboardCard(dir, {
-                    runId: this._sessionId,
+                    runId: this.currentArtifactRunId(),
                     cardId: card.id,
                     actor,
                     outcome: "verified",
@@ -591749,7 +592004,7 @@ ${extras.join("\n")}`;
           if (!existing || existing.status !== "open")
             return;
           this._workboard = updateWorkboardCard(dir, {
-            runId: this._sessionId,
+            runId: this.currentArtifactRunId(),
             cardId: card.id,
             actor: this.options.subAgent ? "sub-agent" : "agent",
             updates: {
@@ -591773,6 +592028,11 @@ ${extras.join("\n")}`;
         state.verifierDirtySinceTurn = turn;
         state.lastVerifierPassedTurn = null;
         state.lastMutationTurn = turn;
+        this._focusSupervisor?.markCompletionBlocked({
+          turn,
+          reason: "A source mutation invalidated the declared verifier; verifier evidence now owns the active focus.",
+          requiredNextAction: "run_verification"
+        });
         for (const card of state.cards) {
           if (card.status === "assigned" && (normalized.length === 0 || normalized.some((pathValue) => card.ownedFiles.some((ownedPath) => this._pathsOverlapForVerifier(pathValue, ownedPath))))) {
             card.status = "patched";
@@ -591825,8 +592085,9 @@ ${extras.join("\n")}`;
             state.preflightBlockStreak = 0;
             return null;
           }
-          if (!shellLikelyMutatesFilesystem)
+          if (!shellLikelyMutatesFilesystem) {
             return null;
+          }
           const extraction = extractShellMutationPaths(command, {
             workingDir: this.authoritativeWorkingDirectory()
           });
@@ -591837,7 +592098,7 @@ ${extras.join("\n")}`;
         } else if (!this._isProjectEditTool(toolName)) {
           return null;
         }
-        const yieldAfter = _AgenticRunner.COMPILE_FIX_GATE_YIELD_AFTER;
+        const yieldAfter = Number.MAX_SAFE_INTEGER;
         const streak = (state.preflightBlockStreak ?? 0) + 1;
         if (streak > yieldAfter) {
           state.preflightBlockStreak = 0;
@@ -591869,7 +592130,7 @@ ${extras.join("\n")}`;
           `lastMutationTurn: ${state.lastMutationTurn}`,
           `lastVerifierRunTurn: ${state.lastVerifierRunTurn}`,
           `blockedTool: ${toolName}`,
-          `consecutiveBlocks: ${streak}/${yieldAfter} (gate yields after ${yieldAfter})`
+          `consecutiveBlocks: ${streak} (verifier focus is retained until a live verifier settles)`
         ].join("\n");
         this.emit({
           type: "status",
@@ -592330,6 +592591,9 @@ ${result.output ?? ""}`;
         return /^\s*(BLOCKED|INCOMPLETE|NEEDS[_ -]?INPUT)\b\s*:?/i.test(summary);
       }
       _shouldBypassTodoCompletionGuardForTaskComplete(args) {
+        if (completionStatusFromTaskCompleteArgs(args) === "blocked") {
+          return this._hasEvidenceBackedBlockedCompletion(args);
+        }
         if (!this._taskCompleteArgsReportDegraded(args))
           return false;
         if (this._completionIncompleteVerification)
@@ -592387,6 +592651,32 @@ ${result.output ?? ""}`;
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
+      /**
+       * Admit a BLOCKED terminal state only when every unresolved leaf is blocked
+       * by observed external evidence. Controller-authored notes, todo churn, and
+       * recovery artifacts are deliberately not evidence: otherwise the recovery
+       * loop can manufacture its own next blocker.
+       */
+      _hasEvidenceBackedBlockedCompletion(args) {
+        if (completionStatusFromTaskCompleteArgs(args) !== "blocked")
+          return false;
+        const summary = extractTaskCompleteSummary(args).trim();
+        if (!summary)
+          return false;
+        const leaves = openTodoLeaves(this._normalizeTodosForPrompt(this.readSessionTodos() ?? [])).filter((todo) => todo.status !== "completed");
+        if (leaves.length === 0)
+          return false;
+        const controllerArtifact = /(?:status artifact|blocker note|recovery (?:note|report|artifact)|todo_(?:write|read)|workboard|completion ledger|session diary)/i;
+        const externalBlocker = /(?:enoent|not found|missing|permission|access denied|credential|network|remote|upstream|service unavailable|waiting for|user input|third[- ]party)/i;
+        const hasObservedExternalFailure = this._recentFailures.some((failure) => externalBlocker.test(`${failure.error || ""}
+${failure.output || ""}`));
+        if (!hasObservedExternalFailure)
+          return false;
+        return leaves.every((todo) => {
+          const blocker = typeof todo.blocker === "string" ? todo.blocker.trim() : "";
+          return todo.status === "blocked" && blocker.length > 0 && externalBlocker.test(blocker) && !controllerArtifact.test(blocker);
+        });
+      }
       buildTodoCompletionGuard(openItems) {
         const list = openItems.slice(0, 20).map((t2, i2) => `${i2 + 1}. [${t2.status}] ${t2.content}`).join("\n");
         const full = this.readSessionTodos() || [];
@@ -594574,7 +594864,6 @@ ${latest.output || ""}`.trim();
               `files=${scan.files.length}${scan.truncated ? "+" : ""}`,
               `dirs=${scan.dirs.length}`,
               `bytes=${totalBytes}`,
-              focusSnapshot?.directive?.requiredNextAction ? `supervisor_required_next_action=${focusSnapshot.directive.requiredNextAction}` : `supervisor_required_next_action=none`,
               recentActionLines.length ? `recent_actions=${recentActions.length}` : `recent_actions=0`,
               recentActionLines.length ? recentActionLines.join("\n") : "",
               ""
@@ -594627,7 +594916,6 @@ ${latest.output || ""}`.trim();
             `root=${root}`,
             `files=${scan.files.length}${scan.truncated ? "+" : ""} dirs=${scan.dirs.length} total_bytes=${totalBytes}`,
             `artifact=${artifactDisplay}`,
-            focusSnapshot?.directive?.requiredNextAction ? `supervisor_required_next_action=${focusSnapshot.directive.requiredNextAction}` : `supervisor_required_next_action=none`,
             recentActionLines.length ? `recent_actions:
 ${recentActionLines.join("\n")}` : "recent_actions=none",
             "Use this tree for path orientation. It includes empty directories; it does not include file contents.",
@@ -595214,9 +595502,9 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
         const artifactContractBlock = this._contractRegistry.format(15);
         const todoBlock = this._renderTodoStateBlock(turn);
         const gitBlock = this._renderGitProgressBlock(turn);
-        const failureBlock = this._renderRecentFailuresBlock(turn);
-        const churnBlock = this._renderWriteChurnBlock(turn);
-        const focusBlock = this._focusSupervisor?.renderFrame() ?? null;
+        const failureBlock = null;
+        const churnBlock = null;
+        const focusBlock = null;
         const actionContractBlock = this._renderNextActionContract(turn);
         const trajectoryCheckpoint = await this._refreshTrajectoryCheckpoint(turn, focusBlock, [
           workspaceTreeBlock,
@@ -595232,8 +595520,7 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
         const toolCacheBlock = recentToolResults ? this._renderKnowledgeBlock(recentToolResults) : null;
         const observationBlock = process.env["OMNIUS_DISABLE_OBSERVATION_FRAME"] === "1" ? null : this._observationLedger.renderBlock(5e3);
         const anchorsBlock = this.surfaceAnchors(messages2);
-        const pprMemoryBlock = this._lastPprMemoryLines.length > 0 ? `[Associative Memory - related prior experience]
-${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
+        const pprMemoryBlock = null;
         const activeItems = await this._collectActiveSemanticContextItems({
           goalBlock,
           filesystemBlock,
@@ -595322,15 +595609,6 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
             createdTurn: turn,
             ttlTurns: 1
           }),
-          signalFromBlock("task_state", "turn.focus-supervisor", focusBlock, {
-            id: "focus-supervisor",
-            dedupeKey: "turn.focus-supervisor",
-            semanticKey: "context.focus-supervisor",
-            conflictGroup: "context.focus-supervisor",
-            priority: 98,
-            createdTurn: turn,
-            ttlTurns: 1
-          }),
           signalFromBlock("recent_failure", "turn.failures", failureBlock, {
             id: "recent-failures",
             dedupeKey: "turn.failures",
@@ -596594,8 +596872,48 @@ ${notice}`;
       }
       /** Inject a user message into the running conversation (mid-task steering) */
       injectUserMessage(content) {
-        this.pendingUserMessages.push(this.scrubUserInput(content, "injected-user-message"));
+        this.injectSteeringInput({
+          inputId: `legacy-steering-${Date.now()}-${++this._steeringSequence}`,
+          content,
+          source: "legacy-injectUserMessage",
+          receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          intent: "append",
+          state: "received",
+          taskEpoch: this._taskEpoch || void 0
+        });
+      }
+      /**
+       * Queue a typed user instruction and return an acknowledgement receipt.
+       * The receipt is emitted and ledgered before a redirect can cancel the
+       * active turn, which closes the old bridge-to-runner message-loss race.
+       */
+      injectSteeringInput(input) {
+        const now2 = (/* @__PURE__ */ new Date()).toISOString();
+        const content = this.scrubUserInput(input.content, "steering-input").trim();
+        const record = {
+          ...input,
+          inputId: input.inputId.trim() || `steering-${Date.now()}-${++this._steeringSequence}`,
+          content,
+          source: input.source || "unknown",
+          receivedAt: input.receivedAt || now2,
+          state: "received",
+          taskEpoch: input.taskEpoch ?? (this._taskEpoch || void 0)
+        };
+        this.pendingSteeringInputs.push(record);
+        this._emitSteeringLifecycle(record, "received by runner");
+        if (!content) {
+          record.state = "cancelled";
+          this._emitSteeringLifecycle(record, "empty steering input rejected");
+          return this._steeringReceipt(record);
+        }
+        this.pendingUserMessages.push(content);
+        record.state = "queued";
+        this._emitSteeringLifecycle(record, "queued for next safe turn boundary");
+        if (record.intent === "redirect" || record.intent === "replace" || record.intent === "cancel") {
+          this._requestSteeringPreemption(record);
+        }
         this._trajectoryDirtyCauses.add("user_steering");
+        return this._steeringReceipt(record);
       }
       /** Inject bounded runtime guidance without treating it as user steering. */
       injectRuntimeGuidance(content) {
@@ -596621,12 +596939,22 @@ ${notice}`;
       retractLastPendingMessage() {
         if (this.pendingUserMessages.length === 0)
           return null;
-        return this.pendingUserMessages.pop();
+        const content = this.pendingUserMessages.pop();
+        const record = [...this.pendingSteeringInputs].reverse().find((candidate) => candidate.content === content && (candidate.state === "queued" || candidate.state === "acknowledged"));
+        if (record) {
+          record.state = "cancelled";
+          if (this._pendingSteeringPreemption?.inputId === record.inputId) {
+            this._pendingSteeringPreemption = null;
+          }
+          this._emitSteeringLifecycle(record, "retracted before consumption");
+        }
+        return content;
       }
       /** Abort the current task run — cancels in-flight requests and kills child processes */
       abort() {
         this.aborted = true;
         this._abortController.abort();
+        this._turnAbortController.abort();
         const shellTool = this.tools.get("shell");
         if (shellTool && typeof shellTool.killAll === "function") {
           shellTool.killAll();
@@ -596638,7 +596966,245 @@ ${notice}`;
       }
       /** Get the current abort signal for passing to fetch/spawn */
       get abortSignal() {
-        return this._abortController.signal;
+        return this._turnAbortController.signal;
+      }
+      /** Current run identity and epoch, exposed for frontends that persist intake. */
+      get taskEpoch() {
+        return this._taskEpoch;
+      }
+      get activeRunId() {
+        return this._activeRunId;
+      }
+      /** Immutable run key for artifacts; sessionId remains correlation metadata. */
+      currentArtifactRunId() {
+        return this._activeRunId || this._sessionId;
+      }
+      _steeringReceipt(record) {
+        return {
+          inputId: record.inputId,
+          intent: record.intent,
+          state: record.state,
+          taskEpoch: record.taskEpoch,
+          runId: this._activeRunId || void 0,
+          acceptedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      /**
+       * Retire a satisfied read-plan from the exact outbound request. Tool-call
+       * metadata and tool-result links are retained untouched for provider
+       * protocol correctness; only stale assistant-visible planning prose changes.
+       */
+      _retireLinkedAssistantReadIntents(messages2) {
+        const resolvedToolCallIds = new Set(messages2.filter((message2) => message2.role === "tool" && message2.tool_call_id).map((message2) => message2.tool_call_id));
+        for (const message2 of messages2) {
+          if (message2.role !== "assistant" || typeof message2.content !== "string" || !Array.isArray(message2.tool_calls) || !message2.tool_calls.some((call) => resolvedToolCallIds.has(call.id)) || !/\b(?:i|we)\s+(?:need|will|should|have)\s+to\s+(?:read|inspect|open)\b/i.test(message2.content)) {
+            continue;
+          }
+          message2.content = "[assistant read intent retired: the linked tool result is present below; decide from that evidence rather than planning the same read]";
+        }
+      }
+      _emitSteeringLifecycle(record, reason) {
+        const receipt = this._steeringReceipt(record);
+        this.emit({
+          type: "status",
+          content: `Steering ${record.inputId} ${record.state}: ${reason}`,
+          steering: receipt,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        appendSteeringLedgerEntry(this._workingDirectory || process.cwd(), {
+          type: "lifecycle",
+          packetId: record.inputId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          intake: { ...record },
+          summary: reason
+        });
+      }
+      _setBackendTurnAbortSignal(signal) {
+        if (typeof this.backend.setAbortSignal === "function") {
+          this.backend.setAbortSignal(signal);
+        }
+      }
+      _requestSteeringPreemption(record) {
+        this._pendingSteeringPreemption = record;
+        record.state = "acknowledged";
+        this._emitSteeringLifecycle(record, "preemption acknowledged");
+        this._turnAbortController.abort(new Error(`steering ${record.intent}: ${record.inputId}`));
+        const shellTool = this.tools.get("shell");
+        if (shellTool && typeof shellTool.killAll === "function") {
+          shellTool.killAll();
+        }
+        this._turnAbortController = new AbortController();
+        this._setBackendTurnAbortSignal(this._turnAbortController.signal);
+      }
+      _prepareSteeringInputsForRun() {
+        const initialInputs = this.pendingSteeringInputs.filter((record) => record.state === "queued" || record.state === "acknowledged");
+        this._allowImplicitContinuation = initialInputs.some((record) => record.intent === "append" || record.intent === "clarify") && !initialInputs.some((record) => record.intent === "redirect" || record.intent === "replace" || record.intent === "cancel");
+        for (const record of this.pendingSteeringInputs) {
+          if (record.state !== "queued" && record.state !== "acknowledged")
+            continue;
+          if (record.taskEpoch && record.taskEpoch !== this._taskEpoch) {
+            record.state = "superseded";
+            this._emitSteeringLifecycle(record, "superseded by a later task run");
+            const index = this.pendingUserMessages.lastIndexOf(record.content);
+            if (index >= 0)
+              this.pendingUserMessages.splice(index, 1);
+            continue;
+          }
+          record.taskEpoch = this._taskEpoch;
+          this._emitSteeringLifecycle(record, "bound to active task epoch");
+        }
+      }
+      /** Archive prior task-epoch state before its session-backed records are hidden. */
+      _archiveSupersededTaskState(taskEpoch, steering) {
+        const todos = this.readSessionTodos() ?? [];
+        const archive = {
+          runId: this._activeRunId || this._sessionId,
+          sessionId: this._sessionId,
+          taskEpoch,
+          supersededAt: (/* @__PURE__ */ new Date()).toISOString(),
+          steering: {
+            inputId: steering.inputId,
+            intent: steering.intent,
+            content: steering.content
+          },
+          todos,
+          workboard: this._workboard,
+          completionLedger: this._completionLedger
+        };
+        try {
+          const dir = _pathJoin(this.omniusStateDir(), "task-epoch-archives");
+          _fsMkdirSync(dir, { recursive: true });
+          _fsWriteFileSync(_pathJoin(dir, `${this._activeRunId || this._sessionId}-epoch-${taskEpoch}.json`), JSON.stringify(archive, null, 2), "utf8");
+        } catch {
+        }
+        for (const todo of todos)
+          this._supersededTodoIds.add(todo.id);
+        this._workboard = null;
+      }
+      _steeringRecordForContent(content) {
+        return this.pendingSteeringInputs.find((record) => record.content === content && (record.state === "queued" || record.state === "acknowledged") && record.taskEpoch === this._taskEpoch);
+      }
+      _canonicalReadEvidencePayload(canonicalPath, contentHash2) {
+        const branch = this._branchEvidenceByPath.get(canonicalPath);
+        if (branch && branch.contentHash === contentHash2)
+          return branch.output;
+        return null;
+      }
+      _rehydrateResolvedReadEvidence(input) {
+        const previous = this._resolvedReadEvidence.get(input.fingerprint);
+        const handle2 = previous?.handle ?? `evidence:${input.canonicalPath}:${input.contentHash.slice(0, 16)}`;
+        this._resolvedReadEvidence.set(input.fingerprint, {
+          state: "resolved_from_cache",
+          handle: handle2,
+          path: input.canonicalPath,
+          contentHash: input.contentHash,
+          resolvedTurn: input.turn,
+          consumed: false
+        });
+        return [
+          "[REHYDRATED_FILE_EVIDENCE]",
+          `handle=${handle2}`,
+          "fingerprint_state=resolved_from_cache",
+          `path=${input.canonicalPath}`,
+          `sha256=${input.contentHash}`,
+          "Facts below are canonical current-run evidence. Consume these facts in the next decision; do not repeat the identical read.",
+          "[CANONICAL_FACTS]",
+          input.payload.slice(0, 7e3),
+          "[/CANONICAL_FACTS]"
+        ].join("\n");
+      }
+      _rejectRepeatedResolvedRead(tc, messages2) {
+        if (tc.name !== "file_read") {
+          for (const state2 of this._resolvedReadEvidence.values()) {
+            state2.consumed = true;
+          }
+          return null;
+        }
+        const fingerprint = this._buildToolFingerprint(tc.name, tc.arguments);
+        const state = this._resolvedReadEvidence.get(fingerprint);
+        if (!state)
+          return null;
+        const latestAssistant = [...messages2].reverse().find((message2) => message2.role === "assistant" && typeof message2.content === "string");
+        if (latestAssistant && typeof latestAssistant.content === "string" && latestAssistant.content.includes(state.handle)) {
+          state.consumed = true;
+        }
+        return [
+          "[REPEATED_READ_REJECTED]",
+          `handle=${state.handle}`,
+          `fingerprint_state=${state.state}`,
+          state.consumed ? "The evidence handle was acknowledged, but an identical read cannot add facts. Change file/range/query scope or take the evidence-backed next action." : "Consume the rehydrated evidence handle in your next decision before requesting another read. Change file/range/query scope if a different fact is required."
+        ].join("\n");
+      }
+      async _drainPendingSteeringMessages(messages2, turn) {
+        this.drainPendingRuntimeGuidance(turn);
+        while (this.pendingUserMessages.length > 0) {
+          const userMsg = this.pendingUserMessages.shift();
+          const record = this._steeringRecordForContent(userMsg);
+          const replacement = this._pendingSteeringPreemption;
+          if (replacement?.intent === "replace" && record && record.inputId !== replacement.inputId) {
+            record.state = "superseded";
+            this._emitSteeringLifecycle(record, `superseded before consumption by replacement ${replacement.inputId}`);
+            continue;
+          }
+          await this.appendInjectedUserMessage(userMsg, messages2, turn);
+          if (record) {
+            record.state = "consumed";
+            this._emitSteeringLifecycle(record, `consumed at turn ${turn}`);
+          }
+        }
+      }
+      /** Apply a preemption only at a safe boundary after its user content is visible. */
+      _applyPendingSteeringPreemption(messages2, turn) {
+        const record = this._pendingSteeringPreemption;
+        if (!record)
+          return false;
+        this._pendingSteeringPreemption = null;
+        if (record.intent === "cancel") {
+          record.state = "cancelled";
+          this._emitSteeringLifecycle(record, `cancelled active task at turn ${turn}`);
+          this.abort();
+          return true;
+        }
+        const previousEpoch = this._taskEpoch;
+        this._archiveSupersededTaskState(previousEpoch, record);
+        this._allowImplicitContinuation = false;
+        this._taskEpoch += 1;
+        record.taskEpoch = this._taskEpoch;
+        if (record.intent === "replace") {
+          for (const candidate of this.pendingSteeringInputs) {
+            if (candidate.inputId !== record.inputId && candidate.taskEpoch === previousEpoch && (candidate.state === "queued" || candidate.state === "acknowledged")) {
+              candidate.state = "superseded";
+              this._emitSteeringLifecycle(candidate, `superseded by replacement ${record.inputId}`);
+            }
+          }
+        }
+        this._completionContract = null;
+        this._completionLedger = this.writesUserTaskArtifacts() ? createCompletionLedger({
+          runId: this.currentArtifactRunId(),
+          goal: record.content
+        }) : null;
+        if (this._completionLedger) {
+          this._completionLedger.taskEpoch = this._taskEpoch;
+        }
+        this._completionHoldState.count = 0;
+        this._completionHoldState.total = 0;
+        this._completionHoldState.lastKey = "";
+        this._completionIncompleteVerification = null;
+        this._taskState.goal = record.content;
+        this._taskState.originalGoal = record.content;
+        messages2.push({
+          role: "system",
+          content: [
+            "[ACTIVE USER STEERING - HIGHEST USER PRIORITY]",
+            `inputId=${record.inputId} taskEpoch=${this._taskEpoch} intent=${record.intent}`,
+            "The prior task epoch is historical evidence only. Do not continue its plan, todos, recovery cards, or completion contract.",
+            "Replan from this active user instruction before any further tool call:",
+            record.content
+          ].join("\n")
+        });
+        record.state = "consumed";
+        this._emitSteeringLifecycle(record, `applied at turn ${turn}; epoch ${previousEpoch} -> ${this._taskEpoch}`);
+        return true;
       }
       /**
        * Pause the current task gracefully. The run loop will suspend at the next
@@ -596899,28 +597465,32 @@ ${notice}`;
         const cacheKey = `${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`;
         const cached = this._branchEvidenceCache.get(cacheKey);
         if (cached) {
-          const duplicateBlocked = [
-            `[BRANCH-DUPLICATE-BLOCKED] path=${rawPath} sha256=${fullHash} contract=${contractFingerprint}`,
-            `The unchanged source was already branch-extracted into the current evidence ledger; the registered file_read was not executed and raw content was not re-injected.`,
-            `Use the existing curated anchors. If a required discovery is unresolved, issue one narrower grep_search or a range whose projected payload stays below the 20% limit; otherwise take the next task action.`
-          ].join("\n");
+          const fingerprint = this._buildToolFingerprint(input.toolName, input.args);
+          const rehydrated = this._rehydrateResolvedReadEvidence({
+            fingerprint,
+            canonicalPath,
+            contentHash: fullHash,
+            payload: cached.output,
+            turn: input.turn
+          });
           this.emit({
             type: "status",
             toolName: input.toolName,
-            content: `Branch-extract cache hit: ${rawPath} sha256=${fullHash.slice(0, 12)} contract=${contractFingerprint}`,
+            content: `Branch-extract cache rehydrated: ${rawPath} sha256=${fullHash.slice(0, 12)} contract=${contractFingerprint} fingerprint_state=resolved_from_cache`,
             turn: input.turn,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
           return {
             success: true,
-            output: duplicateBlocked,
-            llmContent: duplicateBlocked,
+            output: rehydrated,
+            llmContent: rehydrated,
             beforeHash: fullHash,
             runtimeAuthored: true,
             noop: true,
             completionEvidenceMetrics: {
               branchSourceBytes: cached.sourceBytes,
-              branchCacheHit: true
+              branchCacheHit: true,
+              fingerprintState: "resolved_from_cache"
             }
           };
         }
@@ -597439,7 +598009,7 @@ ${inventory}`
           });
           this._onTypedEvent?.({
             type: "trajectory_checkpoint",
-            runId: this._sessionId,
+            runId: this.currentArtifactRunId(),
             revision: checkpoint.revision,
             assessment: checkpoint.assessment,
             nextAction: checkpoint.nextAction,
@@ -597450,7 +598020,7 @@ ${inventory}`
             recordDebugTrajectoryCheckpoint({
               cwd: this.authoritativeWorkingDirectory(),
               stateDir: this.omniusStateDir(),
-              runId: this._sessionId,
+              runId: this.currentArtifactRunId(),
               sessionId: this._sessionId,
               checkpoint
             });
@@ -597691,6 +598261,9 @@ Respond with the assessment and take the selected evidence-backed action.`;
       async run(task, context2, actualUserGoal) {
         this.aborted = false;
         this._abortController = new AbortController();
+        this._turnAbortController = new AbortController();
+        this._taskEpoch += 1;
+        this._activeRunId = `${this._sessionId || "run"}-${Date.now()}-${this._taskEpoch}`;
         this._fileWritesThisRun = 0;
         this._backwardPassCyclesUsed = 0;
         this._completionVerifyRejections = 0;
@@ -597716,7 +598289,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this._resetVisualEvidenceState();
         this._verifyFailuresBaseline = new Set(this._verifyFailures);
         if (typeof this.backend.setAbortSignal === "function") {
-          this.backend.setAbortSignal(this._abortController.signal);
+          this.backend.setAbortSignal(this._turnAbortController.signal);
         }
         const cleanedTask = cleanForStorage(task) || task.slice(0, 500);
         const start2 = Date.now();
@@ -597847,7 +598420,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         }
         this._loadResolutionMemory();
         this._pauseResolve = null;
-        this.pendingUserMessages.length = 0;
+        this._prepareSteeringInputsForRun();
         const persistentTaskGoal = cleanForStorage(actualUserGoal || "") || cleanedTask;
         const userGoal = persistentTaskGoal.slice(0, 500);
         this._taskRelevantErrorPatterns = process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] === "1" ? /* @__PURE__ */ new Map() : await this._selectTaskRelevantErrorPatterns(persistentTaskGoal, 10);
@@ -597952,9 +598525,10 @@ Respond with the assessment and take the selected evidence-backed action.`;
         if (this.writesUserTaskArtifacts()) {
           this._initializeCompletionContract(task, context2, actualUserGoal);
           this._completionLedger = createCompletionLedger({
-            runId: this._sessionId,
+            runId: this._activeRunId || this._sessionId,
             goal: userGoal
           });
+          this._completionLedger.taskEpoch = this._taskEpoch;
         } else {
           this._completionContract = null;
           this._completionLedger = null;
@@ -598071,7 +598645,11 @@ Respond with the assessment and take the selected evidence-backed action.`;
           }
         }
         const contextComposition = await this.assembleContext(task, context2);
-        let systemPrompt = contextComposition.assembled;
+        const staticContextLabels = /* @__PURE__ */ new Set(["c_instr", "c_conventions", "c_state"]);
+        let systemPrompt = contextComposition.sections.filter((section) => staticContextLabels.has(section.label)).map((section) => section.content).join("");
+        const dynamicProjectContext = contextComposition.sections.filter((section) => !staticContextLabels.has(section.label) && section.label !== "c_lessons").map((section) => section.content).join("");
+        if (!systemPrompt)
+          systemPrompt = contextComposition.assembled;
         try {
           systemPrompt = `${systemPrompt}
 
@@ -598143,7 +598721,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
               kind: "system_prompt",
               capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
               taskPreview: persistentTaskGoal.slice(0, 240),
-              assembledCharCount: systemPrompt.length,
+              assembledCharCount: systemPrompt.length + dynamicProjectContext.length,
               totalTokenEstimate: contextComposition.totalTokenEstimate,
               sections: contextComposition.sections.map((section, order) => ({
                 label: section.label,
@@ -598167,17 +598745,20 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         const messages2 = [
           { role: "system", content: systemPrompt },
           ...missionCompletionContract ? [{ role: "system", content: missionCompletionContract }] : [],
+          ...dynamicProjectContext ? [
+            {
+              role: "system",
+              content: `[DYNAMIC PROJECT STATE]
+${dynamicProjectContext}`
+            }
+          ] : [],
           { role: "user", content: userContent }
         ];
         const preflightMemoryRecall = await this._buildPreflightTaskMemoryRecall(persistentTaskGoal);
         if (preflightMemoryRecall) {
-          messages2.splice(messages2.length - 1, 0, {
-            role: "system",
-            content: preflightMemoryRecall
-          });
           this.emit({
             type: "status",
-            content: "Preflight memory recall injected for task-relevant prior episodes",
+            content: "Preflight memory recall retained for telemetry; omitted from model context",
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
@@ -598260,9 +598841,9 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           if (process.env["OMNIUS_FRESH_SESSION"] === "1")
             throw "skip-handoff-fresh";
           const omniusDir = this._workingDirectory ? _pathJoin(this._workingDirectory, ".omnius") : _pathJoin(process.cwd(), ".omnius");
-          const chainPairs = loadMessagePairsFromLog(omniusDir, {
+          const chainPairs = this._allowImplicitContinuation ? loadMessagePairsFromLog(omniusDir, {
             currentTask: persistentTaskGoal
-          });
+          }) : [];
           if (chainPairs.length > 0) {
             messages2.splice(1, 0, ...chainPairs);
             this.emit({
@@ -598273,7 +598854,8 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           } else {
             const prior = readTaskHandoff(omniusDir, {
               currentSessionId: this._sessionId,
-              currentTask: persistentTaskGoal
+              currentTask: persistentTaskGoal,
+              allowImplicitContinuation: this._allowImplicitContinuation
             });
             if (prior) {
               const handoffPair = buildHandoffMessagePair(prior);
@@ -598301,17 +598883,17 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             const reflections = this._reflectionBuffer.getRelevantReflections(persistentTaskGoal, 3);
             if (reflections.length > 0) {
               const reflectionCtx = this._reflectionBuffer.formatForContext(reflections);
-              messages2.push({ role: "system", content: reflectionCtx });
+              void reflectionCtx;
               this.emit({
                 type: "status",
-                content: `Reflexion: injected ${reflections.length} prior failure reflection(s) for this task type`,
+                content: `Reflexion: retained ${reflections.length} prior failure reflection(s) for telemetry only`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
           }
         } catch {
         }
-        if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1") {
+        if (false) {
           try {
             const failureHandoff = buildFailureModeHandoff({
               taskGoal: persistentTaskGoal,
@@ -598328,8 +598910,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
                 priority: 85,
                 createdTurn: 0
               });
-              if (signal)
-                this._contextLedger.upsert(signal);
+              void signal;
             }
           } catch {
           }
@@ -598388,7 +598969,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             }),
             persistPath,
             sessionId: this._sessionId,
-            runId: this._sessionId,
+            runId: this.currentArtifactRunId(),
             cwd: this._workingDirectory || process.cwd(),
             model: this._backendModelLabel(this.backend),
             onCritique: (critique2, sourceTurn) => {
@@ -598634,6 +599215,19 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           return completionHoldEscapeMax * 2;
         })();
         const holdTaskCompleteGates = (args, turn) => {
+          if (this._hasEvidenceBackedBlockedCompletion(args)) {
+            this._completionHoldState.count = 0;
+            this._completionHoldState.lastKey = "";
+            this._completionHoldState.total = 0;
+            lastCompletionGateCode = "";
+            this.emit({
+              type: "status",
+              content: "task_complete admitted as evidence-backed blocked state",
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            return false;
+          }
           if (this._completionHoldState.total >= completionHoldHardMax) {
             const incompleteSummary = [
               `INCOMPLETE_VERIFICATION: completion was requested after ${this._completionHoldState.total} gate hold(s), but required evidence is still missing.`,
@@ -598853,6 +599447,8 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
           }
         }
         for (let turn = 0; turn < turnCap; turn++) {
+          this._turnAbortController = new AbortController();
+          this._setBackendTurnAbortSignal(this._turnAbortController.signal);
           clearTurnState(this._appState);
           this._maybeApplyThinkGuard();
           if (this._paused) {
@@ -598865,7 +599461,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
               });
               this._onTypedEvent?.({
                 type: "run_failed",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 error: "Task aborted by user",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
@@ -598880,7 +599476,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             });
             this._onTypedEvent?.({
               type: "run_failed",
-              runId: this._sessionId ?? "unknown",
+              runId: this.currentArtifactRunId(),
               error: "Task aborted by user",
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
@@ -598954,7 +599550,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
               });
               this._onTypedEvent?.({
                 type: "completion_requested",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 summary: summary.slice(0, 500),
                 sourcePath: "direct",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -599109,7 +599705,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
                 });
               } else {
                 const directive = this._failingApproachDirective(faSignal);
-                messages2.push({ role: "system", content: directive });
+                void directive;
                 this.emit({
                   type: "adversary_reaction",
                   adversary: {
@@ -599146,7 +599742,7 @@ Respond with EXACTLY this structure before your next tool call:
   NEXT ACTION: <a single creative edit — file_write / file_edit / batch_edit — that tests the picked hypothesis>
 
 If the hypothesis cannot be tested by a creative edit, ask the human via task_complete with summary 'BLOCKED: <reason>'.`;
-            messages2.push({ role: "system", content: replan });
+            void replan;
             stagnationCooldownUntilTurn = turn + 8;
             const _tel58 = this._describeTopClusterTelemetry();
             const _telSuffix58 = _tel58 ? `; rca3_preamble=applied; top_cluster=${_tel58.code} (${_tel58.observations}×); has_hint=${_tel58.hasHint}` : `; rca3_preamble=none`;
@@ -599177,7 +599773,7 @@ Respond with EXACTLY this structure before your next tool call:
   WHY: <one sentence>
   FALSIFICATION: <observable signal that would refute the pick>
   NEXT ACTION: <a single targeted edit — file_edit / file_patch / batch_edit; file_write only for a verified-new file>`;
-              messages2.push({ role: "system", content: _replan60 });
+              void _replan60;
               stagnationCooldownUntilTurn = turn + REG60_COOLDOWN_TURNS;
               const _tel60 = this._describeTopClusterTelemetry();
               const _telSuffix60 = _tel60 ? `; rca3_preamble=applied; top_cluster=${_tel60.code} (${_tel60.observations}×); has_hint=${_tel60.hasHint}` : `; rca3_preamble=none`;
@@ -599242,7 +599838,7 @@ Respond with EXACTLY this structure before your next tool call:
                     ].join("\n");
                   }
                 }
-                messages2.push({ role: "system", content: _stagBody });
+                void _stagBody;
                 stagnationCooldownUntilTurn = turn + 5;
                 try {
                   const memMod = await Promise.resolve().then(() => (init_dist(), dist_exports));
@@ -599274,12 +599870,7 @@ Respond with EXACTLY this structure before your next tool call:
                   const recipes = this._episodeStore ? memMod.lookupBySignature(this._episodeStore, sig, 1) : [];
                   if (recipes.length > 0) {
                     const r2 = recipes[0];
-                    messages2.push({
-                      role: "system",
-                      content: `[STAGNATION RECIPE — found from prior run with same failure shape]
-${r2.content}
-If this matches your current shape, try it before continuing.`
-                    });
+                    void r2;
                     this.emit({
                       type: "status",
                       content: `[STAGNATION RECIPE] surfaced prior recipe (sig=${sig}) for current failure shape`,
@@ -599447,30 +600038,6 @@ If this matches your current shape, try it before continuing.`
                   ``,
                   `  (e) REPORT BLOCKED: only when evidence shows a missing dependency, ambiguous requirement, or external service issue. State the blocker and prerequisite; do not call \`task_complete\` merely because this detector fired.`
                 ];
-                messages2.push({
-                  role: "system",
-                  content: [
-                    `[STUCK DETECTOR HALT — REG-44]`,
-                    ``,
-                    `Window: last ${_windowCalls.length} tool calls.`,
-                    `  • Reads/exploration calls: ${_readCount}`,
-                    `  • Productive mutations:    ${_mutationCount}`,
-                    `  • Stale (cached/blocked/no-op) results: ${_staleCount}`,
-                    `  • Triggers fired: ${_trigLabels.join(", ")}`,
-                    ``,
-                    `You are consuming turns without accumulating decision-ready evidence or verified progress. Every shape of “stuck” — read-heavy without a narrowing question, repeated cache hits, blocked-shell loops, no-op todo updates, or blind mutation retries — can produce this signal. The exact tool names do not decide the fix; the freshest evidence does.`,
-                    ``,
-                    ..._reg44ChoiceLines,
-                    ``,
-                    `Recent failures (real or synthetic):`,
-                    _failureBlocks,
-                    ``,
-                    _staleSamples.length > 0 ? `Stale-result samples in this window:
-${_staleSamples.join("\n")}` : ``,
-                    ``,
-                    `Do NOT in your next response: re-read a file you've already read this turn, re-run a shell command that just got blocked, or update todos without changing them. Those are the moves that landed you here.`
-                  ].filter(Boolean).join("\n")
-                });
                 this.emit({
                   type: "status",
                   content: `REG-44 STUCK detector fired at turn ${turn} — triggers=[${_trigLabels.join(",")}], reads=${_readCount}, mutations=${_mutationCount}, stale=${_staleCount}, window=${_windowCalls.length}`,
@@ -599541,10 +600108,7 @@ ${_staleSamples.join("\n")}` : ``,
                       callable: _smaCallable
                     }).then((_smaResult) => {
                       if (_smaResult.injection && !_smaResult.directive.parseFallback) {
-                        messages2.push({
-                          role: "system",
-                          content: _smaResult.injection
-                        });
+                        void _smaResult.injection;
                         this.emit({
                           type: "status",
                           content: `REG-49 stuck-meta-analyzer fired at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
@@ -599635,19 +600199,6 @@ ${_staleSamples.join("\n")}` : ``,
                   ``,
                   `Do NOT in your next response: write to ${_wtWorstPath} again without first running and reading the failing command's output.`
                 ];
-                messages2.push({
-                  role: "system",
-                  content: [
-                    `[WRITE-THRASH HALT — REG-50]`,
-                    ``,
-                    `In the last ${_wtWindow.length} tool calls you have written the same file ${_wtWorstCount} times:`,
-                    `  ${_wtWorstPath}`,
-                    ``,
-                    `No successful test/build/typecheck command ran between writes — you are iterating the file blind, hoping the next variation works. This is a write-thrash anti-pattern. Repeated edits without verification confirm nothing.`,
-                    ``,
-                    ..._reg50ChoiceLines
-                  ].join("\n")
-                });
                 this.emit({
                   type: "status",
                   content: `REG-50 WRITE-THRASH halt fired at turn ${turn} — file=${_wtWorstPath}, count=${_wtWorstCount}/${_wtThreshold}, no successful verify in window`,
@@ -599714,10 +600265,7 @@ ${_staleSamples.join("\n")}` : ``,
                       callable: _smaCallable50
                     }).then((_smaResult) => {
                       if (_smaResult.injection && !_smaResult.directive.parseFallback) {
-                        messages2.push({
-                          role: "system",
-                          content: _smaResult.injection
-                        });
+                        void _smaResult.injection;
                         this.emit({
                           type: "status",
                           content: `REG-50 → SSMA fired at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
@@ -599781,19 +600329,6 @@ ${_staleSamples.join("\n")}` : ``,
                   ``,
                   `Do NOT in your next response: call file_edit or batch_edit on ${_efWorstPath} again with another guess at old_string.`
                 ];
-                messages2.push({
-                  role: "system",
-                  content: [
-                    `[EDIT-FAIL-THRASH HALT — REG-53]`,
-                    ``,
-                    `In the last ${_efWindow.length} tool calls you have failed file_edit/batch_edit on the same file ${_efWorstCount} times:`,
-                    `  ${_efWorstPath}`,
-                    ``,
-                    `Each failure means your old_string did not match the file content. Your remembered version of this file has diverged from what's on disk — likely because an earlier edit succeeded and shifted things, or because you guessed at the file's content.`,
-                    ``,
-                    ..._reg53ChoiceLines
-                  ].join("\n")
-                });
                 this.emit({
                   type: "status",
                   content: `REG-53 EDIT-FAIL-THRASH halt fired at turn ${turn} — file=${_efWorstPath}, failures=${_efWorstCount}/${_efThreshold}`,
@@ -599871,10 +600406,7 @@ ${_staleSamples.join("\n")}` : ``,
                   callable: _pfvCallable
                 }).then((_pfvResult) => {
                   if (_pfvResult.injection && !_pfvResult.verdict.parseFallback && _pfvResult.verdict.verdict !== "continue") {
-                    messages2.push({
-                      role: "system",
-                      content: _pfvResult.injection
-                    });
+                    void _pfvResult.injection;
                     this.emit({
                       type: "status",
                       content: `REG-51 PFV fired at turn ${turn} — verdict=${_pfvResult.verdict.verdict}, trigger=${_pfvTriggerReason}, ssmaCount=${this._ssmaFiredCount}, ${_pfvResult.durationMs}ms`,
@@ -599939,18 +600471,6 @@ ${_staleSamples.join("\n")}` : ``,
                   ].join("\n");
                 }
               }
-              messages2.push({
-                role: "system",
-                content: [
-                  `[STICKY ESCALATION — REG-45 — failure persists across turns]`,
-                  ``,
-                  `You have an unresolved high-attempt failure that you may have stopped trying to fix. Every turn that this remains unresolved, this reflection will resurface so the issue stays visible:`,
-                  ``,
-                  _body,
-                  ``,
-                  `If this failure is genuinely irrelevant now (e.g. the goal moved on), the only way to clear this notice is to make a successful attempt of the same call (or close-equivalent) — that resets the failure record. Otherwise, address it now.`
-                ].join("\n")
-              });
               this._stickyEscalationsSurfacedThisTurn.add(_stem);
               this._reflectionsInjectedThisTurn.add(_stem);
               this.emit({
@@ -600019,10 +600539,11 @@ ${_staleSamples.join("\n")}` : ``,
               });
             }
           }
-          this.drainPendingRuntimeGuidance(turn);
-          while (this.pendingUserMessages.length > 0) {
-            const userMsg = this.pendingUserMessages.shift();
-            await this.appendInjectedUserMessage(userMsg, messages2, turn);
+          await this._drainPendingSteeringMessages(messages2, turn);
+          if (this._applyPendingSteeringPreemption(messages2, turn)) {
+            if (this.aborted)
+              break;
+            continue;
           }
           if (!this.options.disableTodoPlanningNudges) {
             const maybeReminder = this.getTodoReminderContent(turn);
@@ -600252,7 +600773,7 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
                 toolEvents: this._toolEvents,
                 memoryHints: [],
                 runState: {
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   tokenBudget: _limits.compactionThreshold,
                   completionContract: this._completionContract ? formatCompletionContract(this._completionContract) : void 0
                 }
@@ -600397,7 +600918,7 @@ ${memoryLines.join("\n")}`
               toolEvents: this._toolEvents,
               memoryHints: [],
               runState: {
-                runId: this._sessionId,
+                runId: this.currentArtifactRunId(),
                 tokenBudget: _limits.compactionThreshold,
                 completionContract: this._completionContract ? formatCompletionContract(this._completionContract) : void 0
               }
@@ -600425,6 +600946,12 @@ ${memoryLines.join("\n")}`
           const echoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
           if (this._echoTempBoostTurns > 0)
             this._echoTempBoostTurns--;
+          this._stripLegacyControlMessages(requestMessages);
+          requestMessages.push({
+            role: "system",
+            content: this._buildRecentActionGroundTruth(turn)
+          });
+          this._retireLinkedAssistantReadIntents(requestMessages);
           const chatRequest = {
             messages: requestMessages,
             tools: toolDefs,
@@ -600508,6 +601035,15 @@ ${memoryLines.join("\n")}`
           try {
             response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
           } catch (reqErr) {
+            if (this._pendingSteeringPreemption) {
+              this.emit({
+                type: "status",
+                content: "Model request interrupted by pending user steering; skipping recovery.",
+                turn,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              continue;
+            }
             if (reqErr instanceof Error && reqErr.fatal) {
               this.emit({
                 type: "error",
@@ -600516,7 +601052,7 @@ ${memoryLines.join("\n")}`
               });
               this._onTypedEvent?.({
                 type: "run_failed",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 error: reqErr.message,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
@@ -600535,7 +601071,7 @@ ${memoryLines.join("\n")}`
                 });
                 this._onTypedEvent?.({
                   type: "run_failed",
-                  runId: this._sessionId ?? "unknown",
+                  runId: this.currentArtifactRunId(),
                   error: retryMsg,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -600559,7 +601095,7 @@ ${memoryLines.join("\n")}`
                   });
                   this._onTypedEvent?.({
                     type: "run_failed",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     error: `Model not found: ${errMsg}`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
@@ -600634,7 +601170,7 @@ ${memoryLines.join("\n")}`
                             summary = String(parsed.args?.summary ?? content);
                             this._onTypedEvent?.({
                               type: "completion_requested",
-                              runId: this._sessionId ?? "unknown",
+                              runId: this.currentArtifactRunId(),
                               summary: summary.slice(0, 500),
                               sourcePath: this.options.streamEnabled ? "stream" : "batch",
                               timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -600657,7 +601193,7 @@ ${memoryLines.join("\n")}`
                     });
                     this._onTypedEvent?.({
                       type: "run_failed",
-                      runId: this._sessionId ?? "unknown",
+                      runId: this.currentArtifactRunId(),
                       error: msg2,
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
                     });
@@ -600672,7 +601208,7 @@ ${memoryLines.join("\n")}`
                   });
                   this._onTypedEvent?.({
                     type: "run_failed",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     error: `Backend unavailable: ${errMsg}`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
@@ -600682,10 +601218,10 @@ ${memoryLines.join("\n")}`
               response = recovered ?? response;
             }
           }
-          totalTokens += response.usage?.totalTokens ?? 0;
-          promptTokens += response.usage?.promptTokens ?? 0;
+          totalTokens += response.usage?.totalTokens || (response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0) + (response.usage?.completionTokens ?? 0);
+          promptTokens += response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0;
           completionTokens += response.usage?.completionTokens ?? 0;
-          const turnPromptTokens = response.usage?.promptTokens ?? 0;
+          const turnPromptTokens = response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0;
           const turnCompletionTokens = response.usage?.completionTokens ?? 0;
           if (turnPromptTokens || turnCompletionTokens) {
             recordTokenUsage(this._appState, turnPromptTokens, turnCompletionTokens, 0, false);
@@ -600903,8 +601439,19 @@ ${memoryLines.join("\n")}`
               reservations: /* @__PURE__ */ new Map()
             };
             executeSingle = async (tc) => {
-              if (this.aborted)
+              if (this.aborted || this._pendingSteeringPreemption)
                 return null;
+              const resolvedReadBlock = this._rejectRepeatedResolvedRead(tc, messages2);
+              if (resolvedReadBlock) {
+                this.emit({
+                  type: "status",
+                  toolName: tc.name,
+                  content: "Repeated planned file_read rejected until evidence scope changes.",
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                return { tc, output: resolvedReadBlock, success: true };
+              }
               const cohortKey = this.buildArgCohortKey(tc.name, tc.arguments);
               const cohort = this._argCohorts.get(cohortKey);
               if (cohort && cohort.failure >= 3 && cohort.success === 0) {
@@ -600948,10 +601495,7 @@ Corrective action: try a different approach first: read relevant files, adjust a
                   const pattern = rawPattern;
                   if (pattern.tool === tc.name && (pattern.count ?? 0) >= 2 && !currentRunToolAlreadySucceeded && !this._errorGuidanceInjected.has(sig)) {
                     this._errorGuidanceInjected.add(sig);
-                    messages2.push({
-                      role: "system",
-                      content: `[LEARNED FROM EXPERIENCE] ${tc.name} has failed ${pattern.count} times with "${pattern.errorType}" errors. Guidance: ${pattern.guidance}`
-                    });
+                    void pattern;
                   }
                 }
               }
@@ -601166,7 +601710,7 @@ Corrective action: try a different approach first: read relevant files, adjust a
                   ``,
                   _localFailureNudge
                 ].join("\n");
-                pushSoftInjection("system", reg61SteerMsg);
+                void reg61SteerMsg;
                 this.emit({
                   type: "status",
                   content: `REG-61 STEER — nudge injected for '${tc.name}' at turn ${turn}; tool ALLOWED; gate stays active${_dbgLoop.detected ? `; REG-66 debug-loop variant (${_dbgLoop.kind} "${_debugLoopSampleSafe.slice(0, 60)}" ${_dbgLoop.count}×)` : ""}`,
@@ -601509,11 +602053,8 @@ Read the current file if needed, make a different concrete edit, or move to veri
                         ].join("\n");
                       }
                     }
-                    if (_isEscalation) {
-                      messages2.push({ role: "system", content: _reflBody });
-                    } else {
-                      pushSoftInjection("system", _reflBody);
-                    }
+                    void _isEscalation;
+                    void _reflBody;
                     this.emit({
                       type: "status",
                       content: `REG-26 reflection surfaced for stem '${_reflStem.slice(0, 60)}' (attempts=${_reflEntry.attempts}, distinct_errors=${_reflEntry.errorSignatures?.size ?? 0}, escalation=${_isEscalation})`,
@@ -601709,7 +602250,7 @@ ${cachedResult}`,
                 });
                 if (focusDecision.kind === "block_tool_call" && this._maybeAutoDelegate(tc, focusDecision.directive, messages2, turn)) {
                 } else if (focusDecision.kind === "inject_guidance") {
-                  pushSoftInjection("system", focusDecision.message);
+                  void focusDecision.message;
                 } else if (!repeatShortCircuit) {
                   repeatShortCircuit = {
                     success: focusDecision.success,
@@ -601920,30 +602461,70 @@ ${cachedResult}`,
                               const currentRead = this._fileReadDiskIdentity(tc.arguments);
                               if (currentRead && currentRead.contentHash === priorRead.contentHash) {
                                 exactFileReadObservations.set(exactReadKey, currentRead);
-                                const duplicateOutput = [
-                                  `[DUPLICATE_READ_BLOCKED] path=${currentRead.path} sha256=${currentRead.contentHash}`,
-                                  `The exact file_read arguments already produced evidence from this unchanged source during the current run. The tool was not re-executed and the raw body was not re-injected.`,
-                                  `Use the existing evidence/anchors now. To discover something different, issue one narrower offset/limit or grep_search with a new symbol; otherwise take the next mutation, verification, or completion action.`
-                                ].join("\n");
-                                branchPreempted = {
-                                  success: true,
-                                  output: duplicateOutput,
-                                  llmContent: duplicateOutput,
-                                  beforeHash: currentRead.contentHash,
-                                  runtimeAuthored: true,
-                                  noop: true,
-                                  completionEvidenceMetrics: {
-                                    duplicateReadBlocked: true,
-                                    duplicateReadSourceBytes: currentRead.byteCount
+                                const canonicalPayload = this._canonicalReadEvidencePayload(currentRead.canonicalPath, currentRead.contentHash);
+                                if (canonicalPayload) {
+                                  const rehydrated = this._rehydrateResolvedReadEvidence({
+                                    fingerprint: exactReadKey,
+                                    canonicalPath: currentRead.canonicalPath,
+                                    contentHash: currentRead.contentHash,
+                                    payload: canonicalPayload,
+                                    turn
+                                  });
+                                  branchPreempted = {
+                                    success: true,
+                                    output: rehydrated,
+                                    llmContent: rehydrated,
+                                    beforeHash: currentRead.contentHash,
+                                    runtimeAuthored: true,
+                                    noop: true,
+                                    completionEvidenceMetrics: {
+                                      duplicateReadResolvedFromCache: true,
+                                      duplicateReadSourceBytes: currentRead.byteCount,
+                                      fingerprintState: "resolved_from_cache"
+                                    }
+                                  };
+                                  this.emit({
+                                    type: "status",
+                                    toolName: normalizedDispatchName,
+                                    content: `Exact unchanged file_read rehydrated: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)} fingerprint_state=resolved_from_cache`,
+                                    turn,
+                                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                                  });
+                                } else {
+                                  if (this._deterministicNarrowReadFallbacks.has(exactReadKey)) {
+                                    const fallbackBlocked = [
+                                      "[REPEATED_NARROW_READ_REJECTED]",
+                                      `path=${currentRead.path}`,
+                                      "No canonical payload was produced by the allowed narrow reread. Change scope with a new range or symbol query; do not repeat identical arguments."
+                                    ].join("\n");
+                                    branchPreempted = {
+                                      success: true,
+                                      output: fallbackBlocked,
+                                      llmContent: fallbackBlocked,
+                                      beforeHash: currentRead.contentHash,
+                                      runtimeAuthored: true,
+                                      noop: true
+                                    };
+                                  } else {
+                                    this._deterministicNarrowReadFallbacks.add(exactReadKey);
+                                    const previousOffset = tc.arguments["offset"];
+                                    const previousLimit = tc.arguments["limit"];
+                                    Object.assign(finalArgs, {
+                                      offset: typeof previousOffset === "number" && Number.isFinite(previousOffset) ? Math.max(1, Math.floor(previousOffset)) : 1,
+                                      limit: typeof previousLimit === "number" && Number.isFinite(previousLimit) ? Math.max(1, Math.min(160, Math.floor(previousLimit))) : 160
+                                    });
+                                    tc.arguments = finalArgs;
+                                    this._deterministicNarrowReadFallbacks.add(this._buildToolFingerprint("file_read", tc.arguments));
+                                    exactFileReadObservations.delete(exactReadKey);
+                                    this.emit({
+                                      type: "status",
+                                      toolName: normalizedDispatchName,
+                                      content: `Exact read cache lacked canonical payload; allowing one deterministic narrow reread: ${currentRead.path} offset=${tc.arguments["offset"]} limit=${tc.arguments["limit"]}`,
+                                      turn,
+                                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                                    });
                                   }
-                                };
-                                this.emit({
-                                  type: "status",
-                                  toolName: normalizedDispatchName,
-                                  content: `Exact unchanged file_read blocked before dispatch: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)}`,
-                                  turn,
-                                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                                });
+                                }
                               } else {
                                 exactFileReadObservations.delete(exactReadKey);
                               }
@@ -602044,21 +602625,7 @@ ${cachedResult}`,
                                   });
                                   if (process.env["OMNIUS_DISABLE_REG59"] !== "1") {
                                     const _errCtx59 = this._buildErrorContextPreamble();
-                                    messages2.push({
-                                      role: "system",
-                                      content: `[STAGNATION REPLAN — REG-59 same-error escalation]
-The error cluster you keep hitting has occurred 5+ times. Your current approach is NOT working. STOP retrying it.
-` + _errCtx59 + `
-Respond with EXACTLY this structure before your next tool call:
-  HYPOTHESES (3 NEW theories — must be DIFFERENT from anything tried so far):
-  1. ...
-  2. ...
-  3. ...
-  PICK: <number 1-3>
-  WHY: <one sentence — what makes this hypothesis NEW>
-  FALSIFICATION: <observable signal that would refute the pick>
-  NEXT ACTION: <single tool call that tests the picked hypothesis — preferably a creative edit, not a read>`
-                                    });
+                                    void _errCtx59;
                                     stagnationCooldownUntilTurn = turn + 8;
                                     const _tel59 = this._describeTopClusterTelemetry();
                                     const _telSuffix59 = _tel59 ? `; rca3_preamble=applied; top_cluster=${_tel59.code} (${_tel59.observations}×); has_hint=${_tel59.hasHint}` : `; rca3_preamble=none`;
@@ -602119,6 +602686,7 @@ Respond with EXACTLY this structure before your next tool call:
                 args: tc.arguments,
                 result
               });
+              this._reconcileCreationGroundTruth(resolvedTool?.name ?? tc.name, tc.arguments, result, turn);
               if (observedStateMutation) {
                 this._markAdversaryObservedStateMutation();
               }
@@ -602209,7 +602777,7 @@ Respond with EXACTLY this structure before your next tool call:
                       writeCount: prev?.writeCount
                     });
                   }
-                  if (p2 && result.success && result.output) {
+                  if (p2 && result.success && result.output && !(result.runtimeAuthored === true && result.noop === true)) {
                     const rOffset = typeof tc.arguments?.["offset"] === "number" ? tc.arguments["offset"] : void 0;
                     const rLimit = typeof tc.arguments?.["limit"] === "number" ? tc.arguments["limit"] : void 0;
                     const start3 = rOffset === void 0 && rLimit === void 0 ? 0 : Math.max(1, rOffset ?? 1);
@@ -603080,7 +603648,7 @@ Respond with EXACTLY this structure before your next tool call:
                     ``,
                     this._renderLocalFailureNudge(turn)
                   ].join("\n");
-                  pushSoftInjection("system", opaqueMessage);
+                  void opaqueMessage;
                   this.emit({
                     type: "status",
                     content: `REG-32 opaque-error local nudge fired for stem '${_refStem.slice(0, 60)}'`,
@@ -603537,7 +604105,7 @@ ${delegateDir}` : delegateDir;
                 recordDebugToolEvent({
                   cwd: this.authoritativeWorkingDirectory(),
                   stateDir: this.omniusStateDir(),
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   sessionId: this._sessionId,
                   turn,
                   toolCallId: tc.id,
@@ -603748,8 +604316,7 @@ Then use file_read on individual FILES inside it.`);
                     createdTurn: turn,
                     ttlTurns: 4
                   });
-                  if (signal)
-                    this._contextLedger.upsert(signal);
+                  void signal;
                   lastShellPivotTurn = turn;
                   this.emit({
                     type: "status",
@@ -603758,7 +604325,7 @@ Then use file_read on individual FILES inside it.`);
                   });
                 }
               }
-              if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1" && !result.success && turn - lastFailureHandoffTurn >= 4) {
+              if (false) {
                 const runtimeHandoff = buildFailureModeHandoff({
                   taskGoal: persistentTaskGoal,
                   errorPatterns: this._taskRelevantErrorPatterns,
@@ -603775,8 +604342,7 @@ Then use file_read on individual FILES inside it.`);
                     createdTurn: turn,
                     ttlTurns: 4
                   });
-                  if (signal)
-                    this._contextLedger.upsert(signal);
+                  void signal;
                   lastFailureHandoffTurn = turn;
                 }
               }
@@ -603791,7 +604357,7 @@ Then use file_read on individual FILES inside it.`);
               });
               this._onTypedEvent?.({
                 type: "tool_call_finished",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 toolName: tc.name,
                 callId: tc.id,
                 success: result.success === true,
@@ -603803,8 +604369,7 @@ Then use file_read on individual FILES inside it.`);
               return {
                 tc,
                 output,
-                success: result.success,
-                ...runtimeSystemGuidance ? { systemGuidance: runtimeSystemGuidance } : {}
+                success: result.success
               };
             };
             const rawToolCalls = msg.toolCalls;
@@ -603903,7 +604468,7 @@ ${sr.result.output}`;
                       summary = extractTaskCompleteSummary(taskCompleteArgs);
                       this._onTypedEvent?.({
                         type: "completion_requested",
-                        runId: this._sessionId ?? "unknown",
+                        runId: this.currentArtifactRunId(),
                         summary: (summary ?? "").slice(0, 500),
                         sourcePath: this.options.streamEnabled ? "stream" : "batch",
                         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -603926,17 +604491,12 @@ ${sr.result.output}`;
               if (!completed && !this._completionIncompleteVerification) {
                 const unhandled = rawToolCalls.filter((tc) => !handledIds.has(tc.id));
                 for (const tc of unhandled) {
-                  if (this.aborted)
+                  if (this.aborted || this._pendingSteeringPreemption)
                     break;
                   const r2 = await executeSingle(tc);
                   if (r2) {
                     messages2.push(this.buildModelFacingToolMessage(r2.output, r2.tc.id, r2.tc.name, r2.tc.arguments, r2.success));
-                    if (r2.systemGuidance) {
-                      messages2.push({
-                        role: "system",
-                        content: r2.systemGuidance
-                      });
-                    }
+                    void r2.systemGuidance;
                     if (r2.tc.name === "task_complete") {
                       if (!r2.success) {
                         messages2.push({
@@ -603978,7 +604538,7 @@ ${sr.result.output}`;
                         summary = extractTaskCompleteSummary(taskCompleteArgs);
                         this._onTypedEvent?.({
                           type: "completion_requested",
-                          runId: this._sessionId ?? "unknown",
+                          runId: this.currentArtifactRunId(),
                           summary: (summary ?? "").slice(0, 500),
                           sourcePath: this.options.streamEnabled ? "stream" : "batch",
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -604008,7 +604568,7 @@ ${sr.result.output}`;
               }));
               const batches = partitionToolCalls(batchToolCalls);
               for (const batch2 of batches) {
-                if (this.aborted)
+                if (this.aborted || this._pendingSteeringPreemption)
                   break;
                 const batchFingerprintFirstId = /* @__PURE__ */ new Map();
                 const batchInFlight = /* @__PURE__ */ new Map();
@@ -604045,12 +604605,7 @@ ${sr.result.output}`;
                 for (const r2 of results) {
                   if (r2) {
                     messages2.push(this.buildModelFacingToolMessage(r2.output, r2.tc.id, r2.tc.name, r2.tc.arguments, r2.success));
-                    if (r2.systemGuidance) {
-                      messages2.push({
-                        role: "system",
-                        content: r2.systemGuidance
-                      });
-                    }
+                    void r2.systemGuidance;
                     if (r2.tc.name === "task_complete") {
                       if (!r2.success) {
                         messages2.push({
@@ -604092,7 +604647,7 @@ ${sr.result.output}`;
                         summary = extractTaskCompleteSummary(taskCompleteArgs);
                         this._onTypedEvent?.({
                           type: "completion_requested",
-                          runId: this._sessionId ?? "unknown",
+                          runId: this.currentArtifactRunId(),
                           summary: (summary ?? "").slice(0, 500),
                           sourcePath: this.options.streamEnabled ? "stream" : "batch",
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -604141,21 +604696,7 @@ ${sr.result.output}`;
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 const partialResults = this._taskState.completedSteps.length > 0 ? this._taskState.completedSteps.join(". ") : `Progress made before loop: ${topRepeated}`;
-                messages2.push({
-                  role: "system",
-                  content: `LOOP CIRCUIT BREAKER: ${loopInterventionCount} interventions attempted but repetition continues.
-
-MANDATORY: Change state before taking another action. Choose one:
-1. Try a completely different approach
-2. Re-read the exact current target once if the loop is caused by a stale edit
-3. Run verification if files changed since the last successful check
-4. Call ask_user if user input is the real blocker
-5. Report blocked/incomplete with the concrete blocker if no safe progress path remains
-
-Your partial progress: ${partialResults}
-
-Do not call task_complete solely because this circuit breaker fired.`
-                });
+                void partialResults;
                 loopInterventionCount = 0;
               }
               const findings = [];
@@ -604253,10 +604794,7 @@ Only call task_complete when the task is actually complete and the evidence is f
                     callable: _smaCallable
                   }).then((_smaResult) => {
                     if (_smaResult.injection && !_smaResult.directive.parseFallback) {
-                      messages2.push({
-                        role: "system",
-                        content: _smaResult.injection
-                      });
+                      void _smaResult.injection;
                       this.emit({
                         type: "status",
                         content: `REG-49 stuck-meta-analyzer fired (loop-intervention path) at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
@@ -604321,7 +604859,7 @@ Only call task_complete when the task is actually complete and the evidence is f
               summary = content;
               this._onTypedEvent?.({
                 type: "completion_requested",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 summary: content.slice(0, 500),
                 sourcePath: this.options.streamEnabled ? "stream" : "batch",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -604570,7 +605108,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 toolEvents: this._toolEvents,
                 memoryHints: [],
                 runState: {
-                  runId: this._sessionId,
+                  runId: this.currentArtifactRunId(),
                   tokenBudget: _limits.compactionThreshold,
                   completionContract: this._completionContract ? formatCompletionContract(this._completionContract) : void 0
                 }
@@ -604594,7 +605132,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 });
                 this._onTypedEvent?.({
                   type: "run_failed",
-                  runId: this._sessionId ?? "unknown",
+                  runId: this.currentArtifactRunId(),
                   error: "Task aborted by user",
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -604609,7 +605147,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               });
               this._onTypedEvent?.({
                 type: "run_failed",
-                runId: this._sessionId ?? "unknown",
+                runId: this.currentArtifactRunId(),
                 error: "Task aborted by user",
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
@@ -604666,6 +605204,11 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
             const bfEchoBoostedTemp = this._echoTempBoostTurns > 0 ? Math.max(this.options.temperature ?? 0, 0.7) : this.options.temperature;
             if (this._echoTempBoostTurns > 0)
               this._echoTempBoostTurns--;
+            this._stripLegacyControlMessages(modelFacingMessages);
+            modelFacingMessages.push({
+              role: "system",
+              content: this._buildRecentActionGroundTruth(turn)
+            });
             const chatRequest = {
               messages: modelFacingMessages,
               tools: toolDefs,
@@ -604687,7 +605230,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 });
                 this._onTypedEvent?.({
                   type: "run_failed",
-                  runId: this._sessionId ?? "unknown",
+                  runId: this.currentArtifactRunId(),
                   error: "Task aborted by user",
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -604706,7 +605249,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   });
                   this._onTypedEvent?.({
                     type: "run_failed",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     error: bfRetryMsg,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
@@ -604729,7 +605272,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   });
                   this._onTypedEvent?.({
                     type: "run_failed",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     error: errMsg2,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
@@ -604738,10 +605281,10 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 response = recovered;
               }
             }
-            totalTokens += response.usage?.totalTokens ?? 0;
-            promptTokens += response.usage?.promptTokens ?? 0;
+            totalTokens += response.usage?.totalTokens || (response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0) + (response.usage?.completionTokens ?? 0);
+            promptTokens += response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0;
             completionTokens += response.usage?.completionTokens ?? 0;
-            const bfTurnPrompt = response.usage?.promptTokens ?? 0;
+            const bfTurnPrompt = response.usage?.promptEvalCount ?? response.usage?.promptTokens ?? 0;
             const bfTurnCompletion = response.usage?.completionTokens ?? 0;
             if (bfTurnPrompt || bfTurnCompletion) {
               recordTokenUsage(this._appState, bfTurnPrompt, bfTurnCompletion, 0, false);
@@ -604824,12 +605367,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                 messages2.push(this.buildModelFacingToolMessage(r2.output, r2.tc.id, r2.tc.name, r2.tc.arguments, r2.success));
                 this._toolLastUsedTurn.set(r2.tc.name, turn);
                 this._advanceContextTreeOnToolCall(r2.tc.name, this._buildExactArgsKey(r2.tc.arguments ?? {}), turn, messages2);
-                if (r2.systemGuidance) {
-                  messages2.push({
-                    role: "system",
-                    content: r2.systemGuidance
-                  });
-                }
+                void r2.systemGuidance;
                 if (r2.tc.name === "task_complete") {
                   if (!r2.success) {
                     messages2.push({
@@ -604871,7 +605409,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                     summary = extractTaskCompleteSummary(taskCompleteArgs);
                     this._onTypedEvent?.({
                       type: "completion_requested",
-                      runId: this._sessionId ?? "unknown",
+                      runId: this.currentArtifactRunId(),
                       summary: (summary ?? "").slice(0, 500),
                       sourcePath: this.options.streamEnabled ? "stream" : "batch",
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -604929,7 +605467,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   summary = content;
                   this._onTypedEvent?.({
                     type: "completion_requested",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     summary: content.slice(0, 500),
                     sourcePath: this.options.streamEnabled ? "stream" : "batch",
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -605024,7 +605562,7 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   });
                   this._onTypedEvent?.({
                     type: "completion_requested",
-                    runId: this._sessionId ?? "unknown",
+                    runId: this.currentArtifactRunId(),
                     summary: summary.slice(0, 500),
                     sourcePath: "direct",
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -605081,7 +605619,7 @@ ${caveat}` : caveat;
         });
         this._onTypedEvent?.({
           type: "run_finished",
-          runId: this._sessionId ?? "unknown",
+          runId: this.currentArtifactRunId(),
           status: runStatus,
           success: completed,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -605769,7 +606307,8 @@ ${caveat}` : caveat;
             const trajDir = path16.join(this.omniusStateDir(), "trajectories");
             fs14.mkdirSync(trajDir, { recursive: true });
             const trajectory = {
-              id: this._sessionId,
+              id: this.currentArtifactRunId(),
+              sessionId: this._sessionId,
               // CLEAN task — this file is the prerequisite for ALL future RL/RFT
               // training. Storing the scaffolded version would teach future models
               // to reproduce signpost text as part of their task understanding.
@@ -606002,7 +606541,7 @@ ${marker}` : marker);
         ].filter(Boolean).join("\n"));
       }
       shouldBypassDiscoveryCompaction(output) {
-        return output.includes("[IMAGE_BASE64:") || output.includes("[BRANCH-EXTRACT]") || output.includes("[REPEAT GATE - cached evidence not re-sent]") || output.includes("[CACHED READ — content unchanged") || output.includes("[REHYDRATED FROM CACHE") || output.includes("[Tool output truncated") || output.includes(TRIAGE_ENVELOPE_MARKER);
+        return output.includes("[IMAGE_BASE64:") || output.includes("[BRANCH-EXTRACT]") || output.includes("[REPEAT GATE - cached evidence not re-sent]") || output.includes("[REPEATED_READ_REJECTED]") || output.includes("[REPEATED_NARROW_READ_REJECTED]") || output.includes("[CACHED READ — content unchanged") || output.includes("[REHYDRATED FROM CACHE") || output.includes("[Tool output truncated") || output.includes(TRIAGE_ENVELOPE_MARKER);
       }
       countTextLines(text2) {
         if (!text2)
@@ -607616,8 +608155,7 @@ ${tail}`;
             createdTurn: turn,
             ttlTurns: 20
           });
-          if (signal)
-            this._contextLedger.upsert(signal);
+          void signal;
         }
         this.emit({
           type: "user_interrupt",
@@ -608052,37 +608590,13 @@ Describe what you see and integrate this into your current approach.` : "[User s
         let middle = messages2.slice(headEndIdx, recentStart);
         if (middle.length === 0)
           return messages2;
-        const DEFENSE_DIRECTIVE_PREFIXES = [
-          "[STUCK DETECTOR HALT — REG-44]",
-          "[STUCK-STATE META-ANALYZER — REG-49]",
-          "[WRITE-THRASH HALT — REG-50]",
-          "[PROBLEM-FRAME VALIDATION — REG-51",
-          "[EDIT-FAIL-THRASH HALT — REG-53]"
-        ];
-        const isDefenseDirective = (msg) => {
-          const c9 = typeof msg.content === "string" ? msg.content : "";
-          return msg.role === "system" && DEFENSE_DIRECTIVE_PREFIXES.some((pfx) => c9.startsWith(pfx));
-        };
-        const stickyDefenses = [];
-        const filteredMiddle = [];
-        for (const msg of middle) {
-          if (isDefenseDirective(msg))
-            stickyDefenses.push(msg);
-          else
-            filteredMiddle.push(msg);
-        }
-        const filteredRecent = [];
-        for (const msg of recent) {
-          if (isDefenseDirective(msg))
-            stickyDefenses.push(msg);
-          else
-            filteredRecent.push(msg);
-        }
-        const stickyToKeep = stickyDefenses.slice(-10);
-        if (stickyToKeep.length > 0) {
+        const filteredMiddle = middle.filter((message2) => !this._isLegacyControlMessage(message2));
+        const filteredRecent = recent.filter((message2) => !this._isLegacyControlMessage(message2));
+        const retiredLegacyCount = middle.length + recent.length - filteredMiddle.length - filteredRecent.length;
+        if (retiredLegacyCount > 0) {
           this.emit({
             type: "status",
-            content: `REG-54 sticky-defenses preserved ${stickyToKeep.length} directive(s) across compaction (out of ${stickyDefenses.length} matched)`,
+            content: `Controller cleanup retired ${retiredLegacyCount} legacy REG/recovery message(s) during compaction`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
@@ -608350,7 +608864,6 @@ ${telegramPersonaHead}` : stripped
         let result = [
           ...narrowedHead,
           compactionMsg,
-          ...stickyToKeep,
           ...filteredRecent
         ];
         const fileRecoveryBudget = Math.floor((this._branchRoutingContextWindow() || 32768) * 0.15);
@@ -608450,10 +608963,9 @@ ${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live
             createdTurn: this._taskState.toolCallCount,
             ttlTurns: 8
           });
-          if (signal)
-            this._contextLedger.upsert(signal);
+          void signal;
         }
-        if (process.env["OMNIUS_DISABLE_FAILURE_HANDOFF"] !== "1") {
+        if (false) {
           try {
             const compactFailureHandoff = buildFailureModeHandoff({
               taskGoal: this._taskState.goal,
@@ -608470,8 +608982,7 @@ ${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live
                 createdTurn: this._taskState.toolCallCount,
                 ttlTurns: 8
               });
-              if (signal)
-                this._contextLedger.upsert(signal);
+              void signal;
             }
           } catch {
           }
@@ -608513,7 +609024,6 @@ ${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live
             result = [
               ...narrowedHead,
               compactionMsg,
-              ...stickyToKeep,
               ...protectedRecoveryMessages,
               ...trimmedRecent
             ];
@@ -608578,6 +609088,8 @@ ${trimmedNew}`;
        * adversary buffer, this is populated directly after tool execution and does
        * not depend on raw tool messages surviving compaction. */
       _recentToolOutcomes = [];
+      /** Recent successful user-work mutations suppress generic "create again" nudges. */
+      _groundTruthSuccessPaths = /* @__PURE__ */ new Map();
       /** Monotonic counter for observed local state changes.
        *  Redundant-action classification is only valid within the same state
        *  version; a repeated verifier after an edit is fresh evidence. */
@@ -608704,10 +609216,124 @@ ${trimmedNew}`;
           succeeded: input.result.success === true,
           ...outcomeEvidence
         });
+        if (input.result.success === true && this._isRealProjectMutation(input.toolName, input.result)) {
+          for (const rawPath of this._extractToolTargetPaths(input.toolName, input.args ?? {}, input.result)) {
+            const path16 = this._normalizeEvidencePath(rawPath);
+            if (!path16 || path16.startsWith(".omnius/"))
+              continue;
+            this._groundTruthSuccessPaths.set(path16, { turn: input.turn });
+          }
+          this._reg61CooldownUntilTurn = Math.max(this._reg61CooldownUntilTurn, input.turn + 5);
+        }
         while (this._recentToolOutcomes.length > 40) {
           this._recentToolOutcomes.shift();
         }
       }
+      /**
+       * The only late control block visible to a model. It is regenerated from
+       * authoritative run state on each request; it never carries prompt history.
+       * Large models receive state only. Small/medium models may receive one
+       * bounded directive with an explicit expiry and exit condition.
+       */
+      _buildRecentActionGroundTruth(turn) {
+        const activePaths = [...this._taskState.modifiedFiles.entries()].map(([rawPath, rawAction]) => ({
+          path: this._normalizeEvidencePath(rawPath),
+          rawAction
+        })).filter((entry) => entry.path && !entry.path.startsWith(".omnius/")).slice(-5);
+        const todos = this.readSessionTodos() ?? [];
+        const todoCounts = todos.reduce((counts, todo) => {
+          const status = String(todo.status ?? "pending");
+          if (status === "completed")
+            counts.completed++;
+          else if (status === "blocked")
+            counts.blocked++;
+          else if (status === "in_progress")
+            counts.inProgress++;
+          else
+            counts.pending++;
+          return counts;
+        }, { completed: 0, blocked: 0, inProgress: 0, pending: 0 });
+        const activeLeaf = todos.find((todo) => ["in_progress", "pending", "open", "needs_changes"].includes(String(todo.status ?? "")));
+        const verifier = this._worldFacts.lastTest;
+        const verifierState = verifier?.summary ? `outcome=${verifier.passed ? "passed" : "failed"} turn=${verifier.turn ?? "?"}` : "outcome=not_recorded";
+        const verifierRequired = this._compileFixLoop?.active === true && this._compileFixLoop.verifierDirtySinceTurn !== null;
+        const intent = this._taskState.originalGoal || this._taskState.goal || this._taskState.currentStep || "unspecified";
+        const lines = [
+          "[CONTROLLER STATE v1]",
+          `task_epoch=${this._taskEpoch} turn=${turn} state_version=${this._adversaryStateVersion}`,
+          `user_intent=${intent.replace(/\s+/g, " ").slice(0, 700)}`,
+          `active_leaf=${String(activeLeaf?.content ?? this._taskState.currentStep ?? this._taskState.nextAction ?? "none").replace(/\s+/g, " ").slice(0, 360)}`,
+          `todo_counts=completed:${todoCounts.completed},in_progress:${todoCounts.inProgress},pending:${todoCounts.pending},blocked:${todoCounts.blocked}`,
+          `verifier=${verifierState}`
+        ];
+        const tier = this.options.modelTier ?? "large";
+        const directive = this._focusSupervisor?.snapshot().directive;
+        if (directive && tier !== "large") {
+          const expiresTurn = Math.max(turn + 1, directive.createdTurn + 6);
+          lines.push(`active_directive=next_action:${directive.requiredNextAction}; evidence:${directive.reason.replace(/\s+/g, " ").slice(0, 260)}; expires_turn:${expiresTurn}; exit_when:action_evidence_or_verified_mutation_or_user_redirect`);
+        }
+        for (const entry of activePaths) {
+          const action = /creat/i.test(entry.rawAction) ? "created" : /delet/i.test(entry.rawAction) ? "deleted" : "modified";
+          const evidence = this._evidenceLedger.get(entry.path);
+          const fact = this._worldFacts.files.get(entry.path);
+          const outcome = [...this._recentToolOutcomes].reverse().find((item) => item.path && this._normalizeEvidencePath(item.path) === entry.path);
+          const resultState = outcome ? outcome.succeeded ? "tool_result=success" : "tool_result=failure" : "tool_result=not_recorded";
+          const hash = evidence?.contentHash ?? "unknown";
+          const bytes = fact && typeof fact.size === "number" ? String(fact.size) : "unknown";
+          const nextAction = verifierRequired ? "run_declared_verifier" : outcome?.succeeded ? "verify_or_complete_distinct_leaf" : "inspect_external_blocker_or_change_scope";
+          const doNot = action === "created" ? "do_not_create_again" : action === "modified" ? "do_not_full_rewrite_without_fresh_read" : "do_not_recreate_without_authoritative_target";
+          lines.push(`${action} path=${entry.path} hash=${hash} bytes=${bytes} ${resultState} stateVersion=${outcome?.stateVersion ?? this._adversaryStateVersion} turn=${outcome?.turn ?? turn} next_valid_action=${nextAction} ${doNot}`);
+        }
+        lines.push("action_ground_truth=tool-derived only; controller artifacts and bookkeeping do not count as progress");
+        return lines.join("\n").slice(0, 4200);
+      }
+      /** Legacy REG/recovery prose is retained in telemetry only, never in model history. */
+      _isLegacyControlMessage(message2) {
+        if (message2.role !== "system" || typeof message2.content !== "string")
+          return false;
+        return /^(?:\[(?:FIRST-EDIT NUDGE|STAGNATION(?: REPLAN| RECIPE)|STUCK DETECTOR HALT|STUCK-STATE META-ANALYZER|WRITE-THRASH HALT|EDIT-FAIL-THRASH HALT|PROBLEM-FRAME VALIDATION|STICKY ESCALATION|INTRA-RUN LESSON|LEARNED FROM EXPERIENCE|FOCUS SUPERVISOR|REG-\d+ directive active|OPAQUE LOCAL ERROR|LOCAL ERROR-INFORMED NUDGE|PRIOR LESSONS|FAILURE-MODE INTAKE|REFLECTION|Associative Memory)|LOOP CIRCUIT BREAKER)/.test(message2.content);
+      }
+      _stripLegacyControlMessages(messages2) {
+        for (let index = messages2.length - 1; index >= 0; index--) {
+          if (this._isLegacyControlMessage(messages2[index]))
+            messages2.splice(index, 1);
+        }
+      }
+      /** Mark a workboard target complete when a confirmed creation satisfies it. */
+      _reconcileCreationGroundTruth(toolName, args, result, turn) {
+        if (result.success !== true || !this._isRealProjectMutation(toolName, result)) {
+          return;
+        }
+        const created = this._extractToolTargetPaths(toolName, args, result).map((path16) => this._normalizeEvidencePath(path16)).filter((path16) => path16 && !path16.startsWith(".omnius/") && /creat/i.test(this._taskState.modifiedFiles.get(path16) ?? ""));
+        if (created.length === 0)
+          return;
+        const board = this._workboard ?? this.getOrCreateWorkboard();
+        if (board) {
+          const card = this._workboardTodoCardForPaths(board, created);
+          if (card && (card.status === "open" || card.status === "in_progress" || card.status === "needs_changes")) {
+            try {
+              const completed = completeWorkboardCard(this._workboardDir(), {
+                runId: this.currentArtifactRunId(),
+                cardId: card.id,
+                actor: this.options.subAgent ? "sub-agent" : "agent",
+                outcome: "completed",
+                reason: `Creation ground truth satisfied mapped target(s): ${created.join(", ")} at turn ${turn}.`
+              });
+              this._workboard = completed.snapshot;
+            } catch {
+            }
+          }
+        }
+        for (const todo of this.readSessionTodos() ?? []) {
+          const artifacts = Array.isArray(todo.declaredArtifacts) ? todo.declaredArtifacts.filter((path16) => typeof path16 === "string").map((path16) => this._normalizeEvidencePath(path16)) : [];
+          if (todo.status !== "completed" && artifacts.length > 0 && artifacts.every((path16) => created.includes(path16))) {
+            const marker = `created target evidence: ${todo.content}`;
+            if (!this._taskState.completedSteps.includes(marker)) {
+              this._taskState.completedSteps.push(marker);
+            }
+          }
+        }
+      }
       _recentToolActionsForWorldState() {
         if (this._recentToolOutcomes.length > 0)
           return this._recentToolOutcomes;
@@ -610462,7 +611088,7 @@ ${result}`
               stage: "vision_image_recovery",
               agentType: "internal",
               sessionId: this._sessionId,
-              runId: this._sessionId,
+              runId: this._activeRunId || this._sessionId,
               turn,
               attempt: 0,
               model,
@@ -610490,7 +611116,7 @@ ${result}`
                   stage: "vision_image_recovery",
                   agentType: "internal",
                   sessionId: this._sessionId,
-                  runId: this._sessionId,
+                  runId: this._activeRunId || this._sessionId,
                   turn,
                   attempt: 1,
                   model,
@@ -610570,7 +611196,7 @@ ${description}`
        * Returns the response on success, or null if recovery did not apply.
        */
       async retryOnTransient(initialErr, chatRequest, turn) {
-        if (this.aborted)
+        if (this.aborted || this._pendingSteeringPreemption)
           return null;
         if (!this.isTransientError(initialErr))
           return null;
@@ -610584,7 +611210,7 @@ ${description}`
         const backend = this.backend;
         let attempt = 1;
         while (attempt <= (maxRetries === Infinity ? Number.MAX_SAFE_INTEGER : maxRetries)) {
-          if (this.aborted)
+          if (this.aborted || this._pendingSteeringPreemption)
             return null;
           if (this.isPaymentRequiredError(initialErr) && typeof backend.rotateKey === "function") {
             const rotated = backend.rotateKey();
@@ -610651,7 +611277,7 @@ ${description}`
             });
           }
           await new Promise((r2) => setTimeout(r2, effectiveDelay));
-          if (this.aborted)
+          if (this.aborted || this._pendingSteeringPreemption)
             return null;
           try {
             this._recordContextWindowDump("agent_turn_transient_retry", chatRequest, turn, attempt);
@@ -610719,7 +611345,7 @@ ${description}`
           }
         }
         for await (const chunk of backend.chatCompletionStream(request)) {
-          if (this.aborted)
+          if (this.aborted || this._pendingSteeringPreemption)
             break;
           if (chunk.type === "usage" && chunk.usage) {
             streamUsage = chunk.usage;
@@ -611932,8 +612558,6 @@ var init_nexusBackend = __esm({
       effectiveThink(request) {
         if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
           return false;
-        if (process.env["OMNIUS_ENABLE_THINKING"] !== "1")
-          return false;
         if (Array.isArray(request.tools) && request.tools.length > 0)
           return false;
         if (request.think === true)
@@ -633315,11 +633939,149 @@ async function queryOpenAIContextSize(baseUrl2, modelName, apiKey) {
     return null;
   }
 }
-async function queryContextSize(baseUrl2, modelName, apiKey) {
-  if (baseUrl2.startsWith("peer://")) return 32768;
+function llamaCppRootUrl(baseUrl2) {
+  return normalizeBaseUrl(baseUrl2).replace(/\/v1$/i, "");
+}
+function asRecord(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2) ? value2 : null;
+}
+function positiveInteger(value2) {
+  const parsed = typeof value2 === "number" ? value2 : typeof value2 === "string" && /^\d+$/.test(value2.trim()) ? Number(value2) : NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : void 0;
+}
+function firstPositive(record, keys) {
+  for (const key of keys) {
+    const value2 = positiveInteger(record[key]);
+    if (value2 !== void 0) return value2;
+  }
+  return void 0;
+}
+function contextCapacityFromRecord(record) {
+  return firstPositive(record, [
+    "n_ctx",
+    "n_ctx_train",
+    "context_length",
+    "context_window",
+    "max_model_len",
+    "max_context_length"
+  ]);
+}
+function telemetryHeaders(apiKey) {
+  return apiKey ? { Authorization: `Bearer ${apiKey}` } : void 0;
+}
+async function fetchTelemetryJson(url, apiKey) {
+  try {
+    const response = await fetch(url, {
+      headers: telemetryHeaders(apiKey),
+      signal: AbortSignal.timeout(LLAMA_CPP_TELEMETRY_TIMEOUT_MS)
+    });
+    return response.ok ? await response.json() : null;
+  } catch {
+    return null;
+  }
+}
+function llamaCppSlotsFromJson(raw, endpoint, model) {
+  const root = asRecord(raw);
+  const slots = Array.isArray(raw) ? raw : Array.isArray(root?.["slots"]) ? root["slots"] : null;
+  if (!slots) return null;
+  const active = slots.map(asRecord).filter((slot) => {
+    if (!slot) return false;
+    return slot["is_processing"] === true || firstPositive(slot, ["n_prompt_tokens", "n_past", "n_decoded", "n_tokens"]) !== void 0;
+  });
+  if (active.length === 0) {
+    return { endpoint, model, activeSlotCount: 0, isLlamaCpp: true };
+  }
+  const measured = active.map((slot) => {
+    const promptTokens = firstPositive(slot, ["n_prompt_tokens", "prompt_tokens"]);
+    const decodedTokens = firstPositive(slot, ["n_decoded", "n_generated", "n_output_tokens"]);
+    const observed = promptTokens !== void 0 ? promptTokens + (decodedTokens ?? 0) : firstPositive(slot, ["n_past", "n_tokens"]) ?? decodedTokens;
+    return {
+      capacityTokens: firstPositive(slot, ["n_ctx", "context_length"]),
+      promptTokens,
+      decodedTokens,
+      outputReservationTokens: firstPositive(slot, ["n_predict", "n_predict_max", "n_output_reservation"]),
+      estimatedContextTokens: observed
+    };
+  });
+  const selected = measured.reduce(
+    (best, candidate) => (candidate.estimatedContextTokens ?? 0) > (best.estimatedContextTokens ?? 0) ? candidate : best
+  );
+  return {
+    endpoint,
+    model,
+    ...selected,
+    capacitySource: selected.capacityTokens ? "llama_cpp_slots" : void 0,
+    activeSlotCount: active.length,
+    isLlamaCpp: true
+  };
+}
+async function queryLlamaCppSlotTelemetry(baseUrl2, modelName, apiKey) {
+  const endpoint = llamaCppRootUrl(baseUrl2);
+  const slots = await fetchTelemetryJson(`${endpoint}/slots`, apiKey);
+  return llamaCppSlotsFromJson(slots, endpoint, modelName);
+}
+function llamaCppModelCapacity(raw, modelName) {
+  const root = asRecord(raw);
+  if (!root) return void 0;
+  const records = Array.isArray(root["data"]) ? root["data"].map(asRecord).filter((entry) => entry !== null) : [];
+  const target = records.find(
+    (entry) => [entry["id"], entry["name"], entry["model"]].some(
+      (value2) => typeof value2 === "string" && value2 === modelName
+    )
+  );
+  return (target && contextCapacityFromRecord(target)) ?? contextCapacityFromRecord(root);
+}
+async function queryLlamaCppContextTelemetry(baseUrl2, modelName, apiKey) {
+  const endpoint = llamaCppRootUrl(baseUrl2);
+  const [propsRaw, modelsRaw, slotsRaw] = await Promise.all([
+    fetchTelemetryJson(`${endpoint}/props`, apiKey),
+    fetchTelemetryJson(`${endpoint}/v1/models`, apiKey),
+    fetchTelemetryJson(`${endpoint}/slots`, apiKey)
+  ]);
+  const props = asRecord(propsRaw);
+  const slots = llamaCppSlotsFromJson(slotsRaw, endpoint, modelName);
+  const propsCapacity = props ? contextCapacityFromRecord(props) : void 0;
+  const modelsCapacity = llamaCppModelCapacity(modelsRaw, modelName);
+  const isLlamaCpp = props !== null || slots !== null;
+  if (!isLlamaCpp) return null;
+  const capacityTokens = propsCapacity ?? modelsCapacity ?? slots?.capacityTokens;
+  const capacitySource = propsCapacity ? "llama_cpp_props" : modelsCapacity ? "llama_cpp_models" : slots?.capacityTokens ? "llama_cpp_slots" : void 0;
+  return {
+    endpoint,
+    model: modelName,
+    ...slots,
+    capacityTokens,
+    capacitySource,
+    isLlamaCpp: true
+  };
+}
+async function queryContextTelemetry(baseUrl2, modelName, apiKey) {
+  const endpoint = normalizeBaseUrl(baseUrl2);
+  if (baseUrl2.startsWith("peer://")) {
+    return {
+      endpoint,
+      model: modelName,
+      capacityTokens: 32768,
+      capacitySource: "peer_default"
+    };
+  }
   const ollamaSize = await queryModelContextSize(baseUrl2, modelName);
-  if (ollamaSize) return ollamaSize;
-  return queryOpenAIContextSize(baseUrl2, modelName, apiKey);
+  if (ollamaSize) {
+    return { endpoint, model: modelName, capacityTokens: ollamaSize, capacitySource: "ollama_show" };
+  }
+  const llama = await queryLlamaCppContextTelemetry(baseUrl2, modelName, apiKey);
+  const openAiSize = await queryOpenAIContextSize(baseUrl2, modelName, apiKey);
+  if (openAiSize) {
+    return {
+      ...llama ?? { endpoint, model: modelName },
+      capacityTokens: openAiSize,
+      capacitySource: llama?.capacitySource ?? "openai_models"
+    };
+  }
+  return llama ?? { endpoint, model: modelName };
+}
+async function queryContextSize(baseUrl2, modelName, apiKey) {
+  return (await queryContextTelemetry(baseUrl2, modelName, apiKey)).capacityTokens ?? null;
 }
 async function queryModelCapabilities(baseUrl2, modelName) {
   const caps = { vision: false, toolUse: false, thinking: false };
@@ -633412,7 +634174,7 @@ function formatRelativeTime(iso2) {
   const months = Math.floor(days / 30);
   return `${months}mo ago`;
 }
-var IMAGE_GEN_PATTERNS;
+var IMAGE_GEN_PATTERNS, LLAMA_CPP_TELEMETRY_TIMEOUT_MS;
 var init_model_picker = __esm({
   "packages/cli/src/tui/model-picker.ts"() {
     init_dist6();
@@ -633426,6 +634188,7 @@ var init_model_picker = __esm({
       /midjourney/i,
       /imagen/i
     ];
+    LLAMA_CPP_TELEMETRY_TIMEOUT_MS = 2500;
   }
 });
 
@@ -647905,6 +648668,7 @@ var init_status_bar = __esm({
         lastCompletionTokens: 0,
         contextWindowSize: 0
       };
+      _contextCapacity = { status: "unknown" };
       // ── Metrics tracking for Telegram stats ──
       _backend = "ollama";
       _inferenceCount = 0;
@@ -649149,7 +649913,17 @@ var init_status_bar = __esm({
       }
       /** Context window size to display. Can be updated if model changes. */
       setContextWindowSize(size) {
-        this.metrics.contextWindowSize = size;
+        this.setContextCapacity(
+          Number.isFinite(size) && size > 0 ? { status: "known", totalTokens: Math.floor(size), source: "runtime" } : { status: "unknown", source: "unavailable" }
+        );
+      }
+      /** Update capacity provenance without turning missing server metadata into zero percent. */
+      setContextCapacity(state) {
+        const totalTokens = state.status === "known" && (state.totalTokens ?? 0) > 0 ? Math.floor(state.totalTokens) : 0;
+        this._contextCapacity = totalTokens > 0 ? { ...state, status: "known", totalTokens } : { ...state, status: "unknown", totalTokens: void 0 };
+        this.metrics.contextWindowSize = totalTokens;
+        this.pushSpinnerContextMetrics();
+        if (this.active) this.renderFooterPreserveCursor();
       }
       /** Set the current package version for display in the metrics row */
       setVersion(version5) {
@@ -649630,6 +650404,8 @@ var init_status_bar = __esm({
           this.metrics.totalTokens = update2.totalTokens;
         if (update2.estimatedContextTokens !== void 0)
           this.metrics.estimatedContextTokens = update2.estimatedContextTokens;
+        if (update2.contextOutputReservationTokens !== void 0)
+          this.metrics.contextOutputReservationTokens = update2.contextOutputReservationTokens;
         if (update2.lastPromptTokens !== void 0)
           this.metrics.lastPromptTokens = update2.lastPromptTokens;
         if (update2.lastCompletionTokens !== void 0)
@@ -651769,7 +652545,7 @@ ${CONTENT_BG_SEQ}`);
           this.effectiveContextTotal(m2.contextWindowSize)
         );
         let ctxStr = "";
-        if (ctxTotal > 0) {
+        if (this._contextCapacity.status === "known" && ctxTotal > 0) {
           const pct2 = Math.max(
             0,
             Math.min(100, Math.round((1 - ctxUsed / ctxTotal) * 100))
@@ -651781,6 +652557,10 @@ ${CONTENT_BG_SEQ}`);
           const bar = `\x1B[38;5;${barColor}m${"█".repeat(filled)}\x1B[0m\x1B[38;5;240m${"░".repeat(empty2)}\x1B[0m`;
           const pctColor = pct2 > 50 ? 120 : pct2 > 20 ? 222 : 210;
           ctxStr = `${bar} \x1B[38;5;${pctColor}m${pct2}%\x1B[0m`;
+        } else {
+          const usage = ctxUsed >= 1024 ? `${(ctxUsed / 1024).toFixed(ctxUsed >= 1e4 ? 0 : 1)}K` : String(Math.max(0, Math.round(ctxUsed)));
+          const reservation = m2.contextOutputReservationTokens && m2.contextOutputReservationTokens > 0 ? ` +${m2.contextOutputReservationTokens >= 1024 ? `${Math.round(m2.contextOutputReservationTokens / 1024)}K` : m2.contextOutputReservationTokens} rsv` : "";
+          ctxStr = `\x1B[38;5;245mCTX ? | ~${usage}${reservation}\x1B[0m`;
         }
         const arrow = `\x1B[38;5;240m▶\x1B[0m`;
         let rightSide;
@@ -670511,12 +671291,12 @@ async function ensureVoiceDeps(ctx3) {
       }
     }
     if (typeof mod3.getVenvPython === "function") {
-      const { dirname: dirname58 } = await import("node:path");
+      const { dirname: dirname59 } = await import("node:path");
       const { existsSync: existsSync177 } = await import("node:fs");
       const venvPy = mod3.getVenvPython();
       if (existsSync177(venvPy)) {
         process.env.TRANSCRIBE_PYTHON = venvPy;
-        const venvBin = dirname58(venvPy);
+        const venvBin = dirname59(venvPy);
         const sep8 = process.platform === "win32" ? ";" : ":";
         const cur = process.env.PATH || "";
         if (!cur.split(sep8).includes(venvBin)) {
@@ -673977,10 +674757,6 @@ Clone a new voice: /voice clone <wav-file> [name]`);
           renderWarning(
             "OMNIUS_FORCE_NO_THINK=1 forces off regardless of /think setting"
           );
-        else if (cur && process.env["OMNIUS_ENABLE_THINKING"] !== "1")
-          renderWarning(
-            "OMNIUS_ENABLE_THINKING is not set; /think is saved but backend requests remain direct-answer mode."
-          );
         return "handled";
       }
       if (token === "auto") {
@@ -674019,11 +674795,6 @@ Clone a new voice: /voice clone <wav-file> [name]`);
         renderInfo(
           "Note: max_tokens will auto-raise to ≥4096 per request to prevent <think> truncation."
         );
-        if (process.env["OMNIUS_ENABLE_THINKING"] !== "1") {
-          renderWarning(
-            "Thinking is hard-disabled by default. Set OMNIUS_ENABLE_THINKING=1 before launch for /think on or /think auto to affect backend requests."
-          );
-        }
       }
       return "handled";
     }
@@ -683925,14 +684696,14 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
     if (models.length > 0) {
       try {
         const { writeFileSync: writeFileSync97, mkdirSync: mkdirSync114 } = await import("node:fs");
-        const { join: join190, dirname: dirname58 } = await import("node:path");
+        const { join: join190, dirname: dirname59 } = await import("node:path");
         const cachePath2 = join190(
           ctx3.repoRoot || process.cwd(),
           ".omnius",
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync114(dirname58(cachePath2), { recursive: true });
+        mkdirSync114(dirname59(cachePath2), { recursive: true });
         writeFileSync97(
           cachePath2,
           JSON.stringify(
@@ -684008,14 +684779,14 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local, advertisedModels
       );
       try {
         const { writeFileSync: writeFileSync97, mkdirSync: mkdirSync114 } = await import("node:fs");
-        const { join: join190, dirname: dirname58 } = await import("node:path");
+        const { join: join190, dirname: dirname59 } = await import("node:path");
         const cachePath2 = join190(
           ctx3.repoRoot || process.cwd(),
           ".omnius",
           "nexus",
           "peer-models-cache.json"
         );
-        mkdirSync114(dirname58(cachePath2), { recursive: true });
+        mkdirSync114(dirname59(cachePath2), { recursive: true });
         writeFileSync97(
           cachePath2,
           JSON.stringify(
@@ -685031,10 +685802,10 @@ async function handleUpdate(subcommand, ctx3) {
   try {
     const { createRequire: createRequire11 } = await import("node:module");
     const { fileURLToPath: fileURLToPath26 } = await import("node:url");
-    const { dirname: dirname58, join: join190 } = await import("node:path");
+    const { dirname: dirname59, join: join190 } = await import("node:path");
     const { existsSync: existsSync177 } = await import("node:fs");
     const req3 = createRequire11(import.meta.url);
-    const thisDir = dirname58(fileURLToPath26(import.meta.url));
+    const thisDir = dirname59(fileURLToPath26(import.meta.url));
     const candidates = [
       join190(thisDir, "..", "package.json"),
       join190(thisDir, "..", "..", "package.json"),
@@ -700693,6 +701464,7 @@ import {
 } from "node:fs";
 import {
   join as join170,
+  dirname as dirname53,
   resolve as resolve73,
   basename as basename42,
   relative as relative21,
@@ -700700,7 +701472,11 @@ import {
   extname as extname21
 } from "node:path";
 import { homedir as homedir56 } from "node:os";
-import { writeFile as writeFileAsync } from "node:fs/promises";
+import {
+  appendFile as appendFileAsync,
+  mkdir as mkdirAsync,
+  writeFile as writeFileAsync
+} from "node:fs/promises";
 import { createHash as createHash49, randomBytes as randomBytes28, randomInt } from "node:crypto";
 function formatModelBytes(bytes) {
   if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
@@ -703733,6 +704509,12 @@ Telegram link integrity contract:
       subAgents = /* @__PURE__ */ new Map();
       /** Debounced live-context packets for messages arriving during a runner. */
       telegramSubAgentContextBuffers = /* @__PURE__ */ new Map();
+      /** Append-only, durable ingress ledger for every agent-routed Telegram task input. */
+      telegramIntakeRecords = /* @__PURE__ */ new Map();
+      telegramIntakeMessages = /* @__PURE__ */ new Map();
+      telegramIntakeWriteTail = Promise.resolve();
+      /** Intent epochs isolate redirected/replaced work inside a long-lived chat session. */
+      telegramTaskEpochs = /* @__PURE__ */ new Map();
       /** Active direct chat completions, counted with Telegram activity in the TUI */
       activeChatViews = /* @__PURE__ */ new Set();
       /** Active direct chat completions by Telegram session key for admission. */
@@ -704634,7 +705416,7 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
         }
         this.refreshActiveTelegramInteractionCount();
       }
-      buildTelegramQueuedSessionWork(sessionKey, msg, toolContext, now2) {
+      buildTelegramQueuedSessionWork(sessionKey, msg, toolContext, now2, intakeRecord) {
         const existing = this.telegramQueuedSessionWork.get(sessionKey);
         const messages2 = [...existing?.messages ?? [], msg].slice(
           -TELEGRAM_SUB_AGENT_BURST_CONTEXT_LIMIT
@@ -704643,6 +705425,7 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           sessionKey,
           msg,
           messages: messages2,
+          intakeRecords: [...existing?.intakeRecords ?? [], intakeRecord],
           toolContext,
           enqueuedAtMs: existing?.enqueuedAtMs ?? now2,
           lastSpokenAtMs: now2,
@@ -704668,14 +705451,15 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
       shouldAwaitTelegramQueuedWorkForTests() {
         return process.env["OMNIUS_TG_AWAIT_QUEUED_WORK"] === "1" || process.env["VITEST"] === "true";
       }
-      scheduleTelegramSessionWork(msg, toolContext) {
+      scheduleTelegramSessionWork(msg, toolContext, intakeRecord) {
         const sessionKey = this.sessionKeyForMessage(msg);
         const now2 = Date.now();
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
           return this.enqueueTelegramMessageForExistingSubAgent(
             msg,
-            existing
+            existing,
+            intakeRecord
           ).catch((err) => {
             this.tuiWrite(
               () => renderWarning(
@@ -704689,9 +705473,15 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           sessionKey,
           msg,
           toolContext,
-          now2
+          now2,
+          intakeRecord
         );
         this.telegramQueuedSessionWork.set(sessionKey, queued);
+        void this.transitionTelegramIntake(
+          intakeRecord,
+          "deferred",
+          "queued behind Telegram session admission"
+        );
         this.refreshActiveTelegramInteractionCount();
         this.dispatchQueuedTelegramSessionWorkSoon(
           Math.max(0, queued.dispatchAfterMs - now2)
@@ -704902,14 +705692,14 @@ ${message2}`)
             `live context injected (${buffer2.messages.length} message${buffer2.messages.length === 1 ? "" : "s"})`
           );
         } else {
-          subAgent.pendingMessages.push(packet);
+          subAgent.pendingContextPackets.push(packet);
           this.subAgentViewCallbacks?.onWrite(
             subAgent.viewId,
             `live context staged (${buffer2.messages.length} message${buffer2.messages.length === 1 ? "" : "s"})`
           );
         }
       }
-      async enqueueTelegramMessageForExistingSubAgent(msg, subAgent) {
+      async enqueueTelegramMessageForExistingSubAgent(msg, subAgent, intakeRecord) {
         const sessionKey = this.sessionKeyForMessage(msg);
         let mediaContext = "";
         if (msg.media || msg.replyToMedia) {
@@ -704928,11 +705718,16 @@ ${message2}`)
         } else {
           this.recordTelegramUserMessage(msg, "steering");
         }
-        this.enqueueTelegramSubAgentContext(
-          sessionKey,
+        this.injectTelegramSteeringInput(
           subAgent,
-          context2,
-          msg.username
+          intakeRecord,
+          context2
+        );
+        void this.transitionTelegramIntake(
+          intakeRecord,
+          "accepted",
+          "accepted by active Telegram runner",
+          { runId: subAgent.runId }
         );
         this.tuiWrite(
           () => renderTelegramSubAgentEvent(
@@ -704944,8 +705739,259 @@ ${message2}`)
       async enqueueTelegramQueuedSessionWorkForExistingSubAgent(work, subAgent) {
         const messages2 = work.messages.length > 0 ? work.messages : [work.msg];
         for (const msg of messages2) {
-          await this.enqueueTelegramMessageForExistingSubAgent(msg, subAgent);
+          const intakeRecord = work.intakeRecords.find(
+            (record) => record.inputId === this.telegramInputIdForMessage(msg)
+          );
+          if (!intakeRecord) continue;
+          await this.enqueueTelegramMessageForExistingSubAgent(
+            msg,
+            subAgent,
+            intakeRecord
+          );
+        }
+      }
+      telegramInputIdForMessage(msg) {
+        const thread = msg.messageThreadId ?? 0;
+        return `telegram:${this.sessionKeyForMessage(msg)}:${thread}:${msg.messageId ?? "unknown"}`;
+      }
+      telegramTaskEpoch(sessionKey) {
+        const current = this.telegramTaskEpochs.get(sessionKey);
+        if (current !== void 0) return current;
+        this.telegramTaskEpochs.set(sessionKey, 1);
+        return 1;
+      }
+      advanceTelegramTaskEpoch(sessionKey) {
+        const next = this.telegramTaskEpoch(sessionKey) + 1;
+        this.telegramTaskEpochs.set(sessionKey, next);
+        return next;
+      }
+      triageTelegramSteeringInput(msg) {
+        const text2 = msg.text.trim();
+        const lower = text2.toLowerCase();
+        if (/^\/(?:stop|cancel|abort|halt)\b/.test(lower)) {
+          return { intent: "cancel", reason: "explicit stop/cancel command" };
         }
+        if (/^\/(?:redirect|reroute|pivot)\b/.test(lower)) {
+          return { intent: "redirect", reason: "explicit redirect command" };
+        }
+        if (/^\/(?:replace|new[_-]?task)\b/.test(lower) || /^(?:new task|replace (?:the )?(?:current )?task|forget (?:that|the current task)|instead[,!:]?)/.test(
+          lower
+        )) {
+          return { intent: "replace", reason: "explicit replacement/new-task request" };
+        }
+        if (/^\/(?:append|add|also)\b/.test(lower) || /^(?:also|add|include|one more thing)\b/.test(lower)) {
+          return { intent: "append", reason: "explicit additive instruction" };
+        }
+        if (/\?$/.test(text2) || /^(?:clarify|correction|to be clear)\b/.test(lower)) {
+          return { intent: "clarify", reason: "plain-text clarification; scope preserved" };
+        }
+        return { intent: "append", reason: "conservative plain-text intake; momentum preserved" };
+      }
+      telegramIntakePath(sessionKey) {
+        const digest3 = createHash49("sha256").update(sessionKey).digest("hex").slice(0, 20);
+        return join170(
+          this.repoRoot ?? process.cwd(),
+          ".omnius",
+          "telegram-intake",
+          `${digest3}.jsonl`
+        );
+      }
+      appendTelegramIntakeJournal(sessionKey, entry) {
+        const write2 = async () => {
+          const path16 = this.telegramIntakePath(sessionKey);
+          await mkdirAsync(dirname53(path16), { recursive: true });
+          await appendFileAsync(path16, `${JSON.stringify(entry)}
+`, "utf8");
+        };
+        this.telegramIntakeWriteTail = this.telegramIntakeWriteTail.catch(() => {
+        }).then(write2);
+        return this.telegramIntakeWriteTail;
+      }
+      async registerTelegramIntake(msg, triage) {
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const inputId = this.telegramInputIdForMessage(msg);
+        const existing = this.telegramIntakeRecords.get(inputId);
+        if (existing) return existing;
+        const now2 = (/* @__PURE__ */ new Date()).toISOString();
+        const record = {
+          inputId,
+          source: "telegram",
+          receivedAt: now2,
+          lifecycle: "received",
+          lifecycleAt: now2,
+          lifecycleReason: "Telegram update accepted before task routing",
+          intent: triage.intent,
+          classificationReason: triage.reason,
+          sessionKey,
+          chatId: String(msg.chatId),
+          messageId: msg.messageId,
+          messageThreadId: msg.messageThreadId,
+          rawText: msg.text,
+          taskEpoch: this.telegramTaskEpoch(sessionKey)
+        };
+        this.telegramIntakeRecords.set(inputId, record);
+        this.telegramIntakeMessages.set(inputId, msg);
+        await this.appendTelegramIntakeJournal(sessionKey, {
+          kind: "intake_received",
+          record
+        });
+        await this.transitionTelegramIntake(record, "classified", triage.reason);
+        return record;
+      }
+      async transitionTelegramIntake(record, lifecycle, reason, links2 = {}) {
+        const at = (/* @__PURE__ */ new Date()).toISOString();
+        Object.assign(record, links2, {
+          lifecycle,
+          lifecycleAt: at,
+          lifecycleReason: reason
+        });
+        await this.appendTelegramIntakeJournal(record.sessionKey, {
+          kind: "intake_lifecycle",
+          inputId: record.inputId,
+          lifecycle,
+          at,
+          reason,
+          taskEpoch: record.taskEpoch,
+          runId: record.runId,
+          runnerTurn: record.runnerTurn
+        });
+      }
+      formatTelegramSteeringCompatibilityMessage(input) {
+        return [
+          "[TELEGRAM_STEERING_INTAKE]",
+          `input_id: ${input.intake.inputId}`,
+          `intent: ${input.intake.intent}`,
+          `task_epoch: ${input.intake.taskEpoch}`,
+          "This is a direct user intake. Reconcile it before the next action; do not treat it as passive transcript context.",
+          input.content,
+          "[/TELEGRAM_STEERING_INTAKE]"
+        ].join("\n");
+      }
+      injectTelegramSteeringInput(subAgent, intake, content) {
+        const pending2 = { intake, content };
+        if (!subAgent.runner) {
+          subAgent.pendingIntakeRecords.push(pending2);
+          return;
+        }
+        const runner = subAgent.runner;
+        if (typeof runner.injectSteeringInput === "function") {
+          runner.injectSteeringInput({
+            inputId: intake.inputId,
+            content,
+            source: "telegram",
+            receivedAt: intake.receivedAt,
+            intent: intake.intent,
+            taskEpoch: intake.taskEpoch
+          });
+          return;
+        }
+        runner.injectUserMessage(this.formatTelegramSteeringCompatibilityMessage(pending2));
+      }
+      async preemptTelegramSubAgentForIntake(msg, subAgent, toolContext, intake) {
+        const sessionKey = intake.sessionKey;
+        await this.transitionTelegramIntake(
+          intake,
+          "acknowledged",
+          "trusted Telegram steering receipt sent",
+          { runId: subAgent.runId }
+        );
+        const receipt = intake.intent === "cancel" ? "Cancellation received. I am stopping the current task." : "Redirection received. I am stopping the current step and replanning from your latest instruction.";
+        await this.replyToTelegramMessage(msg, receipt).catch(() => null);
+        await this.transitionTelegramIntake(
+          intake,
+          "preempt_requested",
+          "trusted admin-DM steering preemption requested",
+          { runId: subAgent.runId }
+        );
+        subAgent.preempted = true;
+        if (intake.intent !== "cancel") {
+          const epoch = this.advanceTelegramTaskEpoch(sessionKey);
+          const displaced = this.telegramQueuedSessionWork.get(sessionKey);
+          if (displaced) {
+            this.telegramQueuedSessionWork.delete(sessionKey);
+            await Promise.all(
+              displaced.intakeRecords.map(
+                (record) => this.transitionTelegramIntake(
+                  record,
+                  "superseded",
+                  `superseded by trusted ${intake.intent} intake ${intake.inputId}`
+                )
+              )
+            );
+          }
+          intake.taskEpoch = epoch;
+          const queued = this.buildTelegramQueuedSessionWork(
+            sessionKey,
+            msg,
+            toolContext,
+            Date.now(),
+            intake
+          );
+          this.telegramQueuedSessionWork.set(sessionKey, queued);
+          await this.transitionTelegramIntake(
+            intake,
+            "deferred",
+            "waiting for superseded runner cleanup before dispatch",
+            { taskEpoch: epoch }
+          );
+        }
+        const runner = subAgent.runner;
+        if (typeof runner?.requestSteeringPreemption === "function") {
+          runner.requestSteeringPreemption(intake.inputId);
+        } else {
+          runner?.abort?.();
+        }
+        await this.transitionTelegramIntake(
+          intake,
+          "preempted",
+          "active runner interrupted for trusted steering intake",
+          { runId: subAgent.runId }
+        );
+        this.dispatchQueuedTelegramSessionWorkSoon();
+      }
+      async requeuePendingTelegramIntakeOnFinalization(subAgent) {
+        const pending2 = subAgent.pendingIntakeRecords.splice(0);
+        if (pending2.length === 0) return;
+        for (const item of pending2) {
+          const msg = this.telegramIntakeMessages.get(item.intake.inputId);
+          if (!msg || subAgent.preempted) {
+            await this.transitionTelegramIntake(
+              item.intake,
+              subAgent.preempted ? "superseded" : "failed",
+              subAgent.preempted ? "runner was superseded before pending intake dispatch" : "original Telegram message unavailable for pending intake requeue"
+            );
+            continue;
+          }
+          const work = this.buildTelegramQueuedSessionWork(
+            item.intake.sessionKey,
+            msg,
+            subAgent.toolContext,
+            Date.now(),
+            item.intake
+          );
+          this.telegramQueuedSessionWork.set(item.intake.sessionKey, work);
+          await this.transitionTelegramIntake(
+            item.intake,
+            "deferred",
+            "runner finalized before pending intake dispatch; requeued atomically"
+          );
+        }
+        this.dispatchQueuedTelegramSessionWorkSoon();
+      }
+      forwardTelegramRunnerIntakeLifecycle(event) {
+        const typed = event;
+        const inputId = typed.inputId ?? typed.steeringInputId;
+        if (!inputId) return;
+        const record = this.telegramIntakeRecords.get(inputId);
+        if (!record) return;
+        const lifecycle = typed.type === "steering_preempt_requested" ? "preempt_requested" : typed.type === "steering_preempted" ? "preempted" : typed.type === "steering_input_consumed" || typed.type === "steering_consumed" ? "consumed" : typed.type === "steering_input_accepted" || typed.type === "steering_received" ? "accepted" : null;
+        if (!lifecycle) return;
+        void this.transitionTelegramIntake(
+          record,
+          lifecycle,
+          `runner lifecycle event: ${typed.type}`,
+          typeof typed.turn === "number" ? { runnerTurn: typed.turn } : {}
+        );
       }
       async replyWithTelegramHelp(msg, isAdmin) {
         const scope = isAdmin ? "admin" : "public";
@@ -712649,12 +713695,32 @@ Join: ${newUrl}`
             return;
           }
         }
+        const intakeTriage = this.triageTelegramSteeringInput(msg);
+        const intakeRecord = await this.registerTelegramIntake(msg, intakeTriage);
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
-          await this.enqueueTelegramMessageForExistingSubAgent(msg, existing);
+          const trustedPreemption = isAdminDM && (intakeRecord.intent === "cancel" || intakeRecord.intent === "redirect" || intakeRecord.intent === "replace");
+          if (trustedPreemption) {
+            await this.preemptTelegramSubAgentForIntake(
+              msg,
+              existing,
+              toolContext,
+              intakeRecord
+            );
+            return;
+          }
+          await this.enqueueTelegramMessageForExistingSubAgent(
+            msg,
+            existing,
+            intakeRecord
+          );
           return;
         }
-        const queuedWork = this.scheduleTelegramSessionWork(msg, toolContext);
+        const queuedWork = this.scheduleTelegramSessionWork(
+          msg,
+          toolContext,
+          intakeRecord
+        );
         if (this.shouldAwaitTelegramQueuedWorkForTests()) await queuedWork;
       }
       async processTelegramMessageWork(work, workGeneration) {
@@ -712664,6 +713730,15 @@ Join: ${newUrl}`
         const isAdminDM = toolContext === "telegram-admin-dm";
         if (!this.telegramWorkGenerationIsCurrent(sessionKey, workGeneration))
           return;
+        await Promise.all(
+          work.intakeRecords.map(
+            (record) => this.transitionTelegramIntake(
+              record,
+              "dispatched",
+              "Telegram session work dispatched to runner admission"
+            )
+          )
+        );
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
           await this.enqueueTelegramQueuedSessionWorkForExistingSubAgent(
@@ -712742,6 +713817,15 @@ Join: ${newUrl}`
             msg,
             `live inference: no reply — ${decision2.reason}`
           );
+          await Promise.all(
+            work.intakeRecords.map(
+              (intake) => this.transitionTelegramIntake(
+                intake,
+                "consumed",
+                "Telegram attention router retained intake without visible reply"
+              )
+            )
+          );
           return;
         }
         const decisionContext = this.formatTelegramAttentionDecisionContext(deliveredDecision);
@@ -712786,6 +713870,15 @@ Join: ${newUrl}`
               daydreamOpportunities
             );
           }
+          await Promise.all(
+            work.intakeRecords.map(
+              (intake) => this.transitionTelegramIntake(
+                intake,
+                "consumed",
+                "Telegram quick-chat path completed"
+              )
+            )
+          );
           return;
         }
         const subAgent = {
@@ -712809,7 +713902,10 @@ Join: ${newUrl}`
           lastEditMs: 0,
           aborted: false,
           toolContext,
-          pendingMessages: [],
+          pendingIntakeRecords: [],
+          pendingContextPackets: [],
+          runId: `telegram:${randomBytes28(8).toString("hex")}`,
+          taskEpoch: work.intakeRecords[work.intakeRecords.length - 1]?.taskEpoch ?? this.telegramTaskEpoch(sessionKey),
           creativeWorkspaceRoot: this.creativeWorkspaceRootForMessage(
             msg,
             toolContext
@@ -712820,6 +713916,14 @@ Join: ${newUrl}`
           surfacedToolCallFingerprints: /* @__PURE__ */ new Set()
         };
         this.subAgents.set(sessionKey, subAgent);
+        for (const intake of work.intakeRecords) {
+          void this.transitionTelegramIntake(
+            intake,
+            "accepted",
+            "admitted as the primary Telegram task prompt",
+            { runId: subAgent.runId }
+          );
+        }
         this.refreshActiveTelegramInteractionCount();
         this.subAgentViewCallbacks?.onRegister(
           subAgent.viewId,
@@ -712870,6 +713974,20 @@ Join: ${newUrl}`
             mediaContext,
             subAgentProfile,
             [decisionContext, rapidContext].filter(Boolean).join("\n\n")
+          ).catch((err) => {
+            if (subAgent.preempted) return "";
+            throw err;
+          });
+          if (subAgent.preempted) return;
+          await Promise.all(
+            work.intakeRecords.map(
+              (intake) => this.transitionTelegramIntake(
+                intake,
+                "consumed",
+                "primary Telegram task completed its runner lifecycle",
+                { runId: subAgent.runId }
+              )
+            )
           );
           if (subAgent.typingInterval) {
             clearInterval(subAgent.typingInterval);
@@ -713061,6 +714179,7 @@ Join: ${newUrl}`
           }
         } finally {
           this.stopTelegramPublicProgressMessage(subAgent);
+          await this.requeuePendingTelegramIntakeOnFinalization(subAgent);
           this.clearTelegramSubAgentContextBuffer(sessionKey);
           this.subAgents.delete(sessionKey);
           this.refreshActiveTelegramInteractionCount();
@@ -713091,7 +714210,10 @@ Join: ${newUrl}`
           lastEditMs: 0,
           aborted: false,
           toolContext,
-          pendingMessages: [],
+          pendingIntakeRecords: [],
+          pendingContextPackets: [],
+          runId: `telegram:${randomBytes28(8).toString("hex")}`,
+          taskEpoch: this.telegramTaskEpoch(sessionKey),
           creativeWorkspaceRoot: this.creativeWorkspaceRootForMessage(
             msg,
             toolContext
@@ -713102,6 +714224,17 @@ Join: ${newUrl}`
           surfacedToolCallFingerprints: /* @__PURE__ */ new Set()
         };
         this.subAgents.set(sessionKey, subAgent);
+        const primaryIntake = this.telegramIntakeRecords.get(
+          this.telegramInputIdForMessage(msg)
+        );
+        if (primaryIntake) {
+          void this.transitionTelegramIntake(
+            primaryIntake,
+            "accepted",
+            "admitted as the primary Telegram chat prompt",
+            { runId: subAgent.runId }
+          );
+        }
         this.refreshActiveTelegramInteractionCount();
         this.subAgentViewCallbacks?.onRegister(
           subAgent.viewId,
@@ -713144,7 +714277,11 @@ Join: ${newUrl}`
             mediaContext,
             "chat",
             additionalContext
-          );
+          ).catch((err) => {
+            if (subAgent.preempted) return "";
+            throw err;
+          });
+          if (subAgent.preempted) return;
           if (subAgent.typingInterval) {
             clearInterval(subAgent.typingInterval);
             subAgent.typingInterval = null;
@@ -713268,6 +714405,7 @@ Join: ${newUrl}`
             );
           }
         } finally {
+          await this.requeuePendingTelegramIntakeOnFinalization(subAgent);
           this.clearTelegramSubAgentContextBuffer(sessionKey);
           this.subAgents.delete(sessionKey);
           this.refreshActiveTelegramInteractionCount();
@@ -713734,6 +714872,7 @@ ${conversationStream}`
           ...isAdminDM ? TELEGRAM_ADMIN_EVIDENCE_OPTIONS : TELEGRAM_PUBLIC_FAST_OPTIONS,
           // ── WO #03 (Typed Gateway Event Stream): structured event feed ──
           onTypedEvent: (event) => {
+            this.forwardTelegramRunnerIntakeLifecycle(event);
             if (event.type === "run_finished") {
               subAgent.runnerCompleted = event.success;
               subAgent.runnerStatus = event.status;
@@ -713749,17 +714888,33 @@ ${conversationStream}`
         });
         runner.setWorkingDirectory(repoRoot);
         subAgent.runner = runner;
-        if (subAgent.pendingMessages.length > 0) {
-          for (const queued of subAgent.pendingMessages) {
-            runner.injectUserMessage(queued);
+        if (subAgent.pendingIntakeRecords.length > 0) {
+          for (const queued of subAgent.pendingIntakeRecords) {
+            this.injectTelegramSteeringInput(
+              subAgent,
+              queued.intake,
+              queued.content
+            );
+            void this.transitionTelegramIntake(
+              queued.intake,
+              "accepted",
+              "initial Telegram intake handed to runner",
+              { runId: subAgent.runId }
+            );
           }
           this.tuiWrite(
             () => renderTelegramSubAgentEvent(
               msg.username,
-              `replayed ${subAgent.pendingMessages.length} queued message(s)`
+              `replayed ${subAgent.pendingIntakeRecords.length} typed intake record(s)`
             )
           );
-          subAgent.pendingMessages.length = 0;
+          subAgent.pendingIntakeRecords.length = 0;
+        }
+        if (subAgent.pendingContextPackets.length > 0) {
+          for (const packet of subAgent.pendingContextPackets) {
+            runner.injectUserMessage(packet);
+          }
+          subAgent.pendingContextPackets.length = 0;
         }
         const tools = this.buildSubAgentTools(
           ctx3,
@@ -721987,7 +723142,7 @@ var init_audit_log = __esm({
 // packages/cli/src/api/disk-task-output.ts
 import { open } from "node:fs/promises";
 import { existsSync as existsSync164, mkdirSync as mkdirSync102, statSync as statSync63 } from "node:fs";
-import { dirname as dirname53 } from "node:path";
+import { dirname as dirname54 } from "node:path";
 import * as fsConstants from "node:constants";
 var O_NOFOLLOW2, O_APPEND2, O_CREAT2, O_WRONLY2, OPEN_FLAGS_WRITE, OPEN_MODE, DiskTaskOutput;
 var init_disk_task_output = __esm({
@@ -722005,7 +723160,7 @@ var init_disk_task_output = __esm({
       fileSize = 0;
       constructor(outputPath3) {
         this.path = outputPath3;
-        mkdirSync102(dirname53(outputPath3), { recursive: true });
+        mkdirSync102(dirname54(outputPath3), { recursive: true });
       }
       /** Queue content for async append. Non-blocking. */
       append(chunk) {
@@ -741090,7 +742245,7 @@ var init_chat_followup = __esm({
 // packages/cli/src/docker.ts
 import { execSync as execSync39, spawn as spawn37 } from "node:child_process";
 import { existsSync as existsSync172, mkdirSync as mkdirSync108, writeFileSync as writeFileSync91 } from "node:fs";
-import { join as join181, resolve as resolve76, dirname as dirname54 } from "node:path";
+import { join as join181, resolve as resolve76, dirname as dirname55 } from "node:path";
 import { homedir as homedir62 } from "node:os";
 import { fileURLToPath as fileURLToPath22 } from "node:url";
 function getDockerDir() {
@@ -741101,7 +742256,7 @@ function getDockerDir() {
   } catch {
   }
   try {
-    const thisDir = dirname54(fileURLToPath22(import.meta.url));
+    const thisDir = dirname55(fileURLToPath22(import.meta.url));
     return join181(thisDir, "..", "..", "..", "docker");
   } catch {
   }
@@ -741566,7 +742721,7 @@ import * as http5 from "node:http";
 import * as https3 from "node:https";
 import { createRequire as createRequire8 } from "node:module";
 import { fileURLToPath as fileURLToPath23 } from "node:url";
-import { dirname as dirname55, join as join183, resolve as resolve77 } from "node:path";
+import { dirname as dirname56, join as join183, resolve as resolve77 } from "node:path";
 import { homedir as homedir63 } from "node:os";
 import { spawn as spawn38, execSync as execSync40 } from "node:child_process";
 import {
@@ -741596,7 +742751,7 @@ function memoryDbPaths3(baseDir = process.cwd()) {
 }
 function getVersion3() {
   try {
-    const thisDir = dirname55(fileURLToPath23(import.meta.url));
+    const thisDir = dirname56(fileURLToPath23(import.meta.url));
     const candidates = [
       join183(thisDir, "..", "package.json"),
       join183(thisDir, "..", "..", "package.json"),
@@ -744312,7 +745467,8 @@ async function handleV1ChatCompletions(req3, res, ollamaUrl) {
     return;
   }
   const callerProvidedThink = "think" in routedBody;
-  const thinkingAllowed = process.env["OMNIUS_ENABLE_THINKING"] === "1" && process.env["OMNIUS_FORCE_NO_THINK"] !== "1";
+  const requestTools = routedBody["tools"];
+  const thinkingAllowed = process.env["OMNIUS_FORCE_NO_THINK"] !== "1" && !(Array.isArray(requestTools) && requestTools.length > 0);
   const finalThink = thinkingAllowed && callerProvidedThink ? routedBody["think"] : false;
   const ollamaBody = { ...routedBody };
   if (finalThink === false && Array.isArray(ollamaBody["messages"])) {
@@ -745057,7 +746213,7 @@ async function handleV1Update(req3, res, requestId) {
     );
     const fs14 = require4("node:fs");
     const nodeBin = process.execPath;
-    const nodeDir = dirname55(nodeBin);
+    const nodeDir = dirname56(nodeBin);
     const { execSync: es } = require4("node:child_process");
     const isWin2 = process.platform === "win32";
     let npmBin = "";
@@ -745072,7 +746228,7 @@ async function handleV1Update(req3, res, requestId) {
     const dir = join183(homedir63(), ".omnius");
     fs14.mkdirSync(dir, { recursive: true });
     const logFd = fs14.openSync(logPath3, "w");
-    const npmPrefix = dirname55(nodeDir);
+    const npmPrefix = dirname56(nodeDir);
     let globalBinDir = "";
     try {
       if (isWin2) {
@@ -751021,7 +752177,7 @@ function startApiServer(options2 = {}) {
     if (process.env["OMNIUS_DAEMON"] === "1" && process.env["OMNIUS_NO_VERSION_GUARD"] !== "1") {
       const readDiskVersion = () => {
         try {
-          const here = dirname55(fileURLToPath23(import.meta.url));
+          const here = dirname56(fileURLToPath23(import.meta.url));
           for (const rel of ["../package.json", "../../package.json", "../../../package.json", "../../../../package.json"]) {
             const p2 = join183(here, rel);
             if (existsSync173(p2)) {
@@ -752112,7 +753268,7 @@ var init_clipboard_media = __esm({
 
 // packages/cli/src/tui/interactive.ts
 import { cwd } from "node:process";
-import { resolve as resolve78, join as join185, dirname as dirname56, extname as extname22, relative as relative22, sep as sep7 } from "node:path";
+import { resolve as resolve78, join as join185, dirname as dirname57, extname as extname22, relative as relative22, sep as sep7 } from "node:path";
 import { createRequire as createRequire9 } from "node:module";
 import { fileURLToPath as fileURLToPath24 } from "node:url";
 import { createHash as createHash53 } from "node:crypto";
@@ -752129,7 +753285,7 @@ import { existsSync as existsSync174 } from "node:fs";
 import {
   readFile as readFileAsync2,
   writeFile as writeFileAsync2,
-  mkdir as mkdirAsync
+  mkdir as mkdirAsync2
 } from "node:fs/promises";
 import { homedir as homedir64 } from "node:os";
 function refreshLocalOllamaModelCache() {
@@ -752173,7 +753329,7 @@ function formatTimeAgo2(date) {
 function getVersion4() {
   try {
     const require5 = createRequire9(import.meta.url);
-    const thisDir = dirname56(fileURLToPath24(import.meta.url));
+    const thisDir = dirname57(fileURLToPath24(import.meta.url));
     const candidates = [
       join185(thisDir, "..", "package.json"),
       join185(thisDir, "..", "..", "package.json"),
@@ -756081,7 +757237,7 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
                 if (existsSync174(ikFile)) {
                   ikState = JSON.parse(await readFileAsync2(ikFile, "utf8"));
                 } else {
-                  await mkdirAsync(ikDir, { recursive: true });
+                  await mkdirAsync2(ikDir, { recursive: true });
                   const machineId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
                   ikState = {
                     self_id: `omnius-${machineId}`,
@@ -757255,14 +758411,50 @@ ${result.summary}`
     } : null
   });
   let resolvedContextWindowSize = 0;
-  queryContextSize(config.backendUrl, config.model, config.apiKey).then((ctxSize) => {
-    if (ctxSize) {
-      resolvedContextWindowSize = ctxSize;
-      statusBar.setContextWindowSize(ctxSize);
-      setActiveTaskContextWindowSize(ctxSize);
-      telegramBridge?.setContextWindowSize(ctxSize);
+  const contextTelemetryByScope = /* @__PURE__ */ new Map();
+  const contextScope = (backendUrl2, model) => `${normalizeBaseUrl(backendUrl2).replace(/\/v1$/i, "")}\0${model}`;
+  const currentContextScope = () => contextScope(currentConfig.backendUrl, currentConfig.model);
+  const applyContextTelemetry = (telemetry) => {
+    const scope = contextScope(telemetry.endpoint, telemetry.model);
+    const previous = contextTelemetryByScope.get(scope);
+    const merged = {
+      ...previous,
+      ...telemetry,
+      capacityTokens: telemetry.capacityTokens ?? previous?.capacityTokens,
+      capacitySource: telemetry.capacityTokens ? telemetry.capacitySource : previous?.capacitySource
+    };
+    contextTelemetryByScope.set(scope, merged);
+    if (scope !== currentContextScope()) return;
+    const capacity = merged.capacityTokens;
+    resolvedContextWindowSize = capacity ?? 0;
+    statusBar.setContextCapacity(capacity ? {
+      status: "known",
+      totalTokens: capacity,
+      source: merged.capacitySource,
+      endpoint: merged.endpoint,
+      model: merged.model
+    } : {
+      status: "unknown",
+      source: "provider_metadata_missing",
+      endpoint: merged.endpoint,
+      model: merged.model
+    });
+    setActiveTaskContextWindowSize(capacity ?? 0);
+    telegramBridge?.setContextWindowSize(capacity ?? 0);
+    if (merged.estimatedContextTokens !== void 0 || merged.outputReservationTokens !== void 0) {
+      statusBar.updateMetrics({
+        ...merged.estimatedContextTokens !== void 0 ? { estimatedContextTokens: merged.estimatedContextTokens } : {},
+        ...merged.outputReservationTokens !== void 0 ? { contextOutputReservationTokens: merged.outputReservationTokens } : {}
+      });
     }
-  }).catch(() => {
+  };
+  void queryContextTelemetry(config.backendUrl, config.model, config.apiKey).then(applyContextTelemetry).catch(() => {
+    statusBar.setContextCapacity({
+      status: "unknown",
+      source: "query_failed",
+      endpoint: normalizeBaseUrl(config.backendUrl),
+      model: config.model
+    });
   });
   let resolvedCaps = {
     vision: false,
@@ -757576,6 +758768,28 @@ Rationale: ${proposal.rationale}${provenanceNote}${dmnDevDiscipline(proposal.cat
     const runner = activeTask?.runner;
     if (runner) runner.setContextWindowSize(size);
   };
+  let llamaCppSlotPollInFlight = false;
+  const pollLlamaCppSlots = async () => {
+    if (llamaCppSlotPollInFlight || !activeTask) return;
+    llamaCppSlotPollInFlight = true;
+    const pollScope = currentContextScope();
+    const endpoint = currentConfig.backendUrl;
+    const model = currentConfig.model;
+    const apiKey = currentConfig.apiKey;
+    try {
+      const telemetry = await queryLlamaCppSlotTelemetry(endpoint, model, apiKey);
+      if (telemetry && pollScope === currentContextScope()) {
+        applyContextTelemetry(telemetry);
+      }
+    } catch {
+    } finally {
+      llamaCppSlotPollInFlight = false;
+    }
+  };
+  const llamaCppSlotPollTimer = setInterval(() => {
+    void pollLlamaCppSlots();
+  }, 3e3);
+  llamaCppSlotPollTimer.unref();
   const turnQueue = [];
   let queueDrainScheduled = false;
   let sessionTitle = null;
@@ -764397,7 +765611,7 @@ init_typed_node_events();
 init_dist5();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { fileURLToPath as fileURLToPath25 } from "node:url";
-import { dirname as dirname57, join as join189 } from "node:path";
+import { dirname as dirname58, join as join189 } from "node:path";
 import { createRequire as createRequire10 } from "node:module";
 
 // packages/cli/src/cli.ts
@@ -764545,7 +765759,7 @@ init_output();
 function getVersion5() {
   try {
     const require5 = createRequire10(import.meta.url);
-    const pkgPath = join189(dirname57(fileURLToPath25(import.meta.url)), "..", "package.json");
+    const pkgPath = join189(dirname58(fileURLToPath25(import.meta.url)), "..", "package.json");
     const pkg = require5(pkgPath);
     return pkg.version;
   } catch {