omnius 1.0.443 → 1.0.445

package/dist/index.js

@@ -118324,7 +118324,7 @@ var require_auto = __commonJS({
 // ../node_modules/acme-client/src/client.js
 var require_client = __commonJS({
   "../node_modules/acme-client/src/client.js"(exports, module) {
-    var { createHash: createHash47 } = __require("crypto");
+    var { createHash: createHash48 } = __require("crypto");
     var { getPemBodyAsB64u } = require_crypto();
     var { log: log22 } = require_logger();
     var HttpClient = require_http();
@@ -118635,14 +118635,14 @@ var require_client = __commonJS({
        */
       async getChallengeKeyAuthorization(challenge) {
         const jwk = this.http.getJwk();
-        const keysum = createHash47("sha256").update(JSON.stringify(jwk));
+        const keysum = createHash48("sha256").update(JSON.stringify(jwk));
         const thumbprint = keysum.digest("base64url");
         const result = `${challenge.token}.${thumbprint}`;
         if (challenge.type === "http-01") {
           return result;
         }
         if (challenge.type === "dns-01") {
-          return createHash47("sha256").update(result).digest("base64url");
+          return createHash48("sha256").update(result).digest("base64url");
         }
         if (challenge.type === "tls-alpn-01") {
           return result;
@@ -261322,7 +261322,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes31, createHash: createHash47 } = __require("crypto");
+    var { randomBytes: randomBytes31, createHash: createHash48 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate2();
@@ -261982,7 +261982,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash47("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash48("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -262349,7 +262349,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash47 } = __require("crypto");
+    var { createHash: createHash48 } = __require("crypto");
     var extension3 = require_extension2();
     var PerMessageDeflate3 = require_permessage_deflate2();
     var subprotocol3 = require_subprotocol();
@@ -262650,7 +262650,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash47("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash48("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -275457,13 +275457,13 @@ Justification: ${justification || "(none provided)"}`,
         }
         const snapshot = JSON.stringify(this.selfState, null, 2);
         try {
-          const { createHash: createHash47 } = await import("node:crypto");
+          const { createHash: createHash48 } = await import("node:crypto");
           const snapshotDir = join44(this.cwd, ".omnius", "identity", "snapshots");
           await mkdir7(snapshotDir, { recursive: true });
           const version5 = this.selfState.version;
           const snapshotPath = join44(snapshotDir, `v${version5}.json`);
           await writeFile12(snapshotPath, snapshot, "utf8");
-          const hash = createHash47("sha256").update(snapshot).digest("hex");
+          const hash = createHash48("sha256").update(snapshot).digest("hex");
           await writeFile12(join44(this.cwd, ".omnius", "identity", "latest-hash.txt"), hash, "utf8");
           let ipfsCid = "";
           try {
@@ -275596,8 +275596,8 @@ New: ${newNarrative.slice(0, 200)}...`,
       }
       // ── Helpers ──────────────────────────────────────────────────────────────
       createDefaultState() {
-        const { createHash: createHash47 } = __require("node:crypto");
-        const machineId = createHash47("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        const { createHash: createHash48 } = __require("node:crypto");
+        const machineId = createHash48("sha256").update(this.cwd).digest("hex").slice(0, 12);
         return {
           self_id: `omnius-${machineId}`,
           version: 1,
@@ -275679,9 +275679,9 @@ New: ${newNarrative.slice(0, 200)}...`,
         let cid;
         if (this.selfState.version > prevVersion) {
           try {
-            const { createHash: createHash47 } = await import("node:crypto");
+            const { createHash: createHash48 } = await import("node:crypto");
             const stateJson = JSON.stringify(this.selfState);
-            const hash = createHash47("sha256").update(stateJson).digest("hex").slice(0, 32);
+            const hash = createHash48("sha256").update(stateJson).digest("hex").slice(0, 32);
             const cidsPath = join44(this.cwd, ".omnius", "identity", "cids.json");
             const cidsData = { latest: "", hash, version: this.selfState.version };
             try {
@@ -296247,7 +296247,7 @@ var init_working_notes = __esm({
 // packages/execution/dist/tools/workboard.js
 import { appendFileSync as appendFileSync4, existsSync as existsSync58, mkdirSync as mkdirSync32, readFileSync as readFileSync42, renameSync as renameSync6, unlinkSync as unlinkSync10, writeFileSync as writeFileSync27 } from "node:fs";
 import { join as join70 } from "node:path";
-import { randomBytes as randomBytes16 } from "node:crypto";
+import { createHash as createHash21, randomBytes as randomBytes16 } from "node:crypto";
 function workboardRoot(workingDir = process.cwd()) {
   return join70(workingDir, ".omnius", "workboards");
 }
@@ -296408,7 +296408,7 @@ function replayWorkboardEvents(events) {
         }
         cards.set(card.id, {
           ...card,
-          evidence: [...card.evidence, ...event.payload.evidence.map(cloneEvidence)],
+          evidence: appendUniqueEvidence(card.evidence, event.payload.evidence),
           updatedAt: event.createdAt
         });
         break;
@@ -296662,6 +296662,9 @@ function attachWorkboardEvidence(workingDir, input) {
   if (evidence.length === 0) {
     throw new WorkboardError("evidence_required", "at least one evidence item is required");
   }
+  const uniqueEvidence = filterNewEvidence(card.evidence, evidence);
+  if (uniqueEvidence.length === 0)
+    return snapshot;
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   return appendWorkboardEvents(workingDir, runId, [{
     schemaVersion: WORKBOARD_SCHEMA_VERSION,
@@ -296670,7 +296673,7 @@ function attachWorkboardEvidence(workingDir, input) {
     type: "evidence.attached",
     createdAt: now2,
     actor: cleanString(input.actor),
-    payload: { cardId: card.id, evidence }
+    payload: { cardId: card.id, evidence: uniqueEvidence }
   }]);
 }
 function completeWorkboardCard(workingDir, input) {
@@ -296696,8 +296699,9 @@ function completeWorkboardCard(workingDir, input) {
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   if (outcome === "request_changes") {
     const evidence2 = input.evidence === void 0 ? [] : normalizeEvidenceCollection(input.evidence, input.actor);
+    const uniqueEvidence2 = evidence2.length > 0 ? filterNewEvidence(card.evidence, evidence2) : [];
     const events = [];
-    if (evidence2.length > 0) {
+    if (uniqueEvidence2.length > 0) {
       events.push({
         schemaVersion: WORKBOARD_SCHEMA_VERSION,
         id: newEventId("evidence"),
@@ -296705,7 +296709,7 @@ function completeWorkboardCard(workingDir, input) {
         type: "evidence.attached",
         createdAt: now2,
         actor: cleanString(input.actor),
-        payload: { cardId: card.id, evidence: evidence2 }
+        payload: { cardId: card.id, evidence: uniqueEvidence2 }
       });
     }
     const missingEvidence = normalizeStringArray(input.missingEvidence);
@@ -296770,7 +296774,8 @@ function completeWorkboardCard(workingDir, input) {
   }
   const evidence = input.evidence === void 0 ? [] : normalizeEvidenceCollection(input.evidence, input.actor);
   let evidenceSnapshot = snapshot;
-  if (evidence.length > 0) {
+  const uniqueEvidence = evidence.length > 0 ? filterNewEvidence(card.evidence, evidence) : [];
+  if (uniqueEvidence.length > 0) {
     evidenceSnapshot = appendWorkboardEvents(workingDir, runId, [{
       schemaVersion: WORKBOARD_SCHEMA_VERSION,
       id: newEventId("evidence"),
@@ -296778,7 +296783,7 @@ function completeWorkboardCard(workingDir, input) {
       type: "evidence.attached",
       createdAt: now2,
       actor: cleanString(input.actor),
-      payload: { cardId: card.id, evidence }
+      payload: { cardId: card.id, evidence: uniqueEvidence }
     }]);
   }
   const currentCard = evidenceSnapshot.cards.find((existing) => existing.id === card.id) ?? card;
@@ -297281,6 +297286,46 @@ function cloneEvidence(evidence) {
     verifies: evidence.verifies ? [...evidence.verifies] : void 0
   };
 }
+function appendUniqueEvidence(existing, incoming) {
+  const seen = new Set(existing.map(evidenceFingerprint));
+  const next = existing.map(cloneEvidence);
+  for (const item of incoming) {
+    const fingerprint = evidenceFingerprint(item);
+    if (seen.has(fingerprint))
+      continue;
+    seen.add(fingerprint);
+    next.push(cloneEvidence(item));
+  }
+  return next;
+}
+function filterNewEvidence(existing, incoming) {
+  const seen = new Set(existing.map(evidenceFingerprint));
+  const next = [];
+  for (const item of incoming) {
+    const fingerprint = evidenceFingerprint(item);
+    if (seen.has(fingerprint))
+      continue;
+    seen.add(fingerprint);
+    next.push(cloneEvidence(item));
+  }
+  return next;
+}
+function evidenceFingerprint(evidence) {
+  const contentDigest = createHash21("sha256").update(evidence.content ?? "").digest("hex");
+  const key = {
+    kind: evidence.kind,
+    summary: evidence.summary,
+    tool: evidence.tool,
+    command: evidence.command,
+    ref: evidence.ref,
+    path: evidence.path,
+    url: evidence.url,
+    message: evidence.message,
+    verifies: [...evidence.verifies ?? []].sort(),
+    contentDigest
+  };
+  return createHash21("sha256").update(JSON.stringify(key)).digest("hex");
+}
 function cleanString(value2) {
   return typeof value2 === "string" && value2.trim() ? value2.trim() : void 0;
 }
@@ -298546,13 +298591,29 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
               durationMs: performance.now() - start2
             };
           }
+          const inProgressIndexes = incoming.map((todo, index) => todo.status === "in_progress" ? index : -1).filter((index) => index >= 0);
+          if (inProgressIndexes.length === 0) {
+            const firstPending = incoming.findIndex((todo) => todo.status === "pending");
+            if (firstPending >= 0) {
+              incoming[firstPending] = { ...incoming[firstPending], status: "in_progress" };
+              repairNotes.push("promoted first pending todo to in_progress because a non-empty active checklist must name the current task");
+            }
+          } else if (inProgressIndexes.length > 1) {
+            const keep = inProgressIndexes[0];
+            for (const index of inProgressIndexes.slice(1)) {
+              incoming[index] = { ...incoming[index], status: "pending" };
+            }
+            repairNotes.push(`kept todo ${keep + 1} in_progress and demoted extra in_progress todos to pending`);
+          }
           const sessionId = typeof args["session_id"] === "string" && args["session_id"].trim() ? args["session_id"].trim() : typeof args["sessionId"] === "string" && args["sessionId"].trim() ? args["sessionId"].trim() : getTodoSessionId();
           const oldTodos = readTodos(sessionId);
           const canonicalize2 = (todos) => JSON.stringify(todos.map((t2) => ({
             content: t2.content,
             status: t2.status,
             parentId: t2.parentId ?? null,
-            blocker: t2.blocker ?? null
+            blocker: t2.blocker ?? null,
+            verifyCommand: t2.verifyCommand ?? null,
+            declaredArtifacts: Array.isArray(t2.declaredArtifacts) ? [...t2.declaredArtifacts].sort() : null
           })));
           const oldKey = canonicalize2(oldTodos);
           const newKey = canonicalize2(incoming);
@@ -298562,8 +298623,10 @@ Mark tasks complete IMMEDIATELY after finishing — don't batch. Never mark comp
               output: JSON.stringify({
                 reminder: "[NO-OP] You called todo_write with the same plan you already have. The list is unchanged. Use todo_write ONLY to add new tasks, mark a task in_progress / completed, or record a blocker — not as a way to re-read your plan (use todo_read for that, but the current plan is also surfaced automatically in your context). Proceed with the current in_progress task.",
                 todos: oldTodos,
-                noop: true
+                noop: true,
+                noProgress: true
               }),
+              noop: true,
               durationMs: performance.now() - start2
             };
           }
@@ -299118,7 +299181,7 @@ var init_import_graph = __esm({
 import { createRequire as __createRequireGlob } from "node:module";
 import ignore from "ignore";
 import { readFile as readFile22, stat as stat8 } from "node:fs/promises";
-import { createHash as createHash21 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 import { join as join73, relative as relative6, extname as extname10, basename as basename14 } from "node:path";
 var __requireGlob, glob2, DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
@@ -299186,7 +299249,7 @@ var init_codebase_indexer = __esm({
             if (fileStat.size > this.config.maxFileSize)
               continue;
             const content = await readFile22(fullPath);
-            const hash = createHash21("sha256").update(content).digest("hex");
+            const hash = createHash22("sha256").update(content).digest("hex");
             const ext = extname10(relativePath);
             indexed.push({
               path: fullPath,
@@ -543498,7 +543561,7 @@ var init_ts_morph_parser = __esm({
 
 // packages/indexer/dist/code-graph-db.js
 import { createRequire as createRequire4 } from "node:module";
-import { createHash as createHash22 } from "node:crypto";
+import { createHash as createHash23 } from "node:crypto";
 import { mkdirSync as mkdirSync34, readFileSync as readFileSync45 } from "node:fs";
 import { join as join74, dirname as dirname20, extname as extname11 } from "node:path";
 function loadDatabaseCtor() {
@@ -543570,7 +543633,7 @@ function extractFileImports(content, filePath) {
   return imports.map((p2) => p2.replace(/\.(js|ts|jsx|tsx|mjs|cjs)$/, ""));
 }
 function hashContent2(content) {
-  return createHash22("sha1").update(content).digest("hex").slice(0, 16);
+  return createHash23("sha1").update(content).digest("hex").slice(0, 16);
 }
 function detectLanguage(filePath) {
   return EXT_TO_LANG[extname11(filePath)] ?? "unknown";
@@ -553136,7 +553199,7 @@ var init_client3 = __esm({
 import { existsSync as existsSync72, readFileSync as readFileSync52, writeFileSync as writeFileSync35, mkdirSync as mkdirSync44, chmodSync, statSync as statSync28 } from "node:fs";
 import { join as join85, dirname as dirname23 } from "node:path";
 import { homedir as homedir23 } from "node:os";
-import { randomBytes as randomBytes19, createHash as createHash23 } from "node:crypto";
+import { randomBytes as randomBytes19, createHash as createHash24 } from "node:crypto";
 function secretsPath(scope, repoRoot) {
   return scope === "global" ? join85(homedir23(), ".omnius", "secrets.json") : join85(repoRoot, ".omnius", "secrets.json");
 }
@@ -553177,7 +553240,7 @@ function sanitizeHint(hint) {
   return hint.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 32) || "GENERIC";
 }
 function shortDigest(value2) {
-  return createHash23("sha256").update(value2).digest("hex").slice(0, 6);
+  return createHash24("sha256").update(value2).digest("hex").slice(0, 6);
 }
 function randomSuffix() {
   return randomBytes19(3).toString("hex");
@@ -554991,7 +555054,7 @@ var init_environment_snapshot = __esm({
 import { existsSync as existsSync76, mkdirSync as mkdirSync46, writeFileSync as writeFileSync38, readFileSync as readFileSync56, readdirSync as readdirSync26, unlinkSync as unlinkSync16, rmSync as rmSync9 } from "node:fs";
 import { join as join88, basename as basename17, isAbsolute as isAbsolute6, resolve as resolve44 } from "node:path";
 import { homedir as homedir26 } from "node:os";
-import { createHash as createHash24 } from "node:crypto";
+import { createHash as createHash25 } from "node:crypto";
 function isYouTubeUrl2(url) {
   return /(?:youtube\.com\/(?:watch|shorts|live|embed|v\/)|youtu\.be\/)/i.test(url);
 }
@@ -555076,7 +555139,7 @@ async function extractAudioIfPresent(videoPath, audioPath, probe) {
 function imageHash(imagePath) {
   try {
     const data = readFileSync56(imagePath);
-    return createHash24("md5").update(data).digest("hex").slice(0, 12);
+    return createHash25("md5").update(data).digest("hex").slice(0, 12);
   } catch {
     return "unknown";
   }
@@ -565440,7 +565503,10 @@ var init_ollama_pool = __esm({
       }
       /** Synchronous routing decision; returns the instance or null if every one is saturated. */
       pickInstance(opts) {
-        const candidates = this.instances.filter((inst) => !this.isEffectivelySaturated(inst) && !(this.activePlacementMode === "dedicated" && this.dedicatedGpuPoolActive && !inst.state.poolOwned && !opts.preferBaseInstance));
+        const candidates = this.instances.filter((inst) => {
+          const baseResidentDedicatedModel = this.activePlacementMode === "dedicated" && this.dedicatedGpuPoolActive && !inst.state.poolOwned && inst.state.knownModels.has(opts.model) && !this.allowDuplicateBaseModelResident();
+          return !this.isEffectivelySaturated(inst) && !(this.activePlacementMode === "dedicated" && this.dedicatedGpuPoolActive && !inst.state.poolOwned && !opts.preferBaseInstance && !baseResidentDedicatedModel);
+        });
         if (candidates.length === 0)
           return null;
         const affinityTargetId = opts.agentId ? this.affinityById.get(opts.agentId) : void 0;
@@ -565561,7 +565627,12 @@ var init_ollama_pool = __esm({
         await this.withSpawnGate(async () => {
           if (!this.canSpawnWithSharedModelStore(model))
             return;
-          const target = this.dedicatedTargetCount(gpus);
+          const baseInstance = this.instances.find((i2) => !i2.state.poolOwned);
+          const baseResidentModel = baseInstance !== void 0 && !this.allowDuplicateBaseModelResident() && await this.isModelLoadedOnInstance(baseInstance, model);
+          if (baseResidentModel && baseInstance) {
+            baseInstance.state.knownModels.add(model);
+          }
+          const target = Math.max(0, this.dedicatedTargetCount(gpus) - (baseResidentModel ? 1 : 0));
           const vramNeededMB = await this.estimateModelVramMB(model);
           while (this.instances.filter((i2) => i2.state.poolOwned).length < target) {
             const candidates = this.gpusWithCapacityForModel(gpus, vramNeededMB);
@@ -565625,6 +565696,10 @@ var init_ollama_pool = __esm({
         const cappedByGpuCount = Math.min(requested, gpus.length);
         return this.config.maxSpawnedInstances > 0 ? Math.min(cappedByGpuCount, this.config.maxSpawnedInstances) : cappedByGpuCount;
       }
+      allowDuplicateBaseModelResident() {
+        const raw = process.env["OMNIUS_OLLAMA_DUPLICATE_BASE_MODEL"] ?? process.env["OMNIUS_OLLAMA_ALLOW_BASE_DUPLICATE"] ?? "";
+        return /^(1|true|yes|on)$/i.test(raw.trim());
+      }
       elasticSpawnCap(gpus) {
         return this.config.maxSpawnedInstances > 0 ? this.config.maxSpawnedInstances : Math.max(0, gpus.length - 1);
       }
@@ -565898,6 +565973,38 @@ var init_ollama_pool = __esm({
         }
         this.instances = survivors;
       }
+      /**
+       * Probe `/api/ps` on an instance and return true when the requested model is
+       * already resident there. This lets dedicated placement reuse an externally
+       * managed base service instead of loading the same large model twice.
+       */
+      async isModelLoadedOnInstance(inst, model) {
+        try {
+          const url = `${inst.state.baseUrl.replace(/\/+$/, "")}/api/ps`;
+          const resp = await fetch(url, { signal: AbortSignal.timeout(2e3) });
+          if (!resp.ok)
+            return false;
+          const data = await resp.json();
+          if (!Array.isArray(data.models))
+            return false;
+          return data.models.some((resident) => this.modelNamesMatch(model, resident.name ?? resident.model ?? ""));
+        } catch {
+          return false;
+        }
+      }
+      modelNamesMatch(requested, resident) {
+        const req3 = requested.trim();
+        const res = resident.trim();
+        if (!req3 || !res)
+          return false;
+        if (req3 === res)
+          return true;
+        if (!req3.includes(":") && res.startsWith(`${req3}:`))
+          return true;
+        if (!res.includes(":") && req3.startsWith(`${res}:`))
+          return true;
+        return false;
+      }
       /**
        * Probe `/api/ps` on the instance and return true if any resident model has
        * less than 95% of its weights in VRAM — the unmistakable CPU-offload
@@ -566129,7 +566236,7 @@ function evaluate2(inputs) {
       compacted: cached?.compacted
     };
   }
-  const cacheEligible = isReadLike || proposedCall.tool === "shell" || proposedCall.tool === "memory_write";
+  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) {
@@ -566195,9 +566302,16 @@ function isStagnant(signals, opts) {
     return false;
   return signals.completedDelta <= 0 && signals.filesDelta < filesDeltaMin && signals.failureSum >= failureThreshold && signals.variantCount >= variantThreshold;
 }
+var NOOP_WRITE_CACHE_TOOLS;
 var init_critic = __esm({
   "packages/orchestrator/dist/critic.js"() {
     "use strict";
+    NOOP_WRITE_CACHE_TOOLS = /* @__PURE__ */ new Set([
+      "file_write",
+      "file_edit",
+      "batch_edit",
+      "file_patch"
+    ]);
   }
 });
 
@@ -566557,14 +566671,14 @@ var init_artifact_inspector = __esm({
 // packages/orchestrator/dist/lesson-bank.js
 import { existsSync as existsSync90, mkdirSync as mkdirSync52, appendFileSync as appendFileSync7, readFileSync as readFileSync69 } from "node:fs";
 import { join as join101, dirname as dirname30 } from "node:path";
-import { createHash as createHash25 } from "node:crypto";
+import { createHash as createHash26 } from "node:crypto";
 function tokenize4(text2) {
   if (!text2)
     return [];
   return text2.toLowerCase().split(TOKENIZE_RE).filter((t2) => t2.length >= 3).slice(0, 80);
 }
 function shortHash(s2) {
-  return createHash25("sha256").update(s2).digest("hex").slice(0, 16);
+  return createHash26("sha256").update(s2).digest("hex").slice(0, 16);
 }
 function solicit(args) {
   const { taskGoal, stem, reflections, successOutputPreview } = args;
@@ -566660,7 +566774,7 @@ var init_lesson_bank = __esm({
 // packages/orchestrator/dist/intervention-replay.js
 import { existsSync as existsSync91, mkdirSync as mkdirSync53, readFileSync as readFileSync70, writeFileSync as writeFileSync43, readdirSync as readdirSync29 } from "node:fs";
 import { join as join102, dirname as dirname31 } from "node:path";
-import { createHash as createHash26 } from "node:crypto";
+import { createHash as createHash27 } from "node:crypto";
 function checkpointDir2(workingDir) {
   return workingDir ? join102(workingDir, ".omnius", "checkpoints") : join102(process.env["HOME"] || ".", ".omnius", "checkpoints");
 }
@@ -566694,7 +566808,7 @@ function sanitizeMessagesForCheckpoint(messages2) {
       deduped.push(m2);
       continue;
     }
-    const digest3 = createHash26("sha1").update(content).digest("hex");
+    const digest3 = createHash27("sha1").update(content).digest("hex");
     if (seenSystemDigests.has(digest3))
       continue;
     seenSystemDigests.add(digest3);
@@ -572633,6 +572747,7 @@ var init_context_fabric = __esm({
     "use strict";
     PRIORITY = {
       GOAL: 100,
+      ACTION_CONTRACT: 98,
       USER_STEERING: 95,
       TASK_STATE: 80,
       KNOWN_FILES: 70,
@@ -572650,6 +572765,7 @@ var init_context_fabric = __esm({
     KIND_ORDER = [
       "goal",
       "user_steering",
+      "action_contract",
       "task_state",
       "known_files",
       "recent_failure",
@@ -572666,6 +572782,7 @@ var init_context_fabric = __esm({
     KIND_LABELS = {
       goal: "Goal",
       user_steering: "User Steering",
+      action_contract: "Next Action Contract",
       task_state: "Task State",
       known_files: "Known Files",
       recent_failure: "Recent Failures",
@@ -572682,6 +572799,7 @@ var init_context_fabric = __esm({
     DEFAULT_KIND_CHAR_BUDGET = {
       goal: 900,
       user_steering: 1400,
+      action_contract: 1800,
       task_state: 1800,
       known_files: 2400,
       recent_failure: 2600,
@@ -573035,7 +573153,7 @@ var init_evidenceLedger = __esm({
 import { existsSync as existsSync100, mkdirSync as mkdirSync58, readdirSync as readdirSync32, readFileSync as readFileSync78, statSync as statSync36, unlinkSync as unlinkSync17, writeFileSync as writeFileSync48, appendFileSync as appendFileSync9 } from "node:fs";
 import { homedir as homedir35 } from "node:os";
 import { join as join111, resolve as resolve51 } from "node:path";
-import { createHash as createHash27 } from "node:crypto";
+import { createHash as createHash28 } from "node:crypto";
 function contextWindowDumpDir(cwd4 = process.cwd()) {
   const envDir = process.env["OMNIUS_CONTEXT_WINDOW_DUMP_DIR"]?.trim();
   if (envDir)
@@ -573268,7 +573386,7 @@ function safeId(value2) {
   return String(value2 || "unknown").replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 160);
 }
 function shortHash2(value2) {
-  return createHash27("sha256").update(value2).digest("hex").slice(0, 10);
+  return createHash28("sha256").update(value2).digest("hex").slice(0, 10);
 }
 function pruneOldDumpFiles(dir) {
   const raw = Number(process.env["OMNIUS_CONTEXT_WINDOW_DUMP_MAX_FILES"]);
@@ -573645,7 +573763,7 @@ var init_adversaryStream = __esm({
 
 // packages/orchestrator/dist/debugArtifactLibrary.js
 import { appendFileSync as appendFileSync10, existsSync as existsSync101, mkdirSync as mkdirSync59, readFileSync as readFileSync79, statSync as statSync37, writeFileSync as writeFileSync49 } from "node:fs";
-import { createHash as createHash28 } from "node:crypto";
+import { createHash as createHash29 } from "node:crypto";
 import { basename as basename23, join as join112, relative as relative10, resolve as resolve52 } from "node:path";
 function debugArtifactRoot(cwd4 = process.cwd(), stateDir) {
   const envDir = process.env["OMNIUS_DEBUG_ARTIFACT_DIR"]?.trim();
@@ -574269,7 +574387,7 @@ function safeId2(value2) {
   return String(value2 || "unknown").replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 160);
 }
 function shortHash3(value2) {
-  return createHash28("sha256").update(value2).digest("hex").slice(0, 10);
+  return createHash29("sha256").update(value2).digest("hex").slice(0, 10);
 }
 var DEBUG_LIBRARY_DIR, RUN_EVENTS_LIMIT, PREVIEW_LIMIT;
 var init_debugArtifactLibrary = __esm({
@@ -574619,6 +574737,11 @@ var init_focusSupervisor = __esm({
           return;
         }
         if (input.toolName === "todo_write" && input.success) {
+          if (input.noop) {
+            this.lastDecision = "todo_noop_not_satisfied";
+            this.lastReason = "todo_write returned no-op; checklist state did not change";
+            return;
+          }
           this.clearSatisfiedDirective("todo plan updated", input.turn);
           return;
         }
@@ -575754,7 +575877,7 @@ __export(preflightSnapshot_exports, {
 import { existsSync as existsSync102, readFileSync as readFileSync80, statSync as statSync38, statfsSync as statfsSync6 } from "node:fs";
 import { homedir as homedir36, platform as platform4, arch as arch2, totalmem as totalmem4, freemem as freemem3, hostname as hostname3 } from "node:os";
 import { join as join113 } from "node:path";
-import { createHash as createHash29 } from "node:crypto";
+import { createHash as createHash30 } from "node:crypto";
 function capturePreflightSnapshot(workingDir) {
   const warnings = [];
   const configFingerprints = {};
@@ -575923,7 +576046,7 @@ function expandPath(p2) {
   return p2;
 }
 function sha2564(s2) {
-  return createHash29("sha256").update(s2).digest("hex").slice(0, 16);
+  return createHash30("sha256").update(s2).digest("hex").slice(0, 16);
 }
 function freeDiskBytes(path12 = "/tmp") {
   try {
@@ -578208,21 +578331,239 @@ ${parts.join("\n")}
         }
         return null;
       }
+      _currentWorkboardSnapshotForFrame() {
+        const dir = this._workboardDir();
+        const fromDisk = readActiveWorkboardSnapshot(dir, this._sessionId);
+        if (fromDisk) {
+          this._workboard = fromDisk;
+          return fromDisk;
+        }
+        if (this._workboard)
+          return this._workboard;
+        const goal = this._taskState.originalGoal || this._taskState.goal || "";
+        if (this._initialWorkboardCardsForGoal(goal).length === 0)
+          return null;
+        return this.getOrCreateWorkboard();
+      }
+      _workboardEvidenceCount(card) {
+        return card?.evidence?.length ?? 0;
+      }
+      _workboardHasEditEvidence(card) {
+        if (!card)
+          return false;
+        const editTools = /* @__PURE__ */ new Set(["file_write", "file_edit", "batch_edit", "file_patch"]);
+        return card.evidence.some((e2) => typeof e2.tool === "string" && editTools.has(e2.tool));
+      }
+      _workboardHasVerificationEvidence(card) {
+        if (!card)
+          return false;
+        return card.evidence.some((e2) => e2.tool === "shell" || e2.tool === "background_run");
+      }
+      _deriveWorkboardActionContract(snapshot) {
+        if (snapshot.cards.length === 0)
+          return null;
+        const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
+        const discovery = byId.get("discover-current-state");
+        const implementation2 = byId.get("implement-repair");
+        const integration = byId.get("integrate-and-run");
+        const verification = byId.get("verify-observed-outcome");
+        const discoveryEvidence = this._workboardEvidenceCount(discovery);
+        const hasImplementationEvidence = this._workboardHasEditEvidence(implementation2);
+        const hasVerificationEvidence = this._workboardHasVerificationEvidence(integration);
+        if (hasImplementationEvidence && !hasVerificationEvidence && integration) {
+          return {
+            cardId: integration.id,
+            title: integration.title,
+            reason: "implementation evidence exists; exercise the changed runtime path before more discovery",
+            preferredTools: ["shell"]
+          };
+        }
+        if (hasVerificationEvidence && verification) {
+          return {
+            cardId: verification.id,
+            title: verification.title,
+            reason: "verification evidence exists; reconcile outcome, todos, and blockers",
+            preferredTools: ["todo_write", "task_complete"]
+          };
+        }
+        if (discoveryEvidence > 0 && !hasImplementationEvidence && implementation2) {
+          return {
+            cardId: implementation2.id,
+            title: implementation2.title,
+            reason: "discovery evidence is already present; land the smallest concrete repair",
+            preferredTools: ["file_write", "file_edit", "batch_edit", "file_patch"]
+          };
+        }
+        const active = snapshot.cards.find((card) => card.status === "in_progress") ?? snapshot.cards.find((card) => card.status === "needs_changes") ?? snapshot.cards.find((card) => card.status === "open") ?? discovery;
+        if (!active)
+          return null;
+        return {
+          cardId: active.id,
+          title: active.title,
+          reason: active.id === "discover-current-state" ? "no authoritative target evidence is recorded yet" : "workboard card is the next unresolved card",
+          preferredTools: active.id === "discover-current-state" ? ["file_read", "grep_search", "list_directory", "shell"] : ["file_write", "file_edit", "batch_edit", "file_patch", "shell"]
+        };
+      }
+      _focusToolsForRequiredAction(action) {
+        switch (action) {
+          case "update_todos":
+            return "todo_write with a changed plan/status, or a real file edit if that is the active work";
+          case "read_authoritative_target":
+          case "use_cached_evidence":
+            return "use cached evidence or one authoritative file_read/read-only shell, then act";
+          case "edit_different_target":
+            return "file_write, file_edit, batch_edit, or file_patch on a different supported target";
+          case "run_verification":
+            return "shell running the verification/runtime command";
+          case "report_blocked":
+          case "report_incomplete":
+            return "task_complete with the concrete blocker/incomplete evidence";
+          default:
+            return "choose the narrowest tool that advances the current card";
+        }
+      }
+      _renderNextActionContract(turn) {
+        const lines = ["[NEXT ACTION CONTRACT]", `turn=${turn}`];
+        const focus = this._focusSupervisor?.snapshot().directive ?? null;
+        if (focus) {
+          lines.push(`focus_required_next_action=${focus.requiredNextAction}`);
+          lines.push(`focus_valid_tools=${this._focusToolsForRequiredAction(focus.requiredNextAction)}`);
+          lines.push(`focus_reason=${focus.reason}`);
+        }
+        const snapshot = this._currentWorkboardSnapshotForFrame();
+        const action = snapshot ? this._deriveWorkboardActionContract(snapshot) : null;
+        if (snapshot && action) {
+          const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
+          const discovery = byId.get("discover-current-state");
+          const implementation2 = byId.get("implement-repair");
+          const integration = byId.get("integrate-and-run");
+          const verification = byId.get("verify-observed-outcome");
+          lines.push(`workboard_current_card=${action.cardId} (${action.title})`);
+          lines.push(`workboard_preferred_tools=${action.preferredTools.join(", ")}`);
+          lines.push(`workboard_reason=${action.reason}`);
+          lines.push(`workboard_evidence_counts=discover:${this._workboardEvidenceCount(discovery)} implement:${this._workboardEvidenceCount(implementation2)} integrate:${this._workboardEvidenceCount(integration)} verify:${this._workboardEvidenceCount(verification)}`);
+          if (this._workboardHasEditEvidence(implementation2)) {
+            lines.push("implementation_state=mutation evidence is already recorded; do not treat discovery as the active phase");
+          }
+        }
+        const todos = this.readSessionTodos() ?? [];
+        if (todos.length > 0) {
+          const inProgress = todos.filter((todo) => todo.status === "in_progress");
+          const pending2 = todos.filter((todo) => todo.status === "pending");
+          const blocked = todos.filter((todo) => todo.status === "blocked");
+          lines.push(`todo_counts=in_progress:${inProgress.length} pending:${pending2.length} blocked:${blocked.length}`);
+          if (inProgress[0]) {
+            lines.push(`todo_current=${inProgress[0].content.slice(0, 180)}`);
+          } else if (pending2.length > 0) {
+            lines.push("todo_contract=mark exactly one pending todo in_progress before using the checklist as progress");
+          }
+        }
+        if (lines.length === 2)
+          return null;
+        lines.push("not_progress=repeat unchanged todo_write; repeat broad discovery already represented in this frame; keep discovery active after a real mutation");
+        return lines.join("\n");
+      }
+      _workboardTargetCardId(snapshot, toolName, result) {
+        const byId = new Map(snapshot.cards.map((card) => [card.id, card]));
+        if (this._isProjectEditTool(toolName) && this._isRealProjectMutation(toolName, result)) {
+          return byId.has("implement-repair") ? "implement-repair" : null;
+        }
+        if (toolName === "shell" || toolName === "background_run") {
+          const implementation2 = byId.get("implement-repair");
+          const target = this._workboardHasEditEvidence(implementation2) ? "integrate-and-run" : "discover-current-state";
+          return byId.has(target) ? target : null;
+        }
+        if (toolName === "file_read" || toolName === "file_explore" || toolName === "list_directory" || toolName === "grep_search" || toolName === "find_files" || toolName === "web_search") {
+          return byId.has("discover-current-state") ? "discover-current-state" : null;
+        }
+        const active = snapshot.cards.find((card) => card.status === "in_progress");
+        return active?.id ?? null;
+      }
+      _refreshWorkboardSnapshot(snapshot) {
+        const refreshed = readActiveWorkboardSnapshot(this._workboardDir(), this._sessionId) ?? snapshot;
+        this._workboard = refreshed;
+        return refreshed;
+      }
+      _advanceWorkboardForTool(snapshot, toolName, result, actor) {
+        const dir = this._workboardDir();
+        let current = snapshot;
+        const byId = () => new Map(current.cards.map((card) => [card.id, card]));
+        const editMutation = this._isProjectEditTool(toolName) && this._isRealProjectMutation(toolName, result);
+        try {
+          if (editMutation) {
+            let cards = byId();
+            const discovery = cards.get("discover-current-state");
+            if (discovery && discovery.status !== "verified" && discovery.evidence.length > 0) {
+              const completed = completeWorkboardCard(dir, {
+                runId: this._sessionId,
+                cardId: discovery.id,
+                actor,
+                outcome: "completed",
+                reason: "Implementation started after authoritative discovery evidence was recorded."
+              });
+              current = completed.snapshot;
+              cards = byId();
+              const completedDiscovery = cards.get("discover-current-state");
+              if (completedDiscovery?.status === "completed") {
+                const verified = completeWorkboardCard(dir, {
+                  runId: this._sessionId,
+                  cardId: completedDiscovery.id,
+                  actor,
+                  outcome: "verified",
+                  reason: "Discovery evidence was sufficient to select and mutate the implementation target."
+                });
+                current = verified.snapshot;
+                cards = byId();
+              }
+            }
+            const implementation2 = cards.get("implement-repair");
+            if (implementation2 && (implementation2.status === "open" || implementation2.status === "needs_changes")) {
+              current = updateWorkboardCard(dir, {
+                runId: this._sessionId,
+                cardId: implementation2.id,
+                actor,
+                updates: { status: "in_progress", lane: "worker" },
+                decisionReason: "Real project mutation landed; implementation is now the active phase."
+              });
+            }
+          }
+          if (toolName === "shell" || toolName === "background_run") {
+            const cards = byId();
+            const implementation2 = cards.get("implement-repair");
+            const integration = cards.get("integrate-and-run");
+            if (integration && this._workboardHasEditEvidence(implementation2) && (integration.status === "open" || integration.status === "needs_changes")) {
+              current = updateWorkboardCard(dir, {
+                runId: this._sessionId,
+                cardId: integration.id,
+                actor,
+                updates: { status: "in_progress", lane: "verification" },
+                decisionReason: "Runtime or verification command ran after implementation evidence."
+              });
+            }
+          }
+        } catch {
+        }
+        return this._refreshWorkboardSnapshot(current);
+      }
       /**
        * Record evidence from a tool call against the active workboard.
        * Matches by card assignee when the card is in progress.
        * Non-fatal: failures to attach evidence are silently caught.
        */
-      recordWorkboardToolCall(toolName, args, success, output) {
+      recordWorkboardToolCall(toolName, args, success, output, result) {
         const board = this._workboard ?? this.getOrCreateWorkboard();
         if (!board)
           return;
         if (toolName === "task_complete" || toolName === "workboard_create")
           return;
+        if (result?.success === true && this._isProjectEditTool(toolName) && !this._isRealProjectMutation(toolName, result)) {
+          return;
+        }
         const dir = this._workboardDir();
         try {
           const evidenceSummary = `${toolName} ${success ? "ok" : "fail"}`;
-          const evidenceContent = (success ? typeof output === "string" ? output : "" : "").slice(0, 1e3);
+          const rawEvidenceOutput = typeof output === "string" && output.length > 0 ? output : result?.output || result?.error || "";
+          const evidenceContent = rawEvidenceOutput.slice(0, 1e3);
           const evidence = {
             kind: "tool_result",
             summary: evidenceSummary,
@@ -578232,24 +578573,23 @@ ${parts.join("\n")}
             ref: typeof args["path"] === "string" ? args["path"]?.slice(0, 200) : void 0
           };
           const actor = this.options.subAgent ? "sub-agent" : "agent";
-          for (const card of board.cards) {
-            if (card.status !== "in_progress" && card.status !== "open")
-              continue;
-            if (card.assignee && card.assignee !== actor && card.assignee !== "any")
-              continue;
-            if (toolName === "shell" && !card.evidenceRequirements.some((r2) => r2.toLowerCase().includes("shell") || r2.toLowerCase().includes("build") || r2.toLowerCase().includes("test")))
-              continue;
-            if (toolName === "file_write" && !card.evidenceRequirements.some((r2) => r2.toLowerCase().includes("file") || r2.toLowerCase().includes("write") || r2.toLowerCase().includes("implement")))
-              continue;
-            if (toolName === "file_read" && !card.evidenceRequirements.some((r2) => r2.toLowerCase().includes("read") || r2.toLowerCase().includes("explor") || r2.toLowerCase().includes("understand")))
-              continue;
-            attachWorkboardEvidence(dir, {
-              runId: this._sessionId,
-              cardId: card.id,
-              actor,
-              evidence
-            });
+          const advanced = this._advanceWorkboardForTool(board, toolName, result, actor);
+          const targetCardId = this._workboardTargetCardId(advanced, toolName, result);
+          if (!targetCardId)
+            return;
+          const targetCard = advanced.cards.find((card) => card.id === targetCardId);
+          if (!targetCard)
+            return;
+          if (targetCard.assignee && targetCard.assignee !== actor && targetCard.assignee !== "any") {
+            return;
           }
+          attachWorkboardEvidence(dir, {
+            runId: this._sessionId,
+            cardId: targetCard.id,
+            actor,
+            evidence
+          });
+          this._refreshWorkboardSnapshot(advanced);
         } catch {
         }
       }
@@ -579714,6 +580054,21 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           return false;
         return true;
       }
+      _isTodoWriteNoopResult(result) {
+        if (!result)
+          return false;
+        if (result.noop === true)
+          return true;
+        const text2 = String(result.output ?? result.llmContent ?? "");
+        if (!text2 || !/"noop"\s*:\s*true/.test(text2))
+          return false;
+        try {
+          const parsed = JSON.parse(text2);
+          return parsed?.noop === true;
+        } catch {
+          return true;
+        }
+      }
       _toolEvidencePreview(result, displayOutput, max = 500, toolName) {
         const modelVisible = result.llmContent ?? result.output ?? displayOutput ?? "";
         const failurePrefix = result.success === false && result.error ? `Error: ${result.error}` : "";
@@ -579799,6 +580154,9 @@ ${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 : []);
+        if (input.result.success === true && this._isProjectEditTool(input.toolName) && !realFileMutation) {
+          return;
+        }
         if (this._shouldSuppressCompletionDiscoveryEvidence(input.toolName, input.result, attemptedTargetPaths)) {
           return;
         }
@@ -582432,6 +582790,7 @@ ${chunk.content}`, {
         const failureBlock = this._renderRecentFailuresBlock(turn);
         const churnBlock = this._renderWriteChurnBlock(turn);
         const focusBlock = this._focusSupervisor?.renderFrame() ?? null;
+        const actionContractBlock = this._renderNextActionContract(turn);
         const toolCacheBlock = recentToolResults ? this._renderKnowledgeBlock(recentToolResults) : null;
         const anchorsBlock = this.surfaceAnchors(messages2);
         const pprMemoryBlock = this._lastPprMemoryLines.length > 0 ? `[Associative Memory - related prior experience]
@@ -582469,6 +582828,13 @@ ${this._lastPprMemoryLines.slice(0, 5).join("\n")}` : null;
             createdTurn: turn,
             ttlTurns: 1
           }),
+          signalFromBlock("action_contract", "turn.next-action-contract", actionContractBlock, {
+            id: "next-action-contract",
+            dedupeKey: "turn.next-action-contract",
+            priority: PRIORITY.ACTION_CONTRACT,
+            createdTurn: turn,
+            ttlTurns: 1
+          }),
           signalFromBlock("task_state", "turn.todos", todoBlock, {
             id: "todo-state",
             dedupeKey: "turn.todos",
@@ -584430,6 +584796,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         const recentToolResults = /* @__PURE__ */ new Map();
         const dedupHitCount = /* @__PURE__ */ new Map();
         const noopedMemoryWriteFingerprints = /* @__PURE__ */ new Set();
+        const noopedProjectWriteFingerprints = /* @__PURE__ */ new Set();
         const DEDUP_ESCALATION_THRESHOLD = 3;
         const toolCallBudget = /* @__PURE__ */ new Map();
         const loopTier = this.options.modelTier ?? "large";
@@ -586073,8 +586440,8 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               if (process.env["OMNIUS_DISABLE_ADAPTIVE_RETRIEVAL"] !== "1") {
                 const goalForSig = (this._taskState.goal || "").slice(0, 200);
                 const recentTools = this._toolSequence.slice(-5).join("|");
-                const { createHash: createHash47 } = await import("node:crypto");
-                const sig = createHash47("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
+                const { createHash: createHash48 } = await import("node:crypto");
+                const sig = createHash48("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
                 if (this._lastPprSig === sig && this._lastPprMemoryLines.length > 0) {
                   compacted.push({
                     role: "system",
@@ -587019,7 +587386,9 @@ Corrective action: try a different approach first: read relevant files, adjust a
               }
               const exactToolFingerprint = this._buildToolFingerprint(tc.name, tc.arguments ?? {});
               const toolFingerprint = this._resolveReadCoverageFingerprint(tc.name, tc.arguments ?? {}, exactToolFingerprint);
-              if (tc.name === "memory_write" && noopedMemoryWriteFingerprints.has(toolFingerprint)) {
+              const repeatedMemoryWriteNoop = tc.name === "memory_write" && noopedMemoryWriteFingerprints.has(toolFingerprint);
+              const repeatedProjectWriteNoop = this._isProjectEditTool(tc.name) && noopedProjectWriteFingerprints.has(toolFingerprint);
+              if (repeatedMemoryWriteNoop || repeatedProjectWriteNoop) {
                 this.emit({
                   type: "tool_call",
                   toolName: tc.name,
@@ -587027,9 +587396,11 @@ Corrective action: try a different approach first: read relevant files, adjust a
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
-                const repeatNoopMsg = `[MEMORY WRITE NO-OP REPEAT BLOCK] Exact repeat of memory_write(${JSON.stringify(tc.arguments ?? {}).slice(0, 200)}).
+                const repeatNoopMsg = repeatedMemoryWriteNoop ? `[MEMORY WRITE NO-OP REPEAT BLOCK] Exact repeat of memory_write(${JSON.stringify(tc.arguments ?? {}).slice(0, 200)}).
 This same topic/key/value was already confirmed stored, so the call was not executed again.
-Use the saved fact to continue the promised synthesis or next concrete step, or call task_complete if this bookkeeping was the final step.`;
+Use the saved fact to continue the promised synthesis or next concrete step, or call task_complete if this bookkeeping was the final step.` : `[PROJECT WRITE NO-OP REPEAT BLOCK] Exact repeat of ${tc.name}(${JSON.stringify(tc.arguments ?? {}).slice(0, 200)}).
+This edit was already confirmed to make no file change, so the call was not executed again.
+Read the current file if needed, make a different concrete edit, or move to verification/completion.`;
                 this.emit({
                   type: "tool_result",
                   toolName: tc.name,
@@ -587040,7 +587411,7 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                 });
                 this._tagSyntheticFailure({
                   mode: "step_repetition",
-                  rationale: "memory_write retried after an exact no-op was observed"
+                  rationale: repeatedMemoryWriteNoop ? "memory_write retried after an exact no-op was observed" : `${tc.name} retried after an exact project-write no-op was observed`
                 });
                 return {
                   tc,
@@ -587739,7 +588110,7 @@ Respond with EXACTLY this structure before your next tool call:
                     }
                   }
                 }
-                if (tc.name === "todo_write" && result.success) {
+                if (tc.name === "todo_write" && result.success && !this._isTodoWriteNoopResult(result)) {
                   if (this._progressGateActive) {
                     this.emit({
                       type: "status",
@@ -588322,7 +588693,7 @@ Respond with EXACTLY this structure before your next tool call:
                         timestamp: (/* @__PURE__ */ new Date()).toISOString()
                       });
                     }
-                    if (!this._newFieldNudgeFired) {
+                    if (!this._newFieldNudgeFired && !this._isTodoWriteNoopResult(result)) {
                       this._todoWritesObservedForNudge++;
                       const _anyFieldUsed = _todosNow.some((t2) => typeof t2.verifyCommand === "string" || Array.isArray(t2.declaredArtifacts));
                       if (this._todoWritesObservedForNudge >= 2 && !_anyFieldUsed) {
@@ -588444,7 +588815,8 @@ Respond with EXACTLY this structure before your next tool call:
                 }
               }
               const cacheableMemoryNoop = tc.name === "memory_write" && result.success && result.noop;
-              if (isReadLike && result.success || tc.name === "shell" || cacheableMemoryNoop) {
+              const cacheableProjectWriteNoop = this._isProjectEditTool(tc.name) && result.success && !this._isRealProjectMutation(tc.name, result) && (result.noop === true || result.mutated === false);
+              if (isReadLike && result.success || tc.name === "shell" || 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
@@ -588465,10 +588837,17 @@ Respond with EXACTLY this structure before your next tool call:
                   if (firstKey !== void 0) {
                     recentToolResults.delete(firstKey);
                     dedupHitCount.delete(firstKey);
+                    noopedMemoryWriteFingerprints.delete(firstKey);
+                    noopedProjectWriteFingerprints.delete(firstKey);
                   }
                 }
-                if (cacheableMemoryNoop) {
-                  noopedMemoryWriteFingerprints.add(toolFingerprint);
+                if (cacheableMemoryNoop || cacheableProjectWriteNoop) {
+                  if (cacheableMemoryNoop) {
+                    noopedMemoryWriteFingerprints.add(toolFingerprint);
+                  }
+                  if (cacheableProjectWriteNoop) {
+                    noopedProjectWriteFingerprints.add(toolFingerprint);
+                  }
                   const repeatGateSeed = Math.max(0, this._resolveRepeatGateMax() - 1);
                   if (repeatGateSeed > 0) {
                     dedupHitCount.set(toolFingerprint, Math.max(dedupHitCount.get(toolFingerprint) ?? 0, repeatGateSeed));
@@ -588489,6 +588868,10 @@ Respond with EXACTLY this structure before your next tool call:
                       if (key.includes(mp))
                         recentToolResults.delete(key);
                     }
+                    for (const key of Array.from(noopedProjectWriteFingerprints)) {
+                      if (key.includes(mp))
+                        noopedProjectWriteFingerprints.delete(key);
+                    }
                     for (const covKey of Array.from(this._readCoverage.keys())) {
                       if (covKey.includes(mp))
                         this._readCoverage.delete(covKey);
@@ -588496,15 +588879,18 @@ Respond with EXACTLY this structure before your next tool call:
                   }
                 } else if (dedupHitCount.size > 0) {
                   dedupHitCount.clear();
+                  recentToolResults.clear();
+                  noopedProjectWriteFingerprints.clear();
                 }
               }
               if (shellFilesystemMutation && recentToolResults.size > 0) {
                 for (const key of Array.from(recentToolResults.keys())) {
-                  if (key.startsWith("shell:") || key.startsWith("file_read:") || key.startsWith("list_directory:") || key.startsWith("grep_search:") || key.startsWith("find_files:")) {
+                  if (key.startsWith("shell:") || key.startsWith("file_read:") || key.startsWith("file_write:") || key.startsWith("file_edit:") || key.startsWith("batch_edit:") || key.startsWith("file_patch:") || key.startsWith("list_directory:") || key.startsWith("grep_search:") || key.startsWith("find_files:")) {
                     recentToolResults.delete(key);
                     dedupHitCount.delete(key);
                   }
                 }
+                noopedProjectWriteFingerprints.clear();
                 this._readCoverage.clear();
                 this.emit({
                   type: "status",
@@ -588790,12 +589176,12 @@ Evidence: ${evidencePreview}`.slice(0, 500);
               this.emit({
                 type: "tool_result",
                 toolName: tc.name,
-                content: this.toolResultEventContent(tc.name, output),
+                content: this.toolResultEventContent(tc.name, output || result.output || result.error || ""),
                 success: result.success,
                 turn,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
-              this.recordWorkboardToolCall(tc.name, tc.arguments, result.success, result.output || output);
+              this.recordWorkboardToolCall(tc.name, tc.arguments, result.success, result.output || result.error || output, result);
               this._taskState.toolCallCount++;
               if (realFileMutation) {
                 this._lastFileWriteTurn = turn;
@@ -588924,7 +589310,8 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                   output: result.output ?? result.llmContent ?? "",
                   error: result.error ?? "",
                   mutated: realFileMutation || shellFilesystemMutation,
-                  isReadLike
+                  isReadLike,
+                  noop: tc.name === "todo_write" ? this._isTodoWriteNoopResult(result) : result.noop
                 });
                 const focusSnapshotAfter = this._focusSupervisor?.snapshot();
                 focusAfterToolResult = focusSnapshotAfter ?? void 0;
@@ -588953,7 +589340,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                   args: tc.arguments,
                   success: result.success,
                   durationMs: performance.now() - toolStart,
-                  output: result.output || output,
+                  output: result.output || output || result.error || "",
                   error: result.error ?? "",
                   llmContent: result.llmContent,
                   realFileMutation,
@@ -588971,7 +589358,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
                 });
               } catch {
               }
-              if (tc.name === "todo_write") {
+              if (tc.name === "todo_write" && !this._isTodoWriteNoopResult(result)) {
                 this._lastTodoWriteTurn = turn;
               }
               if (tc.name === "file_read" || tc.name === "list_directory" || tc.name === "find_files" || tc.name === "grep_search") {
@@ -589028,12 +589415,13 @@ Do NOT retry ${tc.name} with similar arguments.`);
                 }
               }
               if (filePath && (tc.name === "file_read" || tc.name === "file_write" || tc.name === "file_edit" || tc.name === "batch_edit" || tc.name === "file_patch")) {
-                const isModify = tc.name !== "file_read";
+                const isRead = tc.name === "file_read";
+                const isModify = realFileMutation;
                 const existing = this._fileRegistry.get(filePath);
                 this._fileRegistry.set(filePath, {
                   lastSeenTurn: turn,
                   modified: existing?.modified || isModify,
-                  summary: isModify ? `Modified (${tc.name}) turn ${turn}` : `Read turn ${turn} (${result.output.split("\n").length} lines)`,
+                  summary: isModify ? `Modified (${tc.name}) turn ${turn}` : isRead ? `Read turn ${turn} (${result.output.split("\n").length} lines)` : `${tc.name} no file change turn ${turn}`,
                   accessCount: (existing?.accessCount ?? 0) + 1
                 });
                 if (isModify) {
@@ -589054,7 +589442,9 @@ Do NOT retry ${tc.name} with similar arguments.`);
               }
               if (result.success) {
                 if (tc.name === "file_write" || tc.name === "file_edit" || tc.name === "batch_edit") {
-                  this._taskState.completedSteps.push(`${tc.name}: \`${filePath}\``);
+                  if (realFileMutation) {
+                    this._taskState.completedSteps.push(`${tc.name}: \`${filePath}\``);
+                  }
                 } else if ((tc.name === "shell" || tc.name === "background_run") && /PASS|passed|success|✓/i.test(result.output)) {
                   this._taskState.completedSteps.push(`Test passed: \`${String(tc.arguments?.command ?? "").slice(0, 80)}\``);
                 } else if (tc.name === "memory_write" && !result.noop) {
@@ -590299,7 +590689,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                 this.emit({
                   type: "tool_result",
                   toolName: tc.name,
-                  content: this.toolResultEventContent(tc.name, output),
+                  content: this.toolResultEventContent(tc.name, output || result.output || result.error || ""),
                   success: result.success,
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -591722,7 +592112,7 @@ ${marker}` : marker);
           }
           return;
         }
-        if (toolName === "file_write" && path12 && result.success && result.mutated !== false) {
+        if (toolName === "file_write" && path12 && this._isRealProjectMutation(toolName, result)) {
           for (const [key2, entry] of this._staleEditFamilies) {
             if (entry.pathKey === pathKey)
               this._staleEditFamilies.delete(key2);
@@ -591735,7 +592125,7 @@ ${marker}` : marker);
         if (!target)
           return;
         const targetPathKey = this.staleEditPathKey(target.path);
-        if (result.success && result.mutated !== false) {
+        if (this._isRealProjectMutation(toolName, result)) {
           for (const [key2, entry] of this._staleEditFamilies) {
             if (entry.pathKey === targetPathKey)
               this._staleEditFamilies.delete(key2);
@@ -598101,7 +598491,7 @@ var init_composite_scorer = __esm({
 });
 
 // packages/orchestrator/dist/memory/materialization-policy.js
-import { createHash as createHash30 } from "node:crypto";
+import { createHash as createHash31 } from "node:crypto";
 function materializeMemoryItems(items, options2 = {}) {
   const config = options2.config ?? DEFAULT_WEIGHTING_CONFIG;
   const sorted = [...items].sort((a2, b) => b.weight - a2.weight || a2.id.localeCompare(b.id));
@@ -598339,7 +598729,7 @@ function estimateTokens4(text2) {
   return Math.max(1, Math.ceil(text2.length / 4));
 }
 function hashText(text2) {
-  return createHash30("sha256").update(text2).digest("hex");
+  return createHash31("sha256").update(text2).digest("hex");
 }
 var init_materialization_policy = __esm({
   "packages/orchestrator/dist/memory/materialization-policy.js"() {
@@ -598503,7 +598893,7 @@ var init_config_loader = __esm({
 });
 
 // packages/orchestrator/dist/memory/stability-tracker.js
-import { createHash as createHash31 } from "node:crypto";
+import { createHash as createHash32 } from "node:crypto";
 import { existsSync as existsSync106, mkdirSync as mkdirSync60, readFileSync as readFileSync83, writeFileSync as writeFileSync51 } from "node:fs";
 import { dirname as dirname36, join as join117 } from "node:path";
 function stabilityFilePath(repoRoot) {
@@ -598567,7 +598957,7 @@ function computeStabilityHash(item) {
     item.scope.name,
     item.topicKey
   ].join("|");
-  return createHash31("sha256").update(normalized).digest("hex");
+  return createHash32("sha256").update(normalized).digest("hex");
 }
 function normalizeContent2(content) {
   return content.replace(/\s+/g, " ").trim();
@@ -602539,10 +602929,10 @@ var init_project_arc = __esm({
 });
 
 // packages/orchestrator/dist/dedup-gate.js
-import { createHash as createHash32 } from "node:crypto";
+import { createHash as createHash33 } from "node:crypto";
 function fingerprintCall(name10, args) {
   const canon = canonicalize(args);
-  return createHash32("sha1").update(`${name10}\0${canon}`).digest("hex").slice(0, 16);
+  return createHash33("sha1").update(`${name10}\0${canon}`).digest("hex").slice(0, 16);
 }
 function canonicalize(value2) {
   if (value2 === null || typeof value2 !== "object")
@@ -604476,12 +604866,14 @@ var init_py_embed = __esm({
 var listen_exports = {};
 __export(listen_exports, {
   ListenEngine: () => ListenEngine,
+  asrConsensusEnabled: () => asrConsensusEnabled,
   ensureTranscribeCliBackground: () => ensureTranscribeCliBackground,
   getListenEngine: () => getListenEngine,
   getListenLiveState: () => getListenLiveState,
   isAudioPath: () => isAudioPath,
   isTranscribablePath: () => isTranscribablePath,
   isVideoPath: () => isVideoPath,
+  resolveAsrConsensusModel: () => resolveAsrConsensusModel,
   transcribeFileViaWhisper: () => transcribeFileViaWhisper,
   waitForTranscribeCli: () => waitForTranscribeCli
 });
@@ -604886,9 +605278,25 @@ function defaultConsensusModel(primaryModel) {
   if (model === "large-v3" || model === "large") return "small";
   return "base";
 }
-function asrConsensusEnabled() {
-  const consensusEnv = String(process.env["OMNIUS_ASR_CONSENSUS"] ?? "").trim().toLowerCase();
-  return !(consensusEnv === "0" || consensusEnv === "off" || consensusEnv === "false");
+function resolveAsrConsensusModel(primaryModel) {
+  const disabled = String(process.env["OMNIUS_ASR_DISABLE_CONSENSUS"] ?? "").trim().toLowerCase();
+  if (disabled === "1" || disabled === "true" || disabled === "yes" || disabled === "on") {
+    return "off";
+  }
+  const consensusEnv = String(
+    process.env["OMNIUS_ASR_CONSENSUS"] ?? process.env["OMNIUS_ASR_CONSENSUS_MODEL"] ?? ""
+  ).trim().toLowerCase();
+  if (!consensusEnv) return "off";
+  if (["0", "off", "false", "no", "none", "disabled"].includes(consensusEnv)) {
+    return "off";
+  }
+  if (["1", "on", "true", "yes", "enabled", "auto"].includes(consensusEnv)) {
+    return defaultConsensusModel(primaryModel);
+  }
+  return consensusEnv;
+}
+function asrConsensusEnabled(primaryModel = "base") {
+  return resolveAsrConsensusModel(primaryModel) !== "off";
 }
 function liveAsrUseTranscribeCli() {
   const value2 = String(process.env["OMNIUS_ASR_USE_TRANSCRIBE_CLI"] ?? "").trim().toLowerCase();
@@ -605121,8 +605529,7 @@ var init_listen = __esm({
           model: this.model,
           lastStatus: `loading whisper ${this.model} model...`
         });
-        const consensusEnv = String(process.env["OMNIUS_ASR_CONSENSUS"] ?? "").trim().toLowerCase();
-        const consensusModel = consensusEnv === "0" || consensusEnv === "off" || consensusEnv === "false" ? "off" : consensusEnv || defaultConsensusModel(this.model);
+        const consensusModel = resolveAsrConsensusModel(this.model);
         const consensusThreshold = String(process.env["OMNIUS_ASR_CONSENSUS_THRESHOLD"] ?? "0.45");
         const silenceMs = String(process.env["OMNIUS_ASR_SILENCE_MS"] ?? "3000");
         this.process = spawn29(
@@ -605186,7 +605593,9 @@ var init_listen = __esm({
                     updateListenLiveState({
                       lastStatus: message2
                     });
-                    this.emit("status", message2);
+                    if (process.env["OMNIUS_ASR_VERBOSE_CONSENSUS"] === "1") {
+                      this.emit("status", message2);
+                    }
                   }
                   break;
                 case "vad": {
@@ -605539,7 +605948,7 @@ var init_listen = __esm({
           updateListenLiveState({ phase: "error", lastStatus: "no mic capture tool (arecord/sox/ffmpeg)" });
           return "No microphone capture tool found. Install arecord (Linux), sox (macOS), or ffmpeg.";
         }
-        const consensusEnabled = asrConsensusEnabled();
+        const consensusEnabled = asrConsensusEnabled(this.config.model);
         const useTranscribeCli = liveAsrUseTranscribeCli() && !consensusEnabled;
         const preferWhisperFallback = !useTranscribeCli;
         if (preferWhisperFallback) {
@@ -605833,7 +606242,7 @@ transcribe-cli error: ${transcribeCliError}` : "";
        * Caller is responsible for calling .stop() when done.
        */
       async createCallTranscriber() {
-        const requireConsensus = asrConsensusEnabled();
+        const requireConsensus = asrConsensusEnabled(this.config.model);
         const useTranscribeCli = liveAsrUseTranscribeCli() && !requireConsensus;
         let tc = useTranscribeCli ? await this.loadTranscribeCli() : null;
         if (useTranscribeCli && !tc && _bgInstallPromise) {
@@ -612845,7 +613254,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes31, createHash: createHash47 } = __require("crypto");
+    var { randomBytes: randomBytes31, createHash: createHash48 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate3();
@@ -613505,7 +613914,7 @@ var require_websocket3 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash47("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash48("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -613872,7 +614281,7 @@ var require_websocket_server2 = __commonJS({
     var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash47 } = __require("crypto");
+    var { createHash: createHash48 } = __require("crypto");
     var extension3 = require_extension3();
     var PerMessageDeflate3 = require_permessage_deflate3();
     var subprotocol3 = require_subprotocol2();
@@ -614173,7 +614582,7 @@ var require_websocket_server2 = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash47("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash48("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -620726,14 +621135,14 @@ var init_voice_session = __esm({
 });
 
 // packages/cli/src/tui/scoped-personality.ts
-import { createHash as createHash33 } from "node:crypto";
+import { createHash as createHash34 } from "node:crypto";
 import { appendFileSync as appendFileSync13, existsSync as existsSync117, mkdirSync as mkdirSync72, readFileSync as readFileSync96, writeFileSync as writeFileSync60 } from "node:fs";
 import { join as join131, resolve as resolve56 } from "node:path";
 function safeName(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
 }
 function scopeHash(scope) {
-  return createHash33("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
+  return createHash34("sha1").update(`${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
 }
 function scopedPersonalityDir(repoRoot, kind) {
   return resolve56(repoRoot, ".omnius", "scoped-personality", kind);
@@ -621105,7 +621514,7 @@ var init_scoped_personality = __esm({
 });
 
 // packages/cli/src/tui/voice-soul.ts
-import { createHash as createHash34 } from "node:crypto";
+import { createHash as createHash35 } from "node:crypto";
 import { existsSync as existsSync118, readdirSync as readdirSync38, readFileSync as readFileSync97 } from "node:fs";
 import { basename as basename25, join as join132, resolve as resolve57 } from "node:path";
 function compactText(text2, limit) {
@@ -621120,7 +621529,7 @@ function blockText(text2, limit) {
 ... [truncated]`;
 }
 function scopeStateKey(scope, surface) {
-  return createHash34("sha1").update(`${surface}:${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
+  return createHash35("sha1").update(`${surface}:${scope.kind}:${scope.id}`).digest("hex").slice(0, 16);
 }
 function safeName2(input) {
   return input.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 80) || "default";
@@ -623764,7 +624173,7 @@ var init_types3 = __esm({
 });
 
 // packages/cli/src/tui/p2p/secret-vault.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes23, scryptSync as scryptSync2, createHash as createHash35 } from "node:crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes23, scryptSync as scryptSync2, createHash as createHash36 } from "node:crypto";
 import { readFileSync as readFileSync99, writeFileSync as writeFileSync62, existsSync as existsSync120, mkdirSync as mkdirSync74 } from "node:fs";
 import { dirname as dirname39 } from "node:path";
 var PLACEHOLDER_PREFIX, PLACEHOLDER_SUFFIX, CIPHER_ALGO, SALT_LEN, IV_LEN, KEY_LEN, SecretVault;
@@ -624009,7 +624418,7 @@ var init_secret_vault = __esm({
       /** Generate a deterministic fingerprint of vault contents (for sync verification) */
       fingerprint() {
         const names = Array.from(this.secrets.keys()).sort();
-        const hash = createHash35("sha256");
+        const hash = createHash36("sha256");
         for (const name10 of names) {
           hash.update(name10 + ":");
           hash.update(this.secrets.get(name10).value);
@@ -624024,7 +624433,7 @@ var init_secret_vault = __esm({
 // packages/cli/src/tui/p2p/peer-mesh.ts
 import { EventEmitter as EventEmitter9 } from "node:events";
 import { createServer as createServer6 } from "node:http";
-import { randomBytes as randomBytes24, createHash as createHash36, generateKeyPairSync } from "node:crypto";
+import { randomBytes as randomBytes24, createHash as createHash37, generateKeyPairSync } from "node:crypto";
 var PING_INTERVAL_MS, PEER_TIMEOUT_MS, GOSSIP_INTERVAL_MS, MAX_PEERS, PeerMesh;
 var init_peer_mesh = __esm({
   "packages/cli/src/tui/p2p/peer-mesh.ts"() {
@@ -624041,7 +624450,7 @@ var init_peer_mesh = __esm({
         const { publicKey: publicKey2, privateKey } = generateKeyPairSync("ed25519");
         this.publicKey = publicKey2.export({ type: "spki", format: "der" });
         this.privateKey = privateKey.export({ type: "pkcs8", format: "der" });
-        this.peerId = createHash36("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
+        this.peerId = createHash37("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
         this.capabilities = options2.capabilities;
         this.displayName = options2.displayName;
         this._authKey = options2.authKey ?? randomBytes24(24).toString("base64url");
@@ -625406,7 +625815,7 @@ __export(omnius_directory_exports, {
 import { appendFileSync as appendFileSync14, cpSync as cpSync2, existsSync as existsSync122, mkdirSync as mkdirSync76, readFileSync as readFileSync101, writeFileSync as writeFileSync64, readdirSync as readdirSync41, statSync as statSync47, unlinkSync as unlinkSync23, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync11, watch as fsWatch2 } from "node:fs";
 import { join as join136, relative as relative14, basename as basename26, dirname as dirname40, resolve as resolve58 } from "node:path";
 import { homedir as homedir42 } from "node:os";
-import { createHash as createHash38 } from "node:crypto";
+import { createHash as createHash39 } from "node:crypto";
 function isGitRoot(dir) {
   const gitPath = join136(dir, ".git");
   if (!existsSync122(gitPath)) return false;
@@ -625888,7 +626297,7 @@ function buildHandoffPrompt(repoRoot) {
   return lines.join("\n");
 }
 function computeDedupeHash(task, savedAt) {
-  return createHash38("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
+  return createHash39("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
 }
 function generateSessionId() {
   const timestamp = Date.now().toString(36);
@@ -650659,7 +651068,7 @@ __export(commands_exports, {
 });
 import * as nodeOs from "node:os";
 import { spawn as nodeSpawn2 } from "node:child_process";
-import { createHash as createHash39 } from "node:crypto";
+import { createHash as createHash40 } from "node:crypto";
 import {
   existsSync as existsSync142,
   readFileSync as readFileSync116,
@@ -663936,7 +664345,7 @@ async function collectSponsorMediaStream(args) {
     };
   }
   if (artifact.sha256) {
-    const sha = createHash39("sha256").update(bytes).digest("hex");
+    const sha = createHash40("sha256").update(bytes).digest("hex");
     if (sha !== artifact.sha256)
       return { ok: false, error: `Artifact hash mismatch for ${artifactId}` };
   }
@@ -672344,8 +672753,9 @@ function createEditHistoryLogger(repoRoot, sessionId) {
     mkdirSync90(historyDir, { recursive: true });
   } catch {
   }
-  function logToolCall(toolName, toolArgs, success) {
+  function logToolCall(toolName, toolArgs, success, resultContent = "") {
     if (!EDIT_TOOLS.has(toolName)) return;
+    if (success && /^\[NO-OP\b/i.test(resultContent.trim())) return;
     const entry = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       tool: toolName,
@@ -679061,7 +679471,7 @@ import {
   unlinkSync as unlinkSync33
 } from "node:fs";
 import { join as join166 } from "node:path";
-import { createHash as createHash40 } from "node:crypto";
+import { createHash as createHash41 } from "node:crypto";
 function safeFilePart(value2) {
   return value2.replace(/[^A-Za-z0-9_.-]+/g, "_").slice(0, 80) || "telegram";
 }
@@ -679069,7 +679479,7 @@ function daydreamRoot(repoRoot) {
   return join166(repoRoot, ".omnius", "telegram-daydreams");
 }
 function sessionDir(repoRoot, sessionKey) {
-  const hash = createHash40("sha1").update(sessionKey).digest("hex").slice(0, 20);
+  const hash = createHash41("sha1").update(sessionKey).digest("hex").slice(0, 20);
   return join166(daydreamRoot(repoRoot), safeFilePart(hash));
 }
 function compactLine2(value2, max = 220) {
@@ -679180,7 +679590,7 @@ function buildReplyOpportunities(input, openQuestions) {
   return opportunities;
 }
 function daydreamOpportunityId(input, trigger) {
-  return createHash40("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
+  return createHash41("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
 }
 function clamp0114(value2) {
   if (!Number.isFinite(value2)) return 0;
@@ -679585,7 +679995,7 @@ function buildTelegramChannelDaydream(input, corpus, extraction, extractionCommi
   const seed = `${input.sessionKey}:${input.generatedAtMs}:${input.history.length}`;
   return {
     version: 3,
-    id: createHash40("sha1").update(seed).digest("hex").slice(0, 16),
+    id: createHash41("sha1").update(seed).digest("hex").slice(0, 16),
     sessionKey: input.sessionKey,
     chatId: input.chatId,
     chatTitle: input.chatTitle,
@@ -679898,12 +680308,12 @@ var init_telegram_channel_dmn = __esm({
 });
 
 // packages/cli/src/tui/telegram-reflection-corpus.ts
-import { createHash as createHash41 } from "node:crypto";
+import { createHash as createHash42 } from "node:crypto";
 function telegramReflectionMemoryDbPaths(repoRoot) {
   return omniusMemoryDbPaths(repoRoot);
 }
 function stableHash2(value2, length4 = 16) {
-  return createHash41("sha1").update(value2).digest("hex").slice(0, length4);
+  return createHash42("sha1").update(value2).digest("hex").slice(0, length4);
 }
 function clean3(value2) {
   return String(value2 ?? "").replace(/\s+/g, " ").trim();
@@ -680718,7 +681128,7 @@ var init_telegram_reflection_extraction = __esm({
 });
 
 // packages/cli/src/tui/telegram-social-state-types.ts
-import { createHash as createHash42 } from "node:crypto";
+import { createHash as createHash43 } from "node:crypto";
 function telegramSocialActorKey(actor) {
   if (!actor) return "unknown";
   if (typeof actor.userId === "number") return `user:${actor.userId}`;
@@ -680751,7 +681161,7 @@ function appendUnique(items, value2, max) {
   return next.slice(-max);
 }
 function hashTelegramSocialId(parts) {
-  return createHash42("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
+  return createHash43("sha1").update(parts.map((part) => String(part ?? "")).join(":")).digest("hex").slice(0, 16);
 }
 function cleanUsername(value2) {
   if (typeof value2 !== "string") return void 0;
@@ -681817,7 +682227,7 @@ import {
 } from "node:path";
 import { homedir as homedir55 } from "node:os";
 import { writeFile as writeFileAsync } from "node:fs/promises";
-import { createHash as createHash43, randomBytes as randomBytes27, randomInt } from "node:crypto";
+import { createHash as createHash44, randomBytes as randomBytes27, randomInt } from "node:crypto";
 function formatModelBytes(bytes) {
   if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
   const units = ["B", "KB", "MB", "GB", "TB"];
@@ -683062,7 +683472,7 @@ function buildTelegramRuntimeContext(now2 = /* @__PURE__ */ new Date(), repoRoot
   return buildConversationRuntimeContext(now2, repoRoot);
 }
 function telegramSessionIdFromKey(sessionKey) {
-  return `telegram-${createHash43("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
+  return `telegram-${createHash44("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
 }
 function normalizeTelegramSubAgentLimit(value2) {
   const parsed = typeof value2 === "number" ? value2 : typeof value2 === "string" && value2.trim() ? Number(value2.trim()) : TELEGRAM_SUB_AGENT_DEFAULT_LIMIT;
@@ -685230,7 +685640,7 @@ Telegram link integrity contract:
         return !!this.adminAuthChallenge && this.adminAuthChallenge.expiresAtMs > Date.now();
       }
       hashAdminAuthCode(code8) {
-        return createHash43("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
+        return createHash44("sha256").update(`omnius-telegram-admin:${code8.trim()}`).digest("hex");
       }
       viewIdForMessage(msg) {
         return `telegram-${this.sessionKeyForMessage(msg).replace(/[^A-Za-z0-9_-]/g, "-")}`;
@@ -687294,11 +687704,11 @@ ${mediaContext}` : ""
         return payload;
       }
       telegramConversationPath(sessionKey) {
-        const safe = createHash43("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash44("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join168(this.telegramConversationDir, `${safe}.json`);
       }
       telegramConversationLedgerPath(sessionKey) {
-        const safe = createHash43("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash44("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join168(this.telegramConversationDir, `${safe}.events.jsonl`);
       }
       telegramDb() {
@@ -687531,7 +687941,7 @@ ${mediaContext}` : ""
           relationships: Array.isArray(raw.relationships) ? raw.relationships.slice(0, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT).map((fact) => this.normalizeTelegramAssociativeFact(fact)) : [],
           actions: Array.isArray(raw.actions) ? raw.actions.slice(-TELEGRAM_ASSOCIATIVE_ACTION_LIMIT).map((action) => ({
             id: String(
-              action.id || createHash43("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)
+              action.id || createHash44("sha1").update(JSON.stringify(action)).digest("hex").slice(0, 12)
             ),
             ts: typeof action.ts === "number" ? action.ts : Date.now(),
             role: action.role === "assistant" ? "assistant" : "user",
@@ -687550,7 +687960,7 @@ ${mediaContext}` : ""
         const now2 = Date.now();
         return {
           id: String(
-            raw.id || createHash43("sha1").update(text2 || String(now2)).digest("hex").slice(0, 12)
+            raw.id || createHash44("sha1").update(text2 || String(now2)).digest("hex").slice(0, 12)
           ),
           text: text2,
           tags: Array.isArray(raw.tags) ? raw.tags.map(String).slice(0, 16) : [],
@@ -688007,7 +688417,7 @@ ${mediaContext}` : ""
       telegramHistoryBackfillMessageId(sessionKey, entry, index) {
         if (typeof entry.messageId === "number" && Number.isFinite(entry.messageId))
           return entry.messageId;
-        const digest3 = createHash43("sha1").update(
+        const digest3 = createHash44("sha1").update(
           `${sessionKey}:${index}:${entry.role}:${entry.ts ?? ""}:${entry.text}`
         ).digest("hex").slice(0, 8);
         return -Number.parseInt(digest3, 16);
@@ -689197,7 +689607,7 @@ ${mediaContext}` : ""
         const now2 = entry.ts ?? Date.now();
         memory.updatedAt = now2;
         const speaker = telegramHistorySpeaker(entry);
-        const actionId = createHash43("sha1").update(
+        const actionId = createHash44("sha1").update(
           `${sessionKey}:${entry.role}:${entry.messageId ?? ""}:${now2}:${entry.text}`
         ).digest("hex").slice(0, 16);
         if (!memory.actions.some((action) => action.id === actionId)) {
@@ -689360,7 +689770,7 @@ ${mediaContext}` : ""
         let fact = facts.find((item) => item.text.toLowerCase() === key);
         if (!fact) {
           fact = {
-            id: createHash43("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
+            id: createHash44("sha1").update(`${entry.chatId ?? ""}:${key}`).digest("hex").slice(0, 12),
             text: clean5,
             tags: telegramMemoryTags(clean5, entry.mediaSummary),
             speakers: [],
@@ -689445,7 +689855,7 @@ ${mediaContext}` : ""
           const titleTags = tags.slice(0, 4);
           const title = titleTags.length > 0 ? `${speaker} / ${titleTags.join(" ")}` : `${speaker} / conversation`;
           const card = {
-            id: createHash43("sha1").update(`${sessionKey}:${now2}:${speaker}:${text2}`).digest("hex").slice(0, 12),
+            id: createHash44("sha1").update(`${sessionKey}:${now2}:${speaker}:${text2}`).digest("hex").slice(0, 12),
             title,
             notes: [],
             tags: [],
@@ -692392,7 +692802,7 @@ ${list}` : "No shared group target is currently known for this sender. Ask in th
       }
       telegramRunnerStateDir(sessionKey) {
         if (!this.repoRoot) return void 0;
-        const safe = createHash43("sha1").update(sessionKey).digest("hex").slice(0, 20);
+        const safe = createHash44("sha1").update(sessionKey).digest("hex").slice(0, 20);
         return join168(this.repoRoot, ".omnius", "telegram-runner-state", safe);
       }
       buildTelegramAdminOverviewContext(currentSessionKey) {
@@ -703077,14 +703487,14 @@ var init_access_policy = __esm({
 });
 
 // packages/cli/src/api/project-preferences.ts
-import { createHash as createHash44 } from "node:crypto";
+import { createHash as createHash45 } from "node:crypto";
 import { existsSync as existsSync158, mkdirSync as mkdirSync98, readFileSync as readFileSync131, renameSync as renameSync15, writeFileSync as writeFileSync85, unlinkSync as unlinkSync36 } from "node:fs";
 import { homedir as homedir57 } from "node:os";
 import { join as join170, resolve as resolve70 } from "node:path";
 import { randomUUID as randomUUID20 } from "node:crypto";
 function projectKey(root) {
   const canonical = resolve70(root);
-  return createHash44("sha256").update(canonical).digest("hex").slice(0, 16);
+  return createHash45("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 function projectDir(root) {
   return join170(PROJECTS_DIR, projectKey(root));
@@ -703378,7 +703788,7 @@ var init_disk_task_output = __esm({
 });
 
 // packages/cli/src/api/http.ts
-import { createHash as createHash45 } from "node:crypto";
+import { createHash as createHash46 } from "node:crypto";
 function problemDetails(opts) {
   const p2 = {
     type: opts.type ?? "about:blank",
@@ -703441,7 +703851,7 @@ function paginated(items, page2, total) {
 }
 function computeEtag(payload) {
   const json = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const hash = createHash45("sha1").update(json).digest("hex").slice(0, 16);
+  const hash = createHash46("sha1").update(json).digest("hex").slice(0, 16);
   return `W/"${hash}"`;
 }
 function checkNotModified(req3, res, etag) {
@@ -722108,7 +722518,7 @@ import {
   closeSync as closeSync6
 } from "node:fs";
 import { randomBytes as randomBytes29, randomUUID as randomUUID21, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
-import { createHash as createHash46 } from "node:crypto";
+import { createHash as createHash47 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
   const dir = join182(baseDir, ".omnius");
   return {
@@ -730376,7 +730786,7 @@ function listScheduledTasks() {
                 );
                 const enabled2 = typeof t2?.enabled === "boolean" ? t2.enabled : true;
                 const realId = typeof t2?.id === "string" && t2.id ? t2.id : null;
-                const fallbackId = createHash46("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
+                const fallbackId = createHash47("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
                 const uid = realId || fallbackId;
                 const key = `${uid}`;
                 if (seen.has(key)) return;
@@ -730514,8 +730924,8 @@ function deleteScheduledById(id2) {
     if (typeof entry?.id === "string" && entry.id && !candidates.includes(entry.id))
       candidates.push(entry.id);
     try {
-      const { createHash: createHash47 } = require4("node:crypto");
-      const fallback = createHash47("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
+      const { createHash: createHash48 } = require4("node:crypto");
+      const fallback = createHash48("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
       if (!candidates.includes(fallback)) candidates.push(fallback);
     } catch {
     }
@@ -735713,6 +736123,35 @@ ${entry.fullContent}`
     statusBar.refreshDynamicBlocks();
     return true;
   };
+  const EDIT_TOOL_NAMES = /* @__PURE__ */ new Set([
+    "file_write",
+    "file_edit",
+    "file_patch",
+    "batch_edit"
+  ]);
+  const extractEditToolPaths = (toolName, args) => {
+    if (!EDIT_TOOL_NAMES.has(toolName)) return [];
+    if (toolName === "batch_edit" && Array.isArray(args.edits)) {
+      return [
+        ...new Set(
+          args.edits.map(
+            (edit) => edit && typeof edit === "object" ? edit.path : void 0
+          ).filter((path12) => typeof path12 === "string" && path12.length > 0)
+        )
+      ];
+    }
+    return typeof args.path === "string" && args.path.length > 0 ? [args.path] : [];
+  };
+  const recordEditToolPaths = (toolName, args) => {
+    for (const filePath of extractEditToolPaths(toolName, args)) {
+      filesTouched.add(filePath);
+      sessionMetrics?.recordFileModified(filePath);
+      if (isNeovimActive()) {
+        notifyNeovimFileChange(filePath).catch(() => {
+        });
+      }
+    }
+  };
   runner.onEvent((event) => {
     emotionEngine?.appraise(event);
     switch (event.type) {
@@ -735739,19 +736178,6 @@ ${entry.fullContent}`
             });
           }
         }
-        if (event.toolArgs?.path && typeof event.toolArgs.path === "string") {
-          const name10 = event.toolName ?? "";
-          if (name10 === "file_write" || name10 === "file_edit" || name10 === "file_patch" || name10 === "batch_edit") {
-            filesTouched.add(event.toolArgs.path);
-            sessionMetrics?.recordFileModified(event.toolArgs.path);
-            if (isNeovimActive()) {
-              notifyNeovimFileChange(event.toolArgs.path).catch(
-                () => {
-                }
-              );
-            }
-          }
-        }
         getActivityFeed().push({
           ts: Date.now(),
           source: "main",
@@ -735841,10 +736267,15 @@ ${entry.fullContent}`
           );
         }
         if (lastToolCall) {
+          const editNoop = (event.success ?? false) && /^\[NO-OP\b/i.test(rawContent2.trim());
+          if ((event.success ?? false) && !editNoop) {
+            recordEditToolPaths(lastToolCall.name, lastToolCall.args);
+          }
           editHistory.logToolCall(
             lastToolCall.name,
             lastToolCall.args,
-            event.success ?? false
+            event.success ?? false,
+            rawContent2
           );
           lastToolCall = null;
         }
@@ -740418,10 +740849,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         sharedTranscriber: null
       };
       const engine = getListenEngine();
-      const callConsensusRequired = (() => {
-        const env2 = String(process.env["OMNIUS_ASR_CONSENSUS"] ?? "").trim().toLowerCase();
-        return !(env2 === "0" || env2 === "off" || env2 === "false");
-      })();
+      const callConsensusRequired = asrConsensusEnabled();
       const recentCallFinals = [];
       const normalizeCallTranscript = (value2) => value2.toLowerCase().replace(/[^\p{L}\p{N}\s']/gu, " ").replace(/\s+/g, " ").trim();
       const isLikelyCallAsrHallucination = (normalized) => /^(thanks|thank you) for watching(?: this video)?$/.test(normalized) || /^thanks for watching and/.test(normalized) || /\bdon't forget to (like|subscribe)\b/.test(normalized);
@@ -742447,13 +742875,13 @@ ${taskInput}`;
       writeContent(() => renderError(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash47 } = await import("node:crypto");
+          const { createHash: createHash48 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash47("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash48("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,