omnius 1.0.454 → 1.0.456

package/dist/index.js

@@ -14238,6 +14238,66 @@ function findMatchOffsets(haystack, needle) {
 function replaceAllOccurrences(haystack, needle, replacement) {
   return haystack.split(needle).join(replacement);
 }
+function buildMissingOldStringLlmContent(input) {
+  const lines = [
+    "[FILE_EDIT_OLD_STRING_NOT_FOUND]",
+    `path=${input.path}`,
+    "The attempted old_string was absent from the current file.",
+    "Do not copy diagnostic gutters into old_string. Ignore line numbers, leading '>' markers, and the '|' separator.",
+    "",
+    "attempted_old_string:",
+    fencedText(input.attemptedOldString)
+  ];
+  if (input.snippetContent) {
+    const range = input.snippetStartLine && input.snippetEndLine && input.totalLines ? `lines ${input.snippetStartLine}-${input.snippetEndLine} of ${input.totalLines}` : "closest current text";
+    lines.push("", `copyable_current_text_without_gutters (${range}):`, fencedText(stripDiagnosticGutters(input.snippetContent)), "", "Next action: build a new file_edit old_string only from the copyable_current_text_without_gutters block, or file_read the target if more context is needed.");
+  } else {
+    lines.push("", "Next action: file_read the target, then build old_string from exact current file content.");
+  }
+  lines.push("", "Do not use shell text-rewrite commands as a workaround for this edit failure; keep the change tracked through file_edit, batch_edit, file_patch, or file_write.");
+  if (input.newString.length > 0) {
+    lines.push("", "desired_new_string:", fencedText(input.newString));
+  }
+  return lines.join("\n");
+}
+function buildAmbiguousOldStringLlmContent(input) {
+  const replaceAllArgs = {
+    path: input.path,
+    old_string: input.oldString,
+    new_string: input.newString,
+    replace_all: true
+  };
+  return [
+    "[FILE_EDIT_AMBIGUOUS_OLD_STRING]",
+    `path=${input.path}`,
+    `old_string matched ${input.occurrences} locations at lines ${input.matchLines.join(", ")}.`,
+    "Do not retry the same old_string without either replace_all=true or additional unique surrounding context.",
+    "Do not copy diagnostic gutters into old_string. Ignore line numbers, leading '>' markers, and the '|' separator.",
+    "",
+    "valid_next_action_replace_all_if_every_match_should_change_identically:",
+    fencedJson(replaceAllArgs),
+    "",
+    "valid_next_action_single_location:",
+    "Use file_edit with an old_string that includes unique surrounding current file text from exactly one match below.",
+    "",
+    "copyable_match_contexts_without_gutters:",
+    fencedText(stripDiagnosticGutters(input.snippets).trim()),
+    "",
+    "Do not use shell text-rewrite commands as a workaround for this ambiguity; keep the change tracked through file_edit, batch_edit, file_patch, or file_write."
+  ].join("\n");
+}
+function stripDiagnosticGutters(text2) {
+  return text2.split("\n").map((line) => {
+    const match = line.match(/^[ >]\s*\d+\s\|\s?(.*)$/);
+    return match ? match[1] ?? "" : line;
+  }).join("\n");
+}
+function fencedText(value2) {
+  return ["```text", value2, "```"].join("\n");
+}
+function fencedJson(value2) {
+  return ["```json", JSON.stringify(value2, null, 2), "```"].join("\n");
+}
 var FileEditTool;
 var init_file_edit = __esm({
   "packages/execution/dist/tools/file-edit.js"() {
@@ -14394,6 +14454,15 @@ Use the EXACT current content above to construct a working old_string. Do not re
               success: false,
               output: "",
               error: errorMsg,
+              llmContent: buildMissingOldStringLlmContent({
+                path: filePath,
+                attemptedOldString: oldString,
+                newString,
+                snippetContent: snippet?.content ?? null,
+                snippetStartLine: snippet?.startLine ?? null,
+                snippetEndLine: snippet?.endLine ?? null,
+                totalLines: snippet?.totalLines ?? null
+              }),
               durationMs: performance.now() - start2,
               mutated: false,
               mutatedFiles: [],
@@ -14417,6 +14486,14 @@ ${s2.content}`;
 ${snippets}
 
 Add UNIQUE surrounding context (a function name, distinctive comment, or unique line above/below) to disambiguate. Or set replace_all=true if you want all ${occurrences} occurrences replaced identically.`,
+              llmContent: buildAmbiguousOldStringLlmContent({
+                path: filePath,
+                oldString,
+                newString,
+                occurrences,
+                matchLines,
+                snippets
+              }),
               durationMs: performance.now() - start2,
               mutated: false,
               mutatedFiles: [],
@@ -566026,12 +566103,12 @@ function buildCriticGuidanceMessage(call, hits, opts = {}) {
   const cached = opts.cachedResult ? `
 Prior evidence preview:
 ${opts.cachedResult.slice(0, 700)}` : "";
-  const source = opts.adversaryFlag ? "The adversary recognized this exact tool call as already observed earlier." : `This is exact repeat #${hits} for the same ${call.tool} arguments.`;
-  return `[ADVERSARY GUIDANCE — non-blocking]
+  const source = opts.adversaryFlag ? "The runtime recognized this exact tool call as already observed earlier." : `This is exact repeat #${hits} for the same ${call.tool} arguments.`;
+  return `[RUNTIME EVIDENCE CACHE — non-blocking]
 Observation: ${source}
 Call: ${call.tool}(${argPreview})
-Root cause hypothesis: the run is losing track of already-observed evidence, usually after path confusion, compaction, or an over-broad discovery loop.
-Corrective action: let this call's result inform the next step once, then pivot to a concrete action.
+State: exact prior evidence exists for these arguments in the current state version.
+Next action contract: let this result inform the next step once, then pivot to a concrete action.
 Suggested next actions: edit/write the implicated file, run verification, read a different specific file, or complete with evidence. Prefer not to repeat this exact call again unless the filesystem, browser, or page state changed.${cached}`;
 }
 function buildCachedResultEnvelope(result) {
@@ -570813,7 +570890,7 @@ ${fileLines}`);
         const counts = { ok: 0, failed: 0, blocked: 0 };
         for (const ev of events) {
           const preview = ev.outputPreview ?? "";
-          if (preview.includes("[FOCUS SUPERVISOR BLOCK]") || preview.includes("[STOP RE-RUNNING") || preview.includes("[REPEAT GATE")) {
+          if (preview.includes("[FOCUS SUPERVISOR BLOCK]") || preview.includes("[STOP RE-RUNNING") || preview.includes("[CACHED VERIFIER FAILURE") || preview.includes("[REPEAT GATE")) {
             counts.blocked++;
           } else if (ev.success === false) {
             counts.failed++;
@@ -573775,6 +573852,10 @@ function adversarySystemPrompt() {
   ].join("\n");
 }
 function buildObservationPrompt(obs, recentLedger) {
+  const stateDigest = obs.stateDigest ? `
+Runner world/progress digest:
+${obs.stateDigest.slice(0, 1800)}
+` : "";
   const outcomes = obs.recentToolOutcomes.slice(-8).map((o2) => {
     const target = o2.path ? ` path=${o2.path}` : "";
     const evidence = o2.evidence ? ` | evidence: ${o2.evidence.slice(0, 220)}` : "";
@@ -573788,6 +573869,8 @@ function buildObservationPrompt(obs, recentLedger) {
       `This is a loop. Reason about WHY — for THIS specific call, not generically.`,
       ls2.alreadyHave ? `Evidence the agent ALREADY obtained from a prior identical call:
 ${ls2.alreadyHave.slice(0, 900)}` : `(No cached result available for the repeated call.)`,
+      "",
+      stateDigest.trim(),
       "",
       "Agent's latest message:",
       obs.assistantText.slice(0, 1200) || "(empty)",
@@ -573809,6 +573892,8 @@ ${ls2.alreadyHave.slice(0, 900)}` : `(No cached result available for the repeate
       "",
       "A repeating identical error means the CHANGE ITSELF is wrong — an unsupported attribute/option, a wrong API/signature, or a missing prerequisite — NOT a value the agent hasn't guessed yet.",
       "",
+      stateDigest.trim(),
+      "",
       "Agent's latest message:",
       obs.assistantText.slice(0, 900) || "(empty)",
       "",
@@ -573819,12 +573904,32 @@ ${ls2.alreadyHave.slice(0, 900)}` : `(No cached result available for the repeate
       "Return ONLY the JSON object."
     ].join("\n");
   }
+  if (obs.diagnosticSignal) {
+    return [
+      `The runtime queued a diagnostic trigger: ${obs.diagnosticSignal}.`,
+      "This trigger is only a routing signal. Do NOT trust it as a verdict; classify from the world/progress digest and tool evidence.",
+      stateDigest.trim(),
+      "",
+      "Agent's latest message:",
+      obs.assistantText.slice(0, 1600) || "(empty)",
+      "",
+      "Recent tool outcomes:",
+      outcomes || "  (none)",
+      priorDoubts ? `
+Unresolved doubts you raised earlier:
+${priorDoubts}` : "",
+      "",
+      "Decide whether there is a real contradiction, stale-state action, unproven claim, or no issue. Return ONLY the JSON object."
+    ].filter((line) => line !== "").join("\n");
+  }
   return [
     obs.claimsCompletion ? "The agent is asserting COMPLETION this turn." : "The agent produced a progress/success-flavored claim this turn.",
     "",
     "Agent's latest message:",
     obs.assistantText.slice(0, 1800) || "(empty)",
     "",
+    stateDigest.trim(),
+    "",
     "Recent tool outcomes (evidence available):",
     outcomes || "  (none)",
     priorDoubts ? `
@@ -573959,14 +574064,16 @@ var init_adversaryStream = __esm({
           return true;
         if (obs.failingApproach)
           return true;
+        if (obs.diagnosticSignal)
+          return true;
         return SUCCESS_LANGUAGE.test(obs.assistantText);
       }
       /** Ingest an observation. Replaces any prior un-audited pending observation. */
       observe(obs) {
         if (!this.shouldAudit(obs))
           return;
-        const loopKey = obs.loopSignal ? `loop:${obs.loopSignal.tool}:${obs.loopSignal.target}:${obs.loopSignal.count}` : obs.failingApproach ? `fail:${obs.failingApproach.count}:${obs.failingApproach.sample.slice(0, 60)}` : "";
-        const sig = `${obs.turn}:${loopKey}:${obs.assistantText.slice(0, 200)}`;
+        const loopKey = obs.loopSignal ? `loop:${obs.loopSignal.tool}:${obs.loopSignal.target}:${obs.loopSignal.count}` : obs.failingApproach ? `fail:${obs.failingApproach.count}:${obs.failingApproach.sample.slice(0, 60)}` : obs.diagnosticSignal ? `diag:${obs.diagnosticSignal}` : "";
+        const sig = `${obs.turn}:${loopKey}:${obs.assistantText.slice(0, 200)}:${obs.stateDigest?.slice(0, 120) ?? ""}`;
         if (sig === this.lastAuditedSignature)
           return;
         this.pending = obs;
@@ -574783,8 +574890,13 @@ function violatesDirective(directive, input) {
   if (directive.requiredNextAction !== "update_todos") {
     if (directive.forbiddenActionFamilies.includes(family))
       return true;
-    if (directive.forbiddenActionFamilies.includes(input.toolName))
+    if (directive.forbiddenActionFamilies.includes(input.toolName)) {
+      if (input.toolName === "shell" && input.isReadLike)
+        return false;
+      if (input.toolName === "shell" && input.shellLikelyMutatesFilesystem)
+        return false;
       return true;
+    }
   }
   switch (directive.requiredNextAction) {
     case "update_todos":
@@ -574797,6 +574909,12 @@ function violatesDirective(directive, input) {
       return !(input.toolName === "todo_write" || isEditTool(input.toolName));
     case "read_authoritative_target":
       return !(isEvidenceGatheringTool(input.toolName) || input.isReadLike);
+    case "disambiguate_edit_match":
+      if (isEditTool(input.toolName))
+        return false;
+      if (isEvidenceGatheringTool(input.toolName) || input.isReadLike)
+        return false;
+      return true;
     case "run_verification":
       return input.toolName !== "shell";
     case "report_blocked":
@@ -574812,6 +574930,9 @@ function violatesDirective(directive, input) {
       return false;
   }
 }
+function forbiddenCachedEvidenceFamilies(input, family) {
+  return [family];
+}
 function normalizeCompletionStatus(value2) {
   if (typeof value2 !== "string")
     return null;
@@ -574874,7 +574995,7 @@ function cleanFailureSample(text2) {
 }
 function failureErrorClass(text2) {
   const normalized = String(text2 || "").toLowerCase();
-  if (/ambiguous|multiple occurrences|matches more than once/.test(normalized)) {
+  if (/ambiguous|not unique|multiple occurrences|matches more than once|found \d+ occurrences|has \d+ matches/.test(normalized)) {
     return "stale_ambiguous_target";
   }
   if (/expected[_ -]?hash|hash mismatch|stale hash|beforehash|afterhash/.test(normalized)) {
@@ -574928,13 +575049,15 @@ function editTargetDescriptor(toolName, args) {
     "expected_old_string",
     "expectedHash",
     "expected_hash",
+    "replace_all",
+    "replaceAll",
     "mode",
     "offset",
     "limit",
     "start_line"
   ]) {
     const value2 = args[key];
-    if (typeof value2 === "string" || typeof value2 === "number") {
+    if (typeof value2 === "string" || typeof value2 === "number" || typeof value2 === "boolean") {
       parts.push(`${key}=${String(value2)}`);
     }
   }
@@ -574946,7 +575069,8 @@ function editTargetDescriptor(toolName, args) {
       const rec = edit;
       const editPath = rec["path"] ?? rec["file"] ?? rec["filePath"] ?? rec["file_path"];
       const target = rec["old_string"] ?? rec["oldString"] ?? rec["oldText"] ?? rec["search"] ?? rec["expected_old_string"] ?? rec["offset"] ?? rec["start_line"] ?? "";
-      parts.push(`${String(editPath ?? "")}=${String(target ?? "")}`);
+      const replaceAll = rec["replace_all"] === true || rec["replaceAll"] === true;
+      parts.push(`${String(editPath ?? "")}=${String(target ?? "")}${replaceAll ? ":replace_all=true" : ""}`);
     }
   }
   if (parts.length === 0 && toolName === "file_patch") {
@@ -575141,7 +575265,7 @@ var init_focusSupervisor = __esm({
             state,
             reason: input.cachedResultFailed ? `cached failed ${input.toolName} evidence already exists` : `duplicate ${input.toolName} call has cached evidence`,
             requiredNextAction: "use_cached_evidence",
-            forbiddenActionFamilies: [family]
+            forbiddenActionFamilies: forbiddenCachedEvidenceFamilies(input, family)
           });
           if (strict && !advisoryOnly && (input.cachedResultFailed || duplicateHitCount >= hitLimit)) {
             return this.block(directive, [
@@ -575201,7 +575325,7 @@ var init_focusSupervisor = __esm({
           return;
         }
         if (input.toolName === "file_read" && input.success) {
-          if (this.directive?.requiredNextAction === "read_authoritative_target" || this.directive?.requiredNextAction === "use_cached_evidence") {
+          if (this.directive?.requiredNextAction === "read_authoritative_target") {
             this.clearSatisfiedDirective("authoritative evidence refreshed", input.turn);
           }
           return;
@@ -575209,8 +575333,10 @@ var init_focusSupervisor = __esm({
         if (input.toolName === "shell" && input.success) {
           if (this.directive?.requiredNextAction === "run_verification") {
             this.clearSatisfiedDirective("verification ran successfully", input.turn);
-          } else if (input.isReadLike && (this.directive?.requiredNextAction === "read_authoritative_target" || this.directive?.requiredNextAction === "use_cached_evidence")) {
+          } else if (input.isReadLike && this.directive?.requiredNextAction === "read_authoritative_target") {
             this.clearSatisfiedDirective("authoritative evidence read via shell", input.turn);
+          } else if (!input.isReadLike && this.directive?.requiredNextAction === "use_cached_evidence") {
+            this.clearSatisfiedDirective("distinct shell action executed after cached evidence", input.turn);
           }
           return;
         }
@@ -575226,26 +575352,29 @@ var init_focusSupervisor = __esm({
         };
         this.failureFamilies.set(family, next);
         if (next.count >= 2) {
+          const ambiguousEditFailure = isEditTool(input.toolName) && next.errorClass === "stale_ambiguous_target";
           const staleEditFailure = isEditTool(input.toolName) && next.errorClass.startsWith("stale_");
-          const forbidden = staleEditFailure ? uniqueLimited([
+          const forbidden = staleEditFailure ? ambiguousEditFailure ? [actionFamily(input.toolName, input.args)] : uniqueLimited([
             actionFamily(input.toolName, input.args),
             input.toolName
-          ]) : [actionFamily(input.toolName, input.args)];
+          ]) : input.toolName === "shell" ? [actionFamily(input.toolName, input.args)] : [actionFamily(input.toolName, input.args)];
           this.setDirective({
             turn: input.turn,
             state: "forced_replan",
             reason: `same ${input.toolName} failure family repeated ${next.count} times: ${next.sample}`,
-            requiredNextAction: staleEditFailure ? "read_authoritative_target" : input.toolName === "shell" ? "edit_different_target" : "update_todos",
+            requiredNextAction: ambiguousEditFailure ? "disambiguate_edit_match" : staleEditFailure ? "read_authoritative_target" : input.toolName === "shell" ? "use_cached_evidence" : "update_todos",
             forbiddenActionFamilies: forbidden
           });
         } else if (next.count === 1 && !this.directive) {
+          const ambiguousEditFailure = isEditTool(input.toolName) && next.errorClass === "stale_ambiguous_target";
           const staleEditFailure = isEditTool(input.toolName) && next.errorClass.startsWith("stale_");
+          const shellFailure = input.toolName === "shell";
           this.setDirective({
             turn: input.turn,
-            state: "warn",
+            state: shellFailure ? "cached_evidence" : "warn",
             reason: `first ${input.toolName} failure (${next.errorClass}): ${next.sample}`,
-            requiredNextAction: staleEditFailure ? "read_authoritative_target" : "update_todos",
-            forbiddenActionFamilies: [actionFamily(input.toolName, input.args)]
+            requiredNextAction: ambiguousEditFailure ? "disambiguate_edit_match" : staleEditFailure ? "read_authoritative_target" : shellFailure ? "use_cached_evidence" : "update_todos",
+            forbiddenActionFamilies: shellFailure ? [actionFamily(input.toolName, input.args)] : [actionFamily(input.toolName, input.args)]
           });
         }
       }
@@ -577767,6 +577896,15 @@ function formatTodoReminderItems(todos, maxRows) {
     rows.push(`... +${todos.length - rows.length} more`);
   return rows.join("\n");
 }
+function selectHeadTailLines(lines, headCount, tailCount) {
+  if (lines.length <= headCount + tailCount)
+    return lines;
+  return [
+    ...lines.slice(0, headCount),
+    `... [${lines.length - headCount - tailCount} middle line(s) omitted]`,
+    ...lines.slice(-tailCount)
+  ];
+}
 function stripThinkBlocks(s2) {
   if (!s2)
     return s2;
@@ -578918,8 +579056,11 @@ ${parts.join("\n")}
           case "update_todos":
             return "todo_write with a changed plan/status, or a real file edit if that is the active work";
           case "read_authoritative_target":
-          case "use_cached_evidence":
             return "use cached evidence or one authoritative file_read/read-only shell, then act";
+          case "use_cached_evidence":
+            return "do not rerun the blocked family; use the cached result to make a concrete edit, run a genuinely different diagnostic/verification command, or report incomplete";
+          case "disambiguate_edit_match":
+            return "file_edit or batch_edit with replace_all=true for identical global changes, or with a more unique old_string copied from current file context";
           case "edit_different_target":
             return "file_write, file_edit, batch_edit, or file_patch on a different supported target";
           case "run_verification":
@@ -582836,13 +582977,11 @@ ${contentPreview}
         for (const f2 of shown) {
           const argsRepr = JSON.stringify(f2.args).slice(0, 120);
           const failureText = [f2.error, f2.output].filter((v) => typeof v === "string" && v.trim().length > 0).join("\n");
-          const errFirst = failureText.split(/\n/)[0]?.slice(0, 200) || "(no error message)";
-          const errFull = failureText.slice(0, f2.tool === "file_edit" || f2.tool === "batch_edit" || f2.tool === "file_patch" ? 1200 : 600);
+          const excerpt = this._formatRecentFailureExcerpt(f2.tool, failureText);
           lines.push(`• turn ${f2.turn} — ${f2.tool}(${argsRepr})`);
-          lines.push(`  first line: ${errFirst}`);
-          if (errFull && errFull !== errFirst) {
-            const indented = errFull.split(/\n/).slice(0, 6).map((l2) => `    ${l2}`).join("\n");
-            lines.push(indented);
+          lines.push(`  first line: ${excerpt.firstLine}`);
+          if (excerpt.body) {
+            lines.push(excerpt.body);
           }
         }
         if (repeating.length > 0) {
@@ -582852,6 +582991,14 @@ ${contentPreview}
         lines.push(`(turn ${turn} — failures auto-expire after 10 turns; cleared on success or successful retry)`);
         return lines.join("\n");
       }
+      _formatRecentFailureExcerpt(tool, text2) {
+        const lines = String(text2 || "").replace(/\r/g, "").split("\n").map((line) => line.trimEnd());
+        const firstLine = lines.find((line) => line.trim().length > 0)?.slice(0, 220) || "(no error message)";
+        const maxChars = tool === "file_edit" || tool === "batch_edit" || tool === "file_patch" ? 1400 : tool === "shell" ? 2200 : 900;
+        const selected = tool === "shell" ? selectHeadTailLines(lines, 8, 14) : lines.slice(0, 8);
+        const body = selected.filter((line) => line.trim().length > 0).map((line) => `    ${line}`).join("\n").slice(0, maxChars);
+        return { firstLine, body };
+      }
       /**
        * Render a short, local-code-first nudge from the freshest failure signal.
        * This is intentionally not a web-search suggestion: most coding-agent loops
@@ -585487,16 +585634,14 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             cwd: this._workingDirectory || process.cwd(),
             model: this._backendModelLabel(this.backend),
             onCritique: (critique2, sourceTurn) => {
-              if (completed || this._completionIncompleteVerification || this.aborted) {
-                return;
-              }
-              if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
+              const runClosed = completed || this._completionIncompleteVerification || this.aborted;
+              if (!runClosed && (this._adversaryMode === "skillcoach" || this._adversaryMode === "both")) {
                 this.pendingUserMessages.push(AdversaryStream.formatInjection(critique2));
               }
               this.emit({
                 type: "adversary_reaction",
                 adversary: {
-                  class: critique2.class === "false_failure" ? "false_failure" : critique2.class === "false_success" ? "false_success" : "guidance",
+                  class: critique2.class === "ok" ? "guidance" : critique2.class,
                   shortText: critique2.shortText,
                   confidence: critique2.confidence,
                   details: AdversaryStream.formatInjection(critique2)
@@ -585517,6 +585662,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         this._argCohorts.clear();
         this._adversaryRedundantSignals.clear();
         this._adversaryRecentFlags.clear();
+        this._adversaryStateVersion = 0;
         this._lastTodoWriteTurn = -1;
         this._lastTodoReminderTurn = -1;
         let pendingConstraintWarnings = [];
@@ -588378,6 +588524,7 @@ Read the current file if needed, make a different concrete edit, or move to veri
               ].includes(tc.name);
               const isStatefulBrowserTool = this._isStatefulBrowserTool(tc.name);
               const isReadLike = !isStatefulBrowserTool && (baseIsReadLike || tc.name === "shell" && this._isShellCommandReadOnly(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? ""));
+              const shellLikelyMutatesFilesystem = tc.name === "shell" && this._shellCommandLikelyMutatesFilesystem(String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? ""));
               const adversaryRedundantSignal = this._adversaryRedundantSignals.has(toolFingerprint);
               if (adversaryRedundantSignal) {
                 this._adversaryRedundantSignals.delete(toolFingerprint);
@@ -588453,13 +588600,10 @@ Read the current file if needed, make a different concrete edit, or move to veri
                 }
                 criticGuidance = criticDecision.guidanceMessage;
                 this.emit({
-                  type: "adversary_reaction",
-                  adversary: {
-                    class: "guidance",
-                    shortText: `Adversary guidance for repeated ${tc.name} call`,
-                    confidence: 0.9,
-                    details: criticDecision.reason
-                  },
+                  type: "status",
+                  content: `Runtime cache guidance for repeated ${tc.name} call: ${criticDecision.reason}`,
+                  toolName: tc.name,
+                  turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 if (this._adversaryStream && criticDecision.hitNumber >= 2) {
@@ -588489,6 +588633,9 @@ Read the current file if needed, make a different concrete edit, or move to veri
                 const _repeatGateMax = this._resolveRepeatGateMax();
                 const isFailedShellRepeat = tc.name === "shell" && typeof _existingFp?.result === "string" && _existingFp.result.includes("status: failure");
                 const repeatGateEligible = isReadLike || tc.name === "memory_write" || isFailedShellRepeat;
+                const suppressSuccessfulShellCacheGuidance = tc.name === "shell" && !isFailedShellRepeat;
+                if (suppressSuccessfulShellCacheGuidance)
+                  criticGuidance = null;
                 if (isReadLike && this._evidenceLedger) {
                   const readArgs = tc.arguments;
                   const readPath2 = String(readArgs?.["path"] ?? readArgs?.["file"] ?? "");
@@ -588534,10 +588681,10 @@ Read the current file if needed, make a different concrete edit, or move to veri
                     const cachedResult = this.sanitizeCachedToolResult(tc.name, _existingFp.result);
                     repeatShortCircuit = isFailedShellRepeat ? {
                       success: false,
-                      output: `[STOP RE-RUNNING FAILED COMMAND — this exact shell command already failed and no real file mutation has invalidated that evidence. It was NOT executed again. Use the cached failure below to change approach, inspect a different target, or report incomplete.]
+                      output: `[CACHED VERIFIER FAILURE — this same shell command already produced debugging evidence and was not re-executed unchanged. Treat the cached transcript below as the current failure signal. Change the code/config, run a genuinely different verifier/diagnostic command, or report the blocker with this evidence.]
 
 ${cachedResult}`,
-                      error: "Repeated failing shell command was not re-executed.",
+                      error: "Cached verifier failure reused; command was not re-executed unchanged.",
                       runtimeAuthored: true
                     } : {
                       success: true,
@@ -588550,7 +588697,7 @@ ${cachedResult}`,
                 this.emit({
                   type: "status",
                   toolName: tc.name,
-                  content: repeatShortCircuit ? repeatShortCircuit.success ? `Exact repeat of ${tc.name} served from cache (hit #${criticDecision.hitNumber}); not re-executed` : `Exact repeat of ${tc.name} blocked after ${criticDecision.hitNumber} repeats; re-plan required` : `Adversary guidance emitted for ${tc.name}; tool call will still execute`,
+                  content: repeatShortCircuit ? repeatShortCircuit.success ? `Exact repeat of ${tc.name} served from cache (hit #${criticDecision.hitNumber}); not re-executed` : `Exact repeat of ${tc.name} blocked after ${criticDecision.hitNumber} repeats; re-plan required` : suppressSuccessfulShellCacheGuidance ? `Repeated successful shell command observed; re-executing because no state-independent verdict was made` : `Runtime cache guidance emitted for ${tc.name}; tool call will still execute`,
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -588564,6 +588711,7 @@ ${cachedResult}`,
                 completionStatus: completionStatusFromTaskCompleteArgs(tc.arguments),
                 fingerprint: toolFingerprint,
                 isReadLike,
+                shellLikelyMutatesFilesystem,
                 cachedResult: focusCachedEntry?.result,
                 cachedResultFailed: tc.name === "shell" && typeof focusCachedEntry?.result === "string" && focusCachedEntry.result.includes("status: failure"),
                 duplicateHitCount: focusDuplicateHits,
@@ -588831,7 +588979,11 @@ Respond with EXACTLY this structure before your next tool call:
               }
               const shellFilesystemMutation = tc.name === "shell" && result.success === true && this._shellCommandLikelyMutatesFilesystem(String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? ""));
               const realFileMutation = this._isRealProjectMutation(tc.name, result);
+              const observedStateMutation = realFileMutation || shellFilesystemMutation || result.success === true && result.mutated === true;
               const realMutationPaths = realFileMutation ? this._extractToolTargetPaths(tc.name, tc.arguments, result) : [];
+              if (observedStateMutation) {
+                this._markAdversaryObservedStateMutation();
+              }
               if (realFileMutation && this._reg61PerpetualGateActive) {
                 this._reg61PerpetualGateActive = false;
                 this.emit({
@@ -589671,8 +589823,10 @@ Respond with EXACTLY this structure before your next tool call:
               }
               if (isFileMutation && recentToolResults.size > 0) {
                 for (const key of Array.from(recentToolResults.keys())) {
-                  if (key.startsWith("shell:"))
+                  if (key.startsWith("shell:")) {
                     recentToolResults.delete(key);
+                    dedupHitCount.delete(key);
+                  }
                 }
               }
               if (isFileMutation) {
@@ -589712,7 +589866,7 @@ Respond with EXACTLY this structure before your next tool call:
                   fingerprint: toolFingerprint,
                   args: tc.arguments,
                   error: (result.error ?? "").slice(0, 600),
-                  output: (result.output ?? "").slice(0, 1500),
+                  output: (result.output ?? "").slice(0, tc.name === "shell" ? 4e3 : 1500),
                   turn
                 });
                 if (this._recentFailures.length > 8) {
@@ -593081,7 +593235,18 @@ ${folded}`);
       buildRecoveryGuidance(toolName, error, args) {
         const errLower = error.toLowerCase();
         if (toolName === "file_edit" || toolName === "batch_edit") {
-          if (errLower.includes("not found") || errLower.includes("old_string") || errLower.includes("no match")) {
+          if (/ambiguous|not unique|multiple occurrences|matches more than once|found \d+ occurrences|has \d+ matches/.test(errLower)) {
+            if (toolName === "batch_edit") {
+              return `[RECOVERY] batch_edit failed because at least one old_string matched multiple locations.
+ACTION: retry the affected edit with replace_all=true if every match should change identically, or add unique surrounding current file text to that edit's old_string if only one location should change. Do not switch to shell sed/perl/python rewrites.`;
+            }
+            const filePath = String(args["path"] ?? "the file");
+            const oldStr = String(args["old_string"] ?? "").slice(0, 120);
+            return `[RECOVERY] file_edit failed because old_string is ambiguous in ${filePath}.
+Attempted old_string preview: "${oldStr}".
+ACTION: retry file_edit with replace_all=true if every match should change identically, or use an old_string containing unique surrounding current file text for exactly one location. Do not retry the same old_string without replace_all, and do not switch to shell sed/perl/python rewrites.`;
+          }
+          if (errLower.includes("not found") || errLower.includes("no match") || errLower.includes("no occurrences") || errLower.includes("0 occurrences") || errLower.includes("could not find")) {
             if (toolName === "batch_edit") {
               const edits = Array.isArray(args["edits"]) ? args["edits"] : [];
               const filePaths = [
@@ -594354,6 +594519,10 @@ ${trimmedNew}`;
       // we add a second analysis path that catches mismatches in real-time.
       /** Track recent tool outcomes for the adversary */
       _adversaryToolOutcomes = [];
+      /** Monotonic counter for observed local state changes.
+       *  Redundant-action classification is only valid within the same state
+       *  version; a repeated verifier after an edit is fresh evidence. */
+      _adversaryStateVersion = 0;
       /** WO-FIX-C: Tool fingerprints the adversary has flagged as redundant.
        *  Checked in executeSingle to attach advisory guidance before dispatch. */
       _adversaryRedundantSignals = /* @__PURE__ */ new Set();
@@ -594368,6 +594537,59 @@ ${trimmedNew}`;
        *  Generates typed self-reflections on task failure and injects them
        *  into the next attempt's context for active learning. */
       _reflectionBuffer = null;
+      _markAdversaryObservedStateMutation() {
+        this._adversaryStateVersion++;
+        this._adversaryRedundantSignals.clear();
+        for (const key of Array.from(this._adversaryRecentFlags.keys())) {
+          if (key.startsWith("redundant_action:")) {
+            this._adversaryRecentFlags.delete(key);
+          }
+        }
+      }
+      _buildAdversaryStateDigest(turn) {
+        const ts = this._taskState;
+        let todos = [];
+        try {
+          todos = this.readSessionTodos() ?? [];
+        } catch {
+          todos = [];
+        }
+        const todoCounts = {
+          completed: todos.filter((t2) => t2.status === "completed").length,
+          inProgress: todos.filter((t2) => t2.status === "in_progress").length,
+          pending: todos.filter((t2) => t2.status === "pending").length,
+          blocked: todos.filter((t2) => t2.status === "blocked").length
+        };
+        const activeTodos = todos.filter((t2) => t2.status === "in_progress" || t2.status === "blocked").slice(0, 4).map((t2) => `[${t2.status}] ${String(t2.content ?? "").slice(0, 120)}`);
+        const modifiedFiles = [...ts.modifiedFiles.entries()].slice(-10).map(([path12, action]) => `${action}:${path12}`);
+        const worldFiles = [...this._worldFacts.files.entries()].sort((a2, b) => (b[1].lastSeenTurn ?? 0) - (a2[1].lastSeenTurn ?? 0)).slice(0, 8).map(([path12, fact]) => {
+          const write2 = fact.lastWriteTurn ? ` write@${fact.lastWriteTurn}` : "";
+          const seen = `seen@${fact.lastSeenTurn}`;
+          const wc = fact.writeCount ? ` writes=${fact.writeCount}` : "";
+          return `${path12} (${seen}${write2}${wc})`;
+        });
+        const recentFailures = this._recentFailures.slice(-5).map((failure) => {
+          const text2 = (failure.error || failure.output || "").replace(/\s+/g, " ").trim().slice(0, 180);
+          return `${failure.tool}: ${text2}`;
+        });
+        const focus = this._focusSupervisor?.snapshot().directive;
+        const lines = [
+          `[WORLD STATE SUMMARY] turn=${turn} state_version=${this._adversaryStateVersion}`,
+          `goal=${(ts.originalGoal || ts.goal || "").slice(0, 260)}`,
+          `phase=${ts.phase ?? "unknown"} current_step=${(ts.currentStep || "none").slice(0, 180)}`,
+          ts.nextAction ? `next_action=${ts.nextAction.slice(0, 180)}` : "",
+          `progress=todos completed:${todoCounts.completed} in_progress:${todoCounts.inProgress} pending:${todoCounts.pending} blocked:${todoCounts.blocked}; completed_steps:${ts.completedSteps.length}; failed_approaches:${ts.failedApproaches.length}; modified_files:${ts.modifiedFiles.size}; tool_calls:${ts.toolCallCount}`,
+          activeTodos.length ? `active_todos=${activeTodos.join(" | ")}` : "",
+          ts.completedSteps.length ? `recent_completed=${ts.completedSteps.slice(-5).join(" | ").slice(0, 500)}` : "",
+          ts.failedApproaches.length ? `recent_failed_approaches=${ts.failedApproaches.slice(-4).join(" | ").slice(0, 500)}` : "",
+          modifiedFiles.length ? `modified_files_recent=${modifiedFiles.join(" | ").slice(0, 700)}` : "",
+          worldFiles.length ? `world_files_recent=${worldFiles.join(" | ").slice(0, 700)}` : "",
+          this._worldFacts.lastTest.summary ? `last_verification=${this._worldFacts.lastTest.passed ? "passed" : "failed"} turn=${this._worldFacts.lastTest.turn ?? "?"}: ${this._worldFacts.lastTest.summary.slice(0, 260)}` : "",
+          recentFailures.length ? `recent_failures=${recentFailures.join(" | ").slice(0, 700)}` : "",
+          focus ? `focus=${focus.requiredNextAction}: ${focus.reason.slice(0, 240)}` : ""
+        ].filter(Boolean);
+        return lines.join("\n").slice(0, 2600);
+      }
       buildAdversaryToolOutcomeEvidence(toolName, toolArgs, content, succeeded) {
         const pathValue = toolArgs?.["path"] ?? toolArgs?.["file"] ?? toolArgs?.["filePath"] ?? toolArgs?.["file_path"];
         const path12 = typeof pathValue === "string" && pathValue.trim() ? pathValue.trim() : void 0;
@@ -594451,6 +594673,7 @@ ${trimmedNew}`;
                 toolCallId: msg.tool_call_id,
                 argsKey,
                 fingerprint,
+                stateVersion: this._adversaryStateVersion,
                 succeeded,
                 ...outcomeEvidence
               });
@@ -594459,136 +594682,66 @@ ${trimmedNew}`;
         }
         while (this._adversaryToolOutcomes.length > 20)
           this._adversaryToolOutcomes.shift();
-        if (this._adversaryStream && !this._completionIncompleteVerification) {
-          const lastAssistantMsg = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
-          const assistantText = typeof lastAssistantMsg?.content === "string" ? lastAssistantMsg.content.replace(/<think>[\s\S]*?<\/think>/g, "").trim() : "";
-          if (assistantText) {
-            const claimsCompletion = /task.?complete|all tests pass|\bdone\b|\bcomplete(d)?\b/i.test(assistantText);
-            this._adversaryStream.observe({
-              turn,
-              assistantText,
-              recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({
-                tool: o2.tool,
-                succeeded: o2.succeeded,
-                preview: o2.preview,
-                path: o2.path,
-                evidence: o2.evidence
-              })),
-              claimsCompletion
-            });
-            void this._adversaryStream.tick().catch(() => {
-            });
-          }
-        }
-        for (const [key, val] of this._adversaryRecentFlags) {
-          if (turn - val.lastTurn > _AgenticRunner.ADVERSARY_FLAG_TTL)
-            this._adversaryRecentFlags.delete(key);
-        }
-        const adversaryFlag = (flagKey, messages3) => {
-          const existing = this._adversaryRecentFlags.get(flagKey);
-          if (existing) {
-            existing.count++;
-            existing.lastTurn = turn;
-            if (existing.count >= _AgenticRunner.ADVERSARY_ESCALATE_THRESHOLD) {
-              return "escalate";
-            }
-            return "suppress";
-          }
-          this._adversaryRecentFlags.set(flagKey, { count: 1, lastTurn: turn });
-          return "proceed";
-        };
-        const emitReaction = (cls, shortText, confidence2, details2) => {
+        const stateDigest = this._buildAdversaryStateDigest(turn);
+        const recentToolOutcomes = this._adversaryToolOutcomes.slice(-8).map((o2) => ({
+          tool: o2.tool,
+          succeeded: o2.succeeded,
+          preview: o2.preview,
+          path: o2.path,
+          evidence: o2.evidence
+        }));
+        const queueAdversaryAudit = (input, reason) => {
+          if (!this._adversaryStream || this._completionIncompleteVerification)
+            return;
+          const observation = {
+            turn,
+            recentToolOutcomes,
+            stateDigest,
+            ...input
+          };
+          if (!this._adversaryStream.shouldAudit(observation))
+            return;
+          this._adversaryStream.observe(observation);
+          void this._adversaryStream.tick().catch(() => {
+          });
           this.emit({
-            type: "adversary_reaction",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            adversary: { class: cls, shortText, confidence: confidence2, details: details2 }
+            type: "status",
+            content: `Adversary inference queued: ${reason}`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
         };
-        const buildAdversaryCritique = (input) => {
-          const alternatives = input.alternatives && input.alternatives.length > 0 ? `
-Alternatives:
-${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
-          return [
-            `[ADVERSARY CRITIQUE — non-blocking]`,
-            `Evidence: ${input.evidence}`,
-            `Root cause hypothesis: ${input.hypothesis}`,
-            `Corrective action: ${input.correctiveAction}${alternatives}`
-          ].join("\n");
-        };
         const lastAssistant = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
         if (lastAssistant && typeof lastAssistant.content === "string") {
-          const text2 = lastAssistant.content.toLowerCase();
+          const assistantText = lastAssistant.content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+          const text2 = assistantText.toLowerCase();
+          const claimsCompletion = /task.?complete|all tests pass|\bdone\b|\bcomplete(d)?\b/i.test(text2);
+          queueAdversaryAudit({
+            assistantText,
+            claimsCompletion
+          }, claimsCompletion ? "completion/progress claim" : "success-language audit");
           const claimsFailure = /(?:fail|error|didn't work|not working|unable to|cannot|couldn't|both .* fail|tools? (?:have |has )?been fail)/i.test(text2);
           if (claimsFailure) {
             const recentOutcomes = this._adversaryToolOutcomes.slice(-4);
             const successes = recentOutcomes.filter((o2) => o2.succeeded);
             if (successes.length >= 1) {
-              const successList = successes.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
-              const ffFlag = adversaryFlag("false_failure", messages2);
-              if (ffFlag !== "suppress") {
-                const critiqueText = buildAdversaryCritique({
-                  evidence: `Recent tools succeeded: ${successList}.`,
-                  hypothesis: "The main loop is interpreting uncertainty or partial progress as failure and may be about to discard usable evidence.",
-                  correctiveAction: "Use the successful results to advance the task, then verify the next concrete step.",
-                  alternatives: [
-                    "Edit or run the next verification step that follows from the successful output.",
-                    "Read a different targeted file if the successful result exposed a new path or symbol.",
-                    "Complete only if the successful output is sufficient evidence for the user's request."
-                  ]
-                });
-                emitReaction("false_failure", `Claimed failure, but recent tools succeeded (${successes.length})`, 0.9, successList);
-                if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
-                  if (ffFlag === "escalate") {
-                    messages2.push({
-                      role: "system",
-                      content: critiqueText + "\n[ESCALATED: This warning was previously issued without effect.]"
-                    });
-                  } else {
-                    this.pendingUserMessages.push(critiqueText);
-                  }
-                }
-                this.emit({
-                  type: "status",
-                  content: `\x1B[38;5;178m⚠ Corrected false failure claim (${successes.length} tools succeeded)\x1B[0m`,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-              }
+              queueAdversaryAudit({
+                assistantText,
+                claimsCompletion: false,
+                diagnosticSignal: "possible_false_failure"
+              }, `possible false-failure claim after ${successes.length} successful tool outcome(s)`);
             }
           }
-        }
-        if (lastAssistant && typeof lastAssistant.content === "string") {
-          const text2 = lastAssistant.content.toLowerCase();
           const claimsSuccess = /(done|fixed|success|passed|complete)/i.test(text2);
           if (claimsSuccess) {
             const recentOutcomes = this._adversaryToolOutcomes.slice(-4);
             const failures = recentOutcomes.filter((o2) => !o2.succeeded);
-            const successes = recentOutcomes.filter((o2) => o2.succeeded);
-            if (failures.length > 0 && successes.length === 0) {
-              const failList = failures.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
-              const fsFlag = adversaryFlag("false_success", messages2);
-              if (fsFlag !== "suppress") {
-                const critiqueText = buildAdversaryCritique({
-                  evidence: `Recent tools show errors (${failures.length}): ${failList}.`,
-                  hypothesis: "The main loop is prematurely compressing intent into success language before the verifier produced evidence.",
-                  correctiveAction: "Inspect the failed output, identify the implicated path/symbol/command, and run one focused corrective step before claiming success.",
-                  alternatives: [
-                    "Read the smallest relevant source region around the failed symbol.",
-                    "Patch the implicated code or configuration.",
-                    "Run the same verifier only after a state-changing fix."
-                  ]
-                });
-                emitReaction("false_success", `Claimed success, but recent tools failed (${failures.length})`, 0.9, failList);
-                if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
-                  if (fsFlag === "escalate") {
-                    messages2.push({
-                      role: "system",
-                      content: critiqueText + "\n[ESCALATED: This warning was previously issued without effect.]"
-                    });
-                  } else {
-                    this.pendingUserMessages.push(critiqueText);
-                  }
-                }
-              }
+            if (failures.length > 0) {
+              queueAdversaryAudit({
+                assistantText,
+                claimsCompletion,
+                diagnosticSignal: "possible_false_success"
+              }, `possible false-success claim near ${failures.length} recent failure(s)`);
             }
           }
         }
@@ -594606,38 +594759,20 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
             }
             const argsKey = this._buildExactArgsKey(args);
             const fingerprint = this._buildToolFingerprint(name10, args);
-            const prior = this._adversaryToolOutcomes.find((o2) => o2.succeeded && o2.tool === name10 && o2.fingerprint === fingerprint && o2.turn < turn);
+            const prior = this._adversaryToolOutcomes.find((o2) => o2.succeeded && o2.tool === name10 && o2.fingerprint === fingerprint && o2.stateVersion === this._adversaryStateVersion && o2.turn < turn);
             if (prior) {
-              this._adversaryRedundantSignals.add(fingerprint);
-              const raFlag = adversaryFlag(`redundant_action:${fingerprint}`, messages2);
-              if (raFlag !== "suppress") {
-                const critiqueText = buildAdversaryCritique({
-                  evidence: `${name10} already succeeded on turn ${prior.turn} with exact arguments (${argsKey.slice(0, 120)}). Prior preview: ${prior.preview}`,
-                  hypothesis: "The main loop may have lost track of previously observed evidence because of context pressure, path confusion, or repeated discovery.",
-                  correctiveAction: "Let this duplicate run execute if needed, but treat the prior result as evidence and pivot afterward unless state has changed.",
-                  alternatives: [
-                    "Use the prior result to edit/write, verify, or finish with evidence.",
-                    "Read a different specific file or selector if the current evidence is insufficient.",
-                    "Repeat exact arguments only when filesystem, browser, or page state changed."
-                  ]
-                });
-                emitReaction("redundant_action", `Already ran ${name10} successfully on turn ${prior.turn}`, 0.8, prior.preview);
-                if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
-                  if (raFlag === "escalate") {
-                    messages2.push({
-                      role: "system",
-                      content: critiqueText + "\n[ESCALATED: This redundant-action warning was issued 3+ times as a user message without effect.]"
-                    });
-                  } else {
-                    this.pendingUserMessages.push(critiqueText);
-                  }
-                }
-                this.emit({
-                  type: "status",
-                  content: `\x1B[38;5;178m⚠ Adversary noted redundant ${name10} call (succeeded on turn ${prior.turn}); action remains allowed\x1B[0m`,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-              }
+              const repeatCount = this._adversaryToolOutcomes.filter((o2) => o2.tool === name10 && o2.fingerprint === fingerprint && o2.stateVersion === this._adversaryStateVersion && o2.turn < turn).length + 1;
+              queueAdversaryAudit({
+                assistantText: "",
+                claimsCompletion: false,
+                diagnosticSignal: "possible_repeated_action",
+                loopSignal: {
+                  tool: name10,
+                  target: argsKey.slice(0, 180),
+                  count: repeatCount,
+                  alreadyHave: prior.preview
+                }
+              }, `possible repeated action ${name10} after prior same-state success`);
               break;
             }
           }
@@ -594655,35 +594790,11 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
               }
             }
             if (consecutiveShortResults >= 3) {
-              const itFlag = adversaryFlag("idle_think", messages2);
-              if (itFlag !== "suppress") {
-                const critiqueText = buildAdversaryCritique({
-                  evidence: `${consecutiveShortResults} consecutive output-like calls occurred without an input-like observation.`,
-                  hypothesis: "The loop may be acting from stale state instead of re-observing the environment.",
-                  correctiveAction: "Take one input/observation step before another output step.",
-                  alternatives: [
-                    "Call the input/listen/poll tool for the current environment.",
-                    "Read the current UI/page state before clicking or typing again.",
-                    "If the task is already complete, finish with the concrete evidence already observed."
-                  ]
-                });
-                emitReaction("idle_think", `Consecutive output without input: ${consecutiveShortResults}`, 0.7);
-                if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
-                  if (itFlag === "escalate") {
-                    messages2.push({
-                      role: "system",
-                      content: critiqueText + "\n[ESCALATED: This warning was previously issued without effect.]"
-                    });
-                  } else {
-                    this.pendingUserMessages.push(critiqueText);
-                  }
-                }
-                this.emit({
-                  type: "status",
-                  content: `\x1B[38;5;178m⚠ Adversary flagged runaway-output risk (${consecutiveShortResults} consecutive sends without receive); action remains allowed\x1B[0m`,
-                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                });
-              }
+              queueAdversaryAudit({
+                assistantText: "",
+                claimsCompletion: false,
+                diagnosticSignal: "possible_stale_output"
+              }, `possible stale-output loop (${consecutiveShortResults} short successful outcomes)`);
             }
           }
         }
@@ -594691,6 +594802,8 @@ ${input.alternatives.map((item) => `- ${item}`).join("\n")}` : "";
         const failCount = this._adversaryToolOutcomes.filter((o2) => !o2.succeeded).length;
         const lastFour = this._adversaryToolOutcomes.slice(-4);
         const details = [
+          stateDigest,
+          ``,
           `Recent tool outcomes:`,
           ...lastFour.map((o2) => `- ${o2.tool}: ${o2.succeeded ? "OK" : "ERR"} — ${o2.preview}`)
         ].join("\n");

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.454",
+  "version": "1.0.456",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.454",
+      "version": "1.0.456",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.454",
+  "version": "1.0.456",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",