open-agents-ai 0.187.499 → 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;
               }
@@ -515154,6 +515299,257 @@ var init_stuck_meta_analyzer = __esm({
   }
 });
 
+// packages/orchestrator/dist/problem-frame-validator.js
+function renderFrameValidatorPrompt(inputs) {
+  const lines = [];
+  lines.push(`# PROBLEM-FRAME VALIDATION`);
+  lines.push(``);
+  lines.push(`You are a META-STRATEGY VALIDATOR. Another agent (the implementer)`);
+  lines.push(`is working on a task. You are NOT here to suggest a next tool call.`);
+  lines.push(`You are here to ask the deeper question:`);
+  lines.push(``);
+  lines.push(`  > "Is the implementer solving the right problem?"`);
+  lines.push(``);
+  lines.push(`Specifically, evaluate three things:`);
+  lines.push(``);
+  lines.push(`  1. **Goal-vs-subtask alignment**: does the current sub-task`);
+  lines.push(`     genuinely contribute to the original goal, or has the agent`);
+  lines.push(`     drifted into a side-quest that doesn't matter?`);
+  lines.push(``);
+  lines.push(`  2. **Frame ambition**: is the current frame too ambitious for`);
+  lines.push(`     the implementer's context? Is there a simpler version of`);
+  lines.push(`     the same sub-task that would still satisfy the goal?`);
+  lines.push(``);
+  lines.push(`  3. **Productive blockedness**: if the agent has been stuck on`);
+  lines.push(`     this sub-task for a while, is there a fundamentally`);
+  lines.push(`     different approach that would unblock progress, OR is`);
+  lines.push(`     the right move to declare this specific sub-task blocked`);
+  lines.push(`     and move on / escalate to the user?`);
+  lines.push(``);
+  lines.push(`## Goal (the immutable anchor)`);
+  lines.push(inputs.goal.slice(0, 800));
+  lines.push(``);
+  lines.push(`## Working directory`);
+  lines.push(inputs.workingDir);
+  lines.push(``);
+  lines.push(`## Current sub-task`);
+  if (inputs.currentSubtask.trim().length > 0) {
+    lines.push(inputs.currentSubtask.slice(0, 400));
+  } else {
+    lines.push(`(no in-progress sub-task identified — agent may be drifting)`);
+  }
+  lines.push(``);
+  lines.push(`## Plan status`);
+  if (inputs.planStatus.length === 0) {
+    lines.push(`(no plan items declared)`);
+  } else {
+    for (const t2 of inputs.planStatus.slice(0, 12)) {
+      lines.push(`  [${t2.status}] ${t2.content.slice(0, 100)}`);
+    }
+  }
+  lines.push(``);
+  lines.push(`## Recent activity summary`);
+  lines.push(inputs.recentActivitySummary.slice(0, 2e3));
+  lines.push(``);
+  lines.push(`## Triggers`);
+  lines.push(`  - Trigger reason: ${inputs.triggerReason}`);
+  lines.push(`  - Stuck-event count this run: ${inputs.recentStuckCount}`);
+  lines.push(`  - Turn: ${inputs.turn}`);
+  lines.push(``);
+  lines.push(`## Your verdict — pick ONE`);
+  lines.push(``);
+  lines.push(`Choose the verdict that best matches the situation:`);
+  lines.push(``);
+  lines.push(`  - **continue**: the current frame is right. The agent should`);
+  lines.push(`    keep going. Use this when goal-subtask alignment is good`);
+  lines.push(`    and progress is reasonable for the difficulty.`);
+  lines.push(``);
+  lines.push(`  - **simplify**: the current frame is correct in direction but`);
+  lines.push(`    too ambitious. Suggest a SMALLER version of the same`);
+  lines.push(`    sub-task that still satisfies the goal. Common case:`);
+  lines.push(`    agent is over-engineering a config when defaults would`);
+  lines.push(`    work, or writing comprehensive tests when 1-2 smoke tests`);
+  lines.push(`    would unblock.`);
+  lines.push(``);
+  lines.push(`  - **pivot**: the current frame is WRONG. The sub-task the`);
+  lines.push(`    agent is on does not contribute to the goal, or there is`);
+  lines.push(`    a fundamentally better approach. Common case: agent is`);
+  lines.push(`    fixing a custom config that should be deleted; agent is`);
+  lines.push(`    writing tests against an API that needs changing, not`);
+  lines.push(`    accommodating.`);
+  lines.push(``);
+  lines.push(`  - **declare-blocked**: there is no productive frame from this`);
+  lines.push(`    state. The current sub-task genuinely cannot be completed`);
+  lines.push(`    with the current information; the agent should call`);
+  lines.push(`    task_complete with the specific blocker named (NOT a`);
+  lines.push(`    polite "looks done"). Reserve for genuine dead-ends.`);
+  lines.push(``);
+  lines.push(`Do NOT default to continue out of politeness. If the recent`);
+  lines.push(`activity shows the agent spinning on a sub-problem (especially`);
+  lines.push(`if stuck-event count > 1), seriously consider whether simplify`);
+  lines.push(`or pivot would help.`);
+  lines.push(``);
+  lines.push(`## Output format`);
+  lines.push(``);
+  lines.push(`Reason briefly (1-3 sentences) about goal alignment, then emit`);
+  lines.push(`a SINGLE JSON code block with this exact shape:`);
+  lines.push(``);
+  lines.push("```json");
+  lines.push(`{`);
+  lines.push(`  "verdict": "continue" | "simplify" | "pivot" | "declare-blocked",`);
+  lines.push(`  "rationale": "<1-2 sentences>",`);
+  lines.push(`  "recommended_frame": {  /* OMIT for continue and declare-blocked */`);
+  lines.push(`    "new_subtask": "<concrete description of the better sub-task>",`);
+  lines.push(`    "why_better": "<why this frame is more tractable / aligned>",`);
+  lines.push(`    "success_criterion": "<what 'done' looks like for the new frame>"`);
+  lines.push(`  },`);
+  lines.push(`  "blocker_summary": "<for declare-blocked only — name the specific blocker>"`);
+  lines.push(`}`);
+  lines.push("```");
+  lines.push(``);
+  lines.push(`Be SPECIFIC. Vague verdicts are useless.`);
+  return lines.join("\n");
+}
+function parseFrameVerdict(rawResponse) {
+  const fallback = (msg) => ({
+    verdict: "continue",
+    // Safe default: don't disrupt agent on parser error
+    rationale: `(frame-validator parse failed: ${msg})`,
+    raw: rawResponse,
+    parseFallback: true
+  });
+  if (!rawResponse || typeof rawResponse !== "string" || rawResponse.trim().length === 0) {
+    return fallback("empty response");
+  }
+  const fenceMatch = rawResponse.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
+  let jsonText = null;
+  if (fenceMatch) {
+    jsonText = fenceMatch[1].trim();
+  } else {
+    const first2 = rawResponse.indexOf("{");
+    const last2 = rawResponse.lastIndexOf("}");
+    if (first2 !== -1 && last2 > first2)
+      jsonText = rawResponse.slice(first2, last2 + 1);
+  }
+  if (!jsonText)
+    return fallback("no JSON block found");
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch (e2) {
+    return fallback(`JSON parse: ${e2 instanceof Error ? e2.message : String(e2)}`);
+  }
+  if (!parsed || typeof parsed !== "object")
+    return fallback("not an object");
+  const rawVerdict = String(parsed.verdict ?? "").toLowerCase().trim();
+  let verdict;
+  if (rawVerdict === "continue" || rawVerdict === "ok" || rawVerdict === "stay")
+    verdict = "continue";
+  else if (rawVerdict === "simplify" || rawVerdict === "shrink" || rawVerdict === "minimize")
+    verdict = "simplify";
+  else if (rawVerdict === "pivot" || rawVerdict === "change" || rawVerdict === "redirect")
+    verdict = "pivot";
+  else if (rawVerdict === "declare-blocked" || rawVerdict === "declare_blocked" || rawVerdict === "blocked" || rawVerdict === "escalate")
+    verdict = "declare-blocked";
+  else
+    return fallback(`unrecognized verdict: ${rawVerdict}`);
+  const rationale = typeof parsed.rationale === "string" && parsed.rationale.length > 0 ? parsed.rationale.slice(0, 600) : "(no rationale)";
+  let recommended_frame;
+  if (verdict === "simplify" || verdict === "pivot") {
+    const rf = parsed.recommended_frame;
+    if (rf && typeof rf === "object") {
+      const newSub = typeof rf.new_subtask === "string" ? rf.new_subtask.slice(0, 400) : "";
+      const whyBetter = typeof rf.why_better === "string" ? rf.why_better.slice(0, 400) : "";
+      const success = typeof rf.success_criterion === "string" ? rf.success_criterion.slice(0, 400) : "";
+      if (newSub.length > 0) {
+        recommended_frame = { new_subtask: newSub, why_better: whyBetter, success_criterion: success };
+      }
+    }
+    if (!recommended_frame) {
+      return fallback(`${verdict} verdict missing required recommended_frame`);
+    }
+  }
+  let blocker_summary;
+  if (verdict === "declare-blocked") {
+    blocker_summary = typeof parsed.blocker_summary === "string" && parsed.blocker_summary.length > 0 ? parsed.blocker_summary.slice(0, 600) : void 0;
+    if (!blocker_summary) {
+      return fallback(`declare-blocked verdict missing required blocker_summary`);
+    }
+  }
+  return {
+    verdict,
+    rationale,
+    recommended_frame,
+    blocker_summary,
+    raw: rawResponse
+  };
+}
+function renderVerdictAsMessage(v) {
+  if (v.parseFallback)
+    return "";
+  if (v.verdict === "continue")
+    return "";
+  const lines = [];
+  lines.push(`[PROBLEM-FRAME VALIDATION — REG-51 — ${v.verdict.toUpperCase()}]`);
+  lines.push(``);
+  lines.push(`A meta-strategy validator reviewed your goal, current sub-task, and recent`);
+  lines.push(`activity. Verdict:`);
+  lines.push(``);
+  lines.push(`  ${v.rationale}`);
+  lines.push(``);
+  if (v.verdict === "simplify" || v.verdict === "pivot") {
+    const rf = v.recommended_frame;
+    const verb = v.verdict === "simplify" ? "SHRINK YOUR CURRENT FRAME" : "PIVOT TO A DIFFERENT FRAME";
+    lines.push(`${verb}:`);
+    lines.push(``);
+    lines.push(`  New sub-task:       ${rf.new_subtask}`);
+    lines.push(`  Why this is better: ${rf.why_better}`);
+    lines.push(`  Done when:          ${rf.success_criterion}`);
+    lines.push(``);
+    lines.push(`Update your todo list to reflect this new framing on your next response.`);
+    lines.push(`Then take ONE concrete action toward the new sub-task. Do NOT continue`);
+    lines.push(`the previous approach — it has been judged ${v.verdict === "pivot" ? "wrong" : "too ambitious"} for`);
+    lines.push(`your current state.`);
+  } else if (v.verdict === "declare-blocked") {
+    lines.push(`DECLARE BLOCKED:`);
+    lines.push(``);
+    lines.push(`  ${v.blocker_summary}`);
+    lines.push(``);
+    lines.push(`Call task_complete with a summary that names this blocker EXPLICITLY. Do`);
+    lines.push(`not pretend the work is done; do not keep iterating. The validator has`);
+    lines.push(`determined no productive frame exists from this state. Surface the`);
+    lines.push(`blocker and let the user / next agent intervene.`);
+  }
+  return lines.join("\n");
+}
+async function runFrameValidator(opts) {
+  const startMs = Date.now();
+  const prompt = renderFrameValidatorPrompt(opts.inputs);
+  const promptBytes = Buffer.byteLength(prompt, "utf-8");
+  let raw = "";
+  try {
+    raw = await opts.callable(prompt);
+  } catch (e2) {
+    raw = "";
+    void e2;
+  }
+  const responseBytes = Buffer.byteLength(raw, "utf-8");
+  const verdict = parseFrameVerdict(raw);
+  const injection = renderVerdictAsMessage(verdict);
+  return {
+    verdict,
+    injection,
+    promptBytes,
+    responseBytes,
+    durationMs: Date.now() - startMs
+  };
+}
+var init_problem_frame_validator = __esm({
+  "packages/orchestrator/dist/problem-frame-validator.js"() {
+    "use strict";
+  }
+});
+
 // packages/orchestrator/dist/pressure-gate.js
 function detectPressure(message2) {
   const hasProfanity = PRESSURE_SIGNALS.test(message2);
@@ -521394,6 +521790,7 @@ var init_agenticRunner = __esm({
     init_backward_pass_runner();
     init_world_state_plan_reconciler();
     init_stuck_meta_analyzer();
+    init_problem_frame_validator();
     init_pressure_gate();
     init_dist5();
     init_dist7();
@@ -521594,6 +521991,33 @@ var init_agenticRunner = __esm({
       // turn until they clear. Track which we've surfaced this run so the
       // signal doesn't fire >1× per turn per stem.
       _stickyEscalationsSurfacedThisTurn = /* @__PURE__ */ new Set();
+      // REG-49b: per-loop-episode dedup flag for SSMA invocation from the
+      // Loop Intervention escalation path. Reset when repetition score
+      // drops below the recovery threshold (0.2).
+      _smaFiredThisLoop = false;
+      // REG-50: same-file write-thrash detector cooldown. Once fired, give
+      // the agent 8 turns to break out before re-firing. Distinct from REG-44
+      // because the failure shape is different (writes >> reads, but stuck
+      // because no verification between writes).
+      _writeThrashCooldownUntilTurn = -1;
+      // REG-51: Problem-Frame Validator state. Periodic checkpoint (every
+      // OA_PFV_INTERVAL turns) + chronic-stuck trigger (when SSMA fire count
+      // hits a threshold). Tracks last-fired turn and cumulative SSMA count
+      // 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.
@@ -524316,6 +524740,7 @@ ${_staleSamples.join("\n")}` : ``,
                       preview: (entry.wentWrong || "").slice(0, 200)
                     })).sort((a2, b) => b.attempts - a2.attempts).slice(0, 5);
                     const _smaTools = Array.from(this.tools.keys());
+                    this._ssmaFiredCount++;
                     runStuckAnalyzer({
                       inputs: {
                         goal: this._taskState.originalGoal || this._taskState.goal || "",
@@ -524358,6 +524783,293 @@ ${_staleSamples.join("\n")}` : ``,
               }
             }
           }
+          if (turn > this._writeThrashCooldownUntilTurn && turn >= 12) {
+            const _wtWindow = toolCallLog.slice(-15);
+            if (_wtWindow.length >= 12) {
+              const _wtWriteClass = /* @__PURE__ */ new Set([
+                "file_write",
+                "file_edit",
+                "file_patch",
+                "batch_edit",
+                "notebook_edit"
+              ]);
+              const _wtFileCounts = /* @__PURE__ */ new Map();
+              for (const c9 of _wtWindow) {
+                if (!_wtWriteClass.has(c9.name))
+                  continue;
+                const _ak = c9.argsKey || "";
+                const _m = /(?:^|,)path=([^,]+)/.exec(_ak);
+                const _pk = _m ? _m[1].slice(0, 200) : _ak.slice(0, 200);
+                _wtFileCounts.set(_pk, (_wtFileCounts.get(_pk) ?? 0) + 1);
+              }
+              const _wtThreshold = parseInt(process.env["OA_WRITE_THRASH_THRESHOLD"] || "4", 10) || 4;
+              let _wtWorstPath = "";
+              let _wtWorstCount = 0;
+              for (const [_p, _n] of _wtFileCounts.entries()) {
+                if (_n > _wtWorstCount) {
+                  _wtWorstCount = _n;
+                  _wtWorstPath = _p;
+                }
+              }
+              const _wtHadSuccessfulVerify = _wtWindow.some((c9) => {
+                if (c9.name !== "shell" || c9.success !== true)
+                  return false;
+                const _out = c9.outputPreview || "";
+                return !/error|failed?|exit code [1-9]/i.test(_out);
+              });
+              if (_wtWorstCount >= _wtThreshold && !_wtHadSuccessfulVerify) {
+                this._writeThrashCooldownUntilTurn = turn + 8;
+                messages2.push({
+                  role: "system",
+                  content: [
+                    `[WRITE-THRASH HALT — REG-50]`,
+                    ``,
+                    `In the last ${_wtWindow.length} tool calls you have written the same file ${_wtWorstCount} times:`,
+                    `  ${_wtWorstPath}`,
+                    ``,
+                    `No successful test/build/typecheck command ran between writes — you are iterating the file blind, hoping the next variation works. This is a write-thrash anti-pattern. Repeated edits without verification confirm nothing.`,
+                    ``,
+                    `Pick ONE of these for your next response:`,
+                    ``,
+                    `  (a) RUN-AND-READ: Run the EXACT command that fails (test/typecheck/build) and READ THE FULL ERROR MESSAGE LITERALLY. Do not summarize it from memory; paste it back into context. The current write hasn't been validated against any error.`,
+                    ``,
+                    `  (b) DELETE-AND-RESTART: If the file has been rewritten ${_wtWorstCount} times, the current approach is wrong. Either delete the file and try a fundamentally different design, OR revert to a known-good earlier version (use git, working_notes, or memory_search to find one).`,
+                    ``,
+                    `  (c) WEB-SEARCH: If the error is framework- or version-specific (config files often are), web_search the EXACT error string + relevant tool name. External knowledge beats blind iteration.`,
+                    ``,
+                    `  (d) DECLARE BLOCKED: If the file's correct shape genuinely isn't knowable from the spec + this codebase, call task_complete with a summary that names this specific file as the blocker. Don't burn more turns on it.`,
+                    ``,
+                    `Do NOT in your next response: write to ${_wtWorstPath} again without first running and reading the failing command's output.`
+                  ].join("\n")
+                });
+                this.emit({
+                  type: "status",
+                  content: `REG-50 WRITE-THRASH halt fired at turn ${turn} — file=${_wtWorstPath}, count=${_wtWorstCount}/${_wtThreshold}, no successful verify in window`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                try {
+                  const _smaRaw50 = (process.env["OA_STUCK_META_ANALYZER"] || "off").toLowerCase();
+                  const _smaOn50 = _smaRaw50 === "on" || _smaRaw50 === "1" || _smaRaw50 === "true";
+                  if (_smaOn50) {
+                    const _smaCallable50 = async (prompt) => {
+                      try {
+                        const _r = await this.backend.chatCompletion({
+                          messages: [
+                            { role: "system", content: "You are a META-ANALYSIS sub-agent. Audit the implementer's stuck state and emit a structured JSON directive." },
+                            { role: "user", content: prompt }
+                          ],
+                          tools: [],
+                          temperature: 0,
+                          maxTokens: parseInt(process.env["OA_STUCK_META_MAX_TOKENS"] || "2048", 10) || 2048,
+                          timeoutMs: parseInt(process.env["OA_STUCK_META_TIMEOUT_MS"] || "120000", 10) || 12e4
+                        });
+                        const _c = _r?.choices?.[0]?.message?.content;
+                        return typeof _c === "string" ? _c : "";
+                      } catch {
+                        return "";
+                      }
+                    };
+                    const _smaCalls50 = _wtWindow.map((c9) => ({
+                      name: c9.name,
+                      argsKey: c9.argsKey,
+                      success: c9.success,
+                      outputPreview: (c9.outputPreview || "").split(/\r?\n/)[0]?.slice(0, 120) ?? ""
+                    }));
+                    const _smaPlan50 = (() => {
+                      try {
+                        const _todos = this.readSessionTodos() || [];
+                        return _todos.slice(0, 12).map((t2) => ({
+                          content: t2.content || "",
+                          reconciled: t2.status || "pending",
+                          rationale: "(structural status only)"
+                        }));
+                      } catch {
+                        return [];
+                      }
+                    })();
+                    const _smaTools50 = Array.from(this.tools.keys());
+                    this._ssmaFiredCount++;
+                    runStuckAnalyzer({
+                      inputs: {
+                        goal: this._taskState.originalGoal || this._taskState.goal || "",
+                        workingDir: this._workingDirectory || process.cwd(),
+                        triggerReason: `reg50-write-thrash-${_wtWorstCount}x`,
+                        recentToolCalls: _smaCalls50,
+                        planStatus: _smaPlan50,
+                        recentFailures: [],
+                        workspaceSummary: `WRITE-THRASH: ${_wtWorstPath} written ${_wtWorstCount} times in last ${_wtWindow.length} calls without successful verification.`,
+                        availableTools: _smaTools50,
+                        turn
+                      },
+                      callable: _smaCallable50
+                    }).then((_smaResult) => {
+                      if (_smaResult.injection && !_smaResult.directive.parseFallback) {
+                        messages2.push({ role: "system", content: _smaResult.injection });
+                        this.emit({
+                          type: "status",
+                          content: `REG-50 → SSMA fired at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                      }
+                    }).catch(() => {
+                    });
+                  }
+                } catch {
+                }
+              }
+            }
+          }
+          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 && 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 {
+                    const _r = await this.backend.chatCompletion({
+                      messages: [
+                        { role: "system", content: "You are a META-STRATEGY VALIDATOR. Audit the implementer's frame-vs-goal alignment and emit a structured JSON verdict." },
+                        { role: "user", content: prompt }
+                      ],
+                      tools: [],
+                      temperature: 0,
+                      maxTokens: parseInt(process.env["OA_PFV_MAX_TOKENS"] || "1500", 10) || 1500,
+                      timeoutMs: parseInt(process.env["OA_PFV_TIMEOUT_MS"] || "120000", 10) || 12e4
+                    });
+                    const _c = _r?.choices?.[0]?.message?.content;
+                    return typeof _c === "string" ? _c : "";
+                  } catch {
+                    return "";
+                  }
+                };
+                const _pfvTodos = (() => {
+                  try {
+                    return this.readSessionTodos() || [];
+                  } catch {
+                    return [];
+                  }
+                })();
+                const _pfvCurrentSubtask = _pfvTodos.find((t2) => t2.status === "in_progress")?.content || "";
+                const _pfvPlanStatus = _pfvTodos.slice(0, 12).map((t2) => ({
+                  content: t2.content || "",
+                  status: t2.status || "pending"
+                }));
+                const _pfvRecentCalls = toolCallLog.slice(-30);
+                const _pfvSummaryParts = [];
+                _pfvSummaryParts.push(`Last ${_pfvRecentCalls.length} tool calls (most recent at bottom):`);
+                for (const _c of _pfvRecentCalls) {
+                  const _ak = (_c.argsKey || "").slice(0, 80);
+                  const _flag = _c.success === false ? "ERR" : "ok";
+                  _pfvSummaryParts.push(`  ${_c.name}(${_ak}) ${_flag}`);
+                }
+                const _pfvActivity = _pfvSummaryParts.join("\n");
+                runFrameValidator({
+                  inputs: {
+                    goal: this._taskState.originalGoal || this._taskState.goal || "",
+                    workingDir: this._workingDirectory || process.cwd(),
+                    currentSubtask: _pfvCurrentSubtask,
+                    recentActivitySummary: _pfvActivity,
+                    planStatus: _pfvPlanStatus,
+                    recentStuckCount: this._ssmaFiredCount,
+                    turn,
+                    triggerReason: _pfvTriggerReason
+                  },
+                  callable: _pfvCallable
+                }).then((_pfvResult) => {
+                  if (_pfvResult.injection && !_pfvResult.verdict.parseFallback && _pfvResult.verdict.verdict !== "continue") {
+                    messages2.push({ role: "system", content: _pfvResult.injection });
+                    this.emit({
+                      type: "status",
+                      content: `REG-51 PFV fired at turn ${turn} — verdict=${_pfvResult.verdict.verdict}, trigger=${_pfvTriggerReason}, ssmaCount=${this._ssmaFiredCount}, ${_pfvResult.durationMs}ms`,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  } else {
+                    this.emit({
+                      type: "status",
+                      content: `REG-51 PFV verdict=continue (or parse-fallback) at turn ${turn} — trigger=${_pfvTriggerReason}, ${_pfvResult.durationMs}ms`,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  }
+                }).catch((_e) => {
+                  this.emit({
+                    type: "status",
+                    content: `REG-51 PFV threw: ${_e instanceof Error ? _e.message : String(_e)} (non-fatal)`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                });
+              }
+            }
+          } catch (_e) {
+          }
           try {
             const STICKY_PER_TURN_CAP = 2;
             const _candidates = [];
@@ -526393,7 +527105,90 @@ Call task_complete(summary="...") NOW with whatever you have.`
                 content: `Loop intervention ${loopInterventionCount}/${maxInterventions}: ${Math.round(currentRepScore * 100)}% repetitive (${topRepeated})`,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
+              try {
+                const _smaRaw = (process.env["OA_STUCK_META_ANALYZER"] || "off").toLowerCase();
+                const _smaOn = _smaRaw === "on" || _smaRaw === "1" || _smaRaw === "true";
+                if (_smaOn && loopInterventionCount >= 2 && !this._smaFiredThisLoop) {
+                  this._smaFiredThisLoop = true;
+                  const _smaCallable = async (prompt) => {
+                    try {
+                      const _r = await this.backend.chatCompletion({
+                        messages: [
+                          { role: "system", content: "You are a META-ANALYSIS sub-agent. Audit the implementer's stuck state and emit a structured JSON directive." },
+                          { role: "user", content: prompt }
+                        ],
+                        tools: [],
+                        temperature: 0,
+                        maxTokens: parseInt(process.env["OA_STUCK_META_MAX_TOKENS"] || "2048", 10) || 2048,
+                        timeoutMs: parseInt(process.env["OA_STUCK_META_TIMEOUT_MS"] || "120000", 10) || 12e4
+                      });
+                      const _c = _r?.choices?.[0]?.message?.content;
+                      return typeof _c === "string" ? _c : "";
+                    } catch {
+                      return "";
+                    }
+                  };
+                  const _smaCalls = toolCallLog.slice(-25).map((c9) => ({
+                    name: c9.name,
+                    argsKey: c9.argsKey,
+                    success: c9.success,
+                    outputPreview: (c9.outputPreview || "").split(/\r?\n/)[0]?.slice(0, 120) ?? ""
+                  }));
+                  const _smaPlan = (() => {
+                    try {
+                      const _todos = this.readSessionTodos() || [];
+                      return _todos.slice(0, 12).map((t2) => ({
+                        content: t2.content || "",
+                        reconciled: t2.status || "pending",
+                        rationale: "(structural status only)"
+                      }));
+                    } catch {
+                      return [];
+                    }
+                  })();
+                  const _smaFailures = Array.from(this._failureReflections.entries()).map(([stem, entry]) => ({ stem, attempts: entry.attempts, preview: (entry.wentWrong || "").slice(0, 200) })).sort((a2, b) => b.attempts - a2.attempts).slice(0, 5);
+                  const _smaTools = Array.from(this.tools.keys());
+                  this._ssmaFiredCount++;
+                  runStuckAnalyzer({
+                    inputs: {
+                      goal: this._taskState.originalGoal || this._taskState.goal || "",
+                      workingDir: this._workingDirectory || process.cwd(),
+                      triggerReason: `loop-intervention-${loopInterventionCount}/${maxInterventions}`,
+                      recentToolCalls: _smaCalls,
+                      planStatus: _smaPlan,
+                      recentFailures: _smaFailures,
+                      workspaceSummary: void 0,
+                      availableTools: _smaTools,
+                      turn
+                    },
+                    callable: _smaCallable
+                  }).then((_smaResult) => {
+                    if (_smaResult.injection && !_smaResult.directive.parseFallback) {
+                      messages2.push({ role: "system", content: _smaResult.injection });
+                      this.emit({
+                        type: "status",
+                        content: `REG-49 stuck-meta-analyzer fired (loop-intervention path) at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    } else {
+                      this.emit({
+                        type: "status",
+                        content: `REG-49 stuck-meta-analyzer parse failed (loop-intervention path) at turn ${turn} — falling back to existing intervention`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
+                  }).catch((_e) => {
+                    this.emit({
+                      type: "status",
+                      content: `REG-49 stuck-meta-analyzer (loop-intervention path) threw: ${_e instanceof Error ? _e.message : String(_e)} (non-fatal)`,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  });
+                }
+              } catch (_e) {
+              }
             } else if (currentRepScore <= 0.2) {
+              this._smaFiredThisLoop = false;
             }
           } else {
             const content = msg.content || "";

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.499",
+  "version": "0.187.501",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.499",
+      "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.499",
+  "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",