omnius 1.0.534 → 1.0.536

package/dist/index.js

@@ -6981,14 +6981,14 @@ var init_file_write = __esm({
     init_text_encoding();
     FileWriteTool = class {
       name = "file_write";
-      description = "Write UTF-8 text to a file, creating directories as needed. For content with heavy quoting, raw JSON, control characters, or large full-file payloads, pass content_base64 instead of shell heredocs/cat/tee.";
+      description = "Create new files or deliberately replace small, empty, or placeholder files; use file_edit/file_patch for local changes. For content with heavy quoting, raw JSON, control characters, or large full-file payloads, pass content_base64 instead of shell heredocs/cat/tee.";
       parameters = {
         type: "object",
         properties: {
           path: { type: "string", description: "Absolute or relative file path" },
           content: {
             type: "string",
-            description: "UTF-8 text content to write. Use content_base64 when JSON escaping is fragile."
+            description: "Complete UTF-8 file content. Do not send an existing large file merely to change one region; use file_edit/file_patch."
           },
           content_base64: {
             type: "string",
@@ -567114,13 +567114,103 @@ function normalizeShellCommand(command) {
 function splitConjunctiveVerifyCommand(command) {
   return normalizeShellCommand(command).split(/\s+&&\s+/).map((part) => part.trim()).filter(Boolean);
 }
+function stripVerifierFallbackSuffix(command) {
+  let quote2 = null;
+  for (let i2 = 0; i2 < command.length - 1; i2++) {
+    const ch = command[i2];
+    if (quote2) {
+      if (ch === quote2 && command[i2 - 1] !== "\\")
+        quote2 = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote2 = ch;
+      continue;
+    }
+    if (ch === "|" && command[i2 + 1] === "|") {
+      return command.slice(0, i2).trim();
+    }
+  }
+  return command.trim();
+}
+function stageHeadProgram(stage2) {
+  const tokens = stage2.trim().split(/\s+/);
+  let i2 = 0;
+  while (i2 < tokens.length) {
+    const token = tokens[i2];
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(token)) {
+      i2++;
+      continue;
+    }
+    const base3 = token.replace(/^["']|["']$/g, "").split("/").pop() ?? token;
+    if (STAGE_PREFIX_PROGRAMS.has(base3)) {
+      i2++;
+      if (base3 === "timeout" && /^[0-9]+[smhd]?$/.test(tokens[i2] ?? ""))
+        i2++;
+      continue;
+    }
+    return base3.toLowerCase();
+  }
+  return null;
+}
+function commandIsPureReadOnlyPipeline(command) {
+  const stages = [];
+  let current = "";
+  let quote2 = null;
+  const raw = command.trim();
+  if (!raw)
+    return false;
+  for (let i2 = 0; i2 < raw.length; i2++) {
+    const ch = raw[i2];
+    if (quote2) {
+      current += ch;
+      if (ch === quote2 && raw[i2 - 1] !== "\\")
+        quote2 = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote2 = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "&" && raw[i2 + 1] === "&") {
+      stages.push(current);
+      current = "";
+      i2++;
+      continue;
+    }
+    if (ch === "|") {
+      stages.push(current);
+      current = "";
+      if (raw[i2 + 1] === "|")
+        i2++;
+      continue;
+    }
+    if (ch === ";") {
+      stages.push(current);
+      current = "";
+      continue;
+    }
+    if (ch === "$" && raw[i2 + 1] === "(")
+      return false;
+    if (ch === "`")
+      return false;
+    current += ch;
+  }
+  stages.push(current);
+  const meaningful = stages.map((s2) => s2.trim()).filter(Boolean);
+  if (meaningful.length === 0)
+    return false;
+  return meaningful.every((stage2) => {
+    const head = stageHeadProgram(stage2);
+    return head !== null && PURE_READER_PROGRAMS.has(head);
+  });
+}
 function commandReliablySatisfiesVerifyCommand(observedCommand, verifyCommand) {
   const observed = normalizeShellCommand(observedCommand);
-  const expected = normalizeShellCommand(verifyCommand);
+  const expected = normalizeShellCommand(stripVerifierFallbackSuffix(verifyCommand));
   if (!observed || !expected)
     return false;
-  if (expected.includes(" || "))
-    return false;
   if (observed === expected)
     return true;
   if (observed.startsWith(`${expected} && `) && !observed.includes(" || ")) {
@@ -567141,9 +567231,93 @@ function verifyCommandSatisfiedByShellHistory(verifyCommand, history) {
     return false;
   return parts.every((part) => successful.some((entry) => commandReliablySatisfiesVerifyCommand(entry.command, part)));
 }
+var PURE_READER_PROGRAMS, STAGE_PREFIX_PROGRAMS;
 var init_verificationCommand = __esm({
   "packages/orchestrator/dist/verificationCommand.js"() {
     "use strict";
+    PURE_READER_PROGRAMS = /* @__PURE__ */ new Set([
+      "cat",
+      "tac",
+      "tail",
+      "head",
+      "less",
+      "more",
+      "grep",
+      "egrep",
+      "fgrep",
+      "rg",
+      "ag",
+      "awk",
+      "gawk",
+      "sed",
+      "gsed",
+      "sort",
+      "uniq",
+      "wc",
+      "cut",
+      "tr",
+      "column",
+      "echo",
+      "printf",
+      "ls",
+      "dir",
+      "find",
+      "fd",
+      "stat",
+      "file",
+      "strings",
+      "hexdump",
+      "xxd",
+      "od",
+      "jq",
+      "yq",
+      "tee",
+      "dirname",
+      "basename",
+      "readlink",
+      "realpath",
+      "pwd",
+      "date",
+      "true",
+      "false",
+      "test",
+      "type",
+      "which",
+      "whoami",
+      "env",
+      "printenv",
+      "sleep",
+      "cd",
+      "diff",
+      "cmp",
+      "md5sum",
+      "sha1sum",
+      "sha256sum",
+      "du",
+      "df",
+      "nl",
+      "paste",
+      "join",
+      "comm",
+      "expand",
+      "unexpand",
+      "fold",
+      "rev",
+      "seq",
+      "xargs"
+    ]);
+    STAGE_PREFIX_PROGRAMS = /* @__PURE__ */ new Set([
+      "sudo",
+      "command",
+      "builtin",
+      "nice",
+      "ionice",
+      "time",
+      "timeout",
+      "nohup",
+      "stdbuf",
+      "unbuffer"
+    ]);
   }
 });
 
@@ -569322,11 +569496,6 @@ var init_personality = __esm({
 // packages/orchestrator/dist/critic.js
 function buildCriticGuidanceMessage(call, hits, opts = {}) {
   const argPreview = JSON.stringify(call.args ?? {}).slice(0, 200);
-  const actionReason = call.actionReason ? [
-    call.actionReason.scope ? `scope=${call.actionReason.scope}` : "",
-    call.actionReason.intent ? `intent=${call.actionReason.intent}` : "",
-    call.actionReason.evidence ? `evidence=${call.actionReason.evidence}` : ""
-  ].filter(Boolean).join("; ").slice(0, 500) : "";
   const cached = opts.cachedResult ? `
 Prior evidence preview:
 ${opts.cachedResult.slice(0, 700)}` : "";
@@ -569334,8 +569503,7 @@ ${opts.cachedResult.slice(0, 700)}` : "";
   return `[RUNTIME EVIDENCE CACHE — non-blocking]
 Observation: ${source}
 Call: ${call.tool}(${argPreview})
-` + (actionReason ? `Action reason: ${actionReason}
-` : "") + `State: exact prior evidence exists for these arguments in the current state version.
+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}`;
 }
@@ -569344,10 +569512,13 @@ function buildCachedResultEnvelope(result) {
 ${result}`;
 }
 function evaluate2(inputs) {
-  const { proposedCall, fingerprint, isReadLike, recentToolResults, dedupHitCount, adversaryRedundantSignal } = inputs;
-  if (adversaryRedundantSignal) {
+  const { proposedCall, fingerprint, recentToolResults, dedupHitCount, adversaryRedundantSignal } = inputs;
+  const cacheEligible = proposedCall.tool === "memory_write" || NOOP_WRITE_CACHE_TOOLS.has(proposedCall.tool);
+  if (adversaryRedundantSignal && cacheEligible) {
     const cached = recentToolResults.get(fingerprint);
-    const cachedResult = cached ? buildCachedResultEnvelope(cached.result) : void 0;
+    if (!cached)
+      return { decision: "pass" };
+    const cachedResult = buildCachedResultEnvelope(cached.result);
     return {
       decision: "guidance",
       reason: "Adversary flagged this fingerprint as redundant",
@@ -569360,7 +569531,6 @@ function evaluate2(inputs) {
       compacted: cached?.compacted
     };
   }
-  const cacheEligible = isReadLike || proposedCall.tool === "shell" || proposedCall.tool === "memory_write" || NOOP_WRITE_CACHE_TOOLS.has(proposedCall.tool);
   if (cacheEligible) {
     const cached = recentToolResults.get(fingerprint);
     if (cached !== void 0) {
@@ -573004,13 +573174,13 @@ var init_reflectionBuffer = __esm({
           case "tool_misuse":
             return {
               whatFailed: `Wrong tool or arguments for the task. Tool ${lastFailedTool?.tool ?? "unknown"} failed: ${lastFailedTool?.error?.slice(0, 60) ?? lastError.slice(0, 60)}`,
-              whatToDoDifferently: `Try a different tool. If file_edit failed, try file_write. If shell failed with a complex command, break it into simpler steps. Read the file first before editing.`,
+              whatToDoDifferently: `Correct the tool contract without broadening mutation scope. If file_edit failed, read the current target and use exact text or a line-range file_patch; do not fall back to file_write. If shell failed with a complex command, break it into simpler diagnostic steps.`,
               confidence: 0.8
             };
           case "repetition":
             return {
               whatFailed: `Got stuck in a loop after ${turnsSpent} turns trying ${failedApproaches.length} approaches. The same tools kept failing with similar errors.`,
-              whatToDoDifferently: "Stop and try a completely different strategy. If you were editing, try rewriting from scratch. If searching failed, try a broader or narrower query. Ask yourself: what assumption am I making that might be wrong?",
+              whatToDoDifferently: "Stop and change the diagnosis, not the mutation radius. If you were editing, refresh the implicated range and patch only the verified fault; never rewrite an existing file from scratch as loop recovery. If searching failed, try a broader or narrower query. Ask which assumption is wrong.",
               confidence: 0.9
             };
           case "timeout":
@@ -576293,9 +576463,6 @@ function classifyFailureKind(text2, args) {
   }
   if (/Unknown tool\b|Unknown tool ['"`]/i.test(text2))
     return "missing_tool";
-  if (/\[TOOL ACTION REASON CONTRACT\]|must include action_reason|action_reason must/i.test(text2)) {
-    return "action_reason_missing";
-  }
   if (/\bexpected_hash\b|hash mismatch|fresh file_read|stale edit|stale target|FULL FILE REWRITE CONTRACT|old_string (?:not found|does not match|must be unique|appears \d+)/i.test(text2)) {
     return "stale_hash";
   }
@@ -576536,16 +576703,6 @@ var init_failure_taxonomy = __esm({
         ],
         createRecoveryCard: true
       },
-      action_reason_missing: {
-        severity: "warning",
-        retryable: true,
-        guidance: "A side-effectful tool call lacked the required public action_reason envelope. Retry only with compact task-state metadata, or use a read-only/control-plane tool if no mutation is intended.",
-        workboardEvidenceRequirements: [
-          "corrected action_reason envelope",
-          "same intended operation through the right tool"
-        ],
-        createRecoveryCard: false
-      },
       workboard_noop: {
         severity: "warning",
         retryable: true,
@@ -577277,7 +577434,7 @@ var init_context_fabric = __esm({
         const header = [
           "[ACTIVE CONTEXT FRAME]",
           options2.turn !== void 0 ? `turn: ${options2.turn}` : null,
-          "Scope: runtime state for the next action. Treat this as the single merged context intake; do not re-read or re-emit it unless state changes."
+          "Scope: runtime state for the next action. Do not quote or re-emit this frame. Prior evidence is orientation; execute a narrow file_read or the declared verifier whenever current text/hash or post-mutation proof is required."
         ].filter(Boolean);
         let content = [...header, "", ...sectionLines].join("\n").trim();
         const controlChars = included.filter(isControlSignal).reduce((sum2, signal) => sum2 + signal.content.length, 0);
@@ -577471,7 +577628,7 @@ function retireDuplicateToolFailures(messages2) {
     }
     out[index] = {
       ...message2,
-      content: "[retired_duplicate_tool_failure] newer matching result appears later; do not repeat the same call."
+      content: "[retired_duplicate_tool_failure] a newer matching failure appears later. Use that latest diagnostic; retry only after refreshing prerequisite evidence or correcting the arguments."
     };
   }
   return out;
@@ -577777,8 +577934,8 @@ var init_evidenceLedger = __esm({
           return null;
         const sorted = [...this.entries.values()].sort((a2, b) => b.lastReadTurn - a2.lastReadTurn);
         const lines = [
-          "Evidence already gathered this run — you ALREADY have the content below.",
-          "Do NOT re-read a FRESH file; use this. Re-read ONLY entries marked STALE.",
+          "Earlier file evidence from this run is shown below for orientation.",
+          "Use a displayed full-fidelity snapshot when it is sufficient, but file_read is allowed and required when an edit/hash guard asks for current text, a displayed body is elided, or external state may have changed.",
           ""
         ];
         let used = lines.join("\n").length;
@@ -578253,8 +578410,6 @@ ${obs.stateDigest.slice(0, 1800)}
       `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.)`,
-      ls2.actionReason ? `Agent's stated action reason:
-  scope=${ls2.actionReason.scope ?? ""}; intent=${ls2.actionReason.intent ?? ""}; evidence=${ls2.actionReason.evidence ?? ""}; expected=${ls2.actionReason.expected_result ?? ""}`.slice(0, 700) : "",
       "",
       stateDigest.trim(),
       "",
@@ -578658,7 +578813,6 @@ function recordDebugToolEvent(input) {
     },
     ...input.focusSupervisor ? { focusSupervisor: input.focusSupervisor } : {},
     ...input.focusDecision ? { focusDecision: input.focusDecision } : {},
-    ...input.actionReason ? { actionReason: compactDebugValue(input.actionReason) } : {},
     ...input.repeatShortCircuit !== void 0 ? { repeatShortCircuit: input.repeatShortCircuit } : {},
     ...input.runtimeAuthored !== void 0 ? { runtimeAuthored: input.runtimeAuthored } : {},
     ...input.runtimeGuidance ? { runtimeGuidancePreview: trim(input.runtimeGuidance, 1200) } : {},
@@ -579347,30 +579501,6 @@ function trim(value2, max) {
   return `${value2.slice(0, max)}
 [truncated ${value2.length - max} chars]`;
 }
-function compactDebugValue(value2, depth = 0) {
-  if (value2 == null)
-    return value2;
-  if (typeof value2 === "string") {
-    return value2.length > 500 ? `${value2.slice(0, 497)}...` : value2;
-  }
-  if (typeof value2 === "number" || typeof value2 === "boolean")
-    return value2;
-  if (Array.isArray(value2)) {
-    if (depth >= 2)
-      return `[array:${value2.length}]`;
-    return value2.slice(0, 8).map((entry) => compactDebugValue(entry, depth + 1));
-  }
-  if (typeof value2 === "object") {
-    if (depth >= 2)
-      return "[object]";
-    const out = {};
-    for (const [key, entry] of Object.entries(value2).slice(0, 12)) {
-      out[key] = compactDebugValue(entry, depth + 1);
-    }
-    return out;
-  }
-  return String(value2);
-}
 function safeId2(value2) {
   return String(value2 || "unknown").replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 160);
 }
@@ -579554,17 +579684,6 @@ function meaningfulCachedEvidencePreview(text2) {
   }
   return preview.join(" | ").slice(0, 700);
 }
-function actionReasonSummary(actionReason) {
-  if (!actionReason)
-    return "";
-  const parts = [
-    actionReason.scope ? `scope=${actionReason.scope}` : "",
-    actionReason.intent ? `intent=${actionReason.intent}` : "",
-    actionReason.evidence ? `evidence=${actionReason.evidence}` : "",
-    actionReason.expected_result ? `expected=${actionReason.expected_result}` : ""
-  ].filter(Boolean);
-  return parts.length > 0 ? `Action reason observed: ${parts.join("; ").slice(0, 700)}` : "";
-}
 function normalizeShellForFamily(command, cwd4) {
   let s2 = String(command || "").replace(/\\\r?\n/g, " ").replace(/\s+/g, " ").trim();
   if (cwd4 && cwd4.length > 1) {
@@ -579875,7 +579994,6 @@ var init_focusSupervisor = __esm({
                 `${reason}.`,
                 `Required next action: ${prior.requiredNextAction}.`,
                 `Blocked action family: ${family}.`,
-                actionReasonSummary(input.actionReason),
                 "This block is not counted as a new ignored directive."
               ].filter(Boolean).join("\n"), false);
             }
@@ -579902,7 +580020,6 @@ var init_focusSupervisor = __esm({
               "[FOCUS SUPERVISOR BLOCK: LOOP CONTROL]",
               `Directive ${prior.id} was repeatedly ignored with ${family}.`,
               `Required next action: ${directive.requiredNextAction}.`,
-              actionReasonSummary(input.actionReason),
               "Stop trying this action-family repeatedly. Pivot to a materially different approach or web_search the blocker, then continue."
             ].filter(Boolean).join("\n"), false);
           }
@@ -579942,7 +580059,6 @@ var init_focusSupervisor = __esm({
               `[FOCUS SUPERVISOR BLOCK] The previous directive was ignored: ${prior.reason}`,
               `Required next action: ${directive.requiredNextAction}.`,
               `Blocked action family: ${family}.`,
-              actionReasonSummary(input.actionReason),
               directive.requiredNextAction === "creative_pivot_or_research" ? "Stop trying variants of what failed. The task is NOT over — pivot to a fundamentally different approach or web_search the exact blocker, then act." : "Take the required next action before trying another variant."
             ].filter(Boolean).join("\n"), false);
           }
@@ -579958,7 +580074,6 @@ var init_focusSupervisor = __esm({
           return this.block(directive, [
             input.stalePreflightMessage,
             "",
-            actionReasonSummary(input.actionReason),
             "[FOCUS SUPERVISOR] Required next action: file_read the authoritative current target once, then build a new edit from current evidence or report incomplete."
           ].filter(Boolean).join("\n"), false);
         }
@@ -579980,7 +580095,6 @@ var init_focusSupervisor = __esm({
               input.cachedResultFailed ? "[FOCUS SUPERVISOR: CACHED FAILURE]" : "[FOCUS SUPERVISOR: CACHED EVIDENCE]",
               `This ${input.toolName} action family has already produced evidence and should not be re-executed unchanged.`,
               `Required next action: ${directive.requiredNextAction}.`,
-              actionReasonSummary(input.actionReason),
               "",
               compactCachedEvidence(input.cachedResult)
             ].filter(Boolean).join("\n"), !input.cachedResultFailed);
@@ -585241,9 +585355,6 @@ import { join as _pathJoin, relative as _pathRelative, resolve as _pathResolve }
 import { tmpdir as _osTmpdir } from "node:os";
 import { homedir as _osHomedir } from "node:os";
 import { z as z17 } from "zod";
-function cleanToolActionReasonField(value2) {
-  return String(value2 ?? "").replace(/\s+/g, " ").trim();
-}
 function stripShellQuotedSegments(command) {
   let out = "";
   let quote2 = null;
@@ -585982,7 +586093,7 @@ function classifyThinkOutcome(raw) {
   }
   return null;
 }
-var TOOL_SUBSETS, TOOL_AUTO_DEMOTE_TURNS, TOOL_ACTION_REASON_KEYS, TOOL_ACTION_REASON_SCOPES, READ_ONLY_ACTION_REASON_OPTIONAL_TOOLS, STATE_UPDATE_ACTION_REASON_SYNTHESIS_TOOLS, TOOL_ACTION_REASON_SCHEMA, SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, OllamaAgenticBackend;
+var TOOL_SUBSETS, TOOL_AUTO_DEMOTE_TURNS, LEGACY_ACTION_REASON_KEYS, SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, OllamaAgenticBackend;
 var init_agenticRunner = __esm({
   "packages/orchestrator/dist/agenticRunner.js"() {
     "use strict";
@@ -586080,75 +586191,7 @@ var init_agenticRunner = __esm({
       skill: ["skill_list", "skill_extract", "skill_execute", "skill_search"]
     };
     TOOL_AUTO_DEMOTE_TURNS = 10;
-    TOOL_ACTION_REASON_KEYS = /* @__PURE__ */ new Set([
-      "action_reason",
-      "actionReason",
-      "justification"
-    ]);
-    TOOL_ACTION_REASON_SCOPES = /* @__PURE__ */ new Set([
-      "discovery",
-      "targeted_patch",
-      "new_file",
-      "full_file_rewrite",
-      "verification",
-      "state_update",
-      "delegation",
-      "completion",
-      "other"
-    ]);
-    READ_ONLY_ACTION_REASON_OPTIONAL_TOOLS = /* @__PURE__ */ new Set([
-      "file_read",
-      "file_explore",
-      "list_directory",
-      "grep_search",
-      "grep",
-      "glob_find",
-      "find_files",
-      "todo_read",
-      "memory_read",
-      "memory_search",
-      "semantic_map",
-      "code_graph",
-      "graph_query",
-      "graph_traverse",
-      "web_search",
-      "web_fetch",
-      "tool_search",
-      "task_status",
-      "task_output"
-    ]);
-    STATE_UPDATE_ACTION_REASON_SYNTHESIS_TOOLS = /* @__PURE__ */ new Set([
-      "todo_write",
-      "working_notes"
-    ]);
-    TOOL_ACTION_REASON_SCHEMA = {
-      type: "object",
-      description: "Compact public action contract for this exact tool call. Do not include hidden chain-of-thought; use concise task-state facts.",
-      properties: {
-        task_anchor: {
-          type: "string",
-          description: "One compact phrase tying this call to the active user goal/current focus."
-        },
-        intent: {
-          type: "string",
-          description: "One sentence explaining why this tool is the next action."
-        },
-        evidence: {
-          type: "string",
-          description: "Fresh evidence or contract authorizing the action: file hash, focus directive, cached evidence, user request, or explicit absence."
-        },
-        expected_result: {
-          type: "string",
-          description: "The concrete new state or information expected from this call."
-        },
-        scope: {
-          type: "string",
-          enum: Array.from(TOOL_ACTION_REASON_SCOPES),
-          description: "Classify the action scope. Use targeted_patch for constrained edits; full_file_rewrite only for deliberate whole-file replacement."
-        }
-      },
-      required: ["task_anchor", "intent", "evidence", "expected_result", "scope"]
-    };
+    LEGACY_ACTION_REASON_KEYS = /* @__PURE__ */ new Set(["action_reason", "actionReason"]);
     SYSTEM_PROMPT = loadPrompt("agentic/system-large.md");
     SYSTEM_PROMPT_MEDIUM = loadPrompt("agentic/system-medium.md");
     SYSTEM_PROMPT_SMALL = loadPrompt("agentic/system-small.md");
@@ -587365,10 +587408,8 @@ ${parts.join("\n")}
         if (ts.failedApproaches.length > 0) {
           lines.push(`recent_failed_approaches=${ts.failedApproaches.slice(-3).join(" | ").replace(/\s+/g, " ").slice(0, 420)}`);
         }
-        lines.push("tool_call_contract=Mutating/side-effectful tool calls require action_reason {task_anchor,intent,evidence,expected_result,scope}; read-only evidence tools may include it but must never be blocked only for missing metadata. Compact public facts only, no hidden chain-of-thought.");
         lines.push("edit_transport_contract=file_edit is for exact unique current text copied from file_read; file_patch is for line-range delete/replace/insert using file_read line numbers and expected_hash/current target evidence. A failed file_edit invalidates the edit premise; rebuild from current evidence instead of broadening into file_write unless the task is truly whole-file replacement.");
         lines.push("range_patch_contract=If patch_ready=true or current path+start_line+end_line+expected_hash are known, call file_patch. If read_required=true or a stale exact edit lacks current range/hash, call file_read once. Do not call file_read when patch_ready=true.");
-        lines.push(`scope_contract=${Array.from(TOOL_ACTION_REASON_SCOPES).join("|")}; use targeted_patch for constrained code edits and full_file_rewrite only for deliberate whole-file replacement.`);
         const gitContract = renderGitProgressActionContract(this._gitProgress);
         if (gitContract)
           lines.push(gitContract);
@@ -588238,7 +588279,8 @@ Emit AT MOST 6 tool calls per response. Smaller batches receive better feedback
         };
         const batchGuidance = _BATCH_GUIDANCE[this.options.modelTier ?? "large"] ?? _BATCH_GUIDANCE.large;
         const shellGuidance = "\n\n## Shell command patterns\n\nWhen investigating a build/test/install failure, RUN THE COMMAND WITHOUT TRUNCATION FIRST to see the full error.\nAvoid `| tail -N` / `| head -N` / `| sed -n '1,Np'` on commands you don't yet trust — they drop the part of the output where errors usually appear.\nPipefail is on by default in this orchestrator: a pipeline's exit code reflects the FIRST failing stage, not just the last. So `<cmd> | tail -80` returns non-zero if `<cmd>` failed.\nWhen you DO want to limit context (after diagnosis), prefer `<cmd> 2>&1 | tail -300` (or larger) so you keep enough output to see the actual error block.\nIf your command exited 0 but produced suspiciously short output (~< 800 chars), the orchestrator will inject a [HINT — pipe-to-truncator detected] block telling you to re-run without truncation.";
-        const basePromptWithBatching = basePrompt + batchGuidance + shellGuidance;
+        const editTransportGuidance = "\n\n## Existing-file edit loop\n\nFor an existing non-trivial file, use this loop: (1) file_read the implicated range or whole small file, (2) file_patch a contiguous line range or file_edit exact current text, (3) inspect the resulting diff/changed range, and (4) run the declared verifier live. Use batch_edit only for multiple exact replacements built from one fresh read.\nfile_write is for new files, empty/placeholder files, and deliberate replacement of a genuinely small file. Never use file_write as a fallback for stale hashes, old_string mismatches, malformed patch arguments, or repeated edit failures. A 'different approach' means refresh evidence or change the diagnostic/patch shape; it does not mean broaden a local repair into a whole-file rewrite.\nPreviously observed or compacted results are orientation only. Re-run file_read whenever a freshness/hash guard asks for current text, and re-run the exact verifier after every relevant mutation; cached output never proves current file state or completion.";
+        const basePromptWithBatching = basePrompt + batchGuidance + shellGuidance + editTransportGuidance;
         sections.push({
           label: "c_instr",
           content: basePromptWithBatching,
@@ -589415,8 +589457,9 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           return this._declaredVerifierCommand;
         }
         const diagnostics = parseCompilerDiagnostics(output);
-        if (diagnostics.length > 0 && this._shellResultLooksLikeVerification({ command: trimmed }, { success: false, output })) {
-          return trimmed;
+        if (diagnostics.length > 0 && !commandIsPureReadOnlyPipeline(trimmed)) {
+          const latched = stripVerifierFallbackSuffix(trimmed);
+          return latched || trimmed;
         }
         return null;
       }
@@ -589426,19 +589469,68 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           return false;
         return commandReliablySatisfiesVerifyCommand(command.trim(), state.verifierCommand);
       }
+      /**
+       * When a tool result was triaged for size (full payload saved to
+       * `.omnius/tool-results/<hash>.txt`), append the saved payload so
+       * diagnostics parsing sees the complete output. Without this, a large
+       * failed build's `file:line:col: error:` lines can be cut out of the
+       * triage envelope and the run never registers as a verifier run.
+       * Best effort and bounded — never throws into the loop.
+       */
+      _expandTriagedPayloadForDiagnostics(text2) {
+        if (!text2 || !text2.includes(TRIAGE_SAVED_PATH_MARKER))
+          return text2;
+        const MAX_PAYLOAD_BYTES = 1e6;
+        const MAX_FILES2 = 2;
+        const extras = [];
+        let searchFrom = 0;
+        for (let i2 = 0; i2 < MAX_FILES2; i2++) {
+          const markerAt = text2.indexOf(TRIAGE_SAVED_PATH_MARKER, searchFrom);
+          if (markerAt === -1)
+            break;
+          const pathStart = markerAt + TRIAGE_SAVED_PATH_MARKER.length;
+          const restOfLine = text2.slice(pathStart, text2.indexOf("\n", pathStart) === -1 ? void 0 : text2.indexOf("\n", pathStart));
+          searchFrom = pathStart;
+          const endIdx = (() => {
+            const emDash = restOfLine.indexOf(" — ");
+            if (emDash !== -1)
+              return emDash;
+            const bracket = restOfLine.indexOf("]");
+            return bracket !== -1 ? bracket : restOfLine.length;
+          })();
+          const savedPath = restOfLine.slice(0, endIdx).trim();
+          if (!savedPath)
+            continue;
+          try {
+            if (!_fsExistsSync(savedPath))
+              continue;
+            const stat9 = _fsStatSync(savedPath);
+            if (!stat9.isFile())
+              continue;
+            const raw = _fsReadFileSync(savedPath, "utf8");
+            extras.push(raw.length > MAX_PAYLOAD_BYTES ? raw.slice(0, MAX_PAYLOAD_BYTES) : raw);
+          } catch {
+          }
+        }
+        if (extras.length === 0)
+          return text2;
+        return `${text2}
+${extras.join("\n")}`;
+      }
       _observeCompileVerifierResult(input) {
         const diagnostics = rankCompilerDiagnostics(parseCompilerDiagnostics(input.output));
+        const verifierCommand = stripVerifierFallbackSuffix(input.verifierCommand) || input.verifierCommand.trim();
         const previousDiagnostics = this._lastDeclaredVerifierDiagnostics;
-        this._declaredVerifierCommand = input.verifierCommand;
+        this._declaredVerifierCommand = verifierCommand;
         this._lastDeclaredVerifierOutput = input.output;
         this._lastDeclaredVerifierDiagnostics = diagnostics;
         if (!this._compileFixLoop && diagnostics.length === 0)
           return null;
-        const verifierFingerprint = compileFixVerifierFingerprint(input.verifierCommand);
+        const verifierFingerprint = compileFixVerifierFingerprint(verifierCommand);
         const existingCards = this._compileFixLoop?.cards ?? [];
         const cards = diagnostics.length > 0 ? buildCompileFixCards({
           diagnostics,
-          verifierCommand: input.verifierCommand,
+          verifierCommand,
           turn: input.turn,
           existingCards
         }) : existingCards;
@@ -589447,22 +589539,25 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           existingCards,
           observedCards: cards,
           diagnostics,
-          verifierCommand: input.verifierCommand,
+          verifierCommand,
           turn: input.turn,
           verifierPassed: input.success && diagnostics.length === 0
         });
         this._compileFixLoop = {
           active: diagnostics.length > 0 || nextCards.some((card) => card.status !== "verified"),
-          verifierCommand: input.verifierCommand,
+          verifierCommand,
           verifierFingerprint,
           verifierDirtySinceTurn: null,
           lastVerifierRunTurn: input.turn,
           lastVerifierPassedTurn: input.success && diagnostics.length === 0 ? input.turn : null,
           lastMutationTurn: this._compileFixLoop?.lastMutationTurn ?? null,
-          cards: nextCards
+          cards: nextCards,
+          // A live verifier run resolves the gate's demand — the block streak
+          // is over regardless of pass/fail.
+          preflightBlockStreak: 0
         };
         this._mirrorCompileFixCardsToWorkboard(nextCards, {
-          command: input.verifierCommand,
+          command: verifierCommand,
           success: input.success && diagnostics.length === 0,
           turn: input.turn,
           beforeDiagnosticCount: previousDiagnostics.length,
@@ -589474,7 +589569,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         if (input.success && diagnostics.length === 0) {
           this.emit({
             type: "status",
-            content: `compile_error_fix_loop: verifier passed (${input.verifierCommand}); compile cards verified`,
+            content: `compile_error_fix_loop: verifier passed (${verifierCommand}); compile cards verified`,
             turn: input.turn,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
@@ -589493,7 +589588,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         }
         this.emit({
           type: "status",
-          content: `compile_error_fix_loop_started: verifierCommand=${input.verifierCommand}; cardId=${top.id}; diagnosticFingerprint=${top.diagnostic.fingerprint}; afterDiagnosticCount=${diagnostics.length}`,
+          content: `compile_error_fix_loop_started: verifierCommand=${verifierCommand}; cardId=${top.id}; diagnosticFingerprint=${top.diagnostic.fingerprint}; afterDiagnosticCount=${diagnostics.length}`,
           turn: input.turn,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
@@ -589693,14 +589788,7 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         if (!state?.active)
           return;
         const normalized = paths.map((p2) => this._normalizeEvidencePath(p2)).filter(Boolean);
-        const owned = state.cards.flatMap((card) => card.ownedFiles);
-        const todos = this.readSessionTodos() || [];
-        const artifacts = todos.flatMap((todo) => Array.isArray(todo.declaredArtifacts) ? todo.declaredArtifacts.filter((p2) => typeof p2 === "string") : []);
-        const relevant = normalized.length === 0 || normalized.some((pathValue) => {
-          if (pathValue.startsWith(".omnius/"))
-            return false;
-          return owned.some((ownedPath) => this._pathsOverlapForVerifier(pathValue, ownedPath)) || artifacts.some((artifactPath) => this._pathsOverlapForVerifier(pathValue, artifactPath)) || /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|c|cc|cpp|cxx|h|hpp|hh|hxx|ino)$/i.test(pathValue);
-        });
+        const relevant = normalized.length === 0 || this._compileFixPathsTouchProjectSources(normalized, state);
         if (!relevant)
           return;
         state.verifierDirtySinceTurn = turn;
@@ -589727,6 +589815,24 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
+      /**
+       * True when any of the given normalized paths touches project source:
+       * files owned by compile-fix cards, declared todo artifacts, or files
+       * with a source-code extension. Build side effects (logs, artifacts,
+       * `.omnius/` bookkeeping) do not count.
+       */
+      _compileFixPathsTouchProjectSources(normalizedPaths, state) {
+        const owned = state.cards.flatMap((card) => card.ownedFiles);
+        const todos = this.readSessionTodos() || [];
+        const artifacts = todos.flatMap((todo) => Array.isArray(todo.declaredArtifacts) ? todo.declaredArtifacts.filter((p2) => typeof p2 === "string") : []);
+        return normalizedPaths.some((pathValue) => {
+          if (pathValue.startsWith(".omnius/"))
+            return false;
+          return owned.some((ownedPath) => this._pathsOverlapForVerifier(pathValue, ownedPath)) || artifacts.some((artifactPath) => this._pathsOverlapForVerifier(pathValue, artifactPath)) || /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|c|cc|cpp|cxx|h|hpp|hh|hxx|ino)$/i.test(pathValue);
+        });
+      }
+      /** Consecutive preflight blocks before the gate yields instead of blocking. */
+      static COMPILE_FIX_GATE_YIELD_AFTER = 3;
       _compileFixLoopPreflightBlock(toolName, args, turn, shellLikelyMutatesFilesystem) {
         const state = this._compileFixLoop;
         if (!state?.active)
@@ -589737,29 +589843,62 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
         if (toolName === "shell") {
           const command = String(args["command"] ?? args["cmd"] ?? "").trim();
           if (commandReliablySatisfiesVerifyCommand(command, state.verifierCommand)) {
+            state.preflightBlockStreak = 0;
             return null;
           }
           if (!shellLikelyMutatesFilesystem)
             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 null;
+          }
         } else if (!this._isProjectEditTool(toolName)) {
           return null;
         }
+        const yieldAfter = _AgenticRunner.COMPILE_FIX_GATE_YIELD_AFTER;
+        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")
+          };
+        }
+        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.`,
-          `verifierCommand: ${state.verifierCommand}`,
+          `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}`
+          `blockedTool: ${toolName}`,
+          `consecutiveBlocks: ${streak}/${yieldAfter} (gate yields after ${yieldAfter})`
         ].join("\n");
         this.emit({
           type: "status",
-          content: `compile_error_verifier_dirty: blocked ${toolName} at turn ${turn}`,
+          content: `compile_error_verifier_dirty: blocked ${toolName} at turn ${turn} (${streak}/${yieldAfter})`,
           turn,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
-        return message2;
+        return { kind: "block", message: message2 };
       }
       _compileFixLoopCompletionBlocker(turn) {
         const state = this._compileFixLoop;
@@ -590072,11 +590211,8 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         const realFileMutation = input.realFileMutation ?? this._isRealProjectMutation(input.toolName, input.result);
         const attemptedTargetPaths = this._extractToolTargetPaths(input.toolName, input.args, input.result);
         const realMutationPaths = input.realMutationPaths ?? (realFileMutation ? attemptedTargetPaths : []);
-        const shellActionReasonScope = input.toolName === "shell" ? input.actionReason?.scope : void 0;
-        const shellActionReasonDeclaresVerification = shellActionReasonScope === "verification";
-        const shellActionReasonDeclaresNonVerification = typeof shellActionReasonScope === "string" && shellActionReasonScope.length > 0 && shellActionReasonScope !== "verification";
-        const shellVerification = input.toolName === "shell" && (shellActionReasonDeclaresVerification || !shellActionReasonDeclaresNonVerification && input.result.runtimeAuthored !== true && this._shellResultLooksLikeVerification(input.args, input.result));
-        const shellVerificationFamily = shellVerification ? this._shellVerificationFamily(input.args, input.actionReason) : "";
+        const shellVerification = input.toolName === "shell" && input.result.runtimeAuthored !== true && this._shellResultLooksLikeVerification(input.args, input.result);
+        const shellVerificationFamily = shellVerification ? this._shellVerificationFamily(input.args) : "";
         if (input.result.success === true && this._isProjectEditTool(input.toolName) && !realFileMutation && input.result.alreadyApplied !== true) {
           return;
         }
@@ -590110,17 +590246,7 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         }
         this._saveCompletionLedgerSafe();
       }
-      _shellVerificationFamily(args, actionReason) {
-        if (actionReason?.scope === "verification") {
-          const stableParts = [
-            actionReason.task_anchor,
-            actionReason.expected_result
-          ].map((part) => String(part ?? "").trim()).filter(Boolean);
-          const semanticKey = (stableParts.length > 0 ? stableParts : [String(actionReason.intent ?? "").trim()].filter(Boolean)).join(" | ");
-          const normalized2 = normalizeCompletionKey(semanticKey || "shell verification", "shell_verification").slice(0, 140);
-          if (normalized2)
-            return `shell-action:${normalized2}`;
-        }
+      _shellVerificationFamily(args) {
         const command = String(args?.["command"] ?? args?.["cmd"] ?? "").trim();
         const normalized = normalizeShellCommand(command);
         return `shell:${(normalized || command || "verification").slice(0, 160)}`;
@@ -590130,6 +590256,8 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         if (!command.trim())
           return false;
         void result;
+        if (commandIsPureReadOnlyPipeline(command))
+          return false;
         return /\b(test|tests|vitest|jest|pytest|go test|cargo test|npm test|pnpm test|yarn test|typecheck|tsc|build|verify|verification|check)\b/i.test(command);
       }
       _shouldSuppressCompletionDiscoveryEvidence(toolName, result, targetPaths) {
@@ -592443,13 +592571,11 @@ ${latest.output || ""}`.trim();
             success: item.succeeded,
             path: item.path,
             stateVersion: item.stateVersion,
-            preview: item.preview.slice(0, 240),
-            actionReason: item.actionReason ?? void 0
+            preview: item.preview.slice(0, 240)
           }));
           const recentActionLines = recentActions.slice(-6).map((item) => {
             const path16 = item.path ? ` path=${item.path}` : "";
-            const reason = item.actionReason ? ` reason=${[item.actionReason.scope, item.actionReason.intent].filter(Boolean).join(":").replace(/\s+/g, " ").slice(0, 120)}` : "";
-            return `- turn=${item.turn} ${item.tool} ${item.success ? "ok" : "err"}${path16}${reason}: ${item.preview.replace(/\s+/g, " ").slice(0, 160)}`;
+            return `- turn=${item.turn} ${item.tool} ${item.success ? "ok" : "err"}${path16}: ${item.preview.replace(/\s+/g, " ").slice(0, 160)}`;
           });
           const treeDir = _pathJoin(this.omniusStateDir(), "world-state", "tree");
           const turnName = `turn-${String(turn).padStart(4, "0")}`;
@@ -592751,10 +592877,10 @@ ${sections.join("\n")}` : sections.join("\n");
           }
         }
         const sections = [
-          "[KNOWLEDGE — recent tool results for reference. Re-reading a file after an edit is encouraged to capture the latest content; exact re-reads are NOT blocked and always return fresh, up-to-date data.]"
+          "[KNOWLEDGE — prior observations for orientation only. A file_read requested for current text/hash and a verifier requested after mutation execute live; this history is never substituted for fresh evidence.]"
         ];
         if (compactedCount > 0) {
-          sections.push(`Compacted cached entries still count as already-known results (${compactedCount}); an exact repeat will be served from cache or skipped, not produce new information.`);
+          sections.push(`Compacted historical entries: ${compactedCount}. They show what was observed earlier, not what is currently on disk. Re-run the narrow read or verifier when freshness matters.`);
         }
         if (filesRead.length > 0) {
           const unique2 = [...new Set(filesRead)].slice(0, 30);
@@ -593597,11 +593723,11 @@ ${blob}
           const meta = metaForResult(idx);
           let stub;
           if (p2) {
-            stub = `[Earlier read of ${p2} cleared — its content is preserved in your ACTIVE CONTEXT FRAME (Evidence already gathered). Do NOT re-read it; use the frame.]`;
+            stub = `[Earlier read of ${p2} compacted. A snapshot may appear in the ACTIVE CONTEXT FRAME; file_read the narrow current range again whenever exact text/hash or unelided content is needed.]`;
           } else {
             const firstLine = content.split("\n").find((l2) => l2.trim())?.trim().slice(0, 140) ?? "";
             const failed = /\berror\b|\bfail|✗|exit code [1-9]|traceback/i.test(content);
-            stub = `[${meta?.name ?? "tool"}(${meta?.argsPreview ?? ""}) result compacted to save context — ${failed ? "FAILED" : "ok"}${firstLine ? `: ${firstLine}` : ""}. Re-run ONLY if the underlying state has since changed.]`;
+            stub = `[${meta?.name ?? "tool"}(${meta?.argsPreview ?? ""}) result compacted to save context — ${failed ? "FAILED" : "ok"}${firstLine ? `: ${firstLine}` : ""}. This is historical orientation, not current-state proof; re-run a verifier or narrow state read when freshness matters.]`;
           }
           messages2[idx] = { ...msg, content: stub };
           cleared++;
@@ -593688,7 +593814,7 @@ ${blob}
        * size. The hash is computed over the full canonical value.
        */
       _buildExactArgsKey(args) {
-        return Object.entries(args ?? {}).filter(([key]) => !TOOL_ACTION_REASON_KEYS.has(key)).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${this._formatExactArgValue(v)}`).join(",");
+        return Object.entries(args ?? {}).filter(([key]) => !LEGACY_ACTION_REASON_KEYS.has(key)).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${this._formatExactArgValue(v)}`).join(",");
       }
       _buildToolFingerprint(name10, args) {
         const canonical = this.lookupRegisteredTool(name10)?.name ?? name10;
@@ -593980,7 +594106,7 @@ ${blob}
           if (seen.has(value2))
             return "#cycle";
           seen.add(value2);
-          const entries = Object.entries(value2).filter(([key]) => !TOOL_ACTION_REASON_KEYS.has(key)).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${this._canonicalArgValue(v, seen)}`);
+          const entries = Object.entries(value2).filter(([key]) => !LEGACY_ACTION_REASON_KEYS.has(key)).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${this._canonicalArgValue(v, seen)}`);
           return `#object:{${entries.join(",")}}`;
         }
         return String(value2);
@@ -594170,8 +594296,7 @@ Rewrite it now for ${ctx3.model}.`;
         const unknownKeys = providedKeys.filter((key) => !props.has(key));
         const aliases = this.suggestArgumentAliases(missingRequired, providedKeys, args, props);
         const corrected = this.buildCorrectedArgsPreview(args, props, aliases);
-        const actionReasonOnlyFailure = validationError.includes("[TOOL ACTION REASON CONTRACT]");
-        const siblingMatches = actionReasonOnlyFailure ? [] : this.findSiblingToolSchemaMatches(toolName, providedKeys);
+        const siblingMatches = this.findSiblingToolSchemaMatches(toolName, providedKeys);
         const lines = [
           `[RUNTIME TOOL ARGUMENT REPAIR]`,
           `Tool call failed before execution: ${toolName}`,
@@ -596480,7 +596605,7 @@ ${_staleSamples.join("\n")}` : ``,
                   ``,
                   `  (a) RUN-AND-READ: Run the EXACT command that fails (test/typecheck/build) and READ THE FULL ERROR MESSAGE LITERALLY. Do not summarize it from memory; paste it back into context. The current write hasn't been validated against any error.`,
                   ``,
-                  `  (b) DELETE-AND-RESTART: If the file has been rewritten ${_wtWorstCount} times, the current approach is wrong. Either delete the file and try a fundamentally different design, OR revert to a known-good earlier version (use git, working_notes, or memory_search to find one).`,
+                  `  (b) DIFF-AND-RESET-THE-PREMISE: Inspect git diff for ${_wtWorstPath}, then file_read only the implicated current range. Keep correct changes, identify the first wrong hunk, and repair that hunk with file_patch/file_edit. Do not delete or regenerate the file.`,
                   ``,
                   `  (c) ERROR-INFORMED LOCAL TRIAGE: use the exact failing local command and error line to identify one implicated path/symbol/config key, then inspect or change only that target. Do not search online for a codebase-local failure.`,
                   ``,
@@ -597113,6 +597238,8 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               };
               const ceCompactOutput = await this._contextEngine.compact(ceCompactInput);
               if (ceCompactOutput.compacted && ceCompactOutput.compactedMessages.length > 0 && ceCompactOutput.compactedMessages.length < compacted.length) {
+                const beforeCount = compacted.length;
+                const afterCount = ceCompactOutput.compactedMessages.length;
                 messages2.length = 0;
                 messages2.push(...ceCompactOutput.compactedMessages.map((m2) => ({
                   role: m2.role,
@@ -597120,6 +597247,11 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
                   ...m2.name ? { name: m2.name } : {}
                 })));
                 compacted = messages2;
+                this.emit({
+                  type: "compaction",
+                  content: `Compacted ${beforeCount - afterCount} messages (context engine) | ${beforeCount} -> ${afterCount} messages retained`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
               }
             } catch {
             }
@@ -597746,7 +597878,6 @@ ${memoryLines.join("\n")}`
             executeSingle = async (tc) => {
               if (this.aborted)
                 return null;
-              const actionReasonForAdvisory = this._toolActionReasonForCall(tc.name, tc.arguments ?? {});
               const cohortKey = this.buildArgCohortKey(tc.name, tc.arguments);
               const cohort = this._argCohorts.get(cohortKey);
               if (cohort && cohort.failure >= 3 && cohort.success === 0) {
@@ -598107,7 +598238,6 @@ Read the current file if needed, make a different concrete edit, or move to veri
                   turn,
                   toolName: tc.name,
                   args: tc.arguments ?? {},
-                  actionReason: actionReasonForAdvisory,
                   fingerprint: toolFingerprint,
                   isReadLike: false,
                   stalePreflightMessage: staleEditBlock,
@@ -598173,7 +598303,6 @@ Read the current file if needed, make a different concrete edit, or move to veri
                   turn,
                   toolName: tc.name,
                   args: tc.arguments ?? {},
-                  actionReason: actionReasonForAdvisory,
                   fingerprint: toolFingerprint,
                   isReadLike: false,
                   stalePreflightMessage: staleRewriteBlock,
@@ -598239,7 +598368,6 @@ Read the current file if needed, make a different concrete edit, or move to veri
                   turn,
                   toolName: tc.name,
                   args: tc.arguments ?? {},
-                  actionReason: actionReasonForAdvisory,
                   fingerprint: toolFingerprint,
                   isReadLike: false,
                   stalePreflightMessage: editReversalBlock,
@@ -598373,8 +598501,7 @@ Read the current file if needed, make a different concrete edit, or move to veri
               } : evaluate2({
                 proposedCall: {
                   tool: tc.name,
-                  args: tc.arguments ?? {},
-                  actionReason: actionReasonForAdvisory ?? void 0
+                  args: tc.arguments ?? {}
                 },
                 fingerprint: toolFingerprint,
                 isReadLike,
@@ -598424,7 +598551,6 @@ Read the current file if needed, make a different concrete edit, or move to veri
                       tool: tc.name,
                       target: _target,
                       count: criticDecision.hitNumber,
-                      actionReason: actionReasonForAdvisory ?? void 0,
                       alreadyHave: _existingFp?.result
                     }
                   });
@@ -598529,7 +598655,6 @@ ${cachedResult}`,
                 turn,
                 toolName: tc.name,
                 args: tc.arguments ?? {},
-                actionReason: actionReasonForAdvisory,
                 completionStatus: completionStatusFromTaskCompleteArgs(tc.arguments),
                 fingerprint: toolFingerprint,
                 isReadLike,
@@ -598568,8 +598693,10 @@ ${cachedResult}`,
                   };
                 }
               }
-              const compileLoopPreflightBlock = !repeatShortCircuit ? this._compileFixLoopPreflightBlock(tc.name, tc.arguments ?? {}, turn, shellLikelyMutatesFilesystem) : null;
-              if (compileLoopPreflightBlock) {
+              const compileLoopPreflight = !repeatShortCircuit ? this._compileFixLoopPreflightBlock(tc.name, tc.arguments ?? {}, turn, shellLikelyMutatesFilesystem) : null;
+              if (compileLoopPreflight?.kind === "yield") {
+                pushSoftInjection("system", compileLoopPreflight.notice);
+              } else if (compileLoopPreflight) {
                 this.emit({
                   type: "tool_call",
                   toolName: tc.name,
@@ -598581,7 +598708,7 @@ ${cachedResult}`,
                   type: "tool_result",
                   toolName: tc.name,
                   success: false,
-                  content: compileLoopPreflightBlock.slice(0, 120),
+                  content: compileLoopPreflight.message.slice(0, 120),
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -598591,9 +598718,9 @@ ${cachedResult}`,
                 });
                 return {
                   tc,
-                  output: compileLoopPreflightBlock,
+                  output: compileLoopPreflight.message,
                   success: false,
-                  systemGuidance: compileLoopPreflightBlock
+                  systemGuidance: compileLoopPreflight.message
                 };
               }
               this.emit({
@@ -598607,7 +598734,6 @@ ${cachedResult}`,
               const tool = resolvedTool?.tool;
               let result;
               let runtimeSystemGuidance = null;
-              let toolActionReason = actionReasonForAdvisory;
               if (repeatShortCircuit) {
                 result = repeatShortCircuit;
               } else if (tc.arguments && "_raw" in tc.arguments) {
@@ -598623,12 +598749,12 @@ ${cachedResult}`,
                   error: this.unknownToolError(tc.name)
                 };
               } else {
-                let validationError = this._validateToolActionReason(resolvedTool?.name ?? tc.name, tc.arguments ?? {});
+                let validationError = null;
                 if (!validationError) {
-                  tc.arguments = this._stripToolActionReasonArgs(tc.arguments ?? {});
+                  tc.arguments = this._stripLegacyActionReasonArgs(tc.arguments ?? {});
                   tc.arguments = this._normalizeToolArgsForExecution(resolvedTool?.name ?? tc.name, tc.arguments ?? {});
                   tc.arguments = this._autoDeriveDelegationMutationScope(resolvedTool?.name ?? tc.name, tc.arguments ?? {}, turn);
-                  validationError = this._validateFileWriteOverwriteContract(resolvedTool?.name ?? tc.name, tc.arguments ?? {}, toolActionReason);
+                  validationError = this._validateFileWriteOverwriteContract(resolvedTool?.name ?? tc.name, tc.arguments ?? {});
                 }
                 if (!validationError) {
                   validationError = this._validateFreshExpectedHashesForEdit(resolvedTool?.name ?? tc.name, tc.arguments ?? {});
@@ -598881,8 +599007,7 @@ Respond with EXACTLY this structure before your next tool call:
                 toolName: resolvedTool?.name ?? tc.name,
                 toolCallId: tc.id,
                 args: tc.arguments,
-                result,
-                actionReason: toolActionReason
+                result
               });
               if (observedStateMutation) {
                 this._markAdversaryObservedStateMutation();
@@ -599634,24 +599759,12 @@ Respond with EXACTLY this structure before your next tool call:
               }
               const cacheableMemoryNoop = tc.name === "memory_write" && result.success && result.noop;
               const cacheableProjectWriteNoop = this._isProjectEditTool(tc.name) && result.success && !this._isRealProjectMutation(tc.name, result) && (result.noop === true || result.mutated === false);
-              const cacheableShellResult = tc.name === "shell" && result.runtimeAuthored !== true && !shellLikelyMutatesFilesystem;
-              if (isReadLike && result.success && result.runtimeAuthored !== true || cacheableShellResult || cacheableMemoryNoop || cacheableProjectWriteNoop) {
+              if (cacheableMemoryNoop || cacheableProjectWriteNoop) {
                 recentToolResults.set(toolFingerprint, {
-                  result: tc.name === "shell" ? this._buildShellCacheResult(tc.arguments, result) : (
-                    // Read-like results are SERVED BACK to the model when the
-                    // repeat gate fires, so they must stay complete enough to
-                    // edit against — truncating to 2KB cut the tail off normal
-                    // source files (the "old_string not found" cascade). Large
-                    // files are handled by branch-extract upstream, so 16KB
-                    // here covers ordinary files without bloating the cache.
-                    isReadLike ? this.sanitizeCachedToolResult(tc.name, result.output ?? "").slice(0, 16e3) : (result.output ?? "").slice(0, 2e3)
-                  ),
+                  result: (result.output ?? "").slice(0, 2e3),
                   compacted: false,
                   mutationEpoch: fileMutationEpoch
                 });
-                if (isReadLike && result.success) {
-                  this._registerReadCoverage(tc.name, tc.arguments ?? {}, toolFingerprint);
-                }
                 if (recentToolResults.size > 500) {
                   const firstKey = recentToolResults.keys().next().value;
                   if (firstKey !== void 0) {
@@ -600164,7 +600277,6 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                   turn,
                   toolName: tc.name,
                   args: tc.arguments ?? {},
-                  actionReason: toolActionReason,
                   fingerprint: toolFingerprint,
                   success: result.success,
                   output: result.output ?? result.llmContent ?? "",
@@ -600200,8 +600312,7 @@ ${structuralGuardGuidance}` : structuralGuardGuidance;
               }
               if (tc.name === "shell" && result.runtimeAuthored !== true) {
                 const shellCommand = String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? "");
-                const compileOutput = `${result.output ?? ""}
-${result.error ?? ""}`;
+                const compileOutput = this._expandTriagedPayloadForDiagnostics([result.output, result.llmContent, result.error].filter((part) => typeof part === "string" && part.length > 0).join("\n"));
                 const verifierCommand = this._declaredVerifierCommandForShell(shellCommand, compileOutput);
                 if (verifierCommand) {
                   const compileGuidance = this._observeCompileVerifierResult({
@@ -600377,7 +600488,6 @@ ${delegateDir}` : delegateDir;
                     reason: focusDecision.directive.reason,
                     requiredNextAction: focusDecision.directive.requiredNextAction
                   },
-                  actionReason: toolActionReason ?? void 0,
                   repeatShortCircuit: Boolean(repeatShortCircuit),
                   runtimeAuthored: result.runtimeAuthored === true,
                   runtimeGuidance: runtimeSystemGuidance,
@@ -600415,20 +600525,20 @@ ${delegateDir}` : delegateDir;
                 if (sameToolFailStreak >= 5 && (this.options.modelTier === "small" || this.options.modelTier === "medium")) {
                   this.enqueueRuntimeGuidance(`[BRANCH — evaluate alternatives before acting]
 Tool "${tc.name}" has failed ${sameToolFailStreak} times. STOP and enumerate:
-Option A: [describe a completely different approach]
-Option B: [describe another alternative]
-Option C: [the simplest possible fallback]
-Pick the BEST option and explain why, then execute it. Do NOT retry ${tc.name} with similar arguments.`);
+Option A: refresh the exact evidence or correct the current tool arguments
+Option B: use a different narrow diagnostic or targeted edit transport
+Option C: verify whether the desired change is already present
+Pick the BEST option and explain why, then execute it. Do NOT retry ${tc.name} with similar arguments, and do not broaden a local edit into file_write.`);
                   sameToolFailStreak = 0;
                   sameToolFailName = null;
                 }
                 if (consecutiveSameTool >= 2 && (this.options.modelTier === "small" || this.options.modelTier === "medium")) {
                   this.enqueueRuntimeGuidance(`[PIVOT REQUIRED] You have failed ${consecutiveSameTool + 1} times in a row with ${tc.name}. Your current approach is not working. You MUST try something fundamentally different:
-- If file_edit keeps failing: re-read the file first, then use the EXACT text from the file
+- If file_edit/file_patch keeps failing: re-read the implicated current range, then correct the exact text/range/hash or inspect git diff
 - If shell keeps failing: try a different command or check prerequisites
 - If grep_search finds nothing: try broader patterns or list_directory
-- Consider using a completely different tool or strategy
-Do NOT retry ${tc.name} with similar arguments.`);
+- A different strategy means a different diagnosis or narrow transport, never a whole-file rewrite fallback
+Do NOT retry ${tc.name} with similar arguments and do NOT use file_write to escape a targeted-edit failure.`);
                 }
                 if (!this._taskState.failedApproaches.includes(failDesc)) {
                   this._taskState.failedApproaches.push(failDesc);
@@ -600602,7 +600712,6 @@ Then use file_read on individual FILES inside it.`);
                 toolName: tc.name,
                 argsKey: tc.arguments ? JSON.stringify(tc.arguments) : "",
                 args: tc.arguments,
-                actionReason: toolActionReason,
                 result,
                 outputPreview: this._toolEvidencePreview(result, output, 1200, tc.name),
                 realFileMutation,
@@ -603052,200 +603161,24 @@ ${marker}` : marker);
         }
         return matchesFresh(args);
       }
-      _toolActionReasonPolicy(toolName, args) {
-        if (process.env["OMNIUS_DISABLE_TOOL_ACTION_REASON"] === "1") {
-          return "disabled";
-        }
-        if ((process.env["VITEST"] || process.env["NODE_ENV"] === "test") && process.env["OMNIUS_REQUIRE_TOOL_ACTION_REASON"] !== "1") {
-          return "disabled";
-        }
-        if (this.options.artifactMode === "internal")
-          return "disabled";
-        if (toolName.startsWith("__"))
-          return "disabled";
-        return this._toolActionReasonIsOptional(toolName, args) ? "optional" : "required";
-      }
-      _requiresToolActionReason(toolName, args) {
-        return this._toolActionReasonPolicy(toolName, args) === "required";
-      }
-      _toolActionReasonIsOptional(toolName, args) {
-        const resolved = this.lookupRegisteredTool(toolName);
-        const canonical = resolved?.name ?? toolName;
-        if (READ_ONLY_ACTION_REASON_OPTIONAL_TOOLS.has(canonical))
-          return true;
-        const tool = resolved?.tool;
-        if (typeof tool?.isReadOnly === "function") {
-          try {
-            if (tool.isReadOnly(args ?? {}))
-              return true;
-          } catch {
-          }
-        }
-        return false;
-      }
-      _withToolActionReasonSchema(toolName, parameters) {
-        const policy = this._toolActionReasonPolicy(toolName);
-        if (policy === "disabled") {
-          return parameters ?? { type: "object", properties: {} };
-        }
+      _publicToolParameters(parameters) {
         const base3 = parameters && typeof parameters === "object" && !Array.isArray(parameters) ? { ...parameters } : { type: "object" };
         const properties = base3["properties"] && typeof base3["properties"] === "object" && !Array.isArray(base3["properties"]) ? { ...base3["properties"] } : {};
-        properties["action_reason"] = TOOL_ACTION_REASON_SCHEMA;
-        const required = Array.isArray(base3["required"]) ? base3["required"].map(String) : [];
+        for (const key of LEGACY_ACTION_REASON_KEYS)
+          delete properties[key];
+        const required = Array.isArray(base3["required"]) ? base3["required"].map(String).filter((key) => !LEGACY_ACTION_REASON_KEYS.has(key)) : [];
         return {
           ...base3,
           type: "object",
           properties,
-          required: policy === "required" ? [.../* @__PURE__ */ new Set([...required, "action_reason"])] : required
-        };
-      }
-      _extractToolActionReason(args) {
-        let raw = args["action_reason"] ?? args["actionReason"] ?? args["justification"];
-        if (typeof raw === "string") {
-          const trimmed = raw.trim();
-          if (!trimmed)
-            return null;
-          try {
-            raw = JSON.parse(trimmed);
-          } catch {
-            return { intent: trimmed };
-          }
-        }
-        if (!raw || typeof raw !== "object" || Array.isArray(raw))
-          return null;
-        const rec = raw;
-        const reason = {
-          task_anchor: String(rec["task_anchor"] ?? rec["taskAnchor"] ?? "").trim(),
-          intent: String(rec["intent"] ?? "").trim(),
-          evidence: String(rec["evidence"] ?? "").trim(),
-          expected_result: String(rec["expected_result"] ?? rec["expectedResult"] ?? "").trim(),
-          scope: String(rec["scope"] ?? "").trim()
-        };
-        return reason;
-      }
-      _toolActionReasonForCall(toolName, args) {
-        const explicit = this._extractToolActionReason(args);
-        if (explicit) {
-          return this._completeToolActionReason(toolName, args, explicit);
-        }
-        if (this._shouldSynthesizeMissingToolActionReason(toolName, args)) {
-          return this._synthesizeStateUpdateToolActionReason(toolName, args);
-        }
-        if (this._toolActionReasonPolicy(toolName, args) !== "optional")
-          return null;
-        return this._synthesizeReadOnlyToolActionReason(toolName, args);
-      }
-      _completeToolActionReason(toolName, args, partial) {
-        const canonical = this.lookupRegisteredTool(toolName)?.name ?? toolName;
-        const goal = this._taskState.currentStep || this._taskState.nextAction || this._taskState.goal || this._taskState.originalGoal || "current task";
-        const targetPaths = this._extractToolTargetPaths(canonical, args).slice(0, 3);
-        const targetText = targetPaths.length > 0 ? ` for ${targetPaths.join(", ")}` : "";
-        const scope = TOOL_ACTION_REASON_SCOPES.has(String(partial.scope ?? "")) ? String(partial.scope) : this._defaultToolActionReasonScope(canonical);
-        return {
-          task_anchor: cleanToolActionReasonField(partial.task_anchor) || String(goal).replace(/\s+/g, " ").trim().slice(0, 160),
-          intent: cleanToolActionReasonField(partial.intent) || `Run ${canonical}${targetText} for the active task.`,
-          evidence: cleanToolActionReasonField(partial.evidence) || "Runtime completed partial public action metadata from the tool call contract before execution.",
-          expected_result: cleanToolActionReasonField(partial.expected_result) || this._defaultToolActionExpectedResult(canonical, targetText),
-          scope
-        };
-      }
-      _defaultToolActionReasonScope(toolName) {
-        if (toolName === "file_edit" || toolName === "file_patch" || toolName === "batch_edit") {
-          return "targeted_patch";
-        }
-        if (toolName === "create_structured_file")
-          return "new_file";
-        if (toolName === "task_complete")
-          return "completion";
-        if (READ_ONLY_ACTION_REASON_OPTIONAL_TOOLS.has(toolName))
-          return "discovery";
-        return "other";
-      }
-      _defaultToolActionExpectedResult(toolName, targetText) {
-        switch (toolName) {
-          case "file_edit":
-            return `Requested exact edit is applied${targetText}, or a precise edit error is returned.`;
-          case "file_patch":
-            return `Requested line patch is applied${targetText}, or a precise patch error is returned.`;
-          case "batch_edit":
-            return `Requested edit batch is applied${targetText}, or per-edit failure evidence is returned.`;
-          case "file_write":
-            return `Requested file content is written${targetText}, or a precise write error is returned.`;
-          case "shell":
-            return "Command exits with output evidence for the next decision.";
-          default:
-            return `${toolName} completes and returns success or failure evidence.`;
-        }
-      }
-      _shouldSynthesizeMissingToolActionReason(toolName, _args) {
-        if (this._toolActionReasonPolicy(toolName, _args) === "disabled") {
-          return false;
-        }
-        const canonical = this.lookupRegisteredTool(toolName)?.name ?? toolName;
-        return STATE_UPDATE_ACTION_REASON_SYNTHESIS_TOOLS.has(canonical);
-      }
-      _synthesizeStateUpdateToolActionReason(toolName, args) {
-        const canonical = this.lookupRegisteredTool(toolName)?.name ?? toolName;
-        const goal = this._taskState.currentStep || this._taskState.nextAction || this._taskState.goal || this._taskState.originalGoal || "current task";
-        const todoCount = Array.isArray(args["todos"]) ? args["todos"].length : null;
-        return {
-          task_anchor: String(goal).replace(/\s+/g, " ").trim().slice(0, 160),
-          intent: `Update visible task state with ${canonical}.`,
-          evidence: todoCount === null ? "Model omitted public action_reason; runtime synthesized bookkeeping metadata without authorizing project mutation." : `Model supplied ${todoCount} todo item(s); runtime synthesized bookkeeping metadata without authorizing project mutation.`,
-          expected_result: "Session checklist reflects the current task state.",
-          scope: "state_update"
-        };
-      }
-      _synthesizeReadOnlyToolActionReason(toolName, args) {
-        const canonical = this.lookupRegisteredTool(toolName)?.name ?? toolName;
-        const goal = this._taskState.currentStep || this._taskState.nextAction || this._taskState.goal || this._taskState.originalGoal || "current task";
-        const targets = this._extractToolTargetPaths(canonical, args).slice(0, 3);
-        const targetText = targets.length > 0 ? ` for ${targets.join(", ")}` : "";
-        return {
-          task_anchor: String(goal).replace(/\s+/g, " ").trim().slice(0, 160),
-          intent: `Run read-only ${canonical}${targetText} to gather current evidence.`,
-          evidence: "Read-only metadata fallback; no project mutation is authorized by this action.",
-          expected_result: `Current ${canonical} evidence for the next decision.`,
-          scope: "discovery"
+          required
         };
       }
-      _validateToolActionReason(toolName, args) {
-        const policy = this._toolActionReasonPolicy(toolName, args);
-        if (policy === "disabled")
-          return null;
-        const raw = args["action_reason"] ?? args["actionReason"] ?? args["justification"];
-        if (!raw || typeof raw === "string" && !raw.trim()) {
-          if (policy === "optional")
-            return null;
-          if (this._shouldSynthesizeMissingToolActionReason(toolName, args)) {
-            return null;
-          }
-          return [
-            "[TOOL ACTION REASON CONTRACT]",
-            `This side-effectful tool call must include action_reason: { task_anchor, intent, evidence, expected_result, scope }.`,
-            `Use compact public facts only; do not include hidden chain-of-thought.`,
-            `scope must be one of: ${Array.from(TOOL_ACTION_REASON_SCOPES).join(", ")}.`
-          ].join("\n");
-        }
-        const partialReason = this._extractToolActionReason(args);
-        if (!partialReason) {
-          if (policy === "optional")
-            return null;
-          return "[TOOL ACTION REASON CONTRACT] action_reason must be an object with compact public task-state fields.";
-        }
-        const reason = this._completeToolActionReason(toolName, args, partialReason);
-        if (!TOOL_ACTION_REASON_SCOPES.has(reason.scope)) {
-          if (policy === "optional")
-            return null;
-          return `[TOOL ACTION REASON CONTRACT] action_reason.scope="${reason.scope}" is invalid. Use one of: ${Array.from(TOOL_ACTION_REASON_SCOPES).join(", ")}.`;
-        }
-        return null;
-      }
-      _stripToolActionReasonArgs(args) {
+      _stripLegacyActionReasonArgs(args) {
         let changed = false;
         const next = {};
         for (const [key, value2] of Object.entries(args)) {
-          if (TOOL_ACTION_REASON_KEYS.has(key)) {
+          if (LEGACY_ACTION_REASON_KEYS.has(key)) {
             changed = true;
             continue;
           }
@@ -603362,7 +603295,7 @@ ${marker}` : marker);
         }
         return next;
       }
-      _validateFileWriteOverwriteContract(toolName, args, actionReason) {
+      _validateFileWriteOverwriteContract(toolName, args) {
         if (toolName !== "file_write")
           return null;
         if (process.env["OMNIUS_ALLOW_UNVERIFIED_FILE_WRITE_OVERWRITE"] === "1") {
@@ -603384,20 +603317,13 @@ ${marker}` : marker);
         }
         if (!exists2)
           return null;
-        if (actionReason && actionReason.scope !== "full_file_rewrite") {
-          return [
-            "[FULL FILE REWRITE CONTRACT]",
-            `file_write targets an existing file: ${path16}.`,
-            `For constrained repairs, use file_patch, batch_edit, or file_edit instead of rewriting the full file.`,
-            `If a whole-file replacement is truly intended, set action_reason.scope="full_file_rewrite" and use expected_hash from a fresh file_read.`
-          ].join("\n");
-        }
         if (!this._toolCallUsesFreshFileReadEvidence(toolName, args)) {
           const fresh = this._freshReadHashForEditPath(path16);
           return [
             "[FULL FILE REWRITE CONTRACT]",
             `file_write would overwrite existing file ${path16}, but it is not anchored to fresh file_read evidence.`,
-            fresh ? `Use expected_hash=${fresh.hash} from the current active evidence, or prefer file_patch/batch_edit for a constrained change.` : `First file_read ${path16}, then prefer file_patch/batch_edit; only retry file_write with expected_hash if a whole-file rewrite is necessary.`
+            "file_write is reserved for new, empty/placeholder, or genuinely small files needing deliberate total replacement; it is never recovery for a failed local edit.",
+            fresh ? `Use expected_hash=${fresh.hash} from the current active evidence, or prefer file_patch/batch_edit for a constrained change.` : `First file_read ${path16}, then prefer file_patch/batch_edit; only retry file_write with expected_hash if a whole-file replacement is necessary.`
           ].join("\n");
         }
         return null;
@@ -605157,9 +605083,9 @@ ${postCompactRestore.join("\n")}`);
 
 **IMPORTANT:** You MUST invoke tools through the function calling interface. Do NOT write tool names as text, markdown, or code blocks — that does nothing. Call tools using the structured tool/function API.` : "";
         const readFilesList = Array.from(this._fileRegistry.entries()).filter(([, e2]) => e2.accessCount > 0).map(([p2]) => p2).slice(0, 10);
-        const antiRepetitionReminder = (tier === "small" || tier === "medium") && readFilesList.length > 0 ? `
+        const fileFreshnessReminder = (tier === "small" || tier === "medium") && readFilesList.length > 0 ? `
 
-**DO NOT RE-READ THESE FILES** (you already have their contents): ${readFilesList.join(", ")}. Use the information above to make progress. Reading the same file again wastes a turn.` : "";
+**PREVIOUSLY OBSERVED FILES:** ${readFilesList.join(", ")}. Treat restored or summarized text as orientation, not guaranteed current bytes. Before editing, make a narrow live read when the body is elided/truncated, the file may have changed, a hash or edit anchor is stale, or exact current text is otherwise required. Avoid only redundant reads when the latest complete authoritative content is still visible and unchanged.` : "";
         const ephemeralSkillPackReminder = this._ephemeralSkillPackContext ? `
 
 [Ephemeral skill-pack restore — current run only, do not persist]
@@ -605177,11 +605103,11 @@ ${scopedStickyDynamicContext}` : "";
 ${fullSummary}
 </compaction-summary>
 
-[Continue from the recent context below. Do not repeat work already completed above.]${goalReminder}${nextActionDirective}${antiRepetitionReminder}${stickyDynamicContextReminder}${ephemeralSkillPackReminder}${toolCallingReminder}` : `[Context compacted${strategyLabel} — summary of earlier work]
+[Continue from the recent context below. Do not repeat work already completed above.]${goalReminder}${nextActionDirective}${fileFreshnessReminder}${stickyDynamicContextReminder}${ephemeralSkillPackReminder}${toolCallingReminder}` : `[Context compacted${strategyLabel} — summary of earlier work]
 
 ${fullSummary}
 
-[Continue from the recent context below. Do not repeat work already completed above.]${goalReminder}${nextActionDirective}${antiRepetitionReminder}${stickyDynamicContextReminder}${ephemeralSkillPackReminder}${toolCallingReminder}`
+[Continue from the recent context below. Do not repeat work already completed above.]${goalReminder}${nextActionDirective}${fileFreshnessReminder}${stickyDynamicContextReminder}${ephemeralSkillPackReminder}${toolCallingReminder}`
         };
         this.persistCheckpoint(fullSummary);
         let narrowedHead = [...head];
@@ -605242,10 +605168,11 @@ ${telegramPersonaHead}` : stripped
               const tokenEst = Math.ceil(content.length / 4);
               if (recoveredTokens + tokenEst > fileRecoveryBudget)
                 break;
+              const truncated = content.length > 8e3;
               result.push({
                 role: "system",
-                content: `<recovered-file path="${filePath}" status="${entry.modified ? "modified" : "read"}">
-${content.slice(0, 8e3)}
+                content: `<recovered-file path="${filePath}" status="${entry.modified ? "modified" : "read"}" truncated="${truncated}">
+${content.slice(0, 8e3)}${truncated ? "\n[truncated recovery; use a narrow live read for omitted/current text]" : ""}
 </recovered-file>`
               });
               recoveredFiles.push(filePath);
@@ -605532,7 +605459,6 @@ ${trimmedNew}`;
           fingerprint,
           stateVersion: this._adversaryStateVersion,
           succeeded: input.result.success === true,
-          actionReason: input.actionReason,
           ...outcomeEvidence
         });
         while (this._recentToolOutcomes.length > 40) {
@@ -605678,7 +605604,6 @@ ${trimmedNew}`;
               args = JSON.parse(tc.function.arguments);
             } catch {
             }
-            const actionReason = this._toolActionReasonForCall(name10, args);
             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.stateVersion === this._adversaryStateVersion && o2.turn < turn);
@@ -605692,7 +605617,6 @@ ${trimmedNew}`;
                   tool: name10,
                   target: argsKey.slice(0, 180),
                   count: repeatCount,
-                  actionReason: actionReason ?? void 0,
                   alreadyHave: prior.preview
                 }
               }, `possible repeated action ${name10} after prior same-state success`);
@@ -606926,7 +606850,7 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
             function: {
               name: tool.name,
               description: compressDesc ? (desc.split(/\.\s/)[0]?.slice(0, 120) ?? desc.slice(0, 120)) + "." : desc,
-              parameters: this._withToolActionReasonSchema(tool.name, tool.parameters)
+              parameters: this._publicToolParameters(tool.parameters)
             }
           };
         });
@@ -606948,7 +606872,7 @@ Example: ${tool.name}(${JSON.stringify(meta.examples[0].args ?? {})})` : "";
 
 Available tools (${deferred.length}):
 ${catalog}`,
-              parameters: this._withToolActionReasonSchema("tool_search", {
+              parameters: this._publicToolParameters({
                 type: "object",
                 properties: {
                   query: {
@@ -606999,7 +606923,7 @@ ${catalog}`,
                       lines.push(`Aliases: ${tool.aliases.join(", ")}`);
                     }
                     lines.push(`${getDesc(tool)}${customToolDetails(tool)}`);
-                    lines.push(`Parameters: ${JSON.stringify(this._withToolActionReasonSchema(tool.name, tool.parameters))}`);
+                    lines.push(`Parameters: ${JSON.stringify(this._publicToolParameters(tool.parameters))}`);
                   }
                 }
                 if (alreadyAvailable.length > 0) {
@@ -607051,7 +606975,7 @@ ${catalog}`,
               for (const t2 of matches)
                 activatedToolsRef.add(t2.name);
               const result = matches.map((t2) => {
-                const paramsStr = JSON.stringify(this._withToolActionReasonSchema(t2.name, t2.parameters), null, 2);
+                const paramsStr = JSON.stringify(this._publicToolParameters(t2.parameters), null, 2);
                 const aliases = t2.aliases?.length ? `
 Aliases: ${t2.aliases.join(", ")}` : "";
                 return `## ${t2.name}${aliases}