@yandy0725/pi-subagents 0.1.0 → 0.2.1

package/package.json

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

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;
 }
 
@@ -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.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) ----
@@ -87,6 +89,7 @@ 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) + "…"

package/src/observation/renderer.ts

@@ -36,6 +36,7 @@ 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));

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. */
@@ -45,6 +46,7 @@ export class SubagentsServiceAdapter implements SubagentsService {
 		}
 
 		let model: unknown;
+		let modelName: string | undefined;
 		if (options?.model) {
 			const registry = this.runtime.currentCtx.modelRegistry;
 			if (!registry) {
@@ -56,6 +58,11 @@ export class SubagentsServiceAdapter implements SubagentsService {
 			}
 			model = resolved;
 		}
+		// Always compute display model name, even when same as parent
+		modelName = resolveModelName(
+			(model as { id?: string; name?: string } | undefined) ??
+				(this.runtime.currentCtx.model as { id?: string; name?: string } | undefined),
+		);
 
 		const description = options?.description ?? prompt.slice(0, 80);
 		const isBackground = !(options?.foreground ?? false);
@@ -69,6 +76,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 +136,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/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/spawn-config.ts

@@ -15,6 +15,14 @@ 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 } | undefined): string | undefined {
+	if (!model) return undefined;
+	const raw = model.name ?? model.id;
+	if (!raw) return undefined;
+	return raw.replace(/^Claude\s+/i, "").toLowerCase();
+}
+
 /** Model info extracted from the parent session context. */
 export interface ModelInfo {
 	parentModel: { id: string; name?: string } | undefined;
@@ -103,13 +111,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,
 		};
 	}
 

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[];

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[] {
@@ -219,10 +276,11 @@ export class TranscriptOverlay implements Component {
 		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);