one-code-extension 0.3.0 → 0.4.0

package/extensions/bash/background.ts

@@ -12,11 +12,11 @@
  * notification and task_output can never disagree.
  */
 
-import { spawn } from "node:child_process";
 import { createWriteStream } from "node:fs";
 import type { BackgroundTask } from "../background/registry.ts";
 import { whenAborted } from "../lib/abort.ts";
-import { detachedSpawnOptions, KILL_GRACE_MS, stopProcessTree } from "../lib/process-tree.ts";
+import { detachedSpawnOptions, KILL_GRACE_MS, stopProcessTree, waitForChildExit } from "../lib/process-tree.ts";
+import { bashSpawnOrThrow, type ShellSpawn, spawnShellCommand } from "../lib/shell-spawn.ts";
 
 export const STORED_OUTPUT_CAP = 200_000;
 
@@ -45,12 +45,18 @@ export interface StartBackgroundBashOptions {
 	/** Kill the process tree after this many seconds. */
 	timeoutSeconds?: number;
 	logPath?: string;
+	/**
+	 * The interpreter to run `command` under. Default: the session's bash
+	 * (lib/shell-spawn.ts — Git Bash on Windows, `CLAUDE_CODE_GIT_BASH_PATH`
+	 * honoured); the powershell extension passes its own spec.
+	 */
+	shell?: ShellSpawn;
 	onFinished(task: BackgroundTask, summary: BashFinishSummary): void;
 }
 
 export function startBackgroundBash(options: StartBackgroundBashOptions): BackgroundTask {
 	// Own process group, so stop/timeout can signal the whole tree (lib/process-tree.ts).
-	const child = spawn(process.env.SHELL || "/bin/sh", ["-c", options.command], {
+	const child = spawnShellCommand(options.shell ?? bashSpawnOrThrow(), options.command, {
 		cwd: options.cwd,
 		...detachedSpawnOptions(),
 		stdio: ["ignore", "pipe", "pipe"],
@@ -80,6 +86,7 @@ export function startBackgroundBash(options: StartBackgroundBashOptions): Backgr
 
 	const task: BackgroundTask = {
 		id: options.id,
+		// "bash" for a PowerShell run too: the kind is what the shell panel lists.
 		kind: "bash",
 		description: options.description,
 		command: options.command,
@@ -124,13 +131,15 @@ export function startBackgroundBash(options: StartBackgroundBashOptions): Backgr
 		else complete();
 	};
 
-	child.on("error", (error) => {
-		stored = stored ? `${stored}\n${error.message}` : error.message;
-		end("failed", null, null);
-	});
-	child.on("close", (code, signal) => {
-		end(stopRequested ? "stopped" : timedOut || code !== 0 ? "failed" : "completed", code, signal);
-	});
+	// Exit plus a short stdio grace, not `close`: a descendant the stop missed
+	// must not keep the task "running" for its whole life (lib/process-tree.ts).
+	waitForChildExit(child).then(
+		({ code, signal }) => end(stopRequested ? "stopped" : timedOut || code !== 0 ? "failed" : "completed", code, signal),
+		(error: Error) => {
+			stored = stored ? `${stored}\n${error.message}` : error.message;
+			end("failed", null, null);
+		},
+	);
 
 	return task;
 }

package/extensions/bash/guards.ts

@@ -34,7 +34,7 @@ import {
 	type Token,
 } from "../auto-mode/shell-analysis.ts";
 
-const clip = (text: string, max = 200): string => (text.length > max ? `${text.slice(0, max)}…` : text);
+export const clip = (text: string, max = 200): string => (text.length > max ? `${text.slice(0, max)}…` : text);
 
 export function bashGuardReason(command: string, opts: { background: boolean }): string | undefined {
 	// A heredoc/here-string body is data, but parseCommand tokenizes it as live
@@ -72,34 +72,54 @@ function sleepSeconds(args: Token[]): number | undefined {
 // A segment's raw slice can keep half of the operator that ended the previous
 // one (`a && b` → second raw is `& b`) — strip it for a clean echo.
 
-function waitReason(segments: Segment[]): string | undefined {
-	// Measure the run of LEADING sleep segments: `sleep 1 && sleep 1 && …` is
-	// one wait spelled as a chain, so the pacing exemption applies only to a
-	// single provably-short sleep. Unprovable durations (`sleep "$DELAY"`)
-	// count as long — the model controls the literal.
+/**
+ * The wait guard's grammar-independent half, shared with the PowerShell
+ * guards: measure the run of LEADING sleep statements — `sleep 1 && sleep 1 &&
+ * …` is one wait spelled as a chain, so the pacing exemption applies only to a
+ * single provably-short sleep. Unprovable durations (`sleep "$DELAY"`) count
+ * as long: the model controls the literal. `sleepSeconds` returns undefined
+ * for a non-sleep statement.
+ */
+export function leadingSleepReason<T>(
+	statements: T[],
+	sleepSeconds: (statement: T) => number | undefined | null,
+	raw: (statement: T) => string,
+	opts: { sleepName: string; joiner: string; untilExample: string },
+): string | undefined {
 	let leadSleeps = 0;
 	let total: number | undefined = 0;
-	for (const seg of segments) {
-		const { command: cmd, args } = resolvePayload(leadTokens(seg));
-		if (cmd !== "sleep") break;
+	for (const statement of statements) {
+		const seconds = sleepSeconds(statement);
+		if (seconds === null) break; // not a sleep
 		leadSleeps++;
-		const seconds = sleepSeconds(args);
 		total = total === undefined || seconds === undefined ? undefined : total + seconds;
 	}
 	if (leadSleeps === 0) return undefined;
 	if (leadSleeps === 1 && total !== undefined && total < 2) return undefined;
-	const rest = segments.slice(leadSleeps).map((seg) => seg.raw).filter(Boolean).join("; ");
-	const shown = segments.slice(0, leadSleeps).map((seg) => seg.raw).join(" && ");
+	const rest = statements.slice(leadSleeps).map(raw).filter(Boolean).join("; ");
+	const shown = statements.slice(0, leadSleeps).map(raw).join(opts.joiner);
 	const echo = rest ? `\`${shown}\` followed by: ${clip(rest)}` : `standalone \`${shown}\``;
 	return (
-		`Blocked: ${echo}. A foreground sleep stalls the whole session while it runs. ` +
-		"To wait for a command you started, run it with run_in_background: true — its completion arrives as a system notification on its own, so you never need to poll. " +
-		"To wait for a condition, use the monitor tool with an until-loop (e.g. `until <check>; do sleep 2; done`) — monitor is deferred, load it with tool_search select:monitor. " +
+		`Blocked: ${echo}. A foreground ${opts.sleepName} stalls the whole session while it runs. ` +
+		"To wait for a command you started, run it with run_in_background: true — its completion arrives as a task notification on its own, so you never need to poll. " +
+		`To wait for a condition, use the monitor tool with an until-loop (e.g. \`${opts.untilExample}\`) — monitor is deferred, load it with tool_search select:monitor. ` +
 		"If you genuinely need a delay (rate limiting, deliberate pacing), keep it under 2 seconds. " +
 		"Do not chain shorter sleeps to work around this block."
 	);
 }
 
+function waitReason(segments: Segment[]): string | undefined {
+	return leadingSleepReason(
+		segments,
+		(seg) => {
+			const { command: cmd, args } = resolvePayload(leadTokens(seg));
+			return cmd === "sleep" ? sleepSeconds(args) : null;
+		},
+		(seg) => seg.raw,
+		{ sleepName: "sleep", joiner: " && ", untilExample: "until <check>; do sleep 2; done" },
+	);
+}
+
 // ---------------------------------------------------------------------------
 // Poll-loop guard
 
@@ -173,7 +193,7 @@ export function hasBackgroundAmp(command: string): boolean {
 function orphanReason(command: string, segments: Segment[]): string | undefined {
 	const message = (via: string) =>
 		`Blocked: this command detaches a process with ${via}, leaving an orphan this session cannot manage — its output and exit status would be lost. ` +
-		"Run it with run_in_background: true instead: it returns a task id immediately, completion arrives as a system notification, output stays readable with task_output, and it can be stopped with task_stop. " +
+		"Run it with run_in_background: true instead: it returns a task id immediately, completion arrives as a task notification, output stays readable with task_output, and it can be stopped with task_stop. " +
 		"If you need shell-level parallelism inside one command, end it with `wait` so the children are reaped.";
 
 	for (const seg of segments) {

package/extensions/bash/index.ts

@@ -6,39 +6,24 @@
  * is how pi's official sandbox example does it too. The foreground path
  * delegates to pi's real executor (`createBashToolDefinition`) so upstream
  * bash behavior — timeout handling, truncation, PI_* env, spawn hooks — stays
- * exactly pi's; this file only adds the background branch.
- *
- * A background run spawns detached, returns a task id immediately, spools
- * output to `<sessionDir>/bash/<taskId>/output.log`, registers on the shared
- * background registry (task_output/task_stop just work — they are
- * kind-agnostic), and announces completion as a steered system notification
- * (lib/notifications.ts). The permission gate and auto-mode classifier run before
- * execute like any bash call — a background command is NOT auto-allowed, and
- * the gate fires before anything detaches.
+ * exactly pi's; the shared body in lib/shell-tool.ts adds the background
+ * branch (spool to `<sessionDir>/bash/<taskId>/output.log`, the shared
+ * background registry, a steered completion notification), and this file only
+ * supplies what is bash's: pi's definition, the bash the session resolved
+ * (lib/shell-spawn.ts — Git Bash on Windows, `CLAUDE_CODE_GIT_BASH_PATH`
+ * honoured), the CC-shaped description and the bash guards. The permission
+ * gate and auto-mode classifier run before execute like any bash call — a
+ * background command is NOT auto-allowed, and the gate fires before anything
+ * detaches.
  */
 
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createBashToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { generateTaskId, TASK_REGISTER_CHANNEL } from "../background/registry.ts";
-import { type BashFinishSummary, runBackgroundBashBlocking, startBackgroundBash, tailCap } from "./background.ts";
-import { bashGuardReason } from "./guards.ts";
-import { commandToEvaluate, trackOriginalCommands } from "../lib/original-command.ts";
-import { createTaskNotifier, oneShotNote, sessionOutlivesTurn, systemNotification } from "../lib/notifications.ts";
-import { persistIfLarge, sessionResultsDir } from "../lib/persisted-output.ts";
 import { perCwd } from "../lib/per-cwd.ts";
-import { ccWrapBuiltinRenderers, linesComponent, resultLines } from "../lib/tui-render.ts";
-
-// The completion notification carries status + exit code + where the output is,
-// plus only a short tail: a finished build used to push 30 KB (~8k tokens) into
-// context unasked (review T7). The full tail stays behind task_output / the log.
-const NOTIFY_OUTPUT_CAP = 2_000;
-/** One-shot modes return the whole output in the result; past this it is persisted (file + preview), never cut. */
-const ONE_SHOT_OUTPUT_CAP = 30_000;
-/** Claude Code's Bash cap; the tool's `timeout` is milliseconds, as CC's is. */
-const MAX_TIMEOUT_MS = 600_000;
+import { bashSpawn } from "../lib/shell-spawn.ts";
+import { registerShellTool } from "../lib/shell-tool.ts";
+import { bashGuardReason } from "./guards.ts";
 
 const BashParams = Type.Object({
 	command: Type.String({ description: "Bash command to execute" }),
@@ -46,7 +31,7 @@ const BashParams = Type.Object({
 	run_in_background: Type.Optional(
 		Type.Boolean({
 			description:
-				"Run detached and return a task id immediately instead of waiting. Completion arrives as a system notification; inspect with task_output, stop with task_stop. Use this instead of nohup/'&' — those leave an unmanaged orphan process",
+				"Run detached and return a task id immediately instead of waiting. Completion arrives as a task notification; inspect with task_output, stop with task_stop. Use this instead of nohup/'&' — those leave an unmanaged orphan process",
 		}),
 	),
 	description: Type.Optional(
@@ -55,11 +40,23 @@ const BashParams = Type.Object({
 });
 
 export default function bashExtension(pi: ExtensionAPI) {
+	// The session's bash, resolved once (lib/shell-spawn.ts). An ignored
+	// CLAUDE_CODE_GIT_BASH_PATH is reported once, at the first session start.
+	const bash = bashSpawn();
+	const shellPath = bash.spawn?.commandTransport === "stdin" ? undefined : bash.spawn?.shell;
+	let warned = false;
+	pi.on("session_start", (_event, ctx) => {
+		if (warned || !bash.warning) return;
+		warned = true;
+		if (ctx.hasUI) ctx.ui.notify(bash.warning, "warning");
+		else process.stderr.write(`${bash.warning}\n`);
+	});
+
 	// pi's definition supplies the description and TUI renderers; the executor
 	// is re-created per working directory because it closes over cwd (worktree
-	// switches change ctx.cwd mid-session).
-	const base = createBashToolDefinition(process.cwd());
-	const foreground = perCwd(createBashToolDefinition);
+	// switches change ctx.cwd mid-session). The same bash drives pi's foreground
+	// executor, so the override applies there too.
+	const base = createBashToolDefinition(process.cwd(), { shellPath });
 	// pi's base sentence is "Optionally provide a timeout in seconds." — but the
 	// `timeout` parameter and the execute path both use milliseconds (Claude
 	// Code's Bash unit; the executor divides by 1000). The two must not
@@ -71,141 +68,14 @@ export default function bashExtension(pi: ExtensionAPI) {
 		"`timeout` is in milliseconds: default 120000, max 600000.",
 	);
 
-	const notifyTask = createTaskNotifier(pi);
-	// A worktree session cd-wraps input.command; the pre-wrapper original arrives
-	// over the bus keyed by toolCallId (never read from params — model-writable).
-	const originalCommands = trackOriginalCommands(pi);
-	const notify = (text: string, details: Record<string, unknown>) => notifyTask("task-notification", text, details);
-
-	const taskLogPath = (ctx: ExtensionContext, taskId: string): string | undefined => {
-		try {
-			const dir = join(ctx.sessionManager.getSessionDir(), "bash", taskId);
-			mkdirSync(dir, { recursive: true });
-			return join(dir, "output.log");
-		} catch {
-			return undefined;
-		}
-	};
-
-	const finishLine = (summary: BashFinishSummary, timeoutSeconds?: number): string => {
-		if (summary.stopped) return "stopped";
-		if (summary.timedOut) return `failed (timed out after ${timeoutSeconds}s)`;
-		if (summary.exitCode === 0) return "completed";
-		return `failed (${summary.exitCode !== null ? `exit code ${summary.exitCode}` : `terminated by ${summary.signal ?? "unknown signal"}`})`;
-	};
-
-	pi.registerTool({
+	registerShellTool(pi, {
 		name: "bash",
-		label: base.label,
-		description: `${baseDescription} Pass run_in_background: true for long-running commands (builds, servers, watches): it returns a task id immediately so you can keep working, completion arrives as a system notification, and the output is retrievable with task_output / stoppable with task_stop (both deferred — load them with tool_search; in a one-shot print/json session the call runs to completion and returns the output directly). Foreground \`sleep\` is blocked; to wait on a condition use the monitor tool (deferred — load it with tool_search select:monitor) with an until-loop.`,
-		promptSnippet: base.promptSnippet,
-		promptGuidelines: base.promptGuidelines,
-		executionMode: base.executionMode,
-		...(() => {
-			// `● Bash(cmd)` / elbow-indented output, like every other One Code tool.
-			// Not passing base.renderCall also drops its timer state, so the
-			// misleading "Took Ns" that counted permission-prompt wait disappears.
-			const wrapped = ccWrapBuiltinRenderers<{ command?: string }>("Bash", base, { title: (a) => a?.command });
-			return {
-				renderShell: wrapped.renderShell,
-				renderCall: wrapped.renderCall as ToolDefinition<typeof BashParams>["renderCall"],
-				renderResult: ((result, options, theme, context) => {
-					// A background start returns a model-facing instruction paragraph;
-					// the transcript needs one line (Claude Code: "Running in the background").
-					const details = result.details as { taskId?: string; logPath?: string } | undefined;
-					if (details?.taskId && !context.isError) {
-						const line = options.expanded
-							? `Running in the background (task ${details.taskId}${details.logPath ? ` · log: ${details.logPath}` : ""})`
-							: "Running in the background (↓ to manage)";
-						return linesComponent(() => resultLines(theme as any, line, options.expanded, false));
-					}
-					return wrapped.renderResult(result, options, theme, context);
-				}) as ToolDefinition<typeof BashParams>["renderResult"],
-			};
-		})(),
+		ccLabel: "Bash",
+		description: `${baseDescription} Pass run_in_background: true for long-running commands (builds, servers, watches): it returns a task id immediately so you can keep working, completion arrives as a task notification, and the output is retrievable with task_output / stoppable with task_stop (both deferred — load them with tool_search; in a one-shot print/json session the call runs to completion and returns the output directly). Foreground \`sleep\` is blocked; to wait on a condition use the monitor tool (deferred — load it with tool_search select:monitor) with an until-loop.`,
 		parameters: BashParams,
-		async execute(toolCallId, params, signal, onUpdate, ctx) {
-			// Guards check the model's original command — a worktree session rewrites
-			// input.command to `cd '<wt>' && (…)`, which would hide the real lead.
-			const originalCommand = commandToEvaluate(originalCommands, toolCallId, params.command);
-			const guardReason = bashGuardReason(originalCommand, { background: params.run_in_background === true });
-			if (guardReason) return { content: [{ type: "text" as const, text: guardReason }], isError: true, details: {} };
-			const timeoutSeconds =
-				params.timeout !== undefined && Number.isFinite(params.timeout) && params.timeout > 0
-					? Math.min(params.timeout, MAX_TIMEOUT_MS) / 1000
-					: undefined;
-
-			if (!params.run_in_background) {
-				// pi's executor takes seconds; the model-facing unit is milliseconds
-				// (Claude Code's Bash), so a habitual `timeout: 120000` is 2 minutes,
-				// not 33 hours (review T11).
-				return foreground(ctx.cwd).execute(
-					toolCallId,
-					{ command: params.command, timeout: timeoutSeconds },
-					signal,
-					onUpdate,
-					ctx,
-				);
-			}
-
-			const id = generateTaskId();
-			const logPath = taskLogPath(ctx, id);
-			const description = params.description || params.command.slice(0, 80);
-
-			// One-shot modes (`-p` / `--mode json`) exit when the turn settles: a
-			// detached task would be orphaned, and its completion callback would
-			// call sendMessage on the disposed session and crash pi (measured,
-			// STEERING-REVIEW-2026-09-05 H3). Run blocking there — the same rule the
-			// Agent tool applies — and return the output in the result.
-			if (!sessionOutlivesTurn(ctx.mode)) {
-				const summary = await runBackgroundBashBlocking(
-					{ id, command: params.command, description, cwd: ctx.cwd, timeoutSeconds, logPath },
-					signal,
-				);
-				const output = persistIfLarge(summary.output, { dir: sessionResultsDir(ctx), id: `bash-${id}`, maxBytes: ONE_SHOT_OUTPUT_CAP });
-				return {
-					content: [
-						{
-							type: "text",
-							text: `Bash task ${id} (${description}) ${finishLine(summary, timeoutSeconds)}. ${oneShotNote("command")}${logPath ? ` Log: ${logPath}.` : ""}\n\n${output}`,
-						},
-					],
-					// No taskId: nothing was registered behind task_output/task_stop, and
-					// its presence is what renderResult reads as "running in the background".
-					details: { logPath },
-					isError: summary.exitCode !== 0 && !summary.stopped,
-				};
-			}
-
-			const task = startBackgroundBash({
-				id,
-				command: params.command,
-				description,
-				cwd: ctx.cwd,
-				timeoutSeconds,
-				logPath,
-				onFinished: (finishedTask, summary) => {
-					const tail = tailCap(summary.output, NOTIFY_OUTPUT_CAP).trim();
-					const where = `Full output: task_output ${id}${logPath ? ` (or read ${logPath})` : ""}.`;
-					notify(
-						systemNotification(
-							`Background bash ${id} (${description}) ${finishLine(summary, timeoutSeconds)}. ${where}${tail ? `\n\nLast output:\n${tail}` : ""}`,
-						),
-						{ taskId: id, status: finishedTask.status, exitCode: summary.exitCode, logPath },
-					);
-				},
-			});
-			pi.events.emit(TASK_REGISTER_CHANNEL, task);
-
-			return {
-				content: [
-					{
-						type: "text",
-						text: `⏳ Bash task ${id} running in background (${description}).\n\nCompletion (with output) will arrive as a system notification on its own — you do not need to wait for it or poll; keep working.${logPath ? ` To check interim output, read ${logPath}.` : ""} If your next step cannot proceed without the result, task_output with block=true waits for it. Stop with task_stop.`,
-					},
-				],
-				details: { taskId: id, logPath },
-			};
-		},
+		base,
+		foreground: perCwd((cwd: string) => createBashToolDefinition(cwd, { shellPath })),
+		guard: bashGuardReason,
+		backgroundShell: () => bash.spawn,
 	});
 }

package/extensions/branding/index.ts

@@ -14,9 +14,10 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
+import { modeCycleKey } from "../lib/keys.ts";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { getAgentDir, SettingsManager, VERSION as PI_VERSION } from "@earendil-works/pi-coding-agent";
 import { piVersionWarning } from "../lib/pi-version.ts";
@@ -91,8 +92,9 @@ const HINTS: [key: string, what: string][] = [
 	// it as Claude Code's "effort" so the key and /effort agree on the name.
 	["shift+tab", "effort"],
 	// Claude Code cycles permission modes on shift+tab; pi owns that key, and
-	// ctrl+q is the one ctrl+letter both pi and terminals leave free.
-	["ctrl+q", "permissions"],
+	// ctrl+q is the one ctrl+letter both pi and terminals leave free — except
+	// on Windows and WSL, where pi takes ctrl+q and the key is alt+m.
+	[modeCycleKey(), "permissions"],
 	["ctrl+t", "thinking"],
 	["ctrl+o", "expand output"],
 	["/", "commands"],
@@ -280,7 +282,37 @@ export default function brandingExtension(pi: ExtensionAPI) {
 	}
 	// The label and prompt marker apply in every session; CC_NO_BANNER only
 	// disables the header.
+	// The terminal title. pi writes "π - [<session name> - ]<cwd>" at the end of
+	// its startup, on every session replacement and whenever the name changes —
+	// each AFTER our session_start handler ran, so a title set there alone lost
+	// (seen live 2026-09-19: "π - proj"). Re-assert it once the current task
+	// has drained (setTimeout 0, past pi's synchronous tail) and on every
+	// agent_start, and follow the name like pi does, brand first.
+	let lastTitle: string | undefined;
+	// A ctx captured for the deferred write is stale once the runtime is replaced
+	// (a second /clear inside the 0 ms window); pi's stale-ctx guard throws, and a
+	// throw inside a timer is uncaught — so the write is inert after shutdown.
+	let live = false;
+	const retitle = (ctx: { hasUI: boolean; cwd: string; ui: { setTitle(title: string): void } }) => {
+		if (!live || !ctx.hasUI) return;
+		const name = pi.getSessionName?.()?.trim();
+		const title = name ? `${NAME} - ${name} - ${basename(ctx.cwd)}` : NAME;
+		if (title === lastTitle) return; // agent_start fires every turn; write only on change
+		lastTitle = title;
+		ctx.ui.setTitle(title);
+	};
+	pi.on("session_info_changed", (_event, ctx) => retitle(ctx));
+	pi.on("agent_start", (_event, ctx) => retitle(ctx));
+	pi.on("session_shutdown", () => {
+		live = false;
+	});
+
 	pi.on("session_start", (_event, ctx) => {
+		// pi's own write lands after this handler, so only the deferred write
+		// sticks; a new session may carry a name (resume), so forget the last.
+		lastTitle = undefined;
+		live = true;
+		setTimeout(() => retitle(ctx), 0).unref?.();
 		ctx.ui.setHiddenThinkingLabel(THINKING_LABEL);
 		installPromptMarker(ctx as unknown as { hasUI: boolean; mode: string; ui: BrandingEditorUI });
 		// Soft drift guard: warn once at startup when the hosting pi is outside
@@ -337,7 +369,6 @@ export default function brandingExtension(pi: ExtensionAPI) {
 			? collectStartupSections(ctx.cwd, home, join(dirname(fileURLToPath(import.meta.url)), "..", "..", "themes"), agentDir)
 			: undefined;
 
-		ctx.ui.setTitle(NAME);
 		ctx.ui.setHeader((tui: unknown, theme: unknown) => {
 			const paint = safeThemePaint(theme);
 			// Width-memoized (pi-tui renders every mounted component every frame);