@yandy0725/pi-subagents 0.1.0

package/src/tools/agent-tool.ts

@@ -0,0 +1,220 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-base-to-string, @typescript-eslint/restrict-template-expressions -- Pi SDK types are not fully exported; see upstream Pi SDK for type improvements */
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "@sinclair/typebox";
+import type { AgentTypeRegistry } from "../config/agent-types";
+import type { ParentSnapshot } from "../lifecycle/parent-snapshot";
+import type { AgentSpawnConfig } from "../lifecycle/subagent-manager";
+import { spawnBackground } from "../tools/background-spawner";
+import { runForeground } from "../tools/foreground-runner";
+import { buildDetails, buildTypeListText, textResult } from "../tools/helpers";
+import { renderAgentResult } from "../tools/result-renderer";
+import { type ModelInfo, resolveSpawnConfig } from "../tools/spawn-config";
+import type { ParentSessionInfo, Subagent } from "../types";
+import { type AgentDetails, getDisplayName } from "../ui/display";
+
+// ---- Deps interfaces ----
+
+/** 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<Subagent>;
+	resume: (id: string, prompt: string, signal: AbortSignal) => Promise<Subagent | undefined>;
+	getRecord: (id: string) => Subagent | undefined;
+}
+
+/** Narrow runtime interface — the Agent tool's slice of SubagentRuntime. */
+export interface AgentToolRuntime {
+	buildSnapshot(inheritContext: boolean): ParentSnapshot;
+	getModelInfo(): ModelInfo;
+	getSessionInfo(): { parentSessionFile: string; parentSessionId: string };
+}
+
+/** Narrow settings accessor — only the fields the Agent tool reads. */
+export type AgentToolSettings = {
+	readonly defaultMaxTurns: number | undefined;
+	readonly maxConcurrent: number;
+};
+
+// ---- Class ----
+
+export class AgentTool {
+	private readonly typeListText: string;
+	private readonly availableTypesText: string;
+
+	constructor(
+		private readonly manager: AgentToolManager,
+		private readonly runtime: AgentToolRuntime,
+		private readonly settings: AgentToolSettings,
+		private readonly registry: AgentTypeRegistry,
+		private readonly agentDir: string,
+	) {
+		this.typeListText = buildTypeListText(registry, agentDir);
+		this.availableTypesText = registry.getAvailableTypes().join(", ");
+	}
+
+	async execute(
+		toolCallId: string,
+		params: Record<string, unknown>,
+		signal: AbortSignal | undefined,
+		onUpdate: ((update: AgentToolResult<any>) => void) | undefined,
+		_ctx: any,
+	) {
+		// Reload custom agents so new .pi/agents/*.md files are picked up without restart
+		this.registry.reload();
+
+		// ---- Config resolution (pure) ----
+		const config = resolveSpawnConfig(params, this.registry, this.runtime.getModelInfo(), this.settings);
+		if ("error" in config) return textResult(config.error);
+
+		// ---- Boundary extraction (after config so inheritContext is resolved) ----
+		const snapshot = this.runtime.buildSnapshot(config.execution.inheritContext);
+		const { parentSessionFile, parentSessionId } = this.runtime.getSessionInfo();
+		const parentSession: ParentSessionInfo = { parentSessionFile, parentSessionId, toolCallId };
+
+		// ---- Resume existing agent ----
+		if (params.resume) {
+			const existing = this.manager.getRecord(params.resume as string);
+			if (!existing) {
+				return textResult(`Agent not found: "${params.resume}". It may have been cleaned up.`);
+			}
+			if (!existing.isSessionReady()) {
+				return textResult(`Agent "${params.resume}" has no active session to resume.`);
+			}
+			const record = await this.manager.resume(
+				params.resume as string,
+				params.prompt as string,
+				signal ?? new AbortController().signal,
+			);
+			if (!record) {
+				return textResult(`Failed to resume agent "${params.resume}".`);
+			}
+			return textResult(
+				record.result?.trim() ?? record.error?.trim() ?? "No output.",
+				buildDetails(config.presentation.detailBase, record),
+			);
+		}
+
+		// ---- Background execution ----
+		if (config.execution.runInBackground) {
+			return spawnBackground(this.manager, { config, snapshot, parentSession, settings: this.settings });
+		}
+
+		// ---- Foreground execution — stream progress via onUpdate ----
+		return runForeground(this.manager, { config, snapshot, parentSession }, signal, onUpdate);
+	}
+
+	toToolDefinition() {
+		const typeListText = this.typeListText;
+		const availableTypesText = this.availableTypesText;
+		const agentDir = this.agentDir;
+		const registry = this.registry;
+
+		return defineTool({
+			name: "subagent" as const,
+			label: "Subagent",
+			promptSnippet: "subagent: Launch a specialized agent for complex, multi-step tasks.",
+			description: `Launch a new agent to handle complex, multi-step tasks autonomously.
+
+The subagent tool launches specialized agents that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
+
+Available agent types:
+${typeListText}
+
+Guidelines:
+- For parallel work, use run_in_background: true on each agent. Foreground calls run sequentially — only one executes at a time.
+- Use Explore for codebase searches and code understanding.
+- Use Plan for architecture and implementation planning.
+- Use general-purpose for complex tasks that need file editing.
+- Provide clear, detailed prompts so the agent can work autonomously.
+- Subagent results are returned as text — summarize them for the user.
+- Use run_in_background for work you don't need immediately. You will be notified when it completes.
+- Use resume with an agent ID to continue a previous agent's work.
+- Use steer_subagent to send mid-run messages to a running background agent.
+- Use model to specify a different model (as "provider/modelId", or fuzzy e.g. "haiku", "sonnet").
+- Use thinking to control extended thinking level.
+- Use inherit_context if the agent needs the parent conversation history.
+`,
+			parameters: Type.Object({
+				prompt: Type.String({
+					description: "The task for the agent to perform.",
+				}),
+				description: Type.String({
+					description: "A short (3-5 word) description of the task (shown in UI).",
+				}),
+				subagent_type: Type.String({
+					description: `The type of specialized agent to use. Available types: ${availableTypesText}. Custom agents from .pi/agents/<name>.md (project) or ${agentDir}/agents/<name>.md (global) are also available.`,
+				}),
+				model: Type.Optional(
+					Type.String({
+						description:
+							'Optional model override. Accepts "provider/modelId" or fuzzy name (e.g. "haiku", "sonnet"). Omit to use the agent type\'s default.',
+					}),
+				),
+				thinking: Type.Optional(
+					Type.String({
+						description: "Thinking level: off, minimal, low, medium, high, xhigh. Overrides agent default.",
+					}),
+				),
+				max_turns: Type.Optional(
+					Type.Number({
+						description: "Maximum number of agentic turns before stopping. Omit for unlimited (default).",
+						minimum: 1,
+					}),
+				),
+				run_in_background: Type.Optional(
+					Type.Boolean({
+						description:
+							"Set to true to run in background. Returns agent ID immediately. You will be notified when it completes.",
+					}),
+				),
+				resume: Type.Optional(
+					Type.String({
+						description: "Optional agent ID to resume from. Continues from previous context.",
+					}),
+				),
+				inherit_context: Type.Optional(
+					Type.Boolean({
+						description: "If true, fork parent conversation into the agent. Default: false (fresh context).",
+					}),
+				),
+			}),
+
+			// ---- Custom rendering: inline subagent results ----
+
+			renderCall(args: Record<string, unknown>, theme: any) {
+				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) : ""),
+					0,
+					0,
+				);
+			},
+
+			renderResult(result: any, { expanded, isPartial }: any, theme: any) {
+				const details = result.details as AgentDetails | undefined;
+				if (!details) {
+					const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+					return new Text(text, 0, 0);
+				}
+				const resultText = result.content[0]?.type === "text" ? result.content[0].text : "";
+				return new Text(renderAgentResult(details, resultText, expanded, isPartial, theme), 0, 0);
+			},
+
+			execute: (
+				toolCallId: string,
+				params: Record<string, unknown>,
+				signal: AbortSignal | undefined,
+				onUpdate: ((update: AgentToolResult<any>) => void) | undefined,
+				ctx: any,
+			) => this.execute(toolCallId, params, signal, onUpdate, ctx),
+		});
+	}
+}

package/src/tools/background-spawner.ts

@@ -0,0 +1,66 @@
+import type { ParentSnapshot } from "../lifecycle/parent-snapshot";
+import type { AgentSpawnConfig } from "../lifecycle/subagent-manager";
+import { textResult } from "../tools/helpers";
+import type { ResolvedSpawnConfig } from "../tools/spawn-config";
+import type { ParentSessionInfo, Subagent } from "../types";
+
+/** Narrow manager interface for the background spawner. */
+export interface BackgroundManagerDeps {
+	spawn(snapshot: ParentSnapshot, type: string, prompt: string, opts: AgentSpawnConfig): string;
+	getRecord(id: string): Subagent | undefined;
+}
+
+/** All values the background spawner needs beyond the resolved config. */
+export interface BackgroundParams {
+	config: ResolvedSpawnConfig;
+	snapshot: ParentSnapshot;
+	parentSession: ParentSessionInfo;
+	settings: { readonly maxConcurrent: number };
+}
+
+/**
+ * Spawn a background agent and return the tool result immediately.
+ * Owns: launch message formatting.
+ */
+export function spawnBackground(manager: BackgroundManagerDeps, params: BackgroundParams) {
+	const { identity, execution, presentation } = params.config;
+
+	let id: string;
+	try {
+		id = manager.spawn(params.snapshot, identity.subagentType, execution.prompt, {
+			parentSession: params.parentSession,
+			description: execution.description,
+			model: execution.model,
+			maxTurns: execution.effectiveMaxTurns,
+			inheritContext: execution.inheritContext,
+			thinkingLevel: execution.thinking,
+			isBackground: true,
+			invocation: execution.agentInvocation,
+		});
+	} catch (err) {
+		return textResult(err instanceof Error ? err.message : String(err));
+	}
+
+	const record = manager.getRecord(id);
+
+	const isQueued = record?.status === "queued";
+	return textResult(
+		`Agent ${isQueued ? "queued" : "started"} in background.\n` +
+			`Agent ID: ${id}\n` +
+			`Type: ${identity.displayName}\n` +
+			`Description: ${execution.description}\n` +
+			(record?.outputFile ? `Output file: ${record.outputFile}\n` : "") +
+			(isQueued ? `Position: queued (max ${params.settings.maxConcurrent} concurrent)\n` : "") +
+			`\nYou will be notified when this agent completes.\n` +
+			`Use get_subagent_result to retrieve full results, or steer_subagent to send it messages.\n` +
+			`Do not duplicate this agent's work.`,
+		{
+			...presentation.detailBase,
+			toolUses: 0,
+			tokens: "",
+			durationMs: 0,
+			status: "background" as const,
+			agentId: id,
+		},
+	);
+}

package/src/tools/foreground-runner.ts

@@ -0,0 +1,114 @@
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+import type { ParentSnapshot } from "../lifecycle/parent-snapshot";
+import type { AgentSpawnConfig } from "../lifecycle/subagent-manager";
+import { buildDetails, formatLifetimeTokens, getStatusNote, textResult } from "../tools/helpers";
+import type { ResolvedSpawnConfig } from "../tools/spawn-config";
+import type { ParentSessionInfo, Subagent } from "../types";
+import { type AgentDetails, describeActivity, formatMs, SPINNER } from "../ui/display";
+
+/** Narrow manager interface for the foreground runner. */
+export interface ForegroundManagerDeps {
+	spawnAndWait(
+		snapshot: ParentSnapshot,
+		type: string,
+		prompt: string,
+		opts: Omit<AgentSpawnConfig, "isBackground">,
+	): Promise<Subagent>;
+}
+
+/** All values the foreground runner needs beyond the resolved config. */
+export interface ForegroundParams {
+	config: ResolvedSpawnConfig;
+	snapshot: ParentSnapshot;
+	parentSession: ParentSessionInfo;
+}
+
+/**
+ * Run an agent synchronously in the foreground, streaming spinner updates.
+ * Owns: spinner interval, streaming onUpdate callbacks, cleanup, and result formatting.
+ */
+export async function runForeground(
+	manager: ForegroundManagerDeps,
+	params: ForegroundParams,
+	signal: AbortSignal | undefined,
+	onUpdate: ((update: AgentToolResult<any>) => void) | undefined,
+) {
+	const { identity, execution, presentation } = params.config;
+	let spinnerFrame = 0;
+	const startedAt = Date.now();
+
+	let recordRef: Subagent | undefined;
+
+	const streamUpdate = () => {
+		const toolUses = recordRef?.toolUses ?? 0;
+		const details: AgentDetails = {
+			...presentation.detailBase,
+			toolUses,
+			tokens: recordRef ? formatLifetimeTokens(recordRef) : "",
+			// Read activity off the record; fall back to safe defaults before onSessionCreated fires
+			turnCount: recordRef?.turnCount ?? 1,
+			maxTurns: recordRef?.maxTurns ?? execution.effectiveMaxTurns,
+			durationMs: Date.now() - startedAt,
+			status: "running",
+			activity: describeActivity(recordRef?.activeTools ?? new Map(), recordRef?.responseText ?? ""),
+			spinnerFrame: spinnerFrame % SPINNER.length,
+		};
+		onUpdate?.({
+			content: [{ type: "text", text: `${toolUses} tool uses...` }],
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- Pi SDK ToolCallUpdate details type is not exported
+			details: details as any,
+		});
+	};
+
+	// Animate spinner at ~80ms (smooth rotation through 10 braille frames)
+	const spinnerInterval = setInterval(() => {
+		spinnerFrame++;
+		streamUpdate();
+	}, 80);
+
+	streamUpdate();
+
+	let record: Subagent;
+	try {
+		record = await manager.spawnAndWait(params.snapshot, identity.subagentType, execution.prompt, {
+			description: execution.description,
+			model: execution.model,
+			maxTurns: execution.effectiveMaxTurns,
+			inheritContext: execution.inheritContext,
+			thinkingLevel: execution.thinking,
+			invocation: execution.agentInvocation,
+			signal,
+			parentSession: params.parentSession,
+			observer: {
+				onSessionCreated: (agent) => {
+					recordRef = agent;
+				},
+			},
+		});
+	} catch (err) {
+		clearInterval(spinnerInterval);
+		return textResult(err instanceof Error ? err.message : String(err));
+	}
+
+	clearInterval(spinnerInterval);
+
+	const tokenText = formatLifetimeTokens(record);
+	const details = buildDetails(presentation.detailBase, record, { tokens: tokenText });
+
+	const fallbackNote = identity.fellBack
+		? `Note: Unknown agent type "${identity.rawType}" — using general-purpose.\n\n`
+		: "";
+
+	if (record.status === "error") {
+		return textResult(`${fallbackNote}Agent failed: ${record.error}`, details);
+	}
+
+	const durationMs = (record.completedAt ?? Date.now()) - record.startedAt;
+	const statsParts = [`${record.toolUses} tool uses`];
+	if (tokenText) statsParts.push(tokenText);
+	return textResult(
+		`${fallbackNote}Agent completed in ${formatMs(durationMs)} (${statsParts.join(", ")})${getStatusNote(record.status)}.\n\n` +
+			(record.result?.trim() ?? "No output."),
+		details,
+	);
+}

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

@@ -0,0 +1,120 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import type { AgentConfigLookup } from "../config/agent-types";
+import { formatLifetimeTokens, textResult } from "../tools/helpers";
+import type { Subagent } from "../types";
+import { formatDuration, getDisplayName } from "../ui/display";
+
+// ---- Deps interfaces ----
+
+export interface GetResultToolManager {
+	getRecord(id: string): Subagent | undefined;
+}
+
+export interface GetResultToolNotifications {
+	cancelNudge(key: string): void;
+}
+
+// ---- Class ----
+
+export class GetResultTool {
+	constructor(
+		private readonly manager: GetResultToolManager,
+		private readonly notifications: GetResultToolNotifications,
+		private readonly registry: AgentConfigLookup,
+	) {}
+
+	async execute(
+		_toolCallId: string,
+		params: { agent_id: string; wait?: boolean; verbose?: boolean },
+		_signal: AbortSignal,
+		_onUpdate: unknown,
+		_ctx: unknown,
+	) {
+		const record = this.manager.getRecord(params.agent_id);
+		if (!record) {
+			return textResult(`Agent not found: "${params.agent_id}". It may have been cleaned up.`);
+		}
+
+		// Wait for completion if requested.
+		// Pre-mark resultConsumed BEFORE awaiting: onComplete fires inside .then()
+		// (attached earlier at spawn time) and always runs before this await resumes.
+		// Setting the flag here prevents a redundant follow-up notification.
+		if (params.wait && record.status === "running" && record.promise) {
+			// Pre-mark consumed BEFORE awaiting — onComplete fires inside .then() and
+			// always runs before this await resumes. Prevents a redundant notification.
+			record.notification?.markConsumed();
+			this.notifications.cancelNudge(params.agent_id);
+			await record.promise;
+		}
+
+		const displayName = getDisplayName(record.type, this.registry);
+		const duration = formatDuration(record.startedAt, record.completedAt);
+		const tokens = formatLifetimeTokens(record);
+		const contextPercent = record.getContextPercent();
+		const statsParts = [`Tool uses: ${record.toolUses}`];
+		if (tokens) statsParts.push(tokens);
+		if (contextPercent !== null) statsParts.push(`Context: ${Math.round(contextPercent)}%`);
+		if (record.compactionCount) statsParts.push(`Compactions: ${record.compactionCount}`);
+		statsParts.push(`Duration: ${duration}`);
+
+		let output =
+			`Agent: ${record.id}\n` +
+			`Type: ${displayName} | Status: ${record.status} | ${statsParts.join(" | ")}\n` +
+			`Description: ${record.description}\n\n`;
+
+		if (record.status === "running") {
+			output += "Agent is still running. Use wait: true or check back later.";
+		} else if (record.status === "error") {
+			output += `Error: ${record.error}`;
+		} else {
+			output += record.result?.trim() ?? "No output.";
+		}
+
+		// Mark result as consumed — suppresses the completion notification
+		if (record.status !== "running" && record.status !== "queued") {
+			record.notification?.markConsumed();
+			this.notifications.cancelNudge(params.agent_id);
+		}
+
+		// Verbose: include full conversation
+		const conversation = params.verbose ? record.getConversation() : undefined;
+		if (conversation) {
+			output += `\n\n--- Agent Conversation ---\n${conversation}`;
+		}
+
+		return textResult(output);
+	}
+
+	toToolDefinition() {
+		return defineTool({
+			name: "get_subagent_result" as const,
+			label: "Get Agent Result",
+			promptSnippet: "get_subagent_result: Check status and retrieve results from a background agent.",
+			description:
+				"Check status and retrieve results from a background agent. Use the agent ID returned by Agent with run_in_background.",
+			parameters: Type.Object({
+				agent_id: Type.String({
+					description: "The agent ID to check.",
+				}),
+				wait: Type.Optional(
+					Type.Boolean({
+						description: "If true, wait for the agent to complete before returning. Default: false.",
+					}),
+				),
+				verbose: Type.Optional(
+					Type.Boolean({
+						description: "If true, include the agent's full conversation (messages + tool calls). Default: false.",
+					}),
+				),
+			}),
+			execute: (
+				toolCallId: string,
+				params: { agent_id: string; wait?: boolean; verbose?: boolean },
+				signal: AbortSignal,
+				onUpdate: unknown,
+				ctx: unknown,
+			) => this.execute(toolCallId, params, signal, onUpdate, ctx),
+		});
+	}
+}

package/src/tools/helpers.ts

@@ -0,0 +1,105 @@
+import type { AgentConfigLookup } from "../config/agent-types";
+import { getLifetimeTotal, type LifetimeUsage } from "../lifecycle/usage";
+import { type AgentDetails, formatTokens } from "../ui/display";
+
+/** Parenthetical status note for completed agent result text. */
+export function getStatusNote(status: string): string {
+	switch (status) {
+		case "aborted":
+			return " (aborted \u2014 max turns exceeded, output may be incomplete)";
+		case "steered":
+			return " (wrapped up \u2014 reached turn limit)";
+		case "stopped":
+			return " (stopped by user)";
+		default:
+			return "";
+	}
+}
+
+/** Build AgentDetails from a base + record-specific fields. */
+export function buildDetails(
+	base: Pick<AgentDetails, "displayName" | "description" | "subagentType" | "modelName" | "tags">,
+	record: {
+		toolUses: number;
+		startedAt: number;
+		completedAt?: number;
+		status: string;
+		error?: string;
+		id?: string;
+		lifetimeUsage: LifetimeUsage;
+		/** Live-activity counters — exposed as getters on Subagent (Phase 18 Step 2). */
+		turnCount?: number;
+		maxTurns?: number;
+	},
+	overrides?: Partial<AgentDetails>,
+): AgentDetails {
+	return {
+		...base,
+		toolUses: record.toolUses,
+		tokens: formatLifetimeTokens(record),
+		turnCount: record.turnCount,
+		maxTurns: record.maxTurns,
+		durationMs: (record.completedAt ?? Date.now()) - record.startedAt,
+		status: record.status as AgentDetails["status"],
+		agentId: record.id,
+		error: record.error,
+		...overrides,
+	};
+}
+
+/** Tool execute return value for a text response. */
+export function textResult(msg: string, details?: unknown) {
+	return { content: [{ type: "text" as const, text: msg }], details };
+}
+
+/** Format an agent's lifetime token total, or "" when zero. */
+export function formatLifetimeTokens(o: { lifetimeUsage: LifetimeUsage }): string {
+	const t = getLifetimeTotal(o.lifetimeUsage);
+	return t > 0 ? formatTokens(t) : "";
+}
+
+/**
+ * Narrow registry interface needed by buildTypeListText.
+ * Extends AgentConfigLookup with the two name-listing methods.
+ */
+export interface TypeListRegistry extends AgentConfigLookup {
+	getDefaultAgentNames(): string[];
+	getUserAgentNames(): string[];
+}
+
+/**
+ * Build the full agent-type list text for the Agent tool description.
+ * Extracted from index.ts so it can be called inside createAgentTool.
+ */
+export function buildTypeListText(registry: TypeListRegistry, agentDir: string): string {
+	const isEnabled = (name: string) => registry.resolveAgentConfig(name).enabled !== false;
+	const defaultNames = registry.getDefaultAgentNames().filter(isEnabled);
+	const userNames = registry.getUserAgentNames().filter(isEnabled);
+
+	const defaultDescs = defaultNames.map((name) => {
+		const cfg = registry.resolveAgentConfig(name);
+		const modelSuffix = cfg.model ? ` (${getModelLabelFromConfig(cfg.model)})` : "";
+		return `- ${name}: ${cfg.description}${modelSuffix}`;
+	});
+
+	const customDescs = userNames.map((name) => {
+		const cfg = registry.resolveAgentConfig(name);
+		return `- ${name}: ${cfg.description}`;
+	});
+
+	return [
+		"Default agents:",
+		...defaultDescs,
+		...(customDescs.length > 0 ? ["", "Custom agents:", ...customDescs] : []),
+		"",
+		`Custom agents can be defined in .pi/agents/<name>.md (project) or ${agentDir}/agents/<name>.md (global) — they are picked up automatically. Project-level agents override global ones. Creating a .md file with the same name as a default agent overrides it.`,
+	].join("\n");
+}
+
+/** Derive a short model label from a model string. */
+export function getModelLabelFromConfig(model: string): string {
+	// Strip provider prefix (e.g. "anthropic/claude-sonnet-4-6" → "claude-sonnet-4-6")
+	const name = model.includes("/") ? model.split("/").pop()! : model;
+	// Strip trailing date suffix (e.g. "claude-haiku-4-5-20251001" → "claude-haiku-4-5")
+	return name.replace(/-\d{8}$/, "");
+}