open-agents-ai 0.187.449 → 0.187.450

package/dist/index.js

@@ -505795,12 +505795,16 @@ var init_agent_tool = __esm({
             subAgentMode: true
           });
           if (result.completed) {
+            const filesLine = result.filesModified && result.filesModified.length > 0 ? `
+  Files modified: ${result.filesModified.slice(0, 8).join(", ")}${result.filesModified.length > 8 ? ` (+${result.filesModified.length - 8} more)` : ""}` : "";
+            const artifactLine = result.artifactIds && result.artifactIds.length > 0 ? `
+  Artifacts: ${result.artifactIds.join(", ")} (call memex_retrieve to view full sub-agent transcript)` : "";
             return {
               success: true,
               output: `Agent completed: ${result.summary}
   Type: ${subagentType}
   Turns: ${result.turns}, Tool calls: ${result.toolCalls}
-  Duration: ${(result.durationMs / 1e3).toFixed(1)}s`,
+  Duration: ${(result.durationMs / 1e3).toFixed(1)}s` + filesLine + artifactLine,
               durationMs: performance.now() - start2
             };
           }
@@ -516588,6 +516592,13 @@ var init_contextTree = __esm({
        * Contract the named phase: extract anchors, generate a stub summary,
        * mark the node `contracted`. The caller may then archive via the
        * archive callback (Phase 1 hands off to memex).
+       *
+       * `summarizer` may be sync (returns string) or async (returns Promise<string>).
+       * When async, the node is contracted IMMEDIATELY with the default stub
+       * summary; the real summary lands later via the returned promise's
+       * resolution updating `node.summary` in place. The next compactMessages
+       * render therefore picks up the LLM summary without blocking the turn
+       * loop on it.
        */
       contract(phase, turn, summarizer) {
         const node = this.snapshot.phases[phase];
@@ -516595,9 +516606,24 @@ var init_contextTree = __esm({
           return null;
         const anchors = extractAnchorsFromMessages(node.messages, turn).slice(0, this.opts.maxAnchorsPerNode);
         node.anchors = [...node.anchors, ...anchors].slice(-this.opts.maxAnchorsPerNode);
-        node.summary = summarizer ? summarizer(node.messages) : this.defaultSummary(phase, node.messages);
+        node.summary = this.defaultSummary(phase, node.messages);
         node.status = "contracted";
         node.contractedAtTurn = turn;
+        if (summarizer) {
+          try {
+            const result = summarizer(node.messages);
+            if (result && typeof result.then === "function") {
+              result.then((s2) => {
+                if (typeof s2 === "string" && s2.length > 0)
+                  node.summary = s2;
+              }).catch(() => {
+              });
+            } else if (typeof result === "string") {
+              node.summary = result;
+            }
+          } catch {
+          }
+        }
         this.snapshot.history.push({ ...node, phase });
         if (this.snapshot.history.length > 32) {
           this.snapshot.history = this.snapshot.history.slice(-32);
@@ -517726,6 +517752,11 @@ var init_agenticRunner = __esm({
       // by keyword. Initialized lazily in run() because the system-prompt hash
       // depends on the actual prompt resolved at run time.
       _contextTree = null;
+      // Phase 1 — index in `messages` where the current phase's slice begins.
+      // On phase transition we capture messages[_phaseMessageStartIdx..now]
+      // as the OUTGOING phase's owned slice (via tree.observePhaseMessages),
+      // then advance the cursor so the new phase starts fresh.
+      _phaseMessageStartIdx = 0;
       // Phase 6 — last-surface guard so we don't re-inject the same anchor on
       // consecutive turns when its keywords still match.
       _lastSurfacedAnchorIds = /* @__PURE__ */ new Set();
@@ -517816,6 +517847,32 @@ var init_agenticRunner = __esm({
         return this._fileRegistry;
       }
       /** Get a Memex archive entry by ID (for the dereference tool) */
+      /**
+       * Phase 4 (Task C) — public read access to the runner's TaskState. Used
+       * by the CLI's spawnInProcess wiring to extract `modifiedFiles` from a
+       * sub-agent run and surface them on the parent's `InProcessResult`. The
+       * caller treats the returned object as read-only.
+       */
+      getTaskState() {
+        return this._taskState;
+      }
+      /**
+       * Phase 4 (Task C) — direct memex archive helper for parent runners
+       * that want to file a sub-agent's verbose result under a known id.
+       * Returns the assigned id so the caller can surface it on the result.
+       */
+      archiveToMemex(opts) {
+        const id = opts.id ?? this.quickHash(`${opts.toolName}|${opts.summary}|${Date.now()}`);
+        this._memexArchive.set(id, {
+          id,
+          toolName: opts.toolName,
+          summary: opts.summary,
+          fullContent: opts.fullContent,
+          turn: opts.turn ?? this._taskState.toolCallCount,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return id;
+      }
       getMemexEntry(id) {
         return this._memexArchive.get(id);
       }
@@ -518326,6 +518383,59 @@ ${body}`;
           });
         }
       }
+      /**
+       * Phase 1 (Task B) — build an async LLM summarizer for ContextTree.contract().
+       *
+       * Returns a function that takes a phase's owned message slice and asks the
+       * backend for a 2-3 sentence summary of what the phase accomplished. Hard
+       * caps the messages slice at ~3000 chars (≈750 tokens) of representative
+       * content to keep the cost bounded. Never blocks the turn loop — the
+       * returned promise updates ContextNode.summary in place when it resolves.
+       *
+       * Returns null when the disable knob is set or the backend is missing the
+       * chatCompletion method.
+       */
+      makePhaseSummarizer() {
+        if (process.env["OA_DISABLE_PHASE_SUMMARIZER"] === "1")
+          return null;
+        if (!this.backend || typeof this.backend.chatCompletion !== "function")
+          return null;
+        return async (phase, msgs) => {
+          const tail = msgs.slice(-8);
+          const blob = tail.map((m2) => {
+            const role = m2.role;
+            const content = typeof m2.content === "string" ? m2.content.slice(0, 400) : "";
+            if (m2.role === "assistant" && m2.tool_calls && m2.tool_calls.length > 0) {
+              const calls = m2.tool_calls.map((tc) => `${tc.function.name}(${(tc.function.arguments || "").slice(0, 80)})`).join(", ");
+              return `[${role}] ${content || ""} | tool_calls: ${calls}`.slice(0, 500);
+            }
+            return `[${role}] ${content}`.slice(0, 500);
+          }).join("\n");
+          const prompt = `You are summarizing the "${phase}" phase of an agent's task. Below is the message slice owned by this phase. Write a 2-3 sentence summary focused on WHAT was done and any KEY FINDINGS. No fluff. No "the agent did X" framing — just the facts.
+
+=== ${phase} phase messages ===
+${blob}
+=== end ===`;
+          try {
+            const response = await this.backend.chatCompletion({
+              messages: [
+                { role: "system", content: "You write extremely concise phase summaries for agent context management." },
+                { role: "user", content: prompt }
+              ],
+              tools: [],
+              temperature: 0,
+              maxTokens: 256,
+              timeoutMs: 3e4
+            });
+            const text = response.choices?.[0]?.message?.content;
+            if (typeof text === "string" && text.length > 0) {
+              return `${phase}: ${text.replace(/\s+/g, " ").trim().slice(0, 600)}`;
+            }
+          } catch {
+          }
+          return "";
+        };
+      }
       /**
        * Phase 6 — Anchor Surfacing.
        *
@@ -518857,6 +518967,7 @@ Respond with your assessment, then take action.`;
         const contextComposition = await this.assembleContext(task, context2);
         const systemPrompt = contextComposition.assembled;
         this._contextTree = new ContextTree(`sys-${systemPrompt.length}`, cleanedTask.slice(0, 200));
+        this._phaseMessageStartIdx = 2;
         this.emit({
           type: "status",
           content: `Context assembled: ${contextComposition.sections.map((s2) => `${s2.label}(${s2.tokenEstimate}t)`).join(" + ")} = ~${contextComposition.totalTokenEstimate}t`,
@@ -519610,19 +519721,28 @@ ${memoryLines.join("\n")}`
                 this._contextTree.observeToolCall(tc.name, argsKey, turn);
                 const transition = this._contextTree.maybeTransition(turn);
                 if (transition) {
+                  const phaseSlice = messages2.slice(this._phaseMessageStartIdx);
+                  if (phaseSlice.length > 0) {
+                    const fromNode = this._contextTree.getSnapshot().phases[transition.from];
+                    if (fromNode) {
+                      fromNode.messages = phaseSlice;
+                    }
+                  }
                   this.emit({
                     type: "status",
                     content: `Phase: ${transition.from} → ${transition.to}`,
                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                   });
-                  const contracted = this._contextTree.contractInactive(turn);
+                  const summarizer = this.makePhaseSummarizer();
+                  const contracted = this._contextTree.contractInactive(turn, summarizer ? ((msgs) => summarizer(transition.from, msgs)) : void 0);
                   if (contracted.length > 0) {
                     this.emit({
                       type: "status",
-                      content: `Phase contraction: ${contracted.join(", ")} → contracted (anchors retained)`,
+                      content: `Phase contraction: ${contracted.join(", ")} → contracted (${summarizer ? "LLM-summarized" : "stub-summarized"}, anchors retained)`,
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
                     });
                   }
+                  this._phaseMessageStartIdx = messages2.length;
                   this._taskState.phase = transition.to;
                   this._taskState.phaseSince = turn;
                 }
@@ -584803,6 +584923,119 @@ ${incompleteList}${more}
     }
   };
 }
+function wireAgentToolMinimal(tool, config, repoRoot) {
+  const typeRegistry = getAgentTypeRegistry();
+  const allToolNames = [
+    "file_read",
+    "file_write",
+    "file_edit",
+    "shell",
+    "grep",
+    "glob",
+    "list_directory",
+    "web_fetch",
+    "web_search",
+    "memory_read",
+    "memory_write",
+    "task_complete",
+    "batch_edit",
+    "file_patch",
+    "git_info",
+    "agent",
+    "send_message"
+  ];
+  tool.setCallbacks({
+    resolveType: (typeName) => {
+      const def = typeRegistry.get(typeName);
+      if (!def) return void 0;
+      const resolvedNames = typeRegistry.resolveTools(typeName, allToolNames);
+      return {
+        type: def.type,
+        maxTurns: def.maxTurns,
+        toolNames: resolvedNames,
+        systemPromptAddition: def.systemPromptAddition,
+        canSpawnAgents: def.canSpawnAgents
+      };
+    },
+    listTypes: () => typeRegistry.listTypes(),
+    spawnInProcess: async (opts) => {
+      let backend;
+      if (config.backendType === "nexus") {
+        const nexusTool = new NexusTool(repoRoot);
+        backend = new NexusAgenticBackend(nexusTool.sendCommand.bind(nexusTool), opts.model, void 0, config.apiKey);
+      } else {
+        backend = new OllamaAgenticBackend(config.backendUrl, opts.model, config.apiKey);
+      }
+      const subTier = getModelTier(opts.model);
+      const subCompaction = subTier === "small" ? 12e3 : subTier === "medium" ? 24e3 : 4e4;
+      const subRunner = new AgenticRunner(backend, {
+        maxTurns: opts.maxTurns,
+        maxTokens: 16384,
+        temperature: 0,
+        requestTimeoutMs: config.timeoutMs,
+        taskTimeoutMs: config.timeoutMs * 2,
+        compactionThreshold: subCompaction,
+        contextWindowSize: 0,
+        modelTier: subTier,
+        subAgent: opts.subAgentMode === true
+      });
+      subRunner.setWorkingDirectory(repoRoot);
+      const allSafe = buildSubAgentTools(repoRoot, config);
+      const nameSet = new Set(opts.toolNames || []);
+      const subToolInstances = nameSet.size > 0 ? allSafe.filter((t2) => nameSet.has(t2.name)) : allSafe.slice();
+      const nameOf = (t2) => t2.name;
+      if (!subToolInstances.some((t2) => nameOf(t2) === "todo_write")) subToolInstances.push(new TodoWriteTool());
+      if (!subToolInstances.some((t2) => nameOf(t2) === "todo_read")) subToolInstances.push(new TodoReadTool());
+      subRunner.registerTools(subToolInstances.map(adaptTool6));
+      subRunner.registerTool(createTaskCompleteTool(subTier));
+      const systemCtx = opts.systemPromptAddition ? `Working directory: ${repoRoot}
+
+${opts.systemPromptAddition}` : `Working directory: ${repoRoot}`;
+      const result = await subRunner.run(opts.task, systemCtx);
+      const subState = subRunner.getTaskState();
+      const filesModified = Array.from(subState.modifiedFiles.keys());
+      const artifactIds = [];
+      if (_parentRunnerForArchive && result.summary && result.summary.length > 0) {
+        const artifactId = `subagent-${opts.id}-result`;
+        try {
+          _parentRunnerForArchive.archiveToMemex({
+            id: artifactId,
+            toolName: "agent",
+            summary: `Sub-agent ${opts.id}: ${result.summary.slice(0, 120)}`,
+            fullContent: `Sub-agent task: ${opts.task.slice(0, 1e3)}
+
+Completed: ${result.completed}
+Turns: ${result.turns}, Tool calls: ${result.toolCalls}
+Files modified: ${filesModified.join(", ") || "(none)"}
+
+Summary:
+${result.summary}`
+          });
+          artifactIds.push(artifactId);
+        } catch {
+        }
+      }
+      return {
+        completed: result.completed,
+        summary: result.summary,
+        turns: result.turns,
+        toolCalls: result.toolCalls,
+        durationMs: result.durationMs,
+        filesModified,
+        artifactIds
+      };
+    },
+    spawnSubprocess: (opts) => {
+      const entry = spawnFullSubAgent(
+        opts.task,
+        { model: opts.model, backendUrl: config.backendUrl, workingDir: opts.workingDir }
+      );
+      return { id: entry.id, pid: entry.pid ?? 0 };
+    },
+    trackTask: () => {
+    }
+  });
+}
 function buildSubAgentTools(repoRoot, config) {
   return [
     // File + search
@@ -585684,7 +585917,8 @@ RULES:
     }
   } catch {
   }
-  const compactionThreshold = modelTier === "small" ? 12e3 : modelTier === "medium" ? 24e3 : 4e4;
+  const envOverride = Number.parseInt(process.env["OA_COMPACTION_THRESHOLD"] ?? "", 10);
+  const compactionThreshold = Number.isFinite(envOverride) && envOverride > 0 ? envOverride : modelTier === "small" ? 12e3 : modelTier === "medium" ? 24e3 : 4e4;
   let identityInjection = "";
   try {
     const ikStateFile = join109(repoRoot, ".oa", "identity", "self-state.json");
@@ -585732,6 +585966,7 @@ RULES:
   });
   runner.setWorkingDirectory(repoRoot);
   _activeRunnerRef = runner;
+  _parentRunnerForArchive = runner;
   let _checkinPoller = null;
   try {
     const oaSessionId = process.env["OA_SESSION_ID"];
@@ -587218,12 +587453,38 @@ Review its full output in the [${id}] tab or via sub_agent(action='output', id='
 
 ${opts.systemPromptAddition}` : `Working directory: ${repoRoot}`;
           const result = await subRunner.run(opts.task, systemCtx);
+          const subState = subRunner.getTaskState();
+          const filesModified = Array.from(subState.modifiedFiles.keys());
+          const artifactIds = [];
+          if (_parentRunnerForArchive && result.summary && result.summary.length > 0) {
+            const artifactId = `subagent-${opts.id}-result`;
+            try {
+              _parentRunnerForArchive.archiveToMemex({
+                id: artifactId,
+                toolName: "agent",
+                summary: `Sub-agent ${opts.id}: ${result.summary.slice(0, 120)}`,
+                fullContent: `Sub-agent task: ${opts.task.slice(0, 1e3)}
+
+Completed: ${result.completed}
+Turns: ${result.turns}, Tool calls: ${result.toolCalls}
+Duration: ${result.durationMs}ms
+Files modified: ${filesModified.join(", ") || "(none)"}
+
+Summary:
+${result.summary}`
+              });
+              artifactIds.push(artifactId);
+            } catch {
+            }
+          }
           return {
             completed: result.completed,
             summary: result.summary,
             turns: result.turns,
             toolCalls: result.toolCalls,
-            durationMs: result.durationMs
+            durationMs: result.durationMs,
+            filesModified,
+            artifactIds
           };
         },
         spawnSubprocess: (opts) => {
@@ -590841,6 +591102,9 @@ async function runWithTUI(task, config, repoPath, callbacks) {
   renderCompactHeader(config.model);
   renderUserMessage(task);
   setTerminalTitle(task.slice(0, 60), getVersion4());
+  if (!_wireAgentToolCallbacks) {
+    _wireAgentToolCallbacks = (tool) => wireAgentToolMinimal(tool, config, repoRoot);
+  }
   try {
     const handle2 = startTask(task, config, repoRoot);
     await handle2.promise;
@@ -591106,7 +591370,7 @@ Rules:
     process.exit(1);
   }
 }
-var _interactiveSessionActive, _interactiveSessionReason, _voiceChatSession, taskManager, _apiCallbacks, _shellToolRef, _replToolRef, _fullSubAgentToolRef, _agentToolRef, _sendMessageToolRef, _agentLifecycleMgr, _activeRunnerRef, _wireSubAgentCallbacks, _wireAgentToolCallbacks, _wireSubAgentToolCallbacks, _autoUpdatedThisSession, _mcpManager, _pluginManager, _mcpTools, SELF_IMPROVE_INTERVAL, _tasksSinceImprove;
+var _interactiveSessionActive, _interactiveSessionReason, _voiceChatSession, taskManager, _apiCallbacks, _shellToolRef, _replToolRef, _fullSubAgentToolRef, _agentToolRef, _sendMessageToolRef, _agentLifecycleMgr, _activeRunnerRef, _parentRunnerForArchive, _wireSubAgentCallbacks, _wireAgentToolCallbacks, _wireSubAgentToolCallbacks, _autoUpdatedThisSession, _mcpManager, _pluginManager, _mcpTools, SELF_IMPROVE_INTERVAL, _tasksSinceImprove;
 var init_interactive = __esm({
   "packages/cli/src/tui/interactive.ts"() {
     "use strict";
@@ -591164,6 +591428,7 @@ var init_interactive = __esm({
     _sendMessageToolRef = null;
     _agentLifecycleMgr = getSharedTaskManager();
     _activeRunnerRef = null;
+    _parentRunnerForArchive = null;
     _wireSubAgentCallbacks = null;
     _wireAgentToolCallbacks = null;
     _wireSubAgentToolCallbacks = null;

package/npm-shrinkwrap.json

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

package/package.json

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