open-agents-ai 0.187.448 → 0.187.449

package/dist/index.js

@@ -505627,6 +505627,18 @@ var init_agent_tool = __esm({
           description: {
             type: "string",
             description: "Short label for this agent (3-5 words, shown in status)"
+          },
+          // Phase 4 — explicit handoff inputs (clean isolation: parent decides
+          // exactly what the sub-agent sees, instead of inheriting raw history).
+          relevant_files: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of file paths to pre-load into the sub-agent's context. When set, the sub-agent sees these files in its initial system message and does not need to re-discover them. Saves tokens and prevents duplicate file_read calls in the parent's transcript."
+          },
+          constraints: {
+            type: "array",
+            items: { type: "string" },
+            description: "Explicit rules the sub-agent must follow (e.g. 'do not modify foo.ts', 'use only TypeScript', 'return JSON only'). Rendered as a [Constraints] section in the sub-agent's initial system message."
           }
         },
         required: ["prompt"]
@@ -505648,6 +505660,8 @@ var init_agent_tool = __esm({
         const modelOverride = args["model"] ? String(args["model"]) : void 0;
         const isolation = args["isolation"] ? String(args["isolation"]) : void 0;
         const description = args["description"] ? String(args["description"]) : void 0;
+        const relevantFilePaths = Array.isArray(args["relevant_files"]) ? args["relevant_files"].map((s2) => String(s2)) : [];
+        const constraints = Array.isArray(args["constraints"]) ? args["constraints"].map((s2) => String(s2)) : [];
         if (!prompt) {
           return { success: false, output: "", error: "prompt is required", durationMs: performance.now() - start2 };
         }
@@ -505672,11 +505686,58 @@ var init_agent_tool = __esm({
         const model = modelOverride ?? this.config.model;
         const agentId = generateAgentId(subagentType);
         const label = description ?? `${subagentType}: ${prompt.slice(0, 40)}`;
+        const preloadedFiles = [];
+        if (relevantFilePaths.length > 0) {
+          const fs7 = await import("node:fs");
+          const path8 = await import("node:path");
+          const FILE_CAP = 8 * 1024;
+          const TOTAL_FILE_CAP = 5;
+          for (const p2 of relevantFilePaths.slice(0, TOTAL_FILE_CAP)) {
+            try {
+              const abs = path8.isAbsolute(p2) ? p2 : path8.join(this.config.workingDir, p2);
+              const content = fs7.readFileSync(abs, "utf-8");
+              preloadedFiles.push({
+                path: p2,
+                content: content.length > FILE_CAP ? content.slice(0, FILE_CAP) + `
+[... truncated, original ${content.length} bytes]` : content
+              });
+            } catch {
+            }
+          }
+        }
+        const composedPrompt = (() => {
+          if (preloadedFiles.length === 0 && constraints.length === 0)
+            return prompt;
+          const lines = [];
+          lines.push("[Sub-Agent Handoff — parent has provided this scoped context]");
+          lines.push("");
+          if (preloadedFiles.length > 0) {
+            lines.push("## Pre-loaded files");
+            lines.push("These files have already been read for you. Reference them directly without calling file_read.");
+            lines.push("");
+            for (const f2 of preloadedFiles) {
+              lines.push(`### ${f2.path}`);
+              lines.push("```");
+              lines.push(f2.content);
+              lines.push("```");
+              lines.push("");
+            }
+          }
+          if (constraints.length > 0) {
+            lines.push("## Constraints (must follow)");
+            for (const c9 of constraints)
+              lines.push(`- ${c9}`);
+            lines.push("");
+          }
+          lines.push("## Task");
+          lines.push(prompt);
+          return lines.join("\n");
+        })();
         if (isolation === "worktree") {
           this.callbacks.onViewRegister?.(agentId, label);
           const spawn27 = this.callbacks.spawnSubprocess({
             id: agentId,
-            task: prompt,
+            task: composedPrompt,
             model,
             workingDir: this.config.workingDir
           });
@@ -505694,11 +505755,14 @@ var init_agent_tool = __esm({
           this.callbacks.onViewRegister?.(agentId, label);
           const promise = this.callbacks.spawnInProcess({
             id: agentId,
-            task: prompt,
+            task: composedPrompt,
             toolNames: resolved.toolNames,
             maxTurns: resolved.maxTurns,
             model,
-            systemPromptAddition: resolved.systemPromptAddition
+            systemPromptAddition: resolved.systemPromptAddition,
+            relevantFiles: preloadedFiles,
+            constraints,
+            subAgentMode: true
           }).then((result) => {
             this.callbacks?.onViewStatus?.(agentId, result.completed ? "completed" : "failed");
             return result.completed ? `Agent completed: ${result.summary} (${result.turns} turns, ${result.toolCalls} tool calls)` : `Agent incomplete after ${result.turns} turns`;
@@ -505721,11 +505785,14 @@ var init_agent_tool = __esm({
         try {
           const result = await this.callbacks.spawnInProcess({
             id: agentId,
-            task: prompt,
+            task: composedPrompt,
             toolNames: resolved.toolNames,
             maxTurns: resolved.maxTurns,
             model,
-            systemPromptAddition: resolved.systemPromptAddition
+            systemPromptAddition: resolved.systemPromptAddition,
+            relevantFiles: preloadedFiles,
+            constraints,
+            subAgentMode: true
           });
           if (result.completed) {
             return {
@@ -516249,6 +516316,420 @@ var init_messageLog = __esm({
   }
 });
 
+// packages/orchestrator/dist/contextTree.js
+function classifyToolCall(name10, argsJson) {
+  const direct = TOOL_PHASE_MAP[name10];
+  if (direct)
+    return direct;
+  if (name10 === "shell" || name10 === "shell_async") {
+    if (!argsJson)
+      return "implement";
+    const lower = argsJson.toLowerCase();
+    if (/(?:^|"command":")[^"]*(?:test|pytest|jest|mocha|vitest|cargo test|go test|npm test|pnpm test|tsc|lint|check|verify)\b/i.test(lower)) {
+      return "verify";
+    }
+    return "implement";
+  }
+  return null;
+}
+function detectPhase(toolCallLog, window2 = 10) {
+  if (toolCallLog.length === 0)
+    return "explore";
+  const recent = toolCallLog.slice(-window2);
+  const counts = {};
+  for (const tc of recent) {
+    const p2 = classifyToolCall(tc.name, tc.argsKey);
+    if (p2)
+      counts[p2] = (counts[p2] ?? 0) + 1;
+  }
+  const total = Object.values(counts).reduce((a2, b) => a2 + b, 0);
+  if (total === 0)
+    return "mixed";
+  let best = null;
+  for (const [phase, n2] of Object.entries(counts)) {
+    if (!best || n2 > best.n)
+      best = { phase, n: n2 };
+  }
+  if (!best || best.n / total < 0.4)
+    return "mixed";
+  return best.phase;
+}
+function extractAnchorsFromMessages(messages2, turn) {
+  const anchors = [];
+  const seenSummaries = /* @__PURE__ */ new Set();
+  let counter = 0;
+  const nextId2 = (kind) => `anc-${turn}-${kind}-${counter++}`;
+  for (const msg of messages2) {
+    const content = typeof msg.content === "string" ? msg.content : "";
+    if (!content)
+      continue;
+    if (msg.role === "tool" || msg.role === "assistant") {
+      const matches = content.match(FILE_PATH_RE) ?? [];
+      const distinctPaths = Array.from(new Set(matches.filter((p2) => p2.length > 2 && p2.length < 120))).slice(0, 5);
+      for (const p2 of distinctPaths) {
+        const summary = `file: ${p2}`;
+        if (seenSummaries.has(summary))
+          continue;
+        seenSummaries.add(summary);
+        anchors.push({
+          id: nextId2("file"),
+          type: "file",
+          summary,
+          keywords: [p2.toLowerCase(), ...p2.toLowerCase().split(/[\/\.]/).filter((s2) => s2.length > 2)],
+          turn
+        });
+      }
+    }
+    if (msg.role === "assistant" && DECISION_HINTS.test(content)) {
+      const sentence = content.split(/(?<=[.!?])\s+/).find((s2) => DECISION_HINTS.test(s2)) ?? content.slice(0, 200);
+      const summary = `decision: ${sentence.slice(0, 140).replace(/\s+/g, " ").trim()}`;
+      if (!seenSummaries.has(summary)) {
+        seenSummaries.add(summary);
+        anchors.push({
+          id: nextId2("dec"),
+          type: "decision",
+          summary,
+          keywords: extractKeywords(sentence),
+          turn
+        });
+      }
+    }
+    if (msg.role === "tool" && ERROR_HINTS.test(content)) {
+      const firstErrLine = content.split("\n").find((l2) => ERROR_HINTS.test(l2)) ?? content.slice(0, 200);
+      const summary = `error: ${firstErrLine.slice(0, 140).replace(/\s+/g, " ").trim()}`;
+      if (!seenSummaries.has(summary)) {
+        seenSummaries.add(summary);
+        anchors.push({
+          id: nextId2("err"),
+          type: "error",
+          summary,
+          keywords: extractKeywords(firstErrLine),
+          turn
+        });
+      }
+    }
+  }
+  return anchors;
+}
+function extractKeywords(text) {
+  const tokens = text.toLowerCase().replace(/[^\w./-]+/g, " ").split(/\s+/);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tk of tokens) {
+    if (tk.length < 3)
+      continue;
+    if (STOPWORDS.has(tk))
+      continue;
+    if (seen.has(tk))
+      continue;
+    seen.add(tk);
+    out.push(tk);
+    if (out.length >= 8)
+      break;
+  }
+  return out;
+}
+var TOOL_PHASE_MAP, FILE_PATH_RE, DECISION_HINTS, ERROR_HINTS, STOPWORDS, DEFAULT_OPTS, ContextTree;
+var init_contextTree = __esm({
+  "packages/orchestrator/dist/contextTree.js"() {
+    "use strict";
+    TOOL_PHASE_MAP = {
+      // explore
+      file_read: "explore",
+      list_directory: "explore",
+      find_files: "explore",
+      grep_search: "explore",
+      file_explore: "explore",
+      glob_find: "explore",
+      // plan
+      todo_write: "plan",
+      todo_read: "plan",
+      working_notes: "plan",
+      memory_write: "plan",
+      memory_read: "plan",
+      // implement
+      file_write: "implement",
+      file_edit: "implement",
+      file_patch: "implement",
+      batch_edit: "implement",
+      // verify (heuristic — shell with test-like commands also contributes;
+      // unknown shell defaults to implement)
+      run_tests: "verify"
+    };
+    FILE_PATH_RE = /[\w./-]*\/[\w./-]+(?:\.[a-z0-9]{1,6})?/gi;
+    DECISION_HINTS = /(?:I'll |Let me |I will |I'm going to |Plan: |Decision: |Approach: )/i;
+    ERROR_HINTS = /(?:error|fail|exception|traceback|enoent|enotfound|fatal)/i;
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "the",
+      "and",
+      "or",
+      "of",
+      "to",
+      "in",
+      "is",
+      "it",
+      "this",
+      "that",
+      "for",
+      "on",
+      "with",
+      "as",
+      "by",
+      "from",
+      "at",
+      "an",
+      "be",
+      "are",
+      "was",
+      "were",
+      "if",
+      "then",
+      "you",
+      "we",
+      "i",
+      "but",
+      "not",
+      "no",
+      "do",
+      "does",
+      "did",
+      "have",
+      "has",
+      "had",
+      "will",
+      "would",
+      "should",
+      "can",
+      "could"
+    ]);
+    DEFAULT_OPTS = {
+      maxActiveMessages: 60,
+      maxAnchorsPerNode: 12,
+      phaseWindow: 10
+    };
+    ContextTree = class {
+      snapshot;
+      opts;
+      currentPhase = "mixed";
+      currentTurn = 0;
+      toolCallLog = [];
+      constructor(systemPromptHash, activeGoal, opts) {
+        this.opts = { ...DEFAULT_OPTS, ...opts };
+        this.snapshot = {
+          rootSystemPromptHash: systemPromptHash,
+          activeGoal,
+          phases: {},
+          history: [],
+          archive: []
+        };
+      }
+      /** Returns the current detected phase. */
+      getCurrentPhase() {
+        return this.currentPhase;
+      }
+      /** Returns a read-only snapshot for inspection / serialization. */
+      getSnapshot() {
+        return this.snapshot;
+      }
+      /** Update the active goal (e.g. after compaction rewrites the goal). */
+      setActiveGoal(goal) {
+        this.snapshot.activeGoal = goal;
+      }
+      /**
+       * Record a tool call. Updates phase classification but does not move
+       * messages between nodes (caller must invoke maybeTransition).
+       */
+      observeToolCall(name10, argsKey, turn) {
+        this.toolCallLog.push({ name: name10, argsKey, turn });
+        if (this.toolCallLog.length > 200) {
+          this.toolCallLog = this.toolCallLog.slice(-100);
+        }
+        this.currentTurn = turn;
+      }
+      /**
+       * Detect a phase transition. Returns the previous phase if a transition
+       * happened, or null otherwise. Callers should follow up with
+       * contractInactive to summarize the just-exited phase.
+       */
+      maybeTransition(turn) {
+        const detected = detectPhase(this.toolCallLog, this.opts.phaseWindow);
+        if (detected === this.currentPhase)
+          return null;
+        const from3 = this.currentPhase;
+        this.currentPhase = detected;
+        if (!this.snapshot.phases[detected]) {
+          this.snapshot.phases[detected] = {
+            status: "active",
+            messages: [],
+            anchors: [],
+            startedAtTurn: turn
+          };
+        } else {
+          this.snapshot.phases[detected].status = "active";
+        }
+        return { from: from3, to: detected };
+      }
+      /**
+       * Sync a slice of messages into the current active phase node.
+       * Caller is expected to provide ALL messages owned by the current
+       * phase since the last sync (typically the suffix beyond a known
+       * boundary index).
+       */
+      observePhaseMessages(messages2) {
+        const node = this.snapshot.phases[this.currentPhase];
+        if (!node)
+          return;
+        node.messages = messages2;
+        if (messages2.length > this.opts.maxActiveMessages) {
+          this.contract(this.currentPhase, this.currentTurn);
+        }
+      }
+      /**
+       * 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).
+       */
+      contract(phase, turn, summarizer) {
+        const node = this.snapshot.phases[phase];
+        if (!node || node.status !== "active")
+          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.status = "contracted";
+        node.contractedAtTurn = turn;
+        this.snapshot.history.push({ ...node, phase });
+        if (this.snapshot.history.length > 32) {
+          this.snapshot.history = this.snapshot.history.slice(-32);
+        }
+        return node;
+      }
+      /** Contract every active phase except the current one. */
+      contractInactive(turn, summarizer) {
+        const contracted = [];
+        for (const [phase, node] of Object.entries(this.snapshot.phases)) {
+          if (phase === this.currentPhase)
+            continue;
+          if (node.status !== "active")
+            continue;
+          this.contract(phase, turn, summarizer);
+          contracted.push(phase);
+        }
+        return contracted;
+      }
+      /**
+       * Mark a contracted node as archived after its summary has been moved
+       * to memex. Caller passes the memex id.
+       */
+      archive(phase, memexId) {
+        const node = this.snapshot.phases[phase];
+        if (!node || node.status !== "contracted")
+          return;
+        node.status = "archived";
+        node.summary = void 0;
+        if (!this.snapshot.archive.includes(memexId)) {
+          this.snapshot.archive.push(memexId);
+        }
+      }
+      /**
+       * Restore a contracted phase: pulls the last contracted node for the phase
+       * back into active state. Returns the restored node or null if none found.
+       */
+      expand(phase) {
+        const node = this.snapshot.phases[phase];
+        if (node && node.status === "contracted") {
+          node.status = "active";
+          return node;
+        }
+        const histNode = [...this.snapshot.history].reverse().find((h) => h.phase === phase);
+        if (histNode) {
+          const restored = {
+            status: "active",
+            messages: [],
+            anchors: histNode.anchors,
+            startedAtTurn: this.currentTurn
+          };
+          this.snapshot.phases[phase] = restored;
+          return restored;
+        }
+        return null;
+      }
+      /** Render a compact phase-status block for inclusion in prompts. */
+      renderStatusBlock() {
+        const lines = [`### Phase Status`, `- current: **${this.currentPhase}**`];
+        const phaseSummaries = [];
+        for (const [phase, node] of Object.entries(this.snapshot.phases)) {
+          if (phase === this.currentPhase)
+            continue;
+          const status = node.status;
+          const anchorCount = node.anchors.length;
+          phaseSummaries.push(`- ${phase}: ${status}${anchorCount > 0 ? ` (${anchorCount} anchors)` : ""}`);
+        }
+        if (phaseSummaries.length > 0) {
+          lines.push(...phaseSummaries);
+        }
+        if (this.snapshot.archive.length > 0) {
+          lines.push(`- archived: ${this.snapshot.archive.length} (use memex_retrieve)`);
+        }
+        return lines.join("\n");
+      }
+      /** Render all retained anchors (across phases) for compaction summary. */
+      renderAnchorBlock(maxPerPhase = 5) {
+        const lines = [];
+        for (const [phase, node] of Object.entries(this.snapshot.phases)) {
+          if (node.anchors.length === 0)
+            continue;
+          lines.push(`**${phase} anchors:**`);
+          for (const a2 of node.anchors.slice(-maxPerPhase)) {
+            lines.push(`- [${a2.type}] ${a2.summary}`);
+          }
+        }
+        return lines.length > 0 ? `### Phase Anchors
+${lines.join("\n")}` : "";
+      }
+      /** Look up anchors whose keywords overlap the given query (Phase 6 hook). */
+      findAnchorsByKeywords(query, max = 5) {
+        const tokens = extractKeywords(query.toLowerCase());
+        if (tokens.length === 0)
+          return [];
+        const tokenSet = new Set(tokens);
+        const scored = [];
+        for (const node of Object.values(this.snapshot.phases)) {
+          for (const a2 of node.anchors) {
+            let score = 0;
+            for (const k of a2.keywords) {
+              if (tokenSet.has(k))
+                score += 2;
+              for (const t2 of tokenSet) {
+                if (k.includes(t2) || t2.includes(k))
+                  score += 1;
+              }
+            }
+            if (score > 0)
+              scored.push({ anchor: a2, score });
+          }
+        }
+        scored.sort((a2, b) => b.score - a2.score);
+        return scored.slice(0, max).map((s2) => s2.anchor);
+      }
+      defaultSummary(phase, messages2) {
+        const toolCallNames = /* @__PURE__ */ new Set();
+        let assistantWords = 0;
+        for (const m2 of messages2) {
+          if (m2.role === "assistant" && m2.tool_calls) {
+            for (const tc of m2.tool_calls)
+              toolCallNames.add(tc.function.name);
+          }
+          if (m2.role === "assistant" && typeof m2.content === "string") {
+            assistantWords += m2.content.split(/\s+/).length;
+          }
+        }
+        return `${phase} phase: ${messages2.length} messages, ${toolCallNames.size} distinct tools used, ${assistantWords} words of assistant output.`;
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/codeGraphLink.js
 function isCodeGraphLinkEnabled() {
   return process.env["OA_CODEGRAPH_LINK"] !== "0";
@@ -517095,7 +517576,7 @@ function classifyThinkOutcome(raw) {
   }
   return null;
 }
-var SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, OllamaAgenticBackend;
+var TOOL_SUBSETS, TOOL_AUTO_DEMOTE_TURNS, SYSTEM_PROMPT, SYSTEM_PROMPT_MEDIUM, SYSTEM_PROMPT_SMALL, VISUAL_TOOLS, AUDIO_TOOLS, SOCIAL_TOOLS, SPATIAL_TOOLS, CODE_TOOLS, AgenticRunner, OllamaAgenticBackend;
 var init_agenticRunner = __esm({
   "packages/orchestrator/dist/agenticRunner.js"() {
     "use strict";
@@ -517109,12 +517590,23 @@ var init_agenticRunner = __esm({
     init_reflectionBuffer();
     init_taskHandoff();
     init_messageLog();
+    init_contextTree();
     init_codeGraphLink();
     init_dist5();
     init_tool_batching();
     init_hooks();
     init_app_state();
     init_streaming_executor();
+    TOOL_SUBSETS = {
+      web: ["web_search", "web_fetch", "web_crawl"],
+      code: ["file_patch", "file_explore", "batch_edit", "file_read", "file_write", "file_edit"],
+      agent: ["agent", "sub_agent", "background_run"],
+      memory: ["memory_search", "memory_read", "memory_write", "memex_retrieve", "working_notes"],
+      shell: ["shell", "shell_async", "kill_proc", "run_tests"],
+      graph: ["graph_query", "graph_traverse", "code_graph"],
+      skill: ["skill_list", "skill_execute", "skill_search"]
+    };
+    TOOL_AUTO_DEMOTE_TURNS = 10;
     SYSTEM_PROMPT = loadPrompt("agentic/system-large.md");
     SYSTEM_PROMPT_MEDIUM = loadPrompt("agentic/system-medium.md");
     SYSTEM_PROMPT_SMALL = loadPrompt("agentic/system-small.md");
@@ -517222,6 +517714,21 @@ var init_agenticRunner = __esm({
       _patchHistoryStore = null;
       _toolSequence = [];
       // Track tool calls for pattern detection
+      // Phase 2 — tool subset expansion and usage tracking.
+      // Tools promoted from deferred → inline by tool_search (or by subset
+      // expansion). They stay inline for the rest of the run unless idle past
+      // TOOL_AUTO_DEMOTE_TURNS, at which point buildToolDefinitions drops them
+      // back to deferred to reclaim token budget.
+      _activatedTools = /* @__PURE__ */ new Set();
+      _toolLastUsedTurn = /* @__PURE__ */ new Map();
+      // Phase 1 — Context Tree. Tracks current phase + per-phase anchors so
+      // compactMessages can summarize-by-phase and Phase 6 can surface anchors
+      // by keyword. Initialized lazily in run() because the system-prompt hash
+      // depends on the actual prompt resolved at run time.
+      _contextTree = null;
+      // 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();
       /** WO-AM-10: Process pending episode embeddings in background batches */
       async processPendingEmbeddings() {
         if (this._pendingEmbeddings.length === 0 || !this._episodeStore)
@@ -517280,7 +517787,11 @@ var init_agenticRunner = __esm({
           personality: options2?.personality ?? PERSONALITY_PRESETS.balanced,
           personalityName: options2?.personalityName ?? "",
           finalVarResolver: options2?.finalVarResolver ?? void 0,
-          observerMode: options2?.observerMode ?? "both"
+          observerMode: options2?.observerMode ?? "both",
+          // Phase 4 — sub-agent isolation flag (defaults false). When true, this
+          // runner skips cross-task handoff inheritance from the parent's
+          // session.
+          subAgent: options2?.subAgent ?? false
         };
         this._observerMode = this.options.observerMode;
       }
@@ -517685,6 +518196,212 @@ ${body}`;
        * Hannover reference: services/compact/apiMicrocompact.ts
        * Research: arXiv:2307.03172 (Lost in the Middle — recent context matters most)
        */
+      /**
+       * Phase 5 — Proactive context pruning (precedes microcompact). Targets
+       * specific waste patterns rather than blanket-clearing old tool results:
+       *
+       *   1. Duplicate tool calls — same (name, args) called multiple times.
+       *      Older instances replaced with "[deduped — see turn N]".
+       *   2. Aged file_read results — file_read older than `agedFileReadTurns`
+       *      replaced with a summary stub (path + size + first-line preview).
+       *   3. Successful shell/test runs — shell without error markers older
+       *      than `agedShellTurns` replaced with a "succeeded" stub.
+       *
+       * Mutates `messages` in place. Cheap O(n) walk; safe to run every turn.
+       * Refs: proposal §3 Phase 5, AgentFold (arXiv:2510.24699) progressive
+       * summarization, RECOMP (ICLR 2024) observation masking.
+       */
+      proactivePrune(messages2, currentTurn) {
+        if (process.env["OA_DISABLE_PROACTIVE_PRUNE"] === "1")
+          return;
+        const AGED_FILE_READ_TURNS = 10;
+        const AGED_SHELL_TURNS = 5;
+        const ERROR_MARKERS = /(?:error|fail|exception|traceback|enoent|enotfound|exit code [^0]|status[: ]+1\d?\d?)/i;
+        const PRUNE_PREFIX = "[Tool result cleared";
+        const DEDUPE_PREFIX = "[deduped — same call as turn";
+        const FILE_AGED_PREFIX = "[file_read aged out, summary:";
+        const SHELL_AGED_PREFIX = "[shell succeeded, output pruned —";
+        const seen = /* @__PURE__ */ new Map();
+        const pending = [];
+        let scanTurn = 0;
+        for (let i2 = 0; i2 < messages2.length; i2++) {
+          const msg = messages2[i2];
+          if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+            scanTurn++;
+            for (const tc of msg.tool_calls) {
+              const name10 = tc.function.name;
+              const argsRaw = (tc.function.arguments ?? "").slice(0, 200);
+              const fp = `${name10}|${argsRaw}`;
+              let resultIdx = -1;
+              for (let j = i2 + 1; j < Math.min(messages2.length, i2 + 8); j++) {
+                const r2 = messages2[j];
+                if (r2.role === "tool" && r2.tool_call_id === tc.id) {
+                  resultIdx = j;
+                  break;
+                }
+              }
+              if (resultIdx === -1)
+                continue;
+              const resultMsg = messages2[resultIdx];
+              const content = typeof resultMsg.content === "string" ? resultMsg.content : "";
+              if (content.startsWith(PRUNE_PREFIX) || content.startsWith(DEDUPE_PREFIX) || content.startsWith(FILE_AGED_PREFIX) || content.startsWith(SHELL_AGED_PREFIX)) {
+                if (!seen.has(fp))
+                  seen.set(fp, { turn: scanTurn, idx: resultIdx });
+                continue;
+              }
+              const prior = seen.get(fp);
+              if (prior) {
+                pending.push({
+                  idx: prior.idx,
+                  reason: "dedupe",
+                  replacement: `${DEDUPE_PREFIX} ${scanTurn} — duplicate ${name10}() call]`
+                });
+                seen.set(fp, { turn: scanTurn, idx: resultIdx });
+                continue;
+              }
+              seen.set(fp, { turn: scanTurn, idx: resultIdx });
+              const ageTurns = currentTurn - scanTurn;
+              if (name10 === "file_read" && ageTurns > AGED_FILE_READ_TURNS && content.length > 200) {
+                const pathArg = (() => {
+                  try {
+                    const o2 = JSON.parse(tc.function.arguments || "{}");
+                    return String(o2.path ?? o2.file ?? "?");
+                  } catch {
+                    return "?";
+                  }
+                })();
+                const firstLine = content.split("\n")[0]?.slice(0, 80) ?? "";
+                pending.push({
+                  idx: resultIdx,
+                  reason: "aged_file",
+                  replacement: `${FILE_AGED_PREFIX} path=${pathArg}, size=${content.length} chars, first-line="${firstLine}"]`
+                });
+                continue;
+              }
+              if ((name10 === "shell" || name10 === "shell_async" || name10 === "run_tests") && ageTurns > AGED_SHELL_TURNS && content.length > 200 && !ERROR_MARKERS.test(content)) {
+                const cmdArg = (() => {
+                  try {
+                    const o2 = JSON.parse(tc.function.arguments || "{}");
+                    return String(o2.command ?? o2.cmd ?? "?").slice(0, 80);
+                  } catch {
+                    return "?";
+                  }
+                })();
+                pending.push({
+                  idx: resultIdx,
+                  reason: "aged_shell",
+                  replacement: `${SHELL_AGED_PREFIX} command="${cmdArg}", output ${content.length} chars, no error markers detected]`
+                });
+              }
+            }
+          }
+        }
+        if (pending.length === 0)
+          return;
+        let dedupes = 0, agedFiles = 0, agedShells = 0;
+        for (const p2 of pending) {
+          const m2 = messages2[p2.idx];
+          if (!m2)
+            continue;
+          messages2[p2.idx] = { ...m2, content: p2.replacement };
+          if (p2.reason === "dedupe")
+            dedupes++;
+          else if (p2.reason === "aged_file")
+            agedFiles++;
+          else if (p2.reason === "aged_shell")
+            agedShells++;
+        }
+        const parts = [];
+        if (dedupes > 0)
+          parts.push(`${dedupes} duplicate call(s)`);
+        if (agedFiles > 0)
+          parts.push(`${agedFiles} aged file_read(s)`);
+        if (agedShells > 0)
+          parts.push(`${agedShells} aged shell run(s)`);
+        if (parts.length > 0) {
+          this.emit({
+            type: "status",
+            content: `Proactive prune: replaced ${parts.join(", ")} with summary stubs`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }
+      /**
+       * Phase 6 — Anchor Surfacing.
+       *
+       * Scans the most recent user / assistant text for keyword overlap with
+       * the ContextTree's anchor index plus the memex archive index. When
+       * matches are found, injects a single-line system hint listing the
+       * available anchors so the model knows what archived context exists
+       * (and may call memex_retrieve to expand it).
+       *
+       * Refs: proposal §3 Phase 6, Lost-in-the-Middle (arXiv:2307.03172) —
+       * surfacing relevant context near the tail combats positional decay.
+       */
+      surfaceAnchors(messages2) {
+        if (process.env["OA_DISABLE_ANCHOR_SURFACING"] === "1")
+          return;
+        if (!this._contextTree)
+          return;
+        if (messages2.length === 0)
+          return;
+        const tail = messages2.slice(-6);
+        const queryParts = [];
+        for (const m2 of tail) {
+          if (typeof m2.content === "string" && m2.content.length > 0) {
+            if (m2.role === "user" || m2.role === "assistant") {
+              queryParts.push(m2.content);
+            }
+          }
+        }
+        const query = queryParts.join(" ").slice(0, 800);
+        if (!query)
+          return;
+        const anchors = this._contextTree.findAnchorsByKeywords(query, 5);
+        const memexMatches = [];
+        if (this._memexArchive.size > 0) {
+          const tokens = query.toLowerCase().replace(/[^\w./-]+/g, " ").split(/\s+/).filter((t2) => t2.length > 3);
+          const tokenSet = new Set(tokens);
+          for (const e2 of this._memexArchive.values()) {
+            const summaryLower = e2.summary.toLowerCase();
+            let score = 0;
+            for (const t2 of tokenSet) {
+              if (summaryLower.includes(t2))
+                score += 2;
+            }
+            if (e2.toolName === "todo_complete" && tokenSet.has("todo"))
+              score += 1;
+            if (score > 0)
+              memexMatches.push({ id: e2.id, summary: e2.summary, score });
+          }
+          memexMatches.sort((a2, b) => b.score - a2.score);
+        }
+        const newAnchors = anchors.filter((a2) => !this._lastSurfacedAnchorIds.has(a2.id)).slice(0, 3);
+        const newMemex = memexMatches.filter((m2) => !this._lastSurfacedAnchorIds.has(m2.id)).slice(0, 2);
+        if (newAnchors.length === 0 && newMemex.length === 0)
+          return;
+        const lines = [`[Anchor surface] Relevant archived context for the current activity:`];
+        for (const a2 of newAnchors) {
+          lines.push(`  - [${a2.type}] ${a2.summary}`);
+        }
+        for (const m2 of newMemex) {
+          lines.push(`  - [memex:${m2.id}] ${m2.summary} — call memex_retrieve("${m2.id}") for full body`);
+        }
+        lines.push(`(Anchors are reminders. Pull only what you actually need; ignore otherwise.)`);
+        messages2.push({
+          role: "system",
+          content: lines.join("\n")
+        });
+        for (const a2 of newAnchors)
+          this._lastSurfacedAnchorIds.add(a2.id);
+        for (const m2 of newMemex)
+          this._lastSurfacedAnchorIds.add(m2.id);
+        this.emit({
+          type: "status",
+          content: `Anchor surface: surfaced ${newAnchors.length} anchor(s) + ${newMemex.length} memex entry(ies)`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
       microcompact(messages2, recentToolResults) {
         const tier = this.options.modelTier ?? "large";
         let keepResults = tier === "small" ? 6 : tier === "medium" ? 10 : 20;
@@ -518056,6 +518773,10 @@ Respond with your assessment, then take action.`;
         this.aborted = false;
         this._paused = false;
         this._toolSequence = [];
+        this._activatedTools.clear();
+        this._toolLastUsedTurn.clear();
+        this._contextTree = null;
+        this._lastSurfacedAnchorIds.clear();
         if (!this._memoryInitialized) {
           try {
             const path8 = await import("node:path");
@@ -518135,6 +518856,7 @@ Respond with your assessment, then take action.`;
         this._hookManager.runSessionHook("session_start", this._sessionId);
         const contextComposition = await this.assembleContext(task, context2);
         const systemPrompt = contextComposition.assembled;
+        this._contextTree = new ContextTree(`sys-${systemPrompt.length}`, cleanedTask.slice(0, 200));
         this.emit({
           type: "status",
           content: `Context assembled: ${contextComposition.sections.map((s2) => `${s2.label}(${s2.tokenEstimate}t)`).join(" + ")} = ~${contextComposition.totalTokenEstimate}t`,
@@ -518152,6 +518874,8 @@ TASK: ${task}` : task;
           { role: "user", content: userContent }
         ];
         try {
+          if (this.options.subAgent)
+            throw "skip-handoff-subagent";
           const oaDir = this._workingDirectory ? _pathJoin(this._workingDirectory, ".oa") : _pathJoin(process.cwd(), ".oa");
           const chainPairs = loadMessagePairsFromLog(oaDir, { currentTask: cleanedTask });
           if (chainPairs.length > 0) {
@@ -518590,7 +519314,9 @@ ${memoryLines.join("\n")}`
             }
           }
           this._lastAssistantTimestamp = Date.now();
+          this.proactivePrune(compacted, turn);
           this.microcompact(compacted, recentToolResults);
+          this.surfaceAnchors(compacted);
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
           const chatRequest = {
             messages: compacted,
@@ -518879,6 +519605,28 @@ ${memoryLines.join("\n")}`
               toolCallCount++;
               const argsKey = Object.entries(tc.arguments ?? {}).sort(([a2], [b]) => a2.localeCompare(b)).map(([k, v]) => `${k}=${typeof v === "string" ? v.slice(0, 160) : JSON.stringify(v).slice(0, 160)}`).join(",");
               toolCallLog.push({ name: tc.name, argsKey, turn, timestampMs: Date.now() });
+              this._toolLastUsedTurn.set(tc.name, turn);
+              if (this._contextTree) {
+                this._contextTree.observeToolCall(tc.name, argsKey, turn);
+                const transition = this._contextTree.maybeTransition(turn);
+                if (transition) {
+                  this.emit({
+                    type: "status",
+                    content: `Phase: ${transition.from} → ${transition.to}`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  const contracted = this._contextTree.contractInactive(turn);
+                  if (contracted.length > 0) {
+                    this.emit({
+                      type: "status",
+                      content: `Phase contraction: ${contracted.join(", ")} → contracted (anchors retained)`,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  }
+                  this._taskState.phase = transition.to;
+                  this._taskState.phaseSince = turn;
+                }
+              }
               const budgetRemaining = toolCallBudget.get(tc.name);
               if (budgetRemaining !== void 0) {
                 if (budgetRemaining <= 0) {
@@ -519891,7 +520639,9 @@ Integrate this guidance into your current approach. Continue working on the task
             } else {
               compactedMsgs = await this.compactMessages(messages2, this._skillCompactionStrategy ?? "default");
             }
+            this.proactivePrune(compactedMsgs, this._taskState.toolCallCount);
             this.microcompact(compactedMsgs);
+            this.surfaceAnchors(compactedMsgs);
             const chatRequest = { messages: compactedMsgs, tools: toolDefs, temperature: this.options.temperature, maxTokens: this.options.maxTokens, timeoutMs: this.options.requestTimeoutMs };
             let response;
             try {
@@ -520238,6 +520988,8 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
             }
           }
           try {
+            if (this.options.subAgent)
+              throw "skip-handoff-write-subagent";
             const outcome = consolidation.outcome === "success" ? "success" : consolidation.outcome === "aborted" ? "aborted" : consolidation.outcome === "timeout" ? "timeout" : "failed";
             const oaDir = this._workingDirectory ? _pathJoin(this._workingDirectory, ".oa") : _pathJoin(process.cwd(), ".oa");
             const transcriptPath = _pathJoin(oaDir, "consolidations", `${this._sessionId}.json`);
@@ -520678,6 +521430,9 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
         if (ts.currentStep) {
           parts.push(`**Currently doing:** ${ts.currentStep}`);
         }
+        if (ts.phase) {
+          parts.push(`**Phase:** ${ts.phase}`);
+        }
         if (ts.completedSteps.length > 0) {
           parts.push(`**Completed:**`);
           for (const s2 of ts.completedSteps.slice(-10))
@@ -520702,9 +521457,75 @@ Actions: (1) list_directory on the parent directory to see what's there, (2) Che
             parts.push(`- \`${path8}\` (${action})`);
           }
         }
+        const todoBlock = this.formatCompletedTodoAnchors();
+        if (todoBlock)
+          parts.push(todoBlock);
         parts.push(`**Tool calls:** ${ts.toolCallCount}`);
         return parts.join("\n");
       }
+      /**
+       * Phase 3 — render completed todos as compact anchor cards. Older
+       * completed todos beyond the top-3 are archived to memex on first sight
+       * so the model can still reach them via memex_retrieve. Returns the empty
+       * string when the session has no todos.
+       *
+       * Anchor card shape: `[done] {content slice} (files: a.ts, b.ts) → outcome`
+       */
+      formatCompletedTodoAnchors() {
+        try {
+          const sessionId = process.env["OA_SESSION_ID"] || this._sessionId;
+          const todos = readTodos(sessionId);
+          if (todos.length === 0)
+            return "";
+          const completed = todos.filter((t2) => t2.status === "completed");
+          const blocked = todos.filter((t2) => t2.status === "blocked");
+          if (completed.length === 0 && blocked.length === 0)
+            return "";
+          const parts = [];
+          const topRecent = completed.sort((a2, b) => (b.completedAt || b.updatedAt) - (a2.completedAt || a2.updatedAt)).slice(0, 3);
+          if (topRecent.length > 0) {
+            parts.push(`**Recently completed (anchors):**`);
+            for (const t2 of topRecent) {
+              parts.push(`- [done] ${this.todoAnchorLine(t2)}`);
+            }
+          }
+          const olderCompleted = completed.slice(3);
+          let archivedCount = 0;
+          for (const t2 of olderCompleted) {
+            const memexId = `todo-${t2.id.slice(0, 8)}`;
+            if (!this._memexArchive.has(memexId)) {
+              this._memexArchive.set(memexId, {
+                id: memexId,
+                toolName: "todo_complete",
+                summary: this.todoAnchorLine(t2),
+                fullContent: JSON.stringify(t2, null, 2),
+                turn: this._taskState.toolCallCount,
+                timestamp: new Date(t2.completedAt || t2.updatedAt).toISOString()
+              });
+              archivedCount++;
+            }
+          }
+          if (archivedCount > 0) {
+            parts.push(`*(${archivedCount} older completed todo(s) archived → memex_retrieve("todo-{id}") for details, ${olderCompleted.length} total older)*`);
+          } else if (olderCompleted.length > 0) {
+            parts.push(`*(${olderCompleted.length} older completed todo(s) in memex archive)*`);
+          }
+          if (blocked.length > 0) {
+            parts.push(`**Blocked:**`);
+            for (const t2 of blocked.slice(0, 5)) {
+              parts.push(`- [blocked] ${t2.content}${t2.blocker ? ` — ${t2.blocker}` : ""}`);
+            }
+          }
+          return parts.length > 0 ? parts.join("\n") : "";
+        } catch {
+          return "";
+        }
+      }
+      /** Build a single-line anchor for a completed todo (Phase 3 helper). */
+      todoAnchorLine(t2) {
+        const content = t2.content.length > 80 ? t2.content.slice(0, 77) + "..." : t2.content;
+        return content;
+      }
       /**
        * Format file state registry as compact markdown for domain-aware compaction.
        * Only includes files with meaningful state (modified or recently accessed).
@@ -520954,6 +521775,33 @@ ${taskStateStr}
           if (memexIndexStr)
             enrichments.push(memexIndexStr);
         }
+        if (this._contextTree) {
+          const droppedSlice = messages2.slice(headEndIdx, recentStart);
+          const freshAnchors = extractAnchorsFromMessages(droppedSlice, this._taskState.toolCallCount);
+          if (freshAnchors.length > 0) {
+            const tree2 = this._contextTree;
+            const phase = tree2.getCurrentPhase();
+            const snap = tree2.getSnapshot();
+            if (!snap.phases[phase]) {
+              snap.phases[phase] = {
+                status: "active",
+                messages: [],
+                anchors: [],
+                startedAtTurn: this._taskState.toolCallCount
+              };
+            }
+            snap.phases[phase].anchors = [
+              ...snap.phases[phase].anchors,
+              ...freshAnchors
+            ].slice(-12);
+          }
+          const phaseStatus = this._contextTree.renderStatusBlock();
+          if (phaseStatus)
+            enrichments.push(phaseStatus);
+          const anchorBlock = this._contextTree.renderAnchorBlock();
+          if (anchorBlock)
+            enrichments.push(anchorBlock);
+        }
         const postCompactRestore = [];
         const planSkel = this.buildPlanSkeleton();
         if (planSkel)
@@ -522185,7 +523033,7 @@ ${transcript}`
         const allTools = Array.from(this.tools.values()).filter((tool) => tool.name !== "tool_search");
         const tier = this.options.modelTier ?? "large";
         const taskGoal = this._taskState.goal || "";
-        const STOPWORDS = /* @__PURE__ */ new Set([
+        const STOPWORDS2 = /* @__PURE__ */ new Set([
           "with",
           "that",
           "this",
@@ -522235,7 +523083,7 @@ ${transcript}`
         const getDesc = (tool) => dynamicDescs.get(tool.name) ?? tool.description;
         const getIndexLabel = (tool) => {
           const desc = getDesc(tool).toLowerCase().replace(/[`"'()[\]{}:;,.!?/\\|-]+/g, " ");
-          const keywords = Array.from(new Set(desc.split(/\s+/).filter((word2) => word2.length > 2 && !STOPWORDS.has(word2) && !tool.name.toLowerCase().includes(word2)))).slice(0, 4);
+          const keywords = Array.from(new Set(desc.split(/\s+/).filter((word2) => word2.length > 2 && !STOPWORDS2.has(word2) && !tool.name.toLowerCase().includes(word2)))).slice(0, 4);
           return keywords.length > 0 ? `${tool.name}(${keywords.join(",")})` : tool.name;
         };
         const CORE_TOOLS2 = /* @__PURE__ */ new Set([
@@ -522283,9 +523131,26 @@ ${transcript}`
         scored.sort((a2, b) => b.score - a2.score);
         const maxInlineExtra = tier === "small" ? 4 : 8;
         const inlineExtras = scored.slice(0, maxInlineExtra).filter((s2) => s2.score > 0);
+        const currentTurn = this._taskState.toolCallCount;
+        let demoted = 0;
+        for (const promoted of this._activatedTools) {
+          const lastUsed = this._toolLastUsedTurn.get(promoted) ?? -1;
+          if (lastUsed >= 0 && currentTurn - lastUsed > TOOL_AUTO_DEMOTE_TURNS) {
+            this._activatedTools.delete(promoted);
+            demoted++;
+          }
+        }
+        if (demoted > 0) {
+          this.emit({
+            type: "status",
+            content: `Tool auto-demote: ${demoted} idle promoted tool(s) dropped back to deferred`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
         const inlineNames = /* @__PURE__ */ new Set([
           ...allTools.filter((t2) => CORE_TOOLS2.has(t2.name)).map((t2) => t2.name),
-          ...inlineExtras.map((s2) => s2.tool.name)
+          ...inlineExtras.map((s2) => s2.tool.name),
+          ...Array.from(this._activatedTools).filter((name10) => allTools.some((t2) => t2.name === name10))
         ]);
         const deferred = allTools.filter((t2) => !inlineNames.has(t2.name));
         const inlineTools = allTools.filter((t2) => inlineNames.has(t2.name));
@@ -522317,11 +523182,12 @@ ${transcript}`
             lines[lineIdx].push(entry);
             return lines;
           }, []).map((line) => `- ${line.join(", ")}`).join("\n");
+          const subsetNames = Object.keys(TOOL_SUBSETS).join(", ");
           defs.push({
             type: "function",
             function: {
               name: "tool_search",
-              description: `Search for and activate additional tools not in your current tool list. Call this when your task needs a tool you don't have. Pass a search query describing what you need. The catalog below is a compact index; full schemas are returned only after search.
+              description: `Search for and activate additional tools not in your current tool list. Call this when your task needs a tool you don't have. Pass a search query describing what you need. The catalog below is a compact index; full schemas are returned only after search. Subset shortcuts (call tool_search with one of these as the query to promote the whole group at once): ${subsetNames}.
 
 Available tools (${deferred.length}):
 ${catalog}`,
@@ -522334,16 +523200,64 @@ ${catalog}`,
               }
             }
           });
+          const activatedToolsRef = this._activatedTools;
+          const subsetCatalog = TOOL_SUBSETS;
           this.tools.set("tool_search", {
             name: "tool_search",
             description: "Search for deferred tools",
             parameters: {},
             execute: async (args) => {
-              const query = String(args["query"] ?? "").toLowerCase();
+              const query = String(args["query"] ?? "").toLowerCase().trim();
+              const subsetMatch = subsetCatalog[query];
+              if (subsetMatch && subsetMatch.length > 0) {
+                const newlyPromoted = [];
+                const alreadyAvailable = [];
+                const unknown = [];
+                for (const name10 of subsetMatch) {
+                  const tool = deferred.find((t2) => t2.name === name10) ?? allTools.find((t2) => t2.name === name10);
+                  if (!tool) {
+                    unknown.push(name10);
+                    continue;
+                  }
+                  if (inlineNames.has(name10)) {
+                    alreadyAvailable.push(name10);
+                    continue;
+                  }
+                  activatedToolsRef.add(name10);
+                  newlyPromoted.push(name10);
+                }
+                const lines = [`Subset "${query}" expanded:`];
+                if (newlyPromoted.length > 0) {
+                  lines.push(`  Promoted to inline (${newlyPromoted.length}): ${newlyPromoted.join(", ")}`);
+                  for (const name10 of newlyPromoted) {
+                    const tool = allTools.find((t2) => t2.name === name10);
+                    if (!tool)
+                      continue;
+                    lines.push("");
+                    lines.push(`## ${tool.name}`);
+                    lines.push(getDesc(tool));
+                    lines.push(`Parameters: ${JSON.stringify(tool.parameters)}`);
+                  }
+                }
+                if (alreadyAvailable.length > 0) {
+                  lines.push(`  Already inline (${alreadyAvailable.length}): ${alreadyAvailable.join(", ")}`);
+                }
+                if (unknown.length > 0) {
+                  lines.push(`  Not registered (${unknown.length}): ${unknown.join(", ")}`);
+                }
+                return { success: true, output: lines.join("\n") };
+              }
               const matches = deferred.filter((t2) => t2.name.toLowerCase().includes(query) || getDesc(t2).toLowerCase().includes(query)).slice(0, 5);
               if (matches.length === 0) {
-                return { success: false, output: "", error: `No tools matching "${query}". Try a broader search.` };
+                const subsetHint = Object.keys(subsetCatalog).join(", ");
+                return {
+                  success: false,
+                  output: "",
+                  error: `No tools matching "${query}". Try a broader search, or call a subset name directly: ${subsetHint}.`
+                };
               }
+              for (const t2 of matches)
+                activatedToolsRef.add(t2.name);
               const result = matches.map((t2) => {
                 const paramsStr = JSON.stringify(t2.parameters, null, 2);
                 return `## ${t2.name}
@@ -522354,7 +523268,7 @@ ${paramsStr}`;
               }).join("\n\n---\n\n");
               return {
                 success: true,
-                output: `Found ${matches.length} tool(s). You can now call them directly:
+                output: `Found ${matches.length} tool(s) — promoted to inline for the rest of this run:
 
 ${result}`
               };
@@ -586285,7 +587199,12 @@ Review its full output in the [${id}] tab or via sub_agent(action='output', id='
             compactionThreshold: subCompaction,
             contextWindowSize: 0,
             // sub-agents discover their own context window
-            modelTier: subTier
+            modelTier: subTier,
+            // Phase 4 — sub-agent isolation: skip parent's cross-task handoff
+            // read AND write. The sub-agent gets only what AgentTool composed
+            // into the prompt (relevantFiles + constraints + task), nothing
+            // leaked from the parent's session log or .oa/handoffs/latest.json.
+            subAgent: opts.subAgentMode === true
           });
           const allSafe = buildSubAgentTools(repoRoot, config);
           const nameSet = new Set(opts.toolNames || []);

package/npm-shrinkwrap.json

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

package/package.json

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