omnius 1.0.305 → 1.0.306

package/dist/index.js

@@ -23695,6 +23695,12 @@ function findCanonicalEntry(entries, valueHash, key) {
   }
   return null;
 }
+function getEntryArtifactId(entry) {
+  if (!entry || typeof entry !== "object")
+    return null;
+  const artifactId = entry["artifactId"];
+  return typeof artifactId === "string" && artifactId.length > 0 ? artifactId : null;
+}
 var _writeLocks, MemoryWriteTool;
 var init_memory_write = __esm({
   "packages/execution/dist/tools/memory-write.js"() {
@@ -23742,6 +23748,9 @@ var init_memory_write = __esm({
           }
           const omniusMemDir = resolve12(this.workingDir, ".omnius", "memory");
           const legacyMemDir = resolve12(this.workingDir, ".omnius", "memory");
+          let wroteMemory = false;
+          let storedArtifactId = null;
+          let existingArtifactId = null;
           for (const memoryDir of [.../* @__PURE__ */ new Set([omniusMemDir, legacyMemDir])]) {
             await mkdir3(memoryDir, { recursive: true });
             const topicFile = join22(memoryDir, `${topic}.json`);
@@ -23752,7 +23761,13 @@ var init_memory_write = __esm({
                 entries = JSON.parse(raw);
               } catch {
               }
+              const existingEntry = entries[key];
+              if (existingEntry && typeof existingEntry === "object" && existingEntry["valueHash"] === normalizedValue.valueHash) {
+                existingArtifactId = getEntryArtifactId(existingEntry);
+                return;
+              }
               const artifactId = `mem-${randomBytes5(6).toString("hex")}`;
+              storedArtifactId = artifactId;
               const canonicalKey = findCanonicalEntry(entries, normalizedValue.valueHash, key);
               entries[key] = canonicalKey ? {
                 value: `(duplicate of ${canonicalKey})`,
@@ -23772,8 +23787,20 @@ var init_memory_write = __esm({
               const tempFile = `${topicFile}.tmp-${randomBytes5(4).toString("hex")}`;
               await writeFile4(tempFile, JSON.stringify(entries, null, 2), "utf-8");
               await rename2(tempFile, topicFile);
+              wroteMemory = true;
             });
           }
+          if (!wroteMemory) {
+            const artifactSuffix = existingArtifactId ? ` [artifact: ${existingArtifactId}]` : "";
+            const output = `Memory already stored: ${topic}.${key}${artifactSuffix}. No new memory was written; continue with the next step or call task_complete if this was the final bookkeeping step.`;
+            return {
+              success: true,
+              output,
+              llmContent: output,
+              noop: true,
+              durationMs: performance.now() - start2
+            };
+          }
           const provenanceDir = resolve12(this.workingDir, ".omnius", "provenance");
           try {
             await mkdir3(provenanceDir, { recursive: true });
@@ -23781,7 +23808,7 @@ var init_memory_write = __esm({
               type: "memory_write",
               topic,
               key,
-              artifactId: `mem-${randomBytes5(6).toString("hex")}`,
+              artifactId: storedArtifactId,
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               source: "agent"
             };
@@ -23792,7 +23819,7 @@ var init_memory_write = __esm({
           await this.writeUnifiedMemory(topic, key, normalizedValue.value);
           return {
             success: true,
-            output: `Stored memory: ${topic}.${key} [artifact: mem-${Date.now().toString(36)}]`,
+            output: `Stored memory: ${topic}.${key} [artifact: ${storedArtifactId ?? "mem-unknown"}]`,
             durationMs: performance.now() - start2
           };
         } catch (error) {
@@ -558490,7 +558517,7 @@ function evaluate2(inputs) {
       compacted: cached?.compacted
     };
   }
-  const cacheEligible = isReadLike || proposedCall.tool === "shell";
+  const cacheEligible = isReadLike || proposedCall.tool === "shell" || proposedCall.tool === "memory_write";
   if (cacheEligible) {
     const cached = recentToolResults.get(fingerprint);
     if (cached !== void 0) {
@@ -569562,11 +569589,11 @@ ${latest.output || ""}`.trim();
           `[REPEAT GATE] Exact repeat #${hits} of ${toolName}(${argPreview}).`,
           `You ALREADY have this result — re-reading identical arguments cannot produce new information, so this call was NOT executed.`,
           ``,
-          `You are looping because progress tracking has drifted. Before any further read/list/search calls you MUST:`,
+          `You are looping because progress tracking has drifted. Before any further redundant calls you MUST:`,
           `  1. Call todo_write — decompose the remaining work into concrete, verifiable steps, mark the current step in_progress, and mark anything already done as completed.`,
           `  2. Then take a CONCRETE action on the evidence you already have: edit/write the implicated file, run a verification command, or call task_complete with evidence.`,
           ``,
-          `Do NOT repeat this exact call. If you believe the file changed on disk, make the change first, then read.`
+          `Do NOT repeat this exact call. If you believe state changed, perform the concrete change first, then retry with distinct evidence.`
         ].join("\n");
       }
       _renderKnowledgeBlock(recentToolResults) {
@@ -571640,6 +571667,7 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         let lastShellPivotTurn = -1;
         const recentToolResults = /* @__PURE__ */ new Map();
         const dedupHitCount = /* @__PURE__ */ new Map();
+        const noopedMemoryWriteFingerprints = /* @__PURE__ */ new Set();
         const DEDUP_ESCALATION_THRESHOLD = 3;
         const toolCallBudget = /* @__PURE__ */ new Map();
         const loopTier = this.options.modelTier ?? "large";
@@ -574002,6 +574030,36 @@ Corrective action: try a different approach first: read relevant files, adjust a
                 toolCallBudget.set(tc.name, budgetRemaining - 1);
               }
               const toolFingerprint = this._buildToolFingerprint(tc.name, tc.arguments ?? {});
+              if (tc.name === "memory_write" && noopedMemoryWriteFingerprints.has(toolFingerprint)) {
+                this.emit({
+                  type: "tool_call",
+                  toolName: tc.name,
+                  toolArgs: tc.arguments,
+                  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)}).
+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.`;
+                this.emit({
+                  type: "tool_result",
+                  toolName: tc.name,
+                  success: false,
+                  content: repeatNoopMsg.slice(0, 120),
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this._tagSyntheticFailure({
+                  mode: "step_repetition",
+                  rationale: "memory_write retried after an exact no-op was observed"
+                });
+                return {
+                  tc,
+                  output: repeatNoopMsg,
+                  success: false,
+                  systemGuidance: repeatNoopMsg
+                };
+              }
               const baseIsReadLike = ![
                 "file_write",
                 "file_edit",
@@ -574108,7 +574166,8 @@ Corrective action: try a different approach first: read relevant files, adjust a
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
                 const _repeatGateMax = this._resolveRepeatGateMax();
-                if (isReadLike && _existingFp !== void 0 && _repeatGateMax > 0) {
+                const repeatGateEligible = isReadLike || tc.name === "memory_write";
+                if (repeatGateEligible && _existingFp !== void 0 && _repeatGateMax > 0) {
                   if (criticDecision.hitNumber >= _repeatGateMax) {
                     repeatShortCircuit = {
                       success: false,
@@ -574966,7 +575025,8 @@ Respond with EXACTLY this structure before your next tool call:
                   }
                 }
               }
-              if (isReadLike && result.success || tc.name === "shell") {
+              const cacheableMemoryNoop = tc.name === "memory_write" && result.success && result.noop;
+              if (isReadLike && result.success || tc.name === "shell" || cacheableMemoryNoop) {
                 recentToolResults.set(toolFingerprint, {
                   result: tc.name === "shell" ? this._buildShellCacheResult(tc.arguments, result) : (result.output ?? "").slice(0, 2e3),
                   compacted: false
@@ -574978,6 +575038,13 @@ Respond with EXACTLY this structure before your next tool call:
                     dedupHitCount.delete(firstKey);
                   }
                 }
+                if (cacheableMemoryNoop) {
+                  noopedMemoryWriteFingerprints.add(toolFingerprint);
+                  const repeatGateSeed = Math.max(0, this._resolveRepeatGateMax() - 1);
+                  if (repeatGateSeed > 0) {
+                    dedupHitCount.set(toolFingerprint, Math.max(dedupHitCount.get(toolFingerprint) ?? 0, repeatGateSeed));
+                  }
+                }
               }
               const isFileMutation = realFileMutation;
               if (isFileMutation) {
@@ -575155,6 +575222,19 @@ Respond with EXACTLY this structure before your next tool call:
                 output += `
 
 ${criticGuidance}`;
+              }
+              if (tc.name === "memory_write" && result.success && result.noop) {
+                const topic = String(tc.arguments?.["topic"] ?? "<missing topic>");
+                const key = String(tc.arguments?.["key"] ?? "<missing key>");
+                const bookkeepingGuidance = `[BOOKKEEPING ALREADY DONE]
+memory_write reported that ${topic}.${key} already contains this exact value; no new memory was written.
+Do not call memory_write again for this same topic/key/value. Continue with the promised synthesis or next concrete task step, or call task_complete if the memory write was the final bookkeeping step.`;
+                output += `
+
+${bookkeepingGuidance}`;
+                runtimeSystemGuidance = runtimeSystemGuidance ? `${runtimeSystemGuidance}
+
+${bookkeepingGuidance}` : bookkeepingGuidance;
               }
               if (!result.success && (this.options.modelTier === "small" || this.options.modelTier === "medium")) {
                 const recovery = this.buildRecoveryGuidance(tc.name, result.error ?? "", tc.arguments);
@@ -575395,6 +575475,10 @@ Do NOT retry ${tc.name} with similar arguments.`);
                   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) {
+                  const topic = String(tc.arguments?.["topic"] ?? "<missing topic>");
+                  const key = String(tc.arguments?.["key"] ?? "<missing key>");
+                  this._taskState.completedSteps.push(`Memory stored: ${topic}.${key}`);
                 }
               }
               if (result.output.length > 500 && result.success) {

package/npm-shrinkwrap.json

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

package/package.json

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