omnius 1.0.388 → 1.0.389

package/dist/index.js

@@ -572459,11 +572459,86 @@ function computeEffectiveThink(params) {
   return params.defaultThink;
 }
 function sanitizeHistoryThink(messages2) {
-  return messages2.map((m2) => {
+  const referencedToolCallIds = /* @__PURE__ */ new Set();
+  for (const message2 of messages2) {
+    if (message2.role === "tool" && message2.tool_call_id) {
+      referencedToolCallIds.add(message2.tool_call_id);
+    }
+  }
+  const stripped = messages2.map((m2) => {
     if (m2.role !== "assistant" || typeof m2.content !== "string")
       return m2;
     return { ...m2, content: stripThinkBlocks(m2.content) };
   });
+  const sanitized = [];
+  for (let i2 = 0; i2 < stripped.length; i2++) {
+    const current = stripped[i2];
+    const next = stripped[i2 + 1];
+    if (isOrphanDuplicateAssistantToolAnchor(current, next, referencedToolCallIds)) {
+      continue;
+    }
+    sanitized.push(current);
+  }
+  return sanitized;
+}
+function isOrphanDuplicateAssistantToolAnchor(current, next, referencedToolCallIds) {
+  if (!next)
+    return false;
+  if (current.role !== "assistant" || next.role !== "assistant")
+    return false;
+  if (!Array.isArray(current.tool_calls) || !Array.isArray(next.tool_calls)) {
+    return false;
+  }
+  if (current.tool_calls.length === 0 || next.tool_calls.length === 0) {
+    return false;
+  }
+  if (assistantVisibleText(current).length > 0)
+    return false;
+  if (toolCallsFingerprint(current.tool_calls) !== toolCallsFingerprint(next.tool_calls)) {
+    return false;
+  }
+  const currentIds = current.tool_calls.map((call) => call.id).filter(Boolean);
+  const nextIds = next.tool_calls.map((call) => call.id).filter(Boolean);
+  const currentReferenced = currentIds.some((id) => referencedToolCallIds.has(id));
+  const nextReferenced = nextIds.some((id) => referencedToolCallIds.has(id));
+  return !currentReferenced && (nextReferenced || currentIds.length > 0);
+}
+function assistantVisibleText(message2) {
+  if (typeof message2.content === "string")
+    return message2.content.trim();
+  if (!Array.isArray(message2.content))
+    return "";
+  return message2.content.map((part) => part.type === "text" ? part.text ?? "" : "").join("").trim();
+}
+function toolCallsFingerprint(calls) {
+  return calls.map((call) => {
+    const args = normalizeToolCallArgumentString(call.function.arguments);
+    return `${call.function.name}:${args}`;
+  }).join("|");
+}
+function normalizeToolCallArgumentString(args) {
+  try {
+    return JSON.stringify(JSON.parse(args));
+  } catch {
+    return args.replace(/\s+/g, " ").trim();
+  }
+}
+function normalizeEditComparable(text2) {
+  return text2.replace(/\r\n/g, "\n").trim();
+}
+function previewInline(text2, max = 140) {
+  const normalized = text2.replace(/\s+/g, " ").trim();
+  if (normalized.length <= max)
+    return JSON.stringify(normalized);
+  return JSON.stringify(`${normalized.slice(0, max - 18)}...#${quickTextHash(normalized)}`);
+}
+function quickTextHash(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index++) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
 }
 function applyMemoryPrefixToMessages(messages2, memoryPrefix) {
   const prefix = memoryPrefix?.trim();
@@ -572938,6 +573013,8 @@ var init_agenticRunner = __esm({
       _completionCaveat = null;
       _completionLedger = null;
       _staleEditFamilies = /* @__PURE__ */ new Map();
+      _lastReadTurnByPathKey = /* @__PURE__ */ new Map();
+      _recentSuccessfulReplacements = [];
       // ── WO-AM-01/04/10: Associative memory stores ──
       // Episode store: every tool call → persistent episode with importance + decay
       // Temporal KG: entities + relations with temporal validity (valid_from/valid_until)
@@ -578793,6 +578870,8 @@ Respond with your assessment, then take action.`;
         this._completionLedger = null;
         this._focusTerminalLedgerRecorded = false;
         this._staleEditFamilies.clear();
+        this._lastReadTurnByPathKey.clear();
+        this._recentSuccessfulReplacements = [];
         this._lastWorldStateTurn = -1;
         this._fileWritesSinceLastWorldState = 0;
         this._resetVisualEvidenceState();
@@ -581183,7 +581262,7 @@ ${memoryLines.join("\n")}`
           this.proactivePrune(compacted, turn);
           this.microcompact(compacted, recentToolResults);
           this._insertContextFrame(compacted, await this._buildTurnContextFrame(turn, compacted, recentToolResults, environmentBlock));
-          let requestMessages = compacted;
+          let requestMessages = sanitizeHistoryThink(compacted);
           {
             const _limits = this.contextLimits();
             const ceInput = {
@@ -581219,6 +581298,7 @@ ${memoryLines.join("\n")}`
             }
           }
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
+          requestMessages = sanitizeHistoryThink(requestMessages);
           const chatRequest = {
             messages: requestMessages,
             tools: toolDefs,
@@ -582178,6 +582258,69 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   systemGuidance: staleRewriteOutput
                 };
               }
+              const editReversalBlock = this.editReversalPreflightBlock(tc.name, tc.arguments ?? {}, turn);
+              if (editReversalBlock) {
+                const focusDecision2 = this._focusSupervisor?.evaluateProposedCall({
+                  turn,
+                  toolName: tc.name,
+                  args: tc.arguments ?? {},
+                  fingerprint: toolFingerprint,
+                  isReadLike: false,
+                  stalePreflightMessage: editReversalBlock,
+                  context: this._buildFocusContextSnapshot()
+                });
+                const reversalOutput = focusDecision2?.kind === "block_tool_call" ? focusDecision2.message : editReversalBlock;
+                if (focusDecision2 && focusDecision2.kind !== "pass") {
+                  this._emitFocusSupervisorEvent({
+                    decision: focusDecision2.kind,
+                    state: focusDecision2.state,
+                    directiveId: focusDecision2.directive.id,
+                    reason: focusDecision2.directive.reason,
+                    requiredNextAction: focusDecision2.directive.requiredNextAction,
+                    blockedTool: tc.name,
+                    turn
+                  });
+                  this._maybeMarkFocusTerminalIncomplete({
+                    decision: focusDecision2,
+                    blockedTool: tc.name,
+                    turn
+                  });
+                }
+                this.emit({
+                  type: "tool_call",
+                  toolName: tc.name,
+                  toolArgs: tc.arguments,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this.emit({
+                  type: "tool_result",
+                  toolName: tc.name,
+                  success: false,
+                  content: reversalOutput.slice(0, 120),
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this._tagSyntheticFailure({
+                  mode: "step_repetition",
+                  rationale: "edit attempted to reverse a recent successful replacement without fresh evidence"
+                });
+                if (this._completionLedger) {
+                  this._completionLedger = recordToolEvidence(this._completionLedger, {
+                    name: tc.name,
+                    success: false,
+                    outputPreview: reversalOutput.slice(0, 500),
+                    argsKey: tc.arguments ? JSON.stringify(tc.arguments).slice(0, 300) : ""
+                  });
+                  this._saveCompletionLedgerSafe();
+                }
+                return {
+                  tc,
+                  output: reversalOutput,
+                  success: false,
+                  systemGuidance: reversalOutput
+                };
+              }
               const baseIsReadLike = ![
                 "file_write",
                 "file_edit",
@@ -583812,6 +583955,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
               const filePath = typeof tc.arguments?.path === "string" ? tc.arguments.path : "";
               recordToolExecution(this._appState, tc.name, performance.now() - toolStart, result.success, filePath || void 0);
               this.noteStaleEditGuardOutcome(tc.name, tc.arguments ?? {}, result, turn);
+              this.noteEditReversalOutcome(tc.name, tc.arguments ?? {}, result, turn);
               {
                 const beforeDirective = this._focusSupervisor?.snapshot().directive?.id ?? null;
                 this._focusSupervisor?.observeToolResult({
@@ -584876,8 +585020,9 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               }
             }
             this._insertContextFrame(compactedMsgs, await this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
+            const modelFacingMessages = sanitizeHistoryThink(compactedMsgs);
             const chatRequest = {
-              messages: compactedMsgs,
+              messages: modelFacingMessages,
               tools: toolDefs,
               temperature: this.options.temperature,
               maxTokens: this.options.maxTokens,
@@ -586461,6 +586606,94 @@ ${marker}` : marker);
           `Stale target preview: ${active.preview}`
         ].join("\n");
       }
+      editReversalPreflightBlock(toolName, args, turn) {
+        if (process.env["OMNIUS_ALLOW_BLIND_EDIT_REVERSAL"] === "1")
+          return null;
+        const replacements = this.extractReplacementEdits(toolName, args);
+        if (replacements.length === 0)
+          return null;
+        for (const replacement of replacements) {
+          const prior = [...this._recentSuccessfulReplacements].reverse().find((entry) => entry.pathKey === replacement.pathKey && entry.oldHash === replacement.newHash && entry.newHash === replacement.oldHash && turn - entry.turn <= 8);
+          if (!prior)
+            continue;
+          const lastReadTurn = this._lastReadTurnByPathKey.get(replacement.pathKey) ?? -1;
+          if (lastReadTurn > prior.turn)
+            continue;
+          return [
+            `[EDIT REVERSAL BLOCKED] ${toolName} would exactly reverse a recent successful edit on ${replacement.path}.`,
+            `Prior edit at turn ${prior.turn}: ${previewInline(prior.oldText)} -> ${previewInline(prior.newText)}.`,
+            `Proposed edit: ${previewInline(replacement.oldText)} -> ${previewInline(replacement.newText)}.`,
+            ``,
+            `Do not toggle a target back and forth after verification fails. First file_read the authoritative current file once, then choose one:`,
+            `1. make a different edit based on the fresh file and the latest failure output,`,
+            `2. run a verification command if the current file is already correct, or`,
+            `3. report incomplete/blocked with the concrete failing evidence.`
+          ].join("\n");
+        }
+        return null;
+      }
+      noteEditReversalOutcome(toolName, args, result, turn) {
+        const path12 = this.extractPrimaryToolPath(args);
+        if (toolName === "file_read" && path12 && result.success) {
+          this._lastReadTurnByPathKey.set(this.staleEditPathKey(path12), turn);
+          return;
+        }
+        if (!result.success || result.mutated === false)
+          return;
+        const replacements = this.extractReplacementEdits(toolName, args);
+        if (replacements.length === 0)
+          return;
+        for (const replacement of replacements) {
+          this._recentSuccessfulReplacements.push({
+            ...replacement,
+            tool: toolName,
+            turn
+          });
+        }
+        if (this._recentSuccessfulReplacements.length > 40) {
+          this._recentSuccessfulReplacements = this._recentSuccessfulReplacements.slice(-40);
+        }
+      }
+      extractReplacementEdits(toolName, args) {
+        if (!args)
+          return [];
+        const out = [];
+        const add3 = (path12, oldText, newText) => {
+          if (typeof path12 !== "string" || !path12.trim())
+            return;
+          if (typeof oldText !== "string" || typeof newText !== "string")
+            return;
+          const normalizedOld = normalizeEditComparable(oldText);
+          const normalizedNew = normalizeEditComparable(newText);
+          if (!normalizedOld || !normalizedNew || normalizedOld === normalizedNew)
+            return;
+          out.push({
+            path: path12.trim(),
+            pathKey: this.staleEditPathKey(path12),
+            oldText: normalizedOld,
+            newText: normalizedNew,
+            oldHash: this.quickHash(normalizedOld),
+            newHash: this.quickHash(normalizedNew)
+          });
+        };
+        if (toolName === "file_edit") {
+          add3(this.extractPrimaryToolPath(args), args["old_string"] ?? args["oldString"] ?? args["oldText"], args["new_string"] ?? args["newString"] ?? args["newText"]);
+          return out;
+        }
+        if (toolName === "batch_edit") {
+          const fallbackPath = this.extractPrimaryToolPath(args);
+          const edits = args["edits"];
+          if (!Array.isArray(edits))
+            return out;
+          for (const edit of edits) {
+            if (!edit || typeof edit !== "object")
+              continue;
+            const rec = edit;
+            add3(rec["path"] ?? rec["file"] ?? rec["filePath"] ?? rec["file_path"] ?? fallbackPath, rec["old_string"] ?? rec["oldString"] ?? rec["oldText"], rec["new_string"] ?? rec["newString"] ?? rec["newText"]);
+          }
+        }
+        return out;
+      }
       noteStaleEditGuardOutcome(toolName, args, result, turn) {
         const path12 = this.extractPrimaryToolPath(args);
         const pathKey = path12 ? this.staleEditPathKey(path12) : "";

package/npm-shrinkwrap.json

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

package/package.json

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