@oh-my-pi/pi-coding-agent 16.2.1 → 16.2.3

package/src/modes/components/advisor-config.ts

@@ -0,0 +1,555 @@
+/**
+ * Fullscreen `/advisor configure` overlay: a mouse- and keyboard-driven editor
+ * for the `WATCHDOG.yml` advisor roster at project or user level.
+ *
+ * It paints the entire alternate screen from row 0 (so SGR mouse rows index
+ * directly into the rendered frame) using the shared {@link ./overlay-box} chrome.
+ * The list screen is a two-pane split (the `/extensions` idiom): a clickable
+ * advisor/action sidebar on the left, and a scrollable preview of the highlighted
+ * advisor's model / tools / instructions on the right, filling the free space.
+ *
+ * Each screen is backed by a proven primitive — {@link SelectList} (list / detail
+ * / tools / thinking), {@link Input} (name), {@link ModelSelectorComponent} (the
+ * same rich `/model` picker, in direct-select mode), and {@link HookEditorComponent}
+ * (multiline instructions; Ctrl+G opens `$EDITOR`). The overlay edits an in-memory
+ * {@link WatchdogConfigDoc} and only touches disk + the live advisors via the host
+ * `save` callback.
+ */
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-ai";
+import { getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
+import {
+	type Component,
+	Input,
+	type MouseRoutable,
+	routeSgrMouseInput,
+	type SelectItem,
+	SelectList,
+	type SgrMouseEvent,
+	type TUI,
+	truncateToWidth,
+} from "@oh-my-pi/pi-tui";
+import {
+	ADVISOR_DEFAULT_TOOL_NAMES,
+	type AdvisorConfig,
+	type AdvisorConfigScope,
+	type WatchdogConfigDoc,
+} from "../../advisor";
+import type { ModelRegistry } from "../../config/model-registry";
+import { formatModelSelectorValue } from "../../config/model-resolver";
+import type { Settings } from "../../config/settings";
+import { getSelectListTheme, theme } from "../theme/theme";
+import { HookEditorComponent } from "./hook-editor";
+import { ModelSelectorComponent } from "./model-selector";
+import {
+	bottomBorder,
+	divider,
+	dividerSplit,
+	row,
+	splitBodyWidth,
+	splitRow,
+	topBorder,
+	topBorderSplit,
+} from "./overlay-box";
+
+/** Host callbacks: all disk + live-runtime effects flow through these. */
+export interface AdvisorConfigCallbacks {
+	/** Load a scope's `WATCHDOG.yml` into an editable doc (empty when absent). */
+	loadDoc: (scope: AdvisorConfigScope) => Promise<WatchdogConfigDoc>;
+	/** Persist the doc to the scope's file and rebuild the live advisors. */
+	save: (scope: AdvisorConfigScope, doc: WatchdogConfigDoc) => Promise<void>;
+	/** Tear down the overlay and restore the editor. */
+	close: () => void;
+	requestRender: () => void;
+	/** Surface a transient status/warning line to the user. */
+	notify: (message: string) => void;
+}
+
+export interface AdvisorConfigDeps {
+	modelRegistry: ModelRegistry;
+	settings: Settings;
+	scopedModels: ReadonlyArray<{ model: Model; thinkingLevel?: ThinkingLevel }>;
+	availableToolNames: string[];
+	/** Formatted advisor-role model shown on the seeded default row (e.g. "anthropic/claude-..."). */
+	defaultModelLabel?: string;
+}
+
+const PREVIEW_WIDTH = 60;
+
+function previewLine(text: string | undefined): string {
+	if (!text?.trim()) return "(none)";
+	const first = text.trim().split("\n", 1)[0] ?? "";
+	return first.length > PREVIEW_WIDTH ? `${first.slice(0, PREVIEW_WIDTH - 1)}…` : first;
+}
+
+/** Default when the set is empty or exactly read/grep/glob; else the available-ordered subset. */
+function commitTools(selected: ReadonlySet<string>, all: readonly string[]): string[] | undefined {
+	if (selected.size === 0) return undefined;
+	if (selected.size === ADVISOR_DEFAULT_TOOL_NAMES.size) {
+		let matchesDefault = true;
+		for (const name of ADVISOR_DEFAULT_TOOL_NAMES) {
+			if (!selected.has(name)) {
+				matchesDefault = false;
+				break;
+			}
+		}
+		if (matchesDefault) return undefined;
+	}
+	return all.filter(name => selected.has(name));
+}
+
+/** Soft-wrap plain text to `width`, returning at least one (possibly empty) line. */
+function wrap(text: string, width: number): string[] {
+	if (!text) return [""];
+	return Bun.wrapAnsi(text, Math.max(1, width), { trim: false }).split("\n");
+}
+
+type Screen = "list" | "detail" | "name" | "model" | "tools" | "thinking" | "instructions";
+
+/**
+ * Fullscreen advisor-configuration overlay. Implements {@link Component} directly
+ * (rather than extending Container) so it owns the whole frame and the mouse
+ * geometry needed to make every row clickable.
+ */
+export class AdvisorConfigOverlayComponent implements Component {
+	#tui: TUI;
+	#modelRegistry: ModelRegistry;
+	#settings: Settings;
+	#scopedModels: ReadonlyArray<{ model: Model; thinkingLevel?: ThinkingLevel }>;
+	#availableToolNames: readonly string[];
+	#defaultModelLabel: string | undefined;
+	#cb: AdvisorConfigCallbacks;
+	#scope: AdvisorConfigScope;
+	#doc: WatchdogConfigDoc;
+	#dirty = false;
+
+	#screen: Screen = "list";
+	/** The interactive element for the current screen. */
+	#active: Component = new SelectList([], 1, getSelectListTheme());
+	#footerHint = "";
+	#previewScroll = 0;
+
+	// Frame geometry from the last render (the frame paints from screen row 0,
+	// so SGR `event.row`/`event.col` — already 0-based — index it directly).
+	#bodyRowStart = 0;
+	#dividerCol = 0;
+
+	constructor(
+		tui: TUI,
+		deps: AdvisorConfigDeps,
+		scope: AdvisorConfigScope,
+		doc: WatchdogConfigDoc,
+		callbacks: AdvisorConfigCallbacks,
+	) {
+		this.#tui = tui;
+		this.#modelRegistry = deps.modelRegistry;
+		this.#settings = deps.settings;
+		this.#scopedModels = deps.scopedModels;
+		this.#availableToolNames = deps.availableToolNames;
+		this.#defaultModelLabel = deps.defaultModelLabel;
+		this.#cb = callbacks;
+		this.#scope = scope;
+		this.#doc = doc;
+		this.#ensureRosterVisible();
+		this.#showList();
+	}
+
+	// ───────────────────────────── render ─────────────────────────────
+
+	render(width: number): readonly string[] {
+		const height = Math.max(14, process.stdout.rows || 40);
+		const bodyRows = Math.max(3, height - 4);
+		const title = `Advisor configuration · ${this.#scope}${this.#dirty ? "  ● unsaved" : ""}`;
+		const out: string[] = [];
+
+		if (this.#screen === "list") {
+			const sidebarWidth = Math.max(22, Math.min(42, Math.floor(width * 0.34)));
+			this.#dividerCol = sidebarWidth + 3;
+			const bodyWidth = splitBodyWidth(width, sidebarWidth);
+			const sidebar = this.#active.render(sidebarWidth);
+			const preview = this.#previewWindow(bodyWidth, bodyRows);
+			out.push(topBorderSplit(width, title, sidebarWidth));
+			this.#bodyRowStart = out.length;
+			for (let i = 0; i < bodyRows; i++) {
+				out.push(splitRow(sidebar[i] ?? "", preview[i] ?? "", width, sidebarWidth));
+			}
+			out.push(dividerSplit(width, sidebarWidth));
+		} else {
+			out.push(topBorder(width, title));
+			this.#bodyRowStart = out.length;
+			const lines = this.#active.render(Math.max(1, width - 4));
+			for (let i = 0; i < bodyRows; i++) out.push(row(lines[i] ?? "", width));
+			out.push(divider(width));
+		}
+
+		out.push(row(theme.fg("dim", this.#footerHint), width));
+		out.push(bottomBorder(width));
+		return out;
+	}
+
+	// ───────────────────────────── input ─────────────────────────────
+
+	handleInput(data: string): void {
+		if (data.startsWith("\x1b[<")) {
+			routeSgrMouseInput(data, event => this.#routeMouseEvent(event));
+			return;
+		}
+		this.#active.handleInput?.(data);
+	}
+
+	/** Forward enhanced-paste transports into a multiline instructions editor. */
+	pasteText(text: string): void {
+		if (this.#active instanceof HookEditorComponent) this.#active.pasteText(text);
+	}
+
+	#routeMouseEvent(event: SgrMouseEvent): boolean {
+		// Right pane of the split (the preview) only scrolls; everything left of the
+		// divider routes into the active list/component at frame-local coordinates.
+		if (this.#screen === "list" && event.col >= this.#dividerCol) {
+			if (event.wheel !== null) {
+				this.#previewScroll = Math.max(0, this.#previewScroll + event.wheel);
+				this.#cb.requestRender();
+			}
+			return true;
+		}
+		const el = this.#active as Partial<MouseRoutable>;
+		if (typeof el.routeMouse === "function") {
+			el.routeMouse(event, event.row - this.#bodyRowStart, event.col);
+			return true;
+		}
+		return false;
+	}
+
+	// ───────────────────────────── preview ───────────────────────────
+
+	#previewWindow(bodyWidth: number, rows: number): string[] {
+		const lines = this.#previewContent(bodyWidth);
+		const maxScroll = Math.max(0, lines.length - rows);
+		const start = Math.min(this.#previewScroll, maxScroll);
+		const window = lines.slice(start, start + rows);
+		if (lines.length > rows) {
+			const marker =
+				start + rows < lines.length
+					? theme.fg("dim", `  ↓ ${lines.length - rows - start} more`)
+					: theme.fg("dim", "  (end)");
+			window[rows - 1] = marker;
+		}
+		return window;
+	}
+
+	#previewContent(bodyWidth: number): string[] {
+		const list = this.#active;
+		const value = list instanceof SelectList ? (list.getSelectedItem()?.value ?? "") : "";
+		const match = /^advisor:(\d+)$/.exec(value);
+		if (match) {
+			const advisor = this.#doc.advisors[Number(match[1])];
+			if (advisor) return this.#advisorPreview(advisor, bodyWidth);
+		}
+		if (value === "shared") {
+			const lines = [theme.bold("Shared instructions"), ""];
+			const text = this.#doc.instructions?.trim();
+			lines.push(...(text ? wrap(text, bodyWidth) : [theme.fg("muted", "(none)")]));
+			return lines.map(line => truncateToWidth(line, bodyWidth));
+		}
+		const help =
+			value === "add"
+				? "Create a new advisor entry, then edit its model, tools, and instructions."
+				: value === "scope"
+					? `Switch between the project and user WATCHDOG.yml. Currently editing the ${this.#scope}-level file.`
+					: value === "save"
+						? "Write this scope's WATCHDOG.yml and reload the live advisors without a restart."
+						: value === "close"
+							? "Close the editor. Unsaved changes are discarded."
+							: "";
+		return wrap(help, bodyWidth).map(line => truncateToWidth(theme.fg("muted", line), bodyWidth));
+	}
+
+	#advisorPreview(advisor: AdvisorConfig, bodyWidth: number): string[] {
+		const model = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
+		const tools = advisor.tools?.length ? advisor.tools.join(", ") : "read, grep, glob (default)";
+		const lines = [
+			theme.bold(advisor.name || "(unnamed)"),
+			"",
+			`${theme.fg("dim", "Model:")} ${model}`,
+			`${theme.fg("dim", "Tools:")} ${tools}`,
+			"",
+			theme.fg("dim", "Instructions:"),
+		];
+		const instr = advisor.instructions?.trim();
+		lines.push(...(instr ? wrap(instr, bodyWidth) : [theme.fg("muted", "(none)")]));
+		return lines.map(line => truncateToWidth(line, bodyWidth));
+	}
+
+	// ───────────────────────────── screens ───────────────────────────
+
+	#setScreen(screen: Screen, active: Component, footerHint: string): void {
+		this.#screen = screen;
+		this.#active = active;
+		this.#footerHint = footerHint;
+		this.#previewScroll = 0;
+		this.#cb.requestRender();
+	}
+
+	#otherScope(): AdvisorConfigScope {
+		return this.#scope === "project" ? "user" : "project";
+	}
+
+	#ensureRosterVisible(): void {
+		if (this.#doc.advisors.length === 0) this.#doc.advisors.push({ name: "default" });
+	}
+
+	#isBareDefaultDoc(doc: WatchdogConfigDoc): boolean {
+		if (doc.advisors.length !== 1 || doc.instructions?.trim()) return false;
+		const advisor = doc.advisors[0];
+		if (!advisor) return false;
+		return (
+			advisor.name === "default" && !advisor.model?.trim() && !advisor.tools?.length && !advisor.instructions?.trim()
+		);
+	}
+
+	#advisorSummary(advisor: AdvisorConfig): string {
+		const model = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
+		const tools = advisor.tools?.length ? advisor.tools.join(", ") : "(default: read/grep/glob)";
+		return `${model} · ${tools}`;
+	}
+
+	#showList(): void {
+		this.#ensureRosterVisible();
+		const items: SelectItem[] = this.#doc.advisors.map((advisor, index) => ({
+			value: `advisor:${index}`,
+			label: advisor.name || "(unnamed)",
+			description: this.#advisorSummary(advisor),
+		}));
+		items.push({ value: "add", label: "+ Add advisor" });
+		items.push({ value: "shared", label: "Shared instructions", description: previewLine(this.#doc.instructions) });
+		items.push({ value: "scope", label: `Scope: ${this.#scope}`, description: `→ ${this.#otherScope()}` });
+		items.push({ value: "save", label: "Save & apply" });
+		items.push({ value: "close", label: "Close" });
+
+		// Show every row (no internal overflow-search); the split frame supplies height.
+		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
+		list.onSelectionChange = () => {
+			this.#previewScroll = 0;
+			this.#cb.requestRender();
+		};
+		list.onSelect = item =>
+			void this.#onListSelect(item.value).catch(err => {
+				this.#cb.notify(`Advisor config: ${err instanceof Error ? err.message : String(err)}`);
+			});
+		list.onCancel = () => this.#cb.close();
+		this.#setScreen("list", list, "↑↓ move · Enter / click select · scroll preview on the right · Esc close");
+	}
+
+	async #onListSelect(value: string): Promise<void> {
+		if (value === "add") {
+			this.#doc.advisors.push({ name: `Advisor ${this.#doc.advisors.length + 1}` });
+			this.#dirty = true;
+			this.#showDetail(this.#doc.advisors.length - 1);
+			return;
+		}
+		if (value === "shared") {
+			this.#showInstructionsEditor(-1);
+			return;
+		}
+		if (value === "scope") {
+			if (this.#dirty) {
+				this.#cb.notify('Unsaved changes — "Save & apply" or Close before switching scope.');
+				return;
+			}
+			const next = this.#otherScope();
+			this.#doc = await this.#cb.loadDoc(next);
+			this.#ensureRosterVisible();
+			this.#scope = next;
+			this.#showList();
+			return;
+		}
+		if (value === "save") {
+			await this.#cb.save(this.#scope, this.#isBareDefaultDoc(this.#doc) ? { advisors: [] } : this.#doc);
+			this.#dirty = false;
+			this.#showList();
+			return;
+		}
+		if (value === "close") {
+			this.#cb.close();
+			return;
+		}
+		const match = /^advisor:(\d+)$/.exec(value);
+		if (match) this.#showDetail(Number(match[1]));
+	}
+
+	#showDetail(index: number): void {
+		const advisor = this.#doc.advisors[index];
+		if (!advisor) {
+			this.#showList();
+			return;
+		}
+		const modelDescription = advisor.model?.trim() || this.#defaultModelLabel || "advisor role default";
+		const toolsDescription = advisor.tools?.length ? advisor.tools.join(", ") : "(default: read/grep/glob)";
+		const items: SelectItem[] = [
+			{ value: "name", label: "Name", description: advisor.name },
+			{ value: "model", label: "Model", description: modelDescription },
+		];
+		if (advisor.model?.trim()) {
+			items.push({ value: "resetModel", label: "Reset model to advisor-role default" });
+		}
+		items.push(
+			{ value: "tools", label: "Tools", description: toolsDescription },
+			{ value: "instructions", label: "Instructions", description: previewLine(advisor.instructions) },
+			{ value: "delete", label: "Delete this advisor" },
+			{ value: "back", label: "Back" },
+		);
+		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
+		list.onSelect = item => this.#onDetailSelect(index, item.value);
+		list.onCancel = () => this.#showList();
+		this.#setScreen("detail", list, `Editing "${advisor.name}" · Enter / click edit field · Esc back`);
+	}
+
+	#onDetailSelect(index: number, field: string): void {
+		switch (field) {
+			case "name":
+				this.#showNameEditor(index);
+				return;
+			case "model":
+				this.#showModelPicker(index);
+				return;
+			case "tools":
+				this.#showToolsEditor(
+					index,
+					new Set(this.#doc.advisors[index].tools ?? [...ADVISOR_DEFAULT_TOOL_NAMES]),
+					0,
+				);
+				return;
+			case "resetModel":
+				this.#doc.advisors[index].model = undefined;
+				this.#dirty = true;
+				this.#showDetail(index);
+				return;
+			case "instructions":
+				this.#showInstructionsEditor(index);
+				return;
+			case "delete":
+				this.#doc.advisors.splice(index, 1);
+				this.#dirty = true;
+				this.#showList();
+				return;
+			default:
+				this.#showList();
+		}
+	}
+
+	#showNameEditor(index: number): void {
+		const input = new Input();
+		input.setValue(this.#doc.advisors[index].name);
+		input.onSubmit = value => {
+			const name = value.trim();
+			if (name) {
+				this.#doc.advisors[index].name = name;
+				this.#dirty = true;
+			}
+			this.#showDetail(index);
+		};
+		input.onEscape = () => this.#showDetail(index);
+		this.#setScreen("name", input, "Type a name · Enter save · Esc cancel");
+	}
+
+	#showModelPicker(index: number): void {
+		const picker = new ModelSelectorComponent(
+			this.#tui,
+			undefined,
+			this.#settings,
+			this.#modelRegistry,
+			this.#scopedModels,
+			(model, _role, _thinking, selector) => {
+				const base = selector ?? `${model.provider}/${model.id}`;
+				const efforts = getSupportedEfforts(model);
+				if (efforts.length === 0) {
+					this.#doc.advisors[index].model = base;
+					this.#dirty = true;
+					this.#showDetail(index);
+				} else {
+					this.#showThinkingPicker(index, base, efforts);
+				}
+			},
+			() => this.#showDetail(index),
+			{ directSelect: true, pickerHint: "Pick this advisor's model · Enter / click select · Esc back" },
+		);
+		this.#setScreen("model", picker, "Type to search · Enter / click pick model · Esc back");
+	}
+
+	#showThinkingPicker(index: number, selector: string, efforts: readonly string[]): void {
+		const items: SelectItem[] = [{ value: "", label: "(model default thinking)" }];
+		for (const effort of efforts) items.push({ value: effort, label: effort });
+		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
+		list.onSelect = item => {
+			// `item.value` is one of the model's own supported efforts (or "" for the
+			// model default); `formatModelSelectorValue` spells the `:level` suffix.
+			const level = item.value ? (item.value as ThinkingLevel) : undefined;
+			this.#doc.advisors[index].model = formatModelSelectorValue(selector, level);
+			this.#dirty = true;
+			this.#showDetail(index);
+		};
+		list.onCancel = () => this.#showModelPicker(index);
+		this.#setScreen("thinking", list, `Thinking effort for ${selector} · Enter / click pick · Esc back`);
+	}
+
+	#showToolsEditor(index: number, selected: Set<string>, cursor: number): void {
+		const all = this.#availableToolNames;
+		const items: SelectItem[] = all.map(name => ({
+			value: name,
+			label: `${selected.has(name) ? "[x]" : "[ ]"} ${name}`,
+		}));
+		items.push({ value: "__done", label: "Done" });
+		const list = new SelectList(items, Math.max(1, items.length), getSelectListTheme());
+		list.setSelectedIndex(cursor);
+		let cursorIndex = cursor;
+		list.onSelectionChange = item => {
+			cursorIndex = items.findIndex(i => i.value === item.value);
+		};
+		list.onSelect = item => {
+			if (item.value === "__done") {
+				this.#doc.advisors[index].tools = commitTools(selected, all);
+				this.#dirty = true;
+				this.#showDetail(index);
+				return;
+			}
+			if (selected.has(item.value)) selected.delete(item.value);
+			else selected.add(item.value);
+			this.#showToolsEditor(index, selected, cursorIndex);
+		};
+		list.onCancel = () => {
+			this.#doc.advisors[index].tools = commitTools(selected, all);
+			this.#dirty = true;
+			this.#showDetail(index);
+		};
+		this.#setScreen(
+			"tools",
+			list,
+			"Enter / click toggle · select Done or Esc to apply (empty or read/grep/glob = default)",
+		);
+	}
+
+	/** `index === -1` edits the shared top-level instructions; otherwise advisor[index]. */
+	#showInstructionsEditor(index: number): void {
+		const shared = index < 0;
+		const current = shared ? this.#doc.instructions : this.#doc.advisors[index].instructions;
+		const title = shared ? "Shared advisor instructions" : `Instructions — ${this.#doc.advisors[index].name}`;
+		const editor = new HookEditorComponent(
+			this.#tui,
+			title,
+			current,
+			value => {
+				const text = value.trim() ? value : undefined;
+				if (shared) this.#doc.instructions = text;
+				else this.#doc.advisors[index].instructions = text;
+				this.#dirty = true;
+				if (shared) this.#showList();
+				else this.#showDetail(index);
+			},
+			() => {
+				if (shared) this.#showList();
+				else this.#showDetail(index);
+			},
+		);
+		this.#setScreen("instructions", editor, "");
+	}
+}

package/src/modes/components/advisor-message.ts

@@ -66,10 +66,17 @@ export function createAdvisorMessageCard(
 				const badge = entry.severity
 					? `${formatBadge(entry.severity, severityColor(entry.severity), uiTheme)} `
 					: "";
+				// Multi-advisor: attribute the note to its source. The implicit
+				// single ("default") advisor renders unlabeled, as before.
+				const who =
+					entry.advisor && entry.advisor !== "default"
+						? `${uiTheme.fg("dim", `[${replaceTabs(entry.advisor)}]`)} `
+						: "";
 				const quotePrefix = `  ${quote} `;
 				const quoteWidth = visibleWidth(quotePrefix);
 				const badgeWidth = visibleWidth(badge);
-				const w1 = Math.max(10, Math.min(NOTE_LINE_WIDTH, width) - quoteWidth - badgeWidth);
+				const whoWidth = visibleWidth(who);
+				const w1 = Math.max(10, Math.min(NOTE_LINE_WIDTH, width) - quoteWidth - badgeWidth - whoWidth);
 				const w2 = Math.max(10, Math.min(NOTE_LINE_WIDTH, width) - quoteWidth);
 
 				const paragraphs = entry.note.split("\n").filter(p => p.trim());
@@ -84,7 +91,7 @@ export function createAdvisorMessageCard(
 				}
 
 				bodyLines.forEach((line, index) => {
-					const prefix = index === 0 ? badge : "";
+					const prefix = index === 0 ? `${badge}${who}` : "";
 					lines.push(`  ${quote} ${prefix}${uiTheme.fg("toolOutput", replaceTabs(line))}`);
 				});
 			}

package/src/modes/components/agent-hub.ts

@@ -18,7 +18,7 @@ import * as path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Container, Ellipsis, matchesKey, type OverlayHandle, type TUI } from "@oh-my-pi/pi-tui";
 import { formatAge, getProjectDir, logger } from "@oh-my-pi/pi-utils";
-import { ADVISOR_TRANSCRIPT_FILENAME } from "../../advisor";
+import { ADVISOR_TRANSCRIPT_FILENAME, isAdvisorTranscriptName } from "../../advisor";
 import type { KeyId } from "../../config/keybindings";
 import type { MessageRenderer } from "../../extensibility/extensions/types";
 import { IrcBus } from "../../irc/bus";
@@ -87,9 +87,14 @@ function registerPersistedSubagentsFromDir(registry: AgentRegistry, dir: string,
 		// The advisor transcript is observability-only: register it as a non-peer
 		// `advisor` kind under its owning session so the Hub can show its read-only
 		// transcript, but it never joins agent-facing rosters and is not revivable.
-		if (entry.name === ADVISOR_TRANSCRIPT_FILENAME) {
+		if (isAdvisorTranscriptName(entry.name)) {
 			const owner = parentId ?? MAIN_AGENT_ID;
-			const advisorId = `${owner}/advisor`;
+			// `__advisor.jsonl` → the default advisor (no slug); `__advisor.<slug>.jsonl`
+			// → a named advisor, keyed and labeled by its slug.
+			const slug =
+				entry.name === ADVISOR_TRANSCRIPT_FILENAME ? "" : entry.name.slice("__advisor.".length, -".jsonl".length);
+			const advisorId = slug ? `${owner}/advisor:${slug}` : `${owner}/advisor`;
+			const displayName = slug ? `advisor:${slug}` : "advisor";
 			const existing = registry.get(advisorId);
 			// Never clobber a non-advisor ref that happens to share this id (a freak
 			// user task literally named `<owner>/advisor`): leave it, skip the advisor.
@@ -99,7 +104,7 @@ function registerPersistedSubagentsFromDir(registry: AgentRegistry, dir: string,
 				if (existing) registry.unregister(advisorId);
 				registry.register({
 					id: advisorId,
-					displayName: "advisor",
+					displayName,
 					kind: "advisor",
 					parentId: owner,
 					session: null,

package/src/modes/components/assistant-message.ts

@@ -581,11 +581,11 @@ export class AssistantMessageComponent extends Container {
 			if (content.type === "toolCall") return false;
 		}
 		if (this.#toolImagesByCallId.size > 0) return false;
-		if (message.stopReason === "aborted" && shouldRenderAbortReason(message.errorMessage)) return false;
+		if (message.stopReason === "aborted" && shouldRenderAbortReason(message)) return false;
 		if (message.stopReason === "error" && !this.#errorPinned) return false;
 		if (
 			message.errorMessage &&
-			shouldRenderAbortReason(message.errorMessage) &&
+			shouldRenderAbortReason(message) &&
 			message.stopReason !== "aborted" &&
 			message.stopReason !== "error"
 		)
@@ -779,8 +779,8 @@ export class AssistantMessageComponent extends Container {
 		// But only if there are no tool calls (tool execution components will show the error)
 		const hasToolCalls = message.content.some(c => c.type === "toolCall");
 		if (!hasToolCalls) {
-			if (message.stopReason === "aborted" && shouldRenderAbortReason(message.errorMessage)) {
-				const abortMessage = resolveAbortLabel(message.errorMessage);
+			if (message.stopReason === "aborted" && shouldRenderAbortReason(message)) {
+				const abortMessage = resolveAbortLabel(message);
 				if (hasVisibleContent) {
 					this.#contentContainer.addChild(new Spacer(1));
 				} else {
@@ -793,7 +793,7 @@ export class AssistantMessageComponent extends Container {
 		}
 		if (
 			message.errorMessage &&
-			shouldRenderAbortReason(message.errorMessage) &&
+			shouldRenderAbortReason(message) &&
 			message.stopReason !== "aborted" &&
 			message.stopReason !== "error"
 		) {

package/src/modes/components/index.ts

@@ -1,4 +1,6 @@
 // UI Components barrel export
+
+export * from "./advisor-config";
 export * from "./assistant-message";
 export * from "./bash-execution";
 export * from "./bordered-loader";