omnius 1.0.366 → 1.0.368

package/dist/index.js

@@ -558608,6 +558608,19 @@ function isFailedVerificationEvidence(entry) {
   const text2 = `${entry.toolName ?? ""} ${entry.summary}`.toLowerCase();
   return /\b(test|tests|verify|verification|build|compile|tsc|vitest|jest|pytest|go test|cargo test)\b/.test(text2);
 }
+function verificationFamily(entry) {
+  const text2 = `${entry.toolName ?? ""} ${entry.summary}`.toLowerCase();
+  if (/\b(vitest|jest|pytest|go test|cargo test|npm test|pnpm test|yarn test|node\s+tests?|test|tests|spec)\b/.test(text2)) {
+    return "test";
+  }
+  if (/\b(typecheck|tsc)\b/.test(text2))
+    return "typecheck";
+  if (/\b(build|built|compile|compiled)\b/.test(text2))
+    return "build";
+  if (/\b(verify|verified|verification)\b/.test(text2))
+    return "verify";
+  return null;
+}
 function isStaleEditEvidence(entry) {
   if (entry.success !== false)
     return false;
@@ -558618,13 +558631,24 @@ function finalizeCompletionLedgerTruth(ledger) {
   let unresolved = [...ledger.unresolved];
   let lastMutation = -1;
   let lastVerification = -1;
+  const lastSuccessfulVerificationByFamily = /* @__PURE__ */ new Map();
   ledger.evidence.forEach((entry, index) => {
     if (isMutationEvidence(entry))
       lastMutation = index;
-    if (isSuccessfulVerificationEvidence(entry))
+    if (isSuccessfulVerificationEvidence(entry)) {
       lastVerification = index;
+      const family = verificationFamily(entry);
+      if (family)
+        lastSuccessfulVerificationByFamily.set(family, index);
+    }
+  });
+  ledger.evidence.forEach((entry, index) => {
     if (isFailedVerificationEvidence(entry)) {
-      unresolved = appendUnresolved(unresolved, `Verification failed or did not prove success: ${entry.summary}`, entry.id);
+      const family = verificationFamily(entry);
+      const resolvedByLaterSuccess = family !== null && (lastSuccessfulVerificationByFamily.get(family) ?? -1) > index;
+      if (!resolvedByLaterSuccess) {
+        unresolved = appendUnresolved(unresolved, `Verification failed or did not prove success: ${entry.summary}`, entry.id);
+      }
     }
     if (isStaleEditEvidence(entry)) {
       unresolved = appendUnresolved(unresolved, `Stale edit failure remains unresolved: ${entry.summary}`, entry.id);
@@ -567594,6 +567618,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 +567641,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 +567700,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 +567811,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 +567859,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,
@@ -568759,6 +568840,16 @@ function classifyShellIntent(cmd) {
   } else {
     verbToken = first2;
   }
+  if (isRunner && verbToken === "run" && tokens.length >= 3) {
+    const scriptToken = tokens[2].toLowerCase().replace(/^["']|["']$/g, "");
+    const scriptRow = VERB_TABLE[scriptToken];
+    if (scriptRow) {
+      return { klass: scriptRow.klass, verb: scriptRow.canonical, tool: first2 };
+    }
+    if (/\b(test|spec|vitest|jest|pytest|check|verify|lint|typecheck)\b/i.test(scriptToken)) {
+      return { klass: "verify", verb: "test", tool: first2 };
+    }
+  }
   const row = VERB_TABLE[verbToken];
   if (!row)
     return { klass: "other", verb: verbToken, tool: first2 };
@@ -568774,7 +568865,7 @@ function verifyShellOutcome(command, ctx3, result) {
   if (!result.success) {
     return { trustworthy: true, intentBucket: baseBucket, outcomeClass: "broken" };
   }
-  if (intent.klass === "read") {
+  if (intent.klass === "read" || intent.klass === "verify") {
     return { trustworthy: true, intentBucket: baseBucket, outcomeClass: "verified" };
   }
   const mtimeCheck = checkMutateMtimeDelta(intent, cwd4, ctx3, result);
@@ -569112,13 +569203,17 @@ var init_postActionVerifier = __esm({
       build: { canonical: "build", klass: "mutate" },
       compile: { canonical: "build", klass: "mutate" },
       make: { canonical: "build", klass: "mutate" },
-      // ── test family (mutate — typically writes coverage/snapshots) ────────────
-      test: { canonical: "test", klass: "mutate" },
-      t: { canonical: "test", klass: "mutate" },
-      spec: { canonical: "test", klass: "mutate" },
-      vitest: { canonical: "test", klass: "mutate" },
-      jest: { canonical: "test", klass: "mutate" },
-      pytest: { canonical: "test", klass: "mutate" },
+      // ── verification family (read-only by contract for the verifier) ──────────
+      test: { canonical: "test", klass: "verify" },
+      t: { canonical: "test", klass: "verify" },
+      spec: { canonical: "test", klass: "verify" },
+      vitest: { canonical: "test", klass: "verify" },
+      jest: { canonical: "test", klass: "verify" },
+      pytest: { canonical: "test", klass: "verify" },
+      check: { canonical: "check", klass: "verify" },
+      verify: { canonical: "verify", klass: "verify" },
+      lint: { canonical: "lint", klass: "verify" },
+      typecheck: { canonical: "typecheck", klass: "verify" },
       // ── publish / scaffold / generate (mutate) ────────────────────────────────
       publish: { canonical: "publish", klass: "mutate" },
       init: { canonical: "init", klass: "mutate" },
@@ -571855,6 +571950,37 @@ Pick the SMALLEST concrete deliverable from the spec — typically the project e
           return false;
         return true;
       }
+      _toolEvidencePreview(result, displayOutput, max = 500) {
+        const modelVisible = result.llmContent ?? result.output ?? displayOutput ?? "";
+        const failurePrefix = result.success === false && result.error ? `Error: ${result.error}` : "";
+        const combined = failurePrefix && modelVisible && !String(modelVisible).startsWith(failurePrefix) ? `${failurePrefix}
+${modelVisible}` : modelVisible || result.error || displayOutput || "";
+        return String(combined).slice(0, max);
+      }
+      _recordCompletionToolEvidenceFromResult(input) {
+        if (!this._completionLedger || input.toolName === "task_complete")
+          return;
+        const realFileMutation = input.realFileMutation ?? this._isRealProjectMutation(input.toolName, input.result);
+        const realMutationPaths = input.realMutationPaths ?? (realFileMutation ? this._extractToolTargetPaths(input.toolName, input.args, input.result) : []);
+        this._completionLedger = recordToolEvidence(this._completionLedger, {
+          name: input.toolName,
+          success: input.result.success,
+          outputPreview: (input.outputPreview ?? this._toolEvidencePreview(input.result)).toString().slice(0, 500),
+          argsKey: input.argsKey.slice(0, 300)
+        });
+        if (realFileMutation && realMutationPaths.length > 0) {
+          for (const filePath of realMutationPaths) {
+            this._completionLedger = recordCompletionEvidence(this._completionLedger, {
+              kind: "file_change",
+              toolName: input.toolName,
+              success: true,
+              summary: `file change: ${filePath}`,
+              rawRef: `file://${filePath}`
+            });
+          }
+        }
+        this._saveCompletionLedgerSafe();
+      }
       _isAtomicBatchEditAbort(toolName, result) {
         if (toolName !== "batch_edit" || !result || result.success !== false) {
           return false;
@@ -572548,10 +572674,20 @@ ${_checks}`
         const maxCycles = parseInt(process.env["OMNIUS_BACKWARD_PASS_MAX_CYCLES"] || "2", 10) || 2;
         if (this._backwardPassCyclesUsed >= maxCycles) {
           const lastCritique2 = this._lastBackwardPassCritique;
-          const concern = lastCritique2?.rationale?.trim() || this._lastBackwardPassVerdict || "unspecified";
+          const evidenceAfterCritique = lastCritique2 ? toolCallLog.slice(lastCritique2.toolLogLength) : [];
+          const freshVerification = evidenceAfterCritique.filter((entry) => {
+            if (entry.success !== true)
+              return false;
+            const text2 = `${entry.name} ${entry.argsKey} ${entry.outputPreview ?? ""}`.toLowerCase();
+            return /\b(test|tests|vitest|jest|pytest|go test|cargo test|npm test|pnpm test|yarn test|typecheck|tsc|build|verify|verification)\b/.test(text2) && /\b(pass|passed|success|exit:?\s*0|ok|0 failures|0 failed)\b/.test(text2);
+          }).slice(-3);
+          const concern = freshVerification.length > 0 ? [
+            "Prior reviewer concern may be stale; fresh verification evidence was recorded after that critique.",
+            ...freshVerification.map((entry) => `${entry.name}: ${(entry.outputPreview ?? entry.argsKey).slice(0, 220)}`)
+          ].join(" ") : lastCritique2?.rationale?.trim() || this._lastBackwardPassVerdict || "unspecified";
           this._completionCaveat = [
             `[COMPLETION CAVEAT] Backward-pass review did not fully approve after ${this._backwardPassCyclesUsed}/${maxCycles} cycle(s).`,
-            `Unresolved reviewer concern: ${concern.slice(0, 600)}`,
+            `${freshVerification.length > 0 ? "Reviewer reconciliation note" : "Unresolved reviewer concern"}: ${concern.slice(0, 600)}`,
             "The work was completed with deliverables present; treat the above as follow-up rather than a blocker."
           ].join("\n");
           this.emit({
@@ -576216,6 +576352,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 +579011,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: {
@@ -580099,7 +580240,7 @@ ${bookkeepingGuidance}` : bookkeepingGuidance;
                 currentLogEntry.success = result.success;
                 currentLogEntry.mutated = realFileMutation;
                 currentLogEntry.mutatedFiles = realMutationPaths;
-                currentLogEntry.outputPreview = (result.success ? result.llmContent ?? result.output ?? output : result.error ?? result.output ?? output).toString().slice(0, 500);
+                currentLogEntry.outputPreview = this._toolEvidencePreview(result, output);
               }
               this._toolEvents.push({
                 name: tc.name,
@@ -580440,26 +580581,15 @@ Then use file_read on individual FILES inside it.`);
                   lastFailureHandoffTurn = turn;
                 }
               }
-              if (this._completionLedger && tc.name !== "task_complete") {
-                this._completionLedger = recordToolEvidence(this._completionLedger, {
-                  name: tc.name,
-                  success: result.success,
-                  outputPreview: (result.success ? result.llmContent ?? result.output ?? output : result.error ?? result.output ?? output).toString().slice(0, 500),
-                  argsKey: tc.arguments ? JSON.stringify(tc.arguments).slice(0, 300) : ""
-                });
-                if (realFileMutation && realMutationPaths.length > 0) {
-                  for (const filePath2 of realMutationPaths) {
-                    this._completionLedger = recordCompletionEvidence(this._completionLedger, {
-                      kind: "file_change",
-                      toolName: tc.name,
-                      success: true,
-                      summary: `file change: ${filePath2}`,
-                      rawRef: `file://${filePath2}`
-                    });
-                  }
-                }
-                this._saveCompletionLedgerSafe();
-              }
+              this._recordCompletionToolEvidenceFromResult({
+                toolName: tc.name,
+                argsKey: tc.arguments ? JSON.stringify(tc.arguments) : "",
+                args: tc.arguments,
+                result,
+                outputPreview: this._toolEvidencePreview(result, output),
+                realFileMutation,
+                realMutationPaths
+              });
               this._onTypedEvent?.({
                 type: "tool_call_finished",
                 runId: this._sessionId ?? "unknown",
@@ -581555,6 +581685,15 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                 } else {
                   output = modelContent2;
                 }
+                const bfRealFileMutation = this._isRealProjectMutation(tc.name, result);
+                const bfRealMutationPaths = bfRealFileMutation ? this._extractToolTargetPaths(tc.name, tc.arguments, result) : [];
+                const bfLogEntry = toolCallLog[toolCallLog.length - 1];
+                if (bfLogEntry) {
+                  bfLogEntry.success = result.success;
+                  bfLogEntry.mutated = bfRealFileMutation;
+                  bfLogEntry.mutatedFiles = bfRealMutationPaths;
+                  bfLogEntry.outputPreview = this._toolEvidencePreview(result, output);
+                }
                 this.emit({
                   type: "tool_result",
                   toolName: tc.name,
@@ -581564,14 +581703,15 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 this._trackDecomp2(tc, result, turn);
-                if (this._completionLedger && tc.name !== "task_complete") {
-                  this._completionLedger = recordToolEvidence(this._completionLedger, {
-                    name: tc.name,
-                    success: result.success,
-                    outputPreview: output.slice(0, 500),
-                    argsKey: bfArgsKey.slice(0, 300)
-                  });
-                }
+                this._recordCompletionToolEvidenceFromResult({
+                  toolName: tc.name,
+                  argsKey: bfArgsKey,
+                  args: tc.arguments,
+                  result,
+                  outputPreview: this._toolEvidencePreview(result, output),
+                  realFileMutation: bfRealFileMutation,
+                  realMutationPaths: bfRealMutationPaths
+                });
                 const enoentTools2 = /* @__PURE__ */ new Set([
                   "file_read",
                   "list_directory",
@@ -584050,6 +584190,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 +584236,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 +584266,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 +584274,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.368",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.366",
+      "version": "1.0.368",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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