one-code-extension 0.1.0

package/extensions/bash/index.ts

@@ -0,0 +1,149 @@
+/**
+ * bash extension — Claude Code's Bash `run_in_background` on top of pi's own
+ * bash tool.
+ *
+ * Registering a tool named `bash` overrides the built-in (findings §2), which
+ * 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 follow-up system
+ * notification. 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 { createBashToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { generateTaskId, TASK_REGISTER_CHANNEL } from "../background/registry.ts";
+import { type BashFinishSummary, startBackgroundBash, tailCap } from "./background.ts";
+import { systemNotification } from "../lib/notifications.ts";
+import { perCwd } from "../lib/per-cwd.ts";
+import { ccWrapBuiltinRenderers, linesComponent, resultLines } from "../lib/tui-render.ts";
+
+const NOTIFY_OUTPUT_CAP = 30_000;
+
+const BashParams = Type.Object({
+	command: Type.String({ description: "Bash command to execute" }),
+	timeout: Type.Optional(
+		Type.Number({ description: "Timeout in seconds (optional; also applies to background runs)" }),
+	),
+	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",
+		}),
+	),
+	description: Type.Optional(
+		Type.String({ description: "5-10 word description of what the command does (shown in notifications)" }),
+	),
+});
+
+export default function bashExtension(pi: ExtensionAPI) {
+	// 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);
+
+	const notify = (text: string, details: Record<string, unknown>) => {
+		pi.sendMessage(
+			{ customType: "task-notification", content: [{ type: "text", text }], display: true, details },
+			{ deliverAs: "followUp", triggerTurn: true },
+		);
+	};
+
+	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({
+		name: "bash",
+		label: base.label,
+		description: `${base.description} 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.`,
+		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 = `Running in background (task ${details.taskId}${details.logPath ? ` · log: ${details.logPath}` : ""})`;
+						return linesComponent(() => resultLines(theme as any, line, options.expanded, false));
+					}
+					return wrapped.renderResult(result, options, theme, context);
+				}) as ToolDefinition<typeof BashParams>["renderResult"],
+			};
+		})(),
+		parameters: BashParams,
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			if (!params.run_in_background) {
+				return foreground(ctx.cwd).execute(
+					toolCallId,
+					{ command: params.command, timeout: params.timeout },
+					signal,
+					onUpdate,
+					ctx,
+				);
+			}
+
+			const id = generateTaskId();
+			const logPath = taskLogPath(ctx, id);
+			const description = params.description || params.command.slice(0, 80);
+			const task = startBackgroundBash({
+				id,
+				command: params.command,
+				description,
+				cwd: ctx.cwd,
+				timeoutSeconds: params.timeout,
+				logPath,
+				onFinished: (finishedTask, summary) => {
+					notify(
+						systemNotification(`Background bash ${id} (${description}) ${finishLine(summary, params.timeout)}.\n\n${tailCap(summary.output, NOTIFY_OUTPUT_CAP)}`),
+						{ 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 },
+			};
+		},
+	});
+}

package/extensions/branding/assistant-marker.ts

@@ -0,0 +1,53 @@
+/**
+ * Assistant message marker (pure) — Claude Code prefixes each block of assistant
+ * prose with a "●" bullet in the gutter. pi renders assistant text through its
+ * own markdown component, and the only hook it exposes for that text is a
+ * *text-level* markdown transformer (`registerMarkdownTransformer`) — there is no
+ * lines-level access to paint a true gutter, the way `prompt-marker.ts` can for
+ * the input editor. So the marker rides as a `● ` prefix on the message's first
+ * line instead.
+ *
+ * A raw prefix would corrupt any message whose first line is a markdown block
+ * that must start at column 0 — a heading, a list item, a block quote, a fenced
+ * code block, a table row, a horizontal rule, or raw HTML. Prepending `● ` to
+ * those turns them into plain paragraphs (`● ## Title`, `● - item`), losing the
+ * formatting. Those first lines are therefore left untouched: a missing marker
+ * is a far lesser evil than mangled output, and assistant turns here almost
+ * always open with a sentence (the system prompt asks for a preamble line before
+ * tools), so the guard rarely fires.
+ *
+ * Kept here as a pure string→string function so it is unit-testable without a
+ * terminal; `index.ts` only wires it to `pi.registerMarkdownTransformer`.
+ */
+
+/** The bullet that marks the start of a block of assistant prose. */
+export const ASSISTANT_MARKER = "●";
+
+/**
+ * First-line shapes a `● ` prefix would corrupt — markdown blocks that must begin
+ * at column 0. Matched against the first line only; the string is assumed already
+ * trimmed of leading whitespace (pi trims assistant text before rendering).
+ */
+const BLOCK_START = [
+	/^#{1,6}\s/, // ATX heading
+	/^[-*+]\s/, // unordered list item
+	/^\d+[.)]\s/, // ordered list item
+	/^>/, // block quote
+	/^(?:```|~~~)/, // fenced code
+	/^\|/, // table row
+	/^(?:-{3,}|\*{3,}|_{3,})\s*$/, // horizontal rule
+	/^</, // raw HTML / tag
+];
+
+/**
+ * Prefix assistant `markdown` with the `● ` marker, unless its first line is a
+ * markdown block the prefix would corrupt (see `BLOCK_START`). Returns the input
+ * unchanged for empty text or a corrupting first line, and never throws.
+ */
+export function markAssistantMarkdown(markdown: string, marker: string = ASSISTANT_MARKER): string {
+	if (!markdown) return markdown;
+	const newline = markdown.indexOf("\n");
+	const firstLine = newline === -1 ? markdown : markdown.slice(0, newline);
+	if (BLOCK_START.some((pattern) => pattern.test(firstLine))) return markdown;
+	return `${marker} ${markdown}`;
+}

package/extensions/branding/index.ts

@@ -0,0 +1,366 @@
+/**
+ * branding extension — replaces pi's startup header.
+ *
+ * pi's own banner ("pi v0.83.0 … Ask it how to use or extend Pi") comes from its
+ * `piConfig`, which resolves from pi's *own* installed package.json and so cannot
+ * be changed by a dependent package. But `ctx.ui.setHeader()` replaces the header
+ * component outright, which gets us the same result without a fork.
+ *
+ * A pi-tui `Component` is small enough to implement inline — `render(width)` plus
+ * a no-op `invalidate()` (we have no cached layout to drop) — so this needs no
+ * new dependency on pi-tui.
+ *
+ * Set `CC_NO_BANNER=1` to keep pi's original header.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { 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";
+import {
+	PERMISSION_STATUS_CHANNEL,
+	permissionModeDisplay,
+	type PermissionStatus,
+	shortModelName,
+} from "../permissions/modes.ts";
+import { SUBAGENT_STATUS_CHANNEL, type SubagentStatus } from "../subagents/model-select.ts";
+import {
+	collectStartupSections,
+	quietStartupEnabled,
+	shouldDefaultFlushOutputPad,
+	shouldDefaultHideThinking,
+	type StartupSection,
+} from "./startup.ts";
+import { safeThemePaint, truncateLine } from "../lib/tui-render.ts";
+import { markAssistantMarkdown } from "./assistant-marker.ts";
+import { PROMPT_PADDING, PromptEditor } from "./prompt-editor.ts";
+
+export { truncateLine };
+
+const NAME = "One Code";
+/** Tagline under the wordmark — the "any model" positioning, matching the README. */
+const SUBTITLE = "the Claude Code experience, on any model";
+
+export interface BannerInput {
+	version: string;
+	model?: string;
+	cwd: string;
+	mode: string;
+	/** Effective subagent/workflow default with its selection source. */
+	subagents?: string;
+	/** Compact resource sections, shown when pi's own listing is silenced. */
+	sections?: StartupSection[];
+}
+
+/**
+ * "ONE CODE" wordmark (figlet "ANSI Shadow"), ONE and CODE on a single line.
+ * Rendered as its own block above the text column. Rows are normalised to a
+ * single width at load, so a trailing-space trim in the source can never
+ * misalign the block. Below WORDMARK_WIDTH a compact "One Code" title replaces
+ * it, so a narrow pane never shows sheared glyphs.
+ */
+const WORDMARK_RAW = [
+	" ██████╗ ███╗   ██╗███████╗   ██████╗ ██████╗ ██████╗ ███████╗",
+	"██╔═══██╗████╗  ██║██╔════╝  ██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+	"██║   ██║██╔██╗ ██║█████╗    ██║     ██║   ██║██║  ██║█████╗",
+	"██║   ██║██║╚██╗██║██╔══╝    ██║     ██║   ██║██║  ██║██╔══╝",
+	"╚██████╔╝██║ ╚████║███████╗  ╚██████╗╚██████╔╝██████╔╝███████╗",
+	" ╚═════╝ ╚═╝  ╚═══╝╚══════╝   ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
+];
+/** Display width every wordmark row is padded to (the widest raw row). */
+export const WORDMARK_WIDTH = Math.max(...WORDMARK_RAW.map((r) => [...r].length));
+export const WORDMARK = WORDMARK_RAW.map((r) => r + " ".repeat(WORDMARK_WIDTH - [...r].length));
+
+/**
+ * One curated hint line, not a keymap dump: only the controls someone cannot
+ * discover on their own — the dials this package renames or hides state behind
+ * (effort, permission mode, collapsed thinking/output) plus the two input
+ * prefixes and the opt-in keyword nobody could guess. Everything else lives in
+ * pi's own /hotkeys listing, which the line points at.
+ */
+const HINTS: [key: string, what: string][] = [
+	// First so it survives narrow terminals: the pointer to everything else.
+	["/hotkeys", "all keys"],
+	// pi calls this dial "thinking" and reserves shift+tab for it; we present
+	// 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+t", "thinking"],
+	["ctrl+o", "expand output"],
+	["/", "commands"],
+	["!", "bash"],
+	// A keyword rather than a binding — an opt-in feature nobody knows the
+	// word for is invisible.
+	["ultracode", "max effort"],
+];
+
+/**
+ * Keep only whole leading items that fit the budget (measured unpainted, so
+ * ANSI codes don't count), rather than letting truncateLine cut mid-word.
+ * Always keeps at least one item; truncateLine remains the backstop.
+ */
+export function fitItems<T>(items: T[], plainLength: (item: T) => number, budget: number | undefined, sepLength = 3): T[] {
+	if (budget === undefined) return items;
+	const kept: T[] = [];
+	let used = 0;
+	for (const item of items) {
+		const extra = (kept.length ? sepLength : 0) + plainLength(item);
+		if (kept.length > 0 && used + extra > budget) break;
+		kept.push(item);
+		used += extra;
+	}
+	return kept;
+}
+
+/**
+ * Sections compressed to one line: context files and themes are few and short,
+ * so their names carry information; skills/workflows lists are long and get
+ * truncated into noise, so past three items they collapse to a count.
+ */
+export function sectionSummary(sections: StartupSection[], paint: (color: string, text: string) => string): string {
+	return sections
+		.filter((s) => s.items.length > 0)
+		.map((s) =>
+			s.items.length <= 3
+				? `${paint("muted", s.label)} ${paint("dim", s.items.join(", "))}`
+				: `${paint("muted", s.label)} ${paint("dim", String(s.items.length))}`,
+		)
+		.join(paint("muted", " · "));
+}
+
+/**
+ * Banner layout: the wordmark block, then a one-space-indented text column
+ * (tagline + version, context, hints, sections). Kept pure so the layout is
+ * unit-testable without a terminal. Below WORDMARK_WIDTH the wordmark is
+ * replaced by a compact "One Code" title, so a narrow pane never shows sheared
+ * fragments of the art.
+ */
+export function bannerLines(
+	input: BannerInput,
+	paint: (color: string, text: string) => string,
+	width?: number,
+): string[] {
+	const indent = " ";
+	const budget = width === undefined ? undefined : width - indent.length;
+
+	const subtitle = `${paint("dim", SUBTITLE)}${paint("muted", " · ")}${paint("dim", `v${input.version}`)}`;
+	const context = [
+		input.model ? `${paint("muted", "model")} ${input.model}` : undefined,
+		`${paint("muted", "mode")} ${input.mode}`,
+		input.subagents ? `${paint("muted", "subagents")} ${input.subagents}` : undefined,
+	]
+		.filter(Boolean)
+		.join(paint("muted", " · "));
+	// Narrow terminals drop whole trailing hints (the /hotkeys pointer is
+	// first, so it always survives) instead of cutting one mid-word.
+	const hints = fitItems(HINTS, ([key, what]) => key.length + 1 + what.length, budget)
+		.map(([key, what]) => `${paint("accent", key)} ${paint("muted", what)}`)
+		.join(paint("muted", " · "));
+	const sections = sectionSummary(input.sections ?? [], paint);
+
+	const textColumn = [subtitle, context, hints, ...(sections ? [sections] : [])].map((line) => `${indent}${line}`);
+
+	// The wordmark is a fixed-width block; if it cannot fit, show a text title
+	// rather than let truncateLine shear the glyphs mid-row.
+	const head =
+		width !== undefined && width < WORDMARK_WIDTH ? [paint("accent", NAME)] : WORDMARK.map((row) => paint("accent", row));
+
+	const assembled = [...head, ...textColumn];
+	return width === undefined ? assembled : assembled.map((line) => truncateLine(line, width));
+}
+
+/** Collapsed-thinking placeholder — pi paints it in thinkingText + italic. */
+const THINKING_LABEL = "✻ Thinking… (ctrl+t to expand)";
+
+/** Claude Code-style input marker, painted in the editor's left gutter. A heavy
+ * chevron (U+276F), one column wide so the two-column gutter still aligns. */
+const PROMPT_GLYPH = "❯";
+
+/**
+ * `pi.registerMarkdownTransformer` typed locally: the runtime (pi ≥ 0.84) exposes
+ * it, but the pinned 0.83 type declarations do not, so we cast and feature-detect
+ * — the same "older pi may lack the hook" handling as the prompt marker.
+ */
+interface MarkdownTransformerHost {
+	registerMarkdownTransformer?: (
+		transformer: (
+			markdown: string,
+			context: { messageType: "user" | "assistant" | "assistant-thinking"; isStreaming: boolean; availableWidth: number },
+		) => string,
+	) => void;
+}
+
+/** The slice of the UI context the prompt marker needs (older pi may lack the hook). */
+interface BrandingEditorUI {
+	setEditorComponent?: (factory: (tui: unknown, theme: unknown, keybindings: unknown) => unknown) => void;
+	theme?: unknown;
+}
+
+/**
+ * Replace the core input editor with one that paints a "›" prompt marker, the
+ * way Claude Code does. TUI-only (print/rpc have no editor), skipped when pi is
+ * too old to expose the hook, and disableable with CC_NO_INPUT_MARKER=1 in case
+ * a pi-tui render change ever makes the marker misplace (cosmetic only — typing
+ * is never affected; see prompt-marker.ts).
+ */
+function installPromptMarker(ctx: { hasUI: boolean; mode: string; ui: BrandingEditorUI }): void {
+	if (process.env.CC_NO_INPUT_MARKER === "1") return;
+	if (!ctx.hasUI || ctx.mode !== "tui") return;
+	const ui = ctx.ui;
+	if (typeof ui.setEditorComponent !== "function") return;
+	// The marker follows live theme changes because it is re-read per render.
+	const renderMarker = () => {
+		// Bold makes the chevron read heavier than the input text beside it.
+		return `\x1b[1m${safeThemePaint(ui.theme)("accent", PROMPT_GLYPH)}\x1b[0m${" ".repeat(PROMPT_PADDING - 1)}`;
+	};
+	ui.setEditorComponent((tui: unknown, theme: unknown, keybindings: unknown) => new PromptEditor(tui as never, theme as never, keybindings as never, renderMarker));
+}
+
+/**
+ * Default thinking blocks to collapsed, once, respecting any user choice.
+ * pi caches settings in memory at startup, so a write here lands from the
+ * *next* session; the current one keeps whatever the file said at launch
+ * (ctrl+t still works immediately and persists the user's own preference).
+ */
+function applyThinkingDefault(): void {
+	try {
+		const agentDir = getAgentDir();
+		const settingsPath = join(agentDir, "settings.json");
+		const raw = existsSync(settingsPath) ? readFileSync(settingsPath, "utf8") : undefined;
+		if (shouldDefaultHideThinking(raw)) {
+			SettingsManager.create(process.cwd(), agentDir).setHideThinkingBlock(true);
+		}
+	} catch {
+		// Presentation-only default — never let a settings hiccup break startup.
+	}
+}
+
+/**
+ * Default pi's output padding to 0 so the assistant "●" marker sits flush at
+ * column 0, aligned with the tool bullets (which render there). Only when the
+ * user hasn't set `outputPad` themselves; like the thinking default, pi caches
+ * settings at startup, so this lands from the *next* session (the current one
+ * keeps whatever pad it launched with). Skipped when the marker is disabled, so
+ * the two travel together.
+ */
+function applyOutputPadDefault(): void {
+	if (process.env.CC_NO_ASSISTANT_MARKER === "1") return;
+	try {
+		const agentDir = getAgentDir();
+		const settingsPath = join(agentDir, "settings.json");
+		const raw = existsSync(settingsPath) ? readFileSync(settingsPath, "utf8") : undefined;
+		if (shouldDefaultFlushOutputPad(raw)) {
+			SettingsManager.create(process.cwd(), agentDir).setOutputPad(0);
+		}
+	} catch {
+		// Presentation-only default — never let a settings hiccup break startup.
+	}
+}
+
+export default function brandingExtension(pi: ExtensionAPI) {
+	applyThinkingDefault();
+	applyOutputPadDefault();
+	// Mark each block of assistant prose with Claude Code's "●" bullet. Only
+	// assistant text is transformed (not thinking or user turns); the transformer
+	// runs in markdown rendering, so print/rpc output is untouched.
+	// CC_NO_ASSISTANT_MARKER=1 opts out, mirroring CC_NO_INPUT_MARKER.
+	const transformerHost = pi as unknown as MarkdownTransformerHost;
+	if (process.env.CC_NO_ASSISTANT_MARKER !== "1" && typeof transformerHost.registerMarkdownTransformer === "function") {
+		transformerHost.registerMarkdownTransformer((markdown, context) =>
+			context.messageType === "assistant" ? markAssistantMarkdown(markdown) : markdown,
+		);
+	}
+	// The label and prompt marker apply in every session; CC_NO_BANNER only
+	// disables the header.
+	pi.on("session_start", (_event, ctx) => {
+		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
+		// the range this release was tested against (see lib/pi-version.ts).
+		const versionWarning = piVersionWarning(PI_VERSION);
+		if (versionWarning) ctx.ui.notify(versionWarning, "warning");
+	});
+
+	if (process.env.CC_NO_BANNER === "1") return;
+
+	/**
+	 * Mode and classifier arrive over the bus from the permissions extension
+	 * (jiti isolates module state, so this cannot be a shared variable). The
+	 * banner re-renders on every update, so cycling modes or the classifier
+	 * pinning mid-session keeps the header truthful instead of frozen at
+	 * whatever was true at startup.
+	 */
+	let permissionStatus: PermissionStatus | undefined;
+	let subagentStatus: SubagentStatus | undefined;
+	let currentModelId: string | undefined;
+	let requestHeaderRender: (() => void) | undefined;
+	// The model line goes stale the same way the mode line did once the header
+	// re-renders live, so it follows ctrl+p / /model changes too.
+	pi.on("model_select", (event) => {
+		currentModelId = event.model?.id ?? currentModelId;
+		requestHeaderRender?.();
+	});
+	pi.events.on(PERMISSION_STATUS_CHANNEL, (data) => {
+		permissionStatus = data as PermissionStatus;
+		requestHeaderRender?.();
+	});
+	pi.events.on(SUBAGENT_STATUS_CHANNEL, (data) => {
+		subagentStatus = data as SubagentStatus;
+		requestHeaderRender?.();
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		// Only the TUI has a header to replace; rpc/print modes have no chrome.
+		if (!ctx.hasUI || ctx.mode !== "tui") return;
+
+		const version = process.env.CC_VERSION ?? "0.1.0";
+		currentModelId = ctx.model ? `${ctx.model.id}` : currentModelId;
+
+		// With pi's own listing silenced, the banner carries compact sections
+		// instead (minus the internal [Extensions] noise).
+		const home = os.homedir();
+		// Resolve pi's live agent dir (honours PI_CODING_AGENT_DIR) so an
+		// isolated one-code app reads its own settings/skills, never ~/.pi.
+		const agentDir = getAgentDir();
+		const sections = quietStartupEnabled(join(agentDir, "settings.json"))
+			? 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);
+			requestHeaderRender = () => {
+				(tui as { requestRender?: () => void } | undefined)?.requestRender?.();
+			};
+			return {
+				// Rendered per paint rather than precomputed, so the mode line
+				// follows ctrl+q cycles and the classifier pinning.
+				render: (width: number) => [
+					"",
+					...bannerLines(
+						{
+							version,
+							model: currentModelId,
+							cwd: ctx.cwd,
+							mode: permissionModeDisplay(permissionStatus ?? { mode: "default", paused: false }),
+							subagents: subagentStatus?.model
+								? `${shortModelName(subagentStatus.model)}${subagentStatus.via ? ` (${subagentStatus.via})` : ""}`
+								: undefined,
+							sections,
+						},
+						paint,
+						width,
+					),
+					"",
+				],
+				// Nothing is cached, so there is nothing to invalidate.
+				invalidate: () => {},
+			};
+		});
+	});
+}

package/extensions/branding/prompt-editor.ts

@@ -0,0 +1,42 @@
+/**
+ * PromptEditor — the core input editor with a Claude Code-style "❯" marker.
+ *
+ * pi's editor has no prompt marker and no option for one, but `CustomEditor` is
+ * the sanctioned base for a replacement (it already wires every app keybinding
+ * through handleInput, which we leave untouched). We only reserve a two-column
+ * left gutter and paint the marker into it — see prompt-marker.ts for why that
+ * is cursor-safe. Registered via `ctx.ui.setEditorComponent`; this file is thin
+ * wiring over the pure `applyPromptMarker`.
+ */
+
+import { CustomEditor } from "@earendil-works/pi-coding-agent";
+import { applyPromptMarker } from "./prompt-marker.ts";
+
+/** Width of the left gutter, and therefore the visible width the marker must fill. */
+export const PROMPT_PADDING = 2;
+
+type EditorArgs = ConstructorParameters<typeof CustomEditor>;
+
+export class PromptEditor extends CustomEditor {
+	/** Re-read per render so the marker follows live theme changes. */
+	#renderMarker: () => string;
+
+	constructor(tui: EditorArgs[0], theme: EditorArgs[1], keybindings: EditorArgs[2], renderMarker: () => string) {
+		super(tui, theme, keybindings, { paddingX: PROMPT_PADDING });
+		this.#renderMarker = renderMarker;
+	}
+
+	/**
+	 * Pin the gutter. On install pi copies the *default* editor's paddingX (0)
+	 * onto us, which would leave no room to paint into; keep it at our width so
+	 * the marker always has its gutter. A caller asking for a wider gutter still
+	 * gets at least ours.
+	 */
+	setPaddingX(padding: number): void {
+		super.setPaddingX(Math.max(PROMPT_PADDING, padding));
+	}
+
+	render(width: number): string[] {
+		return applyPromptMarker(super.render(width), PROMPT_PADDING, this.#renderMarker());
+	}
+}

package/extensions/branding/prompt-marker.ts

@@ -0,0 +1,29 @@
+/**
+ * Input prompt marker (pure) — Claude Code shows a "❯" at the start of the
+ * input line; pi's editor draws none. pi's editor renders as
+ * `[topBorder, ...contentLines, bottomBorder]`, and each content line begins
+ * with `paddingX` literal spaces (the left gutter). We overwrite exactly those
+ * gutter spaces on the first content line with a marker the caller has sized to
+ * `paddingX` visible columns. The visible cursor is drawn inside the text (and
+ * reported separately via getCursor), so painting into the always-blank gutter
+ * never shifts text or the cursor — the coupling can only ever go wrong
+ * cosmetically, never break typing.
+ */
+
+/**
+ * Return a copy of the editor's rendered lines with the first content line's
+ * left gutter replaced by `marker`. No-op (returns the input) when there is no
+ * content line yet or the first gutter is not the blank padding we expect — so
+ * an unexpected render shape degrades to "no marker" rather than corruption.
+ *
+ * `marker` must occupy exactly `paddingX` visible columns (e.g. "› " for 2).
+ */
+export function applyPromptMarker(lines: string[], paddingX: number, marker: string): string[] {
+	// index 0 is always the top border; the first content line is index 1.
+	if (paddingX <= 0 || lines.length < 2) return lines;
+	const first = lines[1];
+	if (first.slice(0, paddingX) !== " ".repeat(paddingX)) return lines;
+	const out = lines.slice();
+	out[1] = marker + first.slice(paddingX);
+	return out;
+}