open-agents-ai 0.187.500 → 0.187.501

package/dist/index.js

@@ -3986,6 +3986,91 @@ ${JSON.stringify(extracted, null, 2)}`);
   }
 });
 
+// packages/execution/dist/tools/edit-snippet-finder.js
+function findClosestSnippet(content, oldString, contextLines = 5) {
+  const lines = content.split("\n");
+  if (lines.length === 0)
+    return null;
+  const oldLines = oldString.split("\n").map((l2) => l2.trim()).filter((l2) => l2.length > 0);
+  if (oldLines.length === 0)
+    return null;
+  const anchor = oldLines.reduce((best, l2) => l2.length > best.length ? l2 : best, oldLines[0]);
+  let bestIdx = 0;
+  let bestScore = -1;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const score = diceSimilarity(anchor, lines[i2].trim());
+    if (score > bestScore) {
+      bestScore = score;
+      bestIdx = i2;
+    }
+  }
+  const startIdx = Math.max(0, bestIdx - contextLines);
+  const endIdx = Math.min(lines.length - 1, bestIdx + contextLines);
+  const snippetLines = [];
+  for (let i2 = startIdx; i2 <= endIdx; i2++) {
+    const lineNum = i2 + 1;
+    const marker = i2 === bestIdx ? ">" : " ";
+    snippetLines.push(`${marker} ${lineNum.toString().padStart(4)} | ${lines[i2]}`);
+  }
+  return {
+    startLine: startIdx + 1,
+    endLine: endIdx + 1,
+    content: snippetLines.join("\n"),
+    similarity: Math.max(0, bestScore),
+    totalLines: lines.length
+  };
+}
+function snippetAtOffset(content, charOffset, contextLines = 3) {
+  const lines = content.split("\n");
+  const before = content.slice(0, charOffset);
+  const lineNumber = before.split("\n").length;
+  const idx = lineNumber - 1;
+  const startIdx = Math.max(0, idx - contextLines);
+  const endIdx = Math.min(lines.length - 1, idx + contextLines);
+  const out = [];
+  for (let i2 = startIdx; i2 <= endIdx; i2++) {
+    const marker = i2 === idx ? ">" : " ";
+    out.push(`${marker} ${(i2 + 1).toString().padStart(4)} | ${lines[i2]}`);
+  }
+  return { lineNumber, content: out.join("\n") };
+}
+function diceSimilarity(a2, b) {
+  if (!a2.length && !b.length)
+    return 1;
+  if (!a2.length || !b.length)
+    return 0;
+  if (a2 === b)
+    return 1;
+  if (a2.length < 2 || b.length < 2) {
+    return a2 === b ? 1 : 0;
+  }
+  const bigramsA = bigrams(a2);
+  const bigramsB = bigrams(b);
+  let intersection = 0;
+  for (const bg of bigramsB.keys()) {
+    const count = Math.min(bigramsA.get(bg) ?? 0, bigramsB.get(bg));
+    if (count > 0) {
+      intersection += count;
+      bigramsA.set(bg, (bigramsA.get(bg) ?? 0) - count);
+    }
+  }
+  const total = a2.length - 1 + (b.length - 1);
+  return total > 0 ? 2 * intersection / total : 0;
+}
+function bigrams(s2) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < s2.length - 1; i2++) {
+    const bg = s2.slice(i2, i2 + 2);
+    map2.set(bg, (map2.get(bg) ?? 0) + 1);
+  }
+  return map2;
+}
+var init_edit_snippet_finder = __esm({
+  "packages/execution/dist/tools/edit-snippet-finder.js"() {
+    "use strict";
+  }
+});
+
 // packages/execution/dist/tools/file-edit.js
 import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { resolve as resolve6 } from "node:path";
@@ -4016,6 +4101,15 @@ function findMatchLines(haystack, needle) {
   }
   return lines;
 }
+function findMatchOffsets(haystack, needle) {
+  const offsets = [];
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    offsets.push(pos);
+    pos += needle.length;
+  }
+  return offsets;
+}
 function replaceAllOccurrences(haystack, needle, replacement) {
   return haystack.split(needle).join(replacement);
 }
@@ -4024,6 +4118,7 @@ var init_file_edit = __esm({
   "packages/execution/dist/tools/file-edit.js"() {
     "use strict";
     init_change_log();
+    init_edit_snippet_finder();
     FileEditTool = class {
       name = "file_edit";
       description = "Make a precise edit to a file by replacing an exact string match. The old_string must be unique in the file unless replace_all is true. Use replace_all to rename variables or change repeated patterns throughout the file.";
@@ -4085,19 +4180,42 @@ var init_file_edit = __esm({
           const content = await readFile3(fullPath, "utf-8");
           const occurrences = countOccurrences(content, oldString);
           if (occurrences === 0) {
+            const snippet = findClosestSnippet(content, oldString, 5);
+            let errorMsg = `old_string not found in ${filePath}.`;
+            if (snippet) {
+              const pct = Math.round(snippet.similarity * 100);
+              errorMsg += `
+
+Current file content (closest match, ${pct}% similarity, lines ${snippet.startLine}–${snippet.endLine} of ${snippet.totalLines}):
+${snippet.content}
+
+Use the EXACT current content above to construct a working old_string. Do not retry with a different guess — the file on disk has changed since you last read it.`;
+            } else {
+              errorMsg += ` The file is empty or binary. Use file_read to inspect.`;
+            }
             return {
               success: false,
               output: "",
-              error: `old_string not found in ${filePath}. Read the file first to verify the exact content.`,
+              error: errorMsg,
               durationMs: performance.now() - start2
             };
           }
           if (!replaceAll && occurrences > 1) {
             const matchLines = findMatchLines(content, oldString);
+            const offsets = findMatchOffsets(content, oldString);
+            const snippets = offsets.slice(0, 4).map((off) => {
+              const s2 = snippetAtOffset(content, off, 3);
+              return `
+--- match at line ${s2.lineNumber} ---
+${s2.content}`;
+            }).join("\n");
             return {
               success: false,
               output: "",
-              error: `old_string is not unique — found ${occurrences} occurrences at lines ${matchLines.join(", ")}. Either include more surrounding context to make old_string unique, or set replace_all=true to replace all ${occurrences} occurrences.`,
+              error: `old_string is not unique — found ${occurrences} occurrences at lines ${matchLines.join(", ")}.
+${snippets}
+
+Add UNIQUE surrounding context (a function name, distinctive comment, or unique line above/below) to disambiguate. Or set replace_all=true if you want all ${occurrences} occurrences replaced identically.`,
               durationMs: performance.now() - start2
             };
           }
@@ -5595,6 +5713,15 @@ var init_aiwg_workflow = __esm({
 // packages/execution/dist/tools/batch-edit.js
 import { readFile as readFile7, writeFile as writeFile4 } from "node:fs/promises";
 import { resolve as resolve11 } from "node:path";
+function findMatchOffsetsBatch(haystack, needle) {
+  const offsets = [];
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    offsets.push(pos);
+    pos += needle.length;
+  }
+  return offsets;
+}
 function countOccurrences2(haystack, needle) {
   let count = 0;
   let pos = 0;
@@ -5609,6 +5736,7 @@ var init_batch_edit = __esm({
   "packages/execution/dist/tools/batch-edit.js"() {
     "use strict";
     init_change_log();
+    init_edit_snippet_finder();
     BatchEditTool = class {
       name = "batch_edit";
       description = "Make multiple precise edits across one or more files in a single call. More efficient than calling file_edit repeatedly. Each edit replaces an exact string match with uniqueness validation. Edits are applied in order within each file. Set replace_all on individual edits for bulk renames.";
@@ -5680,12 +5808,29 @@ var init_batch_edit = __esm({
             for (const edit of fileEdits) {
               const occurrences = countOccurrences2(content, edit.old_string);
               if (occurrences === 0) {
-                results.push(`SKIP: old_string not found in ${edit.relPath}`);
+                const snippet = findClosestSnippet(content, edit.old_string, 5);
+                if (snippet) {
+                  const pct = Math.round(snippet.similarity * 100);
+                  results.push(`SKIP: old_string not found in ${edit.relPath}.
+  Closest match in current file (${pct}% similar, lines ${snippet.startLine}–${snippet.endLine} of ${snippet.totalLines}):
+${snippet.content}
+  Use this exact content for old_string in your next attempt.`);
+                } else {
+                  results.push(`SKIP: old_string not found in ${edit.relPath} (file empty or binary)`);
+                }
                 failCount++;
                 continue;
               }
               if (!edit.replace_all && occurrences > 1) {
-                results.push(`AMBIGUOUS: old_string has ${occurrences} matches in ${edit.relPath} — add more context or use replace_all`);
+                const offsets = findMatchOffsetsBatch(content, edit.old_string).slice(0, 4);
+                const snippets = offsets.map((off) => {
+                  const s2 = snippetAtOffset(content, off, 3);
+                  return `
+  --- match at line ${s2.lineNumber} ---
+${s2.content}`;
+                }).join("\n");
+                results.push(`AMBIGUOUS: old_string has ${occurrences} matches in ${edit.relPath}.${snippets}
+  Add UNIQUE surrounding context, or use replace_all=true.`);
                 failCount++;
                 continue;
               }
@@ -521861,6 +522006,18 @@ var init_agenticRunner = __esm({
       // for chronic detection.
       _lastPfvTurn = -1;
       _ssmaFiredCount = 0;
+      // REG-52: PFV cooldown. Without this, chronic-stuck (which only ever
+      // increases) keeps PFV firing every turn after the threshold is
+      // crossed, mostly returning continue (waste). Cooldown for OA_PFV_COOLDOWN
+      // turns (default 8) after every fire — same shape as REG-44/REG-50.
+      _pfvCooldownUntilTurn = -1;
+      // REG-53: edit-fail-thrash detector cooldown. Detects the failure
+      // mode REG-50 misses: agent hammers file_edit/batch_edit on the same
+      // file with old_string variants that never match. Each failure
+      // doesn't increment the file's WRITE count (no bytes hit disk), so
+      // REG-50's cooldown stays armed and never re-fires. The agent stays
+      // stuck.
+      _editFailThrashCooldownUntilTurn = -1;
       // REG-46: world-state regeneration. Replaces stream-based context
       // re-derivation (agent re-listing dirs, re-reading specs) with periodic
       // injected snapshots of workdir + plan reconciliation + recent failures.
@@ -524762,16 +524919,79 @@ ${_staleSamples.join("\n")}` : ``,
               }
             }
           }
+          if (turn > this._editFailThrashCooldownUntilTurn && turn >= 12) {
+            const _efWindow = toolCallLog.slice(-15);
+            if (_efWindow.length >= 12) {
+              const _efEditClass = /* @__PURE__ */ new Set([
+                "file_edit",
+                "batch_edit",
+                "file_patch"
+              ]);
+              const _efFailCounts = /* @__PURE__ */ new Map();
+              for (const c9 of _efWindow) {
+                if (!_efEditClass.has(c9.name))
+                  continue;
+                if (c9.success !== false)
+                  continue;
+                const _ak = c9.argsKey || "";
+                const _m = /(?:^|,)path=([^,]+)/.exec(_ak);
+                const _pk = _m ? _m[1].slice(0, 200) : _ak.slice(0, 200);
+                _efFailCounts.set(_pk, (_efFailCounts.get(_pk) ?? 0) + 1);
+              }
+              const _efThreshold = parseInt(process.env["OA_EDIT_FAIL_THRESHOLD"] || "3", 10) || 3;
+              let _efWorstPath = "";
+              let _efWorstCount = 0;
+              for (const [_p, _n] of _efFailCounts.entries()) {
+                if (_n > _efWorstCount) {
+                  _efWorstCount = _n;
+                  _efWorstPath = _p;
+                }
+              }
+              if (_efWorstCount >= _efThreshold) {
+                this._editFailThrashCooldownUntilTurn = turn + 8;
+                messages2.push({
+                  role: "system",
+                  content: [
+                    `[EDIT-FAIL-THRASH HALT — REG-53]`,
+                    ``,
+                    `In the last ${_efWindow.length} tool calls you have failed file_edit/batch_edit on the same file ${_efWorstCount} times:`,
+                    `  ${_efWorstPath}`,
+                    ``,
+                    `Each failure means your old_string did not match the file content. Your remembered version of this file has diverged from what's on disk — likely because an earlier edit succeeded and shifted things, or because you guessed at the file's content.`,
+                    ``,
+                    `STOP guessing variants of old_string. Pick ONE of these for your next response:`,
+                    ``,
+                    `  (a) FILE_READ + COPY-EXACT: Call file_read on ${_efWorstPath}, then copy the EXACT bytes (whitespace, indentation, punctuation) for old_string from that read. Do not paraphrase or reformat.`,
+                    ``,
+                    `  (b) USE THE INLINE SNIPPET: Recent edit failures already include a "closest match" snippet showing the actual current content near where you tried to edit. Read that snippet in your last error message and use its content verbatim as old_string.`,
+                    ``,
+                    `  (c) REPLACE_ALL: If you want a global rename, set replace_all=true and the uniqueness check is bypassed.`,
+                    ``,
+                    `  (d) FILE_WRITE: If the changes are extensive, rewrite the whole file with file_write instead of patching it. Faster than 6 failed edits.`,
+                    ``,
+                    `Do NOT in your next response: call file_edit or batch_edit on ${_efWorstPath} again with another guess at old_string.`
+                  ].join("\n")
+                });
+                this.emit({
+                  type: "status",
+                  content: `REG-53 EDIT-FAIL-THRASH halt fired at turn ${turn} — file=${_efWorstPath}, failures=${_efWorstCount}/${_efThreshold}`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+            }
+          }
           try {
             const _pfvRaw = (process.env["OA_PFV"] || "off").toLowerCase();
             const _pfvOn = _pfvRaw === "on" || _pfvRaw === "1" || _pfvRaw === "true";
-            if (_pfvOn && this._lastPfvTurn !== turn) {
+            if (_pfvOn && this._lastPfvTurn !== turn && turn > this._pfvCooldownUntilTurn) {
               const _pfvInterval = parseInt(process.env["OA_PFV_INTERVAL"] || "30", 10) || 30;
               const _pfvChronicThreshold = parseInt(process.env["OA_PFV_CHRONIC_THRESHOLD"] || "2", 10) || 2;
+              const _pfvCooldown = parseInt(process.env["OA_PFV_COOLDOWN"] || "8", 10) || 8;
               const _pfvPeriodic = turn > 0 && _pfvInterval > 0 && turn % _pfvInterval === 0;
               const _pfvChronic = this._ssmaFiredCount >= _pfvChronicThreshold;
               if (_pfvPeriodic || _pfvChronic) {
                 this._lastPfvTurn = turn;
+                this._pfvCooldownUntilTurn = turn + _pfvCooldown;
                 const _pfvTriggerReason = _pfvChronic ? "chronic-stuck" : "periodic";
                 const _pfvCallable = async (prompt) => {
                   try {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.500",
+  "version": "0.187.501",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.500",
+      "version": "0.187.501",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

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