gsd-pi 2.75.0 → 2.76.0-dev.82e249f7b

package/packages/pi-coding-agent/src/core/model-registry-auth-mode.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { Api, Model, SimpleStreamOptions, Context, AssistantMessageEventStream } from "@gsd/pi-ai";
 import { getApiProvider } from "@gsd/pi-ai";
-import type { AuthStorage } from "./auth-storage.js";
+import { AuthStorage, type AuthStorageData } from "./auth-storage.js";
 import { ModelRegistry } from "./model-registry.js";
 
 function createRegistry(hasAuthFn?: (provider: string) => boolean): ModelRegistry {
@@ -18,6 +18,10 @@ function createRegistry(hasAuthFn?: (provider: string) => boolean): ModelRegistr
 	return new ModelRegistry(authStorage, undefined);
 }
 
+function createInMemoryRegistry(data: AuthStorageData = {}): ModelRegistry {
+	return new ModelRegistry(AuthStorage.inMemory(data), undefined);
+}
+
 function createProviderModel(id: string, api?: string): NonNullable<Parameters<ModelRegistry["registerProvider"]>[1]["models"]>[number] {
 	return {
 		id,
@@ -389,6 +393,38 @@ describe("ModelRegistry authMode — getAvailable", () => {
 		const available = registry.getAvailable();
 		assert.equal(available.length, 0);
 	});
+
+	it("prunes Codex models removed from ChatGPT-backed openai-codex OAuth", () => {
+		const registry = createInMemoryRegistry({
+			"openai-codex": {
+				type: "oauth",
+				access: "oauth-access",
+				refresh: "oauth-refresh",
+				expires: Date.now() + 60_000,
+				accountId: "acct_123",
+			},
+		});
+
+		assert.equal(registry.find("openai-codex", "gpt-5.1-codex-max"), undefined);
+		assert.equal(registry.find("openai-codex", "gpt-5.1"), undefined);
+		assert.equal(findModel(registry, "openai-codex", "gpt-5.2-codex"), undefined);
+		assert.ok(registry.find("openai-codex", "gpt-5.4"));
+		assert.ok(findModel(registry, "openai-codex", "gpt-5.4"));
+		assert.ok(registry.find("openai-codex", "gpt-5.4-mini"));
+		assert.ok(findModel(registry, "openai-codex", "gpt-5.4-mini"));
+	});
+
+	it("keeps API-backed OpenAI Codex-capable models available", () => {
+		const registry = createInMemoryRegistry({
+			openai: {
+				type: "api_key",
+				key: "sk-test",
+			},
+		});
+
+		assert.ok(registry.find("openai", "gpt-5.2-codex"));
+		assert.ok(findModel(registry, "openai", "gpt-5.2-codex"));
+	});
 });
 
 // ─── getApiKey ────────────────────────────────────────────────────────────────

package/packages/pi-coding-agent/src/core/model-registry-discovery.test.ts

@@ -6,6 +6,7 @@ import { afterEach, beforeEach, describe, it } from "node:test";
 import { AuthStorage } from "./auth-storage.js";
 import { ModelDiscoveryCache } from "./discovery-cache.js";
 import { getDefaultTTL, getDiscoverableProviders, getDiscoveryAdapter } from "./model-discovery.js";
+import { ModelRegistry } from "./model-registry.js";
 
 let testDir: string;
 
@@ -133,3 +134,77 @@ describe("Discovery TTL configuration", () => {
 		assert.equal(customTTL, defaultTTL);
 	});
 });
+
+describe("ModelRegistry discovery — OpenAI-compatible custom providers", () => {
+	it("discovers custom OpenAI-compatible providers and maps capability metadata", async () => {
+		const providerName = `minimax-openai-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+		const modelsPath = join(testDir, "models.json");
+		writeFileSync(
+			modelsPath,
+			JSON.stringify(
+				{
+					providers: {
+						[providerName]: {
+							baseUrl: "https://api.minimax.example",
+							apiKey: "minimax-test-key",
+							api: "openai-completions",
+							models: [{ id: "bootstrap-model" }],
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf-8",
+		);
+
+		const prevFetch = globalThis.fetch;
+		let requestedUrl = "";
+		globalThis.fetch = (async (input: string | URL | Request) => {
+			requestedUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+			return new Response(
+				JSON.stringify({
+					data: [
+						{
+							id: "MiniMax-M2.7-highspeed",
+							name: "MiniMax M2.7 Highspeed",
+							context_window: 165000,
+							max_output_tokens: 32768,
+							supports_reasoning: true,
+							input_modalities: ["text", "image"],
+						},
+					],
+				}),
+				{
+					status: 200,
+					headers: { "content-type": "application/json" },
+				},
+			);
+		}) as typeof globalThis.fetch;
+
+		try {
+			const registry = new ModelRegistry(AuthStorage.inMemory({}), modelsPath);
+			// Guard against global cache leakage from prior test runs.
+			registry.getDiscoveryCache().clear(providerName);
+			const results = await registry.discoverModels([providerName]);
+
+			const discovery = results.find((r) => r.provider === providerName);
+			assert.ok(discovery, "discovery result should include custom provider");
+			assert.equal(discovery?.error, undefined, "custom provider discovery should succeed");
+			assert.equal(requestedUrl, "https://api.minimax.example/v1/models");
+
+			const discovered = registry
+				.getAllWithDiscovered()
+				.find((m) => m.provider === providerName && m.id === "MiniMax-M2.7-highspeed");
+			assert.ok(discovered, "discovered model should be merged into model list");
+			assert.equal(discovered?.api, "openai-completions");
+			assert.equal(discovered?.baseUrl, "https://api.minimax.example");
+			assert.equal(discovered?.contextWindow, 165000);
+			assert.equal(discovered?.maxTokens, 32768);
+			assert.equal(discovered?.reasoning, true);
+			assert.deepEqual(discovered?.input, ["text", "image"]);
+		} finally {
+			globalThis.fetch = prevFetch;
+		}
+	});
+});

package/packages/pi-coding-agent/src/core/model-registry.ts

@@ -29,7 +29,7 @@ import { getAgentDir } from "../config.js";
 import type { AuthStorage } from "./auth-storage.js";
 import { ModelDiscoveryCache } from "./discovery-cache.js";
 import type { DiscoveredModel, DiscoveryResult } from "./model-discovery.js";
-import { getDefaultTTL, getDiscoverableProviders, getDiscoveryAdapter } from "./model-discovery.js";
+import { getDefaultTTL, getDiscoverableProviders, getDiscoveryAdapter, supportsDiscoveryForApi } from "./model-discovery.js";
 import { clearConfigValueCache, resolveConfigValue, resolveHeaders } from "./resolve-config-value.js";
 import { isLocalModel } from "./local-model-check.js";
 
@@ -788,11 +788,12 @@ export class ModelRegistry {
 	 * Results are cached and merged into the registry (never overrides existing models).
 	 */
 	async discoverModels(providers?: string[]): Promise<DiscoveryResult[]> {
-		const targetProviders = providers ?? getDiscoverableProviders();
+		const targetProviders = providers ?? this.getAutoDiscoverableProviders();
 		const results: DiscoveryResult[] = [];
 
 		for (const providerName of targetProviders) {
-			const adapter = getDiscoveryAdapter(providerName);
+			const providerApis = this.getProviderApis(providerName);
+			const adapter = getDiscoveryAdapter(providerName, providerApis);
 			if (!adapter.supportsDiscovery) continue;
 
 			// Skip if cache is still fresh
@@ -812,8 +813,10 @@ export class ModelRegistry {
 				const apiKey = await this.authStorage.getApiKey(providerName);
 				if (!apiKey && !this.isProviderRequestReady(providerName)) continue;
 
-				const models = await adapter.fetchModels(apiKey ?? "", undefined);
-				this.discoveryCache.set(providerName, models);
+				const baseUrl = this.getProviderBaseUrl(providerName);
+				const models = await adapter.fetchModels(apiKey ?? "", baseUrl);
+				const ttlMs = this.getDiscoveryTtl(providerName, providerApis);
+				this.discoveryCache.set(providerName, models, ttlMs);
 				results.push({
 					provider: providerName,
 					models,
@@ -865,24 +868,97 @@ export class ModelRegistry {
 		const converted: Model<Api>[] = [];
 		for (const result of results) {
 			if (result.error) continue;
+			const providerDefaults = this.getDiscoveryProviderDefaults(result.provider);
 			for (const dm of result.models) {
 				converted.push({
 					id: dm.id,
 					name: dm.name ?? dm.id,
-					api: "openai" as Api,
+					api: providerDefaults.api,
 					provider: result.provider,
-					baseUrl: "",
+					baseUrl: providerDefaults.baseUrl,
 					reasoning: dm.reasoning ?? false,
-					input: dm.input ?? ["text"],
+					input: dm.input ?? providerDefaults.input,
 					cost: dm.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-					contextWindow: dm.contextWindow ?? 128000,
-					maxTokens: dm.maxTokens ?? 16384,
+					contextWindow: dm.contextWindow ?? providerDefaults.contextWindow,
+					maxTokens: dm.maxTokens ?? providerDefaults.maxTokens,
 				} as Model<Api>);
 			}
 		}
 		return converted;
 	}
 
+	private getProviderApis(provider: string): Set<string> {
+		const apis = new Set<string>();
+		for (const model of this.models) {
+			if (model.provider === provider && typeof model.api === "string" && model.api.length > 0) {
+				apis.add(model.api);
+			}
+		}
+
+		const providerConfig = this.registeredProviders.get(provider);
+		if (providerConfig?.api) apis.add(providerConfig.api);
+		for (const modelDef of providerConfig?.models ?? []) {
+			if (modelDef.api) apis.add(modelDef.api);
+		}
+		return apis;
+	}
+
+	private getAutoDiscoverableProviders(): string[] {
+		const discoverable = new Set<string>(getDiscoverableProviders());
+		for (const provider of new Set(this.models.map((m) => m.provider))) {
+			const apis = this.getProviderApis(provider);
+			for (const api of apis) {
+				if (supportsDiscoveryForApi(api)) {
+					discoverable.add(provider);
+					break;
+				}
+			}
+		}
+		return [...discoverable];
+	}
+
+	private getProviderBaseUrl(provider: string): string | undefined {
+		const fromModels = this.models.find((m) => m.provider === provider && typeof m.baseUrl === "string" && m.baseUrl.length > 0);
+		if (fromModels?.baseUrl) return fromModels.baseUrl;
+		return this.registeredProviders.get(provider)?.baseUrl;
+	}
+
+	private getDiscoveryProviderDefaults(provider: string): {
+		api: Api;
+		baseUrl: string;
+		input: ("text" | "image")[];
+		contextWindow: number;
+		maxTokens: number;
+	} {
+		const first = this.models.find((m) => m.provider === provider);
+		if (first) {
+			return {
+				api: first.api,
+				baseUrl: first.baseUrl,
+				input: first.input,
+				contextWindow: first.contextWindow,
+				maxTokens: first.maxTokens,
+			};
+		}
+
+		return {
+			api: "openai-completions",
+			baseUrl: this.registeredProviders.get(provider)?.baseUrl ?? "",
+			input: ["text"],
+			contextWindow: 128000,
+			maxTokens: 16384,
+		};
+	}
+
+	private getDiscoveryTtl(provider: string, providerApis: Set<string>): number {
+		for (const api of providerApis) {
+			if (supportsDiscoveryForApi(api)) {
+				return getDefaultTTL("openai");
+			}
+		}
+		return getDefaultTTL(provider);
+	}
+
 	/**
 	 * Check if a model's baseUrl points to a local endpoint.
 	 * Delegates to standalone isLocalModel() function.

package/packages/pi-coding-agent/src/core/retry-handler.ts

@@ -538,7 +538,10 @@ export class RetryHandler {
 		if (!currentModel) return false;
 
 		// Only attempt claude-code fallback when the current provider is anthropic.
-		// Other providers may produce similar error text but should not be rerouted.
+		// Transport-specific (ADR-012): intentionally keys on provider, not api —
+		// the fallback specifically reroutes the plain `anthropic` transport to
+		// the `claude-code` transport. Other Anthropic-fronting transports
+		// (anthropic-vertex, amazon-bedrock) must not be rerouted.
 		if (currentModel.provider !== "anthropic") return false;
 
 		// Find the same model ID under the claude-code provider

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -1,5 +1,17 @@
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 
+/**
+ * Lightweight PATH scan for the `claude` binary — no subprocess, no network.
+ * Mirrors the check in src/resources/extensions/gsd/doctor-providers.ts so the
+ * legacy Anthropic OAuth self-heal path can only trigger when the user has a
+ * working Claude Code CLI to fall back to.
+ */
+function isClaudeCodeBinaryInPath(): boolean {
+	const pathDirs = (process.env.PATH ?? "").split(":");
+	return pathDirs.some((dir) => dir && existsSync(join(dir, "claude")));
+}
+
 /**
  * Structured error thrown when all credentials for a provider are in a
  * backoff window.  Carries typed metadata so callers (e.g. the auto-loop)
@@ -86,6 +98,16 @@ export interface CreateAgentSessionOptions {
 	tools?: Tool[];
 	/** Custom tools to register (in addition to built-in tools). */
 	customTools?: ToolDefinition[];
+	/**
+	 * Additional tool names to activate after extensions/MCP servers register.
+	 * Names that are not registered by any extension are silently ignored
+	 * by AgentSession.setActiveToolsByName.
+	 *
+	 * Used by --tools to forward names that don't match a built-in (likely
+	 * extension- or MCP-provided), so subagents whose frontmatter declares
+	 * extension tools don't end up with an empty tool list.
+	 */
+	extraActiveToolNames?: string[];
 
 	/** Resource loader. When omitted, DefaultResourceLoader is used. */
 	resourceLoader?: ResourceLoader;
@@ -299,9 +321,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const defaultActiveToolNames: ToolName[] = editMode === "hashline"
 		? ["hashline_read", "bash", "hashline_edit", "write", "lsp"]
 		: ["read", "bash", "edit", "write", "lsp"];
-	const initialActiveToolNames: ToolName[] = options.tools
+	const builtinActiveToolNames: ToolName[] = options.tools
 		? options.tools.map((t) => t.name).filter((n): n is ToolName => n in allTools)
 		: defaultActiveToolNames;
+	// Merge in extension/MCP tool names from --tools that didn't match a built-in.
+	// AgentSession.setActiveToolsByName silently drops names that aren't in the
+	// registry, so unknown names are harmless here.
+	const initialActiveToolNames: string[] = options.extraActiveToolNames
+		? [...builtinActiveToolNames, ...options.extraActiveToolNames]
+		: builtinActiveToolNames;
 
 	let agent: Agent;
 
@@ -438,6 +466,35 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			// the retry handler and creating cascading error entries (#3429).
 			const hasAuth = modelRegistry.authStorage.hasAuth(resolvedProvider);
 			if (hasAuth) {
+				// Anthropic OAuth was removed in v2.74.0 for TOS compliance (#3952).
+				// Users who upgraded from an older version may still have OAuth
+				// credentials in auth.json that will never resolve to a valid API key.
+				if (
+					resolvedProvider === "anthropic" &&
+					modelRegistry.authStorage.hasLegacyOAuthCredential(resolvedProvider)
+				) {
+					// Self-heal: strip the stale oauth entry so hasAuth() stops lying
+					// about anthropic being configured. This preserves any api_key
+					// credentials alongside it.
+					const removed = modelRegistry.authStorage.removeLegacyOAuthCredential(resolvedProvider);
+					if (removed) {
+						console.warn(
+							`[auth] Removed unsupported Anthropic OAuth credential from auth.json (#3952).`,
+						);
+					}
+					if (isClaudeCodeBinaryInPath()) {
+						throw new Error(
+							`Removed stale Anthropic OAuth credential (OAuth support removed in v2.74.0). ` +
+								`Your current model's provider is set to "anthropic" but the local Claude Code CLI ` +
+								`is available — switch the model's provider to "claude-code" in your preferences ` +
+								`to use it, or set ANTHROPIC_API_KEY to continue with the Anthropic API directly.`,
+						);
+					}
+					throw new Error(
+						`Removed stale Anthropic OAuth credential (OAuth support removed in v2.74.0). ` +
+							`Set ANTHROPIC_API_KEY, run '/login' and paste an API key, or switch to a different provider.`,
+					);
+				}
 				const expiry = modelRegistry.authStorage.getEarliestBackoffExpiry(resolvedProvider);
 				const retryAfterMs = expiry !== undefined ? Math.max(0, expiry - Date.now()) : undefined;
 				throw new CredentialCooldownError(resolvedProvider, retryAfterMs);

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -92,6 +92,62 @@ export interface ModelDiscoverySettings {
 	autoRefreshOnModelSelect?: boolean; // default: false - refresh discovery when opening model selector
 }
 
+/**
+ * A shell command bound to a Layer 0 hook event.
+ *
+ * Payload is passed to the command on stdin as JSON. The command may write a
+ * JSON object to stdout to mutate the pending action — shape varies per hook
+ * (e.g. `{"block":true,"reason":"..."}` for PreToolUse). Non-zero exit with
+ * `blocking: true` vetoes the action.
+ */
+export interface HookEntry {
+	/** Optional filter on the event payload (currently supports tool name / bash command prefix). */
+	match?: {
+		tool?: string | string[];
+		command?: string;
+	};
+	/** The shell command to execute. */
+	command: string;
+	/** Timeout in milliseconds. Default: 30000. */
+	timeout?: number;
+	/** When true (default), a non-zero exit vetoes the pending action. */
+	blocking?: boolean;
+	/** Extra environment variables for the child process. */
+	env?: Record<string, string>;
+}
+
+/**
+ * Layer 0 shell hooks. Each key is the name of a hook event; each value is a
+ * list of `HookEntry` — all matching entries run in order.
+ *
+ * Hook names mirror Claude Code's for portability.
+ */
+export interface HooksSettings {
+	PreToolUse?: HookEntry[];
+	PostToolUse?: HookEntry[];
+	UserPromptSubmit?: HookEntry[];
+	SessionStart?: HookEntry[];
+	SessionEnd?: HookEntry[];
+	Stop?: HookEntry[];
+	Notification?: HookEntry[];
+	PreCompact?: HookEntry[];
+	PostCompact?: HookEntry[];
+	PreCommit?: HookEntry[];
+	PostCommit?: HookEntry[];
+	PrePush?: HookEntry[];
+	PostPush?: HookEntry[];
+	PrePr?: HookEntry[];
+	PostPr?: HookEntry[];
+	PreMilestone?: HookEntry[];
+	PostMilestone?: HookEntry[];
+	PreUnit?: HookEntry[];
+	PostUnit?: HookEntry[];
+	PreVerify?: HookEntry[];
+	PostVerify?: HookEntry[];
+	BudgetThreshold?: HookEntry[];
+	Blocked?: HookEntry[];
+}
+
 export type TransportSetting = Transport;
 
 /**
@@ -154,6 +210,7 @@ export interface Settings {
 	timestampFormat?: "date-time-iso" | "date-time-us"; // Timestamp display format for messages. Default: "date-time-iso"
 	allowedCommandPrefixes?: string[]; // Override built-in SAFE_COMMAND_PREFIXES for !command resolution (global-only — ignored in project settings)
 	fetchAllowedUrls?: string[]; // Hostnames exempted from SSRF blocklist in fetch_page (global-only — ignored in project settings)
+	hooks?: HooksSettings; // Layer 0 shell-command hooks. Project-scoped hooks require explicit trust (.pi/hooks.trusted).
 }
 
 /** Settings keys that are only respected from global config — project settings cannot override these. */

package/packages/pi-coding-agent/src/core/skill-tool.test.ts

@@ -15,7 +15,7 @@ import { SettingsManager } from "./settings-manager.js";
 let testDir: string;
 
 function writeSkill(cwd: string, name: string, description: string, body = `# ${name}\n`): string {
-	const skillDir = join(cwd, ".pi", "skills", name);
+	const skillDir = join(cwd, ".agents", "skills", name);
 	mkdirSync(skillDir, { recursive: true });
 	const skillPath = join(skillDir, "SKILL.md");
 	writeFileSync(skillPath, `---\nname: ${name}\ndescription: ${description}\n---\n\n${body}`);
@@ -71,7 +71,7 @@ describe("Skill tool", () => {
 		const result = await tool.execute("call-1", { skill: "swift-testing" });
 		assert.equal(
 			result.content[0]?.type === "text" ? result.content[0].text : "",
-			`<skill name="swift-testing" location="${skillPath}">\nReferences are relative to ${join(testDir, ".pi", "skills", "swift-testing")}.\n\n# Swift Testing\nUse this skill.\n</skill>`,
+			`<skill name="swift-testing" location="${skillPath}">\nReferences are relative to ${join(testDir, ".agents", "skills", "swift-testing")}.\n\n# Swift Testing\nUse this skill.\n</skill>`,
 		);
 	});
 

package/packages/pi-coding-agent/src/index.ts

@@ -58,8 +58,24 @@ export type {
 	AppAction,
 	BashToolCallEvent,
 	BeforeAgentStartEvent,
+	BeforeCommitEvent,
+	BeforeCommitEventResult,
+	BeforePrEvent,
+	BeforePrEventResult,
+	BeforePushEvent,
+	BeforePushEventResult,
+	BeforeVerifyEvent,
+	BeforeVerifyEventResult,
+	BudgetThresholdEvent,
+	BudgetThresholdEventResult,
 	BeforeProviderRequestEvent,
 	BeforeProviderRequestEventResult,
+	CommitEvent,
+	NotificationEvent,
+	PrOpenedEvent,
+	PushEvent,
+	VerifyFailure,
+	VerifyResultEvent,
 	CompactOptions,
 	ContextEvent,
 	ContextUsage,

package/packages/pi-coding-agent/src/main.ts

@@ -320,6 +320,10 @@ function buildSessionOptions(
 		options.tools = parsed.tools.map((name) => allTools[name]);
 	}
 
+	if (parsed.extraToolNames && parsed.extraToolNames.length > 0) {
+		options.extraActiveToolNames = parsed.extraToolNames;
+	}
+
 	return { options, cliThinkingFromModel };
 }
 

package/packages/pi-coding-agent/src/modes/interactive/components/chat-frame.ts

@@ -27,10 +27,10 @@ export function renderChatFrame(
 	const contentWidth = Math.max(1, outerWidth - 2); // "│ " + content
 	const borderColor =
 		opts.tone === "user"
-			? "borderAccent"
+			? "border"
 			: opts.tone === "compaction"
 				? "customMessageLabel"
-				: "border";
+				: "borderAccent";
 	const borderMuted =
 		opts.tone === "compaction" ? "customMessageLabel" : "borderMuted";
 	const border = (s: string) => theme.fg(borderColor, s);
@@ -44,12 +44,18 @@ export function renderChatFrame(
 		? Math.max(1, outerWidth - visibleWidth(rightRaw) - 1)
 		: outerWidth;
 	const left = truncateToWidth(leftRaw, leftBudget, "");
-	const leftStyled =
+	const labelColor =
 		opts.tone === "user"
-			? theme.fg("accent", theme.bold(left))
+			? "border"
 			: opts.tone === "compaction"
-				? theme.fg("customMessageLabel", theme.bold(left))
-				: theme.fg("muted", theme.bold(left));
+				? "customMessageLabel"
+				: "borderAccent";
+	const dashIdx = left.indexOf(" - ");
+	const leftStyled =
+		dashIdx >= 0
+			? theme.fg(labelColor, theme.bold(left.slice(0, dashIdx))) +
+				theme.fg("dim", left.slice(dashIdx))
+			: theme.fg(labelColor, theme.bold(left));
 	const rightStyled = rightRaw ? theme.fg("dim", rightRaw) : "";
 	const gap =
 		rightRaw.length > 0
@@ -62,9 +68,15 @@ export function renderChatFrame(
 	const headerPad = Math.max(0, outerWidth - visibleWidth(headerRow));
 
 	const sourceLines = trimOuterBlankLines(contentLines);
+	const bodyColor =
+		opts.tone === "user"
+			? "userMessageText"
+			: opts.tone === "compaction"
+				? "customMessageText"
+				: "assistantMessageText";
 	const bodyLines = (sourceLines.length > 0 ? sourceLines : [""]).map((line) => {
 		const clipped = truncateToWidth(line, contentWidth, "");
-		return border("│ ") + clipped;
+		return border("│ ") + theme.fg(bodyColor, clipped);
 	});
 
 	return [