open-agents-ai 0.187.460 → 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);
@@ -542292,6 +542501,23 @@ async function ensureExpandedContext(modelName, backendUrl) {
     return { model: modelName, created: false, contextLabel: "", numCtx: 0 };
   }
   if (typeof existing === "string") {
+    const lostTools = await wrapperLacksToolsCapability(backendUrl, existing).catch(() => false);
+    if (lostTools) {
+      try {
+        const rebuilt = await createExpandedVariantNamedAsync(
+          stripVariantTag(existing),
+          modelName,
+          specs,
+          sizeGB,
+          kvInfo?.kvBytesPerToken,
+          kvInfo?.archMax
+        );
+        if (rebuilt) {
+          return { model: rebuilt, created: true, contextLabel: ctx3.label, numCtx: ctx3.numCtx };
+        }
+      } catch {
+      }
+    }
     const repair = await repairExpandedVariantIfStale(
       existing,
       modelName,
@@ -542310,6 +542536,38 @@ async function ensureExpandedContext(modelName, backendUrl) {
   }
   return { model: modelName, created: false, contextLabel: ctx3.label, numCtx: ctx3.numCtx };
 }
+function guessBaseFromVariant(variantName, models) {
+  const stripped = stripVariantTag(variantName);
+  for (const m2 of models) {
+    if (/^open-agents-/i.test(m2.name)) continue;
+    const candidates = expandedModelCandidates(stripVariantTag(m2.name));
+    if (candidates.includes(stripped)) {
+      return m2.name;
+    }
+  }
+  return null;
+}
+async function wrapperLacksToolsCapability(backendUrl, modelName) {
+  try {
+    const normalized = backendUrl.replace(/\/+$/, "");
+    const showRes = await fetch(`${normalized}/api/show`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: modelName }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!showRes.ok) return false;
+    const showData = await showRes.json();
+    const caps = Array.isArray(showData.capabilities) ? showData.capabilities : [];
+    const hasTools = caps.some((c9) => /^tools?$/i.test(c9));
+    if (hasTools) return false;
+    const fromMatch = showData.modelfile?.match(/^FROM\s+(.+)$/m);
+    const fromVal = fromMatch?.[1]?.trim() ?? "";
+    return fromVal.startsWith("/") || /blobs\/sha256[-:]/.test(fromVal);
+  } catch {
+    return false;
+  }
+}
 async function repairAllExpandedVariants(backendUrl) {
   const specs = await detectSystemSpecsAsync();
   const models = await fetchOllamaModels(backendUrl);
@@ -542327,25 +542585,47 @@ async function repairAllExpandedVariants(backendUrl) {
       summary.failed.push({ model: variant.name, reason: "missing-state" });
       continue;
     }
-    const baseModel = state.baseModel && !state.baseModel.startsWith("open-agents-") ? state.baseModel : null;
+    let baseModel = state.baseModel && !state.baseModel.startsWith("open-agents-") ? state.baseModel : null;
+    if (!baseModel) {
+      baseModel = guessBaseFromVariant(variant.name, models);
+    }
     if (!baseModel) {
       summary.failed.push({ model: variant.name, reason: "missing-base-model" });
       continue;
     }
-    const sizeGB = modelSizeGB(models, baseModel || variant.name);
+    const sizeGB = modelSizeGB(models, baseModel);
     const kvInfo = await queryModelKVInfo(backendUrl, baseModel);
     const target = calculateExpandedVariantContextWindow(specs, sizeGB, kvInfo?.kvBytesPerToken, kvInfo?.archMax);
+    const lostTools = await wrapperLacksToolsCapability(backendUrl, variant.name);
     try {
-      const result = await repairExpandedVariantIfStale(
-        variant.name,
-        baseModel,
-        backendUrl,
-        specs,
-        sizeGB,
-        target.numCtx,
-        kvInfo?.kvBytesPerToken,
-        kvInfo?.archMax
-      );
+      let result;
+      if (lostTools) {
+        const created = await createExpandedVariantNamedAsync(
+          stripVariantTag(variant.name),
+          baseModel,
+          specs,
+          sizeGB,
+          kvInfo?.kvBytesPerToken,
+          kvInfo?.archMax
+        );
+        result = {
+          repaired: !!created,
+          currentNumCtx: state.currentNumCtx,
+          baseModel,
+          resolvedModel: created ?? variant.name
+        };
+      } else {
+        result = await repairExpandedVariantIfStale(
+          variant.name,
+          baseModel,
+          backendUrl,
+          specs,
+          sizeGB,
+          target.numCtx,
+          kvInfo?.kvBytesPerToken,
+          kvInfo?.archMax
+        );
+      }
       if (result.repaired) {
         summary.repaired.push({
           model: result.resolvedModel,