@gotgenes/pi-subagents 10.0.1 → 10.2.0

package/src/lifecycle/{agent-record.ts → agent.ts}

@@ -1,5 +1,5 @@
 /**
- * agent-record.ts — AgentRecord class with encapsulated status-transition logic.
+ * agent.ts — Agent class with encapsulated status-transition logic and per-agent behavior.
  *
  * Status transitions (status, result, error, startedAt, completedAt) are owned
  * by the class and exposed via transition methods. External code reads these
@@ -8,19 +8,25 @@
  * Stats (toolUses, lifetimeUsage, compactionCount) are owned by the class and
  * accumulated via mutation methods (incrementToolUses, addUsage, incrementCompactions).
  *
+ * Behavior (abort, steer buffering, worktree setup) lives on the agent
+ * rather than on AgentManager — each agent manages its own lifecycle concerns.
+ *
  * Phase-specific collaborators (execution, worktreeState, notification) are attached
  * after construction as lifecycle information becomes available.
  */
 
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import { debugLog } from "#src/debug";
+import type { RunResult } from "#src/lifecycle/agent-runner";
 import type { ExecutionState } from "#src/lifecycle/execution-state";
 import type { LifetimeUsage } from "#src/lifecycle/usage";
 import { addUsage } from "#src/lifecycle/usage";
-import type { WorktreeState } from "#src/lifecycle/worktree-state";
+import type { WorktreeManager } from "#src/lifecycle/worktree";
+import { WorktreeState } from "#src/lifecycle/worktree-state";
 import type { NotificationState } from "#src/observation/notification-state";
-import type { AgentInvocation, SubagentType } from "#src/types";
+import type { AgentInvocation, IsolationMode, SubagentType } from "#src/types";
 
-export type AgentRecordStatus =
+export type AgentStatus =
 	| "queued"
 	| "running"
 	| "completed"
@@ -29,21 +35,21 @@ export type AgentRecordStatus =
 	| "stopped"
 	| "error";
 
-export interface AgentRecordInit {
+export interface AgentInit {
 	id: string;
 	type: SubagentType;
 	description: string;
-	status?: AgentRecordStatus;
+	status?: AgentStatus;
 	startedAt?: number;
 	completedAt?: number;
 	result?: string;
 	error?: string;
 	abortController?: AbortController;
 	invocation?: AgentInvocation;
-	promise?: Promise<string>;
+	promise?: Promise<void>;
 }
 
-export class AgentRecord {
+export class Agent {
 	// Identity — set once at construction
 	readonly id: string;
 	readonly type: SubagentType;
@@ -51,8 +57,8 @@ export class AgentRecord {
 	readonly invocation?: AgentInvocation;
 
 	// Transition state — encapsulated behind getters, mutated only via transition methods
-	private _status: AgentRecordStatus;
-	get status(): AgentRecordStatus { return this._status; }
+	private _status: AgentStatus;
+	get status(): AgentStatus { return this._status; }
 
 	private _result?: string;
 	get result(): string | undefined { return this._result; }
@@ -79,13 +85,36 @@ export class AgentRecord {
 	/** AbortController for cancelling this agent. Set at construction; used only by AgentManager. */
 	readonly abortController?: AbortController;
 	/** Promise for the full agent run (including post-processing). Set once by AgentManager. */
-	promise?: Promise<string>;
+	promise?: Promise<void>;
 
 	// Phase-specific collaborators — each born complete when their info becomes available
 	execution?: ExecutionState;
 	worktreeState?: WorktreeState;
 	notification?: NotificationState;
 
+	/**
+	 * Create a git worktree for isolated execution, set worktreeState, and return the worktree path.
+	 * Returns undefined if isolation is not "worktree".
+	 * Throws if worktree creation fails (strict isolation).
+	 */
+	setupWorktree(worktrees: WorktreeManager, isolation: IsolationMode | undefined): string | undefined {
+		if (isolation !== "worktree") return undefined;
+		const wt = worktrees.create(this.id);
+		if (!wt) {
+			throw new Error(
+				'Cannot run with isolation: "worktree" — not a git repo, no commits yet, or `git worktree add` failed. ' +
+				'Initialize git and commit at least once, or omit `isolation`.',
+			);
+		}
+		this.worktreeState = new WorktreeState(wt);
+		return wt.path;
+	}
+
+	// Steer buffer — messages queued before the session is ready
+	private _pendingSteers: string[] = [];
+	/** Number of steer messages waiting to be delivered. */
+	get pendingSteerCount(): number { return this._pendingSteers.length; }
+
 	/** The active agent session, or undefined before the session is created. */
 	get session(): AgentSession | undefined {
 		return this.execution?.session;
@@ -96,7 +125,7 @@ export class AgentRecord {
 		return this.execution?.outputFile;
 	}
 
-	constructor(init: AgentRecordInit) {
+	constructor(init: AgentInit) {
 		this.id = init.id;
 		this.type = init.type;
 		this.description = init.description;
@@ -190,12 +219,121 @@ export class AgentRecord {
 		this._completedAt = completedAt ?? Date.now();
 	}
 
-	/** Reset for resume: running status, new startedAt, clear completedAt/result/error. */
+	/**
+	 * Abort a running agent: fire AbortController and transition to stopped.
+	 * Returns false if the agent is not running.
+	 * Queue removal stays on AgentManager until #230 extracts ConcurrencyQueue.
+	 */
+	abort(): boolean {
+		if (this._status !== "running") return false;
+		this.abortController?.abort();
+		this.markStopped();
+		return true;
+	}
+
+	/**
+	 * Buffer a steer message for delivery once the session is ready.
+	 * Called when steer is requested before onSessionCreated fires.
+	 */
+	queueSteer(message: string): void {
+		this._pendingSteers.push(message);
+	}
+
+	/**
+	 * Flush all buffered steer messages to the session and clear the buffer.
+	 * Called from onSessionCreated once the session is available.
+	 */
+	flushPendingSteers(session: AgentSession): void {
+		for (const msg of this._pendingSteers) {
+			session.steer(msg).catch(() => {});
+		}
+		this._pendingSteers = [];
+	}
+
+	/** Reset for resume: running status, new startedAt, clear completedAt/result/error/listeners. */
 	resetForResume(startedAt: number): void {
 		this._status = "running";
 		this._startedAt = startedAt;
 		this._completedAt = undefined;
 		this._result = undefined;
 		this._error = undefined;
+		this.releaseListeners();
+		this._onRunFinished = undefined;
+	}
+
+	// --- Per-run listener state (released on completion or resume reset) ---
+	private _unsub?: () => void;
+	private _detachFn?: () => void;
+	private _onRunFinished?: () => void;
+
+	/** Wire a parent AbortSignal so it stops this agent when fired. */
+	wireSignal(signal: AbortSignal | undefined, onAbort: () => void): void {
+		if (!signal) return;
+		const listener = () => onAbort();
+		signal.addEventListener("abort", listener, { once: true });
+		this._detachFn = () => signal.removeEventListener("abort", listener);
+	}
+
+	/** Store the record-observer unsubscribe handle. */
+	attachObserver(unsub: () => void): void {
+		this._unsub = unsub;
+	}
+
+	/** Release observer + signal listener handles. */
+	releaseListeners(): void {
+		this._unsub?.();
+		this._unsub = undefined;
+		this._detachFn?.();
+		this._detachFn = undefined;
+	}
+
+	/** Set the callback fired once when the run finishes (for concurrency drain). */
+	setOnRunFinished(fn: (() => void) | undefined): void {
+		this._onRunFinished = fn;
+	}
+
+	/** Fire the onRunFinished callback at most once. */
+	private fireOnRunFinished(): void {
+		const fn = this._onRunFinished;
+		this._onRunFinished = undefined;
+		fn?.();
+	}
+
+	/** Complete a run: release listeners, worktree cleanup, status transition, execution update, fire onRunFinished. */
+	completeRun(result: RunResult, worktrees: WorktreeManager): void {
+		this.releaseListeners();
+
+		let finalResult = result.responseText;
+		if (this.worktreeState) {
+			const wtResult = this.worktreeState.performCleanup(worktrees, this.description);
+			if (wtResult.hasChanges && wtResult.branch) {
+				finalResult += `\n\n---\nChanges saved to branch \`${wtResult.branch}\`. Merge with: \`git merge ${wtResult.branch}\``;
+			}
+		}
+
+		if (result.aborted) this.markAborted(finalResult);
+		else if (result.steered) this.markSteered(finalResult);
+		else this.markCompleted(finalResult);
+
+		this.execution = {
+			session: result.session,
+			outputFile: result.sessionFile ?? this.execution?.outputFile,
+		};
+
+		this.fireOnRunFinished();
+	}
+
+	/** Fail a run: mark error, release listeners, best-effort worktree cleanup, fire onRunFinished. */
+	failRun(err: unknown, worktrees: WorktreeManager): void {
+		this.markError(err);
+		this.releaseListeners();
+
+		if (this.worktreeState) {
+			try {
+				this.worktreeState.performCleanup(worktrees, this.description);
+			} catch (cleanupErr) { debugLog("cleanupWorktree on agent error", cleanupErr); }
+		}
+
+		this.fireOnRunFinished();
 	}
 }

package/src/lifecycle/execution-state.ts

@@ -1,9 +1,9 @@
 /**
  * execution-state.ts — ExecutionState: execution-phase state for a running agent.
  *
- * Constructed and attached to AgentRecord when onSessionCreated fires inside startAgent().
+ * Constructed and attached to Agent when onSessionCreated fires inside startAgent().
  * Contains the session and output file — the two fields that become known once the
- * runner creates the session. promise stays as a separate AgentRecord field because
+ * runner creates the session. promise stays as a separate Agent field because
  * it is set at a different moment (after runner.run() returns).
  */
 

package/src/observation/notification.ts

@@ -1,6 +1,6 @@
 import { debugLog } from "#src/debug";
 import { getLifetimeTotal, getSessionContextPercent } from "#src/lifecycle/usage";
-import type { AgentRecord } from "#src/types";
+import type { Agent } from "#src/types";
 import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 
 /** Details attached to custom notification messages for visual rendering. */
@@ -42,7 +42,7 @@ export function getStatusLabel(status: string, error?: string): string {
 }
 
 /** Format a structured task notification matching Claude Code's <task-notification> XML. */
-export function formatTaskNotification(record: AgentRecord, resultMaxLen: number): string {
+export function formatTaskNotification(record: Agent, resultMaxLen: number): string {
   const status = getStatusLabel(record.status, record.error);
   const durationMs = record.completedAt ? record.completedAt - record.startedAt : 0;
   const totalTokens = getLifetimeTotal(record.lifetimeUsage);
@@ -75,7 +75,7 @@ export function formatTaskNotification(record: AgentRecord, resultMaxLen: number
 
 /** Build notification details for the custom message renderer. */
 export function buildNotificationDetails(
-  record: AgentRecord,
+  record: Agent,
   resultMaxLen: number,
   activity?: AgentActivityTracker,
 ): NotificationDetails {
@@ -100,8 +100,8 @@ export function buildNotificationDetails(
   };
 }
 
-/** Build event data for lifecycle events from an AgentRecord. */
-export function buildEventData(record: AgentRecord) {
+/** Build event data for lifecycle events from an Agent. */
+export function buildEventData(record: Agent) {
   const durationMs = record.completedAt ? record.completedAt - record.startedAt : Date.now() - record.startedAt;
   const u = record.lifetimeUsage;
   const total = getLifetimeTotal(u);
@@ -126,7 +126,7 @@ export function buildEventData(record: AgentRecord) {
 
 export interface NotificationSystem {
   cancelNudge: (key: string) => void;
-  sendCompletion: (record: AgentRecord) => void;
+  sendCompletion: (record: Agent) => void;
   cleanupCompleted: (id: string) => void;
   dispose: () => void;
 }
@@ -154,7 +154,7 @@ export class NotificationManager implements NotificationSystem {
     }
   }
 
-  sendCompletion(record: AgentRecord): void {
+  sendCompletion(record: Agent): void {
     this.agentActivity.delete(record.id);
     this.markFinished(record.id);
     this.scheduleNudge(record.id, () => this.emitIndividualNudge(record));
@@ -187,7 +187,7 @@ export class NotificationManager implements NotificationSystem {
     );
   }
 
-  private emitIndividualNudge(record: AgentRecord): void {
+  private emitIndividualNudge(record: Agent): void {
     if (record.notification?.resultConsumed) return;
 
     const notification = formatTaskNotification(record, 500);

package/src/observation/record-observer.ts

@@ -1,16 +1,16 @@
 /**
- * record-observer.ts — Subscribes to session events and updates AgentRecord stats.
+ * record-observer.ts — Subscribes to session events and updates Agent stats.
  *
  * Replaces the scattered callback-wrapping logic in AgentManager's startAgent()
  * and resume() with a single direct subscription.
  */
 
+import type { Agent } from "#src/lifecycle/agent";
 import type { CompactionInfo } from "#src/lifecycle/agent-manager";
-import type { AgentRecord } from "#src/lifecycle/agent-record";
 import type { SubscribableSession } from "#src/types";
 
-export interface RecordObserverOptions {
-  onCompact?: (record: AgentRecord, info: CompactionInfo) => void;
+export interface AgentObserverOptions {
+  onCompact?: (record: Agent, info: CompactionInfo) => void;
 }
 
 /**
@@ -23,10 +23,10 @@ export interface RecordObserverOptions {
  *
  * @returns An unsubscribe function.
  */
-export function subscribeRecordObserver(
+export function subscribeAgentObserver(
   session: SubscribableSession,
-  record: AgentRecord,
-  options?: RecordObserverOptions,
+  record: Agent,
+  options?: AgentObserverOptions,
 ): () => void {
   return session.subscribe((event) => {
     if (event.type === "tool_execution_end") {

package/src/service/service-adapter.ts

@@ -8,17 +8,16 @@
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { SpawnOptions, SubagentRecord, SubagentsService } from "#src/service/service";
 import type { ModelRegistry } from "#src/session/model-resolver";
-import type { AgentRecord, SessionContext } from "#src/types";
+import type { Agent, SessionContext } from "#src/types";
 
 /** Narrow interface for the AgentManager — avoids coupling to the concrete class. */
 export interface AgentManagerLike {
   spawn(snapshot: ParentSnapshot, type: string, prompt: string, options: unknown): string;
-  getRecord(id: string): AgentRecord | undefined;
-  listAgents(): AgentRecord[];
+  getRecord(id: string): Agent | undefined;
+  listAgents(): Agent[];
   abort(id: string): boolean;
   waitForAll(): Promise<void>;
   hasRunning(): boolean;
-  queueSteer(id: string, message: string): boolean;
 }
 
 /**
@@ -93,8 +92,9 @@ export class SubagentsServiceAdapter implements SubagentsService {
     }
     const session = record.session;
     if (!session) {
-      // Session not ready yet — queue via manager for delivery once initialized
-      return this.manager.queueSteer(id, message);
+      // Session not ready yet — buffer on the agent for delivery once initialized
+      record.queueSteer(message);
+      return true;
     }
     await session.steer(message);
     return true;
@@ -110,10 +110,10 @@ export class SubagentsServiceAdapter implements SubagentsService {
 }
 
 /**
- * Convert an internal AgentRecord to a serializable SubagentRecord.
+ * Convert an internal Agent to a serializable SubagentRecord.
  * Uses an explicit allowlist — new fields must be opted in.
  */
-export function toSubagentRecord(record: AgentRecord): SubagentRecord {
+export function toSubagentRecord(record: Agent): SubagentRecord {
   const out: SubagentRecord = {
     id: record.id,
     type: record.type,

package/src/tools/agent-tool.ts

@@ -11,7 +11,7 @@ import { runForeground } from "#src/tools/foreground-runner";
 import { buildDetails, buildTypeListText, textResult } from "#src/tools/helpers";
 import { renderAgentResult } from "#src/tools/result-renderer";
 import { type ModelInfo, resolveSpawnConfig } from "#src/tools/spawn-config";
-import type { AgentRecord } from "#src/types";
+import type { Agent } from "#src/types";
 import { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import { type UICtx } from "#src/ui/agent-widget";
 import { type AgentDetails, getDisplayName } from "#src/ui/display";
@@ -33,9 +33,9 @@ export interface AgentActivityAccess {
 /** Narrow manager interface — only the methods the Agent tool calls. */
 export interface AgentToolManager {
 	spawn: (snapshot: ParentSnapshot, type: string, prompt: string, opts: AgentSpawnConfig) => string;
-	spawnAndWait: (snapshot: ParentSnapshot, type: string, prompt: string, opts: Omit<AgentSpawnConfig, "isBackground">) => Promise<AgentRecord>;
-	resume: (id: string, prompt: string, signal: AbortSignal) => Promise<AgentRecord | undefined>;
-	getRecord: (id: string) => AgentRecord | undefined;
+	spawnAndWait: (snapshot: ParentSnapshot, type: string, prompt: string, opts: Omit<AgentSpawnConfig, "isBackground">) => Promise<Agent>;
+	resume: (id: string, prompt: string, signal: AbortSignal) => Promise<Agent | undefined>;
+	getRecord: (id: string) => Agent | undefined;
 }
 
 /** Narrow runtime interface — the Agent tool's slice of SubagentRuntime. */

package/src/tools/background-spawner.ts

@@ -3,14 +3,14 @@ import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import type { AgentActivityAccess } from "#src/tools/agent-tool";
 import { textResult } from "#src/tools/helpers";
 import type { ResolvedSpawnConfig } from "#src/tools/spawn-config";
-import type { AgentRecord } from "#src/types";
+import type { Agent } from "#src/types";
 import { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import { subscribeUIObserver } from "#src/ui/ui-observer";
 
 /** Narrow manager interface for the background spawner. */
 export interface BackgroundManagerDeps {
   spawn(snapshot: ParentSnapshot, type: string, prompt: string, opts: AgentSpawnConfig): string;
-  getRecord(id: string): AgentRecord | undefined;
+  getRecord(id: string): Agent | undefined;
 }
 
 /** Narrow widget interface for the background spawner. */

package/src/tools/foreground-runner.ts

@@ -9,7 +9,7 @@ import {
   textResult,
 } from "#src/tools/helpers";
 import type { ResolvedSpawnConfig } from "#src/tools/spawn-config";
-import type { AgentRecord } from "#src/types";
+import type { Agent } from "#src/types";
 import { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import {
   type AgentDetails,
@@ -26,7 +26,7 @@ export interface ForegroundManagerDeps {
     type: string,
     prompt: string,
     opts: Omit<AgentSpawnConfig, "isBackground">,
-  ): Promise<AgentRecord>;
+  ): Promise<Agent>;
 }
 
 /** Narrow widget interface for the foreground runner. */
@@ -62,7 +62,7 @@ export async function runForeground(
 
   const fgState = new AgentActivityTracker(execution.effectiveMaxTurns);
   let unsubUI: (() => void) | undefined;
-  let recordRef: AgentRecord | undefined;
+  let recordRef: Agent | undefined;
 
   const streamUpdate = () => {
     const toolUses = recordRef?.toolUses ?? 0;
@@ -92,7 +92,7 @@ export async function runForeground(
 
   streamUpdate();
 
-  let record: AgentRecord;
+  let record: Agent;
   try {
     record = await manager.spawnAndWait(
       params.snapshot,

package/src/tools/get-result-tool.ts

@@ -4,13 +4,13 @@ import type { AgentConfigLookup } from "#src/config/agent-types";
 import { getAgentConversation } from "#src/lifecycle/agent-runner";
 import { getSessionContextPercent } from "#src/lifecycle/usage";
 import { formatLifetimeTokens, textResult } from "#src/tools/helpers";
-import type { AgentRecord } from "#src/types";
+import type { Agent } from "#src/types";
 import { formatDuration, getDisplayName } from "#src/ui/display";
 
 // ---- Deps interfaces ----
 
 export interface GetResultToolManager {
-	getRecord(id: string): AgentRecord | undefined;
+	getRecord(id: string): Agent | undefined;
 }
 
 export interface GetResultToolNotifications {

package/src/tools/steer-tool.ts

@@ -2,13 +2,12 @@ import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { getSessionContextPercent } from "#src/lifecycle/usage";
 import { formatLifetimeTokens, textResult } from "#src/tools/helpers";
-import type { AgentRecord } from "#src/types";
+import type { Agent } from "#src/types";
 
 // ---- Deps interfaces ----
 
 export interface SteerToolManager {
-	getRecord(id: string): AgentRecord | undefined;
-	queueSteer(id: string, message: string): boolean;
+	getRecord(id: string): Agent | undefined;
 }
 
 export interface SteerToolEvents {
@@ -43,8 +42,8 @@ export class SteerTool {
 		}
 		const session = record.session;
 		if (!session) {
-			// Session not ready yet — queue via manager for delivery once initialized
-			this.manager.queueSteer(record.id, params.message);
+			// Session not ready yet — buffer on the agent for delivery once initialized
+			record.queueSteer(params.message);
 			this.events.emit("subagents:steered", { id: record.id, message: params.message });
 			return textResult(
 				`Steering message queued for agent ${record.id}. It will be delivered once the session initializes.`,

package/src/types.ts

@@ -7,7 +7,7 @@ import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { ModelRegistry } from "#src/session/model-resolver";
 
 
-export { AgentRecord } from "#src/lifecycle/agent-record";
+export { Agent } from "#src/lifecycle/agent";
 export type { AgentSessionEvent, ThinkingLevel };
 
 /**

package/src/ui/agent-creation-wizard.ts

@@ -9,7 +9,7 @@ import { join } from "node:path";
 
 import { BUILTIN_TOOL_NAMES } from "#src/config/agent-types";
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
-import type { AgentRecord } from "#src/types";
+import type { Agent } from "#src/types";
 import type { AgentFileOps } from "#src/ui/agent-file-ops";
 import { writeAgentFile } from "#src/ui/agent-file-writer";
 import type { MenuUI } from "#src/ui/agent-menu";
@@ -23,7 +23,7 @@ export interface WizardManager {
     type: string,
     prompt: string,
     opts: { description: string; maxTurns: number },
-  ) => Promise<AgentRecord>;
+  ) => Promise<Agent>;
 }
 
 /** Narrow registry interface for reloading after creation. */

package/src/ui/agent-menu.ts

@@ -4,7 +4,7 @@ import { AgentTypeRegistry } from "#src/config/agent-types";
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
 import { type ModelRegistry, resolveModel } from "#src/session/model-resolver";
 import { getModelLabelFromConfig } from "#src/tools/helpers";
-import type { AgentConfig, AgentRecord } from "#src/types";
+import type { Agent, AgentConfig } from "#src/types";
 import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import { AgentConfigEditor } from "#src/ui/agent-config-editor";
 import { AgentCreationWizard } from "#src/ui/agent-creation-wizard";
@@ -15,15 +15,15 @@ import { formatDuration, getDisplayName } from "#src/ui/display";
 
 /** Narrow manager interface for menu operations. */
 export interface AgentMenuManager {
-  listAgents: () => AgentRecord[];
-  getRecord: (id: string) => AgentRecord | undefined;
+  listAgents: () => Agent[];
+  getRecord: (id: string) => Agent | undefined;
   /** Used by generate wizard to spawn an agent that writes the .md file. */
   spawnAndWait: (
     parentSnapshot: ParentSnapshot,
     type: string,
     prompt: string,
     opts: { description: string; maxTurns: number },
-  ) => Promise<AgentRecord>;
+  ) => Promise<Agent>;
 }
 
 /** Narrow settings interface required by the agent menu. */
@@ -251,7 +251,7 @@ export class AgentsMenuHandler {
     await this.showRunningAgents(ui);
   }
 
-  private async viewAgentConversation(ui: MenuUI, record: AgentRecord): Promise<void> {
+  private async viewAgentConversation(ui: MenuUI, record: Agent): Promise<void> {
     const session = record.session;
     if (!session) {
       ui.notify(

package/src/ui/conversation-viewer.ts

@@ -9,7 +9,7 @@ import type { AgentSession } from "@earendil-works/pi-coding-agent";
 import { type Component, matchesKey, type TUI, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { AgentConfigLookup } from "#src/config/agent-types";
 import { getLifetimeTotal, getSessionContextPercent } from "#src/lifecycle/usage";
-import type { AgentRecord } from "#src/types";
+import type { Agent } from "#src/types";
 import type { AgentActivityTracker } from "#src/ui/agent-activity-tracker";
 import { buildInvocationTags, formatDuration, formatSessionTokens, getDisplayName, getPromptModeLabel, type Theme } from "#src/ui/display";
 import { formatMessage, formatStreamingIndicator } from "#src/ui/message-formatters";
@@ -25,7 +25,7 @@ export const VIEWPORT_HEIGHT_PCT = 70;
 export interface ConversationViewerOptions {
   tui: TUI;
   session: AgentSession;
-  record: AgentRecord;
+  record: Agent;
   activity: AgentActivityTracker | undefined;
   theme: Theme;
   done: (result: undefined) => void;
@@ -42,7 +42,7 @@ export class ConversationViewer implements Component {
 
   private tui: TUI;
   private session: AgentSession;
-  private record: AgentRecord;
+  private record: Agent;
   private activity: AgentActivityTracker | undefined;
   private theme: Theme;
   private done: (result: undefined) => void;