open-agents-ai 0.187.461 → 0.187.462

package/dist/index.js

@@ -254253,6 +254253,25 @@ var init_todo_write = __esm({
           }
           const sessionId = getTodoSessionId();
           const oldTodos = readTodos(sessionId);
+          const canonicalize = (todos) => JSON.stringify(todos.map((t2) => ({
+            content: t2.content,
+            status: t2.status,
+            parentId: t2.parentId ?? null,
+            blocker: t2.blocker ?? null
+          })));
+          const oldKey = canonicalize(oldTodos);
+          const newKey = canonicalize(incoming);
+          if (oldKey === newKey && oldTodos.length > 0) {
+            return {
+              success: true,
+              output: JSON.stringify({
+                reminder: "[NO-OP] You called todo_write with the same plan you already have. The list is unchanged. Use todo_write ONLY to add new tasks, mark a task in_progress / completed, or record a blocker — not as a way to re-read your plan (use todo_read for that, but the current plan is also surfaced automatically in your context). Proceed with the current in_progress task.",
+                todos: oldTodos,
+                noop: true
+              }),
+              durationMs: performance.now() - start2
+            };
+          }
           const result = writeTodos(sessionId, incoming);
           const closedCount = result.newTodos.filter((t2) => t2.status === "completed").length;
           const oldClosedCount = oldTodos.filter((t2) => t2.status === "completed").length;
@@ -518395,6 +518414,115 @@ ${body}`;
        * Returns null when the disable knob is set or the backend is missing the
        * chatCompletion method.
        */
+      /**
+       * REG-3: Render the current todo list as a compact transient block so the
+       * agent can read its own plan without calling todo_read or re-emitting
+       * todo_write as a scratchpad. Returns null when there are no todos yet.
+       */
+      _renderTodoStateBlock(turn) {
+        try {
+          const { readTodos: readTodos2 } = __require("@open-agents/execution");
+          const { getTodoSessionId: getTodoSessionId2 } = __require("@open-agents/execution");
+          const sessionId = getTodoSessionId2();
+          const todos = readTodos2(sessionId);
+          if (!todos || todos.length === 0)
+            return null;
+          const lines = ["[CURRENT TODO PLAN — already in your state, no need to call todo_write to see it]"];
+          const inProg = todos.filter((t2) => t2.status === "in_progress");
+          const pending = todos.filter((t2) => t2.status === "pending");
+          const done = todos.filter((t2) => t2.status === "completed");
+          const blocked = todos.filter((t2) => t2.status === "blocked");
+          if (inProg.length > 0) {
+            lines.push(`▶ in_progress (${inProg.length}):`);
+            for (const t2 of inProg)
+              lines.push(`  • ${t2.content}`);
+          }
+          if (pending.length > 0) {
+            lines.push(`◯ pending (${pending.length}):`);
+            for (const t2 of pending.slice(0, 8))
+              lines.push(`  • ${t2.content}`);
+            if (pending.length > 8)
+              lines.push(`  … +${pending.length - 8} more`);
+          }
+          if (blocked.length > 0) {
+            lines.push(`✕ blocked (${blocked.length}):`);
+            for (const t2 of blocked)
+              lines.push(`  • ${t2.content}${t2.blocker ? ` — ${t2.blocker}` : ""}`);
+          }
+          if (done.length > 0) {
+            lines.push(`✓ completed (${done.length}): ${done.map((t2) => t2.content.slice(0, 40)).join(" | ")}`);
+          }
+          lines.push(`(turn ${turn} — call todo_write ONLY to update state, never to re-read this plan)`);
+          return lines.join("\n");
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * REG-2: Render a compact "files known to me" block from `_worldFacts`.
+       * Goal: tell the model what it has already touched this run so it stops
+       * re-running `find src -type f` and `list_directory("...")` to confirm
+       * its own outputs.
+       *
+       * Returns null when there is nothing useful to surface yet.
+       */
+      _renderFilesystemStateBlock(turn) {
+        const wf = this._worldFacts;
+        if (!wf)
+          return null;
+        const files = [...wf.files.entries()];
+        const lists = [...wf.lastLists.entries()];
+        if (files.length === 0 && lists.length === 0 && !wf.lastTest?.summary)
+          return null;
+        const writes = files.filter(([, v]) => (v.writeCount ?? 0) > 0);
+        const reads = files.filter(([, v]) => (v.writeCount ?? 0) === 0);
+        const groupByDir = (entries) => {
+          const m2 = /* @__PURE__ */ new Map();
+          for (const [p2] of entries) {
+            const slash = p2.lastIndexOf("/");
+            const dir = slash > 0 ? p2.slice(0, slash) : ".";
+            const arr = m2.get(dir) ?? [];
+            arr.push(p2);
+            m2.set(dir, arr);
+          }
+          return m2;
+        };
+        const renderGroup = (m2, cap) => {
+          const lines = [];
+          const sorted = [...m2.entries()].sort((a2, b) => b[1].length - a2[1].length);
+          let total = 0;
+          for (const [dir, paths] of sorted) {
+            if (total >= cap) {
+              lines.push(`  ... and ${sorted.slice(lines.length).reduce((s2, [, p2]) => s2 + p2.length, 0)} more files in other dirs`);
+              break;
+            }
+            const show = paths.slice(0, 6);
+            lines.push(`  ${dir}/  →  ${show.map((p2) => p2.slice(dir.length + 1)).join(", ")}${paths.length > show.length ? ` (+${paths.length - show.length} more)` : ""}`);
+            total += paths.length;
+          }
+          return lines.join("\n");
+        };
+        const sections = [];
+        sections.push("[FILES KNOWN — already touched this run; do not re-discover via find/list_directory unless filesystem may have changed externally]");
+        if (writes.length > 0) {
+          sections.push(`Files YOU WROTE this run (${writes.length}):`);
+          sections.push(renderGroup(groupByDir(writes), 40));
+        }
+        if (reads.length > 0) {
+          sections.push(`Files YOU READ this run (${reads.length}):`);
+          sections.push(renderGroup(groupByDir(reads), 20));
+        }
+        if (lists.length > 0) {
+          const recentLists = lists.sort((a2, b) => b[1].lastSeenTurn - a2[1].lastSeenTurn).slice(0, 8);
+          sections.push(`Directories you've listed (${lists.length}):`);
+          sections.push(recentLists.map(([dir, info]) => `  ${dir}  (${info.entriesCount} entries, turn ${info.lastSeenTurn})`).join("\n"));
+        }
+        if (wf.lastTest?.summary) {
+          sections.push(`Last test outcome: ${wf.lastTest.passed ? "PASSED" : "FAILED"} (turn ${wf.lastTest.turn ?? "?"})`);
+        }
+        sections.push(`(turn ${turn} — this block is regenerated every turn from your tool history)`);
+        return sections.join("\n");
+      }
       makePhaseSummarizer() {
         if (process.env["OA_DISABLE_PHASE_SUMMARIZER"] === "1")
           return null;
@@ -519095,7 +519223,7 @@ TASK: ${task}` : task;
         const recentToolResults = /* @__PURE__ */ new Map();
         const toolCallBudget = /* @__PURE__ */ new Map();
         const loopTier = this.options.modelTier ?? "large";
-        const toolBudgets = loopTier === "small" ? { web_search: 6, web_fetch: 4, list_directory: 8, find_files: 6, grep_search: 8 } : loopTier === "medium" ? { web_search: 10, web_fetch: 8, list_directory: 12, find_files: 10, grep_search: 12 } : { web_search: 20, web_fetch: 15, list_directory: 20, find_files: 15, grep_search: 20 };
+        const toolBudgets = loopTier === "small" ? { web_search: 6, web_fetch: 4, list_directory: 12, find_files: 10, grep_search: 12 } : loopTier === "medium" ? { web_search: 10, web_fetch: 8, list_directory: 18, find_files: 14, grep_search: 18 } : { web_search: 20, web_fetch: 15, list_directory: 30, find_files: 20, grep_search: 30 };
         for (const [tool, budget] of Object.entries(toolBudgets)) {
           toolCallBudget.set(tool, budget);
         }
@@ -519462,6 +519590,22 @@ ${memoryLines.join("\n")}`
               }
             });
           }
+          const _injections = [];
+          const fsBlock = this._renderFilesystemStateBlock(turn);
+          if (fsBlock)
+            _injections.push(fsBlock);
+          const todoBlock = this._renderTodoStateBlock(turn);
+          if (todoBlock)
+            _injections.push(todoBlock);
+          if (_injections.length > 0) {
+            const reqMsgs = chatRequest.messages;
+            if (Array.isArray(reqMsgs)) {
+              const insertAt = Math.max(0, reqMsgs.length - 1);
+              for (const blk of _injections) {
+                reqMsgs.splice(insertAt, 0, { role: "system", content: blk });
+              }
+            }
+          }
           let response;
           try {
             response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
@@ -519741,14 +519885,56 @@ ${memoryLines.join("\n")}`
                       content: `Phase contraction: ${contracted.join(", ")} → contracted (${summarizer ? "LLM-summarized" : "stub-summarized"}, anchors retained)`,
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
                     });
+                    try {
+                      const archDir = __require("node:path").join(process.cwd(), ".oa", "phases");
+                      __require("node:fs").mkdirSync(archDir, { recursive: true });
+                      for (const phaseName of contracted) {
+                        const node = this._contextTree.getSnapshot().phases[phaseName];
+                        if (!node)
+                          continue;
+                        const stamp = `${phaseName}-${Date.now().toString(36)}-turn${turn}`;
+                        const archPath = __require("node:path").join(archDir, `${stamp}.jsonl`);
+                        const archived = {
+                          phase: phaseName,
+                          contractedAtTurn: turn,
+                          contractedAtIso: (/* @__PURE__ */ new Date()).toISOString(),
+                          anchors: node.anchors,
+                          summary: node.summary ?? null,
+                          messages: node.messages ?? []
+                        };
+                        __require("node:fs").writeFileSync(archPath, JSON.stringify(archived) + "\n", "utf-8");
+                        this._contextTree.archive(phaseName, archPath);
+                      }
+                      this.emit({
+                        type: "status",
+                        content: `Phase archive: ${contracted.length} phase(s) written to .oa/phases/`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    } catch (archErr) {
+                      this.emit({
+                        type: "status",
+                        content: `Phase archive failed (non-fatal): ${archErr instanceof Error ? archErr.message : String(archErr)}`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
                   }
                   this._phaseMessageStartIdx = messages2.length;
                   this._taskState.phase = transition.to;
                   this._taskState.phaseSince = turn;
+                  for (const [tool2, budget] of Object.entries(toolBudgets)) {
+                    toolCallBudget.set(tool2, budget);
+                  }
+                  this.emit({
+                    type: "status",
+                    content: `Tool budgets reset for new phase (${Object.keys(toolBudgets).length} tools)`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
                 }
               }
+              const _argsKeyForBudget = `${tc.name}:${argsKey}`;
+              const _isCachedHit = recentToolResults.has(_argsKeyForBudget);
               const budgetRemaining = toolCallBudget.get(tc.name);
-              if (budgetRemaining !== void 0) {
+              if (budgetRemaining !== void 0 && !_isCachedHit) {
                 if (budgetRemaining <= 0) {
                   this.emit({
                     type: "tool_call",
@@ -519757,7 +519943,7 @@ ${memoryLines.join("\n")}`
                     turn,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
-                  const budgetMsg = `[BUDGET EXHAUSTED] You have used all ${toolBudgets[tc.name]} allowed ${tc.name} calls for this task. You ALREADY have enough information from previous calls. DO NOT try to call ${tc.name} again — it will be blocked. Summarize what you found and call task_complete with your answer NOW.`;
+                  const budgetMsg = `[BUDGET EXHAUSTED] You have used all ${toolBudgets[tc.name]} allowed ${tc.name} calls for the current phase. You ALREADY have enough information from previous calls. DO NOT try to call ${tc.name} again — it will be blocked. If your todo list shows more phases pending: mark the current phase completed via todo_write so a new budget allowance kicks in. If all phases are done: call task_complete with your final summary.`;
                   this.emit({
                     type: "tool_result",
                     toolName: tc.name,
@@ -519939,10 +520125,33 @@ ${cachedEntry2.result.slice(0, 500)}` : `[BLOCKED — the observer confirmed thi
               updated.lastOutcomeTurn = turn;
               this._argCohorts.set(cohortKey, updated);
               try {
+                if (tc.name === "file_write" || tc.name === "file_edit" || tc.name === "edit_block") {
+                  const p2 = String(tc.arguments?.["path"] ?? tc.arguments?.["file_path"] ?? tc.arguments?.["file"] ?? "");
+                  if (p2 && result.success) {
+                    const prev = this._worldFacts.files.get(p2);
+                    this._worldFacts.files.set(p2, {
+                      exists: true,
+                      size: prev?.size,
+                      hashSample: prev?.hashSample,
+                      lastSeenTurn: turn,
+                      lastWriteTurn: turn,
+                      writeCount: (prev?.writeCount ?? 0) + 1
+                    });
+                  }
+                }
                 if (tc.name === "file_read") {
                   const p2 = String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? "");
-                  if (p2)
-                    this._worldFacts.files.set(p2, { exists: result.success, size: (result.output || "").length, hashSample: (result.output || "").slice(0, 32), lastSeenTurn: turn });
+                  if (p2) {
+                    const prev = this._worldFacts.files.get(p2);
+                    this._worldFacts.files.set(p2, {
+                      exists: result.success,
+                      size: (result.output || "").length,
+                      hashSample: (result.output || "").slice(0, 32),
+                      lastSeenTurn: turn,
+                      lastWriteTurn: prev?.lastWriteTurn,
+                      writeCount: prev?.writeCount
+                    });
+                  }
                   if (this._fileSummaryStore && result.success && result.output && result.output.length > 100) {
                     try {
                       const existing = this._fileSummaryStore.get(p2);

package/npm-shrinkwrap.json

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

package/package.json

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