omnius 1.0.119 → 1.0.120

package/dist/index.js

@@ -527033,15 +527033,17 @@ var init_personality = __esm({
 // packages/orchestrator/dist/critic.js
 function buildForceProgressBlockMessage(call, hits) {
   const argPreview = JSON.stringify(call.args ?? {}).slice(0, 200);
-  return `[FORCED PROGRESS BLOCK — you have called ${call.tool}(${argPreview}) ${hits} times with identical arguments and received the cached result each time. Consider whether additional calls are needed or if you can proceed with what you have.
+  return `[FORCED PROGRESS BLOCK — duplicate ${call.tool} call skipped; this is not a tool failure. You have called ${call.tool}(${argPreview}) ${hits} times with identical arguments. The runtime did not re-run the tool; it is returning the cached result below so you can proceed without retrying.
 
-To proceed, you can:
+Progress is REQUIRED before this tool will run again with the same arguments. To proceed, do one of these:
   • file_write or file_edit to make progress, OR
   • todo_write that advances the plan, OR
   • task_complete (if all phases are done), OR
-  • Call a different tool or use different arguments.
-
-The cached result of this exact call is in your conversation history.]`;
+  • Call a different tool or use different arguments.]`;
+}
+function buildCachedResultEnvelope(result) {
+  return `[CACHED RESULT — you already have this information from a prior successful call. Do NOT call this tool again with the same arguments.]
+${result}`;
 }
 function evaluate(inputs) {
   const { proposedCall, fingerprint, isReadLike, recentToolResults, dedupHitCount, observerRedundantBlock } = inputs;
@@ -527050,8 +527052,7 @@ function evaluate(inputs) {
     return {
       decision: "observer_block",
       reason: "Littleman observer flagged this fingerprint as redundant",
-      cachedResult: cached ? `[CACHED RESULT — you already have this information from a prior call. Do NOT call this tool again with the same arguments.]
-${cached.result}` : null
+      cachedResult: cached ? buildCachedResultEnvelope(cached.result) : null
     };
   }
   if (isReadLike) {
@@ -527064,11 +527065,12 @@ ${cached.result}` : null
           decision: "force_progress_block",
           reason: `${proposedCall.tool} fingerprint hit count ${hits} >= ${threshold}`,
           hitNumber: hits,
-          blockMessage: buildForceProgressBlockMessage(proposedCall, hits)
+          blockMessage: buildForceProgressBlockMessage(proposedCall, hits),
+          cachedResult: buildCachedResultEnvelope(cached.result),
+          compacted: cached.compacted
         };
       }
-      const cachedEnvelope = `[CACHED RESULT — you already have this information from a prior call. Do NOT call this tool again with the same arguments.]
-${cached.result}`;
+      const cachedEnvelope = buildCachedResultEnvelope(cached.result);
       return {
         decision: "serve_cached",
         reason: cached.compacted ? "post-compaction cache re-serve" : `duplicate call #${hits} (still under ${threshold}-hit gate)`,
@@ -543226,27 +543228,35 @@ ${latest.output || ""}`.trim();
         const dirsListed = [];
         const searches = [];
         const shells = [];
+        let compactedCount = 0;
         for (const [fingerprint, entry] of recentToolResults) {
+          const { toolName, args } = this._decodeToolFingerprint(fingerprint);
           if (entry.compacted)
-            continue;
-          const colonIdx = fingerprint.indexOf(":");
-          const toolName = colonIdx > 0 ? fingerprint.slice(0, colonIdx) : fingerprint;
+            compactedCount++;
           if (toolName === "file_read") {
-            const pathMatch = fingerprint.match(/path=([^,\s]+)/);
-            if (pathMatch?.[1])
-              filesRead.push(pathMatch[1]);
+            const path12 = args.get("path") ?? args.get("file");
+            if (path12) {
+              filesRead.push(this._formatKnowledgeTarget(this._formatFileReadKnowledgeTarget(path12, args), entry.compacted));
+            }
           } else if (toolName === "list_directory") {
-            const pathMatch = fingerprint.match(/path=([^,\s]+)/);
-            if (pathMatch?.[1])
-              dirsListed.push(pathMatch[1]);
+            const path12 = args.get("path") ?? ".";
+            dirsListed.push(this._formatKnowledgeTarget(path12, entry.compacted));
           } else if (toolName === "grep_search" || toolName === "find_files") {
-            searches.push(toolName);
+            const path12 = args.get("path") ?? ".";
+            const pattern = args.get("pattern") ?? args.get("query") ?? "";
+            const target = pattern ? `${toolName} ${path12} :: ${pattern}` : `${toolName} ${path12}`;
+            searches.push(this._formatKnowledgeTarget(target, entry.compacted));
           } else if (toolName === "shell" || toolName === "shell_async") {
-            const cmdMatch = fingerprint.match(/cmd=([^,\s]+)/);
-            shells.push(cmdMatch?.[1] ?? toolName);
+            const command = args.get("command") ?? args.get("cmd") ?? toolName;
+            shells.push(this._formatKnowledgeTarget(command, entry.compacted));
           }
         }
-        const sections = ["[KNOWLEDGE — you already have these results in context above. Do NOT re-call these tools for the same targets:]"];
+        const sections = [
+          "[KNOWLEDGE — cached tool results already known to the runtime. Do NOT re-call these tools with the same arguments:]"
+        ];
+        if (compactedCount > 0) {
+          sections.push(`Compacted cached entries still count as already-known results (${compactedCount}); an exact repeat will be served from cache or skipped, not produce new information.`);
+        }
         if (filesRead.length > 0) {
           const unique = [...new Set(filesRead)].slice(0, 30);
           sections.push(`Files already read (${unique.length}): ${unique.join(", ")}`);
@@ -543256,7 +543266,8 @@ ${latest.output || ""}`.trim();
           sections.push(`Directories already listed (${unique.length}): ${unique.join(", ")}`);
         }
         if (searches.length > 0) {
-          sections.push(`Searches already run: ${searches.length}`);
+          const unique = [...new Set(searches)].slice(0, 15);
+          sections.push(`Searches already run (${unique.length}): ${unique.join(", ")}`);
         }
         if (shells.length > 0) {
           const unique = [...new Set(shells)].slice(0, 15);
@@ -543494,6 +543505,68 @@ ${blob}
       _buildToolFingerprint(name10, args) {
         return `${name10}:${this._buildExactArgsKey(args)}`;
       }
+      _decodeToolFingerprint(fingerprint) {
+        const colonIdx = fingerprint.indexOf(":");
+        const toolName = colonIdx > 0 ? fingerprint.slice(0, colonIdx) : fingerprint;
+        const argsKey = colonIdx > 0 ? fingerprint.slice(colonIdx + 1) : "";
+        return { toolName, args: this._parseExactArgsKey(argsKey) };
+      }
+      _parseExactArgsKey(argsKey) {
+        const parsed = /* @__PURE__ */ new Map();
+        if (!argsKey)
+          return parsed;
+        const entries = [];
+        let current = "";
+        let escaped = false;
+        for (const ch of argsKey) {
+          if (escaped) {
+            current += ch;
+            escaped = false;
+          } else if (ch === "\\") {
+            escaped = true;
+          } else if (ch === ",") {
+            entries.push(current);
+            current = "";
+          } else {
+            current += ch;
+          }
+        }
+        if (escaped)
+          current += "\\";
+        entries.push(current);
+        for (const entry of entries) {
+          const eqIdx = entry.indexOf("=");
+          if (eqIdx <= 0)
+            continue;
+          parsed.set(entry.slice(0, eqIdx), entry.slice(eqIdx + 1));
+        }
+        return parsed;
+      }
+      _formatKnowledgeTarget(target, compacted) {
+        const clipped = target.length > 180 ? `${target.slice(0, 130)}...${target.slice(-40)}` : target;
+        return compacted ? `${clipped} (cached after compaction)` : clipped;
+      }
+      _formatFileReadKnowledgeTarget(path12, args) {
+        const offset = this._formatArgsKeyScalar(args.get("offset"));
+        const limit = this._formatArgsKeyScalar(args.get("limit"));
+        if (offset !== void 0 || limit !== void 0) {
+          return `${path12} (offset ${offset ?? "0"}, limit ${limit ?? "end"})`;
+        }
+        return path12;
+      }
+      _formatArgsKeyScalar(value2) {
+        if (value2 === void 0)
+          return void 0;
+        if (value2.startsWith("#number:"))
+          return value2.slice("#number:".length);
+        if (value2.startsWith("#boolean:"))
+          return value2.slice("#boolean:".length);
+        if (value2 === "#null")
+          return "null";
+        if (value2 === "#undefined")
+          return "undefined";
+        return value2;
+      }
       _isStatefulBrowserTool(name10) {
         return name10 === "playwright_browser" || name10 === "browser_action";
       }
@@ -546572,8 +546645,8 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                 this.emit({
                   type: "tool_result",
                   toolName: tc.name,
-                  success: false,
-                  content: criticDecision.blockMessage.slice(0, 120),
+                  success: true,
+                  content: `[SKIPPED DUPLICATE — exact ${tc.name} call not re-run; cached result returned.]`.slice(0, 120),
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
@@ -546581,7 +546654,19 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                   mode: "step_repetition",
                   rationale: `force_progress_block on ${tc.name} after ${criticDecision.hitNumber} identical calls`
                 });
-                return { tc, output: criticDecision.blockMessage };
+                const header = criticDecision.compacted ? `[RE-SERVED FROM CACHE — the original result was compacted from context. Here is the data again. Do not retry this exact call.]
+
+` : `[SKIPPED DUPLICATE — exact ${tc.name} call not re-run. The cached result below is from the prior successful call. Do not retry this exact call.]
+
+`;
+                const truncatedCache = criticDecision.cachedResult.length > 500 ? criticDecision.cachedResult.slice(0, 500) + `
+... [${criticDecision.cachedResult.length - 500} chars omitted — same as before]` : criticDecision.cachedResult;
+                return {
+                  tc,
+                  output: `${criticDecision.blockMessage}
+
+${header}${truncatedCache}`
+                };
               }
               if (criticDecision.decision === "serve_cached") {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);

package/npm-shrinkwrap.json

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

package/package.json

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