open-agents-ai 0.187.479 → 0.187.481

package/dist/index.js

@@ -512229,6 +512229,139 @@ var init_critic = __esm({
   }
 });
 
+// packages/orchestrator/dist/reflection.js
+function extractSubject(errorText) {
+  if (!errorText)
+    return null;
+  const PATTERNS = [
+    // Quoted module / type / symbol after recognizable phrases
+    /cannot find (?:module|name|type|symbol|reference|file|namespace)\s+['"`]([^'"`\n]{1,80})['"`]/i,
+    /(?:undefined|unresolved)\s+(?:reference|import|symbol)\s+(?:to\s+)?['"`]([^'"`\n]{1,80})['"`]/i,
+    /['"`]([^'"`\n]{1,80})['"`]\s+is not (?:a function|defined|assignable)/i,
+    /is not assignable to (?:type|parameter)\s+['"`]([^'"`\n]{1,80})['"`]/i,
+    /\btype\s+['"`]([^'"`\n]{1,80})['"`]\s+is not assignable/i,
+    /\benoent\b[^'"`\n]*['"`]([^'"`\n]{1,200})['"`]/i,
+    /\b(?:permission denied|eacces)\b[^'"`\n]*['"`]([^'"`\n]{1,200})['"`]/i,
+    /no such file or directory[^'"`\n]*['"`]([^'"`\n]{1,200})['"`]/i,
+    /\b([a-z_][a-z0-9_]*)\s+is not defined\b/i,
+    /\b(?:property|method|attribute)\s+['"`]([^'"`\n]{1,80})['"`]\s+(?:does not exist|not found)/i,
+    /\bcannot resolve\s+['"`]?([^'"`\n\s]{1,120})['"`]?/i,
+    /\bmodule not found:?\s+['"`]?([^'"`\n\s]{1,120})['"`]?/i
+  ];
+  for (const re of PATTERNS) {
+    const m2 = errorText.match(re);
+    if (m2 && m2[1]) {
+      const subj = m2[1].trim();
+      if (subj.length > 0 && subj.length <= 200)
+        return subj;
+    }
+  }
+  return null;
+}
+function errorSignature(errorText) {
+  if (!errorText)
+    return "";
+  const norm = errorText.replace(/\r?\n/g, " ").replace(/\s+/g, " ").replace(/^\s*error:\s*/i, "").trim().toLowerCase();
+  return norm.slice(0, 50);
+}
+function categorizeError(errorText) {
+  if (!errorText)
+    return "unknown";
+  for (const { category, re } of CATEGORY_PATTERNS) {
+    if (re.test(errorText))
+      return category;
+  }
+  return "unknown";
+}
+function buildStem(toolName, args) {
+  if (!args || Object.keys(args).length === 0)
+    return toolName;
+  const entries = Object.entries(args).sort(([a2], [b]) => a2.localeCompare(b));
+  const first2 = entries[0];
+  const v = typeof first2[1] === "string" ? first2[1] : JSON.stringify(first2[1]);
+  return `${toolName}:${first2[0]}=${v.slice(0, 60)}`;
+}
+function firstSignalLine(errorText) {
+  if (!errorText)
+    return "";
+  const lines = errorText.split(/\r?\n/);
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line)
+      continue;
+    if (line === "Error:" || line === "error:")
+      continue;
+    return line.slice(0, 200);
+  }
+  return errorText.slice(0, 200);
+}
+function synthesizeReflection(input) {
+  const category = categorizeError(input.errorText);
+  const stem = buildStem(input.toolName, input.args);
+  const argPreview = JSON.stringify(input.args ?? {}).slice(0, 120);
+  const subject = extractSubject(input.errorText);
+  const sigs = new Set(input.priorErrorSignatures ?? []);
+  const sig = errorSignature(input.errorText);
+  if (sig)
+    sigs.add(sig);
+  return {
+    stem,
+    attempted: `${input.toolName}(${argPreview})`,
+    wentWrong: firstSignalLine(input.errorText),
+    hypothesis: HYPOTHESES[category],
+    turn: input.turn,
+    attempts: (input.priorAttempts ?? 0) + 1,
+    subject,
+    errorSignatures: sigs
+  };
+}
+function renderReflectionMessage(r2) {
+  const lines = [];
+  const distinctErrors = r2.errorSignatures?.size ?? 0;
+  if (distinctErrors >= 3) {
+    lines.push(`[ERROR-SHIFT DETECTED — ${distinctErrors} DIFFERENT errors have emerged for \`${r2.attempted}\` across ${r2.attempts} attempts.`, `Each "fix" you've made is moving the bug somewhere new instead of resolving it. Your understanding of the failure is wrong.`, `STOP fixing. Re-read the FIRST error you saw on this call and trace exactly what each subsequent fix changed. Do NOT make another change until you can explain why the next change addresses the root.]`, ``);
+  }
+  lines.push(`[REFLECTION — your last attempt of \`${r2.attempted}\` failed (turn ${r2.turn}, ${r2.attempts} attempt${r2.attempts === 1 ? "" : "s"} so far).`);
+  lines.push(`Last error: "${r2.wentWrong}"`);
+  lines.push(`Hypothesis: ${r2.hypothesis}`);
+  if (r2.subject) {
+    lines.push(`Specifically: verify \`${r2.subject}\` exists at the expected location with the smallest possible read command before retrying.`);
+  }
+  if (r2.attempts >= 3) {
+    lines.push(``);
+    lines.push(`[FORCED — your intrinsic knowledge has not resolved this in ${r2.attempts} attempts. Your NEXT call MUST be \`web_search("${r2.wentWrong.replace(/"/g, '\\"').slice(0, 120)}")\` (or close-equivalent). Read the top result before making another fix attempt.]`);
+  }
+  lines.push(`VERIFY this hypothesis with a single small command BEFORE retrying the same tool. If you retry without verifying, you will likely fail the same way.]`);
+  return lines.join("\n");
+}
+var CATEGORY_PATTERNS, HYPOTHESES;
+var init_reflection = __esm({
+  "packages/orchestrator/dist/reflection.js"() {
+    "use strict";
+    CATEGORY_PATTERNS = [
+      { category: "permission_denied", re: /\b(permission denied|eacces|access denied|operation not permitted|forbidden)\b/i },
+      { category: "type_or_reference_error", re: /\b(type error|cannot find module|cannot find name|is not (a function|defined|assignable)|undefined reference|unresolved (import|reference)|missing required)\b/i },
+      { category: "connection_refused", re: /\b(connection refused|econnrefused|connection reset|econnreset|host unreachable|getaddrinfo|enotfound)\b/i },
+      { category: "timeout", re: /\b(timeout|timed out|etimedout|deadline exceeded)\b/i },
+      { category: "syntax_error", re: /\b(syntax error|parse error|unexpected token|unexpected end of (input|json)|malformed)\b/i },
+      { category: "not_found", re: /\b(not found|enoent|no such file|cannot find|does not exist|404)\b/i },
+      // Use [1-9]\d* so multi-digit non-zero codes (e.g. "return code 127") match —
+      // the prior [^0] only matched a single character and failed on multi-digit.
+      { category: "nonzero_exit", re: /\b(exit code [1-9]\d*|exit status [1-9]\d*|command failed|exit code: ?[1-9]\d*|return code [1-9]\d*)\b/i }
+    ];
+    HYPOTHESES = {
+      permission_denied: "permissions issue — check ownership and mode of the target; you may need to operate on a writeable location",
+      not_found: "the named resource doesn't exist at the expected location — verify the path/name with a single-line list before retrying",
+      connection_refused: "remote service is unreachable — verify it's running and reachable before retrying with the same address",
+      timeout: "operation took too long — reduce scope (smaller batch, fewer items) or verify the service is healthy",
+      syntax_error: "malformed input — re-read the surrounding context; the input you produced doesn't match what the consumer expects",
+      type_or_reference_error: "a name, type, or import doesn't resolve — verify the reference matches what's defined; do not guess at the symbol",
+      nonzero_exit: "the command exited with a failure code — read the FULL error output and verify args + prerequisites before retrying",
+      unknown: "re-read the full error message and identify the most likely cause; verify your assumption with a single small command before retrying"
+    };
+  }
+});
+
 // packages/orchestrator/dist/pressure-gate.js
 function detectPressure(message2) {
   const hasProfanity = PRESSURE_SIGNALS.test(message2);
@@ -518460,6 +518593,7 @@ var init_agenticRunner = __esm({
     init_personality();
     init_promptLoader();
     init_critic();
+    init_reflection();
     init_pressure_gate();
     init_dist5();
     init_dist7();
@@ -518586,6 +518720,22 @@ var init_agenticRunner = __esm({
       _errorPatterns = /* @__PURE__ */ new Map();
       _errorGuidanceInjected = /* @__PURE__ */ new Set();
       // prevent duplicate injection per turn
+      // REG-26 (Patch C): Reflexion-style structured failure memory. Indexed by
+      // fingerprint stem (tool + first arg, truncated). When the agent retries a
+      // tool with a stem matching a stored reflection, surface "what was tried,
+      // what went wrong, hypothesis to verify" as a system message before the
+      // dispatch — generic across all stacks. See packages/orchestrator/src/reflection.ts.
+      _failureReflections = /* @__PURE__ */ new Map();
+      _reflectionsInjectedThisTurn = /* @__PURE__ */ new Set();
+      // prevent duplicate inject per turn
+      // REG-30: one-shot per-turn typecheck-vs-build hint
+      _typecheckHintInjectedThisTurn = false;
+      // REG-31: track most recent successful build-shaped shell so the turn-start
+      // positive-completion check knows when the agent has validated its work.
+      _lastBuildSuccessTurn = -1;
+      _lastBuildSuccessCommand = "";
+      // REG-31: prevent duplicate completion suggestion per turn
+      _completionPromptInjectedThisTurn = false;
       // ── WO-AM-01/04/10: Associative memory stores ──
       // Episode store: every tool call → persistent episode with importance + decay
       // Temporal KG: entities + relations with temporal validity (valid_from/valid_until)
@@ -520729,6 +520879,37 @@ TASK: ${task}` : task;
             break;
           }
           injectionsThisTurn = 0;
+          this._reflectionsInjectedThisTurn.clear();
+          this._typecheckHintInjectedThisTurn = false;
+          this._completionPromptInjectedThisTurn = false;
+          try {
+            const _todos = this.readSessionTodos() || [];
+            if (_todos.length > 0 && _todos.every((t2) => t2.status === "completed") && this._lastBuildSuccessTurn >= 0 && turn - this._lastBuildSuccessTurn <= 8 && !this._completionPromptInjectedThisTurn) {
+              this._completionPromptInjectedThisTurn = true;
+              messages2.push({
+                role: "system",
+                content: [
+                  `[ALL TODOS COMPLETED + LAST VALIDATION PASSED — TIME TO DECLARE DONE]`,
+                  ``,
+                  `Status:`,
+                  `  • Todos: ${_todos.length}/${_todos.length} completed`,
+                  `  • Last successful validation: \`${this._lastBuildSuccessCommand.slice(0, 120)}\` (turn ${this._lastBuildSuccessTurn}, ${turn - this._lastBuildSuccessTurn} turn(s) ago)`,
+                  ``,
+                  `Your work is done. Call task_complete now with a concise summary of what was implemented:`,
+                  ``,
+                  `  task_complete({ summary: "<one-paragraph description of what was built and verified>" })`,
+                  ``,
+                  `Do NOT add more polish, more files, or more validation. The plan is complete; the validation passed; the spec is implemented. Calling task_complete is the correct next action.`
+                ].join("\n")
+              });
+              this.emit({
+                type: "status",
+                content: `REG-31: positive completion signal injected (todos all done, last build success ${turn - this._lastBuildSuccessTurn}t ago)`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          } catch {
+          }
           while (deferredSoftInjections.length > 0 && injectionsThisTurn < INJECTION_BUDGET_SOFT) {
             const next = deferredSoftInjections.shift();
             messages2.push({ role: next.role, content: next.content });
@@ -521598,6 +521779,21 @@ ${memoryLines.join("\n")}`
               if (observerRedundantBlock) {
                 this._littlemanRedundantBlocks.delete(toolFingerprint);
               }
+              {
+                const _reflStem = buildStem(tc.name, tc.arguments ?? {});
+                if (!this._reflectionsInjectedThisTurn.has(_reflStem)) {
+                  const _reflEntry = this._failureReflections.get(_reflStem);
+                  if (_reflEntry) {
+                    this._reflectionsInjectedThisTurn.add(_reflStem);
+                    const _isEscalation = _reflEntry.attempts >= 3 || (_reflEntry.errorSignatures?.size ?? 0) >= 3;
+                    if (_isEscalation) {
+                      messages2.push({ role: "system", content: renderReflectionMessage(_reflEntry) });
+                    } else {
+                      pushSoftInjection("system", renderReflectionMessage(_reflEntry));
+                    }
+                  }
+                }
+              }
               const criticDecision = evaluate({
                 proposedCall: { tool: tc.name, args: tc.arguments ?? {} },
                 fingerprint: toolFingerprint,
@@ -521624,6 +521820,11 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
               }
               if (criticDecision.decision === "force_progress_block") {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
+                const _existingFp = recentToolResults.get(toolFingerprint);
+                if (_existingFp !== void 0) {
+                  recentToolResults.delete(toolFingerprint);
+                  recentToolResults.set(toolFingerprint, _existingFp);
+                }
                 this.emit({ type: "tool_call", toolName: tc.name, toolArgs: tc.arguments, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
                 this.emit({
                   type: "tool_result",
@@ -521637,6 +521838,11 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
               }
               if (criticDecision.decision === "serve_cached") {
                 dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
+                const _existingFp = recentToolResults.get(toolFingerprint);
+                if (_existingFp !== void 0) {
+                  recentToolResults.delete(toolFingerprint);
+                  recentToolResults.set(toolFingerprint, _existingFp);
+                }
                 this.emit({
                   type: "tool_call",
                   toolName: tc.name,
@@ -522026,6 +522232,21 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                 const lastLog = toolCallLog[toolCallLog.length - 1];
                 if (lastLog)
                   lastLog.success = true;
+                if (tc.name === "shell") {
+                  const _shellCmd = String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? "");
+                  const _typecheckOnly = /\b(--noEmit|--dry-run|--check\b|\bmypy\b|\bruff check\b|\bcargo check\b|\bstylelint --check\b|\bpylint\b(?!.*--exit-zero))\b/i.test(_shellCmd);
+                  if (_typecheckOnly && !this._typecheckHintInjectedThisTurn) {
+                    this._typecheckHintInjectedThisTurn = true;
+                    pushSoftInjection("system", `[Typecheck PASSED but does NOT mean the project builds or runs. Typecheck only validates declarations, not runtime behavior, plugin pipelines, or build-time transformations. Before declaring this work complete, run the actual build/run command for the project (the verb is typically "build", "run", "start", or "compile" — context-specific to your stack).]`);
+                  }
+                }
+                if (tc.name === "shell") {
+                  const _shellCmd2 = String(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? "");
+                  if (/\b(build|test|run\b|start\b|serve\b|verify|check)\b/i.test(_shellCmd2)) {
+                    this._lastBuildSuccessTurn = turn;
+                    this._lastBuildSuccessCommand = _shellCmd2.slice(0, 200);
+                  }
+                }
                 if (["file_write", "file_edit", "file_patch", "batch_edit"].includes(tc.name) && this._patchHistoryStore) {
                   try {
                     const filePath2 = tc.arguments?.path || tc.arguments?.file_path;
@@ -522062,6 +522283,8 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
               }
               if (result.success) {
                 this._recentFailures = this._recentFailures.filter((f2) => f2.fingerprint !== toolFingerprint);
+                const _stem = buildStem(tc.name, tc.arguments ?? {});
+                this._failureReflections.delete(_stem);
               }
               if (!result.success) {
                 this._recentFailures.push({
@@ -522075,6 +522298,25 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                 if (this._recentFailures.length > 8) {
                   this._recentFailures = this._recentFailures.slice(-8);
                 }
+                const _refStem = buildStem(tc.name, tc.arguments ?? {});
+                const _prior = this._failureReflections.get(_refStem);
+                const _refErr = (result.error ?? result.output ?? "").toString();
+                const _entry = synthesizeReflection({
+                  toolName: tc.name,
+                  args: tc.arguments ?? {},
+                  errorText: _refErr,
+                  turn,
+                  priorAttempts: _prior?.attempts ?? 0,
+                  // REG-27: carry forward distinct error-signature set so the
+                  // agent's renderer can detect error-shift (3+ different errors)
+                  priorErrorSignatures: _prior?.errorSignatures
+                });
+                this._failureReflections.set(_refStem, _entry);
+                if (this._failureReflections.size > 32) {
+                  const oldestKey = this._failureReflections.keys().next().value;
+                  if (oldestKey !== void 0)
+                    this._failureReflections.delete(oldestKey);
+                }
               }
               if (!result.success && tc.name === "shell" && /\[PERMISSION_ERROR\]/.test(result.error ?? "")) {
                 this.emit({
@@ -522340,9 +522582,35 @@ ${sr.result.output}`;
               for (const batch2 of batches) {
                 if (this.aborted)
                   break;
+                const batchFingerprintFirstId = /* @__PURE__ */ new Map();
+                const batchInFlight = /* @__PURE__ */ new Map();
+                const buildBatchFp = (call) => {
+                  const args = call.args ?? {};
+                  const argsKey = Object.entries(args).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 160) : JSON.stringify(v).slice(0, 160)}`).join(",");
+                  return `${call.name}:${argsKey}`;
+                };
+                for (const call of batch2.calls) {
+                  const fp = buildBatchFp(call);
+                  if (!batchFingerprintFirstId.has(fp)) {
+                    batchFingerprintFirstId.set(fp, call.id);
+                  }
+                }
                 const results = await executeBatch(batch2, async (call) => {
                   const originalTc = rawToolCalls.find((tc) => tc.id === call.id);
-                  return executeSingle(originalTc);
+                  const fp = buildBatchFp(call);
+                  const firstId = batchFingerprintFirstId.get(fp);
+                  if (firstId !== void 0 && call.id !== void 0 && firstId !== call.id) {
+                    const inflight = batchInFlight.get(fp);
+                    if (inflight) {
+                      const cloned = await inflight;
+                      if (!cloned)
+                        return null;
+                      return { tc: { ...cloned.tc, id: call.id }, output: cloned.output };
+                    }
+                  }
+                  const promise = executeSingle(originalTc);
+                  batchInFlight.set(fp, promise);
+                  return promise;
                 }, 5);
                 for (const r2 of results) {
                   if (r2) {

package/npm-shrinkwrap.json

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

package/package.json

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