open-agents-ai 0.187.480 → 0.187.481

package/dist/index.js

@@ -512230,6 +512230,40 @@ 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";
@@ -512265,22 +512299,40 @@ 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
+    attempts: (input.priorAttempts ?? 0) + 1,
+    subject,
+    errorSignatures: sigs
   };
 }
 function renderReflectionMessage(r2) {
-  return [
-    `[REFLECTION — your last attempt of \`${r2.attempted}\` failed (turn ${r2.turn}, ${r2.attempts} attempt${r2.attempts === 1 ? "" : "s"} so far).`,
-    `Last error: "${r2.wentWrong}"`,
-    `Hypothesis: ${r2.hypothesis}`,
-    `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.]`
-  ].join("\n");
+  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({
@@ -518676,6 +518728,14 @@ var init_agenticRunner = __esm({
       _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)
@@ -520820,6 +520880,36 @@ TASK: ${task}` : task;
           }
           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 });
@@ -521695,7 +521785,12 @@ ${memoryLines.join("\n")}`
                   const _reflEntry = this._failureReflections.get(_reflStem);
                   if (_reflEntry) {
                     this._reflectionsInjectedThisTurn.add(_reflStem);
-                    pushSoftInjection("system", renderReflectionMessage(_reflEntry));
+                    const _isEscalation = _reflEntry.attempts >= 3 || (_reflEntry.errorSignatures?.size ?? 0) >= 3;
+                    if (_isEscalation) {
+                      messages2.push({ role: "system", content: renderReflectionMessage(_reflEntry) });
+                    } else {
+                      pushSoftInjection("system", renderReflectionMessage(_reflEntry));
+                    }
                   }
                 }
               }
@@ -522137,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;
@@ -522196,7 +522306,10 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                   args: tc.arguments ?? {},
                   errorText: _refErr,
                   turn,
-                  priorAttempts: _prior?.attempts ?? 0
+                  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) {

package/npm-shrinkwrap.json

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