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

package/dist/types/task/renderer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Task tool renderer export.
+ *
+ * Separated from render.ts to avoid circular dependency issues with
+ * tools/renderers.ts. This module has no side effects and can be safely
+ * imported without triggering the subprocessToolRegistry registration.
+ */
+import { renderCall, renderResult } from "./render";
+export declare const taskToolRenderer: {
+    readonly renderCall: typeof renderCall;
+    readonly renderResult: typeof renderResult;
+    readonly mergeCallAndResult: true;
+};

package/dist/types/task/types.d.ts

@@ -206,6 +206,22 @@ export interface AgentDefinition {
     source: AgentSource;
     filePath?: string;
 }
+/** Details extracted from a subagent `yield` tool call for final-result assembly and task rendering. */
+export interface YieldItem {
+    data?: unknown;
+    status?: "success" | "aborted";
+    error?: string;
+    /** A string label is terminal; a non-empty array of labels is incremental. */
+    type?: string | string[];
+    /** Resolve this yield's payload from the latest durable assistant text instead of `data`. */
+    useLastTurn?: boolean;
+    /**
+     * Set by the in-tool yield validator when it exhausted its retry budget and
+     * accepted schema-invalid data anyway. The executor preserves that override
+     * during post-mortem validation.
+     */
+    schemaOverridden?: boolean;
+}
 /** Progress tracking for a single agent */
 export interface AgentProgress {
     index: number;

package/dist/types/task/yield-assembly.d.ts

@@ -0,0 +1,28 @@
+import type { YieldItem } from "./types";
+/** Outcome of folding a run's yield calls into one payload, with provenance flags. */
+interface AssembledYieldResult {
+    data: unknown;
+    schemaOverridden: boolean;
+    rawText: boolean;
+    missingData: boolean;
+}
+/**
+ * Top-level output-schema property names declared as arrays (JTD `elements` →
+ * JSON `type: "array"`). An incremental yield section for such a label
+ * accumulates into a list even when the agent emits exactly one — otherwise a
+ * single `type: ["findings"]` yield would assemble as a bare object and fail
+ * array-typed schema validation.
+ */
+export declare function arrayValuedLabels(outputSchema: unknown): ReadonlySet<string>;
+/**
+ * Assemble typed yield calls into the final payload consumed by schema validation.
+ *
+ * A non-empty array `type` contributes an incremental section and never decides
+ * termination by itself. A string `type` with omitted `data` makes the last
+ * assistant turn the raw terminal result. Other string-typed yields contribute
+ * the terminal labelled section. Untyped terminal yields keep the historical
+ * "last yield wins" behavior unless no terminal yield exists, in which case
+ * accumulated typed sections finalize on idle.
+ */
+export declare function assembleYieldResult(yieldItems: YieldItem[], lastAssistantText?: string, arrayLabels?: ReadonlySet<string>): AssembledYieldResult | undefined;
+export {};

package/dist/types/tiny/text.d.ts

@@ -16,6 +16,14 @@ export declare function stripCodeBlocks(message: string): string;
 /** Prepare a raw user message for titling: drop code blocks, then bound length. */
 export declare function prepareTitleInput(message: string): string;
 export declare function formatTitleUserMessage(message: string): string;
+/** Single recent conversation turn supplied to title refresh after replanning. */
+export interface TitleConversationTurn {
+    role: "user" | "assistant";
+    text?: string;
+    thinking?: string;
+}
+/** Format recent user/assistant context for title generation after a todo replan. */
+export declare function formatTitleConversationContext(turns: readonly TitleConversationTurn[]): string;
 /**
  * True when a first user message is too low-signal to title (greeting, ack,
  * bare number, or empty once code/punctuation/emoji are stripped).

package/dist/types/tools/render-utils.d.ts

@@ -45,6 +45,8 @@ export declare const TRUNCATE_LENGTHS: {
     readonly LINE: 110;
     /** Very short (task previews, badges) */
     readonly SHORT: 40;
+    /** Idle recap status line (~40-word LLM reply) */
+    readonly RECAP: 280;
 };
 /** Human-readable key currently bound to tool-output expansion, e.g. `Ctrl+O`. */
 export declare function expandKeyHint(): string;

package/dist/types/tools/review.d.ts

@@ -1,9 +1,10 @@
 /**
- * Review tools - report_finding for structured code review.
+ * Legacy hidden review-finding tool for agents that have not migrated to
+ * incremental `yield` sections.
  *
- * Used by the reviewer agent to report findings in a structured way.
- * Hidden by default - only enabled when explicitly listed in agent's tools.
- * Reviewers finish via `yield` tool with SubmitReviewDetails schema.
+ * Hidden by default - only enabled when explicitly listed in an agent's tools.
+ * Reviewers now finish via incremental `yield`; this tool remains for
+ * compatibility with older or custom review agents.
  */
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Theme, ThemeColor } from "../modes/theme/theme";
@@ -15,6 +16,7 @@ export interface FindingPriorityInfo {
     color: ThemeColor;
 }
 export declare const PRIORITY_LABELS: FindingPriority[];
+export declare function isFindingPriority(value: unknown): value is FindingPriority;
 export declare function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo;
 declare const ReportFindingParams: import("arktype/internal/variants/object.ts").ObjectType<{
     title: string;

package/dist/types/tools/ssh.d.ts

@@ -67,7 +67,7 @@ export declare const sshToolRenderer: {
         renderContext?: SshRenderContext;
     }, uiTheme: Theme, args?: SshRenderArgs): Component;
     mergeCallAndResult: boolean;
-    provisionalPendingPreview: string;
+    provisionalPendingPreview: boolean;
     provisionalPartialResult: boolean;
 };
 export {};

package/dist/types/tools/todo.d.ts

@@ -6,6 +6,8 @@ import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
 import type { SessionEntry } from "../session/session-entries";
 export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
+/** Operation names accepted by the todo tool and echoed in successful result details. */
+export type TodoOperation = "init" | "start" | "done" | "rm" | "drop" | "append" | "view";
 export interface TodoItem {
     content: string;
     status: TodoStatus;
@@ -19,6 +21,8 @@ export interface TodoCompletionTransition {
     content: string;
 }
 export interface TodoToolDetails {
+    /** Operation that produced this snapshot; absent on legacy transcript entries. */
+    op?: TodoOperation;
     phases: TodoPhase[];
     storage: "session" | "memory";
     completedTasks?: TodoCompletionTransition[];
@@ -35,6 +39,8 @@ declare const todoSchema: import("arktype/internal/variants/object.ts").ObjectTy
 }, {}>;
 type TodoParams = TodoSchema;
 type TodoSchema = typeof todoSchema.infer;
+/** Return the active todo task, preferring an in-progress item over the first pending item. */
+export declare function nextActionableTask(phases: readonly TodoPhase[]): TodoItem | undefined;
 export declare const USER_TODO_EDIT_CUSTOM_TYPE = "user_todo_edit";
 export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]): TodoPhase[];
 /**

package/dist/types/tools/yield.d.ts

@@ -1,15 +1,20 @@
 /**
- * Submit result tool for structured subagent output.
+ * Result submission tool for subagent output.
  *
- * Subagents must call this tool to finish and return structured JSON output.
+ * Subagents can call this tool incrementally or terminally depending on `type`.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { TSchema } from "@oh-my-pi/pi-ai/types";
 import type { ToolSession } from ".";
 export interface YieldDetails {
-    data: unknown;
+    /** Successful result payload, or omitted when `useLastTurn` requests last-turn extraction. */
+    data?: unknown;
     status: "success" | "aborted";
     error?: string;
+    /** Optional result section/classification supplied by the yield caller. */
+    type?: string | string[];
+    /** True when the caller intentionally omitted success data so the executor uses the last assistant turn. */
+    useLastTurn?: boolean;
     /**
      * Set when the yield tool exhausted its in-tool schema-retry budget
      * (MAX_SCHEMA_RETRIES) and accepted the data anyway. Surfaced so the

package/dist/types/utils/thinking-display.d.ts

@@ -1,3 +1,7 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 export declare function canonicalizeMessage(text: string | null | undefined): string;
 export declare function formatThinkingForDisplay(text: string, proseOnly: boolean): string;
+/** Whether a formatted thinking block has non-placeholder content worth rendering. */
 export declare function hasDisplayableThinking(text: string | null | undefined, formattedText: string | null | undefined): boolean;
+/** Whether an assistant message contains thinking content the TUI can reveal. */
+export declare function messageHasDisplayableThinking(message: AgentMessage, proseOnly: boolean): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.2.2",
+	"version": "16.2.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -55,17 +55,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.2.2",
-		"@oh-my-pi/omp-stats": "16.2.2",
-		"@oh-my-pi/pi-agent-core": "16.2.2",
-		"@oh-my-pi/pi-ai": "16.2.2",
-		"@oh-my-pi/pi-catalog": "16.2.2",
-		"@oh-my-pi/pi-mnemopi": "16.2.2",
-		"@oh-my-pi/pi-natives": "16.2.2",
-		"@oh-my-pi/pi-tui": "16.2.2",
-		"@oh-my-pi/pi-utils": "16.2.2",
-		"@oh-my-pi/pi-wire": "16.2.2",
-		"@oh-my-pi/snapcompact": "16.2.2",
+		"@oh-my-pi/hashline": "16.2.3",
+		"@oh-my-pi/omp-stats": "16.2.3",
+		"@oh-my-pi/pi-agent-core": "16.2.3",
+		"@oh-my-pi/pi-ai": "16.2.3",
+		"@oh-my-pi/pi-catalog": "16.2.3",
+		"@oh-my-pi/pi-mnemopi": "16.2.3",
+		"@oh-my-pi/pi-natives": "16.2.3",
+		"@oh-my-pi/pi-tui": "16.2.3",
+		"@oh-my-pi/pi-utils": "16.2.3",
+		"@oh-my-pi/pi-wire": "16.2.3",
+		"@oh-my-pi/snapcompact": "16.2.3",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/advisor/__tests__/advisor.test.ts

@@ -1,25 +1,33 @@
 import { describe, expect, it, vi } from "bun:test";
 import type { AgentMessage, AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core";
+import type { TUI } from "@oh-my-pi/pi-tui";
 import { type } from "arktype";
+import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
+import { type AdvisorConfigDeps, AdvisorConfigOverlayComponent } from "../../modes/components/advisor-config";
 import { createAdvisorMessageCard } from "../../modes/components/advisor-message";
-import { getThemeByName } from "../../modes/theme/theme";
+import { getThemeByName, setThemeInstance } from "../../modes/theme/theme";
 import advisorSystemPrompt from "../../prompts/advisor/system.md" with { type: "text" };
 import { SecretObfuscator } from "../../secrets/obfuscator";
 import { formatSessionHistoryMarkdown } from "../../session/session-history-format";
 import { YieldQueue } from "../../session/yield-queue";
+import { BUILTIN_TOOL_NAMES } from "../../tools/builtin-names";
 import {
-	ADVISOR_READONLY_TOOL_NAMES,
+	ADVISOR_DEFAULT_TOOL_NAMES,
 	AdviseTool,
 	type AdvisorAgent,
 	type AdvisorNote,
 	AdvisorRuntime,
 	type AdvisorRuntimeHost,
+	advisorTranscriptFilename,
 	deriveAdvisorTelemetry,
 	formatAdvisorBatchContent,
 	formatAdvisorContextPrompt,
 	isAdvisorInterruptImmuneTurnActive,
+	isAdvisorTranscriptName,
 	isInterruptingSeverity,
 	resolveAdvisorDeliveryChannel,
+	type WatchdogConfigDoc,
 } from "..";
 
 describe("advisor", () => {
@@ -158,6 +166,57 @@ describe("advisor", () => {
 		});
 	});
 
+	describe("formatSessionHistoryMarkdown expandEditDiffs", () => {
+		const diff = "--- a/foo.ts\n+++ b/foo.ts\n@@ -1,2 +1,2 @@\n-const x = 1;\n+const x = 2;";
+		const editCall = {
+			role: "assistant",
+			content: [{ type: "toolCall", id: "c1", name: "edit", arguments: { path: "foo.ts" } }],
+			timestamp: 1,
+		} as unknown as AgentMessage;
+		const editResult = {
+			role: "toolResult",
+			toolCallId: "c1",
+			toolName: "edit",
+			content: "ok",
+			details: { diff },
+			timestamp: 2,
+		} as unknown as AgentMessage;
+
+		it("appends the full diff in a fenced block when expandEditDiffs is set", () => {
+			const md = formatSessionHistoryMarkdown([editCall, editResult], {
+				expandEditDiffs: true,
+				watchedRoles: true,
+			});
+			expect(md).toContain("```diff");
+			expect(md).toContain("-const x = 1;");
+			expect(md).toContain("+const x = 2;");
+		});
+
+		it("omits the diff body without the flag", () => {
+			const md = formatSessionHistoryMarkdown([editCall, editResult], { watchedRoles: true });
+			expect(md).not.toContain("```diff");
+			expect(md).not.toContain("+const x = 2;");
+		});
+
+		it("widens the fence past backtick runs in the diff body", () => {
+			const fenced = "--- a/readme.md\n+++ b/readme.md\n@@ -1 +1 @@\n-```\n+```ts\n+code\n+```";
+			const result = {
+				role: "toolResult",
+				toolCallId: "c1",
+				toolName: "edit",
+				content: "ok",
+				details: { diff: fenced },
+				timestamp: 2,
+			} as unknown as AgentMessage;
+			const md = formatSessionHistoryMarkdown([editCall, result], {
+				expandEditDiffs: true,
+				watchedRoles: true,
+			});
+			// The body contains a ``` run, so the wrapping fence widens to 4 backticks.
+			expect(md).toContain("````diff");
+		});
+	});
+
 	describe("advisor yield-queue dispatcher", () => {
 		it("batches advice notes into one custom message", async () => {
 			const injected: AgentMessage[] = [];
@@ -373,6 +432,18 @@ describe("advisor", () => {
 			// Exactly one severity attribute (only the blocker note carries one).
 			expect(content.split('severity="').length - 1).toBe(1);
 		});
+
+		it("emits an advisor attribute only for named advisors, escaping the name", () => {
+			const content = formatAdvisorBatchContent([
+				{ note: "named note", advisor: 'Arch "X"' },
+				{ note: "default note" },
+			]);
+			// Named advisor: attribute present, double quote escaped for attribute context.
+			expect(content).toContain('advisor="Arch "X""');
+			// A note with no source (the legacy/default advisor) carries no advisor attribute.
+			expect(content.split('advisor="').length - 1).toBe(1);
+			expect(content).toContain("default note");
+		});
 	});
 
 	describe("deriveAdvisorTelemetry", () => {
@@ -662,6 +733,46 @@ describe("advisor", () => {
 			expect(promptInputs[0]).not.toContain(secret);
 		});
 
+		it("surfaces edit diff details but redacts secrets inside the diff", async () => {
+			const secret = "DIFF_SECRET_TOKEN_123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const diff = `--- a/config.ts\n+++ b/config.ts\n@@ -1 +1 @@\n-const token = "old";\n+const token = "${secret}";`;
+			const messages: AgentMessage[] = [
+				{
+					role: "assistant",
+					content: [{ type: "toolCall", id: "c1", name: "edit", arguments: { path: "config.ts" } }],
+					timestamp: 1,
+				} as unknown as AgentMessage,
+				{
+					role: "toolResult",
+					toolCallId: "c1",
+					toolName: "edit",
+					content: "ok",
+					details: { diff },
+					timestamp: 2,
+				} as unknown as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			// The diff is surfaced to the advisor (expandEditDiffs) ...
+			expect(promptInputs[0]).toContain("+const token =");
+			// ... but a secret living inside details.diff is obfuscated (details now walked).
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+		});
+
 		it("expands plan-mode context once, then collapses an unchanged re-injection", async () => {
 			const promptInputs: string[] = [];
 			const agent = makeAgent(promptInputs);
@@ -1259,14 +1370,18 @@ describe("advisor", () => {
 		});
 	});
 
-	describe("read-only tool allowlist", () => {
-		it("selects only the investigation tools from a mixed toolset", () => {
-			const toolset = ["read", "edit", "grep", "bash", "glob", "write", "advise"];
-			const selected = toolset.filter(name => ADVISOR_READONLY_TOOL_NAMES.has(name));
-			expect(selected).toEqual(["read", "grep", "glob"]);
-			expect(ADVISOR_READONLY_TOOL_NAMES.has("edit")).toBe(false);
-			expect(ADVISOR_READONLY_TOOL_NAMES.has("bash")).toBe(false);
-			expect(ADVISOR_READONLY_TOOL_NAMES.has("write")).toBe(false);
+	describe("advisor default tools", () => {
+		it("defaults to read/grep/glob, a subset of the full grantable tool pool", () => {
+			expect([...ADVISOR_DEFAULT_TOOL_NAMES]).toEqual(["read", "grep", "glob"]);
+			// The advisor is a full agent now: every built tool is grantable (no hard
+			// read-only restriction), including mutating ones like edit/bash/write.
+			const builtin = new Set<string>(BUILTIN_TOOL_NAMES);
+			for (const name of ["read", "grep", "glob", "edit", "bash", "write"]) {
+				expect(builtin.has(name)).toBe(true);
+			}
+			for (const name of ADVISOR_DEFAULT_TOOL_NAMES) {
+				expect(builtin.has(name)).toBe(true);
+			}
 		});
 	});
 
@@ -1289,6 +1404,26 @@ describe("advisor", () => {
 			expect(text).toContain("watch the empty case");
 		});
 
+		it("prefixes the note with a named-advisor label, but not for the default advisor", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			const card = createAdvisorMessageCard(
+				{
+					notes: [
+						{ note: "module boundary leak", severity: "concern", advisor: "Architecture" },
+						{ note: "default-advisor note", advisor: "default" },
+					],
+				},
+				() => true,
+				uiTheme,
+			);
+			const text = strip(card.render(80));
+			expect(text).toContain("[Architecture]");
+			expect(text).toContain("module boundary leak");
+			// The implicit "default" advisor stays unlabeled.
+			expect(text).not.toContain("[default]");
+		});
+
 		it("collapses to the first notes with an overflow hint", async () => {
 			const uiTheme = await getThemeByName("dark");
 			if (!uiTheme) throw new Error("theme unavailable");
@@ -1427,4 +1562,101 @@ describe("advisor", () => {
 			}
 		});
 	});
+	describe("advisor transcript filenames", () => {
+		it("derives default and named transcript filenames", () => {
+			expect(advisorTranscriptFilename("")).toBe("__advisor.jsonl");
+			expect(advisorTranscriptFilename("arch")).toBe("__advisor.arch.jsonl");
+		});
+
+		it("recognizes default and named advisor transcripts, and nothing else", () => {
+			expect(isAdvisorTranscriptName("__advisor.jsonl")).toBe(true);
+			expect(isAdvisorTranscriptName("__advisor.arch.jsonl")).toBe(true);
+			expect(isAdvisorTranscriptName("__advisor-2.jsonl")).toBe(false);
+			expect(isAdvisorTranscriptName("Foo.jsonl")).toBe(false);
+			expect(isAdvisorTranscriptName("__advisor.arch.bak")).toBe(false);
+		});
+	});
+
+	describe("AdvisorConfigOverlayComponent", () => {
+		const deps = {
+			modelRegistry: { getCanonicalModelSelections: () => [] } as unknown as ModelRegistry,
+			settings: {} as unknown as Settings,
+			scopedModels: [],
+			availableToolNames: ["read", "grep", "glob", "lsp", "web_search"],
+		};
+		const callbacks = {
+			loadDoc: async () => ({ advisors: [] }),
+			save: async () => {},
+			close: () => {},
+			requestRender: () => {},
+			notify: () => {},
+		};
+		const strip = (lines: readonly string[]): string => lines.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+		const make = (doc: WatchdogConfigDoc, extra?: Partial<AdvisorConfigDeps>): AdvisorConfigOverlayComponent =>
+			new AdvisorConfigOverlayComponent({} as unknown as TUI, { ...deps, ...extra }, "project", doc, callbacks);
+		const fullHeight = Math.max(14, process.stdout.rows || 40);
+
+		it("paints a full-screen split frame: roster sidebar + selected-advisor preview", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			setThemeInstance(uiTheme);
+			const overlay = make({
+				instructions: "shared baseline",
+				advisors: [
+					{ name: "Architecture", model: "x-ai/grok-code-fast:high" },
+					{ name: "Security", tools: ["read", "web_search"] },
+				],
+			});
+			const frame = overlay.render(200);
+			// Fills the screen top-to-bottom (the fix for the bottom-anchored frame
+			// whose offset broke mouse hit-testing and wasted the upper space).
+			expect(frame.length).toBe(fullHeight);
+			const text = strip(frame);
+			expect(text).toContain("Advisor configuration");
+			expect(text).toContain("project");
+			expect(text).toContain("Architecture");
+			expect(text).toContain("Security");
+			expect(text).toContain("+ Add advisor");
+			expect(text).toContain("Save & apply");
+			// Right preview reflects the highlighted (first) advisor.
+			expect(text).toContain("x-ai/grok-code-fast:high");
+			expect(text).toContain("read, grep, glob (default)");
+		});
+
+		it("moves the preview with keyboard selection and preserves an explicit tool set", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			setThemeInstance(uiTheme);
+			const overlay = make({
+				advisors: [{ name: "Architecture" }, { name: "Security", tools: ["read", "web_search"] }],
+			});
+			overlay.render(200);
+			overlay.handleInput("\x1b[B"); // arrow down → highlight Security
+			expect(strip(overlay.render(200))).toContain("read, web_search");
+		});
+
+		it("opens an advisor's detail editor on a left click in the sidebar", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			setThemeInstance(uiTheme);
+			const overlay = make({ advisors: [{ name: "Architecture" }, { name: "Security" }] });
+			// Render once so the frame geometry is recorded; the first advisor sits on
+			// the first body row (0-based screen row 1 → SGR 1-based row 2).
+			overlay.render(120);
+			overlay.handleInput("\x1b[<0;4;2M"); // left-button press, col 4, row 2
+			const text = strip(overlay.render(120));
+			expect(text).toContain("Editing");
+			expect(text).toContain("Architecture");
+		});
+
+		it("seeds a visible default advisor (labeled with the role model) when the config is empty", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			setThemeInstance(uiTheme);
+			const overlay = make({ advisors: [] }, { defaultModelLabel: "anthropic/claude-opus" });
+			const text = strip(overlay.render(200));
+			expect(text).toContain("default");
+			expect(text).toContain("anthropic/claude-opus");
+		});
+	});
 });