open-agents-ai 0.187.499 → 0.187.500

package/dist/index.js

@@ -515154,6 +515154,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 +521645,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 +521846,21 @@ 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-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 +524583,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 +524626,230 @@ ${_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 {
+                }
+              }
+            }
+          }
+          try {
+            const _pfvRaw = (process.env["OA_PFV"] || "off").toLowerCase();
+            const _pfvOn = _pfvRaw === "on" || _pfvRaw === "1" || _pfvRaw === "true";
+            if (_pfvOn && this._lastPfvTurn !== turn) {
+              const _pfvInterval = parseInt(process.env["OA_PFV_INTERVAL"] || "30", 10) || 30;
+              const _pfvChronicThreshold = parseInt(process.env["OA_PFV_CHRONIC_THRESHOLD"] || "2", 10) || 2;
+              const _pfvPeriodic = turn > 0 && _pfvInterval > 0 && turn % _pfvInterval === 0;
+              const _pfvChronic = this._ssmaFiredCount >= _pfvChronicThreshold;
+              if (_pfvPeriodic || _pfvChronic) {
+                this._lastPfvTurn = turn;
+                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 +526885,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.500",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.499",
+      "version": "0.187.500",
       "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.500",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",