pi-fast-subagent 0.9.1 → 0.9.3

package/README.md

@@ -1,6 +1,6 @@
 # pi-fast-subagent
 
-In-process subagent delegation for [pi](https://github.com/badlogic/pi-mono).
+In-process subagent delegation for [pi](https://github.com/badlogic/pi-mono) with max visibility.
 
 Runs subagents with `createAgentSession()` in same process instead of spawning `pi` subprocesses. This removes subprocess cold-start and reuses pi auth/model registry.
 
@@ -289,7 +289,7 @@ Goal: keep this extension **small and focused** — aligned with pi's philosophy
 
 - Async/background isolation not supported in-process
 - Git worktree isolation not supported
-- Nested subagent depth limited to 2 by default
+- Nested subagent spawning disabled by default (`maxDepth: 0`); opt in per agent via frontmatter
 
 ## Tool Reference
 

package/agents/scout.md

@@ -1,7 +1,7 @@
 ---
 name: scout
 description: Explores codebases, maps structure, traces data flow, answers how things work across many files
-model: anthropic/claude-haiku-4-5
+model: openai-codex/gpt-5.4-mini
 
 # tools: which tools this agent can use.
 #   (omit)               → all tools: builtins + every parent extension (default)
@@ -36,5 +36,6 @@ Output style:
 - use sections
 - include file paths
 - include short bullets
-- mention notable patterns, risks, and coupling
-- do not propose code changes unless asked
+- describe what code does, not whether it is good or bad
+- do not rate, review, or analyze quality
+- do not propose code changes

package/index.ts

@@ -49,6 +49,7 @@ function refreshBgStatus(): void {
   _setBgStatus?.(running.length > 0 ? `⧗ ${running.length} bg agent${running.length > 1 ? "s" : ""}` : undefined);
 }
 
+
 // ─── Foreground detach registry ─────────────────────────────────────────────
 
 interface ForegroundDetachEntry {
@@ -417,11 +418,13 @@ export default function (pi: ExtensionAPI) {
         const { agent, error } = findAgent(params.agent);
         if (error || !agent) return { content: [{ type: "text", text: error ?? "Not found" }] };
 
+        const effectiveModel = params.model;
+
         if (params.background) {
           const bgAbort = new AbortController();
           const handle: BackgroundHandleLike = { abort: () => bgAbort.abort() };
           const resultPromise: Promise<BackgroundJobResult> = runAgent(
-            agent, params.task, cwd, params.model, bgAbort.signal, undefined,
+            agent, params.task, cwd, effectiveModel, bgAbort.signal, undefined,
           ).then((r) => ({ summary: r.output, exitCode: r.exitCode, error: r.error, model: r.model }));
           const jobId = getBgManager().adoptHandle(agent.name, params.task, cwd, handle, resultPromise);
           return { content: [{ type: "text", text: `Background job started: ${jobId}\nTo check status, ask me to poll job ${jobId}.` }] };
@@ -441,7 +444,7 @@ export default function (pi: ExtensionAPI) {
           : undefined;
 
         const agentRunPromise: Promise<RunResult> = runAgent(
-          agent, params.task, cwd, params.model, agentAbort.signal, wrappedOnUpdate,
+          agent, params.task, cwd, effectiveModel, agentAbort.signal, wrappedOnUpdate,
         );
 
         const bgResultPromise: Promise<BackgroundJobResult> = agentRunPromise
@@ -546,7 +549,15 @@ export default function (pi: ExtensionAPI) {
             parallelAgents[i]!.responseText = (partial.content?.[0] as any)?.text || parallelAgents[i]!.responseText;
             emitParallel(true);
           };
-          const result = await runAgent(agent, t.task, t.cwd ?? cwd, t.model, signal, agentOnUpdate, parentDepth);
+          const result = await runAgent(
+            agent,
+            t.task,
+            t.cwd ?? cwd,
+            t.model,
+            signal,
+            agentOnUpdate,
+            parentDepth,
+          );
           parallelAgents[i]!.status = result.exitCode === 0 ? "done" : "error";
           parallelAgents[i]!.durMs = Date.now() - agentStart;
           parallelAgents[i]!.toolCalls = result.toolCalls;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fast-subagent",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "In-process subagent delegation for pi with single, parallel, and background modes",
   "type": "module",
   "keywords": [

package/render.ts

@@ -302,6 +302,16 @@ export function renderSubagentResult(
     promptSkipped?: number;
     responseLines?: string[];
     skipped?: number;
+    expandedWidth?: number;
+    expandedEventsLen?: number;
+    expandedLastEventTs?: number;
+    expandedTask?: string;
+    expandedAgentName?: string;
+    expandedToolCallsLen?: number;
+    expandedAgentTextLen?: number;
+    expandedBodyLines?: string[];
+    expandedFooterKey?: string;
+    expandedOutputLines?: string[];
   } = {};
 
   function renderExpandedChronological(width: number): string[] {
@@ -334,11 +344,22 @@ export function renderSubagentResult(
         }
       }
     } else {
-      // Render events chronologically
+      // Render events chronologically. Coalesce text deltas to avoid one-line-per-token output.
       let lastWasText = false;
+      let textBuffer = "";
       const agentLabel = `${details.agentName ?? "Agent"}:`;
+
+      const flushTextBuffer = () => {
+        if (!textBuffer) return;
+        for (const line of textBuffer.split("\n")) {
+          for (const w of wrapLine(indent + line, width)) out.push(w);
+        }
+        textBuffer = "";
+      };
+
       for (const evt of events) {
         if (evt.type === "tool_start") {
+          if (lastWasText) flushTextBuffer();
           lastWasText = false;
           const call = `${evt.toolName}(${evt.argSummary})`;
           toolLineMap.set(evt.toolCallId, out.length);
@@ -348,10 +369,9 @@ export function renderSubagentResult(
             out.push(truncateToWidth(theme.fg("toolTitle", agentLabel), width, "..."));
             lastWasText = true;
           }
-          for (const line of evt.text.split("\n")) {
-            for (const w of wrapLine(indent + line, width)) out.push(w);
-          }
+          textBuffer += evt.text;
         } else if (evt.type === "tool_end") {
+          if (lastWasText) flushTextBuffer();
           lastWasText = false;
           const toolLineIdx = toolLineMap.get(evt.toolCallId);
           const dur = evt.durMs != null
@@ -368,13 +388,27 @@ export function renderSubagentResult(
           }
         }
       }
+
+      if (lastWasText) flushTextBuffer();
     }
 
     return out;
   }
 
   return {
-    invalidate() { cache.width = undefined; },
+    invalidate() {
+      cache.width = undefined;
+      cache.expandedWidth = undefined;
+      cache.expandedEventsLen = undefined;
+      cache.expandedLastEventTs = undefined;
+      cache.expandedTask = undefined;
+      cache.expandedAgentName = undefined;
+      cache.expandedToolCallsLen = undefined;
+      cache.expandedAgentTextLen = undefined;
+      cache.expandedBodyLines = undefined;
+      cache.expandedFooterKey = undefined;
+      cache.expandedOutputLines = undefined;
+    },
     render(width: number): string[] {
       const out: string[] = [];
       const indent = "  ";
@@ -382,15 +416,52 @@ export function renderSubagentResult(
         theme.fg("muted", `${indent}… (${count} more line${count === 1 ? "" : "s"})`);
 
       if (expanded) {
-        // Expanded: render chronologically from events
-        const expandedOut = renderExpandedChronological(width);
-        expandedOut.push("");
+        const events = details.executionEvents || [];
+        const lastEventTs = events.length ? events[events.length - 1]!.timestamp : undefined;
+        const taskKey = details.task ?? "";
+        const agentKey = details.agentName ?? "";
+        const bodyCacheHit =
+          cache.expandedWidth === width
+          && cache.expandedEventsLen === events.length
+          && cache.expandedLastEventTs === lastEventTs
+          && cache.expandedTask === taskKey
+          && cache.expandedAgentName === agentKey
+          && cache.expandedToolCallsLen === toolCalls.length
+          && cache.expandedAgentTextLen === agentText.length
+          && Array.isArray(cache.expandedBodyLines);
+
+        let bodyLines: string[];
+        if (bodyCacheHit) {
+          bodyLines = cache.expandedBodyLines!;
+        } else {
+          bodyLines = renderExpandedChronological(width);
+          cache.expandedWidth = width;
+          cache.expandedEventsLen = events.length;
+          cache.expandedLastEventTs = lastEventTs;
+          cache.expandedTask = taskKey;
+          cache.expandedAgentName = agentKey;
+          cache.expandedToolCallsLen = toolCalls.length;
+          cache.expandedAgentTextLen = agentText.length;
+          cache.expandedBodyLines = bodyLines;
+          cache.expandedFooterKey = undefined;
+          cache.expandedOutputLines = undefined;
+        }
+
         const status = statusLine();
-        if (status) expandedOut.push(truncateToWidth(status, width, "..."));
-        if (details.running && !details.backgroundJobId) {
-          expandedOut.push(truncateToWidth(theme.fg("dim", "Ctrl+Shift+B: move to background"), width, "..."));
+        const bgHint = details.running && !details.backgroundJobId
+          ? truncateToWidth(theme.fg("dim", "Ctrl+Shift+B: move to background"), width, "...")
+          : "";
+        const footerKey = `${status}__${bgHint}`;
+
+        if (cache.expandedFooterKey !== footerKey || !Array.isArray(cache.expandedOutputLines)) {
+          const expandedOut = [...bodyLines, ""];
+          if (status) expandedOut.push(truncateToWidth(status, width, "..."));
+          if (bgHint) expandedOut.push(bgHint);
+          cache.expandedFooterKey = footerKey;
+          cache.expandedOutputLines = expandedOut;
         }
-        return expandedOut;
+
+        return cache.expandedOutputLines!;
       }
 
       // Collapsed view

package/runner.ts

@@ -114,6 +114,8 @@ export async function runAgent(
   });
   await allowUiPaint(coldLoader);
 
+  const createPrevEnvDepth = process.env[DEPTH_ENV];
+  process.env[DEPTH_ENV] = String(depth + 1);
   const loaderLease = await pool.acquire(
     cwd,
     agentDir,
@@ -134,6 +136,8 @@ export async function runAgent(
     session = created.session;
   } catch (e) {
     loaderLease.release();
+    if (createPrevEnvDepth === undefined) delete process.env[DEPTH_ENV];
+    else process.env[DEPTH_ENV] = createPrevEnvDepth;
     return {
       output: "",
       exitCode: 1,
@@ -142,6 +146,8 @@ export async function runAgent(
       usage: { input: 0, output: 0, cost: 0, turns: 0 },
     };
   }
+  if (createPrevEnvDepth === undefined) delete process.env[DEPTH_ENV];
+  else process.env[DEPTH_ENV] = createPrevEnvDepth;
 
   // Resolve and apply model
   const modelStr = modelOverride ?? agent.model;