omnius 1.0.366 → 1.0.367

package/dist/index.js

@@ -567594,6 +567594,9 @@ function adversarySystemPrompt() {
     "  • started ≠ running — a PID or a log line is not a liveness probe.",
     "  • exit code 0 / 'build complete' ≠ success — the specific artifact must exist.",
     "  • an edit ≠ a fix — the failing command must be re-run and pass.",
+    "  • file_write/file_read tool outcomes ARE first-class evidence for narrow file existence/content claims.",
+    "    Do not demand shell/cat proof when a successful file_write is followed by file_read evidence for the same path.",
+    "  • If a shell integrity check is truly needed, demand a newline-safe command such as: printf '\n---sha256---\n'; sha256sum <path>. Do not use brittle cat <path> && sha256sum <path> as the default.",
     "  • simulation / mock / placeholder ≠ real.",
     "  • partial progress ≠ done.",
     "Mixed results are the norm: do NOT let one success excuse an unproven completion claim.",
@@ -567614,7 +567617,11 @@ function adversarySystemPrompt() {
   ].join("\n");
 }
 function buildObservationPrompt(obs, recentLedger) {
-  const outcomes = obs.recentToolOutcomes.slice(-8).map((o2) => `  - ${o2.tool}: ${o2.succeeded ? "OK" : "FAIL"} — ${o2.preview.slice(0, 120)}`).join("\n");
+  const outcomes = obs.recentToolOutcomes.slice(-8).map((o2) => {
+    const target = o2.path ? ` path=${o2.path}` : "";
+    const evidence = o2.evidence ? ` | evidence: ${o2.evidence.slice(0, 220)}` : "";
+    return `  - ${o2.tool}: ${o2.succeeded ? "OK" : "FAIL"}${target} — ${o2.preview.slice(0, 160)}${evidence}`;
+  }).join("\n");
   const priorDoubts = recentLedger.slice(-3).filter((e2) => e2.verdict !== "ok").map((e2) => `  - turn ${e2.turn}: ${e2.verdict} — demanded: ${e2.demand}`).join("\n");
   if (obs.loopSignal) {
     const ls2 = obs.loopSignal;
@@ -567669,6 +567676,47 @@ ${priorDoubts}` : "",
     "Audit this. Return ONLY the JSON object."
   ].join("\n");
 }
+function deterministicFileProofPaths(obs) {
+  const writes = /* @__PURE__ */ new Set();
+  const reads = /* @__PURE__ */ new Set();
+  for (const outcome of obs.recentToolOutcomes) {
+    if (!outcome.succeeded || !outcome.path)
+      continue;
+    if (/^(file_write|file_edit|file_patch|batch_edit)$/.test(outcome.tool)) {
+      writes.add(outcome.path);
+    }
+    if (outcome.tool === "file_read")
+      reads.add(outcome.path);
+  }
+  const proven = /* @__PURE__ */ new Set();
+  for (const path12 of writes)
+    if (reads.has(path12))
+      proven.add(path12);
+  return proven;
+}
+function hasRecentNonFileFailure(obs) {
+  return obs.recentToolOutcomes.some((outcome) => !outcome.succeeded && !/^(file_write|file_edit|file_patch|batch_edit|file_read|task_complete)$/.test(outcome.tool));
+}
+function isNarrowFileCompletionClaim(text2) {
+  return /\b(file|path|created|wrote|written|exists|content|reads?back|verified by read|single line)\b/i.test(text2);
+}
+function critiqueContradictedByFileProof(obs, critique2) {
+  if (!obs.claimsCompletion)
+    return false;
+  if (hasRecentNonFileFailure(obs))
+    return false;
+  if (!isNarrowFileCompletionClaim(obs.assistantText))
+    return false;
+  if (deterministicFileProofPaths(obs).size === 0)
+    return false;
+  if (critique2.class === "ok")
+    return false;
+  const text2 = critique2.shortText + "\n" + critique2.details + "\n" + critique2.demand;
+  return /no tool output|tool output|file creation|file exists|file content|cat\b|sha256|hash|unverified|unproven|readback|read back/i.test(text2);
+}
+function hasDeterministicFileCompletionProof(obs) {
+  return obs.claimsCompletion && !hasRecentNonFileFailure(obs) && isNarrowFileCompletionClaim(obs.assistantText) && deterministicFileProofPaths(obs).size > 0;
+}
 function parseAdversaryCritique(raw) {
   if (!raw)
     return null;
@@ -567739,7 +567787,7 @@ var init_adversaryStream = __esm({
        */
       shouldAudit(obs) {
         if (obs.claimsCompletion)
-          return true;
+          return !hasDeterministicFileCompletionProof(obs);
         if (obs.loopSignal)
           return true;
         if (obs.failingApproach)
@@ -567787,6 +567835,15 @@ var init_adversaryStream = __esm({
           }
           if (!critique2)
             return null;
+          if (critiqueContradictedByFileProof(obs, critique2)) {
+            critique2 = {
+              class: "ok",
+              shortText: "file proof present",
+              confidence: 0.05,
+              details: "The recent file_write/file_read outcomes provide deterministic evidence for this narrow file existence/content claim.",
+              demand: ""
+            };
+          }
           this.ledger.push({
             ts: Date.now(),
             turn: obs.turn,
@@ -576216,6 +576273,9 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             backend: this._auxInferenceBackend(),
             persistPath,
             onCritique: (critique2, sourceTurn) => {
+              if (completed || this._completionIncompleteVerification || this.aborted) {
+                return;
+              }
               if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
                 this.pendingUserMessages.push(AdversaryStream.formatInjection(critique2));
               }
@@ -578872,7 +578932,9 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                     recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({
                       tool: o2.tool,
                       succeeded: o2.succeeded,
-                      preview: o2.preview
+                      preview: o2.preview,
+                      path: o2.path,
+                      evidence: o2.evidence
                     })),
                     claimsCompletion: false,
                     loopSignal: {
@@ -584050,6 +584112,39 @@ ${trimmedNew}`;
        *  Generates typed self-reflections on task failure and injects them
        *  into the next attempt's context for active learning. */
       _reflectionBuffer = null;
+      buildAdversaryToolOutcomeEvidence(toolName, toolArgs, content, succeeded) {
+        const pathValue = toolArgs?.["path"] ?? toolArgs?.["file"] ?? toolArgs?.["filePath"] ?? toolArgs?.["file_path"];
+        const path12 = typeof pathValue === "string" && pathValue.trim() ? pathValue.trim() : void 0;
+        const compact3 = content.replace(/\s+/g, " ").trim();
+        const snippet = compact3.slice(0, 160);
+        const digest3 = _createHash("sha256").update(content).digest("hex").slice(0, 16);
+        const lineCount = content.length > 0 ? content.split("\n").length : 0;
+        if (toolName === "file_read") {
+          const evidence = path12 ? `file_read confirmed path=${path12}; lines=${lineCount}; sha256=${digest3}` : `file_read confirmed content; lines=${lineCount}; sha256=${digest3}`;
+          return {
+            path: path12,
+            evidence,
+            preview: `${evidence}; content="${snippet}"`
+          };
+        }
+        if (/^(file_write|file_edit|file_patch|batch_edit)$/.test(toolName)) {
+          const evidence = path12 ? `${toolName} succeeded for path=${path12}; output_sha256=${digest3}` : `${toolName} succeeded; output_sha256=${digest3}`;
+          return {
+            path: path12,
+            evidence,
+            preview: `${evidence}; output="${snippet}"`
+          };
+        }
+        if (toolName === "shell") {
+          const command = typeof toolArgs?.["command"] === "string" ? String(toolArgs["command"]) : void 0;
+          return {
+            path: command,
+            evidence: succeeded ? `shell exited successfully; stdout_sha256=${digest3}` : `shell failed; output_sha256=${digest3}`,
+            preview: snippet || content.slice(0, 160)
+          };
+        }
+        return { preview: snippet || content.slice(0, 160) };
+      }
       /**
        * Adversary: post-turn meta-analysis.
        *
@@ -584063,29 +584158,10 @@ ${trimmedNew}`;
        */
       adversaryObserve(messages2, turn) {
         const recent = messages2.slice(-6);
-        if (this._adversaryStream) {
-          const lastAssistantMsg = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
-          const assistantText = typeof lastAssistantMsg?.content === "string" ? lastAssistantMsg.content.replace(/<think>[\s\S]*?<\/think>/g, "").trim() : "";
-          if (assistantText) {
-            this._adversaryStream.observe({
-              turn,
-              assistantText,
-              recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({
-                tool: o2.tool,
-                succeeded: o2.succeeded,
-                preview: o2.preview
-              })),
-              claimsCompletion: /task.?complete|all tests pass|\bdone\b|\bcomplete(d)?\b/i.test(assistantText)
-            });
-            void this._adversaryStream.tick().catch(() => {
-            });
-          }
-        }
         for (const msg of recent) {
           if (msg.role === "tool" && typeof msg.content === "string") {
             const isError2 = msg.content.startsWith("Error:") || /^(FAIL|ERR!|TypeError)/i.test(msg.content);
             const succeeded = !isError2;
-            const preview = msg.content.slice(0, 80);
             let toolName = "unknown";
             let toolArgs;
             if (msg.tool_call_id) {
@@ -584112,6 +584188,7 @@ ${trimmedNew}`;
               return o2.turn === turn && o2.tool === toolName && o2.fingerprint === fingerprint;
             });
             if (!alreadySeen) {
+              const outcomeEvidence = this.buildAdversaryToolOutcomeEvidence(toolName, toolArgs, msg.content, succeeded);
               this._adversaryToolOutcomes.push({
                 turn,
                 tool: toolName,
@@ -584119,13 +584196,34 @@ ${trimmedNew}`;
                 argsKey,
                 fingerprint,
                 succeeded,
-                preview
+                ...outcomeEvidence
               });
             }
           }
         }
         while (this._adversaryToolOutcomes.length > 20)
           this._adversaryToolOutcomes.shift();
+        if (this._adversaryStream && !this._completionIncompleteVerification) {
+          const lastAssistantMsg = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
+          const assistantText = typeof lastAssistantMsg?.content === "string" ? lastAssistantMsg.content.replace(/<think>[\s\S]*?<\/think>/g, "").trim() : "";
+          if (assistantText) {
+            const claimsCompletion = /task.?complete|all tests pass|\bdone\b|\bcomplete(d)?\b/i.test(assistantText);
+            this._adversaryStream.observe({
+              turn,
+              assistantText,
+              recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({
+                tool: o2.tool,
+                succeeded: o2.succeeded,
+                preview: o2.preview,
+                path: o2.path,
+                evidence: o2.evidence
+              })),
+              claimsCompletion
+            });
+            void this._adversaryStream.tick().catch(() => {
+            });
+          }
+        }
         for (const [key, val] of this._adversaryRecentFlags) {
           if (turn - val.lastTurn > _AgenticRunner.ADVERSARY_FLAG_TTL)
             this._adversaryRecentFlags.delete(key);

package/npm-shrinkwrap.json

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

package/package.json

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