open-agents-ai 0.187.153 → 0.187.154

package/dist/index.js

@@ -265520,8 +265520,19 @@ ${top.map((t2) => `- ${t2.name}: ${t2.desc}`).join("\n")}`
           const turnBudget = turnTier === "small" ? 5 : turnTier === "medium" ? 8 : 0;
           if (turnBudget > 0 && turn > 0 && turn % turnBudget === 0) {
             const repetitionRatio = this.detectRepetition(toolCallLog);
+            const recentToolResults2 = messages2.slice(-16).filter((m2) => m2.role === "tool" && typeof m2.content === "string");
+            const recentErrors = recentToolResults2.filter((m2) => /error|failed|not found|permission denied/i.test(String(m2.content))).length;
+            const errorRatio = recentToolResults2.length > 0 ? recentErrors / recentToolResults2.length : 0;
             const noProgress = this._taskState.completedSteps.length === 0 && turn >= turnBudget;
             const isLooping = repetitionRatio > 0.4;
+            const highArousal = errorRatio > 0.5 || isLooping;
+            if (highArousal && !isLooping && !noProgress) {
+              this.pendingUserMessages.push(`[COGNITIVE STATE: HIGH AROUSAL] Recent error rate is ${Math.round(errorRatio * 100)}%. Your current approach may be hitting a wall. Consider:
+1. Read related files you haven't examined yet
+2. Search for similar patterns in the codebase
+3. Check if your assumptions about the API/framework are correct
+State what you've learned from the errors before trying again.`);
+            }
             if (isLooping || noProgress) {
               const progress = this._taskState.completedSteps.slice(-3).join("; ");
               const failures = this._taskState.failedApproaches.slice(-2).join("; ");
@@ -265795,7 +265806,7 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
               const toolStart = performance.now();
               toolCallCount++;
               const argsKey = Object.entries(tc.arguments ?? {}).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 80) : JSON.stringify(v)}`).join(",");
-              toolCallLog.push({ name: tc.name, argsKey });
+              toolCallLog.push({ name: tc.name, argsKey, turn, timestampMs: Date.now() });
               const budgetRemaining = toolCallBudget.get(tc.name);
               if (budgetRemaining !== void 0) {
                 if (budgetRemaining <= 0) {
@@ -266629,6 +266640,95 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
           success: completed,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         });
+        try {
+          const extractPaths = (entries, toolNames) => {
+            return [...new Set(entries.filter((tc) => toolNames.includes(tc.name)).map((tc) => {
+              const pathMatch = tc.argsKey.match(/path=([^,]+)/);
+              return pathMatch?.[1] || "";
+            }).filter(Boolean))];
+          };
+          const consolidation = {
+            sessionId: this._sessionId,
+            task: task.slice(0, 500),
+            outcome: completed ? "success" : this.aborted ? "aborted" : "timeout",
+            turns: messages2.filter((m2) => m2.role === "assistant").length,
+            toolsUsed: [...new Set(toolCallLog.map((tc) => tc.name))],
+            filesModified: extractPaths(toolCallLog, ["file_write", "file_edit", "file_patch", "batch_edit"]),
+            filesRead: extractPaths(toolCallLog, ["file_read"]),
+            totalToolCalls: toolCallLog.length,
+            durationMs,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          const fs4 = await import("node:fs");
+          const path5 = await import("node:path");
+          const consolidDir = path5.join(process.cwd(), ".oa", "consolidations");
+          fs4.mkdirSync(consolidDir, { recursive: true });
+          fs4.writeFileSync(path5.join(consolidDir, `${this._sessionId}.json`), JSON.stringify(consolidation, null, 2));
+          const provenanceDir = path5.join(process.cwd(), ".oa", "provenance");
+          fs4.mkdirSync(provenanceDir, { recursive: true });
+          const provenanceGraph = {
+            sessionId: this._sessionId,
+            task: task.slice(0, 500),
+            outcome: consolidation.outcome,
+            timestamp: consolidation.timestamp,
+            // Full action trace — every tool call with sequence ordering
+            actions: toolCallLog.map((tc, idx) => ({
+              id: `${this._sessionId}-${idx}`,
+              tool: tc.name,
+              args_fingerprint: tc.argsKey.slice(0, 200),
+              turn: tc.turn,
+              timestamp_ms: tc.timestampMs,
+              // Causal links: which earlier action informed this one?
+              // Heuristic: if this action reads a file that a previous action wrote, they're linked
+              caused_by: toolCallLog.slice(0, idx).filter((prev) => {
+                const prevPath = prev.argsKey.match(/path=([^,]+)/)?.[1];
+                const thisPath = tc.argsKey.match(/path=([^,]+)/)?.[1];
+                return prevPath && thisPath && prevPath === thisPath && ["file_write", "file_edit"].includes(prev.name) && ["file_read", "grep_search"].includes(tc.name);
+              }).map((_, prevIdx) => `${this._sessionId}-${prevIdx}`)
+            })),
+            // File dependency graph: which files were read before being modified?
+            file_provenance: (() => {
+              const readTurns = /* @__PURE__ */ new Map();
+              const writeTurns = /* @__PURE__ */ new Map();
+              for (const tc of toolCallLog) {
+                const filePath = tc.argsKey.match(/path=([^,]+)/)?.[1];
+                if (!filePath)
+                  continue;
+                if (tc.name === "file_read" && !readTurns.has(filePath))
+                  readTurns.set(filePath, tc.turn ?? 0);
+                if (["file_write", "file_edit"].includes(tc.name))
+                  writeTurns.set(filePath, tc.turn ?? 0);
+              }
+              const deps = [];
+              for (const [file, writeTurn] of writeTurns) {
+                const readTurn = readTurns.get(file);
+                if (readTurn !== void 0 && readTurn < writeTurn) {
+                  deps.push({ file, read_turn: readTurn, write_turn: writeTurn });
+                }
+              }
+              return deps;
+            })()
+          };
+          fs4.writeFileSync(path5.join(provenanceDir, `${this._sessionId}.json`), JSON.stringify(provenanceGraph, null, 2));
+          if (completed && this.tools.has("memory_write")) {
+            const memTool = this.tools.get("memory_write");
+            const lessonContent = `Task "${task.slice(0, 100)}" completed successfully. Tools: ${consolidation.toolsUsed.join(", ")}. Files: ${consolidation.filesModified.slice(0, 3).join(", ")}. Duration: ${Math.round(durationMs / 1e3)}s, ${consolidation.turns} turns.`;
+            try {
+              await memTool.execute({
+                topic: "task_lessons",
+                key: this._sessionId,
+                value: lessonContent
+              });
+            } catch {
+            }
+          }
+          this.emit({
+            type: "status",
+            content: `Task consolidation: ${consolidation.outcome}, ${consolidation.toolsUsed.length} tools, ${consolidation.filesModified.length} files modified`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch {
+        }
         this._hookManager.runSessionHook("session_end", this._sessionId);
         try {
           const fs4 = await import("node:fs");

package/package.json

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