omnius 1.0.553 → 1.0.554

package/dist/index.js

@@ -7256,6 +7256,22 @@ var init_file_write = __esm({
 import { execFile as execFile2 } from "node:child_process";
 import { promisify } from "node:util";
 import { resolve as resolve6 } from "node:path";
+function partialGrepOutput(input) {
+  const raw = input.stdout ?? "";
+  const lines = raw.split("\n").filter(Boolean);
+  const sample = lines.slice(0, MAX_OUTPUT_LINES).join("\n");
+  const narrowing = JSON.stringify({
+    pattern: input.pattern,
+    path: input.searchPath,
+    ...input.include ? { include: input.include } : {}
+  });
+  return [
+    `[GREP_PARTIAL] output reached the ${input.capBytes}-byte capture cap; matching succeeded but this is only a prefix (${lines.length} captured lines).`,
+    `provenance=tool:grep_search cap_bytes=${input.capBytes} path=${input.searchPath}${input.include ? ` include=${input.include}` : ""}`,
+    `narrow_next=add an include/path or a more specific pattern, e.g. grep_search(${narrowing})`,
+    sample
+  ].filter(Boolean).join("\n");
+}
 var _a, execFileAsync, MAX_OUTPUT_LINES, DEFAULT_SEARCH_TIMEOUT_MS, RG_EXCLUDED_GLOBS, GREP_EXCLUDED_DIRS, GrepSearchTool;
 var init_grep_search = __esm({
   "packages/execution/dist/tools/grep-search.js"() {
@@ -7374,10 +7390,25 @@ var init_grep_search = __esm({
             output: truncated ? `${output}
 
 [Output truncated to ${MAX_OUTPUT_LINES} lines. ${lines.length - MAX_OUTPUT_LINES} more matches exist.]` : output,
+            partial: truncated,
             durationMs: performance.now() - start2
           };
         } catch (error) {
           const err = error;
+          if (err.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || /maxbuffer|max buffer/i.test(err.message)) {
+            return {
+              success: true,
+              partial: true,
+              output: partialGrepOutput({
+                stdout: err.stdout,
+                pattern,
+                searchPath,
+                include,
+                capBytes: 1024 * 1024
+              }),
+              durationMs: performance.now() - start2
+            };
+          }
           if (err.code === 1) {
             return {
               success: true,
@@ -274007,11 +274038,11 @@ var require_out = __commonJS({
       async.read(path16, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports.stat = stat9;
-    function statSync70(path16, optionsOrSettings) {
+    function statSync71(path16, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path16, settings);
     }
-    exports.statSync = statSync70;
+    exports.statSync = statSync71;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -297514,6 +297545,10 @@ function replayWorkboardEvents(events) {
         goal: event.payload.goal,
         scope: event.payload.scope,
         title: event.payload.title,
+        taskEpoch: event.payload.taskEpoch,
+        rawUserIntent: event.payload.rawUserIntent,
+        artifactEvidence: event.payload.artifactEvidence,
+        lastSubstantiveProgress: event.payload.lastSubstantiveProgress,
         createdAt: event.createdAt,
         updatedAt: event.createdAt,
         eventCount: 0,
@@ -297538,7 +297573,11 @@ function replayWorkboardEvents(events) {
             status: event.payload.status,
             goal: event.payload.goal,
             scope: event.payload.scope,
-            title: event.payload.title
+            title: event.payload.title,
+            taskEpoch: event.payload.taskEpoch,
+            rawUserIntent: event.payload.rawUserIntent,
+            artifactEvidence: event.payload.artifactEvidence,
+            lastSubstantiveProgress: event.payload.lastSubstantiveProgress
           })
         };
         break;
@@ -297705,7 +297744,11 @@ function createWorkboard(workingDir, input = {}) {
           status: "active",
           goal: cleanString(input.goal),
           scope: cleanString(input.scope),
-          title: cleanString(input.title)
+          title: cleanString(input.title),
+          taskEpoch: typeof input.taskEpoch === "number" && Number.isFinite(input.taskEpoch) ? input.taskEpoch : void 0,
+          rawUserIntent: cleanString(input.rawUserIntent),
+          artifactEvidence: input.artifactEvidence ? normalizeEvidenceCollection(input.artifactEvidence, input.actor).slice(-12) : void 0,
+          lastSubstantiveProgress: input.lastSubstantiveProgress
         }
       }
     ];
@@ -297777,6 +297820,25 @@ function addWorkboardCard(workingDir, input) {
   }
   return appendWorkboardEvents(workingDir, runId, events);
 }
+function updateWorkboardMetadata(workingDir, input) {
+  const runId = normalizeWorkboardRunId(input.runId);
+  const snapshot = requireWorkboard(workingDir, runId);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  return appendWorkboardEvents(workingDir, runId, [{
+    schemaVersion: WORKBOARD_SCHEMA_VERSION,
+    id: newEventId("board"),
+    runId,
+    type: "board.updated",
+    createdAt: now2,
+    actor: cleanString(input.actor),
+    payload: {
+      taskEpoch: typeof input.taskEpoch === "number" && Number.isFinite(input.taskEpoch) ? input.taskEpoch : void 0,
+      rawUserIntent: cleanString(input.rawUserIntent),
+      artifactEvidence: input.artifactEvidence ? appendUniqueEvidence(snapshot.artifactEvidence ?? [], normalizeEvidenceCollection(input.artifactEvidence, input.actor)).slice(-12) : void 0,
+      lastSubstantiveProgress: input.lastSubstantiveProgress
+    }
+  }]);
+}
 function updateWorkboardCard(workingDir, input) {
   const runId = normalizeWorkboardRunId(input.runId);
   const snapshot = requireWorkboard(workingDir, runId);
@@ -297881,9 +297943,9 @@ function completeWorkboardCard(workingDir, input) {
   if (outcome === "request_changes") {
     const evidence2 = input.evidence === void 0 ? [] : normalizeEvidenceCollection(input.evidence, input.actor);
     const uniqueEvidence2 = evidence2.length > 0 ? filterNewEvidence(card.evidence, evidence2) : [];
-    const events = [];
+    const events2 = [];
     if (uniqueEvidence2.length > 0) {
-      events.push({
+      events2.push({
         schemaVersion: WORKBOARD_SCHEMA_VERSION,
         id: newEventId("evidence"),
         runId,
@@ -297895,7 +297957,7 @@ function completeWorkboardCard(workingDir, input) {
     }
     const missingEvidence = normalizeStringArray(input.missingEvidence);
     const reason2 = cleanString(input.reason) || cleanString(input.notes) || "Verifier requested changes.";
-    events.push({
+    events2.push({
       schemaVersion: WORKBOARD_SCHEMA_VERSION,
       id: newEventId("changes"),
       runId,
@@ -297909,7 +297971,7 @@ function completeWorkboardCard(workingDir, input) {
         decision: makeDecision("needs_changes", reason2, { cardId: card.id, actor: input.actor, createdAt: now2 })
       }
     });
-    snapshot = appendWorkboardEvents(workingDir, runId, events);
+    snapshot = appendWorkboardEvents(workingDir, runId, events2);
     return {
       accepted: true,
       snapshot,
@@ -297954,20 +298016,8 @@ function completeWorkboardCard(workingDir, input) {
     };
   }
   const evidence = input.evidence === void 0 ? [] : normalizeEvidenceCollection(input.evidence, input.actor);
-  let evidenceSnapshot = snapshot;
   const uniqueEvidence = evidence.length > 0 ? filterNewEvidence(card.evidence, evidence) : [];
-  if (uniqueEvidence.length > 0) {
-    evidenceSnapshot = appendWorkboardEvents(workingDir, runId, [{
-      schemaVersion: WORKBOARD_SCHEMA_VERSION,
-      id: newEventId("evidence"),
-      runId,
-      type: "evidence.attached",
-      createdAt: now2,
-      actor: cleanString(input.actor),
-      payload: { cardId: card.id, evidence: uniqueEvidence }
-    }]);
-  }
-  const currentCard = evidenceSnapshot.cards.find((existing) => existing.id === card.id) ?? card;
+  const currentCard = uniqueEvidence.length > 0 ? { ...card, evidence: appendUniqueEvidence(card.evidence, uniqueEvidence) } : card;
   const evidenceCheck = verifyCardEvidence(currentCard);
   if (!evidenceCheck.valid) {
     const diagnostic = makeDiagnostic("completion_without_evidence", "error", `card '${card.id}' cannot be ${outcome} without required evidence`, {
@@ -298012,7 +298062,20 @@ function completeWorkboardCard(workingDir, input) {
       decision: makeDecision("completed", reason, { cardId: card.id, actor: input.actor, createdAt: now2 })
     }
   };
-  snapshot = appendWorkboardEvents(workingDir, runId, [event]);
+  const events = [];
+  if (uniqueEvidence.length > 0) {
+    events.push({
+      schemaVersion: WORKBOARD_SCHEMA_VERSION,
+      id: newEventId("evidence"),
+      runId,
+      type: "evidence.attached",
+      createdAt: now2,
+      actor: cleanString(input.actor),
+      payload: { cardId: card.id, evidence: uniqueEvidence }
+    });
+  }
+  events.push(event);
+  snapshot = appendWorkboardEvents(workingDir, runId, events);
   return {
     accepted: true,
     snapshot,
@@ -298267,7 +298330,9 @@ function normalizeCardInput(input, timestamp) {
     diagnosticFingerprint: cleanString(input.diagnosticFingerprint),
     ownedFiles: normalizeStringArray(input.ownedFiles),
     verifierCommand: cleanString(input.verifierCommand),
-    rank: typeof input.rank === "number" && Number.isFinite(input.rank) ? input.rank : void 0
+    rank: typeof input.rank === "number" && Number.isFinite(input.rank) ? input.rank : void 0,
+    canonicalKey: cleanString(input.canonicalKey),
+    sourceTodoIds: normalizeStringArray(input.sourceTodoIds)
   };
   validateSpecialCardAdmission(card);
   return card;
@@ -298308,6 +298373,12 @@ function normalizeCardUpdates(input) {
     updates.verifierCommand = cleanString(input.verifierCommand);
   if (input.rank !== void 0 && Number.isFinite(input.rank))
     updates.rank = input.rank;
+  if (input.canonicalKey !== void 0)
+    updates.canonicalKey = cleanString(input.canonicalKey);
+  if (input.sourceTodoIds !== void 0)
+    updates.sourceTodoIds = normalizeStringArray(input.sourceTodoIds);
+  if (input.supersededBy !== void 0)
+    updates.supersededBy = cleanString(input.supersededBy);
   if (Object.keys(updates).length === 0)
     throw new WorkboardError("empty_update", "at least one card field must be updated");
   return updates;
@@ -311942,7 +312013,7 @@ ${lanes.join("\n")}
               return process.memoryUsage().heapUsed;
             },
             getFileSize(path16) {
-              const stat9 = statSync70(path16);
+              const stat9 = statSync71(path16);
               if (stat9 == null ? void 0 : stat9.isFile()) {
                 return stat9.size;
               }
@@ -311986,7 +312057,7 @@ ${lanes.join("\n")}
             }
           };
           return nodeSystem;
-          function statSync70(path16) {
+          function statSync71(path16) {
             try {
               return _fs.statSync(path16, statSyncOptions);
             } catch {
@@ -312045,7 +312116,7 @@ ${lanes.join("\n")}
               activeSession.post("Profiler.stop", (err, { profile }) => {
                 var _a2;
                 if (!err) {
-                  if ((_a2 = statSync70(profilePath)) == null ? void 0 : _a2.isDirectory()) {
+                  if ((_a2 = statSync71(profilePath)) == null ? void 0 : _a2.isDirectory()) {
                     profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
                   }
                   try {
@@ -312165,7 +312236,7 @@ ${lanes.join("\n")}
                 let stat9;
                 if (typeof dirent === "string" || dirent.isSymbolicLink()) {
                   const name10 = combinePaths(path16, entry);
-                  stat9 = statSync70(name10);
+                  stat9 = statSync71(name10);
                   if (!stat9) {
                     continue;
                   }
@@ -312189,7 +312260,7 @@ ${lanes.join("\n")}
             return matchFiles(path16, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
           }
           function fileSystemEntryExists(path16, entryKind) {
-            const stat9 = statSync70(path16);
+            const stat9 = statSync71(path16);
             if (!stat9) {
               return false;
             }
@@ -312231,7 +312302,7 @@ ${lanes.join("\n")}
           }
           function getModifiedTime3(path16) {
             var _a2;
-            return (_a2 = statSync70(path16)) == null ? void 0 : _a2.mtime;
+            return (_a2 = statSync71(path16)) == null ? void 0 : _a2.mtime;
           }
           function setModifiedTime(path16, time) {
             try {
@@ -562249,6 +562320,7 @@ __export(dist_exports2, {
   unifiedPythonEnv: () => unifiedPythonEnv,
   unifiedRuntimeDir: () => unifiedRuntimeDir,
   updateWorkboardCard: () => updateWorkboardCard,
+  updateWorkboardMetadata: () => updateWorkboardMetadata,
   validateCustomToolDefinition: () => validateCustomToolDefinition,
   validateMediaModelAdapter: () => validateMediaModelAdapter,
   validateMutationWorkerContract: () => validateMutationWorkerContract,
@@ -572353,14 +572425,17 @@ function collectDiff(opts) {
     }
     return { files, strategy: "explicit" };
   }
+  if (opts.explicitFilesOnly)
+    return { files: [], strategy: "explicit" };
   const since = Date.now() - opts.mtimeWindowMs;
   const scan = scanWorkspace({ root: opts.workingDir, maxFiles: cap * 4 });
   const recent = scan.files.filter((f2) => f2.mtimeMs >= since).sort((a2, b) => b.mtimeMs - a2.mtimeMs).slice(0, cap).map((f2) => ({ path: f2.rel, bytes: f2.bytes, status: "modified" }));
   return { files: recent, strategy: "mtime" };
 }
 async function collectDiffAsync(opts) {
-  if (opts.explicitFiles && opts.explicitFiles.length > 0)
+  if (opts.explicitFilesOnly || opts.explicitFiles && opts.explicitFiles.length > 0) {
     return collectDiff(opts);
+  }
   const cap = Math.max(1, opts.maxFiles);
   if (existsSync96(join106(opts.workingDir, ".git"))) {
     try {
@@ -572423,7 +572498,8 @@ async function runBackwardPass(opts) {
     workingDir: opts.workingDir,
     maxFiles,
     mtimeWindowMs,
-    explicitFiles: opts.explicitFiles
+    explicitFiles: opts.explicitFiles,
+    explicitFilesOnly: opts.explicitFilesOnly
   });
   const diff = collected.files.map((f2) => {
     const abs = isAbsolute14(f2.path) ? f2.path : join106(opts.workingDir, f2.path);
@@ -578836,7 +578912,10 @@ function retireDuplicateToolFailures(messages2) {
     }
     out[index] = {
       ...message2,
-      content: "[retired_duplicate_tool_failure] a newer matching result appears later. Use that latest diagnostic; retry only after refreshing prerequisite evidence or correcting the arguments."
+      // Keep the protocol message (some providers require every tool call to
+      // retain a response) but make retired duplicate failures token-empty.
+      // The newest result is the sole model-visible recovery record.
+      content: ""
     };
   }
   return out;
@@ -578877,10 +578956,22 @@ function prepareModelFacingApiMessages(input) {
     }
     sanitized.push({ ...message2 });
   }
-  const keep = new Array(sanitized.length).fill(true);
+  const activeUserEpoch = sanitized.reduce((latest, message2) => {
+    if (message2.role !== "user")
+      return latest;
+    const epoch = Number(message2["taskEpoch"]);
+    return Number.isInteger(epoch) && epoch >= 0 && (latest === null || epoch > latest) ? epoch : latest;
+  }, null);
+  const epochScoped = activeUserEpoch === null ? sanitized : sanitized.filter((message2) => {
+    if (message2.role !== "user")
+      return true;
+    const epoch = Number(message2["taskEpoch"]);
+    return Number.isInteger(epoch) && epoch === activeUserEpoch;
+  });
+  const keep = new Array(epochScoped.length).fill(true);
   const seenSystemKeys = /* @__PURE__ */ new Set();
-  for (let index = sanitized.length - 1; index >= 0; index--) {
-    const message2 = sanitized[index];
+  for (let index = epochScoped.length - 1; index >= 0; index--) {
+    const message2 = epochScoped[index];
     if (message2.role !== "system" || typeof message2.content !== "string")
       continue;
     if (preserveFirstSystem && index === 0)
@@ -578894,7 +578985,7 @@ function prepareModelFacingApiMessages(input) {
     }
     seenSystemKeys.add(key);
   }
-  const deduped = retireDuplicateToolFailures(sanitized.filter((_message, index) => keep[index]));
+  const deduped = retireDuplicateToolFailures(epochScoped.filter((_message, index) => keep[index]));
   if (!hasUserMessage(deduped) && !hasConcreteGoalMessage(deduped)) {
     const goal = deriveCurrentGoal({
       explicitGoal: input.currentGoal,
@@ -579026,7 +579117,7 @@ var init_context_compiler = __esm({
     MODEL_FACING_ACTION_GROUND_TRUTH_CHAR_CAP = 5500;
     CONTROLLER_STATE_MARKER = "[CONTROLLER STATE v1]";
     ACTION_GROUND_TRUTH_MARKER = "[RECENT ACTION GROUND TRUTH]";
-    LEGACY_RUNTIME_CONTROL_FRAGMENT_RE = /(?:\bREG-\d+\b|\bfocus supervisor\b|\bworld[ -]state\b|\brecent tool failures\b|\bstop\s*[—-]\s*retry loop\b|\bstagnation replan\b|\bfirst-edit nudge\b|\bintra-run lesson\b|\blocal error-informed nudge\b|\b(?:failure|failing)\s+(?:recovery|replan|loop)\b|\bdoom-loop\b|\b(?:prior\s+)?failure reflection\b|\breflexion\b|\b(?:cross-session|prior)\s+lessons?\b|\bprogress gate\b|\bforecast\b)/i;
+    LEGACY_RUNTIME_CONTROL_FRAGMENT_RE = /(?:\bREG-\d+\b|\bfocus supervisor\b|\bworld[ -]state\b|\brecent tool failures\b|\bstop\s*[—-]\s*retry loop\b|\bstagnation replan\b|\bfirst-edit nudge\b|\bintra-run lesson\b|\blocal error-informed nudge\b|\b(?:failure|failing)\s+(?:recovery|replan|loop|recap)\b|\b(?:controller|admin)\s+(?:summary|recap|reflection)\b|\bdoom-loop\b|\b(?:prior\s+)?failure reflection\b|\breflexion\b|\b(?:cross-session|prior)\s+lessons?\b|\bprogress gate\b|\bforecast\b)/i;
     LEGACY_RUNTIME_CONTROL_BLOCK_START_RE = /(?:\[(?:REG-\d+|FOCUS SUPERVISOR[^\]]*|WORLD[ -]STATE[^\]]*|RECENT TOOL FAILURES|STOP\s*[—-]\s*RETRY LOOP|STAGNATION REPLAN[^\]]*|FIRST-EDIT NUDGE[^\]]*|INTRA-RUN LESSON[^\]]*|LOCAL ERROR-INFORMED NUDGE[^\]]*|FORECAST[^\]]*|PROGRESS GATE[^\]]*|FAIL(?:URE|ING)[^\]]*(?:RECOVERY|REPLAN|LOOP)[^\]]*|DOOM-LOOP[^\]]*)\]|<(?:world-state|focus-supervisor|failure-recovery|reflection|lessons?)[^>]*>)/i;
     ASSISTANT_READ_INTENT_RETIRED_MARKER = "[assistant read intent retired: the linked tool result is already available; decide from that evidence instead of restating a read plan]";
     RESTORE_NOISE_LINE_RE = /^\s*(?:🔊|E Task timeout reached|E Incomplete:|⚠ Task incomplete|Tokens:\s*[\d,]+|▹\s*continue\b|·\s*(?:Starting fresh|Context (?:auto-)?restored|Nexus P2P network connected|REST API:|Voice feedback enabled|Memory maintenance:)|.*\bSHELL TRANSCRIPT\b.*|.*speaker emoji.*).*$/i;
@@ -579459,6 +579550,7 @@ function recordContextWindowDump(input) {
     ...input.note ? { note: input.note } : {},
     ...input.focusSupervisor ? { focusSupervisor: compactFocusSupervisor(input.focusSupervisor) } : {},
     metrics: metrics2,
+    contextAccounting: buildContextAccounting(input.request, metrics2),
     apiView: summarizeApiView(input.request, metrics2),
     request: input.request
   };
@@ -579634,6 +579726,57 @@ function analyzeContextWindowDumpRequest(request) {
     }
   };
 }
+function contextSourceForMessage(role, text2) {
+  if (/\[ACTIVE USER INTENT\]|\[CURRENT USER GOAL\]/.test(text2)) {
+    return "current_user_intent";
+  }
+  if (/\[CONTROLLER STATE v1\]|\[RECENT ACTION GROUND TRUTH\]/.test(text2)) {
+    return "current_controller_state";
+  }
+  if (/\[ACTIVE CONTEXT FRAME\]|Evidence already gathered this run/.test(text2)) {
+    return "active_evidence";
+  }
+  if (role === "tool")
+    return "tool_result";
+  if (role === "system")
+    return "system_instruction";
+  if (role === "user")
+    return "user_history";
+  if (role === "assistant")
+    return "assistant_history";
+  return `role:${role}`;
+}
+function buildContextAccounting(request, metrics2) {
+  const buckets = /* @__PURE__ */ new Map();
+  const add3 = (source, chars) => {
+    const bucket = buckets.get(source) ?? { messageCount: 0, chars: 0 };
+    bucket.messageCount++;
+    bucket.chars += chars;
+    buckets.set(source, bucket);
+  };
+  const messages2 = Array.isArray(request["messages"]) ? request["messages"] : [];
+  for (const message2 of messages2) {
+    const record = message2 && typeof message2 === "object" ? message2 : {};
+    const role = typeof record["role"] === "string" ? record["role"] : "unknown";
+    const extracted = textAndImagesFromContent(record["content"]);
+    const toolCallChars = Array.isArray(record["tool_calls"]) ? JSON.stringify(record["tool_calls"]).length : 0;
+    add3(contextSourceForMessage(role, extracted.textWithoutImages), extracted.textWithoutImages.length + toolCallChars);
+  }
+  if (metrics2.toolSchemaChars > 0)
+    add3("tool_schema", metrics2.toolSchemaChars);
+  const sources = [...buckets.entries()].map(([source, bucket]) => ({
+    source,
+    ...bucket,
+    estimatedTokens: Math.ceil(bucket.chars / 4)
+  })).sort((a2, b) => a2.source.localeCompare(b.source));
+  return {
+    schemaVersion: 1,
+    totalMessageChars: metrics2.totalChars,
+    toolSchemaChars: metrics2.toolSchemaChars,
+    estimatedTokens: metrics2.estimatedTokens,
+    sources
+  };
+}
 function summarizeApiView(request, metrics2) {
   const messages2 = Array.isArray(request["messages"]) ? request["messages"] : [];
   const previews = [];
@@ -581453,6 +581596,9 @@ var init_focusSupervisor = __esm({
         }
         this.taskEpoch = next;
         this.state = "observe";
+        this.failureFamilies.clear();
+        this.convergenceFamilyCounts.clear();
+        this.sawMutationSinceFailure = false;
         this.ignoredDirectiveStreak = 0;
         this.lastIgnoredDirectiveTurn = null;
         this.repeatedViolationCounts.clear();
@@ -581746,6 +581892,8 @@ var init_focusSupervisor = __esm({
       }
       observeToolResult(input) {
         this.lastObservedTurn = Math.max(this.lastObservedTurn, input.turn);
+        if (input.taskEpoch !== void 0)
+          this.setTaskEpoch(input.taskEpoch, input.turn);
         this.expireDirectiveIfNeeded(input.turn);
         if (!this.enabled)
           return;
@@ -581767,7 +581915,7 @@ var init_focusSupervisor = __esm({
         if (input.toolName === "shell" && input.success) {
           if (this.convergenceBreaker) {
             const fam = actionFamily(input.toolName, input.args, this.familyCwd);
-            this.convergenceBreaker.resolve(fam);
+            this.convergenceBreaker.resolve(`${this.taskEpoch}:${fam}`);
             this.convergenceFamilyCounts.delete(fam);
           }
           if (this.directive?.requiredNextAction === "run_verification") {
@@ -581855,7 +582003,7 @@ var init_focusSupervisor = __esm({
           const convCount = (this.convergenceFamilyCounts.get(convergenceFamily) ?? 0) + 1;
           this.convergenceFamilyCounts.set(convergenceFamily, convCount);
           const verdict = this.convergenceBreaker.observe({
-            family: convergenceFamily,
+            family: `${this.taskEpoch}:${convergenceFamily}`,
             sessionCount: convCount,
             turn: input.turn,
             sample: next.sample,
@@ -581882,7 +582030,15 @@ var init_focusSupervisor = __esm({
               ]
             });
           } else if (verdict.tier === "abandon") {
-            this.markTerminalIncomplete(verdict.reason, input.turn);
+            this.setDirective({
+              turn: input.turn,
+              state: "forced_replan",
+              reason: verdict.reason,
+              requiredNextAction: this.resolveRequiredNextAction("creative_pivot_or_research"),
+              forbiddenActionFamilies: [
+                actionFamily(input.toolName, input.args, this.familyCwd)
+              ]
+            });
           } else if (verdict.tier === "stalled") {
             this.setDirective({
               turn: input.turn,
@@ -588446,6 +588602,8 @@ var init_agenticRunner = __esm({
       pendingSteeringInputs = [];
       _steeringSequence = 0;
       _taskEpoch = 0;
+      /** First tool-log turn belonging to the active task epoch. */
+      _taskEpochStartTurn = 0;
       _activeRunId = "";
       /** Session storage is retained for compatibility; superseded task leaves are hidden from active guards. */
       _supersededTodoIds = /* @__PURE__ */ new Set();
@@ -589044,6 +589202,10 @@ var init_agenticRunner = __esm({
       _workboardDir() {
         return this.options.workboardDir || this._workingDirectory || process.cwd();
       }
+      /** One immutable execution run owns every workboard read and mutation. */
+      _workboardRunId() {
+        return this.currentArtifactRunId();
+      }
       _todoWriteAvailable() {
         return this.tools.has("todo_write");
       }
@@ -589065,7 +589227,7 @@ var init_agenticRunner = __esm({
           return this._workboard;
         }
         const dir = this._workboardDir();
-        const runId = this.currentArtifactRunId();
+        const runId = this._workboardRunId();
         const existing = loadWorkboardSnapshot(dir, runId);
         if (existing) {
           this._workboard = this._seedWorkboardCardsIfNeeded(existing, goal);
@@ -589082,6 +589244,8 @@ var init_agenticRunner = __esm({
             runId,
             owner: this.options.subAgent ? "sub-agent" : "agent",
             goal: goal || void 0,
+            rawUserIntent: goal || void 0,
+            taskEpoch: this._taskEpoch,
             title: (this._taskState.goal || "").slice(0, 120) || void 0,
             cards: initialCards
           });
@@ -589186,6 +589350,8 @@ var init_agenticRunner = __esm({
               runId,
               owner: actor,
               goal: this._taskState.originalGoal || this._taskState.goal || void 0,
+              rawUserIntent: this._taskState.originalGoal || this._taskState.goal || void 0,
+              taskEpoch: this._taskEpoch,
               title: (this._taskState.goal || diagnosis.workboardTitle).slice(0, 120) || void 0,
               actor,
               cards: [cardInput]
@@ -589244,6 +589410,52 @@ var init_agenticRunner = __esm({
         const safe = todoId.replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
         return `todo-${safe || "item"}`;
       }
+      /**
+       * Todo ids are transport identifiers, not task identity.  Prefer declared
+       * artifacts, then an explicit verifier, and only then a normalized title so
+       * repeated todo_write calls cannot fork semantic workboard cards.
+       */
+      _todoWorkboardCanonicalKey(todo) {
+        const artifacts = (todo.declaredArtifacts ?? []).filter((path16) => typeof path16 === "string").map((path16) => this._normalizeEvidencePath(path16)).filter(Boolean).sort();
+        if (artifacts.length > 0)
+          return `artifacts:${[...new Set(artifacts)].join("|")}`;
+        const verifier = normalizeShellCommand(String(todo.verifyCommand ?? ""));
+        if (verifier)
+          return `verifier:${verifier}`;
+        const words = todo.content.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((word2) => word2.length > 2).filter((word2) => !(/* @__PURE__ */ new Set(["the", "and", "for", "with", "from", "that", "this", "then", "into", "todo"])).has(word2));
+        return `text:${[...new Set(words)].sort().join("|")}`;
+      }
+      _todoCardsSemanticallyMatch(existing, input) {
+        if (existing.canonicalKey && input.canonicalKey) {
+          return existing.canonicalKey === input.canonicalKey;
+        }
+        const existingVerifier = normalizeShellCommand(existing.verifierCommand ?? "");
+        const inputVerifier = normalizeShellCommand(input.verifierCommand ?? "");
+        if (existingVerifier && inputVerifier)
+          return existingVerifier === inputVerifier;
+        const existingFiles = new Set((existing.ownedFiles ?? []).map((path16) => this._normalizeEvidencePath(path16)));
+        const inputFiles = (input.ownedFiles ?? []).map((path16) => this._normalizeEvidencePath(path16));
+        if (existingFiles.size > 0 && inputFiles.length > 0) {
+          return inputFiles.some((path16) => existingFiles.has(path16));
+        }
+        const words = (value2) => new Set(value2.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((word2) => word2.length > 3));
+        const left = words(`${existing.title} ${existing.description}`);
+        const right = words(`${input.title} ${input.description ?? ""}`);
+        let shared = 0;
+        for (const word2 of left)
+          if (right.has(word2))
+            shared++;
+        return shared >= 5 && shared / Math.max(left.size, right.size, 1) >= 0.62;
+      }
+      _mergeTodoCardInputs(target, incoming) {
+        target.sourceTodoIds = [.../* @__PURE__ */ new Set([...target.sourceTodoIds ?? [], ...incoming.sourceTodoIds ?? []])];
+        target.ownedFiles = [.../* @__PURE__ */ new Set([...target.ownedFiles ?? [], ...incoming.ownedFiles ?? []])];
+        target.evidenceRequirements = [.../* @__PURE__ */ new Set([...target.evidenceRequirements ?? [], ...incoming.evidenceRequirements ?? []])];
+        if (incoming.status === "in_progress") {
+          target.status = "in_progress";
+          target.lane = "worker";
+        }
+      }
       _todoWorkboardCardInput(todo, path16) {
         const requirements = [];
         if (todo.verifyCommand) {
@@ -589268,6 +589480,8 @@ var init_agenticRunner = __esm({
         const status = todo.status === "blocked" ? "blocked" : todo.status === "pending" ? "open" : "in_progress";
         return {
           id: this._todoWorkboardCardId(todo.id),
+          canonicalKey: this._todoWorkboardCanonicalKey(todo),
+          sourceTodoIds: [todo.id],
           title: todo.content.slice(0, 120),
           description: path16.map((item) => item.content).join(" > ").slice(0, 800),
           lane,
@@ -589275,7 +589489,9 @@ var init_agenticRunner = __esm({
           assignee: todo.owner || "any",
           role: "worker",
           evidenceRequired: true,
-          evidenceRequirements: requirements
+          evidenceRequirements: requirements,
+          ownedFiles: (todo.declaredArtifacts ?? []).filter((path17) => typeof path17 === "string").map((path17) => this._normalizeEvidencePath(path17)).filter(Boolean),
+          verifierCommand: todo.verifyCommand
         };
       }
       _mirrorTodosToWorkboard(todos) {
@@ -589286,7 +589502,15 @@ var init_agenticRunner = __esm({
         const activeLeaves = this._todoLeaves(normalized, index).filter((todo) => todo.status !== "completed").slice(0, 20);
         if (activeLeaves.length === 0)
           return;
-        const cards = activeLeaves.map((todo) => this._todoWorkboardCardInput(todo, this._todoPath(todo, index)));
+        const cards = [];
+        for (const todo of activeLeaves) {
+          const incoming = this._todoWorkboardCardInput(todo, this._todoPath(todo, index));
+          const equivalent = cards.find((card) => this._todoCardsSemanticallyMatch(card, incoming));
+          if (equivalent)
+            this._mergeTodoCardInputs(equivalent, incoming);
+          else
+            cards.push(incoming);
+        }
         const dir = this._workboardDir();
         const runId = this.currentArtifactRunId();
         const actor = this.options.subAgent ? "sub-agent" : "agent";
@@ -589297,6 +589521,8 @@ var init_agenticRunner = __esm({
               runId,
               owner: actor,
               goal: this._taskState.originalGoal || this._taskState.goal || void 0,
+              rawUserIntent: this._taskState.originalGoal || this._taskState.goal || void 0,
+              taskEpoch: this._taskEpoch,
               title: (this._taskState.goal || "Active todo work").slice(0, 120),
               actor,
               cards
@@ -589305,7 +589531,7 @@ var init_agenticRunner = __esm({
             return;
           }
           for (const cardInput of cards) {
-            const existing = board.cards.find((card) => card.id === cardInput.id);
+            let existing = board.cards.find((card) => card.id === cardInput.id) ?? board.cards.find((card) => !card.supersededBy && this._todoCardsSemanticallyMatch(card, cardInput));
             if (!existing) {
               board = addWorkboardCard(dir, {
                 ...cardInput,
@@ -589315,6 +589541,28 @@ var init_agenticRunner = __esm({
               });
               continue;
             }
+            const duplicates = board.cards.filter((card) => card.id !== existing.id && !card.supersededBy && this._todoCardsSemanticallyMatch(card, cardInput));
+            for (const duplicate of duplicates) {
+              if (duplicate.evidence.length > 0) {
+                attachWorkboardEvidence(dir, {
+                  runId,
+                  cardId: existing.id,
+                  actor,
+                  evidence: duplicate.evidence
+                });
+              }
+              board = updateWorkboardCard(dir, {
+                runId,
+                cardId: duplicate.id,
+                actor,
+                updates: {
+                  supersededBy: existing.id,
+                  blocker: `Superseded by canonical card '${existing.id}'.`
+                },
+                decisionReason: `Merged duplicate todo card into canonical '${existing.id}'.`
+              });
+              existing = board.cards.find((card) => card.id === existing.id) ?? existing;
+            }
             if (existing.status === "verified")
               continue;
             board = updateWorkboardCard(dir, {
@@ -589326,7 +589574,11 @@ var init_agenticRunner = __esm({
                 description: cardInput.description,
                 lane: cardInput.lane,
                 status: existing.status === "completed" ? "needs_changes" : cardInput.status,
-                evidenceRequirements: cardInput.evidenceRequirements
+                evidenceRequirements: cardInput.evidenceRequirements,
+                canonicalKey: cardInput.canonicalKey,
+                sourceTodoIds: [.../* @__PURE__ */ new Set([...existing.sourceTodoIds ?? [], ...cardInput.sourceTodoIds ?? []])],
+                ownedFiles: cardInput.ownedFiles,
+                verifierCommand: cardInput.verifierCommand
               },
               decisionReason: "Synchronized workboard card from current todo state."
             });
@@ -589452,12 +589704,12 @@ var init_agenticRunner = __esm({
       injectWorkboardContext() {
         if (this._workboard || this.options.subAgent) {
           const dir = this._workboardDir();
-          let snapshot = readActiveWorkboardSnapshot(dir, this._sessionId);
+          let snapshot = readActiveWorkboardSnapshot(dir, this._workboardRunId());
           if (!snapshot)
             return null;
           snapshot = this._seedWorkboardCardsIfNeeded(snapshot, this._taskState.originalGoal || this._taskState.goal || "");
           this._workboard = snapshot;
-          const activeCards = snapshot.cards.filter((c9) => c9.status === "in_progress" || c9.status === "open" || c9.status === "needs_changes");
+          const activeCards = snapshot.cards.filter((c9) => !c9.supersededBy && (c9.status === "in_progress" || c9.status === "open" || c9.status === "needs_changes"));
           if (activeCards.length === 0 && snapshot.cards.every((c9) => c9.status === "verified" || c9.status === "completed"))
             return null;
           const synthesis = buildWorkboardSynthesisContext(snapshot);
@@ -589558,7 +589810,7 @@ ${parts.join("\n")}
       _deriveWorkboardActionContract(snapshot) {
         if (snapshot.cards.length === 0)
           return null;
-        const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
+        const byId = new Map(snapshot.cards.filter((card) => !card.supersededBy).map((card) => [card.id, card]));
         const discovery = byId.get("discover-current-state");
         const implementation2 = byId.get("implement-repair");
         const integration = byId.get("integrate-and-run");
@@ -589598,7 +589850,7 @@ ${parts.join("\n")}
             ])
           };
         }
-        const active = snapshot.cards.find((card) => card.status === "in_progress") ?? snapshot.cards.find((card) => card.status === "needs_changes") ?? snapshot.cards.find((card) => card.status === "open") ?? discovery;
+        const active = snapshot.cards.find((card) => !card.supersededBy && card.status === "in_progress") ?? snapshot.cards.find((card) => !card.supersededBy && card.status === "needs_changes") ?? snapshot.cards.find((card) => !card.supersededBy && card.status === "open") ?? discovery;
         if (!active)
           return null;
         return {
@@ -589738,6 +589990,8 @@ ${parts.join("\n")}
         for (const card of snapshot.cards) {
           if (!card.id.startsWith("todo-"))
             continue;
+          if (card.supersededBy)
+            continue;
           if (card.status === "completed" || card.status === "verified")
             continue;
           const text2 = [
@@ -589760,6 +590014,19 @@ ${parts.join("\n")}
         }
         return best?.card ?? null;
       }
+      _workboardTodoCardForVerifier(snapshot, args) {
+        const command = String(args["command"] ?? args["cmd"] ?? "").trim();
+        if (!command)
+          return null;
+        return snapshot.cards.find((card) => {
+          if (!card.id.startsWith("todo-") || card.supersededBy)
+            return false;
+          if (card.status === "completed" || card.status === "verified")
+            return false;
+          const verifier = card.verifierCommand || card.evidenceRequirements.find((item) => item.startsWith("verifyCommand:"))?.replace(/^verifyCommand:\s*/, "") || "";
+          return verifier.length > 0 && commandReliablySatisfiesVerifyCommand(command, verifier);
+        }) ?? null;
+      }
       _workboardTargetCardId(snapshot, toolName, args, result, meta = {}) {
         const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
         const targetPaths = this._extractToolTargetPaths(toolName, args, result);
@@ -589771,6 +590038,9 @@ ${parts.join("\n")}
           return matchingTodo?.id ?? (byId.has("implement-repair") ? "implement-repair" : null);
         }
         if (toolName === "shell" || toolName === "background_run") {
+          const verifierTodo = this._workboardTodoCardForVerifier(snapshot, args);
+          if (verifierTodo)
+            return verifierTodo.id;
           const implementation2 = byId.get("implement-repair");
           const target = this._workboardHasEditEvidence(implementation2) ? "integrate-and-run" : "discover-current-state";
           return byId.has(target) ? target : null;
@@ -589784,7 +590054,7 @@ ${parts.join("\n")}
         return active?.id ?? null;
       }
       _refreshWorkboardSnapshot(snapshot) {
-        const refreshed = readActiveWorkboardSnapshot(this._workboardDir(), this._sessionId) ?? snapshot;
+        const refreshed = readActiveWorkboardSnapshot(this._workboardDir(), this._workboardRunId()) ?? snapshot;
         this._workboard = refreshed;
         return refreshed;
       }
@@ -589855,7 +590125,7 @@ ${parts.join("\n")}
        * Non-fatal: failures to attach evidence are silently caught.
        */
       recordWorkboardToolCall(toolName, args, success, output, result, meta = {}) {
-        const board = this._workboard ?? this.getOrCreateWorkboard();
+        const board = this._currentWorkboardSnapshotForFrame() ?? this.getOrCreateWorkboard();
         if (!board)
           return;
         if (toolName === "task_complete" || toolName === "workboard_create")
@@ -589891,13 +590161,26 @@ ${parts.join("\n")}
           if (targetCard.assignee && targetCard.assignee !== actor && targetCard.assignee !== "any") {
             return;
           }
-          attachWorkboardEvidence(dir, {
+          const evidenced = attachWorkboardEvidence(dir, {
             runId: this.currentArtifactRunId(),
             cardId: targetCard.id,
             actor,
             evidence
           });
-          this._refreshWorkboardSnapshot(advanced);
+          const persistedEvidence = evidenced.cards.find((card) => card.id === targetCard.id)?.evidence.find((item) => item.summary === evidence.summary && item.content === evidence.content);
+          const substantive = success === true && result?.runtimeAuthored !== true;
+          this._workboard = updateWorkboardMetadata(dir, {
+            runId: this.currentArtifactRunId(),
+            actor,
+            taskEpoch: this._taskEpoch,
+            artifactEvidence: persistedEvidence ? [persistedEvidence] : [evidence],
+            lastSubstantiveProgress: substantive ? {
+              turn: this._taskState.toolCallCount,
+              signature: this._buildToolFingerprint(toolName, args),
+              evidenceIds: persistedEvidence ? [persistedEvidence.id] : [],
+              occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+            } : void 0
+          });
         } catch {
         }
       }
@@ -590362,7 +590645,12 @@ ${parts.join("\n")}
         try {
           const dir = _pathJoin(this.omniusStateDir(), "completion-ledgers");
           _fsMkdirSync(dir, { recursive: true });
-          saveCompletionLedger(_pathJoin(dir, `${this._sessionId}.json`), this._completionLedger);
+          saveCompletionLedger(
+            // A session can contain several steering epochs. Persist by immutable
+            // artifact run so recovery never hydrates evidence from a retired goal.
+            _pathJoin(dir, `${this.currentArtifactRunId()}.json`),
+            this._completionLedger
+          );
         } catch {
         }
       }
@@ -590807,7 +591095,20 @@ Your hypotheses MUST address this specific error, not generic causes.
           messages: messages2,
           currentGoal: this._taskState.originalGoal || this._taskState.goal || this._taskState.currentStep || this._taskState.nextAction || ""
         });
-        return sanitizeHistoryThink(prepared);
+        const withCurrentUserIntent = sanitizeHistoryThink(prepared);
+        if (!withCurrentUserIntent.some((message2) => message2.role === "user")) {
+          const currentIntent = this._taskState.originalGoal || this._taskState.goal || this._taskState.currentStep || this._taskState.nextAction || "";
+          if (currentIntent.trim()) {
+            const insertAt = withCurrentUserIntent[0]?.role === "system" ? 1 : 0;
+            withCurrentUserIntent.splice(insertAt, 0, {
+              role: "user",
+              content: `[ACTIVE USER INTENT]
+${currentIntent.trim().slice(0, 6e3)}`,
+              taskEpoch: this._taskEpoch
+            });
+          }
+        }
+        return withCurrentUserIntent;
       }
       // ── Failing-approach detector (the "stop retrying variants" reflex) ───────
       // Encodes the behavior an effective agent uses and the dropbear 27× loop
@@ -590875,7 +591176,7 @@ Your hypotheses MUST address this specific error, not generic causes.
                 stage: opts?.dumpStage ?? "aux_inference",
                 agentType: "internal",
                 sessionId: this._sessionId,
-                runId: this.currentArtifactRunId(),
+                runId: this._workboardRunId(),
                 model: this._backendModelLabel(this.backend),
                 cwd: this._workingDirectory || process.cwd(),
                 request: r2
@@ -591769,6 +592070,13 @@ ${extras.join("\n")}`;
           existingCards
         }) : existingCards;
         const delta = diffDiagnosticSets(previousDiagnostics, diagnostics);
+        const verifierActionSignature = normalizeShellCommand(verifierCommand);
+        const verifierResultSignature = [
+          input.success ? "success" : "failure",
+          ...diagnostics.map((diagnostic) => diagnostic.fingerprint).sort()
+        ].join("|");
+        const unchangedVerifierRound = this._compileFixLoop?.verifierActionSignature === verifierActionSignature && this._compileFixLoop?.verifierResultSignature === verifierResultSignature;
+        const verifierStasisCount = unchangedVerifierRound ? (this._compileFixLoop?.verifierStasisCount ?? 0) + 1 : 0;
         const nextCards = this._mergeCompileFixCardsAfterVerifier({
           existingCards,
           observedCards: cards,
@@ -591788,8 +592096,21 @@ ${extras.join("\n")}`;
           cards: nextCards,
           // A live verifier run resolves the gate's demand — the block streak
           // is over regardless of pass/fail.
-          preflightBlockStreak: 0
-        };
+          preflightBlockStreak: 0,
+          verifierActionSignature,
+          verifierResultSignature,
+          verifierStasisCount,
+          verifierStasisBlocked: verifierStasisCount >= 3 && !(input.success && diagnostics.length === 0),
+          prerequisiteRecoverySignature: void 0
+        };
+        if (this._compileFixLoop.verifierStasisBlocked) {
+          this.emit({
+            type: "status",
+            content: `compile_error_verifier_stasis: action/result unchanged for ${verifierStasisCount} rounds; block unchanged verifier/read retries until a scoped fix or fresh prerequisite evidence changes state`,
+            turn: input.turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
         this._mirrorCompileFixCardsToWorkboard(nextCards, {
           command: verifierCommand,
           success: input.success && diagnostics.length === 0,
@@ -591918,7 +592239,7 @@ ${extras.join("\n")}`;
           const dir = this._workboardDir();
           const actor = this.options.subAgent ? "sub-agent" : "agent";
           for (const card of cards) {
-            const existing = (readActiveWorkboardSnapshot(dir, this._sessionId) ?? this._workboard)?.cards.find((item) => item.id === card.id);
+            const existing = (readActiveWorkboardSnapshot(dir, this._workboardRunId()) ?? this._workboard)?.cards.find((item) => item.id === card.id);
             if (!existing) {
               this._workboard = addWorkboardCard(dir, {
                 ...compileFixCardToWorkboardInput(card),
@@ -591967,7 +592288,7 @@ ${extras.join("\n")}`;
               }
             });
             if (card.status === "dismissed" || card.status === "verified") {
-              const active = readActiveWorkboardSnapshot(dir, this._sessionId);
+              const active = readActiveWorkboardSnapshot(dir, this._workboardRunId());
               const wbCard = active?.cards.find((item) => item.id === card.id);
               if (wbCard && wbCard.status !== "completed" && wbCard.status !== "verified") {
                 this._workboard = completeWorkboardCard(dir, {
@@ -591979,7 +592300,7 @@ ${extras.join("\n")}`;
                 }).snapshot;
               }
               if (card.status === "verified") {
-                const latest = readActiveWorkboardSnapshot(dir, this._sessionId);
+                const latest = readActiveWorkboardSnapshot(dir, this._workboardRunId());
                 const latestCard = latest?.cards.find((item) => item.id === card.id);
                 if (latestCard?.status === "completed") {
                   this._workboard = completeWorkboardCard(dir, {
@@ -591999,7 +592320,7 @@ ${extras.join("\n")}`;
       _mirrorCompileFixCardAssigned(card, turn) {
         try {
           const dir = this._workboardDir();
-          const active = readActiveWorkboardSnapshot(dir, this._sessionId);
+          const active = readActiveWorkboardSnapshot(dir, this._workboardRunId());
           const existing = active?.cards.find((item) => item.id === card.id);
           if (!existing || existing.status !== "open")
             return;
@@ -592028,6 +592349,9 @@ ${extras.join("\n")}`;
         state.verifierDirtySinceTurn = turn;
         state.lastVerifierPassedTurn = null;
         state.lastMutationTurn = turn;
+        state.verifierStasisCount = 0;
+        state.verifierStasisBlocked = false;
+        state.prerequisiteRecoverySignature = void 0;
         this._focusSupervisor?.markCompletionBlocked({
           turn,
           reason: "A source mutation invalidated the declared verifier; verifier evidence now owns the active focus.",
@@ -592077,68 +592401,67 @@ ${extras.join("\n")}`;
         if (!state?.active)
           return null;
         const action = compileFixLoopNextRequiredAction(state);
-        if (action !== "run_declared_verifier")
+        const verifierLocked = action === "run_declared_verifier" || state.verifierStasisBlocked === true;
+        if (!verifierLocked)
           return null;
+        const blocked = (reason) => {
+          const streak = (state.preflightBlockStreak ?? 0) + 1;
+          state.preflightBlockStreak = streak;
+          return {
+            kind: "block",
+            message: [
+              `[COMPILE ERROR FIX LOOP BLOCKED — verifier action locked]`,
+              reason,
+              `declared_verifier=${state.verifierCommand}`,
+              `dirtySinceTurn=${state.verifierDirtySinceTurn}`,
+              `lastVerifierRunTurn=${state.lastVerifierRunTurn}`,
+              `stasisRounds=${state.verifierStasisCount ?? 0}`,
+              `blockedTool=${toolName} consecutiveBlocks=${streak}`,
+              `Allowed next actions: the declared verifier; one narrow prerequisite read of an owned file; or a scoped source fix that changes verifier inputs.`
+            ].join("\n")
+          };
+        };
         if (toolName === "shell") {
           const command = String(args["command"] ?? args["cmd"] ?? "").trim();
           if (commandReliablySatisfiesVerifyCommand(command, state.verifierCommand)) {
+            if (state.verifierStasisBlocked) {
+              return blocked("The same verifier action/result is in stasis. Change the owned source or obtain fresh prerequisite evidence before rerunning this unchanged verifier.");
+            }
             state.preflightBlockStreak = 0;
             return null;
           }
-          if (!shellLikelyMutatesFilesystem) {
+          void shellLikelyMutatesFilesystem;
+          return blocked("Only the declared verifier shell command is admitted while verifier evidence is locked.");
+        }
+        const readLike = /* @__PURE__ */ new Set([
+          "file_read",
+          "grep_search",
+          "find_files",
+          "list_directory",
+          "file_explore"
+        ]);
+        if (readLike.has(toolName)) {
+          const target = String(args["path"] ?? args["file"] ?? args["file_path"] ?? "");
+          const owned = state.cards.flatMap((card) => card.ownedFiles);
+          const scoped = target.length > 0 && owned.some((path16) => this._pathsOverlapForVerifier(target, path16));
+          const signature = `${toolName}:${this._buildExactArgsKey(args)}`;
+          if (scoped && state.prerequisiteRecoverySignature !== signature) {
+            state.prerequisiteRecoverySignature = signature;
+            state.preflightBlockStreak = 0;
             return null;
           }
-          const extraction = extractShellMutationPaths(command, {
-            workingDir: this.authoritativeWorkingDirectory()
-          });
-          const mutationPaths = extraction.paths.map((p2) => this._normalizeEvidencePath(p2)).filter(Boolean);
-          if (mutationPaths.length === 0 || !this._compileFixPathsTouchProjectSources(mutationPaths, state)) {
+          return blocked(scoped ? "The one prerequisite-recovery read has already been used; act on its evidence instead of reading again." : "Prerequisite recovery must be a narrow read of a compile-card owned file.");
+        }
+        if (this._isProjectEditTool(toolName)) {
+          const targetPaths = this._extractToolTargetPaths(toolName, args);
+          const scoped = targetPaths.some((path16) => this._compileFixPathsTouchProjectSources([this._normalizeEvidencePath(path16)], state));
+          if (scoped) {
+            state.preflightBlockStreak = 0;
             return null;
           }
-        } else if (!this._isProjectEditTool(toolName)) {
-          return null;
-        }
-        const yieldAfter = Number.MAX_SAFE_INTEGER;
-        const streak = (state.preflightBlockStreak ?? 0) + 1;
-        if (streak > yieldAfter) {
-          state.preflightBlockStreak = 0;
-          this.emit({
-            type: "status",
-            content: `compile_error_verifier_dirty: gate yielded to ${toolName} after ${yieldAfter} consecutive blocks at turn ${turn}`,
-            turn,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          return {
-            kind: "yield",
-            notice: [
-              `[COMPILE FIX GATE YIELDED — verifier still required]`,
-              `The verifier-required gate blocked ${yieldAfter} consecutive tool calls and is yielding so work can continue.`,
-              `Verifier evidence is still stale. Run the verifier as your next evidence step:`,
-              `  ${state.verifierCommand}`,
-              `Any real build/test command whose output shows current compiler diagnostics is also accepted as the live verifier.`,
-              `task_complete remains blocked until a verifier run passes after the last mutation.`
-            ].join("\n")
-          };
+          return blocked("A repair mutation must target a file owned by the active compile-fix card.");
         }
-        state.preflightBlockStreak = streak;
-        const message2 = [
-          `[COMPILE ERROR FIX LOOP BLOCKED — declared verifier required]`,
-          `A compile-fix card was patched, so the next mutation/evidence step must be the live verifier.`,
-          `Run this now: ${state.verifierCommand}`,
-          `Any real build/test command whose output shows current compiler diagnostics is also accepted.`,
-          `dirtySinceTurn: ${state.verifierDirtySinceTurn}`,
-          `lastMutationTurn: ${state.lastMutationTurn}`,
-          `lastVerifierRunTurn: ${state.lastVerifierRunTurn}`,
-          `blockedTool: ${toolName}`,
-          `consecutiveBlocks: ${streak} (verifier focus is retained until a live verifier settles)`
-        ].join("\n");
-        this.emit({
-          type: "status",
-          content: `compile_error_verifier_dirty: blocked ${toolName} at turn ${turn} (${streak}/${yieldAfter})`,
-          turn,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        return { kind: "block", message: message2 };
+        return blocked("This tool is unrelated to the locked verifier action.");
       }
       _compileFixLoopCompletionBlocker(turn) {
         const state = this._compileFixLoop;
@@ -593350,8 +593673,8 @@ ${_checks}`
           return { proceed: true };
         const maxCycles = parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_CYCLES"] || "2", 10) || 2;
         if (this._backwardPassCyclesUsed >= maxCycles) {
-          const lastCritique2 = this._lastBackwardPassCritique;
-          const evidenceAfterCritique = lastCritique2 ? toolCallLog.slice(lastCritique2.toolLogLength) : [];
+          const lastCritique = this._lastBackwardPassCritique;
+          const evidenceAfterCritique = lastCritique ? toolCallLog.slice(lastCritique.toolLogLength) : [];
           const freshVerification = evidenceAfterCritique.filter((entry) => {
             if (entry.success !== true)
               return false;
@@ -593361,7 +593684,7 @@ ${_checks}`
           const concern = freshVerification.length > 0 ? [
             "Prior reviewer concern may be stale; fresh verification evidence was recorded after that critique.",
             ...freshVerification.map((entry) => `${entry.name}: ${(entry.outputPreview ?? entry.argsKey).slice(0, 220)}`)
-          ].join(" ") : lastCritique2?.rationale?.trim() || this._lastBackwardPassVerdict || "unspecified";
+          ].join(" ") : lastCritique?.rationale?.trim() || this._lastBackwardPassVerdict || "unspecified";
           this._completionCaveat = [
             `[COMPLETION CAVEAT] Backward-pass review did not fully approve after ${this._backwardPassCyclesUsed}/${maxCycles} cycle(s).`,
             `${freshVerification.length > 0 ? "Reviewer reconciliation note" : "Unresolved reviewer concern"}: ${concern.slice(0, 600)}`,
@@ -593413,7 +593736,7 @@ ${_checks}`
             });
           }
         };
-        const todos = (() => {
+        const allTodos = (() => {
           try {
             const _t = this.readSessionTodos();
             return Array.isArray(_t) ? _t : [];
@@ -593421,17 +593744,15 @@ ${_checks}`
             return [];
           }
         })();
+        const todos = allTodos.filter((todo) => !this._supersededTodoIds.has(todo.id));
         const wd = this._workingDirectory || process.cwd();
         let reconciled = [];
         try {
           reconciled = reconcilePlan(todos, [], { workingDir: wd });
         } catch {
         }
-        const recentFailures = Array.from(this._failureReflections.entries()).map(([stem, entry]) => ({
-          stem,
-          attempts: entry.attempts,
-          preview: (entry.wentWrong || "").slice(0, 200)
-        })).sort((a2, b) => b.attempts - a2.attempts).slice(0, 5);
+        const recentFailures = [];
+        const activeEpochToolLog = toolCallLog.filter((entry) => typeof entry.turn === "number" && entry.turn >= this._taskEpochStartTurn);
         const toCriticEvidence = (entries, limit) => entries.filter((entry) => entry.name !== "task_complete").slice(-limit).map((entry) => ({
           name: entry.name,
           argsKey: entry.argsKey.slice(0, 300),
@@ -593440,9 +593761,7 @@ ${_checks}`
           turn: entry.turn,
           mutated: entry.mutated === true
         }));
-        const criticToolEvidence = toCriticEvidence(toolCallLog, 40);
-        const lastCritique = this._lastBackwardPassCritique;
-        const evidenceSincePriorCritique = lastCritique ? toCriticEvidence(toolCallLog.slice(lastCritique.toolLogLength), 20) : [];
+        const criticToolEvidence = toCriticEvidence(activeEpochToolLog, 40);
         const completionContract = this._completionContractForClaims(proposedSummary);
         const openLoops = [
           ...todos.filter((todo) => todo.status !== "completed" && todo.status !== "blocked").slice(0, 12).map((todo) => `todo still ${todo.status}: ${todo.content}`),
@@ -593451,7 +593770,7 @@ ${_checks}`
         const modifiedFileDigest = (() => {
           const seen = /* @__PURE__ */ new Set();
           const files = [];
-          for (const entry of toolCallLog) {
+          for (const entry of activeEpochToolLog) {
             if (!Array.isArray(entry.mutatedFiles))
               continue;
             for (const filePath of entry.mutatedFiles) {
@@ -593492,20 +593811,13 @@ ${_checks}`
             ].join("\n\n");
           }
         }
-        const reviewReconciliation = lastCritique ? {
-          previousVerdict: lastCritique.verdict,
-          previousRationale: lastCritique.rationale,
-          previousFeedback: lastCritique.feedback,
-          previousCompletionSummary: lastCritique.completionSummary,
-          previousCycle: lastCritique.cycle,
-          recordedAtIso: lastCritique.recordedAtIso,
-          evidenceSincePreviousReview: evidenceSincePriorCritique
-        } : void 0;
+        const reviewReconciliation = void 0;
+        const activeWorkboard = this._currentWorkboardSnapshotForFrame();
         let result;
         try {
           result = await runBackwardPass({
             workingDir: wd,
-            goal: this._taskState.originalGoal || this._taskState.goal || "",
+            goal: this._taskState.goal || this._taskState.originalGoal || "",
             planStatus: reconciled.map((t2) => ({
               id: t2.id,
               content: t2.content,
@@ -593518,9 +593830,9 @@ ${_checks}`
             completionScenarioDecomposition: _ledgerScenarioDecomposition,
             reviewReconciliation,
             openLoops,
-            workboardSynthesisContext: this._workboard ? (() => {
+            workboardSynthesisContext: activeWorkboard ? (() => {
               try {
-                return buildWorkboardSynthesisContext(this._workboard).excludedUnverifiedCardIds.length > 0 ? `Verified: ${this._workboard.cards.filter((c9) => c9.status === "verified").length}, Unverified remaining: ${this._workboard.cards.filter((c9) => c9.status !== "verified").length}, Blockers: ${this._workboard.cards.filter((c9) => c9.status === "blocked" || c9.status === "needs_changes").length}` : void 0;
+                return buildWorkboardSynthesisContext(activeWorkboard).excludedUnverifiedCardIds.length > 0 ? `Verified: ${activeWorkboard.cards.filter((c9) => c9.status === "verified").length}, Unverified remaining: ${activeWorkboard.cards.filter((c9) => c9.status !== "verified").length}, Blockers: ${activeWorkboard.cards.filter((c9) => c9.status === "blocked" || c9.status === "needs_changes").length}` : void 0;
               } catch {
                 return void 0;
               }
@@ -593529,35 +593841,23 @@ ${_checks}`
             maxFiles: parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_FILES"] || "60", 10) || 60,
             maxFilePreviewBytes: parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_FILE_PREVIEW"] || "8000", 10) || 8e3,
             explicitFiles: modifiedFileDigest.length > 0 ? modifiedFileDigest.map((file) => file.path) : void 0,
+            explicitFilesOnly: true,
             cycle: this._backwardPassCyclesUsed,
             maxCycles
           });
         } catch (e2) {
           const reason = `backward-pass runner failed: ${e2 instanceof Error ? e2.message : String(e2)}`;
-          this._completionIncompleteVerification = {
-            reason,
-            summary: [
-              "INCOMPLETE_VERIFICATION: backward-pass review could not verify completion.",
-              "",
-              `Attempted summary: ${proposedSummary || "(no summary)"}`,
-              "",
-              "Not verified / blocked:",
-              reason,
-              "",
-              "Evidence:",
-              completionScenarioDecomposition
-            ].join("\n")
-          };
-          this._focusSupervisor?.markTerminalIncomplete(reason, turn);
+          this._completionCaveat = [
+            this._completionCaveat || "",
+            `[BACKWARD-PASS ADVISORY] ${reason}`,
+            "Completion authority remains with deterministic verifier and current completion-ledger evidence."
+          ].filter(Boolean).join("\n");
           this.emit({
             type: "status",
-            content: `REG-47 backward-pass runner threw: ${e2 instanceof Error ? e2.message : String(e2)}. Ending as incomplete_verification instead of completing.`,
+            content: `Backward-pass review unavailable; preserved as advisory telemetry: ${reason}`,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
-          return {
-            proceed: false,
-            feedback: "Backward-pass review failed before completion could be verified. Report incomplete_verification rather than claiming success."
-          };
+          return { proceed: true, feedback: this._completionCaveat };
         }
         this._backwardPassCyclesUsed++;
         this._lastBackwardPassVerdict = result.verdict.verdict;
@@ -593579,7 +593879,15 @@ ${_checks}`
           return { proceed: true };
         }
         const feedback = result.feedbackMessage;
-        if (this._completionLedger) {
+        const currentArtifactPaths = modifiedFileDigest.map((file) => file.path.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase());
+        const criticReferencesCurrentArtifact = result.verdict.issues.some((issue) => {
+          const issueText = [issue.file, issue.problem, issue.suggested_fix].filter((value2) => typeof value2 === "string").join(" ").replace(/\\/g, "/").toLowerCase();
+          return currentArtifactPaths.some((path16) => {
+            const basename46 = path16.slice(path16.lastIndexOf("/") + 1);
+            return issueText.includes(path16) || basename46.length > 0 && issueText.includes(basename46);
+          });
+        });
+        if (this._completionLedger && criticReferencesCurrentArtifact) {
           this._completionLedger = recordCompletionCritique(this._completionLedger, {
             verdict: result.verdict.verdict === "blocked" ? "blocked" : "request_changes",
             rationale: result.verdict.rationale,
@@ -593587,16 +593895,18 @@ ${_checks}`
           });
           this._saveCompletionLedgerSafe();
         }
-        this._lastBackwardPassCritique = {
-          verdict: result.verdict.verdict,
-          rationale: result.verdict.rationale,
-          feedback,
-          completionSummary: proposedSummary,
-          cycle: this._backwardPassCyclesUsed,
-          toolLogLength: toolCallLog.length,
-          recordedAtIso: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        if (result.verdict.verdict === "blocked") {
+        if (criticReferencesCurrentArtifact) {
+          this._lastBackwardPassCritique = {
+            verdict: result.verdict.verdict,
+            rationale: result.verdict.rationale,
+            feedback,
+            completionSummary: proposedSummary,
+            cycle: this._backwardPassCyclesUsed,
+            toolLogLength: toolCallLog.length,
+            recordedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        if (result.verdict.verdict === "blocked" && criticReferencesCurrentArtifact) {
           const reason = `backward-pass critic blocked completion: ${result.verdict.rationale.slice(0, 240)}`;
           this._completionIncompleteVerification = {
             reason,
@@ -593619,6 +593929,19 @@ ${_checks}`
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
+        if (!criticReferencesCurrentArtifact) {
+          this._completionCaveat = [
+            this._completionCaveat || "",
+            `[BACKWARD-PASS ADVISORY] ${result.verdict.verdict}: ${result.verdict.rationale.slice(0, 600)}`,
+            "The critic named no current-epoch artifact; current verifier and completion-ledger evidence remain authoritative."
+          ].filter(Boolean).join("\n");
+          this.emit({
+            type: "status",
+            content: `Backward-pass ${result.verdict.verdict} retained as advisory: no current artifact was referenced.`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return { proceed: true, feedback: this._completionCaveat };
+        }
         return { proceed: false, feedback };
       }
       /**
@@ -596198,6 +596521,20 @@ ${blob}
           if (covered)
             return cov.fingerprint;
         }
+        if (!iv.whole && Number.isFinite(iv.end)) {
+          let best = null;
+          const requestedLength = Math.max(1, iv.end - iv.start + 1);
+          for (const cov of intervals) {
+            if (cov.whole || !Number.isFinite(cov.end))
+              continue;
+            const overlap = Math.max(0, Math.min(iv.end, cov.end) - Math.max(iv.start, cov.start) + 1);
+            if (overlap / requestedLength >= 0.8 && (!best || overlap > best.overlap)) {
+              best = { fingerprint: cov.fingerprint, overlap };
+            }
+          }
+          if (best)
+            return best.fingerprint;
+        }
         return exactFingerprint;
       }
       /** Register a read's region under the fingerprint that cached its result. */
@@ -596940,6 +597277,26 @@ ${notice}`;
         this._trajectoryDirtyCauses.add("user_steering");
         return this._steeringReceipt(record);
       }
+      /**
+       * Request safe-boundary preemption for an already accepted typed input.
+       * Frontends use this after delivery so cancellation reaches an in-flight
+       * request without fabricating a second, disconnected runner.
+       */
+      requestSteeringPreemption(inputId) {
+        const normalizedInputId = inputId.trim();
+        if (!normalizedInputId)
+          return null;
+        const record = this.pendingSteeringInputs.find((candidate) => candidate.inputId === normalizedInputId);
+        if (!record)
+          return null;
+        if (record.intent !== "redirect" && record.intent !== "replace" && record.intent !== "cancel") {
+          return null;
+        }
+        if (this._pendingSteeringPreemption?.inputId !== record.inputId) {
+          this._requestSteeringPreemption(record);
+        }
+        return this._steeringReceipt(record);
+      }
       /** Inject bounded runtime guidance without treating it as user steering. */
       injectRuntimeGuidance(content) {
         this.enqueueRuntimeGuidance(content);
@@ -597194,6 +597551,8 @@ ${notice}`;
         this._archiveSupersededTaskState(previousEpoch, record);
         this._allowImplicitContinuation = false;
         this._taskEpoch += 1;
+        this._taskEpochStartTurn = turn;
+        this._focusSupervisor?.setTaskEpoch(this._taskEpoch, turn);
         record.taskEpoch = this._taskEpoch;
         if (record.intent === "replace") {
           for (const candidate of this.pendingSteeringInputs) {
@@ -598373,8 +598732,10 @@ Respond with the assessment and take the selected evidence-backed action.`;
           convergenceBreaker: this._longHaul?.convergenceBreaker ?? null,
           // WO-9: run cwd so shell family keys canonicalize absolute↔relative
           // path form and command variants collapse into one family.
-          cwd: this.authoritativeWorkingDirectory()
+          cwd: this.authoritativeWorkingDirectory(),
+          taskEpoch: this._taskEpoch
         });
+        this._focusSupervisor?.setTaskEpoch(this._taskEpoch);
         if (!this._workingDirectory) {
           this._workingDirectory = _pathResolve(process.cwd());
         }
@@ -599044,6 +599405,7 @@ ${dynamicProjectContext}`
         let lastShellPivotTurn = -1;
         const recentToolResults = /* @__PURE__ */ new Map();
         const exactFileReadObservations = /* @__PURE__ */ new Map();
+        const exactReadEvidenceEpochs = /* @__PURE__ */ new Map();
         let fileMutationEpoch = 0;
         const dedupHitCount = /* @__PURE__ */ new Map();
         const noopedMemoryWriteFingerprints = /* @__PURE__ */ new Set();
@@ -601168,7 +601530,6 @@ ${memoryLines.join("\n")}`
                     "After seeing the tool result, continue or call another tool.",
                     'When done, output: {"tool": "task_complete", "args": {"summary": "what you did"}}'
                   ].join("\n");
-                  messages2.push({ role: "system", content: toolInjectMsg });
                   chatRequest.messages = this._prepareModelFacingMessages([
                     ...requestMessages,
                     { role: "system", content: toolInjectMsg }
@@ -602111,7 +602472,49 @@ Read the current file if needed, make a different concrete edit, or move to veri
                 adversaryRedundantSignal
               });
               let repeatShortCircuit = null;
-              if (criticDecision.decision === "guidance") {
+              const exactReadArgs = tc.arguments;
+              const exactReadPath = String(exactReadArgs?.["path"] ?? exactReadArgs?.["file"] ?? "");
+              const exactReadEvidence = exactReadEvidenceEpochs.get(toolFingerprint);
+              const exactReadEvidenceFresh = tc.name === "file_read" && exactReadPath.length > 0 && this._evidenceLedger.validateFreshness(this._normalizeEvidencePath(exactReadPath), this._absoluteToolPath(exactReadPath));
+              const exactReadEvidenceEntry = tc.name === "file_read" && exactReadPath ? this._evidenceLedger.get(this._normalizeEvidencePath(exactReadPath)) : void 0;
+              const exactReadHasCuratedPayload = exactReadEvidenceEntry?.fidelity === "extract";
+              if (tc.name === "file_read" && exactReadEvidenceFresh && exactReadHasCuratedPayload && exactReadEvidence?.taskEpoch === this._taskEpoch && exactReadEvidence.mutationEpoch === fileMutationEpoch) {
+                const path16 = this._normalizeEvidencePath(exactReadPath);
+                const evidence = this._evidenceLedger.get(path16);
+                const curated = this._branchEvidenceByPath.get(path16) ?? [...this._branchEvidenceByPath.entries()].find(([candidate]) => this._normalizeEvidencePath(candidate) === path16)?.[1];
+                const curatedPayload = curated?.output ?? (evidence?.fidelity === "extract" && evidence.content.includes("[BRANCH-EXTRACT") ? evidence.content : null);
+                repeatShortCircuit = {
+                  success: true,
+                  output: curatedPayload ? this._rehydrateResolvedReadEvidence({
+                    fingerprint: toolFingerprint,
+                    canonicalPath: path16,
+                    contentHash: curated?.contentHash ?? evidence?.contentHash ?? "unknown",
+                    payload: curatedPayload,
+                    turn
+                  }) : [
+                    ...evidence?.fidelity === "extract" ? [
+                      "[REHYDRATED_FILE_EVIDENCE]",
+                      "source=active_context_frame fidelity=extract"
+                    ] : [],
+                    "[READ EVIDENCE REFERENCE]",
+                    `path=${path16 || "unknown"}`,
+                    `task_epoch=${this._taskEpoch}`,
+                    `freshness=${evidence?.stale ? "stale" : "fresh"}`,
+                    evidence?.contentHash ? `sha256=${evidence.contentHash}` : null,
+                    "Exact unchanged range was not re-executed. Use the existing evidence handle or request a newly uncovered range after identifying the missing fact."
+                  ].filter(Boolean).join("\n"),
+                  runtimeAuthored: true,
+                  noop: true
+                };
+                this.emit({
+                  type: "status",
+                  toolName: tc.name,
+                  content: `Exact unchanged file_read blocked before dispatch: ${path16}`,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+              if (criticDecision.decision === "guidance" && !repeatShortCircuit) {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
                 const _existingFp = recentToolResults.get(toolFingerprint);
                 if (_existingFp !== void 0) {
@@ -602156,12 +602559,14 @@ Read the current file if needed, make a different concrete edit, or move to veri
                 const suppressSuccessfulShellCacheGuidance = tc.name === "shell" && !isFailedShellRepeat;
                 if (suppressSuccessfulShellCacheGuidance)
                   criticGuidance = null;
+                let exactReadEvidenceFresh2 = true;
                 if (isReadLike && this._evidenceLedger) {
                   const readArgs = tc.arguments;
                   const readPath2 = String(readArgs?.["path"] ?? readArgs?.["file"] ?? "");
                   if (readPath2) {
                     const evidencePath = this._normalizeEvidencePath(readPath2);
                     const wasFresh = evidencePath && this._evidenceLedger.validateFreshness(evidencePath, this._absoluteToolPath(readPath2));
+                    exactReadEvidenceFresh2 = Boolean(wasFresh);
                     if (!wasFresh) {
                       recentToolResults.delete(toolFingerprint);
                       dedupHitCount.delete(toolFingerprint);
@@ -602175,7 +602580,41 @@ Read the current file if needed, make a different concrete edit, or move to veri
                     }
                   }
                 }
-                if (repeatGateEligible && _existingFp !== void 0 && _repeatGateMax > 0) {
+                const exactReadEvidence2 = exactReadEvidenceEpochs.get(toolFingerprint);
+                const exactFileReadReference = tc.name === "file_read" && exactReadEvidenceFresh2 && exactReadHasCuratedPayload && exactReadEvidence2?.taskEpoch === this._taskEpoch && exactReadEvidence2.mutationEpoch === fileMutationEpoch;
+                if (exactFileReadReference) {
+                  const path16 = this._normalizeEvidencePath(String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? ""));
+                  const evidence = this._evidenceLedger?.get(path16);
+                  const curated = this._branchEvidenceByPath.get(path16) ?? [...this._branchEvidenceByPath.entries()].find(([candidate]) => this._normalizeEvidencePath(candidate) === path16)?.[1];
+                  const curatedPayload = curated?.output ?? (evidence?.fidelity === "extract" && evidence.content.includes("[BRANCH-EXTRACT") ? evidence.content : null);
+                  repeatShortCircuit = {
+                    success: true,
+                    // Curated branch output is the bounded authoritative payload
+                    // for this source version. Rehydrate it instead of replacing
+                    // it with a pointer; exact/overlap suppression must not force
+                    // the model to reread a large source merely to recover facts.
+                    output: curatedPayload ? this._rehydrateResolvedReadEvidence({
+                      fingerprint: toolFingerprint,
+                      canonicalPath: path16,
+                      contentHash: curated?.contentHash ?? evidence?.contentHash ?? "unknown",
+                      payload: curatedPayload,
+                      turn
+                    }) : [
+                      ...evidence?.fidelity === "extract" ? [
+                        "[REHYDRATED_FILE_EVIDENCE]",
+                        "source=active_context_frame fidelity=extract"
+                      ] : [],
+                      "[READ EVIDENCE REFERENCE]",
+                      `path=${path16 || "unknown"}`,
+                      `task_epoch=${this._taskEpoch}`,
+                      `freshness=${evidence?.stale ? "stale" : "fresh"}`,
+                      evidence?.contentHash ? `sha256=${evidence.contentHash}` : null,
+                      "Exact unchanged range was not re-executed. Use the existing evidence handle or request a newly uncovered range after identifying the missing fact."
+                    ].filter(Boolean).join("\n"),
+                    runtimeAuthored: true,
+                    noop: true
+                  };
+                } else if (repeatGateEligible && _existingFp !== void 0 && _repeatGateMax > 0) {
                   const _rehydrateArgs = tc.arguments;
                   const _rehydratePath = String(_rehydrateArgs?.["path"] ?? _rehydrateArgs?.["file"] ?? "");
                   const _visibleViaEvidenceFrame = _rehydratePath.length > 0 && (this._evidenceLedger?.renderedFullInLastBlock(this._normalizeEvidencePath(_rehydratePath)) ?? false);
@@ -602256,7 +602695,8 @@ ${cachedResult}`,
                 cachedResultFailed: tc.name === "shell" && typeof focusCachedEntry?.result === "string" && focusCachedEntry.result.includes("status: failure"),
                 duplicateHitCount: focusDuplicateHits,
                 context: this._buildFocusContextSnapshot(),
-                usesAuthoritativeTargetEvidence
+                usesAuthoritativeTargetEvidence,
+                taskEpoch: this._taskEpoch
               });
               if (focusDecision && focusDecision.kind !== "pass") {
                 this._emitFocusSupervisorEvent({
@@ -602817,6 +603257,10 @@ ${cachedResult}`,
                       turn,
                       fidelity: result.runtimeAuthored === true && result.output.startsWith("[BRANCH-EXTRACT") ? "extract" : void 0
                     });
+                    exactReadEvidenceEpochs.set(toolFingerprint, {
+                      taskEpoch: this._taskEpoch,
+                      mutationEpoch: fileMutationEpoch
+                    });
                   }
                   if (this._fileSummaryStore && result.success && result.output && result.output.length > 100) {
                     try {
@@ -603822,6 +604266,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
               this._taskState.toolCallCount++;
               if (realFileMutation) {
                 this._lastFileWriteTurn = turn;
+                this._fileWritesThisRun += Math.max(1, realMutationPaths.length);
                 const writeEvents = Math.max(1, realMutationPaths.length);
                 for (let i2 = 0; i2 < writeEvents; i2++) {
                   this._fileWriteTimestamps.push(Date.now());
@@ -603951,7 +604396,8 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                   noop: tc.name === "todo_write" ? this._isTodoWriteNoopResult(result) : result.noop,
                   alreadyApplied: result.alreadyApplied === true,
                   runtimeAuthored: result.runtimeAuthored === true,
-                  usedAuthoritativeTargetEvidence: usesAuthoritativeTargetEvidence
+                  usedAuthoritativeTargetEvidence: usesAuthoritativeTargetEvidence,
+                  taskEpoch: this._taskEpoch
                 });
                 const focusSnapshotAfter = this._focusSupervisor?.snapshot();
                 focusAfterToolResult = focusSnapshotAfter ?? void 0;
@@ -606633,9 +607079,8 @@ ${marker}` : marker);
           "oldText",
           "search",
           "expected_old_string",
-          "expectedHash",
-          "expected_hash",
-          "start_line"
+          "start_line",
+          "end_line"
         ];
         for (const key of directKeys) {
           const value2 = args[key];
@@ -607135,13 +607580,13 @@ ${marker}` : marker);
           "Next action: file_read the target file or range, then retry the edit with old_string copied exactly from that read and expected_hash set to the read's sha256."
         ].join("\n");
       }
-      staleEditFamilyKey(toolName, pathKey, errorKind, targetHash, latestFileHash) {
+      staleEditFamilyKey(toolName, pathKey, errorKind, targetHash) {
         return [
+          `epoch=${this._taskEpoch}`,
           toolName,
           pathKey || "(unknown)",
           errorKind,
-          targetHash,
-          latestFileHash || "unknown-file-hash"
+          targetHash
         ].join(":");
       }
       staleEditPreflightBlock(toolName, args) {
@@ -607157,11 +607602,8 @@ ${marker}` : marker);
           if (entry.count >= 2 && !hasFreshRead && !hasFreshMutation) {
             return [
               "[STALE EDIT LOOP BLOCKED] " + toolName + " has already failed " + entry.count + " times for " + entry.path + " (" + entry.errorKind + ").",
-              "Do not retry the same stale edit target again. First file_read the current file content once, then either:",
-              "1. confirm the desired change is already present and run verification,",
-              "2. build a new edit from the exact current text, or",
-              "3. choose a different target if this edit is no longer relevant.",
-              "Previous stale target preview: " + entry.preview
+              "Blocked until a fresh file read, a real mutation, or a changed semantic edit target is observed.",
+              "Previous target: " + entry.preview
             ].join("\n");
           }
         }
@@ -607354,7 +607796,7 @@ ${marker}` : marker);
         if (!errorKind)
           return;
         const latestFileHash = typeof result.beforeHash === "string" && result.beforeHash.trim() ? result.beforeHash.trim() : typeof result.afterHash === "string" && result.afterHash.trim() ? result.afterHash.trim() : "unknown-file-hash";
-        const key = this.staleEditFamilyKey(toolName, targetPathKey, errorKind, target.targetHash, latestFileHash);
+        const key = this.staleEditFamilyKey(toolName, targetPathKey, errorKind, target.targetHash);
         const existing = this._staleEditFamilies.get(key);
         this._staleEditFamilies.set(key, {
           count: (existing?.count ?? 0) + 1,
@@ -608182,6 +608624,11 @@ ${tail}`;
           });
           if (signal)
             this._contextLedger.upsert(signal);
+          messages2.push({
+            role: "user",
+            content: userMsg,
+            taskEpoch: this._taskEpoch
+          });
         }
         this.emit({
           type: "user_interrupt",
@@ -609332,16 +609779,24 @@ ${trimmedNew}`;
         const created = this._extractToolTargetPaths(toolName, args, result).map((path16) => this._normalizeEvidencePath(path16)).filter((path16) => path16 && !path16.startsWith(".omnius/") && /creat/i.test(this._taskState.modifiedFiles.get(path16) ?? ""));
         if (created.length === 0)
           return;
-        const board = this._workboard ?? this.getOrCreateWorkboard();
+        const board = this._currentWorkboardSnapshotForFrame() ?? this.getOrCreateWorkboard();
         if (board) {
           const card = this._workboardTodoCardForPaths(board, created);
           if (card && (card.status === "open" || card.status === "in_progress" || card.status === "needs_changes")) {
             try {
+              const runId = this._workboardRunId();
               const completed = completeWorkboardCard(this._workboardDir(), {
-                runId: this.currentArtifactRunId(),
+                runId,
                 cardId: card.id,
                 actor: this.options.subAgent ? "sub-agent" : "agent",
                 outcome: "completed",
+                evidence: {
+                  kind: "tool_result",
+                  summary: `creation ground truth: ${created.join(", ")}`,
+                  tool: toolName,
+                  ref: created[0],
+                  content: String(result.output ?? result.error ?? "").slice(0, 1e3)
+                },
                 reason: `Creation ground truth satisfied mapped target(s): ${created.join(", ")} at turn ${turn}.`
               });
               this._workboard = completed.snapshot;
@@ -610786,6 +611241,7 @@ ${catalog}`,
             parameters: {},
             execute: async (args) => {
               const query = String(args["query"] ?? "").toLowerCase().trim();
+              const queryTerms2 = query.split(/[^a-z0-9_]+/).filter((term) => term.length >= 3);
               const subsetMatch = subsetCatalog[query];
               if (subsetMatch && subsetMatch.length > 0) {
                 const newlyPromoted = [];
@@ -610828,7 +611284,15 @@ ${catalog}`,
                 }
                 return { success: true, output: lines.join("\n") };
               }
-              const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || (t2.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)) || getDesc(t2).toLowerCase().includes(query) || customToolSearchText(t2).toLowerCase().includes(query)).sort((a2, b) => {
+              const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || (t2.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)) || getDesc(t2).toLowerCase().includes(query) || customToolSearchText(t2).toLowerCase().includes(query) || queryTerms2.some((term) => {
+                const searchable = [
+                  t2.name,
+                  ...t2.aliases ?? [],
+                  getDesc(t2),
+                  customToolSearchText(t2)
+                ].join(" ").toLowerCase();
+                return searchable.includes(term);
+              })).sort((a2, b) => {
                 const scoreTool = (tool) => {
                   const meta = getCustomToolMetadata(tool);
                   let score = 0;
@@ -610836,6 +611300,16 @@ ${catalog}`,
                     score += 30;
                   if (tool.name.toLowerCase().includes(query))
                     score += 10;
+                  for (const term of queryTerms2) {
+                    if (tool.name.toLowerCase() === term)
+                      score += 30;
+                    else if (tool.name.toLowerCase().includes(term))
+                      score += 10;
+                    if (getDesc(tool).toLowerCase().includes(term))
+                      score += 4;
+                    if (customToolSearchText(tool).toLowerCase().includes(term))
+                      score += 6;
+                  }
                   if ((tool.aliases ?? []).some((alias) => alias.toLowerCase() === query))
                     score += 24;
                   if ((tool.aliases ?? []).some((alias) => alias.toLowerCase().includes(query)))
@@ -633849,7 +634323,7 @@ async function fetchOpenAIModels(baseUrl2, apiKey) {
     sizeBytes: 0,
     modified: m2.created ? formatRelativeTime(new Date(m2.created * 1e3).toISOString()) : "",
     parameterSize: m2.owned_by ?? void 0,
-    contextLength: m2.context_length ?? m2.max_model_len ?? void 0
+    contextLength: positiveInteger(m2.context_length) ?? positiveInteger(m2.max_model_len) ?? positiveInteger(m2.meta?.["n_ctx"]) ?? positiveInteger(m2.meta?.["context_length"]) ?? void 0
   })).sort((a2, b) => a2.name.localeCompare(b.name));
 }
 async function fetchPeerModels(peerId, authKey) {
@@ -634149,14 +634623,14 @@ function firstPositive(record, keys) {
   return void 0;
 }
 function contextCapacityFromRecord(record) {
-  return firstPositive(record, [
-    "n_ctx",
-    "n_ctx_train",
-    "context_length",
-    "context_window",
-    "max_model_len",
-    "max_context_length"
-  ]);
+  const direct = firstPositive(record, CONTEXT_CAPACITY_KEYS);
+  if (direct !== void 0) return direct;
+  const meta = asRecord(record["meta"]);
+  const metaCapacity = meta ? firstPositive(meta, CONTEXT_CAPACITY_KEYS) : void 0;
+  if (metaCapacity !== void 0) return metaCapacity;
+  const defaults3 = asRecord(record["default_generation_settings"]);
+  const params = defaults3 && asRecord(defaults3["params"]);
+  return params ? firstPositive(params, CONTEXT_CAPACITY_KEYS) : void 0;
 }
 function telemetryHeaders(apiKey) {
   return apiKey ? { Authorization: `Bearer ${apiKey}` } : void 0;
@@ -634366,7 +634840,7 @@ function formatRelativeTime(iso2) {
   const months = Math.floor(days / 30);
   return `${months}mo ago`;
 }
-var IMAGE_GEN_PATTERNS, LLAMA_CPP_TELEMETRY_TIMEOUT_MS;
+var IMAGE_GEN_PATTERNS, LLAMA_CPP_TELEMETRY_TIMEOUT_MS, CONTEXT_CAPACITY_KEYS;
 var init_model_picker = __esm({
   "packages/cli/src/tui/model-picker.ts"() {
     init_dist6();
@@ -634381,6 +634855,14 @@ var init_model_picker = __esm({
       /imagen/i
     ];
     LLAMA_CPP_TELEMETRY_TIMEOUT_MS = 2500;
+    CONTEXT_CAPACITY_KEYS = [
+      "n_ctx",
+      "n_ctx_train",
+      "context_length",
+      "context_window",
+      "max_model_len",
+      "max_context_length"
+    ];
   }
 });
 
@@ -663382,6 +663864,7 @@ var init_runtime_keys = __esm({
 // packages/cli/src/daemon.ts
 var daemon_exports = {};
 __export(daemon_exports, {
+  claimDaemonEndpoint: () => claimDaemonEndpoint,
   ensureDaemon: () => ensureDaemon,
   forceKillDaemon: () => forceKillDaemon,
   getDaemonPid: () => getDaemonPid,
@@ -663389,12 +663872,14 @@ __export(daemon_exports, {
   getDaemonStatus: () => getDaemonStatus,
   getLocalCliVersion: () => getLocalCliVersion,
   isDaemonRunning: () => isDaemonRunning,
+  releaseDaemonEndpointClaim: () => releaseDaemonEndpointClaim,
+  releaseDaemonEndpointForCurrentProcess: () => releaseDaemonEndpointForCurrentProcess,
   restartDaemon: () => restartDaemon,
   startDaemon: () => startDaemon,
   stopDaemon: () => stopDaemon
 });
 import { spawn as spawn35 } from "node:child_process";
-import { existsSync as existsSync140, readFileSync as readFileSync114, writeFileSync as writeFileSync70, mkdirSync as mkdirSync82, unlinkSync as unlinkSync27, openSync as openSync4, closeSync as closeSync4 } from "node:fs";
+import { existsSync as existsSync140, readFileSync as readFileSync114, writeFileSync as writeFileSync70, mkdirSync as mkdirSync82, unlinkSync as unlinkSync27, openSync as openSync4, closeSync as closeSync4, writeSync as writeSync2, statSync as statSync57 } from "node:fs";
 import { join as join149 } from "node:path";
 import { homedir as homedir51 } from "node:os";
 import { fileURLToPath as fileURLToPath20 } from "node:url";
@@ -663408,6 +663893,106 @@ function getDaemonPort() {
   }
   return parseInt(process.env["OMNIUS_PORT"] ?? String(DEFAULT_PORT2), 10);
 }
+function daemonEndpoint(port) {
+  return `127.0.0.1:${port}`;
+}
+function daemonLockFile(port) {
+  return join149(OMNIUS_DIR2, `daemon-${port}.lock`);
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function readDaemonLock(lockFile) {
+  try {
+    const value2 = JSON.parse(readFileSync114(lockFile, "utf8"));
+    if (typeof value2.endpoint !== "string" || typeof value2.pid !== "number" || !Number.isInteger(value2.pid) || value2.pid <= 0 || typeof value2.token !== "string" || typeof value2.startedAt !== "number") {
+      return null;
+    }
+    return value2;
+  } catch {
+    return null;
+  }
+}
+function daemonLockIsInitializing(lockFile) {
+  try {
+    return Date.now() - statSync57(lockFile).mtimeMs < LOCK_INITIALIZATION_GRACE_MS;
+  } catch {
+    return false;
+  }
+}
+function newDaemonLockToken() {
+  return `${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function claimDaemonEndpoint(port = getDaemonPort(), inheritedToken) {
+  mkdirSync82(OMNIUS_DIR2, { recursive: true });
+  const endpoint = daemonEndpoint(port);
+  const lockFile = daemonLockFile(port);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const token = inheritedToken ?? newDaemonLockToken();
+    const record = {
+      endpoint,
+      pid: process.pid,
+      token,
+      startedAt: Date.now()
+    };
+    let fd = null;
+    try {
+      fd = openSync4(lockFile, "wx", 384);
+      writeSync2(fd, JSON.stringify(record));
+      closeSync4(fd);
+      return { endpoint, lockFile, pid: process.pid, port, token };
+    } catch (error) {
+      if (fd !== null) {
+        try {
+          closeSync4(fd);
+        } catch {
+        }
+        try {
+          unlinkSync27(lockFile);
+        } catch {
+        }
+      }
+      const code8 = error.code;
+      if (code8 !== "EEXIST") return null;
+    }
+    const existing = readDaemonLock(lockFile);
+    if (existing?.endpoint === endpoint && inheritedToken && existing.token === inheritedToken) {
+      const transferred = { ...existing, pid: process.pid, startedAt: Date.now() };
+      writeFileSync70(lockFile, JSON.stringify(transferred), { encoding: "utf8", mode: 384 });
+      return { endpoint, lockFile, pid: process.pid, port, token: inheritedToken };
+    }
+    if (existing && processIsAlive(existing.pid) || !existing && daemonLockIsInitializing(lockFile)) {
+      return null;
+    }
+    try {
+      unlinkSync27(lockFile);
+    } catch {
+    }
+  }
+  return null;
+}
+function releaseDaemonEndpointClaim(claim) {
+  const existing = readDaemonLock(claim.lockFile);
+  if (existing?.pid !== claim.pid || existing.token !== claim.token) return;
+  try {
+    unlinkSync27(claim.lockFile);
+  } catch {
+  }
+}
+function releaseDaemonEndpointForCurrentProcess(port = getDaemonPort()) {
+  const lockFile = daemonLockFile(port);
+  const existing = readDaemonLock(lockFile);
+  if (existing?.pid !== process.pid) return;
+  try {
+    unlinkSync27(lockFile);
+  } catch {
+  }
+}
 async function isDaemonRunning(port) {
   const p2 = port ?? getDaemonPort();
   try {
@@ -663518,9 +664103,15 @@ async function resolveDaemonCommand(nodeExe) {
 }
 async function startDaemon() {
   mkdirSync82(OMNIUS_DIR2, { recursive: true });
+  const daemonPort = getDaemonPort();
+  const endpointClaim = claimDaemonEndpoint(daemonPort);
+  if (!endpointClaim) return null;
   const nodeExe = process.execPath;
   const daemonCommand = await resolveDaemonCommand(nodeExe);
-  if (!daemonCommand) return null;
+  if (!daemonCommand) {
+    releaseDaemonEndpointClaim(endpointClaim);
+    return null;
+  }
   let outFd = null;
   let errFd = null;
   try {
@@ -663536,6 +664127,8 @@ async function startDaemon() {
         ...processLeaseEnv(leaseId, ownerId, process.cwd()),
         OMNIUS_DAEMON: "1",
         // signal to serve.ts that it's running as daemon
+        OMNIUS_DAEMON_LOCK_TOKEN: endpointClaim.token,
+        OMNIUS_DAEMON_LOCK_PORT: String(daemonPort),
         OMNIUS_PROCESS_OWNER_KIND: "daemon",
         OMNIUS_PROCESS_LIFECYCLE: "daemon",
         OMNIUS_PROCESS_PERSISTENT: "1"
@@ -663561,6 +664154,7 @@ async function startDaemon() {
     }
     return pid;
   } catch {
+    releaseDaemonEndpointClaim(endpointClaim);
     return null;
   } finally {
     if (outFd !== null) try {
@@ -663683,7 +664277,13 @@ async function ensureDaemon() {
     }
   }
   const pid = await startDaemon();
-  if (!pid) return false;
+  if (!pid) {
+    for (let i2 = 0; i2 < 20; i2++) {
+      await new Promise((r2) => setTimeout(r2, 500));
+      if (await isDaemonRunning(port)) return true;
+    }
+    return false;
+  }
   for (let i2 = 0; i2 < 20; i2++) {
     await new Promise((r2) => setTimeout(r2, 500));
     if (await isDaemonRunning(port)) {
@@ -663698,6 +664298,7 @@ async function ensureDaemon() {
     unlinkSync27(PID_FILE2);
   } catch {
   }
+  releaseDaemonEndpointForCurrentProcess(port);
   return false;
 }
 async function getDaemonStatus() {
@@ -663719,13 +664320,14 @@ async function getDaemonStatus() {
   }
   return { running, pid, port, uptime: uptime2, pidFile: PID_FILE2 };
 }
-var OMNIUS_DIR2, PID_FILE2, DEFAULT_PORT2;
+var OMNIUS_DIR2, PID_FILE2, DEFAULT_PORT2, LOCK_INITIALIZATION_GRACE_MS;
 var init_daemon = __esm({
   "packages/cli/src/daemon.ts"() {
     init_dist5();
     OMNIUS_DIR2 = join149(homedir51(), ".omnius");
     PID_FILE2 = join149(OMNIUS_DIR2, "daemon.pid");
     DEFAULT_PORT2 = 11435;
+    LOCK_INITIALIZATION_GRACE_MS = 5e3;
   }
 });
 
@@ -663883,7 +664485,7 @@ __export(kg_prune_exports, {
   pruneKnowledgeGraph: () => pruneKnowledgeGraph,
   pruneKnowledgeGraphWithInference: () => pruneKnowledgeGraphWithInference
 });
-import { existsSync as existsSync142, statSync as statSync57 } from "node:fs";
+import { existsSync as existsSync142, statSync as statSync58 } from "node:fs";
 import { join as join151 } from "node:path";
 function stateDirFor(workingDir) {
   return join151(workingDir, ".omnius");
@@ -663903,13 +664505,13 @@ function knowledgeGraphStats(workingDir) {
   };
   if (stats.exists) {
     try {
-      stats.sizeBytes = statSync57(dbPath).size;
+      stats.sizeBytes = statSync58(dbPath).size;
     } catch {
     }
   }
   if (existsSync142(archivePath)) {
     try {
-      stats.archiveSizeBytes = statSync57(archivePath).size;
+      stats.archiveSizeBytes = statSync58(archivePath).size;
     } catch {
     }
   }
@@ -666530,7 +667132,7 @@ import {
   readFileSync as readFileSync118,
   unlinkSync as unlinkSync30,
   readdirSync as readdirSync47,
-  statSync as statSync58,
+  statSync as statSync59,
   copyFileSync as copyFileSync6,
   rmSync as rmSync12
 } from "node:fs";
@@ -666664,7 +667266,7 @@ function mergeDir2(src2, dst) {
       if (entry.isDirectory()) {
         mergeDir2(s2, d2);
       } else if (entry.isFile()) {
-        if (!existsSync146(d2) || statSync58(s2).mtimeMs > statSync58(d2).mtimeMs) {
+        if (!existsSync146(d2) || statSync59(s2).mtimeMs > statSync59(d2).mtimeMs) {
           copyFileSync6(s2, d2);
         }
       }
@@ -668149,7 +668751,7 @@ except Exception as exc:
           const p2 = join155(dir, f2);
           let size = 0;
           try {
-            size = statSync58(p2).size;
+            size = statSync59(p2).size;
           } catch {
           }
           const entry = meta[f2];
@@ -671187,10 +671789,10 @@ import {
   mkdirSync as mkdirSync87,
   readdirSync as readdirSync48,
   lstatSync as lstatSync2,
-  statSync as statSync59,
+  statSync as statSync60,
   rmSync as rmSync13,
   appendFileSync as appendFileSync16,
-  writeSync as writeSync2
+  writeSync as writeSync3
 } from "node:fs";
 import { basename as basename32, dirname as dirname49, relative as relative19, join as join156 } from "node:path";
 function omniusPinnedDependencyVersion(name10) {
@@ -671442,7 +672044,7 @@ function parseTelegramMessageIdList(value2) {
 }
 function writeDirectTerminal(data) {
   try {
-    writeSync2(1, data);
+    writeSync3(1, data);
   } catch {
     try {
       overlayWrite(data);
@@ -674053,7 +674655,7 @@ async function handleSlashCommand(input, ctx3) {
           ipfsFiles = files.length;
           for (const f2 of files) {
             try {
-              ipfsBytes += statSync59(join156(ipfsLocalDir, f2)).size;
+              ipfsBytes += statSync60(join156(ipfsLocalDir, f2)).size;
             } catch {
             }
           }
@@ -674066,7 +674668,7 @@ async function handleSlashCommand(input, ctx3) {
               else {
                 heliaBlocks++;
                 try {
-                  heliaBytes += statSync59(join156(dir, entry.name)).size;
+                  heliaBytes += statSync60(join156(dir, entry.name)).size;
                 } catch {
                 }
               }
@@ -674209,7 +674811,7 @@ async function handleSlashCommand(input, ctx3) {
           lines.push(`
   ${c3.bold("Structured Memory (SQLite)")}`);
           lines.push(
-            `    Memories: ${c3.bold(String(count))}   DB: ${c3.dim(formatFileSize(statSync59(dbPath).size))}`
+            `    Memories: ${c3.bold(String(count))}   DB: ${c3.dim(formatFileSize(statSync60(dbPath).size))}`
           );
           cDb(db);
         }
@@ -674241,7 +674843,7 @@ async function handleSlashCommand(input, ctx3) {
               walkStorage(full, subCat);
             } else {
               try {
-                const sz = statSync59(full).size;
+                const sz = statSync60(full).size;
                 totalBytes += sz;
                 if (!categories[category])
                   categories[category] = { files: 0, bytes: 0 };
@@ -681393,7 +681995,7 @@ async function showCohereDashboard(ctx3) {
                 const snapItems = snaps.slice(0, 20).map((f2) => ({
                   key: f2,
                   label: f2.replace(".json", ""),
-                  detail: `${formatFileSize(statSync59(join156(snapDir, f2)).size)}`
+                  detail: `${formatFileSize(statSync60(join156(snapDir, f2)).size)}`
                 }));
                 if (snapItems.length > 0) {
                   await tuiSelect({
@@ -696286,48 +696888,86 @@ var init_emotion_engine = __esm({
         }
         return { allowed: true };
       }
+      /** Auxiliary stages share one non-queuing backend slot. */
+      auxiliaryInferenceInFlight = false;
+      /** Failed stages cool down independently; a successful nonempty reply resets them. */
+      internalInferenceCircuit = /* @__PURE__ */ new Map();
+      noteInternalInferenceFailure(stage2, now2 = Date.now()) {
+        const prior = this.internalInferenceCircuit.get(stage2);
+        const failureCount = Math.min(6, (prior?.failureCount ?? 0) + 1);
+        const cooldownMs = Math.min(10 * 6e4, 3e4 * 2 ** (failureCount - 1));
+        this.internalInferenceCircuit.set(stage2, {
+          failureCount,
+          openUntil: now2 + cooldownMs
+        });
+      }
+      resetInternalInferenceCircuit(stage2) {
+        this.internalInferenceCircuit.delete(stage2);
+      }
       async runDirectInternalInference(opts) {
         const cwd4 = resolve71(process.cwd());
         const startedAt2 = Date.now();
-        const admission = await this.admitInternalInference();
-        if (!admission.allowed) {
+        const circuit = this.internalInferenceCircuit.get(opts.stage);
+        if (circuit && circuit.openUntil > startedAt2) {
           this.recordInternalDecision({
             stage: opts.stage,
             status: "skipped",
             elapsedMs: Date.now() - startedAt2,
-            skipReason: admission.reason,
+            skipReason: `internal_inference_circuit_open:${opts.stage}:retry_after_ms=${circuit.openUntil - startedAt2}`,
             promptChars: opts.system.length + opts.user.length
           });
           return null;
         }
-        const request = {
-          messages: [
-            { role: "system", content: opts.system },
-            { role: "user", content: opts.user }
-          ],
-          tools: [],
-          temperature: opts.temperature,
-          maxTokens: opts.maxTokens,
-          timeoutMs: opts.timeoutMs,
-          think: false,
-          disableEmptyContentRecovery: true,
-          poolQueuePolicy: "skip",
-          poolQueueTimeoutMs: 1
-        };
-        recordContextWindowDump({
-          source: "emotionEngine",
-          stage: opts.stage,
-          agentType: "internal",
-          sessionId: process.env["OMNIUS_SESSION_ID"] || "emotion-engine",
-          runId: process.env["OMNIUS_SESSION_ID"] || "emotion-engine",
-          turn: 0,
-          attempt: 0,
-          model: this.config.model,
-          cwd: cwd4,
-          note: opts.note,
-          request
-        });
+        if (this.auxiliaryInferenceInFlight) {
+          this.recordInternalDecision({
+            stage: opts.stage,
+            status: "skipped",
+            elapsedMs: Date.now() - startedAt2,
+            skipReason: `auxiliary_inference_busy:${opts.stage}`,
+            promptChars: opts.system.length + opts.user.length
+          });
+          return null;
+        }
+        this.auxiliaryInferenceInFlight = true;
         try {
+          const admission = await this.admitInternalInference();
+          if (!admission.allowed) {
+            this.recordInternalDecision({
+              stage: opts.stage,
+              status: "skipped",
+              elapsedMs: Date.now() - startedAt2,
+              skipReason: admission.reason,
+              promptChars: opts.system.length + opts.user.length
+            });
+            return null;
+          }
+          const request = {
+            messages: [
+              { role: "system", content: opts.system },
+              { role: "user", content: opts.user }
+            ],
+            tools: [],
+            temperature: opts.temperature,
+            maxTokens: opts.maxTokens,
+            timeoutMs: opts.timeoutMs,
+            think: false,
+            disableEmptyContentRecovery: true,
+            poolQueuePolicy: "skip",
+            poolQueueTimeoutMs: 1
+          };
+          recordContextWindowDump({
+            source: "emotionEngine",
+            stage: opts.stage,
+            agentType: "internal",
+            sessionId: process.env["OMNIUS_SESSION_ID"] || "emotion-engine",
+            runId: process.env["OMNIUS_SESSION_ID"] || "emotion-engine",
+            turn: 0,
+            attempt: 0,
+            model: this.config.model,
+            cwd: cwd4,
+            note: opts.note,
+            request
+          });
           const backend = new OllamaAgenticBackend(
             this.config.backendUrl,
             this.config.model,
@@ -696338,6 +696978,19 @@ var init_emotion_engine = __esm({
           const output = String(
             result.choices?.[0]?.message?.content ?? ""
           ).trim();
+          if (!output) {
+            const error = "empty internal inference response";
+            this.noteInternalInferenceFailure(opts.stage);
+            this.recordInternalDecision({
+              stage: opts.stage,
+              status: "error",
+              elapsedMs: Date.now() - startedAt2,
+              error,
+              promptChars: opts.system.length + opts.user.length
+            });
+            return null;
+          }
+          this.resetInternalInferenceCircuit(opts.stage);
           this.recordInternalDecision({
             stage: opts.stage,
             status: "ok",
@@ -696347,14 +697000,18 @@ var init_emotion_engine = __esm({
           });
           return output;
         } catch (err) {
+          const error = err instanceof Error ? err.message : String(err);
+          this.noteInternalInferenceFailure(opts.stage);
           this.recordInternalDecision({
             stage: opts.stage,
             status: "error",
             elapsedMs: Date.now() - startedAt2,
-            error: err instanceof Error ? err.message : String(err),
+            error,
             promptChars: opts.system.length + opts.user.length
           });
           throw err;
+        } finally {
+          this.auxiliaryInferenceInFlight = false;
         }
       }
       recordInternalDecision(entry) {
@@ -697716,7 +698373,7 @@ import {
   existsSync as existsSync157,
   mkdirSync as mkdirSync96,
   readFileSync as readFileSync128,
-  statSync as statSync60,
+  statSync as statSync61,
   unlinkSync as unlinkSync33,
   writeFileSync as writeFileSync83
 } from "node:fs";
@@ -698229,7 +698886,7 @@ function materializeTelegramCreativeArtifactForSend(root, rawPath) {
 }
 function safeStatFile(path16) {
   try {
-    return statSync60(path16).isFile();
+    return statSync61(path16).isFile();
   } catch {
     return false;
   }
@@ -698500,7 +699157,7 @@ ${(result.error || result.output || "").slice(0, 1200)}`,
           for (const fn of cleanup) fn();
         }
         rememberCreated(this.root, guarded.path.abs);
-        const sizeKB = Math.round(statSync60(guarded.path.abs).size / 1024);
+        const sizeKB = Math.round(statSync61(guarded.path.abs).size / 1024);
         this.emitProgress(start2, {
           stage: "save",
           message: `Saved scoped audio file (${sizeKB}KB)`
@@ -701883,7 +702540,7 @@ import {
   existsSync as existsSync160,
   unlinkSync as unlinkSync36,
   readdirSync as readdirSync56,
-  statSync as statSync61,
+  statSync as statSync62,
   readFileSync as readFileSync131,
   writeFileSync as writeFileSync85,
   appendFileSync as appendFileSync20
@@ -705103,6 +705760,8 @@ Telegram link integrity contract:
        */
       telegramOwnerLockFile = null;
       telegramOwnerLockFiles = [];
+      /** Per-bridge ownership tokens prevent a second bridge from releasing our lock. */
+      telegramOwnerLockTokens = /* @__PURE__ */ new Map();
       /** Session keys loaded from persistent conversation memory */
       loadedConversationState = /* @__PURE__ */ new Set();
       /** True once persisted Telegram conversation scopes have been bulk-loaded. */
@@ -706194,11 +706853,20 @@ ${message2}`)
       triageTelegramSteeringInput(msg) {
         const text2 = msg.text.trim();
         const lower = text2.toLowerCase();
-        if (/^\/(?:stop|cancel|abort|halt)\b/.test(lower)) {
-          return { intent: "cancel", reason: "explicit stop/cancel command" };
+        if (/^\/(?:stop|cancel|abort|halt)\b/.test(lower) || /^(?:stop|cancel|abort|halt)(?:[.!]?|\s+(?:the\s+)?(?:current\s+)?(?:task|work|run)\b)/.test(
+          lower
+        )) {
+          return { intent: "cancel", reason: "explicit cancellation request" };
         }
-        if (/^\/(?:redirect|reroute|pivot)\b/.test(lower)) {
-          return { intent: "redirect", reason: "explicit redirect command" };
+        if (/^\/(?:redirect|reroute|pivot)\b/.test(lower) || /^(?:please\s+)?(?:redirect|reroute|pivot)\s+(?:the\s+)?(?:current\s+)?(?:task|work|run)\b/.test(
+          lower
+        ) || /^(?:please\s+)?(?:switch|change|move)\s+(?:(?:focus|work|task)\s+)?to\b/.test(
+          lower
+        )) {
+          return {
+            intent: "redirect",
+            reason: "explicit natural-language redirect request"
+          };
         }
         if (/^\/(?:replace|new[_-]?task)\b/.test(lower) || /^(?:new task|replace (?:the )?(?:current )?task|forget (?:that|the current task)|instead[,!:]?)/.test(
           lower
@@ -706306,14 +706974,13 @@ ${message2}`)
             content,
             source: "telegram",
             receivedAt: intake.receivedAt,
-            intent: intake.intent,
-            taskEpoch: intake.taskEpoch
+            intent: intake.intent
           });
           return;
         }
         runner.injectUserMessage(this.formatTelegramSteeringCompatibilityMessage(pending2));
       }
-      async preemptTelegramSubAgentForIntake(msg, subAgent, toolContext, intake) {
+      async preemptTelegramSubAgentForIntake(msg, subAgent, intake) {
         const sessionKey = intake.sessionKey;
         await this.transitionTelegramIntake(
           intake,
@@ -706321,59 +706988,33 @@ ${message2}`)
           "trusted Telegram steering receipt sent",
           { runId: subAgent.runId }
         );
-        const receipt = intake.intent === "cancel" ? "Cancellation received. I am stopping the current task." : "Redirection received. I am stopping the current step and replanning from your latest instruction.";
+        const receipt = intake.intent === "cancel" ? "Cancellation received. I am stopping the current task." : "Redirection received. I am interrupting the current step and replanning from your latest instruction at the next safe boundary.";
         await this.replyToTelegramMessage(msg, receipt).catch(() => null);
+        if (intake.intent !== "cancel") {
+          intake.taskEpoch = this.advanceTelegramTaskEpoch(sessionKey);
+        }
         await this.transitionTelegramIntake(
           intake,
           "preempt_requested",
-          "trusted admin-DM steering preemption requested",
+          "trusted admin-DM steering preemption requested for the active runner",
           { runId: subAgent.runId }
         );
-        subAgent.preempted = true;
-        if (intake.intent !== "cancel") {
-          const epoch = this.advanceTelegramTaskEpoch(sessionKey);
-          const displaced = this.telegramQueuedSessionWork.get(sessionKey);
-          if (displaced) {
-            this.telegramQueuedSessionWork.delete(sessionKey);
-            await Promise.all(
-              displaced.intakeRecords.map(
-                (record) => this.transitionTelegramIntake(
-                  record,
-                  "superseded",
-                  `superseded by trusted ${intake.intent} intake ${intake.inputId}`
-                )
-              )
-            );
-          }
-          intake.taskEpoch = epoch;
-          const queued = this.buildTelegramQueuedSessionWork(
-            sessionKey,
-            msg,
-            toolContext,
-            Date.now(),
-            intake
-          );
-          this.telegramQueuedSessionWork.set(sessionKey, queued);
-          await this.transitionTelegramIntake(
-            intake,
-            "deferred",
-            "waiting for superseded runner cleanup before dispatch",
-            { taskEpoch: epoch }
-          );
-        }
+        await this.enqueueTelegramMessageForExistingSubAgent(msg, subAgent, intake);
         const runner = subAgent.runner;
-        if (typeof runner?.requestSteeringPreemption === "function") {
-          runner.requestSteeringPreemption(intake.inputId);
-        } else {
+        const preemptionReceipt = runner?.requestSteeringPreemption?.(
+          intake.inputId
+        );
+        if (!preemptionReceipt) {
+          subAgent.preempted = true;
           runner?.abort?.();
         }
+        if (intake.intent === "cancel") subAgent.preempted = true;
         await this.transitionTelegramIntake(
           intake,
           "preempted",
-          "active runner interrupted for trusted steering intake",
+          preemptionReceipt ? "active runner turn interrupted; typed steering will apply at its safe boundary" : "runner lacks typed preemption support; active run was cancelled",
           { runId: subAgent.runId }
         );
-        this.dispatchQueuedTelegramSessionWorkSoon();
       }
       async requeuePendingTelegramIntakeOnFinalization(subAgent) {
         const pending2 = subAgent.pendingIntakeRecords.splice(0);
@@ -707137,7 +707778,7 @@ Model: <code>${escapeTelegramHTML(model.id)}</code>`
         }
         let sent = 0;
         for (const path16 of paths) {
-          if (!existsSync160(path16) || !statSync61(path16).isFile()) continue;
+          if (!existsSync160(path16) || !statSync62(path16).isFile()) continue;
           const kind = classifyMedia(path16) ?? "document";
           const messageId = await this.sendMediaReference(
             msg.chatId,
@@ -712852,8 +713493,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
             } catch (e2) {
               for (const lockFile of claimed)
                 this.releaseTelegramOwnerLock(lockFile);
-              if (e2 instanceof Error && e2.message.startsWith("Telegram bot @"))
-                throw e2;
+              throw e2;
             }
           }
           this.state = {
@@ -713012,47 +713652,97 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
       claimTelegramOwnerLock(lockDir, botUserId, botUsername) {
         mkdirSync98(lockDir, { recursive: true });
         const lockFile = join170(lockDir, `bot-${botUserId}.owner.lock`);
-        if (existsSync160(lockFile)) {
+        const ownerToken = randomBytes28(16).toString("hex");
+        const payload = JSON.stringify(
+          {
+            pid: process.pid,
+            cwd: this.repoRoot || process.cwd(),
+            botUsername,
+            botUserId,
+            ownerToken,
+            ts: Date.now()
+          },
+          null,
+          2
+        );
+        const recoveryFile = `${lockFile}.recovery`;
+        for (let attempt = 0; attempt < 4; attempt++) {
           try {
-            const prior = JSON.parse(readFileSync131(lockFile, "utf8"));
-            const priorAlive = typeof prior.pid === "number" && prior.pid !== process.pid ? this.processIsAlive(prior.pid) : false;
-            if (priorAlive) {
+            writeFileSync85(lockFile, payload, {
+              encoding: "utf-8",
+              mode: 384,
+              flag: "wx"
+            });
+            this.telegramOwnerLockTokens.set(lockFile, ownerToken);
+            return lockFile;
+          } catch (error) {
+            if (error?.code !== "EEXIST") throw error;
+          }
+          let prior = {};
+          try {
+            prior = JSON.parse(readFileSync131(lockFile, "utf8"));
+          } catch {
+          }
+          const priorAlive = typeof prior.pid === "number" && prior.pid !== process.pid ? this.processIsAlive(prior.pid) : typeof prior.pid === "number";
+          if (priorAlive) {
+            throw new Error(
+              `Telegram bot @${prior.botUsername || botUsername || "unknown"} is already being polled by pid ${prior.pid} (cwd ${prior.cwd || "?"}). Stop that instance or use a different bot token in this project.`
+            );
+          }
+          const recoveryToken = randomBytes28(12).toString("hex");
+          try {
+            writeFileSync85(recoveryFile, recoveryToken, {
+              encoding: "utf-8",
+              mode: 384,
+              flag: "wx"
+            });
+          } catch (error) {
+            if (error?.code === "EEXIST") continue;
+            throw error;
+          }
+          try {
+            let currentPid;
+            try {
+              currentPid = JSON.parse(readFileSync131(lockFile, "utf8"))?.pid;
+            } catch {
+            }
+            if (typeof currentPid === "number" && (currentPid === process.pid || this.processIsAlive(currentPid))) {
               throw new Error(
-                `Telegram bot @${prior.botUsername || botUsername || "unknown"} is already being polled by pid ${prior.pid} (cwd ${prior.cwd || "?"}). Stop that instance or use a different bot token in this project.`
+                `Telegram bot @${botUsername || "unknown"} acquired an owner while stale-lock recovery was pending.`
               );
             }
-          } catch (e2) {
-            if (e2 instanceof Error && e2.message.startsWith("Telegram bot @"))
-              throw e2;
+            try {
+              unlinkSync36(lockFile);
+            } catch (error) {
+              if (error?.code !== "ENOENT") throw error;
+            }
+          } finally {
+            try {
+              if (readFileSync131(recoveryFile, "utf8") === recoveryToken)
+                unlinkSync36(recoveryFile);
+            } catch {
+            }
           }
         }
-        writeFileSync85(
-          lockFile,
-          JSON.stringify(
-            {
-              pid: process.pid,
-              cwd: this.repoRoot || process.cwd(),
-              botUsername,
-              botUserId,
-              ts: Date.now()
-            },
-            null,
-            2
-          ),
-          { encoding: "utf-8", mode: 384 }
+        throw new Error(
+          `Could not atomically acquire Telegram owner lock for @${botUsername || botUserId}; retry after the current startup settles.`
         );
-        return lockFile;
       }
       releaseTelegramOwnerLock(lockFile) {
         try {
+          const ownerToken = this.telegramOwnerLockTokens.get(lockFile);
+          if (!ownerToken) return;
           if (!existsSync160(lockFile)) return;
           try {
             const prior = JSON.parse(readFileSync131(lockFile, "utf8"));
-            if (prior.pid !== process.pid) return;
+            if (prior.pid !== process.pid || prior.ownerToken !== ownerToken) return;
           } catch {
+            return;
           }
           unlinkSync36(lockFile);
         } catch {
+        } finally {
+          this.telegramOwnerLockTokens.delete(lockFile);
         }
       }
       /**
@@ -714130,7 +714820,6 @@ Join: ${newUrl}`
             await this.preemptTelegramSubAgentForIntake(
               msg,
               existing,
-              toolContext,
               intakeRecord
             );
             return;
@@ -719392,7 +720081,7 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
         const abs = isAbsolute17(trimmed) ? resolve73(trimmed) : resolve73(base3, trimmed);
         if (!existsSync160(abs))
           return { ok: false, error: `File does not exist: ${trimmed}` };
-        if (!statSync61(abs).isFile())
+        if (!statSync62(abs).isFile())
           return { ok: false, error: `Path is not a file: ${trimmed}` };
         return { ok: true, path: abs };
       }
@@ -719906,7 +720595,7 @@ ${text2}`.trim()
       }
       async sendTelegramFileToChat(chatId, path16, options2) {
         const abs = resolve73(path16);
-        if (!existsSync160(abs) || !statSync61(abs).isFile()) {
+        if (!existsSync160(abs) || !statSync62(abs).isFile()) {
           throw new Error(`File does not exist or is not a regular file: ${path16}`);
         }
         return this.sendMediaReferenceStrict(
@@ -720176,7 +720865,7 @@ Content-Type: ${contentType}\r
         for (const path16 of paths) {
           const abs = resolve73(path16);
           if (subAgent.deliveredArtifacts.includes(abs)) continue;
-          if (!existsSync160(abs) || !statSync61(abs).isFile()) continue;
+          if (!existsSync160(abs) || !statSync62(abs).isFile()) continue;
           subAgent.deliveredArtifacts.push(abs);
           await this.sendMediaReference(
             msg.chatId,
@@ -720218,7 +720907,7 @@ Content-Type: ${contentType}\r
             abs
           );
           if (!materialized.ok) continue;
-          if (!existsSync160(materialized.path) || !statSync61(materialized.path).isFile()) {
+          if (!existsSync160(materialized.path) || !statSync62(materialized.path).isFile()) {
             materialized.cleanup?.();
             continue;
           }
@@ -722407,7 +723096,7 @@ __export(projects_exports, {
   setCurrentProject: () => setCurrentProject,
   unregisterProject: () => unregisterProject
 });
-import { readFileSync as readFileSync132, writeFileSync as writeFileSync86, mkdirSync as mkdirSync99, existsSync as existsSync161, statSync as statSync62, renameSync as renameSync15 } from "node:fs";
+import { readFileSync as readFileSync132, writeFileSync as writeFileSync86, mkdirSync as mkdirSync99, existsSync as existsSync161, statSync as statSync63, renameSync as renameSync15 } from "node:fs";
 import { homedir as homedir58 } from "node:os";
 import { basename as basename43, join as join171, resolve as resolve74 } from "node:path";
 import { randomUUID as randomUUID19 } from "node:crypto";
@@ -722433,7 +723122,7 @@ function listProjects() {
   const alive = [];
   for (const p2 of projects) {
     try {
-      if (statSync62(p2.root).isDirectory()) alive.push(p2);
+      if (statSync63(p2.root).isDirectory()) alive.push(p2);
     } catch {
     }
   }
@@ -723573,7 +724262,7 @@ var init_audit_log = __esm({
 
 // packages/cli/src/api/disk-task-output.ts
 import { open } from "node:fs/promises";
-import { existsSync as existsSync164, mkdirSync as mkdirSync102, statSync as statSync63 } from "node:fs";
+import { existsSync as existsSync164, mkdirSync as mkdirSync102, statSync as statSync64 } from "node:fs";
 import { dirname as dirname54 } from "node:path";
 import * as fsConstants from "node:constants";
 var O_NOFOLLOW2, O_APPEND2, O_CREAT2, O_WRONLY2, OPEN_FLAGS_WRITE, OPEN_MODE, DiskTaskOutput;
@@ -723671,7 +724360,7 @@ var init_disk_task_output = __esm({
           if (!existsSync164(this.path)) {
             return { content: "", nextOffset: offset, eof: true, size: 0 };
           }
-          const st = statSync63(this.path);
+          const st = statSync64(this.path);
           if (offset >= st.size) {
             return { content: "", nextOffset: offset, eof: true, size: st.size };
           }
@@ -723858,7 +724547,7 @@ data: ${JSON.stringify(ev)}
 });
 
 // packages/cli/src/api/routes-media.ts
-import { existsSync as existsSync165, mkdirSync as mkdirSync103, statSync as statSync64, copyFileSync as copyFileSync7, createReadStream } from "node:fs";
+import { existsSync as existsSync165, mkdirSync as mkdirSync103, statSync as statSync65, copyFileSync as copyFileSync7, createReadStream } from "node:fs";
 import { basename as basename44, join as join174, resolve as pathResolve2 } from "node:path";
 function mediaWorkDir() {
   return join174(omniusHomeDir(), "media", "_work");
@@ -724159,7 +724848,7 @@ async function runGeneration(ctx3, kind, buildTool, buildArgs) {
     const published = publishToGallery(srcPath, kind);
     const size = (() => {
       try {
-        return statSync64(published.path).size;
+        return statSync65(published.path).size;
       } catch {
         return 0;
       }
@@ -724266,7 +724955,7 @@ function handleFile(ctx3) {
   const ext = full.slice(full.lastIndexOf(".")).toLowerCase();
   ctx3.res.writeHead(200, {
     "Content-Type": MIME_BY_EXT[ext] || "application/octet-stream",
-    "Content-Length": statSync64(full).size,
+    "Content-Length": statSync65(full).size,
     "Cache-Control": "private, max-age=3600"
   });
   createReadStream(full).pipe(ctx3.res);
@@ -724850,7 +725539,7 @@ __export(aiwg_exports, {
   resolveAiwgRoot: () => resolveAiwgRoot,
   tryRouteAiwg: () => tryRouteAiwg
 });
-import { existsSync as existsSync167, readFileSync as readFileSync136, readdirSync as readdirSync57, statSync as statSync65 } from "node:fs";
+import { existsSync as existsSync167, readFileSync as readFileSync136, readdirSync as readdirSync57, statSync as statSync66 } from "node:fs";
 import { join as join176 } from "node:path";
 import { homedir as homedir60 } from "node:os";
 import { execSync as execSync38 } from "node:child_process";
@@ -724952,7 +725641,7 @@ function listAiwgFrameworks() {
   for (const name10 of readdirSync57(frameworksDir)) {
     const p2 = join176(frameworksDir, name10);
     try {
-      const st = statSync65(p2);
+      const st = statSync66(p2);
       if (!st.isDirectory()) continue;
       const agg = aggregateDir(p2);
       out.push({
@@ -724989,7 +725678,7 @@ function aggregateDir(dir, depth = 0) {
         out.commands += sub2.commands;
       } else if (e2.isFile()) {
         try {
-          const st = statSync65(p2);
+          const st = statSync66(p2);
           out.files++;
           out.bytes += st.size;
           if (e2.name.endsWith(".md")) {
@@ -725123,7 +725812,7 @@ function listAiwgAddons() {
   for (const name10 of readdirSync57(addonsDir)) {
     const p2 = join176(addonsDir, name10);
     try {
-      const st = statSync65(p2);
+      const st = statSync66(p2);
       if (!st.isDirectory()) continue;
       const agg = aggregateDir(p2);
       out.push({
@@ -725912,7 +726601,7 @@ import {
   mkdirSync as mkdirSync106,
   readFileSync as readFileSync138,
   readdirSync as readdirSync58,
-  statSync as statSync66
+  statSync as statSync67
 } from "node:fs";
 import { join as join179, resolve as pathResolve3 } from "node:path";
 import { homedir as homedir62 } from "node:os";
@@ -727374,7 +728063,7 @@ async function handleFilesRead(ctx3) {
       );
       return true;
     }
-    const st = statSync66(resolved);
+    const st = statSync67(resolved);
     if (st.isDirectory()) {
       sendProblem(
         res,
@@ -743166,7 +743855,7 @@ import {
   watch as fsWatch4,
   renameSync as renameSync18,
   unlinkSync as unlinkSync38,
-  statSync as statSync67,
+  statSync as statSync68,
   openSync as openSync7,
   readSync as readSync3,
   closeSync as closeSync7
@@ -743526,7 +744215,7 @@ function fileEntryMetadata(dir, entry) {
     kind: fileKindForPath(entry.name)
   };
   try {
-    const st = statSync67(target);
+    const st = statSync68(target);
     meta["size"] = st.size;
     meta["mtime"] = new Date(st.mtimeMs).toISOString();
   } catch {
@@ -743538,7 +744227,7 @@ function contentDispositionName(filePath) {
   return name10.replace(/["\r\n]/g, "");
 }
 function streamWorkspaceFile(req3, res, target) {
-  const st = statSync67(target);
+  const st = statSync68(target);
   if (!st.isFile()) {
     jsonResponse(res, 400, { error: "Path is not a file", path: target });
     return;
@@ -747444,7 +748133,7 @@ function handleV1RunsById(res, id2) {
   const enriched = { ...job };
   if (outputFile && existsSync173(outputFile)) {
     try {
-      const size = statSync67(outputFile).size;
+      const size = statSync68(outputFile).size;
       const tailSize = Math.min(size, 4096);
       const buffer2 = Buffer.alloc(tailSize);
       const fd = openSync7(outputFile, "r");
@@ -748092,7 +748781,7 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
           const dir = path16.dirname(cssEntry);
           const fullPath = path16.join(dir, entry.path);
           if (fs14.existsSync(fullPath)) {
-            const stat9 = statSync67(fullPath);
+            const stat9 = statSync68(fullPath);
             res.writeHead(200, {
               "Content-Type": entry.ct,
               "Content-Length": String(stat9.size),
@@ -748644,17 +749333,17 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
             const child = join183(dir, e2.name);
             const omniusDir = join183(child, ".omnius");
             try {
-              if (statSync67(omniusDir).isDirectory()) {
+              if (statSync68(omniusDir).isDirectory()) {
                 const name10 = e2.name;
                 const prefsFile = join183(omniusDir, "config.json");
                 let lastSeen = 0;
                 try {
-                  lastSeen = statSync67(prefsFile).mtimeMs;
+                  lastSeen = statSync68(prefsFile).mtimeMs;
                 } catch {
                 }
                 if (!lastSeen) {
                   try {
-                    lastSeen = statSync67(omniusDir).mtimeMs;
+                    lastSeen = statSync68(omniusDir).mtimeMs;
                   } catch {
                   }
                 }
@@ -748702,17 +749391,17 @@ async function handleRequest(req3, res, ollamaUrl, verbose, runtimeDefaults = {}
             const child = join183(dir, e2.name);
             const omniusDir = join183(child, ".omnius");
             try {
-              if (statSync67(omniusDir).isDirectory()) {
+              if (statSync68(omniusDir).isDirectory()) {
                 const name10 = e2.name;
                 const prefsFile = join183(omniusDir, "config.json");
                 let lastSeen = 0;
                 try {
-                  lastSeen = statSync67(prefsFile).mtimeMs;
+                  lastSeen = statSync68(prefsFile).mtimeMs;
                 } catch {
                 }
                 if (!lastSeen) {
                   try {
-                    lastSeen = statSync67(omniusDir).mtimeMs;
+                    lastSeen = statSync68(omniusDir).mtimeMs;
                   } catch {
                   }
                 }
@@ -753710,7 +754399,7 @@ import {
   appendFileSync as appendFileSync22,
   rmSync as rmSync17,
   readdirSync as readdirSync60,
-  statSync as statSync68,
+  statSync as statSync69,
   mkdirSync as mkdirSync111
 } from "node:fs";
 import { existsSync as existsSync174 } from "node:fs";
@@ -759581,7 +760270,7 @@ This is an independent background session started from /background.`
             if (!entry.startsWith(partialName)) continue;
             const full = join185(searchDir, entry);
             try {
-              const st = statSync68(full);
+              const st = statSync69(full);
               const suffix = st.isDirectory() ? "/" : "";
               const display = isAbsolute18 ? full : full.startsWith(repoRoot + sep7) ? full.slice(repoRoot.length + 1) : full;
               completions.push(display + suffix);
@@ -762365,11 +763054,11 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
               }
               if (name10 === "voice_list_files") {
                 const baseDir = String(args?.dir ?? ".");
-                const { readdirSync: readdirSync62, statSync: statSync70 } = __require("node:fs");
+                const { readdirSync: readdirSync62, statSync: statSync71 } = __require("node:fs");
                 const { join: join190, resolve: resolve82 } = __require("node:path");
                 const base3 = baseDir.startsWith("/") ? baseDir : resolve82(join190(repoRoot, baseDir));
                 const items = readdirSync62(base3).slice(0, 200).map((f2) => {
-                  const s2 = statSync70(join190(base3, f2));
+                  const s2 = statSync71(join190(base3, f2));
                   return { name: f2, dir: s2.isDirectory(), size: s2.size };
                 });
                 return JSON.stringify({ dir: base3, items }, null, 2);
@@ -765202,7 +765891,7 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve80 } from "node:path";
-import { existsSync as existsSync176, statSync as statSync69 } from "node:fs";
+import { existsSync as existsSync176, statSync as statSync70 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config3) {
   const repoRoot = resolve80(opts.repoPath ?? cwd2());
@@ -765212,7 +765901,7 @@ async function indexRepoCommand(opts, _config3) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
-  const stat9 = statSync69(repoRoot);
+  const stat9 = statSync70(repoRoot);
   if (!stat9.isDirectory()) {
     printError(`Path is not a directory: ${repoRoot}`);
     process.exit(1);
@@ -765696,23 +766385,34 @@ async function serveCommand(opts, config) {
   const ollamaUrl = config.backendUrl || "http://127.0.0.1:11434";
   const isDaemon = opts.daemon || process.env["OMNIUS_DAEMON"] === "1";
   const isQuiet = opts.quiet || isDaemon;
+  let releaseDaemonClaim;
+  if (isDaemon) {
+    const { claimDaemonEndpoint: claimDaemonEndpoint2, releaseDaemonEndpointClaim: releaseDaemonEndpointClaim2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    const inheritedPort = parseInt(process.env["OMNIUS_DAEMON_LOCK_PORT"] ?? "", 10);
+    const claim = claimDaemonEndpoint2(
+      Number.isFinite(inheritedPort) && inheritedPort > 0 ? inheritedPort : port,
+      process.env["OMNIUS_DAEMON_LOCK_TOKEN"]
+    );
+    if (!claim) return;
+    releaseDaemonClaim = () => releaseDaemonEndpointClaim2(claim);
+  }
   if (!isQuiet) {
     printHeader("Omnius REST API");
     printInfo(`Starting API server on port ${port}...`);
     printInfo(`Backend: ${config.backendType} (${ollamaUrl})`);
   }
-  if (isDaemon) {
-    try {
-      const resp = await fetch(`http://127.0.0.1:${port}/health`, {
-        signal: AbortSignal.timeout(1500)
-      });
-      if (resp.ok) {
-        return;
+  try {
+    if (isDaemon) {
+      try {
+        const resp = await fetch(`http://127.0.0.1:${port}/health`, {
+          signal: AbortSignal.timeout(1500)
+        });
+        if (resp.ok) {
+          return;
+        }
+      } catch {
       }
-    } catch {
     }
-  }
-  try {
     const server2 = startApiServer({ port, ollamaUrl, quiet: isQuiet });
     if (isDaemon) {
       let lastActivity = Date.now();
@@ -765749,6 +766449,8 @@ async function serveCommand(opts, config) {
     } else {
       if (!isQuiet) printError(`API server failed: ${msg}`);
     }
+  } finally {
+    releaseDaemonClaim?.();
   }
 }
 var init_serve2 = __esm({
@@ -766246,6 +766948,8 @@ function parseCliArgs(argv) {
       live: { type: "boolean" },
       json: { type: "boolean", short: "j" },
       background: { type: "boolean" },
+      daemon: { type: "boolean" },
+      quiet: { type: "boolean" },
       "self-test": { type: "string" },
       help: { type: "boolean", short: "h" },
       version: { type: "boolean", short: "V" }
@@ -766269,6 +766973,8 @@ function parseCliArgs(argv) {
     local: values.local === true,
     json: values.json === true,
     background: values.background === true,
+    daemon: values.daemon === true,
+    quiet: values.quiet === true,
     selfTest: typeof values["self-test"] === "string" ? values["self-test"] : void 0,
     help: values.help === true,
     version: values.version === true
@@ -766494,8 +767200,8 @@ async function main() {
             port: parsed.servePort,
             model: parsed.model,
             verbose: parsed.verbose,
-            daemon: process.env["OMNIUS_DAEMON"] === "1",
-            quiet: process.argv.includes("--quiet") || process.env["OMNIUS_DAEMON"] === "1"
+            daemon: parsed.daemon === true || process.env["OMNIUS_DAEMON"] === "1",
+            quiet: parsed.quiet === true || process.env["OMNIUS_DAEMON"] === "1"
           },
           config
         );