@selesai/code 0.10.1 → 0.10.2

package/dist/extensions/web-agent-onboarding.ts

@@ -1,222 +1,222 @@
-/**
- * Web-Agent first-run onboarding extension.
- *
- * On the first interactive session, ask the user whether they want to use Brave
- * Search. If yes, open the Brave API key dashboard, collect the pasted key, and
- * persist it in ~/.selesai/agent/settings.json under webAgent.braveApiKey, then
- * configure the bundled pi-web-agent backend to use Brave (with DuckDuckGo fallback).
- * If no, the extension falls back to pi-web-agent's default DuckDuckGo backend.
- *
- * Mirrors src/extensions/tokenin-onboarding.ts.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getAgentDir, getSettingsPath } from "@selesai/code";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionStartEvent } from "@selesai/code";
-
-export type OnboardingResult =
-	| { kind: "saved" }
-	| { kind: "skipped" }
-	| { kind: "deferred" }
-	| { kind: "error"; message: string };
-
-export const BRAVE_KEYS_URL = "https://api-dashboard.search.brave.com/app/keys";
-export const ONBOARDING_MARKER_NAME = ".webAgentOnboardingComplete";
-export const WEB_AGENT_CONFIG_SUBPATH = join("extensions", "pi-web-agent", "config.json");
-
-// ponytail: duplicated ~15 lines of marker-file + browser-open logic from
-// tokenin-onboarding.ts rather than extracting a shared module nobody asked for.
-// Ceiling: if a third onboarding extension appears, extract a shared helper then.
-
-/** Read and parse the current settings.json, returning a deep-ish mutable object. */
-export function readSettingsJson(settingsPath: string = getSettingsPath()): Record<string, unknown> {
-	try {
-		const raw = readFileSync(settingsPath, "utf-8");
-		return JSON.parse(raw) as Record<string, unknown>;
-	} catch {
-		return {};
-	}
-}
-
-/** Write settings.json back to disk atomically-ish with a trailing newline. */
-export function writeSettingsJson(settings: Record<string, unknown>, settingsPath: string = getSettingsPath()): void {
-	mkdirSync(dirname(settingsPath), { recursive: true });
-	writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
-}
-
-/**
- * Return true if the Brave key value is missing, empty. We prompt again for any
- * non-key value.
- */
-export function isPlaceholderKey(apiKey: unknown): boolean {
-	if (apiKey === undefined || apiKey === null) return true;
-	if (typeof apiKey !== "string") return true;
-	return apiKey.trim() === "";
-}
-
-/** Return the current webAgent.braveApiKey value from settings.json. */
-export function getBraveApiKey(settings: Record<string, unknown>): unknown {
-	const webAgent = settings.webAgent;
-	if (!webAgent || typeof webAgent !== "object" || Array.isArray(webAgent)) return undefined;
-	return (webAgent as Record<string, unknown>).braveApiKey;
-}
-
-/** Return a new settings object with webAgent.braveApiKey set to key. */
-export function setBraveApiKey(settings: Record<string, unknown>, key: string): Record<string, unknown> {
-	const next = JSON.parse(JSON.stringify(settings)) as Record<string, unknown>;
-	if (!next.webAgent || typeof next.webAgent !== "object" || Array.isArray(next.webAgent)) {
-		next.webAgent = {};
-	}
-	const webAgent = next.webAgent as Record<string, unknown>;
-	webAgent.braveApiKey = key;
-	return next;
-}
-
-/** Validate a pasted Brave key. Returns normalized key or an error message. */
-export function validateBraveKey(raw: string | undefined): { key?: string; error?: string } {
-	if (raw === undefined || raw === null) return { error: "No key entered." };
-	const trimmed = raw.trim();
-	if (trimmed === "") return { error: "Key cannot be empty." };
-	return { key: trimmed };
-}
-
-/** Path to the pi-web-agent global backend config (matches vendored config-store). */
-export function getWebAgentConfigPath(agentDir: string = getAgentDir()): string {
-	return join(agentDir, WEB_AGENT_CONFIG_SUBPATH);
-}
-
-/** Write pi-web-agent backend config selecting brave (with duckduckgo fallback). */
-export function writeWebAgentBraveBackendConfig(agentDir: string = getAgentDir()): void {
-	const configPath = getWebAgentConfigPath(agentDir);
-	mkdirSync(dirname(configPath), { recursive: true });
-	// Merge into any existing config so we don't clobber presentation settings.
-	let existing: Record<string, unknown> = {};
-	try {
-		existing = JSON.parse(readFileSync(configPath, "utf-8")) as Record<string, unknown>;
-	} catch {
-		// ENOENT or invalid JSON — start fresh.
-	}
-	const next = existing;
-	const backends = (next.backends ?? {}) as Record<string, unknown>;
-	(backends as Record<string, unknown>).search = { provider: "brave", fallback: "duckduckgo" };
-	next.backends = backends;
-	writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`, "utf-8");
-}
-
-function getOnboardingMarkerPath(agentDir: string = getAgentDir()): string {
-	return join(agentDir, ONBOARDING_MARKER_NAME);
-}
-
-function markOnboardingComplete(agentDir: string = getAgentDir()): void {
-	writeFileSync(getOnboardingMarkerPath(agentDir), "1", "utf-8");
-}
-
-function isOnboardingComplete(agentDir: string = getAgentDir()): boolean {
-	return existsSync(getOnboardingMarkerPath(agentDir));
-}
-
-async function openBraveKeysUrl(pi: ExtensionAPI): Promise<void> {
-	const url = BRAVE_KEYS_URL;
-	let command: string;
-	let args: string[];
-	if (process.platform === "darwin") {
-		command = "open";
-		args = [url];
-	} else if (process.platform === "win32") {
-		command = "cmd";
-		args = ["/c", "start", "", url];
-	} else {
-		command = "xdg-open";
-		args = [url];
-	}
-	const result = await pi.exec(command, args, { timeout: 10_000 });
-	if (result.code !== 0) {
-		throw new Error(`Failed to open ${url}: ${result.stderr || result.stdout || "unknown error"}`);
-	}
-}
-
-async function promptForKey(ctx: ExtensionContext): Promise<string | undefined> {
-	return ctx.ui.input("Paste your Brave API key", "");
-}
-
-async function runOnboarding(pi: ExtensionAPI, ctx: ExtensionContext): Promise<OnboardingResult> {
-	const settingsPath = getSettingsPath();
-	const settings = readSettingsJson(settingsPath);
-	const currentKey = getBraveApiKey(settings);
-
-	// Already configured? Mark complete and skip.
-	if (!isPlaceholderKey(currentKey)) {
-		markOnboardingComplete();
-		return { kind: "deferred" };
-	}
-
-	// No UI? Defer to a later session.
-	if (!ctx.hasUI) {
-		return { kind: "deferred" };
-	}
-
-	const wantsBrave = await ctx.ui.confirm(
-		"Use Brave Search?",
-		"Brave gives reliable web results for the web_explore tool. You can get an API key at https://api-dashboard.search.brave.com/app/keys. Use Brave now?",
-	);
-
-	if (!wantsBrave) {
-		markOnboardingComplete();
-		ctx.ui.notify("Brave skipped — web search will use the default DuckDuckGo backend.", "info");
-		return { kind: "skipped" };
-	}
-
-	try {
-		await openBraveKeysUrl(pi);
-		ctx.ui.notify("Opened the Brave API key dashboard in your browser.", "info");
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		ctx.ui.notify(`Could not open browser: ${message}`, "warning");
-		ctx.ui.notify(`Open this URL manually: ${BRAVE_KEYS_URL}`, "info");
-	}
-
-	const rawKey = await promptForKey(ctx);
-	const validated = validateBraveKey(rawKey);
-
-	if (validated.error) {
-		ctx.ui.notify(validated.error, "warning");
-		// Do not mark complete so the prompt retries on next launch.
-		return { kind: "deferred" };
-	}
-
-	const updated = setBraveApiKey(settings, validated.key!);
-	writeSettingsJson(updated, settingsPath);
-	// Select Brave as the pi-web-agent search backend (DuckDuckGo fallback).
-	writeWebAgentBraveBackendConfig();
-	markOnboardingComplete();
-
-	ctx.ui.notify("Brave API key saved — web search will use Brave.", "info");
-	return { kind: "saved" };
-}
-
-export default function webAgentOnboardingExtension(pi: ExtensionAPI): void {
-	pi.on("session_start", async (event: SessionStartEvent, ctx: ExtensionContext) => {
-		if (event.reason !== "startup") return;
-		if (isOnboardingComplete()) return;
-
-		// Avoid prompting during tests or non-interactive runs.
-		if (process.env.SELESAI_SKIP_WEB_AGENT_ONBOARDING === "1") return;
-
-		await runOnboarding(pi, ctx);
-	});
-
-	// ponytail: command reuses runOnboarding() instead of duplicating the flow.
-	// On "saved" -> ctx.reload() so pi-web-agent re-applies the Brave backend config.
-	// On skipped/deferred -> no reload (nothing changed). The post-reload session_start
-	// fires with reason "reload" but the auto handler only acts on "startup", so no double prompt.
-	pi.registerCommand("setup-web-search", {
-		description: "Re-run the Brave Search onboarding flow, then reload extensions",
-		handler: async (_args: string, ctx: ExtensionCommandContext) => {
-			const result = await runOnboarding(pi, ctx);
-			if (result.kind === "saved") {
-				ctx.ui.notify("Brave key saved — reloading extensions…", "info");
-				await ctx.reload();
-			}
-		},
-	});
-}
+/**
+ * Web-Agent first-run onboarding extension.
+ *
+ * On the first interactive session, ask the user whether they want to use Brave
+ * Search. If yes, open the Brave API key dashboard, collect the pasted key, and
+ * persist it in ~/.selesai/agent/settings.json under webAgent.braveApiKey, then
+ * configure the bundled pi-web-agent backend to use Brave (with DuckDuckGo fallback).
+ * If no, the extension falls back to pi-web-agent's default DuckDuckGo backend.
+ *
+ * Mirrors src/extensions/tokenin-onboarding.ts.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir, getSettingsPath } from "@selesai/code";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionStartEvent } from "@selesai/code";
+
+export type OnboardingResult =
+	| { kind: "saved" }
+	| { kind: "skipped" }
+	| { kind: "deferred" }
+	| { kind: "error"; message: string };
+
+export const BRAVE_KEYS_URL = "https://api-dashboard.search.brave.com/app/keys";
+export const ONBOARDING_MARKER_NAME = ".webAgentOnboardingComplete";
+export const WEB_AGENT_CONFIG_SUBPATH = join("extensions", "pi-web-agent", "config.json");
+
+// ponytail: duplicated ~15 lines of marker-file + browser-open logic from
+// tokenin-onboarding.ts rather than extracting a shared module nobody asked for.
+// Ceiling: if a third onboarding extension appears, extract a shared helper then.
+
+/** Read and parse the current settings.json, returning a deep-ish mutable object. */
+export function readSettingsJson(settingsPath: string = getSettingsPath()): Record<string, unknown> {
+	try {
+		const raw = readFileSync(settingsPath, "utf-8");
+		return JSON.parse(raw) as Record<string, unknown>;
+	} catch {
+		return {};
+	}
+}
+
+/** Write settings.json back to disk atomically-ish with a trailing newline. */
+export function writeSettingsJson(settings: Record<string, unknown>, settingsPath: string = getSettingsPath()): void {
+	mkdirSync(dirname(settingsPath), { recursive: true });
+	writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf-8");
+}
+
+/**
+ * Return true if the Brave key value is missing, empty. We prompt again for any
+ * non-key value.
+ */
+export function isPlaceholderKey(apiKey: unknown): boolean {
+	if (apiKey === undefined || apiKey === null) return true;
+	if (typeof apiKey !== "string") return true;
+	return apiKey.trim() === "";
+}
+
+/** Return the current webAgent.braveApiKey value from settings.json. */
+export function getBraveApiKey(settings: Record<string, unknown>): unknown {
+	const webAgent = settings.webAgent;
+	if (!webAgent || typeof webAgent !== "object" || Array.isArray(webAgent)) return undefined;
+	return (webAgent as Record<string, unknown>).braveApiKey;
+}
+
+/** Return a new settings object with webAgent.braveApiKey set to key. */
+export function setBraveApiKey(settings: Record<string, unknown>, key: string): Record<string, unknown> {
+	const next = JSON.parse(JSON.stringify(settings)) as Record<string, unknown>;
+	if (!next.webAgent || typeof next.webAgent !== "object" || Array.isArray(next.webAgent)) {
+		next.webAgent = {};
+	}
+	const webAgent = next.webAgent as Record<string, unknown>;
+	webAgent.braveApiKey = key;
+	return next;
+}
+
+/** Validate a pasted Brave key. Returns normalized key or an error message. */
+export function validateBraveKey(raw: string | undefined): { key?: string; error?: string } {
+	if (raw === undefined || raw === null) return { error: "No key entered." };
+	const trimmed = raw.trim();
+	if (trimmed === "") return { error: "Key cannot be empty." };
+	return { key: trimmed };
+}
+
+/** Path to the pi-web-agent global backend config (matches vendored config-store). */
+export function getWebAgentConfigPath(agentDir: string = getAgentDir()): string {
+	return join(agentDir, WEB_AGENT_CONFIG_SUBPATH);
+}
+
+/** Write pi-web-agent backend config selecting brave (with duckduckgo fallback). */
+export function writeWebAgentBraveBackendConfig(agentDir: string = getAgentDir()): void {
+	const configPath = getWebAgentConfigPath(agentDir);
+	mkdirSync(dirname(configPath), { recursive: true });
+	// Merge into any existing config so we don't clobber presentation settings.
+	let existing: Record<string, unknown> = {};
+	try {
+		existing = JSON.parse(readFileSync(configPath, "utf-8")) as Record<string, unknown>;
+	} catch {
+		// ENOENT or invalid JSON — start fresh.
+	}
+	const next = existing;
+	const backends = (next.backends ?? {}) as Record<string, unknown>;
+	(backends as Record<string, unknown>).search = { provider: "brave", fallback: "duckduckgo" };
+	next.backends = backends;
+	writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`, "utf-8");
+}
+
+function getOnboardingMarkerPath(agentDir: string = getAgentDir()): string {
+	return join(agentDir, ONBOARDING_MARKER_NAME);
+}
+
+function markOnboardingComplete(agentDir: string = getAgentDir()): void {
+	writeFileSync(getOnboardingMarkerPath(agentDir), "1", "utf-8");
+}
+
+function isOnboardingComplete(agentDir: string = getAgentDir()): boolean {
+	return existsSync(getOnboardingMarkerPath(agentDir));
+}
+
+async function openBraveKeysUrl(pi: ExtensionAPI): Promise<void> {
+	const url = BRAVE_KEYS_URL;
+	let command: string;
+	let args: string[];
+	if (process.platform === "darwin") {
+		command = "open";
+		args = [url];
+	} else if (process.platform === "win32") {
+		command = "cmd";
+		args = ["/c", "start", "", url];
+	} else {
+		command = "xdg-open";
+		args = [url];
+	}
+	const result = await pi.exec(command, args, { timeout: 10_000 });
+	if (result.code !== 0) {
+		throw new Error(`Failed to open ${url}: ${result.stderr || result.stdout || "unknown error"}`);
+	}
+}
+
+async function promptForKey(ctx: ExtensionContext): Promise<string | undefined> {
+	return ctx.ui.input("Paste your Brave API key", "");
+}
+
+async function runOnboarding(pi: ExtensionAPI, ctx: ExtensionContext): Promise<OnboardingResult> {
+	const settingsPath = getSettingsPath();
+	const settings = readSettingsJson(settingsPath);
+	const currentKey = getBraveApiKey(settings);
+
+	// Already configured? Mark complete and skip.
+	if (!isPlaceholderKey(currentKey)) {
+		markOnboardingComplete();
+		return { kind: "deferred" };
+	}
+
+	// No UI? Defer to a later session.
+	if (!ctx.hasUI) {
+		return { kind: "deferred" };
+	}
+
+	const wantsBrave = await ctx.ui.confirm(
+		"Use Brave Search?",
+		"Brave gives reliable web results for the web_explore tool. You can get an API key at https://api-dashboard.search.brave.com/app/keys. Use Brave now?",
+	);
+
+	if (!wantsBrave) {
+		markOnboardingComplete();
+		ctx.ui.notify("Brave skipped — web search will use the default DuckDuckGo backend.", "info");
+		return { kind: "skipped" };
+	}
+
+	try {
+		await openBraveKeysUrl(pi);
+		ctx.ui.notify("Opened the Brave API key dashboard in your browser.", "info");
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		ctx.ui.notify(`Could not open browser: ${message}`, "warning");
+		ctx.ui.notify(`Open this URL manually: ${BRAVE_KEYS_URL}`, "info");
+	}
+
+	const rawKey = await promptForKey(ctx);
+	const validated = validateBraveKey(rawKey);
+
+	if (validated.error) {
+		ctx.ui.notify(validated.error, "warning");
+		// Do not mark complete so the prompt retries on next launch.
+		return { kind: "deferred" };
+	}
+
+	const updated = setBraveApiKey(settings, validated.key!);
+	writeSettingsJson(updated, settingsPath);
+	// Select Brave as the pi-web-agent search backend (DuckDuckGo fallback).
+	writeWebAgentBraveBackendConfig();
+	markOnboardingComplete();
+
+	ctx.ui.notify("Brave API key saved — web search will use Brave.", "info");
+	return { kind: "saved" };
+}
+
+export default function webAgentOnboardingExtension(pi: ExtensionAPI): void {
+	pi.on("session_start", async (event: SessionStartEvent, ctx: ExtensionContext) => {
+		if (event.reason !== "startup") return;
+		if (isOnboardingComplete()) return;
+
+		// Avoid prompting during tests or non-interactive runs.
+		if (process.env.SELESAI_SKIP_WEB_AGENT_ONBOARDING === "1") return;
+
+		await runOnboarding(pi, ctx);
+	});
+
+	// ponytail: command reuses runOnboarding() instead of duplicating the flow.
+	// On "saved" -> ctx.reload() so pi-web-agent re-applies the Brave backend config.
+	// On skipped/deferred -> no reload (nothing changed). The post-reload session_start
+	// fires with reason "reload" but the auto handler only acts on "startup", so no double prompt.
+	pi.registerCommand("setup-web-search", {
+		description: "Re-run the Brave Search onboarding flow, then reload extensions",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			const result = await runOnboarding(pi, ctx);
+			if (result.kind === "saved") {
+				ctx.ui.notify("Brave key saved — reloading extensions…", "info");
+				await ctx.reload();
+			}
+		},
+	});
+}

package/dist/modes/interactive/components/startup-box.d.ts

@@ -0,0 +1,38 @@
+import type { Component } from "@earendil-works/pi-tui";
+/**
+ * Pure layout math for the startup resource boxes. No coloring here so it can
+ * be unit-tested without a terminal.
+ *
+ * Items flow horizontally into columns; the box width hugs its content and
+ * never exceeds maxWidth:
+ *
+ *   ╭─ Skills ────────────────────────╮
+ *   │ • alpha    • gamma    • zeta    │
+ *   │ • beta     • delta              │
+ *   ╰─────────────────────────────────╯
+ *
+ * Every line is exactly `innerWidth + 2` visible characters: outer border char
+ * (1) + inner content (innerWidth) + border char (1).
+ */
+/** Minimum inner width so the bullet, label, and padding always have room. */
+export declare const MIN_BOX_INNER_WIDTH = 6;
+/** Visible line width for a box with the given inner content width. */
+export declare function boxLineWidth(innerWidth: number): number;
+/**
+ * Build the box lines for a titled bullet box.
+ * Labels are trimmed and sorted. Items flow into as many columns as fit within
+ * `maxWidth`; the box shrinks to its content (never wider than maxWidth).
+ * Anything that still doesn't fit is ellipsis-truncated.
+ */
+export declare function buildBulletBoxLines(title: string, items: string[], maxWidth?: number): string[];
+/**
+ * Responsive boxed bullet list component. Recomputes layout per render width,
+ * so it stays correct on terminal resize.
+ */
+export declare class StartupBox implements Component {
+    private readonly title;
+    private readonly items;
+    constructor(title: string, items: string[]);
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/modes/interactive/components/startup-box.js

@@ -0,0 +1,90 @@
+import { theme } from "../theme/theme.js";
+/**
+ * Pure layout math for the startup resource boxes. No coloring here so it can
+ * be unit-tested without a terminal.
+ *
+ * Items flow horizontally into columns; the box width hugs its content and
+ * never exceeds maxWidth:
+ *
+ *   ╭─ Skills ────────────────────────╮
+ *   │ • alpha    • gamma    • zeta    │
+ *   │ • beta     • delta              │
+ *   ╰─────────────────────────────────╯
+ *
+ * Every line is exactly `innerWidth + 2` visible characters: outer border char
+ * (1) + inner content (innerWidth) + border char (1).
+ */
+/** Minimum inner width so the bullet, label, and padding always have room. */
+export const MIN_BOX_INNER_WIDTH = 6;
+/** Visible line width for a box with the given inner content width. */
+export function boxLineWidth(innerWidth) {
+    return innerWidth + 2;
+}
+/**
+ * Build the box lines for a titled bullet box.
+ * Labels are trimmed and sorted. Items flow into as many columns as fit within
+ * `maxWidth`; the box shrinks to its content (never wider than maxWidth).
+ * Anything that still doesn't fit is ellipsis-truncated.
+ */
+export function buildBulletBoxLines(title, items, maxWidth) {
+    const labels = items
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0)
+        .sort((a, b) => a.localeCompare(b));
+    const longestLabel = labels.reduce((max, label) => Math.max(max, label.length), 0);
+    const gap = 2;
+    const naturalCell = longestLabel + 2; // "• label" + one pad
+    const titleWidth = Math.max(title.length + 4, MIN_BOX_INNER_WIDTH);
+    const maxInner = maxWidth !== undefined ? Math.max(1, maxWidth - 2) : Infinity;
+    // Cell width and column count: fit as many columns as the budget allows.
+    const cellWidth = Math.min(naturalCell, maxInner);
+    const maxCols = maxWidth !== undefined
+        ? Math.max(1, Math.floor((maxInner + gap) / (cellWidth + gap)))
+        : Math.max(1, labels.length);
+    const cols = Math.min(labels.length, maxCols);
+    // Box hugs content: columns + gaps, at least as wide as the title, capped by budget.
+    const contentWidth = cols * cellWidth + gap * (cols - 1);
+    const innerWidth = Math.min(Math.max(titleWidth, contentWidth), maxInner);
+    const fit = (label) => label.length <= cellWidth - 2 ? label : `${label.slice(0, cellWidth - 3)}…`;
+    const rows = Math.ceil(labels.length / cols);
+    const topInner = `─ ${title} ${"─".repeat(Math.max(0, innerWidth - title.length - 3))}`.slice(0, innerWidth);
+    const top = `╭${topInner}╮`;
+    const bottom = `╰${"─".repeat(innerWidth)}╯`;
+    const rowLines = Array.from({ length: rows }, (_, row) => {
+        const cells = [];
+        for (let col = 0; col < cols; col++) {
+            const label = labels[row * cols + col];
+            cells.push(label === undefined ? " ".repeat(cellWidth) : `• ${fit(label)}`.padEnd(cellWidth));
+        }
+        const content = cells.join(" ".repeat(gap));
+        return `│${content.padEnd(innerWidth)}│`;
+    });
+    return [top, ...rowLines, bottom];
+}
+/**
+ * Responsive boxed bullet list component. Recomputes layout per render width,
+ * so it stays correct on terminal resize.
+ */
+export class StartupBox {
+    title;
+    items;
+    constructor(title, items) {
+        this.title = title;
+        this.items = items;
+    }
+    invalidate() {
+        // Stateless per render; nothing cached.
+    }
+    render(width) {
+        const lines = buildBulletBoxLines(this.title, this.items, width);
+        const border = (s) => theme.fg("border", s);
+        return lines.map((line, index) => {
+            // Top line: color the embedded title with the heading color.
+            const match = index === 0 ? line.match(/^(╭─ )(.+?)( ─*╮)$/) : undefined;
+            if (match) {
+                return border(match[1]) + theme.fg("mdHeading", match[2]) + border(match[3]);
+            }
+            return border(line);
+        });
+    }
+}

package/dist/modes/interactive/interactive-mode.d.ts

@@ -118,6 +118,7 @@ export declare class InteractiveMode {
     private customFooter;
     private headerContainer;
     private builtInHeader;
+    private startupBannerDismissed;
     private customHeader;
     private options;
     private readonly onRightClickPaste;
@@ -179,6 +180,8 @@ export declare class InteractiveMode {
     private formatPathWithSource;
     private formatDiagnostics;
     private showLoadedResources;
+    /** Dismiss the startup banner (logo + loaded resources) on first user message. */
+    private dismissStartupBanner;
     private bindCurrentSessionExtensions;
     private applyRuntimeSettings;
     private rebindCurrentSession;