@yandy0725/pi-subagents 0.1.0 → 0.2.2

package/package.json

@@ -3,7 +3,7 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"version": "0.1.0",
+	"version": "0.2.2",
 	"description": "Focused, in-process sub-agent core for pi — autonomous agents plus a typed API and lifecycle events",
 	"license": "MIT",
 	"repository": {
@@ -33,12 +33,10 @@
 		]
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-ai": ">=0.74.0",
-		"@earendil-works/pi-coding-agent": ">=0.74.0",
-		"@earendil-works/pi-tui": ">=0.74.0"
-	},
-	"dependencies": {
-		"@sinclair/typebox": "^0.34.49"
+		"@earendil-works/pi-ai": ">=0.80.2",
+		"@earendil-works/pi-coding-agent": ">=0.80.2",
+		"@earendil-works/pi-tui": ">=0.80.2",
+		"@sinclair/typebox": "*"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.5.0",

package/src/handlers/lifecycle.ts

@@ -1,3 +1,4 @@
+import type { EvictedSubagent } from "../lifecycle/subagent-manager";
 import type { SessionContext } from "../types";
 
 /**
@@ -12,6 +13,8 @@ export interface LifecycleManager {
 	clearCompleted(): void;
 	abortAll(): void;
 	dispose(): void;
+	/** Repopulate evicted descriptors recovered from disk on session start. */
+	restoreEvicted(descriptors: readonly EvictedSubagent[]): void;
 }
 
 /** Narrow runtime interface — only the methods lifecycle handlers call. */
@@ -20,14 +23,20 @@ export interface LifecycleRuntime {
 	clearSessionContext(): void;
 }
 
+/** Recovers evicted subagent descriptors from the parent session file. */
+export type RecoverEvicted = (parentSessionFile: string | undefined) => EvictedSubagent[];
+
 /**
  * Handles session lifecycle events.
  *
  * Constructor deps:
  * - `runtime` — owns session context state
- * - `manager` — manages agent lifecycle (clear, abort, dispose)
+ * - `manager` — manages agent lifecycle (clear, abort, dispose, restore)
  * - `disposeNotifications` — tears down the notification system on shutdown
  * - `unpublishService` — unpublishes the SubagentsService symbol on shutdown
+ * - `recoverEvicted` — rebuilds navigable descriptors from the parent session
+ *   file so `/subagents:sessions` works after resume/fork (the extension is
+ *   re-instantiated per session, so the in-memory evicted map starts empty)
  */
 export class SessionLifecycleHandler {
 	constructor(
@@ -35,11 +44,16 @@ export class SessionLifecycleHandler {
 		private readonly manager: LifecycleManager,
 		private readonly disposeNotifications: () => void,
 		private readonly unpublishService: () => void,
+		private readonly recoverEvicted: RecoverEvicted,
 	) {}
 
 	handleSessionStart(_event: unknown, ctx: unknown): void {
-		this.runtime.setSessionContext(ctx as SessionContext);
+		const sessionCtx = ctx as SessionContext;
+		this.runtime.setSessionContext(sessionCtx);
 		this.manager.clearCompleted();
+		// Re-discover persisted subagent sessions from the parent session file so
+		// they remain viewable after resume/fork (the in-memory map starts empty).
+		this.manager.restoreEvicted(this.recoverEvicted(sessionCtx.sessionManager?.getSessionFile()));
 	}
 
 	handleSessionBeforeSwitch(): void {

package/src/index.ts

@@ -10,7 +10,7 @@
  * Commands:
  */
 
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import {
 	createAgentSession,
 	DefaultResourceLoader,
@@ -37,6 +37,7 @@ import { detectEnv } from "./session/env";
 
 import { resolveModel } from "./session/model-resolver";
 import { buildAgentPrompt } from "./session/prompts";
+import { recoverEvictedSubagents } from "./session/recover-subagents";
 import { deriveSubagentSessionDir } from "./session/session-dir";
 import { SettingsManager } from "./settings";
 import { AgentTool } from "./tools/agent-tool";
@@ -124,6 +125,7 @@ export default function (pi: ExtensionAPI) {
 		manager,
 		() => notifications.dispose(),
 		unpublishSubagentsService,
+		(parentSessionFile) => recoverEvictedSubagents(parentSessionFile, (path) => readFileSync(path, "utf8"), existsSync),
 	);
 
 	pi.on("session_start", (event, ctx) => lifecycle.handleSessionStart(event, ctx));

package/src/lifecycle/subagent-manager.ts

@@ -36,6 +36,8 @@ export interface EvictedSubagent {
 	readonly startedAt: number;
 	readonly completedAt: number | undefined;
 	readonly toolUses: number;
+	/** Short display model name (always shown; falls back to parent model when unset). */
+	readonly modelName?: string;
 	readonly outputFile: string;
 }
 
@@ -132,7 +134,7 @@ export class SubagentManager {
 				this.observer?.onSubagentStarted(agent);
 			},
 			onSessionCreated: options.observer?.onSessionCreated
-				? (agent) => options.observer!.onSessionCreated!(agent)
+				? (agent) => options.observer?.onSessionCreated?.(agent)
 				: undefined,
 			onRunFinished: (agent) => {
 				if (options.isBackground) {
@@ -237,6 +239,21 @@ export class SubagentManager {
 		return [...this.evicted.values()].sort((a, b) => b.startedAt - a.startedAt);
 	}
 
+	/**
+	 * Repopulate evicted descriptors recovered from disk (the parent session's
+	 * `subagents:record` entries) on session start/resume/fork — the in-memory
+	 * map starts empty because the extension is re-instantiated per session.
+	 *
+	 * Descriptors whose id still has a live record are dropped: the live record
+	 * (and its real-time transcript) wins over the stale on-disk descriptor.
+	 */
+	restoreEvicted(descriptors: readonly EvictedSubagent[]): void {
+		for (const descriptor of descriptors) {
+			if (this.agents.has(descriptor.id)) continue; // live record wins
+			this.evicted.set(descriptor.id, descriptor);
+		}
+	}
+
 	abort(id: string): boolean {
 		const record = this.agents.get(id);
 		if (!record) return false;
@@ -348,6 +365,7 @@ function toEvictedSubagent(record: Subagent, outputFile: string): EvictedSubagen
 		startedAt: record.startedAt,
 		completedAt: record.completedAt,
 		toolUses: record.toolUses,
+		modelName: record.invocation?.modelName,
 		outputFile,
 	};
 }

package/src/lifecycle/subagent-state.ts

@@ -122,7 +122,7 @@ export class SubagentState {
 
 	/** Record a tool starting. Called by record-observer on tool_execution_start. */
 	addActiveTool(toolName: string): void {
-		this._activeTools.set(toolName + "_" + ++this._toolKeySeq, toolName);
+		this._activeTools.set(`${toolName}_${++this._toolKeySeq}`, toolName);
 	}
 
 	/** Remove one active tool by name (first match). Called by record-observer on tool_execution_end. */

package/src/lifecycle/subagent.ts

@@ -129,6 +129,10 @@ export class Subagent {
 	get maxTurns(): number | undefined {
 		return this.execution.maxTurns;
 	}
+	/** Short display model name (always shown; falls back to parent model when unset). */
+	get modelName(): string | undefined {
+		return this.invocation?.modelName;
+	}
 
 	readonly abortController: AbortController;
 	private _promise?: Promise<void>;

package/src/observation/notification.ts

@@ -15,6 +15,8 @@ export interface NotificationDetails {
 	outputFile?: string;
 	error?: string;
 	resultPreview: string;
+	/** Short display model name (always shown; falls back to parent model when unset). */
+	modelName?: string;
 }
 
 // ---- Pure helpers (exported for unit testing) ----
@@ -51,7 +53,7 @@ export function formatTaskNotification(record: Subagent, resultMaxLen: number):
 
 	const resultPreview = record.result
 		? record.result.length > resultMaxLen
-			? record.result.slice(0, resultMaxLen) + "\n...(truncated, use get_subagent_result for full output)"
+			? `${record.result.slice(0, resultMaxLen)}\n...(truncated, use get_subagent_result for full output)`
 			: record.result
 		: "No output.";
 
@@ -87,9 +89,10 @@ export function buildNotificationDetails(record: Subagent, resultMaxLen: number)
 		durationMs: record.completedAt ? record.completedAt - record.startedAt : 0,
 		outputFile: record.outputFile,
 		error: record.error,
+		modelName: record.modelName,
 		resultPreview: record.result
 			? record.result.length > resultMaxLen
-				? record.result.slice(0, resultMaxLen) + "…"
+				? `${record.result.slice(0, resultMaxLen)}…`
 				: record.result
 			: "No output.",
 	};

package/src/observation/renderer.ts

@@ -36,26 +36,27 @@ export function createNotificationRenderer() {
 
 		// Line 2: stats
 		const parts: string[] = [];
+		if (d.modelName) parts.push(d.modelName);
 		if (d.turnCount > 0) parts.push(formatTurns(d.turnCount, d.maxTurns));
 		if (d.toolUses > 0) parts.push(`${d.toolUses} tool use${d.toolUses === 1 ? "" : "s"}`);
 		if (d.totalTokens > 0) parts.push(formatTokens(d.totalTokens));
 		if (d.durationMs > 0) parts.push(formatMs(d.durationMs));
 		if (parts.length) {
-			line += "\n  " + parts.map((p) => theme.fg("dim", p)).join(" " + theme.fg("dim", "·") + " ");
+			line += `\n  ${parts.map((p) => theme.fg("dim", p)).join(` ${theme.fg("dim", "·")} `)}`;
 		}
 
 		// Line 3: result preview (collapsed) or full (expanded)
 		if (expanded) {
 			const lines = d.resultPreview.split("\n").slice(0, 30);
-			for (const l of lines) line += "\n" + theme.fg("dim", `  ${l}`);
+			for (const l of lines) line += `\n${theme.fg("dim", `  ${l}`)}`;
 		} else {
 			const preview = d.resultPreview.split("\n")[0]?.slice(0, 80) ?? "";
-			line += "\n  " + theme.fg("dim", `⎿  ${preview}`);
+			line += `\n  ${theme.fg("dim", `⎿  ${preview}`)}`;
 		}
 
 		// Line 4: output file link (if present)
 		if (d.outputFile) {
-			line += "\n  " + theme.fg("muted", `transcript: ${d.outputFile}`);
+			line += `\n  ${theme.fg("muted", `transcript: ${d.outputFile}`)}`;
 		}
 
 		return new Text(line, 0, 0);

package/src/observation/subagent-events-observer.ts

@@ -62,6 +62,9 @@ export class SubagentEventsObserver implements SubagentManagerObserver {
 			error: record.error,
 			startedAt: record.startedAt,
 			completedAt: record.completedAt,
+			toolUses: record.toolUses,
+			modelName: record.modelName,
+			outputFile: record.outputFile,
 		});
 
 		// Skip notification if result was already consumed via get_subagent_result.

package/src/service/service-adapter.ts

@@ -9,6 +9,7 @@ import type { ParentSnapshot } from "../lifecycle/parent-snapshot";
 import type { WorkspaceProvider } from "../lifecycle/workspace";
 import type { SpawnOptions, SubagentRecord, SubagentsService } from "../service/service";
 import type { ModelRegistry } from "../session/model-resolver";
+import { resolveModelName } from "../tools/spawn-config";
 import type { SessionContext, Subagent } from "../types";
 
 /** Narrow interface for the SubagentManager — avoids coupling to the concrete class. */
@@ -56,6 +57,11 @@ export class SubagentsServiceAdapter implements SubagentsService {
 			}
 			model = resolved;
 		}
+		// Always compute display model name, even when same as parent
+		const modelName = resolveModelName(
+			(model as { id?: string; name?: string; provider?: string } | undefined) ??
+				(this.runtime.currentCtx.model as { id?: string; name?: string; provider?: string } | undefined),
+		);
 
 		const description = options?.description ?? prompt.slice(0, 80);
 		const isBackground = !(options?.foreground ?? false);
@@ -69,6 +75,9 @@ export class SubagentsServiceAdapter implements SubagentsService {
 			inheritContext: options?.inheritContext,
 			bypassQueue: options?.bypassQueue,
 			isBackground,
+			// Service API builds a display-minimal invocation (modelName only);
+			// the tool path additionally carries thinking/maxTurns/inherit tags.
+			invocation: modelName != null ? { modelName } : undefined,
 		});
 	}
 
@@ -126,6 +135,7 @@ export function toSubagentRecord(record: Subagent): SubagentRecord {
 	if (record.result !== undefined) out.result = record.result;
 	if (record.error !== undefined) out.error = record.error;
 	if (record.completedAt !== undefined) out.completedAt = record.completedAt;
+	if (record.modelName !== undefined) out.modelName = record.modelName;
 
 	return out;
 }

package/src/service/service.ts

@@ -48,6 +48,8 @@ export interface SubagentRecord {
 	completedAt?: number;
 	lifetimeUsage: LifetimeUsage;
 	compactionCount: number;
+	/** Short display model name (always shown; falls back to parent model when unset). */
+	modelName?: string;
 }
 
 /** Options for spawning an agent via the service. */

package/src/session/conversation.ts

@@ -27,7 +27,7 @@ export function getAgentConversation(session: AgentSession): string {
 			if (toolNames.length > 0) parts.push(`[Tool Calls]:\n${toolNames.map((n) => `  Tool: ${n}`).join("\n")}`);
 		} else if (msg.role === "toolResult") {
 			const text = extractText(msg.content);
-			const truncated = text.length > 200 ? text.slice(0, 200) + "..." : text;
+			const truncated = text.length > 200 ? `${text.slice(0, 200)}...` : text;
 			parts.push(`[Tool Result (${msg.toolName})]: ${truncated}`);
 		}
 	}

package/src/session/prompts.ts

@@ -66,14 +66,14 @@ You are operating as a sub-agent invoked to handle a specific task.
 		// placed verbatim (no wrapper tag) so it forms an identical byte prefix
 		// with the parent session, maximising KV cache hits. The <active_agent>
 		// tag and env block vary per call and are placed after the cached prefix.
-		return identity + "\n\n" + bridge + "\n\n" + activeAgentTag + envBlock + customSection;
+		return `${identity}\n\n${bridge}\n\n${activeAgentTag}${envBlock}${customSection}`;
 	}
 
 	// "replace" mode — parent/genericBase prefix first for KV cache reuse, then
 	// the active_agent tag, env block, and the config's full system prompt.
 	// Unlike append mode, no <sub_agent_context> bridge or <agent_instructions>
 	// wrapper is injected — the custom prompt retains full control.
-	return identity + "\n\n" + activeAgentTag + envBlock + "\n\n" + config.systemPrompt;
+	return `${identity}\n\n${activeAgentTag}${envBlock}\n\n${config.systemPrompt}`;
 }
 
 /** Fallback base prompt when parent system prompt is unavailable (both modes). */

package/src/session/recover-subagents.ts

@@ -0,0 +1,109 @@
+/**
+ * recover-subagents.ts — Rebuild navigable subagent descriptors from disk.
+ *
+ * When a session is resumed or forked, the in-memory `SubagentManager` starts
+ * empty (the extension is re-instantiated per session). The child sessions'
+ * transcripts still live on disk, and a `subagents:record` custom entry was
+ * appended to the *parent* session file on each completion — carrying the
+ * metadata (and, since this fix, the transcript `outputFile`) needed to label
+ * and source them. This module parses those entries back into `EvictedSubagent`
+ * descriptors so `/subagents:sessions` can show them again after resume/fork.
+ *
+ * Pure: takes the parent session file path, a `readFile` seam, and an optional
+ * `exists` seam (defaults to a readFile-based probe), returns descriptors. The
+ * default keeps the function free of direct `fs` calls; callers may pass
+ * `fs.existsSync` to avoid reading the whole file just to check existence.
+ */
+
+import { join } from "node:path";
+import { type CustomEntry, parseSessionEntries } from "@earendil-works/pi-coding-agent";
+import type { EvictedSubagent } from "../lifecycle/subagent-manager";
+import type { SubagentStatus } from "../lifecycle/subagent-state";
+import type { SubagentType } from "../types";
+import { deriveSubagentSessionDir } from "./session-dir";
+
+/** The customType under which completed-subagent records are persisted. */
+export const SUBAGENT_RECORD_CUSTOM_TYPE = "subagents:record";
+
+/** Fields persisted on each `subagents:record` entry (see onSubagentCompleted). */
+interface PersistedSubagentRecord {
+	id: string;
+	type: SubagentType;
+	description: string;
+	status: SubagentStatus;
+	result?: string;
+	error?: string;
+	startedAt: number;
+	completedAt: number | undefined;
+	toolUses?: number;
+	modelName?: string;
+	outputFile?: string;
+}
+
+/**
+ * Read the parent session file and rebuild `EvictedSubagent` descriptors from
+ * its `subagents:record` entries, most-recent-first. Records without an
+ * `outputFile` are dropped — their transcript is not navigable from disk.
+ *
+ * Returns `[]` when the parent session is not persisted (no file) or the file
+ * cannot be read, so callers can invoke unconditionally on session start.
+ */
+export function recoverEvictedSubagents(
+	parentSessionFile: string | undefined,
+	readFile: (path: string) => string,
+	exists: (path: string) => boolean = (path) => {
+		try {
+			readFile(path);
+			return true;
+		} catch {
+			return false;
+		}
+	},
+): EvictedSubagent[] {
+	if (!parentSessionFile) return [];
+	let entries: ReturnType<typeof parseSessionEntries>;
+	try {
+		entries = parseSessionEntries(readFile(parentSessionFile));
+	} catch {
+		return [];
+	}
+
+	const records = entries.filter(
+		(entry): entry is CustomEntry =>
+			entry.type === "custom" && (entry as CustomEntry).customType === SUBAGENT_RECORD_CUSTOM_TYPE,
+	);
+
+	const recovered: EvictedSubagent[] = [];
+	// Derive the tasks directory once for fallback outputFile construction.
+	// The empty cwd is harmless: when parentSessionFile is set, session-dir
+	// derives the path from it and ignores cwd entirely.
+	const tasksDir = deriveSubagentSessionDir(parentSessionFile, "");
+	for (const entry of records) {
+		const data = (entry.data ?? {}) as PersistedSubagentRecord;
+		// Try to determine outputFile: prefer the persisted one, else construct
+		// from the agent id and tasks directory (backwards compat for pre-fix records).
+		let outputFile: string | undefined = data.outputFile;
+		if (!outputFile) {
+			const constructed = join(tasksDir, `${data.id}.jsonl`);
+			// Confirm the session file is readable so the file-snapshot source
+			// works later. The `exists` seam defaults to a readFile probe (pure);
+			// callers may pass `fs.existsSync` to avoid reading the whole file.
+			if (!exists(constructed)) continue; // session file doesn't exist — not navigable
+			outputFile = constructed;
+		}
+		recovered.push({
+			id: data.id,
+			type: data.type,
+			description: data.description,
+			status: data.status,
+			startedAt: data.startedAt,
+			completedAt: data.completedAt,
+			toolUses: data.toolUses ?? 0,
+			modelName: data.modelName,
+			outputFile,
+		});
+	}
+	// Most-recent-first, matching listEvicted()'s ordering.
+	recovered.sort((a, b) => b.startedAt - a.startedAt);
+	return recovered;
+}

package/src/tools/agent-tool.ts

@@ -192,7 +192,7 @@ Guidelines:
 				const displayName = args.subagent_type ? getDisplayName(args.subagent_type as string, registry) : "Subagent";
 				const desc = (args.description as string | undefined) ?? "";
 				return new Text(
-					"▸ " + theme.fg("toolTitle", theme.bold(displayName)) + (desc ? "  " + theme.fg("muted", desc) : ""),
+					`▸ ${theme.fg("toolTitle", theme.bold(displayName))}${desc ? `  ${theme.fg("muted", desc)}` : ""}`,
 					0,
 					0,
 				);

package/src/tools/result-renderer.ts

@@ -33,8 +33,8 @@ export function renderAgentResult(
 export function renderRunning(details: AgentDetails, theme: Theme): string {
 	const frame = SPINNER[details.spinnerFrame ?? 0];
 	const s = renderStats(details, theme);
-	let line = theme.fg("accent", frame) + (s ? " " + s : "");
-	line += "\n" + theme.fg("dim", `  ⎿  ${details.activity ?? "thinking\u2026"}`);
+	let line = theme.fg("accent", frame) + (s ? ` ${s}` : "");
+	line += `\n${theme.fg("dim", `  ⎿  ${details.activity ?? "thinking\u2026"}`)}`;
 	return line;
 }
 
@@ -49,22 +49,22 @@ export function renderCompleted(details: AgentDetails, resultText: string, expan
 	const isSteered = details.status === "steered";
 	const icon = isSteered ? theme.fg("warning", "\u2713") : theme.fg("success", "\u2713");
 	const s = renderStats(details, theme);
-	let line = icon + (s ? " " + s : "");
-	line += " " + theme.fg("dim", "\u00B7") + " " + theme.fg("dim", duration);
+	let line = icon + (s ? ` ${s}` : "");
+	line += ` ${theme.fg("dim", "\u00B7")} ${theme.fg("dim", duration)}`;
 
 	if (expanded) {
 		if (resultText) {
 			const lines = resultText.split("\n").slice(0, 50);
 			for (const l of lines) {
-				line += "\n" + theme.fg("dim", `  ${l}`);
+				line += `\n${theme.fg("dim", `  ${l}`)}`;
 			}
 			if (resultText.split("\n").length > 50) {
-				line += "\n" + theme.fg("muted", "  ... (use get_subagent_result with verbose for full output)");
+				line += `\n${theme.fg("muted", "  ... (use get_subagent_result with verbose for full output)")}`;
 			}
 		}
 	} else {
 		const doneText = isSteered ? "Wrapped up (turn limit)" : "Done";
-		line += "\n" + theme.fg("dim", `  \u23BF  ${doneText}`);
+		line += `\n${theme.fg("dim", `  \u23BF  ${doneText}`)}`;
 	}
 	return line;
 }
@@ -72,20 +72,20 @@ export function renderCompleted(details: AgentDetails, resultText: string, expan
 /** Render stopped status: dim stop icon + stats + "Stopped". */
 export function renderStopped(details: AgentDetails, theme: Theme): string {
 	const s = renderStats(details, theme);
-	let line = theme.fg("dim", "\u25A0") + (s ? " " + s : "");
-	line += "\n" + theme.fg("dim", "  \u23BF  Stopped");
+	let line = theme.fg("dim", "\u25A0") + (s ? ` ${s}` : "");
+	line += `\n${theme.fg("dim", "  \u23BF  Stopped")}`;
 	return line;
 }
 
 /** Render error or aborted status: error icon + stats + status message. */
 export function renderFailed(details: AgentDetails, theme: Theme): string {
 	const s = renderStats(details, theme);
-	let line = theme.fg("error", "\u2717") + (s ? " " + s : "");
+	let line = theme.fg("error", "\u2717") + (s ? ` ${s}` : "");
 
 	if (details.status === "error") {
-		line += "\n" + theme.fg("error", `  \u23BF  Error: ${details.error ?? "unknown"}`);
+		line += `\n${theme.fg("error", `  \u23BF  Error: ${details.error ?? "unknown"}`)}`;
 	} else {
-		line += "\n" + theme.fg("warning", "  \u23BF  Aborted (max turns exceeded)");
+		line += `\n${theme.fg("warning", "  \u23BF  Aborted (max turns exceeded)")}`;
 	}
 	return line;
 }
@@ -105,5 +105,5 @@ export function renderStats(details: AgentDetails, theme: Theme): string {
 	}
 	if (details.toolUses > 0) parts.push(`${details.toolUses} tool use${details.toolUses === 1 ? "" : "s"}`);
 	if (details.tokens) parts.push(details.tokens);
-	return parts.map((p) => theme.fg("dim", p)).join(" " + theme.fg("dim", "\u00B7") + " ");
+	return parts.map((p) => theme.fg("dim", p)).join(` ${theme.fg("dim", "\u00B7")} `);
 }

package/src/tools/spawn-config.ts

@@ -15,9 +15,20 @@ import { resolveInvocationModel } from "../session/model-resolver";
 import type { AgentInvocation, SubagentType, ThinkingLevel } from "../types";
 import { type AgentDetails, buildInvocationTags, getDisplayName, getPromptModeLabel } from "../ui/display";
 
+/** Derive a short display model name from a model object (or undefined). */
+export function resolveModelName(
+	model: { id?: string; name?: string; provider?: string } | undefined,
+): string | undefined {
+	if (!model) return undefined;
+	// Primary: provider/id complete format
+	if (model.provider && model.id) return `${model.provider}/${model.id}`;
+	// Fallback: raw name or id, no transformation
+	return model.name ?? model.id ?? undefined;
+}
+
 /** Model info extracted from the parent session context. */
 export interface ModelInfo {
-	parentModel: { id: string; name?: string } | undefined;
+	parentModel: { id: string; name?: string; provider?: string } | undefined;
 	modelRegistry: unknown;
 }
 
@@ -103,13 +114,8 @@ export function resolveSpawnConfig(
 	const inheritContext = resolvedConfig.inheritContext;
 	const runInBackground = resolvedConfig.runInBackground;
 
-	// Compute display model name (only shown when different from parent)
-	const parentModelId = modelInfo.parentModel?.id;
-	const effectiveModelId = model?.id;
-	const modelName =
-		effectiveModelId && effectiveModelId !== parentModelId
-			? (model?.name ?? effectiveModelId).replace(/^Claude\s+/i, "").toLowerCase()
-			: undefined;
+	// Compute display model name — always shown, even when same as parent.
+	const modelName = resolveModelName(model ?? modelInfo.parentModel);
 
 	const effectiveMaxTurns = normalizeMaxTurns(resolvedConfig.maxTurns ?? settings.defaultMaxTurns);
 

package/src/types.ts

@@ -63,7 +63,7 @@ export interface AgentConfig extends AgentIdentity, AgentPromptConfig {
 }
 
 export interface AgentInvocation {
-	/** Short display name, e.g. "haiku" — only set when different from parent. */
+	/** Short display model name (always shown; falls back to parent model when unset). */
 	modelName?: string;
 	thinking?: ThinkingLevel;
 	maxTurns?: number;

package/src/ui/agent-widget.ts

@@ -180,6 +180,7 @@ export class AgentWidget implements SubagentManagerObserver {
 			activeTools: record.activeTools,
 			responseText: record.responseText,
 			contextPercent: record.getContextPercent(),
+			modelName: record.invocation?.modelName,
 		};
 	}
 
@@ -202,12 +203,12 @@ export class AgentWidget implements SubagentManagerObserver {
 	 */
 	private clearWidget(backgroundAgents: readonly AgentSummary[]): void {
 		if (this.widgetRegistered) {
-			this.uiCtx!.setWidget("agents", undefined);
+			this.uiCtx?.setWidget("agents", undefined);
 			this.widgetRegistered = false;
 			this.tui = undefined;
 		}
 		if (this.lastStatusText !== undefined) {
-			this.uiCtx!.setStatus("subagents", undefined);
+			this.uiCtx?.setStatus("subagents", undefined);
 			this.lastStatusText = undefined;
 		}
 		if (this.widgetInterval) {
@@ -233,7 +234,7 @@ export class AgentWidget implements SubagentManagerObserver {
 			newStatusText = `${statusParts.join(", ")} agent${total === 1 ? "" : "s"}`;
 		}
 		if (newStatusText !== this.lastStatusText) {
-			this.uiCtx!.setStatus("subagents", newStatusText);
+			this.uiCtx?.setStatus("subagents", newStatusText);
 			this.lastStatusText = newStatusText;
 		}
 	}

package/src/ui/display.ts

@@ -28,7 +28,7 @@ export interface AgentDetails {
 	activity?: string;
 	/** Current spinner frame index (for animated running indicator). */
 	spinnerFrame?: number;
-	/** Short model name if different from parent (e.g. "haiku", "sonnet"). */
+	/** Short display model name (always shown; falls back to parent model when unset). */
 	modelName?: string;
 	/** Notable config tags (e.g. ["thinking: high", "inherit context"]). */
 	tags?: string[];
@@ -142,7 +142,7 @@ function truncateLine(text: string, len = 60): string {
 			.find((l) => l.trim())
 			?.trim() ?? "";
 	if (line.length <= len) return line;
-	return line.slice(0, len) + "…";
+	return `${line.slice(0, len)}…`;
 }
 
 /** Build a human-readable activity string from currently-running tools or response text. */
@@ -162,7 +162,7 @@ export function describeActivity(activeTools: ReadonlyMap<string, string>, respo
 				parts.push(action);
 			}
 		}
-		return parts.join(", ") + "…";
+		return `${parts.join(", ")}…`;
 	}
 
 	// No tools active — show truncated response text if available

package/src/ui/session-navigation.ts

@@ -38,6 +38,8 @@ export interface NavigableSubagent {
 	readonly activeTools: ReadonlyMap<string, string>;
 	readonly responseText: string;
 	readonly agentMessages: readonly SessionMessage[];
+	/** Short display model name (always shown; falls back to parent model when unset). */
+	readonly modelName?: string;
 	isSessionReady(): boolean;
 	subscribeToUpdates(fn: (event: AgentSessionEvent) => void): (() => void) | undefined;
 	getToolDefinition(name: string): ToolDefinition | undefined;
@@ -51,7 +53,7 @@ export interface NavigableSubagent {
  */
 export type NavigationEntry =
 	| { readonly kind: "live"; readonly label: string; readonly record: NavigableSubagent }
-	| { readonly kind: "evicted"; readonly label: string; readonly outputFile: string };
+	| { readonly kind: "evicted"; readonly label: string; readonly outputFile: string; readonly modelName?: string };
 
 /** The fields `buildLabel` reads — shared by a live record and an evicted descriptor. */
 interface LabelFields {
@@ -61,6 +63,7 @@ interface LabelFields {
 	readonly startedAt: number;
 	readonly completedAt: number | undefined;
 	readonly toolUses: number;
+	readonly modelName?: string;
 }
 
 /** Running-agent streaming state, surfaced by a live source. */
@@ -100,6 +103,7 @@ export function listNavigableAgents(
 			(descriptor): NavigationEntry => ({
 				kind: "evicted",
 				outputFile: descriptor.outputFile,
+				modelName: descriptor.modelName,
 				label: buildLabel(descriptor, registry, true),
 			}),
 		);
@@ -142,6 +146,7 @@ export function liveSource(record: NavigableSubagent): TranscriptSource {
 function buildLabel(fields: LabelFields, registry: AgentConfigLookup, evicted = false): string {
 	const name = getDisplayName(fields.type, registry);
 	const duration = formatDuration(fields.startedAt, fields.completedAt);
+	const modelTag = fields.modelName ? ` · model:${fields.modelName}` : "";
 	const marker = evicted ? " · evicted (snapshot)" : "";
-	return `${name} (${fields.description}) · ${fields.toolUses} tools · ${fields.status} · ${duration}${marker}`;
+	return `${name} (${fields.description}) · ${fields.toolUses} tools · ${fields.status} · ${duration}${modelTag}${marker}`;
 }

package/src/ui/session-navigator.ts

@@ -92,6 +92,8 @@ export interface TranscriptOverlayOptions {
 	done: (result: undefined) => void;
 	cwd: string;
 	markdownTheme: MarkdownTheme;
+	/** Short model name to show in the header, or undefined to omit. */
+	modelName?: string;
 }
 
 /**
@@ -117,15 +119,23 @@ export class SessionNavigatorHandler {
 		if (!entry) return;
 
 		let source: TranscriptSource;
+		let modelName: string | undefined;
 		try {
-			source = entry.kind === "live" ? liveSource(entry.record) : fileSnapshotSource(entry.outputFile, readFile);
+			if (entry.kind === "live") {
+				source = liveSource(entry.record);
+				modelName = entry.record.modelName;
+			} else {
+				source = fileSnapshotSource(entry.outputFile, readFile);
+				modelName = entry.modelName;
+			}
 		} catch {
 			ui.notify("Could not read the session transcript file.", "error");
 			return;
 		}
 		const markdownTheme = getMarkdownTheme();
 		await ui.custom<undefined>(
-			(tui, theme, _keybindings, done) => new TranscriptOverlay({ tui, theme, source, done, cwd, markdownTheme }),
+			(tui, theme, _keybindings, done) =>
+				new TranscriptOverlay({ tui, theme, source, done, cwd, markdownTheme, modelName }),
 			{
 				overlay: true,
 				overlayOptions: { anchor: "center", width: "90%", maxHeight: `${VIEWPORT_HEIGHT_PCT}%` },
@@ -134,14 +144,34 @@ export class SessionNavigatorHandler {
 	}
 }
 
+/**
+ * Minimum interval between two component rebuilds for a live (streaming) source.
+ *
+ * A running agent emits many events per second (text deltas, tool calls). Without
+ * throttling, each event rebuilt the whole component tree (markdown parsing
+ * included) and re-rendered it — starving the event loop so keystrokes (arrows,
+ * `q`) stopped responding. Coalescing bursts into at most one rebuild per tick
+ * keeps the overlay responsive while still streaming.
+ */
+const REBUILD_THROTTLE_MS = 120;
+
 /**
  * Read-only scrollable transcript overlay.
  *
- * Caches a `Container` of Pi's per-entry components and rebuilds it only when the
- * source changes (live agents) — each paint reuses the cached tree, so markdown
- * highlighting does not re-run per frame. This class owns scroll state, chrome,
- * and the running-agent streaming indicator; the component mapping lives in
- * `buildTranscriptComponents`.
+ * Two caches keep it responsive even for long, live-streaming transcripts:
+ *
+ *   - `content` (a `Container` of Pi's per-entry components) is rebuilt only when
+ *     the source changes, and rebuilds are *throttled* — a burst of streaming
+ *     events coalesces into at most one rebuild per `REBUILD_THROTTLE_MS`, so
+ *     markdown highlighting never re-runs on every token.
+ *   - `renderedLines` caches the laid-out, width-wrapped lines. `render()` and
+ *     `handleInput()` read the cache (O(1) slice / length) instead of
+ *     re-rendering the whole container on every frame and every keystroke.
+ *
+ * The cache is invalidated (`linesDirty`) whenever the component tree changes,
+ * and recomputed lazily at the current width. This class owns scroll state,
+ * chrome, and the running-agent streaming indicator; the component mapping lives
+ * in `buildTranscriptComponents`.
  */
 export class TranscriptOverlay implements Component {
 	private scrollOffset = 0;
@@ -155,21 +185,36 @@ export class TranscriptOverlay implements Component {
 	private readonly done: (result: undefined) => void;
 	private readonly cwd: string;
 	private readonly markdownTheme: MarkdownTheme;
+	private readonly modelName?: string;
 	private content: Container;
 
-	constructor({ tui, theme, source, done, cwd, markdownTheme }: TranscriptOverlayOptions) {
+	/** Throttle bookkeeping for coalescing live-source rebuilds. */
+	private rebuildTimer: ReturnType<typeof setTimeout> | undefined;
+	private lastRebuildAt = 0;
+
+	/** Cached laid-out lines + the width they were computed at; recomputed lazily when `linesDirty`. */
+	private renderedLines: string[] = [];
+	private renderedWidth = -1;
+	private linesDirty = true;
+
+	constructor({ tui, theme, source, done, cwd, markdownTheme, modelName }: TranscriptOverlayOptions) {
 		this.tui = tui;
 		this.theme = theme;
 		this.source = source;
 		this.done = done;
 		this.cwd = cwd;
 		this.markdownTheme = markdownTheme;
+		this.modelName = modelName;
 		this.content = this.rebuild();
-		this.unsubscribe = source.subscribe(() => {
-			if (this.closed) return;
-			this.content = this.rebuild();
-			this.tui.requestRender();
-		});
+		// Seed `lastRebuildAt` far in the past so the first source-change event
+		// always rebuilds immediately (leading-edge throttle). The constructor
+		// already built `content` from the snapshot at construction time, but
+		// the source may have accumulated events between construction and
+		// subscription — that first rebuild surfaces them without delay.
+		// Subsequent events inside the throttle window are coalesced into a
+		// single trailing rebuild.
+		this.lastRebuildAt = 0;
+		this.unsubscribe = source.subscribe(() => this.scheduleRebuild());
 	}
 
 	// fallow-ignore-next-line unused-class-member
@@ -180,29 +225,41 @@ export class TranscriptOverlay implements Component {
 			return;
 		}
 
-		const totalLines = this.buildContentLines(this.innerWidth()).length;
+		const totalLines = this.getRenderedLines(this.innerWidth()).length;
 		const viewportHeight = this.viewportHeight();
 		const maxScroll = Math.max(0, totalLines - viewportHeight);
+		let scrolled = false;
 
 		if (matchesKey(data, "up") || matchesKey(data, "k")) {
 			this.scrollOffset = Math.max(0, this.scrollOffset - 1);
-			this.autoScroll = this.scrollOffset >= maxScroll;
+			// Streaming may add lines between handleInput and render,
+			// making maxScroll larger; unconditionally disable autoScroll
+			// so render() does not reset scrollOffset back to the bottom.
+			this.autoScroll = false;
+			scrolled = true;
 		} else if (matchesKey(data, "down") || matchesKey(data, "j")) {
 			this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 1);
-			this.autoScroll = this.scrollOffset >= maxScroll;
+			this.autoScroll = false;
+			scrolled = true;
 		} else if (matchesKey(data, "pageUp") || matchesKey(data, "shift+up")) {
 			this.scrollOffset = Math.max(0, this.scrollOffset - viewportHeight);
 			this.autoScroll = false;
+			scrolled = true;
 		} else if (matchesKey(data, "pageDown") || matchesKey(data, "shift+down")) {
 			this.scrollOffset = Math.min(maxScroll, this.scrollOffset + viewportHeight);
-			this.autoScroll = this.scrollOffset >= maxScroll;
+			this.autoScroll = false;
+			scrolled = true;
 		} else if (matchesKey(data, "home")) {
 			this.scrollOffset = 0;
 			this.autoScroll = false;
+			scrolled = true;
 		} else if (matchesKey(data, "end")) {
 			this.scrollOffset = maxScroll;
 			this.autoScroll = true;
+			scrolled = true;
 		}
+
+		if (scrolled) this.tui.requestRender();
 	}
 
 	render(width: number): string[] {
@@ -213,16 +270,17 @@ export class TranscriptOverlay implements Component {
 
 		const pad = (s: string, len: number): string => s + " ".repeat(Math.max(0, len - visibleWidth(s)));
 		const row = (content: string): string =>
-			th.fg("border", "│") + " " + truncateToWidth(pad(content, innerW), innerW) + " " + th.fg("border", "│");
+			`${th.fg("border", "│")} ${truncateToWidth(pad(content, innerW), innerW)} ${th.fg("border", "│")}`;
 		const hrTop = th.fg("border", `╭${"─".repeat(width - 2)}╮`);
 		const hrBot = th.fg("border", `╰${"─".repeat(width - 2)}╯`);
 		const hrMid = row(th.fg("dim", "─".repeat(innerW)));
 
 		lines.push(hrTop);
-		lines.push(row(th.bold("Subagent session")));
+		const title = this.modelName ? `Subagent session · ${this.modelName}` : "Subagent session";
+		lines.push(row(th.bold(title)));
 		lines.push(hrMid);
 
-		const contentLines = this.buildContentLines(innerW);
+		const contentLines = this.getRenderedLines(innerW);
 		const viewportHeight = this.viewportHeight();
 		const maxScroll = Math.max(0, contentLines.length - viewportHeight);
 		if (this.autoScroll) this.scrollOffset = maxScroll;
@@ -236,7 +294,7 @@ export class TranscriptOverlay implements Component {
 				? "100%"
 				: `${Math.round(((visibleStart + viewportHeight) / contentLines.length) * 100)}%`;
 		const footerLeft = th.fg("dim", `${contentLines.length} lines · ${scrollPct}`);
-		const footerRight = th.fg("dim", "↑↓ scroll · PgUp/PgDn · Esc close");
+		const footerRight = th.fg("dim", "↑↓ scroll · PgUp/PgDn · end follow · q close");
 		const footerGap = Math.max(1, innerW - visibleWidth(footerLeft) - visibleWidth(footerRight));
 		lines.push(row(footerLeft + " ".repeat(footerGap) + footerRight));
 		lines.push(hrBot);
@@ -247,11 +305,17 @@ export class TranscriptOverlay implements Component {
 	// fallow-ignore-next-line unused-class-member
 	invalidate(): void {
 		this.content.invalidate();
+		this.linesDirty = true;
+		this.renderedWidth = -1;
 	}
 
 	// fallow-ignore-next-line unused-class-member
 	dispose(): void {
 		this.closed = true;
+		if (this.rebuildTimer) {
+			clearTimeout(this.rebuildTimer);
+			this.rebuildTimer = undefined;
+		}
 		if (this.unsubscribe) {
 			this.unsubscribe();
 			this.unsubscribe = undefined;
@@ -269,6 +333,50 @@ export class TranscriptOverlay implements Component {
 		return Math.max(MIN_VIEWPORT, maxRows - CHROME_LINES);
 	}
 
+	/**
+	 * Coalesce a burst of source-change events into at most one component rebuild
+	 * per `REBUILD_THROTTLE_MS`. The first event after an idle gap rebuilds
+	 * immediately (so a freshly-picked agent paints without delay); subsequent
+	 * events inside the gap are merged into a single trailing rebuild.
+	 */
+	private scheduleRebuild(): void {
+		if (this.closed) return;
+		const now = Date.now();
+		const elapsed = now - this.lastRebuildAt;
+		if (elapsed >= REBUILD_THROTTLE_MS) {
+			this.doRebuild();
+			return;
+		}
+		if (this.rebuildTimer) return; // a trailing rebuild is already pending
+		this.rebuildTimer = setTimeout(() => {
+			this.rebuildTimer = undefined;
+			this.doRebuild();
+		}, REBUILD_THROTTLE_MS - elapsed);
+	}
+
+	/** Rebuild the component tree, invalidate the line cache, and request a paint. */
+	private doRebuild(): void {
+		if (this.closed) return;
+		this.lastRebuildAt = Date.now();
+		this.content = this.rebuild();
+		this.linesDirty = true;
+		this.tui.requestRender();
+	}
+
+	/**
+	 * Return the laid-out content lines at `innerW`, recomputing the cache only
+	 * when the component tree changed (`linesDirty`) or the width changed.
+	 * Cheap O(1) on the hot path (every render frame and every keystroke).
+	 */
+	private getRenderedLines(innerW: number): string[] {
+		if (innerW <= 0) return [];
+		if (!this.linesDirty && this.renderedWidth === innerW) return this.renderedLines;
+		this.renderedLines = this.buildContentLines(innerW);
+		this.renderedWidth = innerW;
+		this.linesDirty = false;
+		return this.renderedLines;
+	}
+
 	private buildContentLines(innerW: number): string[] {
 		if (innerW <= 0) return [];
 		const lines = this.content.render(innerW);

package/src/ui/widget-renderer.ts

@@ -42,6 +42,8 @@ export interface WidgetAgent {
 	readonly responseText: string;
 	/** Context-window utilisation (0–100), or null when unavailable. */
 	readonly contextPercent: number | null;
+	/** Short display model name (always shown; falls back to parent model when unset). */
+	readonly modelName?: string;
 }
 
 // ── Per-agent rendering ──────────────────────────────────────────────────────
@@ -74,6 +76,7 @@ export function renderFinishedLine(agent: WidgetAgent, registry: AgentConfigLook
 	}
 
 	const parts: string[] = [];
+	if (agent.modelName) parts.push(agent.modelName);
 	parts.push(formatTurns(agent.turnCount, agent.maxTurns));
 	if (agent.toolUses > 0) parts.push(`${agent.toolUses} tool use${agent.toolUses === 1 ? "" : "s"}`);
 	parts.push(duration);
@@ -98,6 +101,7 @@ export function renderRunningLines(
 	const tokenText = tokens > 0 ? formatSessionTokens(tokens, agent.contextPercent, theme, agent.compactionCount) : "";
 
 	const parts: string[] = [];
+	if (agent.modelName) parts.push(agent.modelName);
 	parts.push(formatTurns(agent.turnCount, agent.maxTurns));
 	if (agent.toolUses > 0) parts.push(`${agent.toolUses} tool use${agent.toolUses === 1 ? "" : "s"}`);
 	if (tokenText) parts.push(tokenText);
@@ -155,14 +159,14 @@ function buildSections(
 ): WidgetSections {
 	const finishedLines: string[] = [];
 	for (const a of categories.finished) {
-		finishedLines.push(truncate(theme.fg("dim", "\u251C\u2500") + " " + renderFinishedLine(a, registry, theme)));
+		finishedLines.push(truncate(`${theme.fg("dim", "\u251C\u2500")} ${renderFinishedLine(a, registry, theme)}`));
 	}
 
 	const runningLines: [string, string][] = [];
 	for (const a of categories.running) {
 		const [header, act] = renderRunningLines(a, registry, spinnerFrame, theme);
 		runningLines.push([
-			truncate(theme.fg("dim", "\u251C\u2500") + ` ${header}`),
+			truncate(`${theme.fg("dim", "\u251C\u2500")} ${header}`),
 			truncate(theme.fg("dim", "\u2502  ") + act),
 		]);
 	}
@@ -248,7 +252,7 @@ function assembleOverflow(
 	const overflowText = overflowParts.join(", ");
 	lines.push(
 		truncate(
-			theme.fg("dim", "\u2514\u2500") + ` ${theme.fg("dim", `+${hiddenRunning + hiddenFinished} more (${overflowText})`)}`,
+			`${theme.fg("dim", "\u2514\u2500")} ${theme.fg("dim", `+${hiddenRunning + hiddenFinished} more (${overflowText})`)}`,
 		),
 	);
 	return lines;
@@ -287,7 +291,7 @@ export function renderWidgetLines(params: {
 	// Assemble with overflow cap (heading takes 1 line).
 	const maxBody = MAX_WIDGET_LINES - 1;
 	const totalBody = finishedLines.length + runningLines.length * 2 + (queuedLine ? 1 : 0);
-	const heading = truncate(theme.fg(headingColor, headingIcon) + " " + theme.fg(headingColor, "Agents"));
+	const heading = truncate(`${theme.fg(headingColor, headingIcon)} ${theme.fg(headingColor, "Agents")}`);
 
 	if (totalBody <= maxBody) {
 		return assembleWithinBudget(heading, { finishedLines, runningLines, queuedLine });