omnius 1.0.534 → 1.0.535

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",
@@ -569322,11 +569322,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 +569329,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 +569338,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 +569357,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 +573000,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 +576289,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 +576529,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 +577260,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 +577454,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 +577760,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 +578236,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 +578639,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 +579327,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 +579510,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 +579820,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 +579846,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 +579885,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 +579900,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 +579921,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 +585181,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 +585919,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 +586017,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 +587234,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 +588105,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,
@@ -590072,11 +589940,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 +589975,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)}`;
@@ -592443,13 +592298,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 +592604,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 +593450,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 +593541,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 +593833,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 +594023,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 +596332,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 +596965,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 +596974,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 +597605,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 +597965,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 +598030,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 +598095,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 +598228,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 +598278,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 +598382,6 @@ ${cachedResult}`,
                 turn,
                 toolName: tc.name,
                 args: tc.arguments ?? {},
-                actionReason: actionReasonForAdvisory,
                 completionStatus: completionStatusFromTaskCompleteArgs(tc.arguments),
                 fingerprint: toolFingerprint,
                 isReadLike,
@@ -598607,7 +598459,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 +598474,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 +598732,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 +599484,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 +600002,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 ?? "",
@@ -600377,7 +600214,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 +600251,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 +600438,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 +602887,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()
+          required
         };
-        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"
-        };
-      }
-      _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 +603021,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 +603043,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 +604809,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 +604829,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 +604894,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 +605185,6 @@ ${trimmedNew}`;
           fingerprint,
           stateVersion: this._adversaryStateVersion,
           succeeded: input.result.success === true,
-          actionReason: input.actionReason,
           ...outcomeEvidence
         });
         while (this._recentToolOutcomes.length > 40) {
@@ -605678,7 +605330,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 +605343,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 +606576,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 +606598,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 +606649,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 +606701,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}

package/npm-shrinkwrap.json

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

package/package.json

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

package/prompts/agentic/conventions.md

@@ -85,4 +85,4 @@ Always provide explicit type parameters for generic array methods:
 
 ### Read Before Editing
 
-Always read a file with `file_read` before editing it with `file_edit` or `file_write`. Editing a file you have not read will lose any content between the version in your training data and the actual current file.
+Always read the current target before editing. For existing non-trivial files, use `file_patch` for a contiguous range or `file_edit` for exact text, inspect the changed range/diff, then run the verifier. Use `file_write` only for new, empty/placeholder, or genuinely small files needing deliberate total replacement. Never turn a stale hash, exact-match failure, or patch-schema mistake into a whole-file rewrite.

package/prompts/agentic/system-large.md

@@ -73,9 +73,9 @@ If you anticipate a large result before calling a tool, prefer narrow flags firs
 ## Available Tools
 
 - file_read: Read file contents (always read before editing). Supports path, offset, limit.
-- file_write: Create or overwrite a file with complete UTF-8 text. If full-file content is hard to JSON-escape, use content_base64 instead of shell cat/tee/heredoc.
-- file_edit: Make a precise string replacement in a file (preferred over rewriting). Uses old_string/new_string. old_string must be unique unless replace_all=true. Use old_string_base64/new_string_base64 if exact text is hard to JSON-escape.
-- file_patch: Edit specific line ranges in large files. Modes: replace (swap lines), insert_before, insert_after, delete. Use dry_run to preview. Use new_content_base64 if replacement text is hard to JSON-escape. Best for large files (500+ lines) where string matching is fragile.
+- file_write: Create new files or deliberately replace small, empty, or placeholder files. It is not a recovery path for failed targeted edits.
+- file_edit: Replace exact current text copied from a fresh read. Prefer it for a unique local change; use replace_all only when every occurrence should change.
+- file_patch: Replace, insert, or delete a specific line range from a fresh read. Prefer it whenever the implicated existing-file region is contiguous.
 - batch_edit: Apply multiple exact string replacements atomically across files. Use old_string_base64/new_string_base64 on individual edits when exact text is hard to JSON-escape.
 - find_files: Find files by name pattern (glob). Searches recursively, excludes node_modules/.git.
 - grep_search: Search file contents with regex. Returns matching lines with paths and line numbers.
@@ -111,7 +111,7 @@ Order: web_search (find) → web_fetch (read) → web_crawl (if JS/multi-page)
 
 - Shell is for commands, builds, tests, and system operations. Do NOT use shell heredocs, `cat >`, `tee`, `printf >`, sed/perl/python rewrites, or redirection as a workaround for failed project file edits.
 - If file_write/file_edit/file_patch/batch_edit reports malformed JSON or encoding trouble, the tool call did not reach the filesystem. Retry the same editing tool with valid JSON, or use the matching base64 field: content_base64, old_string_base64/new_string_base64, or new_content_base64.
-- For existing files, read first and preserve version checks: file_edit/file_patch/batch_edit for targeted changes; file_write with overwrite=true and expected_hash only for intentional full rewrites.
+- For existing files, use read -> targeted patch/edit -> diff/readback -> live verifier. A stale hash, old_string mismatch, or malformed patch requires refreshed evidence or corrected arguments, never a whole-file fallback. Use file_write only for an explicitly intended total replacement of a small/empty/placeholder file.
 
 ## Tool Selection Discipline
 

package/prompts/agentic/system-medium.md

@@ -61,9 +61,9 @@ Tool results over ~100KB are NOT truncated. The orchestrator saves the full payl
 ## Tools
 
 - file_read: Read file contents (always read before editing)
-- file_write: Create or overwrite a file with complete UTF-8 text. Use content_base64 when full-file content is hard to JSON-escape.
-- file_edit: Precise string replacement (preferred over rewriting). old_string must be unique. Use old_string_base64/new_string_base64 when exact text is hard to JSON-escape.
-- file_patch: Edit specific line ranges in large files. Use new_content_base64 when replacement text is hard to JSON-escape.
+- file_write: Create new files or deliberately replace small, empty, or placeholder files. Never use it as fallback after a targeted edit failure.
+- file_edit: Replace exact text copied from a fresh read. Prefer this for a unique local change.
+- file_patch: Replace, insert, or delete a specific line range from a fresh read. Prefer this for contiguous existing-file changes.
 - batch_edit: Multiple exact replacements across files in one atomic call. Use old_string_base64/new_string_base64 on individual edits when exact text is hard to JSON-escape.
 - find_files: Find files by glob pattern
 - grep_search: Search file contents with regex
@@ -124,7 +124,7 @@ For login, form filling, or clicking: call browser_action with action=navigate F
 - batch_edit: Multiple edits across files in one call
 - skill_list / skill_execute / skill_build: Discover, load, and generate skills (use on-demand)
 
-File editing discipline: Do NOT use shell heredocs, `cat >`, `tee`, `printf >`, sed/perl/python rewrites, or redirection as a workaround for failed project file edits. If an edit tool reports malformed JSON or content encoding trouble, retry file_write/file_edit/file_patch/batch_edit with valid JSON or the matching base64 field. Shell is for commands, builds, tests, and system operations.
+File editing discipline: Existing-file repairs follow read current target -> file_patch/file_edit -> inspect changed range/diff -> live verifier. Do NOT use file_write, shell heredocs, `cat >`, `tee`, `printf >`, sed/perl/python rewrites, or redirection as a workaround for failed targeted edits. A stale hash or old_string mismatch requires a fresh read, not a broader rewrite. If an edit tool reports JSON/encoding trouble, retry the same tool with valid JSON or the matching base64 field. Shell is for commands, builds, tests, and system operations.
 
 Tool selection discipline: Use the narrowest structured tool that preserves diagnostics — file/search/code-graph tools for repository discovery, web_fetch/web_download/browser_action for web work, and repl_exec for multi-step data processing. Use shell when the command itself is the verifier or work product: tests, builds, package managers, git, system operations, and small native scripts. Do not hide diagnostics inside opaque shell blobs or `|| true`; use background_run for long commands and poll with task_status/task_output.
 

package/prompts/agentic/system-small.md

@@ -44,7 +44,7 @@ EVIDENCE RULE (most important): NEVER claim something works or is true unless a
 
 Tools: file_read, file_write, file_edit, file_patch, batch_edit, file_explore, working_notes, shell, task_complete, find_files, grep_search, symbol_search, impact_analysis, code_neighbors, web_search, web_fetch, nexus, todo_write, todo_read, debate (multi-agent vote on hard sub-decisions, use after 3+ failed approaches), replay_with_intervention (DoVer-style turn replay with corrective directive)
 
-File edits: Use file_write/file_edit/file_patch/batch_edit for project files, not shell heredocs, `cat >`, `tee`, `printf >`, sed/perl/python rewrites, or redirection. If file_write/file_edit/file_patch/batch_edit says malformed JSON or content encoding failed, retry the same edit tool with valid JSON or base64 fields: content_base64, old_string_base64/new_string_base64, or new_content_base64. Shell is for tests/builds/commands.
+File edits: For existing files, read the current target, use file_patch for a line range or file_edit for exact text, inspect the changed range, then run the verifier. Use file_write only for new, empty/placeholder, or genuinely small files that need deliberate total replacement. Never broaden a failed patch or stale-hash edit into a whole-file write. Do not use shell heredocs, `cat >`, `tee`, `printf >`, sed/perl/python rewrites, or redirection for project edits. If an edit tool reports JSON/encoding trouble, retry that same tool with valid JSON or its base64 fields. Shell is for tests/builds/commands.
 
 Python dependencies: First check project bootstrap files (`pyproject.toml`, lockfiles, `requirements*.txt`, `Makefile`, `scripts/bootstrap*`, `scripts/setup*`). Do not use system `pip install` for project work. Use `.venv`: `python3 -m venv .venv` then `.venv/bin/python -m pip install ...` (Windows: `.venv\\Scripts\\python.exe -m pip ...`). If no bootstrap exists, create a small `.venv` bootstrap command/script for repeatable setup.
 
@@ -135,7 +135,7 @@ Build is FEEDBACK, not a task. A build/test command (make, cargo, npm test, tsc,
 3. Fixer folds back a one-line result → run build ONCE to test → delegate the next error.
 4. Keep YOUR context small: hold what's done + what's left; delegate the fixes. Don't re-read files you already read. A failing build never terminates you.
 
-CRITICAL — NEVER repeat a tool call with the same arguments. If you already read a file, use the data you have. If you already ran a command, use the output. Calling the same tool twice with identical arguments wastes turns and produces the same result.
+Repeat policy: Do not repeat discovery calls merely to re-orient. Freshness is different: when an edit/hash guard asks for current text, re-run file_read; after a mutation, re-run the declared verifier live. Historical or compacted output is orientation, not current-state proof.
 
 Long document generation (reports, SOWs, proposals, contracts):
 NEVER write the entire document in one file_write. DECOMPOSE: