one-code-extension 0.1.0

package/extensions/workflow/widget.ts

@@ -0,0 +1,56 @@
+/**
+ * Live progress panel for workflow runs, rendered with the plain string[]
+ * overload of ctx.ui.setWidget. Re-renders are debounced so a chatty fan-out
+ * doesn't thrash the TUI; the widget clears itself once no run is active.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { RunHandle, WorkflowRunManager } from "./run-manager.ts";
+
+const WIDGET_KEY = "workflow";
+const DEBOUNCE_MS = 250;
+const EVENT_TAIL = 4;
+
+export class WorkflowWidget {
+	private timer: ReturnType<typeof setTimeout> | undefined;
+
+	constructor(
+		private readonly manager: WorkflowRunManager,
+		private readonly getCtx: () => ExtensionContext | undefined,
+	) {}
+
+	attach(handle: RunHandle): void {
+		handle.on("progress", () => this.schedule());
+		handle.on("done", () => this.schedule());
+		this.schedule();
+	}
+
+	private schedule(): void {
+		if (this.timer) return;
+		this.timer = setTimeout(() => {
+			this.timer = undefined;
+			this.render();
+		}, DEBOUNCE_MS);
+		this.timer.unref?.();
+	}
+
+	private render(): void {
+		const ctx = this.getCtx();
+		if (!ctx?.hasUI) return;
+		const active = this.manager.list().filter((h) => h.status === "running");
+		if (active.length === 0) {
+			ctx.ui.setWidget(WIDGET_KEY, undefined);
+			return;
+		}
+		const lines: string[] = [];
+		for (const handle of active) {
+			const state = handle.state;
+			const phase = state?.currentPhase();
+			const stats = state ? `${state.agentCount()} agents · ${state.outputTokens()} out-tokens` : "starting…";
+			lines.push(`⚡ workflow ${handle.meta.name} (${handle.runId}) — ${phase ? `${phase} · ` : ""}${stats}`);
+			for (const event of handle.recentEvents.slice(-EVENT_TAIL)) lines.push(`   ${event}`);
+		}
+		lines.push("   /workflows to inspect · /workflows stop <runId> to stop");
+		ctx.ui.setWidget(WIDGET_KEY, lines);
+	}
+}

package/extensions/worktree/index.ts

@@ -0,0 +1,266 @@
+/**
+ * worktree extension — Claude Code's EnterWorktree/ExitWorktree.
+ *
+ * enter_worktree creates (or switches into) a git worktree under
+ * `.claude/worktrees/` and "moves" the session there. pi fixes a session's cwd
+ * at creation, so the move is enforced on the tool_call hook: bash commands
+ * are prefixed with `cd`, relative paths resolve against the worktree (see
+ * rewrite.ts), and an every-turn reminder keeps the model oriented. State
+ * rides in tool-result details so a resumed or branched session restores it.
+ */
+
+import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { restoreLatestDetails } from "../lib/branch-restore.ts";
+import { DEFER_CHANNEL } from "../lib/deferred.ts";
+import { REMINDER_CHANNEL } from "../lib/reminders.ts";
+import { rewriteToolInput, validateWorktreeName } from "./rewrite.ts";
+import { ccToolRenderers } from "../lib/tui-render.ts";
+
+const run = promisify(execFile);
+const REMINDER_KEY = "cc-worktree-session";
+const WORKTREE_TOOLS = new Set(["enter_worktree", "exit_worktree"]);
+
+interface WorktreeState {
+	path: string;
+	branch?: string;
+	baseCommit?: string;
+	createdByUs: boolean;
+	originalCwd: string;
+}
+
+interface WorktreeDetails {
+	/** null = session exited the worktree; undefined = tool did not change state. */
+	worktreeState?: WorktreeState | null;
+}
+
+async function git(args: string[], cwd: string): Promise<string> {
+	const { stdout } = await run("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+	return stdout.trim();
+}
+
+async function listWorktreePaths(cwd: string): Promise<string[]> {
+	const out = await git(["worktree", "list", "--porcelain"], cwd);
+	return out
+		.split("\n")
+		.filter((line) => line.startsWith("worktree "))
+		.map((line) => line.slice("worktree ".length));
+}
+
+export default function worktreeExtension(pi: ExtensionAPI) {
+	let state: WorktreeState | undefined;
+
+	const reminderFor = (s: WorktreeState) =>
+		`Worktree session active: you are working in the git worktree at ${s.path}` +
+		`${s.branch ? ` (branch ${s.branch})` : ""}, not in ${s.originalCwd}. ` +
+		"Relative paths and bash commands already run there. Use exit_worktree to leave when the user asks.";
+
+	const applyState = (next: WorktreeState | undefined) => {
+		state = next;
+		if (next) {
+			pi.events.emit(REMINDER_CHANNEL, { text: reminderFor(next), scope: "every-turn", key: REMINDER_KEY });
+		} else {
+			pi.events.emit(REMINDER_CHANNEL, { key: REMINDER_KEY, remove: true });
+		}
+	};
+
+	const reconstructState = (ctx: ExtensionContext) => {
+		const details = restoreLatestDetails<WorktreeDetails>(ctx.sessionManager.getBranch(), WORKTREE_TOOLS, (d) => d?.worktreeState !== undefined);
+		let restored = details?.worktreeState ?? undefined;
+		if (restored && !existsSync(restored.path)) restored = undefined;
+		applyState(restored);
+	};
+
+	pi.on("session_start", (_event, ctx) => reconstructState(ctx));
+	pi.on("session_tree", (_event, ctx) => reconstructState(ctx));
+
+	pi.on("tool_call", (event) => {
+		if (!state) return;
+		if (["enter_worktree", "exit_worktree", "subagent", "send_message", "workflow"].includes(event.toolName)) return;
+		rewriteToolInput(event.toolName, event.input as Record<string, unknown>, state.path);
+	});
+
+	pi.registerTool({
+		name: "enter_worktree",
+		label: "Enter Worktree",
+		...ccToolRenderers("Enter Worktree"),
+		description:
+			"Create an isolated git worktree under .claude/worktrees/ (branched from the current HEAD) and switch this session into it — subsequent commands and relative paths run there. Use ONLY when the user or project instructions explicitly ask for a worktree. Pass `name` to name the new worktree, or `path` to switch into an existing worktree instead (mutually exclusive). Leave with exit_worktree.",
+		parameters: Type.Object({
+			name: Type.Optional(
+				Type.String({ description: "Name for a new worktree (segments of letters/digits/._-, max 64 chars). Random if omitted" }),
+			),
+			path: Type.Optional(Type.String({ description: "Existing worktree (from `git worktree list`) to switch into instead of creating one" })),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const fail = (text: string) => ({ content: [{ type: "text" as const, text }], details: {} as WorktreeDetails, isError: true });
+
+			if (params.name && params.path) return fail("Pass either `name` or `path`, not both.");
+			// An empty `path` string is falsy, so without this it would fall through
+			// to *creating* a new worktree instead of reporting the bad argument —
+			// the mirror of the empty-`name` case, which is already rejected below.
+			if (params.path !== undefined && params.path.length === 0) {
+				return fail("`path` was empty — pass an existing worktree path from `git worktree list`, or omit `path` to create a new worktree.");
+			}
+
+			let repoRoot: string;
+			try {
+				repoRoot = await git(["rev-parse", "--show-toplevel"], ctx.cwd);
+			} catch {
+				return fail("enter_worktree needs a git repository; this directory is not one.");
+			}
+
+			if (params.path) {
+				const known = await listWorktreePaths(ctx.cwd);
+				const target = known.find((p) => p === params.path);
+				if (!target) return fail(`${params.path} is not a worktree of this repository. Known worktrees:\n${known.join("\n")}`);
+				const next: WorktreeState = { path: target, createdByUs: false, originalCwd: ctx.cwd };
+				applyState(next);
+				return {
+					content: [{ type: "text", text: `Switched into existing worktree ${target}. All work now happens there; exit_worktree returns to ${ctx.cwd}.` }],
+					details: { worktreeState: next } satisfies WorktreeDetails,
+				};
+			}
+
+			// Any active worktree session blocks creating another — not just ones we
+			// created. A session entered via `path` has createdByUs:false, and
+			// without gating on `state` alone a create-new call silently abandoned it.
+			if (state) {
+				return fail(`Already in a worktree session (${state.path}). exit_worktree first, or switch with \`path\` to another worktree.`);
+			}
+
+			const name = params.name ?? `wt-${randomBytes(3).toString("hex")}`;
+			const nameError = validateWorktreeName(name);
+			if (nameError) return fail(`Invalid worktree name "${name}": ${nameError}`);
+
+			const worktreesDir = join(repoRoot, ".claude", "worktrees");
+			mkdirSync(worktreesDir, { recursive: true });
+			// Self-ignoring directory: worktrees never show up as untracked files.
+			const ignorePath = join(worktreesDir, ".gitignore");
+			if (!existsSync(ignorePath)) writeFileSync(ignorePath, "*\n");
+
+			const path = join(worktreesDir, name);
+			if (existsSync(path)) return fail(`Worktree ${path} already exists — pass it as \`path\` to switch into it.`);
+
+			const branch = name.replace(/\//g, "-");
+			let baseCommit: string;
+			try {
+				baseCommit = await git(["rev-parse", "HEAD"], ctx.cwd);
+				await git(["worktree", "add", "-b", branch, path, "HEAD"], repoRoot);
+			} catch (error) {
+				return fail(`Could not create worktree: ${(error as Error).message}`);
+			}
+
+			const next: WorktreeState = { path, branch, baseCommit, createdByUs: true, originalCwd: ctx.cwd };
+			applyState(next);
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Created worktree ${path} on branch ${branch} (from HEAD ${baseCommit.slice(0, 8)}). All commands and relative paths now run there; exit_worktree returns to ${ctx.cwd}.`,
+					},
+				],
+				details: { worktreeState: next } satisfies WorktreeDetails,
+			};
+		},
+	});
+
+	pi.registerTool({
+		name: "exit_worktree",
+		label: "Exit Worktree",
+		...ccToolRenderers("Exit Worktree"),
+		description:
+			'End the worktree session started by enter_worktree and return to the original directory. action: "keep" leaves the worktree and branch on disk; "remove" deletes both — refused (listing the changes) if there are uncommitted files or commits not on the original branch, unless discard_changes is true. No-op when no worktree session is active.',
+		parameters: Type.Object({
+			action: StringEnum(["keep", "remove"] as const, { description: '"keep" preserves the worktree on disk; "remove" deletes it and its branch' }),
+			discard_changes: Type.Optional(Type.Boolean({ description: "Required true to remove a worktree with uncommitted files or unmerged commits" })),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			if (!state) {
+				return {
+					content: [{ type: "text", text: "No worktree session is active; nothing to exit." }],
+					details: {} satisfies WorktreeDetails,
+				};
+			}
+			const current = state;
+
+			if (params.action === "keep") {
+				applyState(undefined);
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Left worktree session; back in ${current.originalCwd}. The worktree remains at ${current.path}${current.branch ? ` (branch ${current.branch})` : ""} — re-enter it with enter_worktree {path}.`,
+						},
+					],
+					details: { worktreeState: null } satisfies WorktreeDetails,
+				};
+			}
+
+			if (!current.createdByUs) {
+				return {
+					content: [
+						{ type: "text", text: `This worktree (${current.path}) was not created by enter_worktree in this session — exit with action: "keep" and remove it manually if intended.` },
+					],
+					details: {} satisfies WorktreeDetails,
+					isError: true,
+				};
+			}
+
+			if (!params.discard_changes) {
+				const blockers: string[] = [];
+				try {
+					const dirty = await git(["status", "--porcelain"], current.path);
+					if (dirty) blockers.push(`Uncommitted changes:\n${dirty}`);
+					if (current.baseCommit && current.branch) {
+						const ahead = await git(["rev-list", "--count", `${current.baseCommit}..${current.branch}`], current.path);
+						if (ahead !== "0") blockers.push(`${ahead} commit(s) on ${current.branch} not on the original branch.`);
+					}
+				} catch {
+					blockers.push("Could not verify the worktree is clean.");
+				}
+				if (blockers.length > 0) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: `Refusing to remove ${current.path}:\n\n${blockers.join("\n\n")}\n\nConfirm with the user, then re-invoke with discard_changes: true — or exit with action: "keep".`,
+							},
+						],
+						details: {} satisfies WorktreeDetails,
+						isError: true,
+					};
+				}
+			}
+
+			try {
+				await git(["worktree", "remove", "--force", current.path], current.originalCwd);
+				if (current.branch) await git(["branch", "-D", current.branch], current.originalCwd);
+			} catch (error) {
+				return {
+					content: [{ type: "text", text: `Could not remove the worktree: ${(error as Error).message}` }],
+					details: {} satisfies WorktreeDetails,
+					isError: true,
+				};
+			}
+			applyState(undefined);
+			return {
+				content: [{ type: "text", text: `Removed worktree ${current.path}${current.branch ? ` and branch ${current.branch}` : ""}; back in ${current.originalCwd}.` }],
+				details: { worktreeState: null } satisfies WorktreeDetails,
+			};
+		},
+	});
+
+	for (const [name, keywords] of Object.entries({
+		enter_worktree: ["worktree", "isolate", "branch", "checkout"],
+		exit_worktree: ["worktree", "leave", "return", "cleanup"],
+	})) {
+		pi.events.emit(DEFER_CHANNEL, { name, keywords });
+	}
+}

package/extensions/worktree/rewrite.ts

@@ -0,0 +1,59 @@
+/**
+ * Worktree-session input rewriting (pure).
+ *
+ * pi binds every built-in tool to the cwd captured at session creation, so a
+ * live session cannot truly change directory. While a worktree session is
+ * active we instead rewrite tool inputs on the tool_call hook: bash commands
+ * get a `cd` prefix, and relative paths resolve against the worktree. Absolute
+ * paths are left alone — pointing back at the original checkout stays possible
+ * and explicit.
+ */
+
+import { isAbsolute, resolve } from "node:path";
+
+/** Tools whose `path` argument is relative to the session cwd. */
+const PATH_TOOLS = new Set(["read", "edit", "write", "notebook_edit", "grep", "find", "ls", "lsp_diagnostics"]);
+/** Of those, the ones where a missing path means "the cwd itself". */
+const DEFAULTS_TO_CWD = new Set(["grep", "find", "ls"]);
+
+export function shellQuote(path: string): string {
+	return `'${path.replace(/'/g, "'\\''")}'`;
+}
+
+/**
+ * Key under which a worktree-rewritten bash call preserves the model's original
+ * (pre-`cd`-wrapper) command. The permission matcher reads it so allow/ask/deny
+ * rules are evaluated against what the model actually asked for, not the
+ * `cd '<wt>' && (…)` wrapper (which starts with `cd` and matches no Bash rule).
+ * The classifier and safety floor still see the wrapped `input.command`, whose
+ * `cd` makes containment resolve inside the worktree — see docs/decisions/worktree.md.
+ */
+export const ORIGINAL_COMMAND_KEY = "__ccOriginalCommand";
+
+/** Mutates `input` in place so the call runs inside the worktree. */
+export function rewriteToolInput(toolName: string, input: Record<string, unknown>, worktreePath: string): void {
+	if (toolName === "bash") {
+		if (typeof input.command === "string") {
+			input[ORIGINAL_COMMAND_KEY] = input.command;
+			input.command = `cd ${shellQuote(worktreePath)} && (${input.command}\n)`;
+		}
+		return;
+	}
+	if (!PATH_TOOLS.has(toolName)) return;
+
+	if (typeof input.path === "string" && input.path.length > 0) {
+		if (!isAbsolute(input.path)) input.path = resolve(worktreePath, input.path);
+	} else if (DEFAULTS_TO_CWD.has(toolName)) {
+		input.path = worktreePath;
+	}
+}
+
+/** Validates an EnterWorktree name: /-separated segments of [A-Za-z0-9._-], ≤64 chars total. */
+export function validateWorktreeName(name: string): string | undefined {
+	if (name.length === 0 || name.length > 64) return "name must be 1-64 characters";
+	if (!/^[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)*$/.test(name)) {
+		return "each /-separated segment may contain only letters, digits, dots, underscores, and dashes";
+	}
+	if (name.split("/").some((seg) => seg === "." || seg === "..")) return "segments may not be . or ..";
+	return undefined;
+}

package/package.json

@@ -0,0 +1,101 @@
+{
+	"name": "one-code-extension",
+	"version": "0.1.0",
+	"description": "One Code as a pi package \u2014 the Claude Code experience on your own pi install: ported system prompt, Claude-Code-format permissions, .claude/ compatibility, ToolSearch-style deferred tools, and system-reminder steering. For the bundled app, install `one-code` instead.",
+	"keywords": [
+		"pi",
+		"pi-package",
+		"pi-extension",
+		"claude-code",
+		"coding-agent",
+		"mcp",
+		"agent"
+	],
+	"license": "MIT",
+	"engines": {
+		"node": ">=22.19"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/IsuruMaduranga/one-code.git"
+	},
+	"homepage": "https://github.com/IsuruMaduranga/one-code#readme",
+	"bugs": {
+		"url": "https://github.com/IsuruMaduranga/one-code/issues"
+	},
+	"type": "module",
+	"pi": {
+		"extensions": [
+			"extensions/branding/index.ts",
+			"extensions/claude-compat/index.ts",
+			"extensions/system-reminder/index.ts",
+			"extensions/claude-context/index.ts",
+			"extensions/hooks/index.ts",
+			"extensions/tool-search/index.ts",
+			"extensions/search-tools/index.ts",
+			"extensions/tool-style/index.ts",
+			"extensions/plugins/index.ts",
+			"extensions/worktree/index.ts",
+			"extensions/file-tracker/index.ts",
+			"extensions/memory/index.ts",
+			"extensions/permissions/index.ts",
+			"extensions/ask-user/index.ts",
+			"extensions/skill/index.ts",
+			"extensions/background/index.ts",
+			"extensions/bash/index.ts",
+			"extensions/subagents/index.ts",
+			"extensions/workflow/index.ts",
+			"extensions/effort/index.ts",
+			"extensions/exit/index.ts",
+			"extensions/todo/index.ts",
+			"extensions/tasks/index.ts",
+			"extensions/plan-mode/index.ts",
+			"extensions/notebook/index.ts",
+			"extensions/web/index.ts",
+			"extensions/web-fetch/index.ts",
+			"extensions/lsp/index.ts",
+			"extensions/mcp/index.ts",
+			"extensions/context-management/index.ts",
+			"extensions/compaction/index.ts",
+			"extensions/system-prompt/index.ts"
+		],
+		"themes": [
+			"./themes"
+		]
+	},
+	"files": [
+		"extensions/",
+		"agents/",
+		"themes/",
+		"types/",
+		"README.md",
+		"LICENSE",
+		"docs/decisions.md",
+		"docs/decisions/"
+	],
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.30.0",
+		"@mozilla/readability": "^0.6.0",
+		"acorn": "^8.18.0",
+		"linkedom": "^0.18.13",
+		"pi-web-search": "^1.3.1",
+		"turndown": "^7.2.4",
+		"typebox": "^1.3.7"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-agent-core": "^0.84.1",
+		"@earendil-works/pi-ai": "^0.84.1",
+		"@earendil-works/pi-coding-agent": "^0.84.1",
+		"@types/node": "^26.1.2",
+		"@types/turndown": "^5.0.6",
+		"typescript": "^5.6.0",
+		"vitest": "^2.1.0"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": ">=0.83.0"
+	}
+}

package/themes/one-code-light.json

@@ -0,0 +1,76 @@
+{
+  "$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "one-code-light",
+  "vars": {
+    "clay": "#c05f38",
+    "clayDeep": "#9c4a29",
+    "surface": "#f0ebe5",
+    "surfaceRaised": "#e4ddd4",
+    "toolIdle": "#f2eee9",
+    "toolOk": "#e8f0e4",
+    "toolBad": "#f7e6e4",
+    "gray": 240,
+    "grayDim": 245,
+    "green": "#4f7a3c",
+    "red": "#b8342c",
+    "amber": "#9a6b1f",
+    "blue": "#33608c",
+    "cyan": "#2f6f72",
+    "violet": "#7a4f86"
+  },
+  "colors": {
+    "accent": "clay",
+    "border": "gray",
+    "borderAccent": "clay",
+    "borderMuted": "grayDim",
+    "success": "green",
+    "error": "red",
+    "warning": "amber",
+    "muted": "gray",
+    "dim": "grayDim",
+    "text": "",
+    "thinkingText": "grayDim",
+    "selectedBg": "surface",
+    "scrollbarThumb": "surfaceRaised",
+    "userMessageBg": "surface",
+    "userMessageText": "",
+    "customMessageBg": "surface",
+    "customMessageText": "",
+    "customMessageLabel": "clay",
+    "toolPendingBg": "",
+    "toolSuccessBg": "",
+    "toolErrorBg": "toolBad",
+    "toolTitle": "clay",
+    "toolOutput": "",
+    "mdHeading": "clay",
+    "mdLink": "blue",
+    "mdLinkUrl": "gray",
+    "mdCode": "cyan",
+    "mdCodeBlock": "",
+    "mdCodeBlockBorder": "grayDim",
+    "mdQuote": "gray",
+    "mdQuoteBorder": "grayDim",
+    "mdHr": "grayDim",
+    "mdListBullet": "clay",
+    "toolDiffAdded": "green",
+    "toolDiffRemoved": "red",
+    "toolDiffContext": "gray",
+    "syntaxComment": "grayDim",
+    "syntaxKeyword": "clay",
+    "syntaxFunction": "blue",
+    "syntaxVariable": "amber",
+    "syntaxString": "green",
+    "syntaxNumber": "violet",
+    "syntaxType": "cyan",
+    "syntaxOperator": "clayDeep",
+    "syntaxPunctuation": "gray",
+    "thinkingOff": "grayDim",
+    "thinkingMinimal": "gray",
+    "thinkingLow": "cyan",
+    "thinkingMedium": "blue",
+    "thinkingHigh": "clay",
+    "thinkingXhigh": "red",
+    "thinkingMax": "violet",
+    "bashMode": "amber"
+  }
+}

package/themes/one-code.json

@@ -0,0 +1,76 @@
+{
+  "$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "one-code",
+  "vars": {
+    "clay": "#d97757",
+    "clayDeep": "#b8623f",
+    "surface": "#2a2725",
+    "surfaceRaised": "#333029",
+    "toolIdle": "#26231f",
+    "toolOk": "#1f2a20",
+    "toolBad": "#2d1f1f",
+    "gray": 245,
+    "grayDim": 240,
+    "green": "#87b070",
+    "red": "#e05a52",
+    "amber": "#e0a458",
+    "blue": "#7ba2c8",
+    "cyan": "#8bb5b7",
+    "violet": "#b48ead"
+  },
+  "colors": {
+    "accent": "clay",
+    "border": "grayDim",
+    "borderAccent": "clay",
+    "borderMuted": "grayDim",
+    "success": "green",
+    "error": "red",
+    "warning": "amber",
+    "muted": "gray",
+    "dim": "grayDim",
+    "text": "",
+    "thinkingText": "grayDim",
+    "selectedBg": "surface",
+    "scrollbarThumb": "surfaceRaised",
+    "userMessageBg": "surface",
+    "userMessageText": "",
+    "customMessageBg": "surface",
+    "customMessageText": "",
+    "customMessageLabel": "clay",
+    "toolPendingBg": "",
+    "toolSuccessBg": "",
+    "toolErrorBg": "toolBad",
+    "toolTitle": "clay",
+    "toolOutput": "",
+    "mdHeading": "clay",
+    "mdLink": "blue",
+    "mdLinkUrl": "gray",
+    "mdCode": "cyan",
+    "mdCodeBlock": "",
+    "mdCodeBlockBorder": "grayDim",
+    "mdQuote": "gray",
+    "mdQuoteBorder": "grayDim",
+    "mdHr": "grayDim",
+    "mdListBullet": "clay",
+    "toolDiffAdded": "green",
+    "toolDiffRemoved": "red",
+    "toolDiffContext": "gray",
+    "syntaxComment": "grayDim",
+    "syntaxKeyword": "clay",
+    "syntaxFunction": "blue",
+    "syntaxVariable": "amber",
+    "syntaxString": "green",
+    "syntaxNumber": "violet",
+    "syntaxType": "cyan",
+    "syntaxOperator": "clayDeep",
+    "syntaxPunctuation": "gray",
+    "thinkingOff": "grayDim",
+    "thinkingMinimal": "gray",
+    "thinkingLow": "cyan",
+    "thinkingMedium": "blue",
+    "thinkingHigh": "clay",
+    "thinkingXhigh": "red",
+    "thinkingMax": "violet",
+    "bashMode": "amber"
+  }
+}

package/types/app.d.ts

@@ -0,0 +1,5 @@
+/** Types for the bundled app's plain-JS modules (app/), used by unit tests. */
+declare module "*/app/update-check.mjs" {
+	export function isNewerVersion(candidate: string, current: string): boolean;
+	export function createUpdateCheck(options: { currentVersion: string; upgradeHint: string }): (pi: unknown) => void;
+}

package/types/community-packages.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Type stub for the one bundled community pi package. It ships raw TypeScript
+ * written against a different pi version, so typechecking its sources against
+ * our pinned pi types produces spurious errors. tsconfig `paths` points the
+ * compiler here, while jiti resolves the real module at runtime.
+ */
+
+declare module "pi-web-search/src/index.ts" {
+	import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+	const factory: (pi: ExtensionAPI) => unknown;
+	export default factory;
+}