omnius 1.0.456 → 1.0.458

package/dist/index.js

@@ -14315,7 +14315,7 @@ var init_file_edit = __esm({
           path: { type: "string", description: "Absolute or relative file path" },
           old_string: {
             type: "string",
-            description: "The exact string to search for and replace. Must be unique in the file (or use replace_all). Use old_string_base64 when JSON escaping is fragile."
+            description: "The exact current string to search for and replace, copied from the most recent file_read for this file. Must be unique in the file (or use replace_all). Use old_string_base64 when JSON escaping is fragile."
           },
           old_string_base64: {
             type: "string",
@@ -14340,14 +14340,14 @@ var init_file_edit = __esm({
           },
           expected_hash: {
             type: "string",
-            description: "Optional SHA-256 from the most recent file_read. If provided, edit is refused when the file changed."
+            description: "SHA-256 from the most recent file_read for this file. The runner refuses unverified exact replacements that omit or mismatch this hash."
           },
           dry_run: {
             type: "boolean",
             description: "Validate the edit and preview the diff without modifying disk."
           }
         },
-        required: ["path"],
+        required: ["path", "expected_hash"],
         allOf: [
           { anyOf: [{ required: ["old_string"] }, { required: ["old_string_base64"] }] },
           { anyOf: [{ required: ["new_string"] }, { required: ["new_string_base64"] }] }
@@ -28570,7 +28570,7 @@ var init_batch_edit = __esm({
                 },
                 old_string: {
                   type: "string",
-                  description: "Exact string to find and replace (must be unique unless replace_all). Use old_string_base64 when JSON escaping is fragile."
+                  description: "Exact current string to find and replace, copied from the most recent file_read for this file. Must be unique unless replace_all. Use old_string_base64 when JSON escaping is fragile."
                 },
                 old_string_base64: {
                   type: "string",
@@ -28595,10 +28595,10 @@ var init_batch_edit = __esm({
                 },
                 expected_hash: {
                   type: "string",
-                  description: "SHA-256 from the most recent file_read for this file. All edits for a file must use the same hash if provided."
+                  description: "SHA-256 from the most recent file_read for this file. All edits for a file must use the same verified hash."
                 }
               },
-              required: ["path"],
+              required: ["path", "expected_hash"],
               allOf: [
                 { anyOf: [{ required: ["old_string"] }, { required: ["old_string_base64"] }] },
                 { anyOf: [{ required: ["new_string"] }, { required: ["new_string_base64"] }] }
@@ -566824,6 +566824,7 @@ function shouldIgnore(relPath, base3, patterns) {
 function scanWorkspace(opts) {
   const root = opts.root;
   const maxFiles = Math.max(1, Math.min(2e3, opts.maxFiles ?? 200));
+  const maxDirs = Math.max(1, Math.min(5e3, opts.maxDirs ?? 1e3));
   const noGitignore = opts.noGitignore === true;
   const noDefaults = opts.noDefaults === true;
   const patterns = [];
@@ -566834,6 +566835,7 @@ function scanWorkspace(opts) {
   if (opts.extraIgnore)
     patterns.push(...opts.extraIgnore);
   const files = [];
+  const dirs = [];
   let totalBytes = 0;
   let truncated = false;
   let dirsVisited = 0;
@@ -566849,6 +566851,17 @@ function scanWorkspace(opts) {
       continue;
     visited.add(dir);
     dirsVisited++;
+    if (dirs.length < maxDirs) {
+      try {
+        const st = statSync32(dir);
+        dirs.push({
+          abs: dir,
+          rel: relative8(root, dir) || ".",
+          mtimeMs: st.mtimeMs
+        });
+      } catch {
+      }
+    }
     let entries = [];
     try {
       entries = readdirSync30(dir);
@@ -566883,7 +566896,87 @@ function scanWorkspace(opts) {
     }
   }
   files.sort((a2, b) => a2.rel.localeCompare(b.rel));
-  return { files, totalBytes, truncated, dirsVisited };
+  dirs.sort((a2, b) => a2.rel.localeCompare(b.rel));
+  return { files, dirs, totalBytes, truncated, dirsVisited };
+}
+function humanBytes(n2) {
+  if (n2 < 1024)
+    return `${n2}B`;
+  if (n2 < 1024 * 1024)
+    return `${(n2 / 1024).toFixed(1)}KB`;
+  return `${(n2 / 1024 / 1024).toFixed(1)}MB`;
+}
+function ensureTreeNode(root, rel) {
+  if (!rel || rel === ".")
+    return root;
+  let node = root;
+  for (const part of rel.split("/").filter(Boolean)) {
+    let child = node.children.get(part);
+    if (!child) {
+      child = { name: part, children: /* @__PURE__ */ new Map(), directory: true };
+      node.children.set(part, child);
+    }
+    node = child;
+  }
+  return node;
+}
+function renderWorkspaceTree(scan, opts = {}) {
+  const maxLines = Math.max(10, Math.min(2e3, opts.maxLines ?? 120));
+  const includeFileSizes = opts.includeFileSizes !== false;
+  const root = {
+    name: ".",
+    children: /* @__PURE__ */ new Map(),
+    directory: true
+  };
+  for (const dir of scan.dirs)
+    ensureTreeNode(root, dir.rel).directory = true;
+  for (const file of scan.files) {
+    const parts = file.rel.split("/").filter(Boolean);
+    const name10 = parts.pop();
+    if (!name10)
+      continue;
+    const parent = ensureTreeNode(root, parts.join("/"));
+    parent.children.set(name10, {
+      name: name10,
+      children: /* @__PURE__ */ new Map(),
+      file,
+      directory: false
+    });
+  }
+  const lines = ["./"];
+  let truncated = false;
+  const walk2 = (node, depth) => {
+    const children2 = [...node.children.values()].sort((a2, b) => {
+      if (a2.directory !== b.directory)
+        return a2.directory ? -1 : 1;
+      return a2.name.localeCompare(b.name);
+    });
+    for (const child of children2) {
+      if (lines.length >= maxLines) {
+        truncated = true;
+        return;
+      }
+      const indent2 = "  ".repeat(depth);
+      if (child.directory) {
+        lines.push(`${indent2}${child.name}/`);
+        walk2(child, depth + 1);
+        if (truncated)
+          return;
+      } else {
+        const size = includeFileSizes && child.file ? ` (${humanBytes(child.file.bytes)})` : "";
+        lines.push(`${indent2}${child.name}${size}`);
+      }
+    }
+  };
+  walk2(root, 1);
+  if (truncated || scan.truncated) {
+    if (lines.length >= maxLines)
+      lines[lines.length - 1] = "... [workspace tree truncated]";
+    else
+      lines.push("... [workspace tree truncated]");
+    truncated = true;
+  }
+  return { text: lines.join("\n"), lineCount: lines.length, truncated };
 }
 var UNIVERSAL_DEFAULTS;
 var init_world_state_disk_scan = __esm({
@@ -567578,9 +567671,9 @@ function regenerate(opts) {
     lines.push(`  No files found in workspace (excluding ignored paths).`);
   } else {
     const totalBytes = files.reduce((sum, f2) => sum + f2.bytes, 0);
-    lines.push(`  ${files.length} file(s)${truncated ? " (truncated — more exist)" : ""}, total ${humanBytes(totalBytes)}.`);
+    lines.push(`  ${files.length} file(s)${truncated ? " (truncated — more exist)" : ""}, total ${humanBytes2(totalBytes)}.`);
     if (lastWriteFile) {
-      lines.push(`  Most recently modified: ${lastWriteFile.rel} (${humanBytes(lastWriteFile.bytes)}, ${ago(nowMs - lastWriteFile.mtimeMs)}).`);
+      lines.push(`  Most recently modified: ${lastWriteFile.rel} (${humanBytes2(lastWriteFile.bytes)}, ${ago(nowMs - lastWriteFile.mtimeMs)}).`);
     }
     const topDirs = /* @__PURE__ */ new Map();
     for (const f2 of files) {
@@ -567676,7 +567769,7 @@ function reconciledMark(t2) {
       return "BLOCK";
   }
 }
-function humanBytes(n2) {
+function humanBytes2(n2) {
   if (n2 < 1024)
     return `${n2}B`;
   if (n2 < 1024 * 1024)
@@ -573437,6 +573530,7 @@ var init_evidenceLedger = __esm({
           this.entries.set(path12, {
             ...existing,
             content: keepNew ? built.text : existing.content,
+            contentHash: input.contentHash ?? existing.contentHash,
             fidelity: keepNew ? built.fidelity : existing.fidelity,
             ranges: mergeRanges([...existing.ranges, range]),
             lastReadTurn: turn,
@@ -573447,6 +573541,7 @@ var init_evidenceLedger = __esm({
         }
         this.entries.set(path12, {
           path: path12,
+          contentHash: input.contentHash,
           readVersion: fileVersion,
           mtimeMs: input.mtimeMs ?? 0,
           lastReadTurn: turn,
@@ -573475,7 +573570,7 @@ var init_evidenceLedger = __esm({
        * like a manual chmod, device reconnect, or human edit), mark as stale.
        * Returns true if evidence was valid, false if became stale or stat failed.
        */
-      validateFreshness(path12) {
+      validateFreshness(path12, statPath = path12) {
         const e2 = this.entries.get(path12);
         if (!e2)
           return false;
@@ -573484,7 +573579,7 @@ var init_evidenceLedger = __esm({
         if (e2.mtimeMs <= 0)
           return true;
         try {
-          const st = statSync36(path12, { throwIfNoEntry: false });
+          const st = statSync36(statPath, { throwIfNoEntry: false });
           if (!st)
             return true;
           if (st.mtimeMs > e2.mtimeMs) {
@@ -573499,6 +573594,11 @@ var init_evidenceLedger = __esm({
       get(path12) {
         return this.entries.get(path12);
       }
+      markStale(path12) {
+        const e2 = this.entries.get(path12);
+        if (e2)
+          e2.stale = true;
+      }
       size() {
         return this.entries.size;
       }
@@ -573521,12 +573621,12 @@ var init_evidenceLedger = __esm({
         ];
         let used = lines.join("\n").length;
         for (const e2 of sorted) {
-          const header = e2.stale ? `▸ ${e2.path} @v${e2.readVersion} [STALE — changed since read; re-read needed] (${rangeLabel(e2.ranges)})` : `▸ ${e2.path} @v${e2.readVersion} [FRESH] (${rangeLabel(e2.ranges)}):`;
+          const header = e2.stale ? `▸ ${e2.path} @v${e2.readVersion} [STALE — changed since read; re-read needed] (${rangeLabel(e2.ranges)})` : `▸ ${e2.path} @v${e2.readVersion} [FRESH${e2.contentHash ? ` sha256=${e2.contentHash}` : ""}] (${rangeLabel(e2.ranges)}):`;
           const body = e2.stale ? "" : "\n" + indent(e2.content);
           const chunk = `${header}${body}
 `;
           if (used + chunk.length > maxChars) {
-            const stub = `▸ ${e2.path} @v${e2.readVersion} [${e2.stale ? "STALE" : "FRESH"}] (${rangeLabel(e2.ranges)})
+            const stub = `▸ ${e2.path} @v${e2.readVersion} [${e2.stale ? "STALE" : `FRESH${e2.contentHash ? ` sha256=${e2.contentHash}` : ""}`}] (${rangeLabel(e2.ranges)})
 `;
             if (used + stub.length <= maxChars) {
               lines.push(stub);
@@ -574603,9 +574703,22 @@ ${input.error}`;
   }
   if (input.realFileMutation)
     diagnoses.add("project-file-mutation");
-  const focusDecisionJson = previewJson(input.focusDecision ?? {});
-  if (focusDecisionJson.includes("block_tool_call")) {
-    diagnoses.add("focus-supervisor-block");
+  const focusDecision = input.focusDecision && typeof input.focusDecision === "object" ? input.focusDecision : null;
+  const focusDecisionKind = typeof focusDecision?.["kind"] === "string" ? focusDecision["kind"] : null;
+  if (focusDecisionKind === "block_tool_call") {
+    if (focusDecision?.["success"] === true || input.success) {
+      diagnoses.add("focus-supervisor-cached-evidence");
+    } else {
+      diagnoses.add("focus-supervisor-block");
+    }
+  } else {
+    const focusDecisionJson = previewJson(input.focusDecision ?? {});
+    if (focusDecisionJson.includes("block_tool_call")) {
+      if (input.success)
+        diagnoses.add("focus-supervisor-cached-evidence");
+      else
+        diagnoses.add("focus-supervisor-block");
+    }
   }
   const focusJson = previewJson(input.focusSupervisor ?? {});
   if (focusJson.includes("block_tool_call") || focusJson.includes("requiredNextAction")) {
@@ -574736,7 +574849,8 @@ function writeContract(contractPath) {
     "",
     "- `shell-brace-whitespace`: a shell command used brace expansion containing whitespace, which can split an intended path set into unrelated shell words.",
     "- `successful-command-needs-post-state-audit`: the command exited zero but its shape is risky enough that filesystem state should be inspected.",
-    "- `focus-supervisor-block`: the tool result or supervisor state shows a blocked next action.",
+    "- `focus-supervisor-block`: the tool result or supervisor state shows an unsuccessful blocked next action.",
+    "- `focus-supervisor-cached-evidence`: the focus supervisor short-circuited a call successfully by reusing current cached evidence.",
     "- `background-task-id-missing`: task status lookup could not find the spawned task id.",
     "- `raw-discovery-dominates-context`: context-window metrics show low signal/noise around raw discovery output.",
     ""
@@ -575305,6 +575419,10 @@ var init_focusSupervisor = __esm({
           this.clearSatisfiedDirective("requested edit already applied", input.turn);
           return;
         }
+        if (input.success && input.noop && input.isReadLike && (this.directive?.requiredNextAction === "use_cached_evidence" || this.directive?.requiredNextAction === "read_authoritative_target")) {
+          this.clearSatisfiedDirective(input.runtimeAuthored ? "cached authoritative evidence reused" : "authoritative evidence already available", input.turn);
+          return;
+        }
         if (input.runtimeAuthored) {
           this.lastDecision = "runtime_authored_not_satisfied";
           this.lastReason = "runtime-authored control result did not execute the requested tool";
@@ -577519,7 +577637,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
 import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync, writeFileSync as _fsWriteFileSync, appendFileSync as _fsAppendFileSync, unlinkSync as _fsUnlinkSync, mkdirSync as _fsMkdirSync, statSync as _fsStatSync, readdirSync as _fsReaddirSync } from "node:fs";
 import { execFile as _execFile, spawn as _spawn } from "node:child_process";
 import { createHash as _createHash } from "node:crypto";
-import { join as _pathJoin, resolve as _pathResolve } from "node:path";
+import { join as _pathJoin, relative as _pathRelative, resolve as _pathResolve } from "node:path";
 import { tmpdir as _osTmpdir } from "node:os";
 import { homedir as _osHomedir } from "node:os";
 import { z as z17 } from "zod";
@@ -578182,6 +578300,7 @@ var init_agenticRunner = __esm({
     init_lesson_bank();
     init_intervention_replay();
     init_world_state_regenerator();
+    init_world_state_disk_scan();
     init_backward_pass_runner();
     init_world_state_plan_reconciler();
     init_process_async2();
@@ -581015,7 +581134,7 @@ ${result.error ?? ""}`;
         if (result.success !== true)
           return false;
         if (toolName === "file_read") {
-          return targetPaths.length > 0 && targetPaths.some((path12) => this._evidenceLedger.hasFresh(path12));
+          return targetPaths.length > 0 && targetPaths.some((path12) => this._evidenceLedger.hasFresh(this._normalizeEvidencePath(path12)));
         }
         return toolName === "list_directory" || toolName === "find_files" || toolName === "grep_search";
       }
@@ -583124,6 +583243,133 @@ ${latest.output || ""}`.trim();
           return null;
         }
       }
+      /**
+       * Render a fresh, bounded workspace tree from disk for the active context
+       * frame, and persist the fuller capped tree under .omnius/world-state/tree.
+       * This is deliberately independent of tool history: it answers "what exists
+       * where right now?" without forcing the model to list_directory for basic
+       * orientation.
+       */
+      _renderWorkspaceTreeBlock(turn) {
+        const rawEnabled = String(process.env["OMNIUS_CONTEXT_WORKSPACE_TREE"] ?? "1").trim().toLowerCase();
+        if (rawEnabled === "0" || rawEnabled === "false" || rawEnabled === "off") {
+          return null;
+        }
+        const intEnv = (name10, fallback, min, max) => {
+          const parsed = Number.parseInt(process.env[name10] ?? "", 10);
+          return Number.isFinite(parsed) ? Math.max(min, Math.min(max, parsed)) : fallback;
+        };
+        const root = this.authoritativeWorkingDirectory();
+        const maxFiles = intEnv("OMNIUS_CONTEXT_TREE_MAX_FILES", 1e3, 20, 2e3);
+        const maxDirs = intEnv("OMNIUS_CONTEXT_TREE_MAX_DIRS", 1500, 20, 5e3);
+        const contextLines = intEnv("OMNIUS_CONTEXT_TREE_LINES", 90, 20, 400);
+        const artifactLines = intEnv("OMNIUS_CONTEXT_TREE_ARTIFACT_LINES", 1800, 100, 4e3);
+        try {
+          const scan = scanWorkspace({ root, maxFiles, maxDirs });
+          const compactTree = renderWorkspaceTree(scan, { maxLines: contextLines });
+          const fullTree = renderWorkspaceTree(scan, { maxLines: artifactLines });
+          const totalBytes = scan.files.reduce((sum, file) => sum + file.bytes, 0);
+          const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const focusSnapshot = this._focusSupervisor?.snapshot();
+          const recentActions = this._adversaryToolOutcomes.slice(-12).map((item) => ({
+            turn: item.turn,
+            tool: item.tool,
+            success: item.succeeded,
+            path: item.path,
+            stateVersion: item.stateVersion,
+            preview: item.preview.slice(0, 240)
+          }));
+          const recentActionLines = recentActions.slice(-6).map((item) => {
+            const path12 = item.path ? ` path=${item.path}` : "";
+            return `- turn=${item.turn} ${item.tool} ${item.success ? "ok" : "err"}${path12}: ${item.preview.replace(/\s+/g, " ").slice(0, 160)}`;
+          });
+          const treeDir = _pathJoin(this.omniusStateDir(), "world-state", "tree");
+          const turnName = `turn-${String(turn).padStart(4, "0")}`;
+          const latestTextPath = _pathJoin(treeDir, "latest.txt");
+          const latestJsonPath = _pathJoin(treeDir, "latest.json");
+          const turnTextPath = _pathJoin(treeDir, `${turnName}.txt`);
+          const turnJsonPath = _pathJoin(treeDir, `${turnName}.json`);
+          let artifactDisplay = latestTextPath;
+          try {
+            _fsMkdirSync(treeDir, { recursive: true });
+            const header = [
+              `WORKSPACE TREE SNAPSHOT`,
+              `generated_at=${generatedAt}`,
+              `turn=${turn}`,
+              `session=${this._sessionId ?? ""}`,
+              `root=${root}`,
+              `files=${scan.files.length}${scan.truncated ? "+" : ""}`,
+              `dirs=${scan.dirs.length}`,
+              `bytes=${totalBytes}`,
+              focusSnapshot?.directive?.requiredNextAction ? `supervisor_required_next_action=${focusSnapshot.directive.requiredNextAction}` : `supervisor_required_next_action=none`,
+              recentActionLines.length ? `recent_actions=${recentActions.length}` : `recent_actions=0`,
+              recentActionLines.length ? recentActionLines.join("\n") : "",
+              ""
+            ].join("\n");
+            const text2 = `${header}${fullTree.text}
+`;
+            const payload = {
+              generatedAt,
+              turn,
+              sessionId: this._sessionId,
+              root,
+              supervisor: focusSnapshot ? {
+                state: focusSnapshot.state,
+                lastDecision: focusSnapshot.lastDecision,
+                lastReason: focusSnapshot.lastReason,
+                requiredNextAction: focusSnapshot.directive?.requiredNextAction ?? null,
+                directiveReason: focusSnapshot.directive?.reason ?? null
+              } : null,
+              recentActions,
+              stats: {
+                files: scan.files.length,
+                dirs: scan.dirs.length,
+                totalBytes,
+                truncated: scan.truncated || fullTree.truncated,
+                dirsVisited: scan.dirsVisited
+              },
+              files: scan.files.map((file) => ({
+                path: file.rel,
+                bytes: file.bytes,
+                mtimeMs: file.mtimeMs
+              })),
+              dirs: scan.dirs.map((dir) => ({
+                path: dir.rel,
+                mtimeMs: dir.mtimeMs
+              }))
+            };
+            _fsWriteFileSync(latestTextPath, text2, "utf8");
+            _fsWriteFileSync(turnTextPath, text2, "utf8");
+            _fsWriteFileSync(latestJsonPath, JSON.stringify(payload, null, 2), "utf8");
+            _fsWriteFileSync(turnJsonPath, JSON.stringify(payload, null, 2), "utf8");
+            const rel = _pathRelative(root, latestTextPath).replace(/\\/g, "/");
+            if (rel && !rel.startsWith(".."))
+              artifactDisplay = rel;
+          } catch {
+            artifactDisplay = "(workspace tree artifact write failed; inline digest still current)";
+          }
+          return [
+            "[WORKSPACE TREE — fresh per-turn disk crawl]",
+            `generated_at=${generatedAt}`,
+            `root=${root}`,
+            `files=${scan.files.length}${scan.truncated ? "+" : ""} dirs=${scan.dirs.length} total_bytes=${totalBytes}`,
+            `artifact=${artifactDisplay}`,
+            focusSnapshot?.directive?.requiredNextAction ? `supervisor_required_next_action=${focusSnapshot.directive.requiredNextAction}` : `supervisor_required_next_action=none`,
+            recentActionLines.length ? `recent_actions:
+${recentActionLines.join("\n")}` : "recent_actions=none",
+            "Use this tree for path orientation. It includes empty directories; it does not include file contents.",
+            compactTree.truncated || scan.truncated ? "Inline tree is truncated; read the artifact path above for the fuller capped tree before broad rediscovery." : "Inline tree is complete within the configured scan cap.",
+            compactTree.text
+          ].join("\n");
+        } catch (error) {
+          return [
+            "[WORKSPACE TREE — fresh per-turn disk crawl]",
+            `root=${root}`,
+            `scan_failed=${error instanceof Error ? error.message : String(error)}`,
+            "Do not assume the tree is current; use list_directory/find_files if path orientation is required."
+          ].join("\n");
+        }
+      }
       /**
        * REG-2: Render a compact "files known to me" block from `_worldFacts`.
        * Goal: tell the model what it has already touched this run so it stops
@@ -583663,6 +583909,7 @@ ${chunk.content}`, {
           this._renderRuntimeRootBlock(),
           this._taskState.goal ? `Active task: (see user message above — the goal block defers to the user message as the authoritative source)` : null
         ].filter(Boolean).join("\n\n");
+        const workspaceTreeBlock = this._renderWorkspaceTreeBlock(turn);
         const filesystemBlock = this._renderFilesystemStateBlock(turn);
         const artifactContractBlock = this._contractRegistry.format(15);
         const todoBlock = this._renderTodoStateBlock(turn);
@@ -583707,6 +583954,13 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
             createdTurn: turn,
             ttlTurns: 1
           }),
+          signalFromBlock("known_files", "turn.workspace-tree", workspaceTreeBlock, {
+            id: "workspace-tree",
+            dedupeKey: "turn.workspace-tree",
+            priority: 84,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
           signalFromBlock("known_files", "turn.artifact-contracts", artifactContractBlock, {
             id: "artifact-contracts",
             dedupeKey: "turn.artifact-contracts",
@@ -583795,7 +584049,7 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
           // Raised from 10k to fit the durable read-evidence content (known_files)
           // that replaces the re-read loop; the per-kind budget below caps it.
           maxChars: 13e3,
-          kindCharBudget: { known_files: 6500 },
+          kindCharBudget: { known_files: 8500 },
           includeDiagnostics: process.env["OMNIUS_CONTEXT_FABRIC_DIAGNOSTICS"] === "1"
         });
         this._lastContextFrameDiagnostics = frame.diagnostics;
@@ -583999,10 +584253,12 @@ ${blob}
           if (p2 && content.length >= 100) {
             try {
               this._evidenceLedger.recordRead({
-                path: p2,
+                path: this._normalizeEvidencePath(p2),
                 content,
+                contentHash: this._extractFileReadSha256(content) ?? void 0,
                 range: { start: 0, end: Number.POSITIVE_INFINITY },
                 fileVersion: this._worldFacts.files.get(p2)?.writeCount ?? 0,
+                mtimeMs: this._statMtimeMsForToolPath(p2),
                 turn: this._taskState?.toolCallCount ?? 0
               });
             } catch {
@@ -587901,6 +588157,18 @@ ${memoryLines.join("\n")}`
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
             }
+            for (const tc of msg.toolCalls) {
+              const patched = this._attachFreshExpectedHashesToEditArgs(tc.name, tc.arguments ?? {});
+              if (patched.patchedCount > 0) {
+                tc.arguments = patched.args;
+                this.emit({
+                  type: "status",
+                  content: `Edit freshness: attached expected_hash to ${patched.patchedCount} ${tc.name} edit target${patched.patchedCount === 1 ? "" : "s"} from fresh file_read evidence`,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+            }
             messages2.push({
               role: "assistant",
               content: msg.content || null,
@@ -588640,7 +588908,8 @@ Read the current file if needed, make a different concrete edit, or move to veri
                   const readArgs = tc.arguments;
                   const readPath2 = String(readArgs?.["path"] ?? readArgs?.["file"] ?? "");
                   if (readPath2) {
-                    const wasFresh = this._evidenceLedger.validateFreshness(readPath2);
+                    const evidencePath = this._normalizeEvidencePath(readPath2);
+                    const wasFresh = evidencePath && this._evidenceLedger.validateFreshness(evidencePath, this._absoluteToolPath(readPath2));
                     if (!wasFresh) {
                       recentToolResults.delete(toolFingerprint);
                       dedupHitCount.delete(toolFingerprint);
@@ -588770,13 +589039,13 @@ ${cachedResult}`,
                   error: this.unknownToolError(tc.name)
                 };
               } else {
-                let validationError = null;
-                if (tool.inputSchema) {
+                let validationError = this._validateFreshExpectedHashesForEdit(resolvedTool?.name ?? tc.name, tc.arguments ?? {});
+                if (!validationError && tool.inputSchema) {
                   const parseResult = tool.inputSchema.safeParse(tc.arguments);
                   if (!parseResult.success) {
                     validationError = parseResult.error.issues.map((iss) => `${iss.path.join(".")}: ${iss.message}`).join("; ");
                   }
-                } else if (tool.parameters && typeof tool.parameters === "object") {
+                } else if (!validationError && tool.parameters && typeof tool.parameters === "object") {
                   const required = tool.parameters.required;
                   if (Array.isArray(required)) {
                     const missing = required.filter((field) => tc.arguments[field] === void 0 || tc.arguments[field] === null);
@@ -589017,7 +589286,7 @@ Respond with EXACTLY this structure before your next tool call:
                       lastWriteTurn: turn,
                       writeCount: nextWriteCount
                     });
-                    this._evidenceLedger.markMutated(p2, nextWriteCount, turn);
+                    this._evidenceLedger.markMutated(this._normalizeEvidencePath(p2), nextWriteCount, turn);
                   }
                   if (paths.length > 0) {
                     this._writesSinceLastTodoWrite += paths.length;
@@ -589061,11 +589330,12 @@ Respond with EXACTLY this structure before your next tool call:
                     const start3 = rOffset === void 0 && rLimit === void 0 ? 0 : Math.max(1, rOffset ?? 1);
                     const end = rOffset === void 0 && rLimit === void 0 ? Number.POSITIVE_INFINITY : rLimit !== void 0 ? Math.max(1, rOffset ?? 1) + Math.max(0, rLimit) - 1 : Number.POSITIVE_INFINITY;
                     this._evidenceLedger.recordRead({
-                      path: p2,
+                      path: this._normalizeEvidencePath(p2),
                       content: result.output,
+                      contentHash: typeof result.beforeHash === "string" ? result.beforeHash : void 0,
                       range: { start: start3, end },
                       fileVersion: this._worldFacts.files.get(p2)?.writeCount ?? 0,
-                      mtimeMs: Date.now(),
+                      mtimeMs: this._statMtimeMsForToolPath(p2),
                       turn
                     });
                   }
@@ -590286,6 +590556,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                   focusSupervisor: focusAfterToolResult,
                   focusDecision: !focusDecision || focusDecision.kind === "pass" ? void 0 : {
                     kind: focusDecision.kind,
+                    success: focusDecision.kind === "block_tool_call" ? focusDecision.success : void 0,
                     state: focusDecision.directive.state,
                     reason: focusDecision.directive.reason,
                     requiredNextAction: focusDecision.directive.requiredNextAction
@@ -592760,13 +593031,14 @@ ${marker}` : marker);
         const displayOutput = this.unwrapToolOutputForDisplay(output);
         if (toolName === "file_read") {
           const path13 = this.extractPrimaryToolPath(args);
-          if (!path13 || !this._evidenceLedger.hasFresh(path13))
+          const evidencePath = path13 ? this._normalizeEvidencePath(path13) : "";
+          if (!evidencePath || !this._evidenceLedger.hasFresh(evidencePath))
             return output;
-          const entry = this._evidenceLedger.get(path13);
+          const entry = this._evidenceLedger.get(evidencePath);
           return this.wrapToolOutputForModel(toolName, [
             "[DISCOVERY COMPACTED - file_read evidence captured]",
             `path=${path13}`,
-            `captured=${this.countTextLines(displayOutput)} lines, ${displayOutput.length} chars${entry ? `, fidelity=${entry.fidelity}` : ""}`,
+            `captured=${this.countTextLines(displayOutput)} lines, ${displayOutput.length} chars${entry ? `, fidelity=${entry.fidelity}${entry.contentHash ? `, sha256=${entry.contentHash}` : ""}` : ""}`,
             'active_context="Evidence already gathered this run"',
             "Use the active evidence frame. Re-read only if that frame marks this file STALE or you need a distinct range."
           ].join("\n"));
@@ -592912,6 +593184,175 @@ ${marker}` : marker);
           return trimmed.replace(/\\/g, "/").replace(/^\.\/+/, "");
         }
       }
+      _absoluteToolPath(path12) {
+        return _pathResolve(this.authoritativeWorkingDirectory(), path12.trim() || ".");
+      }
+      _normalizeEvidencePath(path12) {
+        const trimmed = path12.trim();
+        if (!trimmed)
+          return "";
+        try {
+          const root = this.authoritativeWorkingDirectory();
+          const abs = _pathResolve(root, trimmed);
+          const rel = _pathRelative(root, abs).replace(/\\/g, "/");
+          if (rel && !rel.startsWith("..") && rel !== ".")
+            return rel;
+          if (rel === "")
+            return ".";
+          return abs.replace(/\\/g, "/");
+        } catch {
+          return trimmed.replace(/\\/g, "/").replace(/^\.\/+/, "");
+        }
+      }
+      _statMtimeMsForToolPath(path12) {
+        try {
+          const st = _fsStatSync(this._absoluteToolPath(path12), {
+            throwIfNoEntry: false
+          });
+          return st?.mtimeMs;
+        } catch {
+          return void 0;
+        }
+      }
+      _normalizeExpectedHashValue(value2) {
+        if (typeof value2 !== "string")
+          return null;
+        const raw = value2.trim();
+        if (!raw)
+          return null;
+        const stripped = raw.replace(/^sha256[:=]/i, "").toLowerCase();
+        return /^[a-f0-9]{64}$/.test(stripped) ? stripped : null;
+      }
+      _extractFileReadSha256(text2) {
+        const match = text2.match(/\bsha256=([a-f0-9]{64})\b/i);
+        return match ? match[1].toLowerCase() : null;
+      }
+      _rawExpectedHashValue(rec) {
+        return rec["expected_hash"] ?? rec["expectedHash"] ?? rec["before_hash"] ?? rec["beforeHash"];
+      }
+      _freshReadHashForEditPath(path12) {
+        const key = this._normalizeEvidencePath(path12);
+        if (!key)
+          return null;
+        const entry = this._evidenceLedger.get(key);
+        if (!entry || entry.stale || !entry.contentHash)
+          return null;
+        const statPath = this._absoluteToolPath(path12);
+        if (!this._evidenceLedger.validateFreshness(key, statPath))
+          return null;
+        const fresh = this._evidenceLedger.get(key);
+        if (!fresh || fresh.stale || !fresh.contentHash)
+          return null;
+        return {
+          key,
+          hash: fresh.contentHash,
+          lastReadTurn: fresh.lastReadTurn
+        };
+      }
+      _attachFreshExpectedHashesToEditArgs(toolName, args) {
+        if (process.env["OMNIUS_ALLOW_UNVERIFIED_OLD_STRING_EDIT"] === "1") {
+          return { args, patchedCount: 0 };
+        }
+        if (toolName === "file_edit") {
+          if (this._normalizeExpectedHashValue(this._rawExpectedHashValue(args))) {
+            return { args, patchedCount: 0 };
+          }
+          const path12 = this.extractPrimaryToolPath(args);
+          const fresh = path12 ? this._freshReadHashForEditPath(path12) : null;
+          if (!fresh)
+            return { args, patchedCount: 0 };
+          return { args: { ...args, expected_hash: fresh.hash }, patchedCount: 1 };
+        }
+        if (toolName !== "batch_edit" || !Array.isArray(args["edits"])) {
+          return { args, patchedCount: 0 };
+        }
+        let patchedCount = 0;
+        const edits = args["edits"].map((edit) => {
+          if (!edit || typeof edit !== "object" || Array.isArray(edit))
+            return edit;
+          const rec = edit;
+          if (this._normalizeExpectedHashValue(this._rawExpectedHashValue(rec))) {
+            return rec;
+          }
+          const path12 = typeof rec["path"] === "string" ? rec["path"] : typeof rec["file"] === "string" ? rec["file"] : "";
+          const fresh = path12 ? this._freshReadHashForEditPath(path12) : null;
+          if (!fresh)
+            return rec;
+          patchedCount++;
+          return { ...rec, expected_hash: fresh.hash };
+        });
+        return patchedCount > 0 ? { args: { ...args, edits }, patchedCount } : { args, patchedCount: 0 };
+      }
+      _validateFreshExpectedHashesForEdit(toolName, args) {
+        if (process.env["OMNIUS_ALLOW_UNVERIFIED_OLD_STRING_EDIT"] === "1") {
+          return null;
+        }
+        const targets = [];
+        if (toolName === "file_edit") {
+          const path12 = this.extractPrimaryToolPath(args);
+          if (path12) {
+            targets.push({
+              label: path12,
+              path: path12,
+              expectedHash: this._normalizeExpectedHashValue(this._rawExpectedHashValue(args)),
+              rawExpectedHash: this._rawExpectedHashValue(args)
+            });
+          }
+        } else if (toolName === "batch_edit" && Array.isArray(args["edits"])) {
+          args["edits"].forEach((edit, index) => {
+            if (!edit || typeof edit !== "object" || Array.isArray(edit))
+              return;
+            const rec = edit;
+            const path12 = typeof rec["path"] === "string" ? rec["path"] : typeof rec["file"] === "string" ? rec["file"] : "";
+            if (!path12)
+              return;
+            targets.push({
+              label: `edit #${index + 1} ${path12}`,
+              path: path12,
+              expectedHash: this._normalizeExpectedHashValue(this._rawExpectedHashValue(rec)),
+              rawExpectedHash: this._rawExpectedHashValue(rec)
+            });
+          });
+        } else {
+          return null;
+        }
+        if (targets.length === 0)
+          return null;
+        const problems = [];
+        for (const target of targets) {
+          const fresh = this._freshReadHashForEditPath(target.path);
+          if (target.rawExpectedHash !== void 0 && !target.expectedHash) {
+            problems.push(`${target.label}: expected_hash is present but is not a valid 64-character SHA-256`);
+            continue;
+          }
+          if (!fresh && target.expectedHash) {
+            continue;
+          }
+          if (!fresh) {
+            problems.push(`${target.label}: missing expected_hash and no fresh file_read hash is available for this file in the current run`);
+            continue;
+          }
+          if (!target.expectedHash) {
+            problems.push(`${target.label}: missing expected_hash; use sha256=${fresh.hash} from the fresh file_read evidence`);
+            continue;
+          }
+          if (target.expectedHash !== fresh.hash) {
+            problems.push(`${target.label}: expected_hash=${target.expectedHash} does not match fresh file_read sha256=${fresh.hash}`);
+          }
+        }
+        if (problems.length === 0)
+          return null;
+        return [
+          "[EDIT FRESHNESS CONTRACT]",
+          "Exact replacement edits must be built from verified current file content, not remembered text.",
+          "Before file_edit or batch_edit can run, each target must carry expected_hash from file_read. If the runner has fresh read evidence, it will attach that hash automatically; otherwise the edit tool verifies the provided hash against disk before mutating.",
+          "For multiple edits to the same file, use one batch_edit against the same expected_hash so all replacements validate atomically before the file changes.",
+          "",
+          ...problems.map((problem) => `- ${problem}`),
+          "",
+          "Next action: file_read the target file or range, then retry the edit with old_string copied exactly from that read and expected_hash set to the read's sha256."
+        ].join("\n");
+      }
       staleEditFamilyKey(toolName, pathKey, errorKind, targetHash, latestFileHash) {
         return [
           toolName,
@@ -631048,6 +631489,7 @@ var init_status_bar = __esm({
           this._contentScrollOffset = 0;
         if (this.active) {
           this.repaintContent();
+          this.refreshDynamicBlocks();
           this._contentCursorNeedsReplay = true;
           if (this.writeDepth > 0) this._contentCursorReplayActive = true;
         }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.456",
+  "version": "1.0.458",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.456",
+      "version": "1.0.458",
       "bundleDependencies": [
         "image-to-ascii"
       ],
@@ -4138,9 +4138,9 @@
       }
     },
     "node_modules/iconv-lite": {
-      "version": "0.7.2",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
-      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+      "version": "0.7.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.3.tgz",
+      "integrity": "sha512-IKXpvIzjnC9XTAUbVBcMfGS0EPaIXtW6v+zr+RRp+hqULEpo0owZax6wyRwPOJbWbzjYspQwusTsfVr0ifh4uQ==",
       "license": "MIT",
       "dependencies": {
         "safer-buffer": ">= 2.1.2 < 3.0.0"

package/package.json

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