open-agents-ai 0.187.498 → 0.187.500

package/dist/index.js

@@ -255394,14 +255394,26 @@ function buildScaffoldedPrompt(args) {
     lines.push(bulletList(args.features));
     lines.push("");
   }
-  lines.push(`## Tech stack — POSITIVE constraints (use these)`);
-  lines.push(bulletList(args.stack));
-  lines.push("");
-  lines.push(`## Tech stack — NEGATIVE constraints (do NOT use these)`);
-  lines.push(`These prohibitions are load-bearing. Default training data favors popular alternatives; you must respect the explicit "no" here even when a forbidden choice would be conventional.`);
-  lines.push("");
-  lines.push(bulletList(args.anti_stack));
-  lines.push("");
+  if (args.stack && args.stack.length > 0) {
+    lines.push(`## Tech stack — POSITIVE constraints (use these)`);
+    lines.push(bulletList(args.stack));
+    lines.push("");
+  } else {
+    lines.push(`## Tech stack — POSITIVE constraints`);
+    lines.push(`The caller did not specify positive tech-stack constraints. The spec MUST declare its own tech stack explicitly in section 1 (Overview) — language, runtime, frameworks, persistence, build/test tools — so the downstream implementer has unambiguous targets. Do NOT leave the stack as an open choice.`);
+    lines.push("");
+  }
+  if (args.anti_stack && args.anti_stack.length > 0) {
+    lines.push(`## Tech stack — NEGATIVE constraints (do NOT use these)`);
+    lines.push(`These prohibitions are load-bearing. Default training data favors popular alternatives; you must respect the explicit "no" here even when a forbidden choice would be conventional.`);
+    lines.push("");
+    lines.push(bulletList(args.anti_stack));
+    lines.push("");
+  } else {
+    lines.push(`## Tech stack — NEGATIVE constraints`);
+    lines.push(`No explicit prohibitions supplied. The spec is free to choose any tooling consistent with the positive constraints, but the spec itself SHOULD include a brief "anti-requirements" section (see section 11) listing the patterns/libraries explicitly excluded — even if the caller did not pre-specify them.`);
+    lines.push("");
+  }
   if (args.notes && args.notes.trim().length > 0) {
     lines.push(`## Additional constraints / notes`);
     lines.push(args.notes.trim());
@@ -514617,6 +514629,23 @@ function renderCriticPrompt(inputs) {
   lines.push(`9. **Unresolved failures**: stems with attempts ≥ 3 that never cleared.`);
   lines.push(`10. **Generic-vs-specific drift**: code claims to be generic but contains`);
   lines.push(`    framework- or vendor-specific keywords.`);
+  lines.push(`11. **Backtest evidence for new code (CRITICAL — recurring failure mode)**: For any`);
+  lines.push(`    NEWLY ADDED tool, module, public function, or prompt-generation feature,`);
+  lines.push(`    the implementer MUST have invoked the new code with realistic input and`);
+  lines.push(`    inspected the actual rendered/returned output. Unit-test pass is necessary`);
+  lines.push(`    but NOT sufficient — unit tests verify the implementer's own assertions,`);
+  lines.push(`    not whether the output is human-usable. Look for evidence in the recent`);
+  lines.push(`    tool calls of: a node/python/shell invocation that exercises the new code`);
+  lines.push(`    with realistic args, OR a manual-inspection step (cat / file_read of the`);
+  lines.push(`    output, head/tail of generated content). If you find ONLY unit-test`);
+  lines.push(`    evidence and no realistic-invocation evidence for new code, this is a`);
+  lines.push(`    \`request_changes\` regardless of test count. Tests passing while output is`);
+  lines.push(`    nonsense is a recurring class of negligence this gate exists to catch.`);
+  lines.push(`12. **Empty-section / contradiction sweep**: For any output the implementer`);
+  lines.push(`    generates programmatically (prompts, configs, docs), check for sections`);
+  lines.push(`    that say "(none specified)" / "(no items)" / "(empty)" alongside framing`);
+  lines.push(`    text that asserts the section IS load-bearing. These contradictions`);
+  lines.push(`    indicate the generator wasn't tested with the empty / minimal-input case.`);
   lines.push(``);
   lines.push(`Do NOT flag:`);
   lines.push(`- Stylistic choices (formatting, naming) unless they hide a real bug.`);
@@ -514910,6 +514939,472 @@ var init_backward_pass_runner = __esm({
   }
 });
 
+// packages/orchestrator/dist/stuck-meta-analyzer.js
+function renderAnalyzerPrompt(inputs) {
+  const lines = [];
+  lines.push(`# STUCK-STATE META-ANALYSIS`);
+  lines.push(``);
+  lines.push(`You are a META-ANALYSIS sub-agent. Another agent (the implementer) is`);
+  lines.push(`stuck in an unproductive tool-call loop and the runtime's structural`);
+  lines.push(`stuck-detector has fired. Your job: examine the loop + state below and`);
+  lines.push(`return ONE specific next tool call that will unblock the implementer.`);
+  lines.push(``);
+  lines.push(`## Context`);
+  lines.push(`Goal: ${inputs.goal.slice(0, 600)}`);
+  lines.push(`Working directory: ${inputs.workingDir}`);
+  lines.push(`Trigger: ${inputs.triggerReason}  (turn ${inputs.turn})`);
+  if (inputs.workspaceSummary) {
+    lines.push(``);
+    lines.push(`## Workspace summary`);
+    lines.push(inputs.workspaceSummary.slice(0, 1500));
+  }
+  lines.push(``);
+  lines.push(`## Plan status (reconciled against disk)`);
+  if (inputs.planStatus.length === 0) {
+    lines.push(`(no plan items declared)`);
+  } else {
+    for (const t2 of inputs.planStatus.slice(0, 12)) {
+      lines.push(`  [${t2.reconciled}] ${t2.content.slice(0, 100)} — ${t2.rationale.slice(0, 120)}`);
+    }
+  }
+  lines.push(``);
+  lines.push(`## Recent unresolved failures`);
+  if (inputs.recentFailures.length === 0) {
+    lines.push(`(none)`);
+  } else {
+    for (const f2 of inputs.recentFailures.slice(0, 5)) {
+      lines.push(`  - ${f2.stem} (attempts=${f2.attempts}): ${f2.preview.slice(0, 200)}`);
+    }
+  }
+  lines.push(``);
+  lines.push(`## The loop pattern (recent tool calls, oldest first)`);
+  if (inputs.recentToolCalls.length === 0) {
+    lines.push(`(no recent calls)`);
+  } else {
+    const recent = inputs.recentToolCalls.slice(-30);
+    for (const c9 of recent) {
+      const status = c9.success === false ? "FAIL" : "OK";
+      const args = c9.argsKey ? ` ${c9.argsKey}` : "";
+      const preview = c9.outputPreview ? ` → "${c9.outputPreview.slice(0, 100)}"` : "";
+      lines.push(`  ${c9.name}${args} [${status}]${preview}`);
+    }
+  }
+  lines.push(``);
+  if (inputs.availableTools && inputs.availableTools.length > 0) {
+    lines.push(`## Tools available to the implementer`);
+    lines.push(inputs.availableTools.slice(0, 60).join(", "));
+    lines.push(``);
+  }
+  lines.push(`## Your task`);
+  lines.push(``);
+  lines.push(`Diagnose the loop in 1 sentence (what specific category of un-`);
+  lines.push(`productive activity is happening?). Then emit ONE concrete next`);
+  lines.push(`tool call the implementer should make. Do NOT emit a list of`);
+  lines.push(`alternatives. Do NOT emit categories like "PRODUCE" or "EDIT" —`);
+  lines.push(`emit the actual tool name and the actual args (with concrete`);
+  lines.push(`paths and a content seed when applicable).`);
+  lines.push(``);
+  lines.push(`Universal rules for the directive:`);
+  lines.push(`- Use only tools the implementer has access to.`);
+  lines.push(`- The next_action MUST produce new state on disk (file_write,`);
+  lines.push(`  file_edit, batch_edit, file_patch, shell mutation, or similar).`);
+  lines.push(`  If the loop is read-heavy, the unblocker is virtually always a`);
+  lines.push(`  write of some kind.`);
+  lines.push(`- The args_seed must contain enough content that the implementer`);
+  lines.push(`  can apply or refine it directly. For file writes, the args_seed`);
+  lines.push(`  MUST include a 'content' field with at least skeleton text`);
+  lines.push(`  (function signatures, imports, key structures). For shell calls,`);
+  lines.push(`  include the exact command.`);
+  lines.push(`- The anti_pattern must name the SPECIFIC repeated activity to stop`);
+  lines.push(`  (e.g. "list_directory of /tests/* repeatedly with no writes"),`);
+  lines.push(`  not just "stop being stuck".`);
+  lines.push(`- The verification must be a concrete check (a tool call OR an`);
+  lines.push(`  expected state change) the implementer runs after the action.`);
+  lines.push(``);
+  lines.push(`## Output format`);
+  lines.push(``);
+  lines.push(`Reason briefly (1-3 sentences) about the loop, then emit a SINGLE`);
+  lines.push(`JSON code block with this exact shape:`);
+  lines.push(``);
+  lines.push("```json");
+  lines.push(`{`);
+  lines.push(`  "diagnosis": "<1-sentence root cause>",`);
+  lines.push(`  "next_action": {`);
+  lines.push(`    "tool": "<exact tool name from the available list>",`);
+  lines.push(`    "args_seed": { /* concrete args; for writes, include 'path' + 'content' seed */ },`);
+  lines.push(`    "rationale": "<why this unblocks>"`);
+  lines.push(`  },`);
+  lines.push(`  "anti_pattern": "<the specific loop activity to stop>",`);
+  lines.push(`  "verification": "<concrete check after the action>"`);
+  lines.push(`}`);
+  lines.push("```");
+  lines.push(``);
+  lines.push(`Be SPECIFIC. Vague directives are useless to a stuck implementer.`);
+  return lines.join("\n");
+}
+function parseDirective(rawResponse) {
+  const fallback = (msg) => ({
+    diagnosis: `(meta-analyzer parse failed: ${msg})`,
+    next_action: {
+      tool: "(unknown)",
+      args_seed: {},
+      rationale: "Parser fell back; directive should not be injected."
+    },
+    anti_pattern: "(unknown)",
+    verification: "(unknown)",
+    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 diagnosis = typeof parsed.diagnosis === "string" && parsed.diagnosis.trim().length > 0 ? parsed.diagnosis.slice(0, 400) : "";
+  const next = parsed.next_action;
+  const tool = next && typeof next.tool === "string" ? next.tool.trim() : "";
+  const args_seed = next && typeof next.args_seed === "object" && next.args_seed !== null ? next.args_seed : {};
+  const rationale = next && typeof next.rationale === "string" ? next.rationale.slice(0, 400) : "";
+  const anti_pattern = typeof parsed.anti_pattern === "string" ? parsed.anti_pattern.slice(0, 400) : "";
+  const verification = typeof parsed.verification === "string" ? parsed.verification.slice(0, 400) : "";
+  if (!diagnosis || !tool || !anti_pattern || !verification) {
+    return fallback("missing required fields");
+  }
+  return {
+    diagnosis,
+    next_action: { tool, args_seed, rationale },
+    anti_pattern,
+    verification,
+    raw: rawResponse
+  };
+}
+function renderDirectiveAsMessage(d2) {
+  if (d2.parseFallback) {
+    return "";
+  }
+  const lines = [];
+  lines.push(`[STUCK-STATE META-ANALYZER — REG-49]`);
+  lines.push(``);
+  lines.push(`A meta-analyzer sub-agent reviewed the recent tool-call pattern, the`);
+  lines.push(`current world state, and the plan; it produced a single concrete`);
+  lines.push(`unblocking action for you to take.`);
+  lines.push(``);
+  lines.push(`DIAGNOSIS: ${d2.diagnosis}`);
+  lines.push(``);
+  lines.push(`STOP DOING (anti-pattern): ${d2.anti_pattern}`);
+  lines.push(``);
+  lines.push(`DO NEXT:`);
+  lines.push(`  Tool: ${d2.next_action.tool}`);
+  const argsJson = JSON.stringify(d2.next_action.args_seed, null, 2);
+  lines.push(`  Args:`);
+  for (const ln of argsJson.split("\n"))
+    lines.push(`    ${ln}`);
+  lines.push(`  Rationale: ${d2.next_action.rationale}`);
+  lines.push(``);
+  lines.push(`AFTER THE ACTION, verify with: ${d2.verification}`);
+  lines.push(``);
+  lines.push(`This directive comes from a meta-analysis of YOUR recent activity. The`);
+  lines.push(`args above are a SEED — refine them as needed (filenames, content) but`);
+  lines.push(`emit a tool call of this kind on your next response. Do NOT emit`);
+  lines.push(`another instance of the anti-pattern; that loop has been blocked.`);
+  return lines.join("\n");
+}
+async function runStuckAnalyzer(opts) {
+  const startMs = Date.now();
+  const prompt = renderAnalyzerPrompt(opts.inputs);
+  const promptBytes = Buffer.byteLength(prompt, "utf-8");
+  let raw = "";
+  try {
+    raw = await opts.callable(prompt);
+  } catch (e2) {
+    raw = "";
+  }
+  const responseBytes = Buffer.byteLength(raw, "utf-8");
+  const directive = parseDirective(raw);
+  const injection = renderDirectiveAsMessage(directive);
+  return {
+    directive,
+    injection,
+    promptBytes,
+    responseBytes,
+    durationMs: Date.now() - startMs
+  };
+}
+var init_stuck_meta_analyzer = __esm({
+  "packages/orchestrator/dist/stuck-meta-analyzer.js"() {
+    "use strict";
+  }
+});
+
+// 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);
@@ -520475,7 +520970,7 @@ function executeHook(hook, env2 = {}) {
       maxBuffer: 1024 * 1024
       // 1MB
     });
-    const directive = parseDirective(output);
+    const directive = parseDirective2(output);
     return {
       success: true,
       output: output.trim(),
@@ -520493,7 +520988,7 @@ function executeHook(hook, env2 = {}) {
     };
   }
 }
-function parseDirective(output) {
+function parseDirective2(output) {
   const lines = output.split("\n");
   for (const line of lines) {
     const trimmed = line.trim();
@@ -521149,6 +521644,8 @@ var init_agenticRunner = __esm({
     init_world_state_regenerator();
     init_backward_pass_runner();
     init_world_state_plan_reconciler();
+    init_stuck_meta_analyzer();
+    init_problem_frame_validator();
     init_pressure_gate();
     init_dist5();
     init_dist7();
@@ -521349,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.
@@ -524025,8 +524537,318 @@ ${_staleSamples.join("\n")}` : ``,
                   content: `REG-44 STUCK detector fired at turn ${turn} — triggers=[${_trigLabels.join(",")}], reads=${_readCount}, mutations=${_mutationCount}, stale=${_staleCount}, window=${_windowCalls.length}`,
                   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) {
+                    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 = _windowCalls.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: "(reconcile context unavailable here; 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: `reg44-${_trigLabels[0] || "unknown"}`,
+                        recentToolCalls: _smaCalls,
+                        planStatus: _smaPlan,
+                        recentFailures: _smaFailures,
+                        workspaceSummary: void 0,
+                        // world-state regen owns this; analyzer infers from calls
+                        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 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 at turn ${turn} — falling back to REG-44 abstract halt only`,
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                      }
+                    }).catch((_e) => {
+                      this.emit({
+                        type: "status",
+                        content: `REG-49 stuck-meta-analyzer threw: ${_e instanceof Error ? _e.message : String(_e)} (non-fatal)`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    });
+                  }
+                } catch (_e) {
+                }
+              }
+            }
+          }
+          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;
@@ -526063,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.498",
+  "version": "0.187.500",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.498",
+      "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.498",
+  "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",