@gavin-hu/my-pi-agent 0.21.0 → 0.22.0

package/extensions/bytefly/working/format.ts

@@ -1,20 +1,20 @@
 /**
  * Pure text for the live working line.
  *
- * Before the first tool starts it is a plain count (`Working… 42s`). After that
- * it names the last top-level tool and how many this run has started, then the
- * elapsed time (`edit · 3 tools · 42s`). Whole seconds, because the tick
- * advances once a second; negative and non-finite input reads as `0s`.
+ * A plain count while the run has started nothing (`working · 42s`), then how
+ * many top-level tools this run has started and the elapsed time
+ * (`working · 3 tools · 42s`). The line no longer names the tool: it is one word
+ * a reader can skim, and the transcript already draws each call as its own block.
+ * Whole seconds, because the tick advances once a second; negative and
+ * non-finite input reads as `0s`.
  */
 
-import { sanitizeLine, formatToolCount } from "../../../lib/format.ts";
+import { formatToolCount } from "../../../lib/format.ts";
 import { SEPARATORS } from "../../../lib/tui/glyphs.ts";
 import { WORKING_CONFIG } from "./config.ts";
 
 /** What the current run has done so far, for the live line. */
 export interface WorkingRun {
-	/** The last top-level tool started, or `null` before the first one. */
-	readonly tool: string | null;
 	/** Top-level tool calls started in this run. */
 	readonly tools: number;
 }
@@ -30,13 +30,10 @@ export function formatElapsed(ms: number): string {
 	return `${seconds}s`;
 }
 
-/** The working-row message: `Working… 4s` until a tool starts, then the run line. */
+/** The working line's message: `working · 4s`, then `working · 3 tools · 4s`. */
 export function workingCounter(ms: number, run?: WorkingRun): string {
 	const elapsed = formatElapsed(ms);
 	const tools = run?.tools ?? 0;
-	const tool = run?.tool ? sanitizeLine(run.tool) : "";
-	if (tools > 0) {
-		return [tool, formatToolCount(tools), elapsed].filter((part) => part !== "").join(SEPARATORS.item);
-	}
-	return `${WORKING_CONFIG.working}${WORKING_CONFIG.ellipsis} ${elapsed}`;
+	const count = tools > 0 ? formatToolCount(tools) : "";
+	return [WORKING_CONFIG.working, count, elapsed].filter((part) => part !== "").join(SEPARATORS.item);
 }

package/extensions/bytefly/working/register.ts

@@ -1,31 +1,30 @@
 /**
  * bytefly's live working line.
  *
- * Pi's working row shows a static `Working`, so a long run reads the same as a
- * short one. This surface advances the message once a second while the row is
- * up, and hands it back to Pi when the row comes down. Once a top-level tool
- * starts, the message also names that tool and how many this run has started,
- * turning the row into a live run line (`edit · 3 tools · 12s`).
+ * Pi's working indicator shows a static `Working`, so a long run reads the same as
+ * a short one. This surface advances the message once a second while the indicator
+ * is up, and hands it back to Pi when it comes down. Once a top-level tool starts,
+ * the message also counts this run's tools, turning the line on the composer's top
+ * border into `working · 3 tools · 12s`.
  *
- * The timer is tied to the row's visibility. The host shows the working
- * indicator in its own `turn_start` handler and clears it at `agent_end`
- * (`interactive-mode.js`), so the tick starts at `turn_start` and stops at
- * `agent_end` — the two moments the row appears and disappears. Turns inside
- * one run do not restart it: the host leaves the same indicator up across
- * turns, and `start` is a no-op while it is counting.
+ * The timer is tied to the indicator's visibility. The host shows it in its own
+ * `turn_start` handler and clears it at `agent_end` (`interactive-mode.js`), so the
+ * tick starts at `turn_start` and stops at `agent_end` — the two moments it appears
+ * and disappears. Turns inside one run do not restart it: the host leaves the same
+ * indicator up across turns, and `start` is a no-op while it is counting.
  *
  * A nested tool call (one carrying `parentToolCallId`, such as a codemode
- * script's inner call) is not counted and does not take over the line, so the
- * number matches the tool blocks the transcript shows. The tool events repaint
- * the row immediately; the one-second tick is still the only timer.
+ * script's inner call) is not counted, so the number matches the tool blocks the
+ * transcript shows. The tool events repaint the line immediately; the one-second
+ * tick is still the only timer.
  *
- * Compaction and auto-retry also replace the row, but both run outside this
+ * Compaction and auto-retry also replace the indicator, but both run outside this
  * window (`auto_retry_start` follows `agent_end`; the before-settle compaction
  * runs after it), and neither is an extension event, so there is nothing to
  * hook and nothing to undo.
  *
- * The handle is global (`setWorkingMessage` drives the single working row), so
- * the tick is cancelled and the message reset on stop and, belt and braces, on
+ * The handle is global (`setWorkingMessage` drives the single indicator), so the
+ * tick is cancelled and the message reset on stop and, belt and braces, on
  * `session_shutdown` — the factory itself only registers.
  */
 
@@ -50,14 +49,13 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 	let startedAt = 0;
 	// A boolean, not `startedAt === 0`: an injected clock is allowed to start at 0.
 	let active = false;
-	// The last top-level tool and how many this run has started. Reset with the run.
-	let tool: string | null = null;
+	// How many top-level tools this run has started. Reset with the run.
 	let tools = 0;
 
-	/** The current row text, from the run state and the elapsed time. */
-	const message = (): string => workingCounter(now() - startedAt, { tool, tools });
+	/** The current line's text, from the run state and the elapsed time. */
+	const message = (): string => workingCounter(now() - startedAt, { tools });
 
-	/** Repaint an active row now, so a tool start does not wait for the next tick. */
+	/** Repaint an active line now, so a tool start does not wait for the next tick. */
 	const refresh = (ctx: ExtensionContext): void => {
 		if (active) ctx.ui.setWorkingMessage(message());
 	};
@@ -68,7 +66,6 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 		cancel = undefined;
 		if (!active) return;
 		active = false;
-		tool = null;
 		tools = 0;
 		ctx.ui.setWorkingMessage(undefined);
 	};
@@ -78,7 +75,6 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 		if (active) return;
 		startedAt = now();
 		active = true;
-		tool = null;
 		tools = 0;
 		const tick = (): void => {
 			ctx.ui.setWorkingMessage(message());
@@ -88,17 +84,16 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 	};
 
 	// The host shows the working indicator on its own `turn_start` handler, so
-	// this is the first frame the row is up.
+	// this is the first frame the indicator is up.
 	pi.on("turn_start", (_event, ctx) => {
 		if (ctx.mode !== "tui") return;
 		start(ctx);
 	});
 
 	// A nested tool is an implementation detail of its parent run, not a
-	// transcript block, so it neither counts nor takes over the line.
+	// transcript block, so it does not count toward the line.
 	pi.on("tool_execution_start", (event, ctx) => {
 		if (ctx.mode !== "tui" || !active || event.parentToolCallId) return;
-		tool = event.toolName;
 		tools += 1;
 		refresh(ctx);
 	});

package/extensions/check/commands.ts

@@ -12,10 +12,8 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 import { resolveEffectiveCwd } from "../../lib/env.ts";
 import { planModeRefusal } from "../../lib/plan-entry.ts";
 import { isPlanModeEnabled } from "../../lib/plan-state.ts";
-import { withRailsSuppressed } from "../../lib/rails.ts";
 import { formatCheckReport, formatCheckSummary } from "./format.ts";
 import { CheckError, type CheckRuntime } from "./runtime.ts";
-import { CheckResultComponent, CheckRunComponent } from "./tui.ts";
 import type { CheckResult, CheckTarget } from "./types.ts";
 
 /** The accepted targets and their completion descriptions. */
@@ -42,6 +40,8 @@ function runLabel(commands: readonly string[]): string {
 
 /** The TUI loop: run, then list/detail, with rerun. */
 async function runTui(runtime: CheckRuntime, ctx: ExtensionCommandContext, target: CheckTarget): Promise<void> {
+	// The screens are the TUI's: a text run above and registration load neither.
+	const { CheckResultComponent, CheckRunComponent } = await import("./view/check-screens.ts");
 	while (true) {
 		let active: ReturnType<CheckRuntime["start"]>;
 		try {
@@ -123,6 +123,7 @@ export function registerCheckCommand(pi: ExtensionAPI, runtime: CheckRuntime): v
 				return;
 			}
 
+			const { withRailsSuppressed } = await import("../../lib/rails.ts");
 			await withRailsSuppressed(pi, () => runTui(runtime, ctx, target));
 		},
 	});

package/extensions/check/{tui.ts → view/check-screens.ts}

@@ -11,19 +11,19 @@
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { type Component, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
-import { formatDuration, sanitizeLine } from "../../lib/format.ts";
-import { dockListFrame, screenHint, type ScreenHint, type ViewportRowsSource } from "../../lib/tui/chrome.ts";
-import { clip } from "../../lib/tui/columns.ts";
-import { fitRows, formatRange, isCloseKey, wheelDelta } from "../../lib/tui/cursor.ts";
-import { DockListScreen, type DetailContents } from "../../lib/tui/dock-screen.ts";
-import { SEPARATORS } from "../../lib/tui/glyphs.ts";
-import { LinePane } from "../../lib/tui/line-pane.ts";
-import { emptyState, listRow } from "../../lib/tui/rows.ts";
-import { titleRule } from "../../lib/tui/rules.ts";
-import { paint } from "../../lib/tui/tokens.ts";
-import { formatFailureDetail, formatFailureLocation, formatResultSummary } from "./format.ts";
-import { readSourceExcerpt } from "./source.ts";
-import type { CheckResult, Failure } from "./types.ts";
+import { formatDuration, sanitizeLine } from "../../../lib/format.ts";
+import { dockListFrame, screenHint, type ScreenHint, type ViewportRowsSource } from "../../../lib/tui/chrome.ts";
+import { clip } from "../../../lib/tui/columns.ts";
+import { fitRows, formatRange, isCloseKey, wheelDelta } from "../../../lib/tui/cursor.ts";
+import { DockListScreen, type DetailContents } from "../../../lib/tui/dock-screen.ts";
+import { SEPARATORS } from "../../../lib/tui/glyphs.ts";
+import { LinePane } from "../../../lib/tui/line-pane.ts";
+import { emptyState, listRow } from "../../../lib/tui/rows.ts";
+import { titleRule } from "../../../lib/tui/rules.ts";
+import { paint } from "../../../lib/tui/tokens.ts";
+import { formatFailureDetail, formatFailureLocation, formatResultSummary } from "../format.ts";
+import { readSourceExcerpt } from "../source.ts";
+import type { CheckResult, Failure } from "../types.ts";
 
 const RUN_DEFAULT_ROWS = 20;
 const RUN_CHROME_ROWS = 5;
@@ -166,12 +166,7 @@ export class CheckResultComponent extends DockListScreen<Failure> {
 	protected listHints(rows: readonly Failure[]): ScreenHint[] {
 		// An empty list has nothing to open, so it offers only the two ways out.
 		if (rows.length === 0) return ["Esc close", { text: "r rerun", color: "accent" }];
-		return [
-			"Esc close",
-			{ text: "Enter detail", color: "accent" },
-			{ text: "r rerun", color: "warning" },
-			"↑/↓ select",
-		];
+		return ["Esc close", { text: "Enter detail", color: "accent" }, { text: "r rerun", color: "warn" }, "↑/↓ select"];
 	}
 
 	protected detailHints(): ScreenHint[] {

package/extensions/context/commands.ts

@@ -10,12 +10,10 @@
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { formatTokens } from "../../lib/format.ts";
-import { withRailsSuppressed } from "../../lib/rails.ts";
 import { messageOf } from "../../lib/errors.ts";
 import { collectInputs } from "./collect.ts";
 import { formatReport } from "./format.ts";
 import { buildReport } from "./report.ts";
-import { ContextComponent } from "./tui.ts";
 
 /** The command's argument surface, shared by the description and the usage warning. */
 const CONTEXT_USAGE = "/context [compact [instructions]]";
@@ -37,6 +35,8 @@ async function openReport(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promi
 	}
 
 	// The dock screen owns the editor slot; hide the rails for its lifetime.
+	const { withRailsSuppressed } = await import("../../lib/rails.ts");
+	const { ContextComponent } = await import("./view/context-report.ts");
 	await withRailsSuppressed(pi, () =>
 		ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
 			return new ContextComponent({

package/extensions/context/{tui.ts → view/context-report.ts}

@@ -14,17 +14,17 @@
 
 import type { CompactionResult, Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
-import { messageOf } from "../../lib/errors.ts";
-import { formatTokens } from "../../lib/format.ts";
-import { screenFooter, screenHint, type ViewportRowsSource } from "../../lib/tui/chrome.ts";
-import { ConfirmState } from "../../lib/tui/confirm.ts";
-import { clampScroll, fitRows, formatRange, isCloseKey, navigateScroll } from "../../lib/tui/cursor.ts";
-import { gaugeBar, gaugeRole } from "../../lib/tui/gauge.ts";
-import { BODY_INDENT } from "../../lib/tui/indent.ts";
-import { titleRule } from "../../lib/tui/rules.ts";
-import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
-import { formatBudget, formatCompaction, formatDrift } from "./format.ts";
-import type { ContextBucket, ContextReport } from "./types.ts";
+import { messageOf } from "../../../lib/errors.ts";
+import { formatTokens } from "../../../lib/format.ts";
+import { screenFooter, screenHint, type ViewportRowsSource } from "../../../lib/tui/chrome.ts";
+import { ConfirmState } from "../../../lib/tui/confirm.ts";
+import { clampScroll, fitRows, formatRange, isCloseKey, navigateScroll } from "../../../lib/tui/cursor.ts";
+import { gaugeBar, gaugeRole } from "../../../lib/tui/gauge.ts";
+import { BODY_INDENT } from "../../../lib/tui/indent.ts";
+import { titleRule } from "../../../lib/tui/rules.ts";
+import { paint, type TuiRole } from "../../../lib/tui/tokens.ts";
+import { formatBudget, formatCompaction, formatDrift } from "../format.ts";
+import type { ContextBucket, ContextReport } from "../types.ts";
 
 /** Fixed rows around the scrollable body: title, gauge, budget, blank, blank, footer, closing rule. */
 const CHROME_ROWS = 7;
@@ -71,6 +71,34 @@ function shareCell(share: number): string {
 	return `${share.toFixed(1)}%`.padStart(6);
 }
 
+/**
+ * The hue that identifies a context category, keyed by the bucket ids
+ * `report.ts` builds.
+ *
+ * Categories are what the screen tells apart at a glance; a bucket with no
+ * entry here — injected context and its children, summaries, shell output, a
+ * type this build has never seen — reads neutral, so the catch-all rows stay
+ * quiet and the coloured ones mean something. The same table answers for the
+ * largest-message list, so a tool result is one colour in both sections.
+ */
+const CATEGORY_HUES: Readonly<Record<string, TuiRole>> = {
+	system: "hue1",
+	tools: "hue2",
+	user: "hue3",
+	assistant: "hue4",
+	toolResults: "hue5",
+};
+
+/** The hue for a bucket id, or `undefined` when the category is neutral. */
+export function hueOf(id: string): TuiRole | undefined {
+	return CATEGORY_HUES[id];
+}
+
+/** The hue for a message role word; `tool result` is the bucket's own category. */
+export function hueForRole(role: string): TuiRole | undefined {
+	return CATEGORY_HUES[role === "tool result" ? "toolResults" : role];
+}
+
 /** Pad a label to its column with spaces, measured in terminal columns. */
 function padCell(text: string, width: number): string {
 	const clipped = truncateToWidth(text, width, "…");
@@ -151,7 +179,7 @@ export class ContextComponent implements Component {
 	private compositionLine(width: number): string {
 		const label = paint(this.theme, "label", "Composition");
 		const total = paint(this.theme, "meta", `${formatTokens(this.report.estimate)} estimate`);
-		const full = `  ${label} · ${total}`;
+		const full = `  ${label}${paint(this.theme, "faint", " · ")}${total}`;
 		return visibleWidth(full) <= width ? full : truncateToWidth(`  ${label}`, width);
 	}
 
@@ -161,12 +189,15 @@ export class ContextComponent implements Component {
 		const labelWidth = bucket.depth > 0 ? 20 : 22;
 		const label = padCell(bucket.label, labelWidth);
 		const tokens = formatTokens(bucket.tokens).padStart(6);
-		const share = shareCell(bucket.share);
-		const note = bucket.note ? `  ${bucket.note}` : "";
+		// The row's hue carries the category; the label, the count, and the printed
+		// share still say everything the colour repeats.
+		const hue = hueOf(bucket.id) ?? "meta";
+		const share = paint(this.theme, hue, shareCell(bucket.share));
+		const note = bucket.note ? paint(this.theme, "faint", `  ${bucket.note}`) : "";
 		const bar = gaugeBar(this.theme, {
 			percent: bucket.share,
 			blocks: BUCKET_BLOCKS,
-			role: "meta",
+			role: hue,
 			emptyRole: "faint",
 		});
 		const head = `${indent}${paint(this.theme, "label", label)}${paint(this.theme, "meta", tokens)}`;
@@ -204,7 +235,8 @@ export class ContextComponent implements Component {
 			for (const block of report.largest) {
 				const tokens = formatTokens(block.tokens).padStart(6);
 				const role = padCell(block.role, 12);
-				const candidate = `    ${paint(this.theme, "meta", tokens)}  ${paint(this.theme, "label", role)}${block.label}`;
+				const hue = hueForRole(block.role) ?? "meta";
+				const candidate = `    ${paint(this.theme, "meta", tokens)}  ${paint(this.theme, hue, role)}${paint(this.theme, "label", block.label)}`;
 				lines.push(truncateToWidth(candidate, width));
 			}
 		}
@@ -221,9 +253,9 @@ export class ContextComponent implements Component {
 			width,
 			[
 				{ text: "c compact", color: "accent" },
-				{ text: "r refresh", color: "dim" },
-				{ text: "↑↓ scroll", color: "dim" },
-				{ text: "Esc close", color: "dim" },
+				{ text: "r refresh", color: "faint" },
+				{ text: "↑↓ scroll", color: "faint" },
+				{ text: "Esc close", color: "faint" },
 			],
 			BODY_INDENT,
 		);

package/extensions/file-browse/index.ts

@@ -14,16 +14,13 @@ import { realpathSync } from "node:fs";
 import { stat } from "node:fs/promises";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isExtensionEnabled, resolveEffectiveCwd } from "../../lib/env.ts";
-import { requestMount } from "../../lib/http/index.ts";
-import { loadConfig } from "./config/config.ts";
-import { createGitDiff, createGitStatus } from "./git/git.ts";
-import { openInBrowser } from "../../lib/browser.ts";
-import { HttpError, resolveRequestPath } from "./files/paths.ts";
-import { createFileServer, type FileServer } from "./transport/server.ts";
+import type { openInBrowser } from "../../lib/browser.ts";
+import type { ServeConfig } from "./config/config.ts";
+import type { FileServer } from "./transport/server.ts";
 
 export interface FileBrowserDeps {
 	/** Override the server factory (tests). */
-	createServer?: typeof createFileServer;
+	createServer?: typeof import("./transport/server.ts").createFileServer;
 	/** Override the browser opener (tests). */
 	open?: typeof openInBrowser;
 }
@@ -58,51 +55,49 @@ export default function fileBrowser(pi: ExtensionAPI, deps: FileBrowserDeps = {}
 		if (await stop()) current.ctx.ui.notify("browse: stopped — the last page was closed", "info");
 	};
 
-	const start = async (args: string, ctx: ExtensionContext): Promise<void> => {
-		const target = args.trim();
-		if (target === "status") {
-			ctx.ui.notify(
-				running ? `browse: ${running.server.root} at ${running.server.url}` : "browse: not running",
-				"info",
-			);
-			return;
-		}
-		if (target === "stop") {
-			ctx.ui.notify((await stop()) ? "browse: stopped" : "browse: not running", "info");
-			return;
-		}
+	type ResolvedRoot = { root: string; config: ServeConfig };
 
-		const cwd = resolveEffectiveCwd(ctx.cwd);
+	/** The folder `/browse [path]` names, or undefined after telling the user why. */
+	const resolveRoot = async (target: string, cwd: string, ctx: ExtensionContext): Promise<ResolvedRoot | undefined> => {
+		const { loadConfig } = await import("./config/config.ts");
 		const config = loadConfig(cwd);
 		let root = cwd;
 		if (target) {
+			const { HttpError, resolveRequestPath } = await import("./files/paths.ts");
 			try {
 				root = await resolveRequestPath(cwd, target);
 			} catch (error) {
 				const message = error instanceof HttpError ? error.message : String(error);
 				ctx.ui.notify(`browse: ${message}`, "error");
-				return;
+				return undefined;
 			}
 			const info = await stat(root).catch(() => undefined);
 			if (!info?.isDirectory()) {
 				ctx.ui.notify(`browse: ${target} is not a folder inside the working directory`, "error");
-				return;
+				return undefined;
 			}
 		}
+		return { root, config };
+	};
 
-		let realRoot = root;
-		try {
-			realRoot = realpathSync.native(root);
-		} catch {
-			// Keep the unresolved root; the server factory reports a real failure.
-		}
-		if (running && running.server.root === realRoot) {
-			ctx.ui.notify(`browse: ${running.server.url} (already running)`, "info");
-			return;
-		}
+	/**
+	 * Put the page in front of the user, unless the project asked to stay headless.
+	 *
+	 * Every `/browse` opens it, including one that finds the page already served: the
+	 * command's job is showing the page, and a URL printed over a running server leaves
+	 * the user to paste it.
+	 */
+	const openPage = async (url: string, config: ServeConfig): Promise<void> => {
+		if (!config.autoOpen) return;
+		const open = deps.open ?? (await import("../../lib/browser.ts")).openInBrowser;
+		open(url);
+	};
 
-		await stop();
-		const create = deps.createServer ?? createFileServer;
+	/** Open the page's server; the server, git, HTTP, and browser modules live here. */
+	const openServer = async (root: string, config: ServeConfig, ctx: ExtensionContext): Promise<void> => {
+		const create = deps.createServer ?? (await import("./transport/server.ts")).createFileServer;
+		const { createGitDiff, createGitStatus } = await import("./git/git.ts");
+		const { requestMount } = await import("../../lib/http/index.ts");
 		try {
 			const outcome = await create({
 				root,
@@ -125,12 +120,48 @@ export default function fileBrowser(pi: ExtensionAPI, deps: FileBrowserDeps = {}
 			const server = outcome.server;
 			running = { server, ctx };
 			ctx.ui.notify(`browse: ${server.root} at ${server.url}`, "info");
-			if (config.autoOpen) (deps.open ?? openInBrowser)(server.url);
+			await openPage(server.url, config);
 		} catch (error) {
 			ctx.ui.notify(`browse: ${error instanceof Error ? error.message : String(error)}`, "error");
 		}
 	};
 
+	const start = async (args: string, ctx: ExtensionContext): Promise<void> => {
+		const target = args.trim();
+		if (target === "status") {
+			ctx.ui.notify(
+				running ? `browse: ${running.server.root} at ${running.server.url}` : "browse: not running",
+				"info",
+			);
+			return;
+		}
+		if (target === "stop") {
+			ctx.ui.notify((await stop()) ? "browse: stopped" : "browse: not running", "info");
+			return;
+		}
+
+		const cwd = resolveEffectiveCwd(ctx.cwd);
+		const resolved = await resolveRoot(target, cwd, ctx);
+		if (resolved === undefined) return;
+		const { root, config } = resolved;
+
+		let realRoot = root;
+		try {
+			realRoot = realpathSync.native(root);
+		} catch {
+			// Keep the unresolved root; the server factory reports a real failure.
+		}
+		if (running && running.server.root === realRoot) {
+			ctx.ui.notify(`browse: ${running.server.url} (already running)`, "info");
+			// The page is already served, so this is an open and not a restart.
+			await openPage(running.server.url, config);
+			return;
+		}
+
+		await stop();
+		await openServer(root, config, ctx);
+	};
+
 	pi.registerCommand("browse", {
 		description: "Browse the working directory in a local browser (read-only): /browse [path | status | stop]",
 		getArgumentCompletions: (prefix) => {

package/extensions/file-read/render.ts

@@ -25,10 +25,10 @@ export const PREVIEW_LINES = 20;
 
 /** Render the argument path: body colour, `~`-shortened, OSC-8 linked when supported. */
 export function renderReadPath(rawPath: string | undefined, theme: Theme, cwd: string, argsComplete = true): string {
-	if (rawPath === undefined && !argsComplete) return theme.fg("toolOutput", "...");
+	if (rawPath === undefined && !argsComplete) return paint(theme, "toolOutput", "...");
 	if (typeof rawPath !== "string") return paint(theme, "bad", "[invalid arg]");
 	const value = sanitizeLine(rawPath);
-	if (!value) return theme.fg("toolOutput", "...");
+	if (!value) return paint(theme, "toolOutput", "...");
 	const styled = paint(theme, "label", shortenPath(value));
 	if (!getCapabilities().hyperlinks) return styled;
 	const abs = isAbsolute(value) ? value : resolve(cwd, value);
@@ -93,14 +93,14 @@ export function formatReadResult(result: ReadRenderResult, options: ReadRenderOp
 
 	const summary = summarizeRead(details);
 	const sep = paint(theme, "faint", SEPARATORS.item);
-	let text = paint(theme, "meta", summary.format) + sep + theme.fg("toolOutput", summary.detail);
+	let text = paint(theme, "meta", summary.format) + sep + paint(theme, "toolOutput", summary.detail);
 	if (summary.note) text += paint(theme, summary.truncated ? "accent" : "faint", SEPARATORS.item + summary.note);
 
 	if (details.text.length > 0) {
 		if (options.expanded) {
 			const { body, moreLines } = previewText(details.text, PREVIEW_LINES);
 			// Blank line before the body, matching the built-ins' header/output gap.
-			text += `\n\n${theme.fg("toolOutput", body)}`;
+			text += `\n\n${paint(theme, "toolOutput", body)}`;
 			if (moreLines > 0) text += `\n${paint(theme, "meta", `... (${moreLines} more lines)`)}`;
 		} else {
 			const hint = expandKey(theme);

package/extensions/goal/plan-route.ts

@@ -22,7 +22,7 @@ import { isPursuedGoal } from "../../lib/goal-state.ts";
 import { isRemoteTurn, remoteLanguage } from "../../lib/interaction.ts";
 import { PLAN_CONSENT, PLAN_CONSENT_SHORT, PLAN_CONSENT_SHORT_ZH, requestPlanMode } from "../../lib/plan-entry.ts";
 import { isPlanModeEnabled } from "../../lib/plan-state.ts";
-import { PLAN_ENTER_TOOL } from "../../lib/tool-names.ts";
+import { PLAN_TOOL } from "../../lib/tool-names.ts";
 import type { Goal, GoalStatus } from "./types.ts";
 
 /** Dialog title: the question the phase answers. */
@@ -45,7 +45,7 @@ export async function goalPhase(
 	if (isPlanModeEnabled(ctx.sessionManager.getBranch())) return "planning";
 	if (!options.ask || !ctx.hasUI) return "active";
 	// Do not ask about a phase this session cannot enter.
-	if (!pi.getAllTools().some((tool) => tool.name === PLAN_ENTER_TOOL)) return "active";
+	if (!pi.getAllTools().some((tool) => tool.name === PLAN_TOOL)) return "active";
 	const consent = isRemoteTurn(ctx)
 		? remoteLanguage(ctx) === "zh"
 			? PLAN_CONSENT_SHORT_ZH