open-agents-ai 0.187.498 → 0.187.499

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,221 @@ 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/pressure-gate.js
 function detectPressure(message2) {
   const hasProfanity = PRESSURE_SIGNALS.test(message2);
@@ -520475,7 +520719,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 +520737,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 +521393,7 @@ var init_agenticRunner = __esm({
     init_world_state_regenerator();
     init_backward_pass_runner();
     init_world_state_plan_reconciler();
+    init_stuck_meta_analyzer();
     init_pressure_gate();
     init_dist5();
     init_dist7();
@@ -524025,6 +524270,91 @@ ${_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());
+                    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) {
+                }
               }
             }
           }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.498",
+  "version": "0.187.499",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.498",
+      "version": "0.187.499",
       "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.499",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",