pi-fast-subagent 0.9.1 → 0.9.2

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.
 
@@ -272,6 +272,14 @@ Cancel a specific job directly:
 /fast-subagent:bg-cancel sa_ab12cd34
 ```
 
+### `/fast-subagent:debug-model`
+
+Show cached/inferred main-model state used for model inheritance troubleshooting.
+
+```
+/fast-subagent:debug-model
+```
+
 ## Keyboard Shortcuts
 
 | Shortcut | Action |
@@ -289,7 +297,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

@@ -27,7 +27,7 @@ import {
 } from "./format.js";
 import { defaultLoaderPool } from "./loader-pool.js";
 import { renderSubagentCall, renderSubagentResult } from "./render.js";
-import { getCurrentDepth, mapConcurrent, runAgent } from "./runner.js";
+import { DEPTH_ENV, getCurrentDepth, mapConcurrent, resolveModelObject, runAgent } from "./runner.js";
 import { SubagentParams } from "./schemas.js";
 import type { AgentRowStatus, OnUpdate, RunResult, SubagentDetails, ToolCallEntry } from "./types.js";
 
@@ -36,6 +36,9 @@ import type { AgentRowStatus, OnUpdate, RunResult, SubagentDetails, ToolCallEntr
 let _bgManager: BackgroundJobManager | null = null;
 let _onBgJobComplete: ((job: BackgroundSubagentJob) => void) | null = null;
 let _setBgStatus: ((text: string | undefined) => void) | null = null;
+let _currentMainModel: string | undefined;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let _currentMainModelObject: any | undefined;
 
 function getBgManager(): BackgroundJobManager {
   if (!_bgManager) _bgManager = new BackgroundJobManager({
@@ -49,6 +52,54 @@ function refreshBgStatus(): void {
   _setBgStatus?.(running.length > 0 ? `⧗ ${running.length} bg agent${running.length > 1 ? "s" : ""}` : undefined);
 }
 
+function rememberMainModel(model: ExtensionContext["model"]): void {
+  if (!model) return;
+  _currentMainModel = `${model.provider}/${model.id}`;
+  _currentMainModelObject = model;
+}
+
+function rememberMainModelReference(modelRef: string | undefined, ctx: ExtensionContext): void {
+  if (!modelRef) return;
+  _currentMainModel = modelRef;
+  _currentMainModelObject = resolveModelObject(ctx.modelRegistry, modelRef) ?? _currentMainModelObject;
+}
+
+function rememberPayloadModel(payload: unknown, ctx: ExtensionContext): void {
+  const modelId = typeof payload === "object" && payload && "model" in payload && typeof (payload as { model?: unknown }).model === "string"
+    ? (payload as { model: string }).model
+    : undefined;
+  if (!modelId) return;
+
+  const lower = modelId.toLowerCase();
+  const matches = ctx.modelRegistry.getAll().filter((m) => m.id.toLowerCase() === lower || `${m.provider}/${m.id}`.toLowerCase() === lower);
+  if (matches.length === 1) rememberMainModel(matches[0]);
+}
+
+function isMainSessionEvent(): boolean {
+  return !process.env[DEPTH_ENV];
+}
+
+function rememberLatestSessionModel(ctx: ExtensionContext): void {
+  const scan = (entries: ReturnType<ExtensionContext["sessionManager"]["getEntries"]>): boolean => {
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const e = entries[i]!;
+      if (e.type === "model_change") {
+        rememberMainModelReference(`${(e as any).provider}/${(e as any).modelId}`, ctx);
+        return true;
+      }
+    }
+    return false;
+  };
+  if (!scan(ctx.sessionManager.getEntries())) scan(ctx.sessionManager.getBranch());
+}
+
+function getInheritedMainModel(ctx: ExtensionContext): { modelRef?: string; deps: { modelRegistry: ExtensionContext["modelRegistry"]; modelObject?: unknown } } {
+  rememberMainModel(ctx.model);
+  if (!_currentMainModelObject && _currentMainModel) rememberMainModelReference(_currentMainModel, ctx);
+  if (_currentMainModelObject) return { modelRef: _currentMainModel, deps: { modelRegistry: ctx.modelRegistry, modelObject: _currentMainModelObject } };
+  return { modelRef: _currentMainModel, deps: { modelRegistry: ctx.modelRegistry } };
+}
+
 // ─── Foreground detach registry ─────────────────────────────────────────────
 
 interface ForegroundDetachEntry {
@@ -84,8 +135,28 @@ export default function (pi: ExtensionAPI) {
     );
   };
 
+  pi.on("model_select", async (event) => {
+    if (!isMainSessionEvent()) return;
+    rememberMainModel(event.model);
+  });
+
+  pi.on("before_provider_request", async (event, ctx) => {
+    if (!isMainSessionEvent()) return;
+    if (ctx.model) rememberMainModel(ctx.model);
+    else rememberPayloadModel(event.payload, ctx);
+  });
+
+  pi.on("turn_start", async (_event, ctx) => {
+    if (!isMainSessionEvent()) return;
+    rememberMainModel(ctx.model);
+  });
+
   pi.on("session_start", async (_event, ctx) => {
     _setBgStatus = (text) => ctx.ui.setStatus(BG_STATUS_KEY, text);
+    if (!isMainSessionEvent()) return;
+    // Seed _currentMainModel from ctx.model or session entries.
+    if (ctx.model) rememberMainModel(ctx.model);
+    else rememberLatestSessionModel(ctx);
 
     // Warm one extension-capable loader after startup so first `tools: all`
     // subagent call reuses loaded extensions instead of blocking.
@@ -100,6 +171,8 @@ export default function (pi: ExtensionAPI) {
     getBgManager().shutdown();
     _bgManager = null;
     _setBgStatus = null;
+    _currentMainModel = undefined;
+    _currentMainModelObject = undefined;
     defaultLoaderPool.clear();
   });
 
@@ -124,6 +197,30 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
+  // ─── /fast-subagent:debug-model ──────────────────────────────────────────
+  pi.registerCommand("fast-subagent:debug-model", {
+    description: "Debug: show cached main model and session entries.",
+    async handler(_args, ctx) {
+      const entries = ctx.sessionManager.getEntries();
+      const modelEntries = entries.filter((e) => e.type === "model_change");
+      const branch = ctx.sessionManager.getBranch();
+      const branchModelEntries = branch.filter((e) => e.type === "model_change");
+      if (!_currentMainModelObject && _currentMainModel) rememberMainModelReference(_currentMainModel, ctx);
+      const registryMatch = resolveModelObject(ctx.modelRegistry, _currentMainModel);
+      const lines = [
+        `_currentMainModel: ${_currentMainModel ?? "(undefined)"}`,
+        `_currentMainModelObject: ${_currentMainModelObject ? `${_currentMainModelObject.provider}/${_currentMainModelObject.id}` : "(undefined)"}`,
+        `ctx.model: ${ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "(undefined)"}`,
+        `resolveModelObject(_currentMainModel): ${registryMatch ? `${registryMatch.provider}/${registryMatch.id}` : "(undefined)"}`,
+        `getEntries() total: ${entries.length}`,
+        `getEntries() model_change: ${modelEntries.map((e) => `${(e as any).provider}/${(e as any).modelId}`).join(", ") || "none"}`,
+        `getBranch() total: ${branch.length}`,
+        `getBranch() model_change: ${branchModelEntries.map((e) => `${(e as any).provider}/${(e as any).modelId}`).join(", ") || "none"}`,
+      ];
+      ctx.ui.notify(lines.join("\n"), "info");
+    },
+  });
+
   // ─── /fast-subagent:agent ─────────────────────────────────────────────────
   pi.registerCommand("fast-subagent:agent", {
     description: "List available subagents. Usage: /fast-subagent:agent [name] — show details for a specific agent.",
@@ -417,11 +514,26 @@ export default function (pi: ExtensionAPI) {
         const { agent, error } = findAgent(params.agent);
         if (error || !agent) return { content: [{ type: "text", text: error ?? "Not found" }] };
 
+        // Determine if this agent should inherit the main session's model.
+        const shouldInherit = !params.model && (!agent.model || agent.model === "inherit");
+        let inheritedModel: string | undefined;
+        let inheritDeps: { modelRegistry: ExtensionContext["modelRegistry"]; modelObject?: unknown } = { modelRegistry: ctx.modelRegistry };
+        if (shouldInherit) {
+          let inherited = getInheritedMainModel(ctx);
+          if (!inherited.modelRef) {
+            rememberLatestSessionModel(ctx);
+            inherited = getInheritedMainModel(ctx);
+          }
+          inheritedModel = inherited.modelRef;
+          inheritDeps = inherited.deps;
+        }
+        const effectiveModel = params.model ?? (shouldInherit ? inheritedModel : (agent.model === "inherit" ? undefined : agent.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, undefined, inheritDeps,
           ).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 +553,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, undefined, inheritDeps,
         );
 
         const bgResultPromise: Promise<BackgroundJobResult> = agentRunPromise
@@ -546,7 +658,18 @@ 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 shouldInherit = !t.model && (!agent.model || agent.model === "inherit");
+          const inherited = shouldInherit ? getInheritedMainModel(ctx) : undefined;
+          const result = await runAgent(
+            agent,
+            t.task,
+            t.cwd ?? cwd,
+            t.model ?? inherited?.modelRef,
+            signal,
+            agentOnUpdate,
+            parentDepth,
+            inherited?.deps ?? { modelRegistry: ctx.modelRegistry },
+          );
           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.2",
   "description": "In-process subagent delegation for pi with single, parallel, and background modes",
   "type": "module",
   "keywords": [

package/render.ts

@@ -334,11 +334,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 +359,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,6 +378,8 @@ export function renderSubagentResult(
           }
         }
       }
+
+      if (lastWasText) flushTextBuffer();
     }
 
     return out;

package/runner.ts

@@ -66,6 +66,62 @@ export function getCurrentDepth(): number {
 
 export interface RunAgentDeps {
   loaderPool?: LoaderPool;
+  modelRegistry?: ModelRegistry;
+  /** Pass a Model object directly to bypass registry lookup (used for model: inherit). */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  modelObject?: any;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function modelRef(model: any): string {
+  return `${model.provider}/${model.id}`;
+}
+
+/**
+ * Resolve provider/modelId into a Model object.
+ *
+ * `ModelRegistry.find()` only returns bundled/custom registry entries. Pi itself
+ * can run ad-hoc provider model IDs (for example via `--model
+ * anthropic/claude-sonnet-4-6`) by cloning provider config from a known model.
+ * Do same here so `model: inherit` can use main session's exact model ID even
+ * before pi's bundled registry knows it.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function resolveModelObject(modelRegistry: ModelRegistry, modelReference: string | undefined): any | undefined {
+  const ref = modelReference?.trim();
+  if (!ref) return undefined;
+
+  const allModels = modelRegistry.getAll();
+  const lowerRef = ref.toLowerCase();
+  const exact = allModels.find((m) => modelRef(m).toLowerCase() === lowerRef || m.id.toLowerCase() === lowerRef);
+  if (exact) return exact;
+
+  const slash = ref.indexOf("/");
+  if (slash === -1) return undefined;
+
+  const providerRef = ref.slice(0, slash).trim();
+  const modelId = ref.slice(slash + 1).trim();
+  if (!providerRef || !modelId) return undefined;
+
+  const providerModels = allModels.filter((m) => m.provider.toLowerCase() === providerRef.toLowerCase());
+  if (providerModels.length === 0) return undefined;
+  const provider = providerModels[0]!.provider;
+
+  const found = modelRegistry.find(provider, modelId);
+  if (found) return found;
+
+  // Unknown model ID for known provider: clone closest provider model so auth,
+  // API, baseUrl, headers, compat, cost shape, and token defaults survive.
+  const idLower = modelId.toLowerCase();
+  const family = ["opus", "sonnet", "haiku", "gpt", "gemini", "kimi", "glm", "grok"].find((token) => idLower.includes(token));
+  const familyModels = family ? providerModels.filter((m) => m.id.toLowerCase().includes(family)) : [];
+  const base = (familyModels[0] ?? providerModels[0])!;
+  return {
+    ...base,
+    provider,
+    id: modelId,
+    name: modelId,
+  };
 }
 
 export async function runAgent(
@@ -92,7 +148,8 @@ export async function runAgent(
   }
 
   const bootStartedAt = Date.now();
-  const { authStorage, modelRegistry } = getAuth();
+  const { authStorage, modelRegistry: defaultRegistry } = getAuth();
+  const modelRegistry = deps.modelRegistry ?? defaultRegistry;
   const agentDir = getAgentDir();
   const noExtensions = !agentNeedsExtensions(agent.tools);
   const coldLoader = !pool.isWarm(cwd, agentDir, noExtensions);
@@ -114,6 +171,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,
@@ -130,10 +189,13 @@ export async function runAgent(
       authStorage,
       modelRegistry,
       resourceLoader: loaderLease.loader,
+      ...(deps.modelObject ? { model: deps.modelObject } : {}),
     });
     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,17 +204,14 @@ export async function runAgent(
       usage: { input: 0, output: 0, cost: 0, turns: 0 },
     };
   }
-
-  // Resolve and apply model
-  const modelStr = modelOverride ?? agent.model;
-  if (modelStr) {
-    const [provider, ...rest] = modelStr.split("/");
-    const modelId = rest.join("/");
-    if (provider && modelId) {
-      const model = modelRegistry.find(provider, modelId);
-      if (model) await session.setModel(model);
-    }
-  }
+  if (createPrevEnvDepth === undefined) delete process.env[DEPTH_ENV];
+  else process.env[DEPTH_ENV] = createPrevEnvDepth;
+
+  // Resolve and apply model. Force this even when createAgentSession received
+  // modelObject so restore/default fallback cannot silently win.
+  const modelStr = modelOverride ?? (agent.model === "inherit" ? undefined : agent.model);
+  const model = deps.modelObject ?? resolveModelObject(modelRegistry, modelStr);
+  if (model) await session.setModel(model);
 
   // Apply tools allowlist.
   //   "all"    → no restriction (everything registered stays active)