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

package/extensions/wechat/commands/commands.ts

@@ -21,30 +21,25 @@ import { join } from "node:path";
 import { writeConfigValue } from "../../../lib/config.ts";
 import { sanitizeLine } from "../../../lib/format.ts";
 import { supportsCustomUI } from "../../../lib/interaction.ts";
-import { isAllowedPeer, type Bridge } from "../bridge.ts";
+import type { Bridge } from "../bridge.ts";
 import type { WechatClient } from "../transport/client.ts";
 import type { WechatConfig } from "../config.ts";
+import type { StatusAction } from "../view/status-screen.ts";
+import type { LoginViewState } from "../view/login-screen.ts";
+import type { LoginOutcome } from "./login.ts";
 import { doctorReport } from "./doctor.ts";
 import { messageOf } from "../errors.ts";
 import { peerLabel, peerKey } from "../text/format.ts";
-import { waitForLogin, type LoginOutcome } from "./login.ts";
 import { defaultSleep } from "../timer.ts";
-import { LoginScreenComponent, type LoginViewState } from "../view/login-screen.ts";
 import { qrLines } from "../../../lib/qr.ts";
-import {
-	statusLine,
-	statusView,
-	StatusScreenComponent,
-	type StatusAction,
-	type StatusView,
-} from "../view/status-screen.ts";
+import { statusLine, statusView, type StatusView } from "../text/status.ts";
 import type { BotCredentials } from "../types.ts";
 
 export interface CommandDeps {
 	getBridge: () => Bridge | undefined;
-	ensureBridge: (ctx: ExtensionContext) => Bridge;
+	ensureBridge: (ctx: ExtensionContext) => Promise<Bridge>;
 	loadConfig: (cwd: string) => WechatConfig;
-	createLoginClient: (cwd: string) => WechatClient;
+	createLoginClient: (cwd: string) => Promise<WechatClient>;
 	saveAccount: (account: BotCredentials) => void;
 	primaryAccount: () => BotCredentials | undefined;
 	/** Read a peer's recent messages for `/wechat history`; read-only. */
@@ -202,6 +197,9 @@ async function runAllow(ctx: ExtensionContext, deps: CommandDeps, peerArg?: stri
 	const candidate = peerArg?.trim() || (await chooseRefused(ctx, deps));
 	if (!candidate) return;
 	const config = deps.loadConfig(ctx.cwd);
+	// The admission rule lives with the bridge's intake, which a session that never
+	// runs `/wechat allow` does not load.
+	const { isAllowedPeer } = await import("../intake.ts");
 	if (isAllowedPeer(candidate, undefined, config.allowedPeers)) {
 		ctx.ui.notify(`${sanitizeLine(peerLabel(candidate))} is already allowed.`);
 		return;
@@ -262,7 +260,7 @@ export async function finishLogin(result: LoginOutcome, ctx: ExtensionContext, d
 				// previous client and its token, and `open()` is a no-op while it runs, so
 				// it has to stop before the new credentials are used.
 				await deps.getBridge()?.close();
-				deps.ensureBridge(ctx).open();
+				(await deps.ensureBridge(ctx)).open();
 				ctx.ui.notify(`WeChat connected as ${label} and the bridge is running.`);
 			} catch (error) {
 				ctx.ui.notify(
@@ -289,7 +287,7 @@ async function runLogin(ctx: ExtensionContext, deps: CommandDeps): Promise<void>
 		return;
 	}
 	if (busyWithPeerTurn(ctx, deps, "login")) return;
-	const client = deps.createLoginClient(ctx.cwd);
+	const client = await deps.createLoginClient(ctx.cwd);
 	const config = deps.loadConfig(ctx.cwd);
 
 	let qr: { qrcode: string; imgContent: string };
@@ -300,6 +298,10 @@ async function runLogin(ctx: ExtensionContext, deps: CommandDeps): Promise<void>
 		return;
 	}
 
+	// The login screen and its poll loop are the TUI's: the refusal above and
+	// registration load neither.
+	const { waitForLogin } = await import("./login.ts");
+	const { LoginScreenComponent } = await import("../view/login-screen.ts");
 	const state: LoginViewState = { status: "wait", lines: await qrLines(qr.imgContent), url: qr.imgContent };
 	const result = await ctx.ui.custom<LoginOutcome | undefined>((tui, theme, _keybindings, done) => {
 		const controller = new AbortController();
@@ -357,6 +359,8 @@ async function runPanel(ctx: ExtensionCommandContext, deps: CommandDeps): Promis
 		ctx.ui.notify(statusLine(view()));
 		return;
 	}
+	// The control screen is the TUI's: the one-line summary above loads it never.
+	const { StatusScreenComponent } = await import("../view/status-screen.ts");
 	const action = await ctx.ui.custom<StatusAction>(
 		(tui, theme, _keybindings, done) =>
 			new StatusScreenComponent({

package/extensions/wechat/index.ts

@@ -15,22 +15,18 @@
 import { getAgentDir, type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
 import { join } from "node:path";
 import { isExtensionEnabled } from "../../lib/env.ts";
+import { lazy } from "../../lib/lazy.ts";
 import { isPidAlive } from "../../lib/spawn.ts";
 import { GLYPHS, STATUS_KEYS } from "../../lib/tui/glyphs.ts";
 import { paint } from "../../lib/tui/tokens.ts";
-import { createBridge, type Bridge, type BridgeState } from "./bridge.ts";
-import { createFetchRunner, WechatClient, type WechatClientOptions } from "./transport/client.ts";
+import type { Bridge, BridgeState } from "./bridge.ts";
+import type { WechatClient, WechatClientOptions } from "./transport/client.ts";
 import { registerCommands, type CommandDeps } from "./commands/commands.ts";
 import { messageOf } from "./errors.ts";
-import { loadWechatConfig } from "./config.ts";
+import { loadWechatConfig, type WechatConfig } from "./config.ts";
 import { clearCredentials, primaryAccount, saveAccount, wechatDir } from "./state/credentials.ts";
-import { acquireLock, lockPath, readLock, refreshLock, releaseLock } from "./state/lock.ts";
-import { openPeerSession, type PeerSession, type PeerSessionOptions } from "./peer/peer-session.ts";
-import { createPeerUIContext } from "./dialog/remote-ui.ts";
+import type { PeerSession, PeerSessionOptions } from "./peer/peer-session.ts";
 import { peerKey } from "./text/format.ts";
-import { readPeerHistory } from "./commands/history.ts";
-import { SLASH_COMMANDS } from "./commands/slash.ts";
-import { readState, statePath, writeState } from "./state/state.ts";
 import { registerTools } from "./tools.ts";
 
 /**
@@ -62,14 +58,20 @@ export interface WechatDeps {
 	 * call a model; production opens a real SDK session per peer.
 	 */
 	openSession?: (peer: string, options: PeerSessionOptions) => Promise<PeerSession>;
+	/** The bridge module; overridden in tests so a load can be counted. */
+	loadBridge?: () => Promise<typeof import("./bridge.ts")>;
 }
 
 export default function wechat(pi: ExtensionAPI, deps: WechatDeps = {}): void {
 	if (!isExtensionEnabled("wechat")) return;
 
-	const makeClient = deps.createClient ?? ((options: WechatClientOptions) => new WechatClient(options));
+	/** The bridge and the transport, loaded on the first account, never at registration. */
+	const bridgeModule = lazy(deps.loadBridge ?? (() => import("./bridge.ts")));
+	const clientModule = lazy(() => import("./transport/client.ts"));
 
 	let bridge: Bridge | undefined;
+	/** A build in flight, so a command that races `session_start` joins it instead of loading twice. */
+	let building: Promise<Bridge> | undefined;
 	let ctxRef: ExtensionContext | undefined;
 
 	const lockDeps = () => ({
@@ -78,10 +80,36 @@ export default function wechat(pi: ExtensionAPI, deps: WechatDeps = {}): void {
 		isAlive: isPidAlive,
 	});
 
-	const build = (ctx: ExtensionContext): Bridge => {
+	/** One iLink client over the fetched transport, from an already-loaded module. */
+	const clientOf = (
+		module: typeof import("./transport/client.ts"),
+		config: WechatConfig,
+		account?: { baseUrl: string },
+	): WechatClient =>
+		(deps.createClient ?? ((options: WechatClientOptions) => new module.WechatClient(options)))({
+			http: module.createFetchRunner(),
+			channelVersion: config.channelVersion,
+			botAgent: config.botAgent,
+			cdnBaseUrl: config.cdnBaseUrl,
+			...(account === undefined ? {} : { baseUrl: account.baseUrl }),
+		});
+
+	const build = async (ctx: ExtensionContext): Promise<Bridge> => {
 		ctxRef = ctx;
 		const config = loadWechatConfig(ctx.cwd);
 		const peerTools = new Map(Object.entries(config.peers).map(([id, peer]) => [peerKey(id), peer.tools] as const));
+		// Everything a live bridge composes loads here, so a session with no account
+		// never evaluates the bridge, the peer worker, the transport or the lock.
+		const [{ createBridge }, client, { openPeerSession }, { createPeerUIContext }] = await Promise.all([
+			bridgeModule.get(),
+			clientModule.get(),
+			import("./peer/peer-session.ts"),
+			import("./dialog/remote-ui.ts"),
+		]);
+		const { acquireLock, lockPath, readLock, refreshLock, releaseLock } = await import("./state/lock.ts");
+		const { readState, statePath, writeState } = await import("./state/state.ts");
+		const { SLASH_COMMANDS } = await import("./commands/slash.ts");
+		const { readPeerHistory } = await import("./commands/history.ts");
 		return createBridge({
 			config,
 			now: () => Date.now(),
@@ -111,14 +139,7 @@ export default function wechat(pi: ExtensionAPI, deps: WechatDeps = {}): void {
 			loadAccount: () => primaryAccount(),
 			loadState: () => readState(statePath()),
 			saveState: (state) => writeState(statePath(), state),
-			createClient: (account) =>
-				makeClient({
-					http: createFetchRunner(),
-					channelVersion: config.channelVersion,
-					botAgent: config.botAgent,
-					baseUrl: account.baseUrl,
-					cdnBaseUrl: config.cdnBaseUrl,
-				}),
+			createClient: (account) => clientOf(client, config, account),
 			sleep: deps.sleep,
 			acquireLock: () => acquireLock(lockPath(), lockDeps()),
 			refreshLock: () => refreshLock(lockPath(), lockDeps()),
@@ -147,13 +168,28 @@ export default function wechat(pi: ExtensionAPI, deps: WechatDeps = {}): void {
 	 * no-op, so a host that binds one session twice (RPC emits `session_start`
 	 * twice on a session switch) cannot start a second poller.
 	 */
-	const autoStart = (ctx: ExtensionContext): void => {
+	/** Build the bridge once, sharing the load with a command that asks while it is in flight. */
+	const ensure = (ctx: ExtensionContext): Promise<Bridge> => {
+		building ??= build(ctx).then(
+			(built) => {
+				bridge = built;
+				return built;
+			},
+			(error: unknown) => {
+				// A failed build is not remembered, so the next command can retry.
+				building = undefined;
+				throw error;
+			},
+		);
+		return building;
+	};
+
+	const autoStart = async (ctx: ExtensionContext): Promise<void> => {
 		if (ctx.mode !== "tui" && ctx.mode !== "rpc") return;
 		if (!primaryAccount()) return;
 		if (bridge?.status().open || bridge?.status().paused) return;
 		try {
-			bridge = bridge ?? build(ctx);
-			bridge.open();
+			(bridge ?? (await ensure(ctx))).open();
 		} catch (error) {
 			ctx.ui.notify(`WeChat did not connect: ${messageOf(error)}`, "warning");
 		}
@@ -161,24 +197,20 @@ export default function wechat(pi: ExtensionAPI, deps: WechatDeps = {}): void {
 
 	const commandDeps: CommandDeps = {
 		getBridge: () => bridge,
-		ensureBridge: (ctx) => {
-			if (!bridge) bridge = build(ctx);
-			return bridge;
-		},
+		// Both of these can be the first thing that needs the bridge: `/wechat login`
+		// runs before `session_start` on an RPC host, so the load is awaited here too.
+		ensureBridge: (ctx) => (bridge === undefined ? ensure(ctx) : Promise.resolve(bridge)),
 		loadConfig: (cwd) => loadWechatConfig(cwd),
-		createLoginClient: (cwd) => {
+		createLoginClient: async (cwd) => {
 			const config = loadWechatConfig(cwd);
-			return makeClient({
-				http: createFetchRunner(),
-				channelVersion: config.channelVersion,
-				botAgent: config.botAgent,
-				cdnBaseUrl: config.cdnBaseUrl,
-			});
+			return clientOf(await clientModule.get(), config);
 		},
 		saveAccount,
 		primaryAccount,
-		readHistory: (peer, count) =>
-			readPeerHistory(ctxRef?.cwd ?? process.cwd(), join(wechatDir(), "sessions"), peer, count),
+		readHistory: async (peer, count) => {
+			const { readPeerHistory } = await import("./commands/history.ts");
+			return readPeerHistory(ctxRef?.cwd ?? process.cwd(), join(wechatDir(), "sessions"), peer, count);
+		},
 		logout: () => {
 			clearCredentials();
 			// The account is the on/off switch: without one there is nothing to report,
@@ -186,6 +218,7 @@ export default function wechat(pi: ExtensionAPI, deps: WechatDeps = {}): void {
 			// counters. The next `ensureBridge`/`autoStart` builds a fresh bridge from
 			// the new account.
 			bridge = undefined;
+			building = undefined;
 		},
 		now: () => Date.now(),
 	};
@@ -193,11 +226,12 @@ export default function wechat(pi: ExtensionAPI, deps: WechatDeps = {}): void {
 	registerCommands(pi, commandDeps);
 	registerTools(pi, { getBridge: () => bridge });
 
-	pi.on("session_start", (_event, ctx) => {
+	pi.on("session_start", async (_event, ctx) => {
 		ctxRef = ctx;
 		// Stored credentials mean the bridge should be polling, so a new session
 		// (startup, reload, `/new`, resume, fork) reconnects it without a command.
-		autoStart(ctx);
+		// The bridge module loads here, on the first account, not at registration.
+		await autoStart(ctx);
 	});
 	pi.on("session_shutdown", async () => {
 		// Shutdown is emitted before the host resets the UI, so the chip is still ours to clear.
@@ -207,6 +241,7 @@ export default function wechat(pi: ExtensionAPI, deps: WechatDeps = {}): void {
 		} finally {
 			// A throwing close must not leave a live handle on a dead runtime.
 			bridge = undefined;
+			building = undefined;
 			ctxRef = undefined;
 		}
 	});

package/extensions/wechat/state/credentials.ts

@@ -1,5 +1,5 @@
 /**
- * Reading and writing `<agentDir>/wechat/credentials.json`.
+ * Reading and writing `<agent-dir>/wechat/credentials.json`.
  *
  * The file is written `0600` and holds one entry per bot account, keyed by
  * `ilinkBotId`. Malformed or partial entries are dropped on read rather than

package/extensions/wechat/state/state.ts

@@ -1,5 +1,5 @@
 /**
- * Reading and writing `<agentDir>/wechat/state.json`.
+ * Reading and writing `<agent-dir>/wechat/state.json`.
  *
  * Holds the long-poll cursor, the owner id, and per-peer reply tokens. It is
  * validated on read; a corrupt file degrades to empty state rather than losing

package/extensions/wechat/text/status.ts

@@ -0,0 +1,112 @@
+/**
+ * The `/wechat` status facts and their one-line summary (text only).
+ *
+ * `statusView` turns the stored account and the live bridge status into the
+ * facts the control screen and the text modes both read, and `statusLine` is
+ * what a non-TUI turn prints. They live in `text/` rather than beside the
+ * screen because the text modes need them and must never load the screen:
+ * `view/status-screen.ts` is a full-screen surface and loads on first use.
+ */
+
+import { sanitizeLine } from "../../../lib/format.ts";
+import { SEPARATORS } from "../../../lib/tui/glyphs.ts";
+import type { BridgeStatus } from "../bridge.ts";
+import { peerLabel } from "./format.ts";
+import type { BotCredentials } from "../types.ts";
+
+/** User-facing connection word; the internal `BridgeState` stays running/stopped. */
+export type StatusConnection = "open" | "expired" | "paused" | "closed";
+
+/** The facts the status screen and the one-line summary render. */
+export interface StatusView {
+	/** Whether a bridge exists, so the activity counters are meaningful. */
+	bridge: boolean;
+	account?: string;
+	connection: StatusConnection;
+	owner?: string;
+	peers: number;
+	queued: number;
+	/** Per-peer activity, so an operator can see who is waiting and for how long. */
+	peerRows: PeerRow[];
+	refused: number;
+	/** Labels of the refused senders, so an operator can allowlist one. */
+	refusedPeers: string[];
+	mediaDropped: number;
+	promptPending: boolean;
+	/** Every waiting prompt, one per peer that was asked something. */
+	prompts: Array<{ peer: string; title: string; startedAt: number }>;
+	/** The clock the view was built with, for the prompt age. */
+	now?: number;
+}
+
+/** One peer's line in the control screen. */
+export interface PeerRow {
+	/** The raw peer id, so an action targets the right person; falls back to `label`. */
+	id?: string;
+	label: string;
+	status: "idle" | "queued" | "running";
+	queued: number;
+	runningMs?: number;
+}
+
+/** The connection word for a bridge status, or `closed` when there is none. */
+export function connectionOf(status: BridgeStatus | undefined): StatusConnection {
+	return status?.paused ? "paused" : status?.open ? "open" : status?.expired ? "expired" : "closed";
+}
+
+/** Build the view from the stored account and the live bridge status. */
+export function statusView(
+	account: BotCredentials | undefined,
+	status: BridgeStatus | undefined,
+	now: number = Date.now(),
+): StatusView {
+	return {
+		bridge: status !== undefined,
+		account: account ? peerLabel(account.ilinkUserId) : undefined,
+		connection: connectionOf(status),
+		owner: status?.owner ? peerLabel(status.owner) : undefined,
+		peers: status?.peerCount ?? 0,
+		queued: status?.queued ?? 0,
+		peerRows: (status?.peerStates ?? []).map((entry) => ({
+			id: entry.peer,
+			label: peerLabel(entry.peer),
+			status: entry.state.status,
+			queued: entry.state.queued,
+			runningMs: entry.state.runningMs,
+		})),
+		refused: status?.refused ?? 0,
+		refusedPeers: status?.refusedPeers ?? [],
+		mediaDropped: status?.mediaDropped ?? 0,
+		promptPending: status?.promptPending ?? false,
+		prompts: (status?.prompts ?? []).map((prompt) => ({
+			peer: sanitizeLine(peerLabel(prompt.peer)),
+			title: sanitizeLine(prompt.title),
+			startedAt: prompt.startedAt,
+		})),
+		now,
+	};
+}
+
+/** The one-line summary used outside the TUI. */
+export function statusLine(view: StatusView): string {
+	const parts = [view.account ? `account ${view.account}` : "not logged in", view.connection];
+	if (view.bridge) {
+		parts.push(`${view.peers} peer(s)`, `${view.queued} queued`);
+		if (view.refused > 0) parts.push(`refused ${refusedValue(view)}`);
+		if (view.mediaDropped > 0) parts.push(`${view.mediaDropped} media dropped`);
+		if (view.owner) parts.push(`owner ${view.owner}`);
+		const active = view.peerRows.find((row) => row.status === "running");
+		if (active) parts.push(`running ${active.label}`);
+	}
+	const recovery = view.connection === "expired" ? " — run /wechat login to reconnect" : "";
+	return `wechat: ${parts.join(SEPARATORS.item)}${recovery}`;
+}
+
+/**
+ * The refusal count with the senders named: naming them is what makes
+ * `allowedPeers` usable, and either id form can be pasted into the config.
+ */
+export function refusedValue(view: StatusView): string {
+	const who = view.refusedPeers.length > 0 ? ` (${view.refusedPeers.join(", ")})` : "";
+	return `${view.refused}${who}`;
+}

package/extensions/wechat/types.ts

@@ -93,7 +93,7 @@ export interface BotCredentials {
 	createdAt: number;
 }
 
-/** Persisted `<agentDir>/wechat/credentials.json`. */
+/** Persisted `<agent-dir>/wechat/credentials.json`. */
 export interface CredentialsFile {
 	accounts: Record<string, BotCredentials>;
 	/**
@@ -111,7 +111,7 @@ export interface PeerState {
 	lastSeen: number;
 }
 
-/** Persisted `<agentDir>/wechat/state.json`. */
+/** Persisted `<agent-dir>/wechat/state.json`. */
 export interface WechatState {
 	cursor: string;
 	ownerId?: string;

package/extensions/wechat/view/status-screen.ts

@@ -11,7 +11,7 @@
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
-import { formatDuration, sanitizeLine } from "../../../lib/format.ts";
+import { formatDuration } from "../../../lib/format.ts";
 import { screenFooter, screenHint, type ScreenHint } from "../../../lib/tui/chrome.ts";
 import { clip } from "../../../lib/tui/columns.ts";
 import { formatRange, IdCursor, isCloseKey, navIntent } from "../../../lib/tui/cursor.ts";
@@ -19,12 +19,7 @@ import { SEPARATORS } from "../../../lib/tui/glyphs.ts";
 import { keyValueRow, listRow } from "../../../lib/tui/rows.ts";
 import { titleRule } from "../../../lib/tui/rules.ts";
 import { paint, type TuiRole } from "../../../lib/tui/tokens.ts";
-import type { BridgeStatus } from "../bridge.ts";
-import { peerLabel } from "../text/format.ts";
-import type { BotCredentials } from "../types.ts";
-
-/** User-facing connection word; the internal `BridgeState` stays running/stopped. */
-export type StatusConnection = "open" | "expired" | "paused" | "closed";
+import { type PeerRow, refusedValue, type StatusConnection, type StatusView } from "../text/status.ts";
 
 /**
  * What the status screen closed with: a global action, a peer history request,
@@ -32,106 +27,12 @@ export type StatusConnection = "open" | "expired" | "paused" | "closed";
  */
 export type StatusAction = "close" | "login" | "new" | "logout" | { kind: "history"; peer: string } | { kind: "allow" };
 
-/** The facts the status screen and the one-line summary render. */
-export interface StatusView {
-	/** Whether a bridge exists, so the activity counters are meaningful. */
-	bridge: boolean;
-	account?: string;
-	connection: StatusConnection;
-	owner?: string;
-	peers: number;
-	queued: number;
-	/** Per-peer activity, so an operator can see who is waiting and for how long. */
-	peerRows: PeerRow[];
-	refused: number;
-	/** Labels of the refused senders, so an operator can allowlist one. */
-	refusedPeers: string[];
-	mediaDropped: number;
-	promptPending: boolean;
-	/** Every waiting prompt, one per peer that was asked something. */
-	prompts: Array<{ peer: string; title: string; startedAt: number }>;
-	/** The clock the view was built with, for the prompt age. */
-	now?: number;
-}
-
-/** One peer's line in the control screen. */
-export interface PeerRow {
-	/** The raw peer id, so an action targets the right person; falls back to `label`. */
-	id?: string;
-	label: string;
-	status: "idle" | "queued" | "running";
-	queued: number;
-	runningMs?: number;
-}
-
 /** How many peer rows the screen lists before scrolling. */
 const MAX_PEER_ROWS = 5;
 
-/** The connection word for a bridge status, or `closed` when there is none. */
-export function connectionOf(status: BridgeStatus | undefined): StatusConnection {
-	return status?.paused ? "paused" : status?.open ? "open" : status?.expired ? "expired" : "closed";
-}
-
-/** Build the view from the stored account and the live bridge status. */
-export function statusView(
-	account: BotCredentials | undefined,
-	status: BridgeStatus | undefined,
-	now: number = Date.now(),
-): StatusView {
-	return {
-		bridge: status !== undefined,
-		account: account ? peerLabel(account.ilinkUserId) : undefined,
-		connection: connectionOf(status),
-		owner: status?.owner ? peerLabel(status.owner) : undefined,
-		peers: status?.peerCount ?? 0,
-		queued: status?.queued ?? 0,
-		peerRows: (status?.peerStates ?? []).map((entry) => ({
-			id: entry.peer,
-			label: peerLabel(entry.peer),
-			status: entry.state.status,
-			queued: entry.state.queued,
-			runningMs: entry.state.runningMs,
-		})),
-		refused: status?.refused ?? 0,
-		refusedPeers: status?.refusedPeers ?? [],
-		mediaDropped: status?.mediaDropped ?? 0,
-		promptPending: status?.promptPending ?? false,
-		prompts: (status?.prompts ?? []).map((prompt) => ({
-			peer: sanitizeLine(peerLabel(prompt.peer)),
-			title: sanitizeLine(prompt.title),
-			startedAt: prompt.startedAt,
-		})),
-		now,
-	};
-}
-
-/** The one-line summary used outside the TUI. */
-export function statusLine(view: StatusView): string {
-	const parts = [view.account ? `account ${view.account}` : "not logged in", view.connection];
-	if (view.bridge) {
-		parts.push(`${view.peers} peer(s)`, `${view.queued} queued`);
-		if (view.refused > 0) parts.push(`refused ${refusedValue(view)}`);
-		if (view.mediaDropped > 0) parts.push(`${view.mediaDropped} media dropped`);
-		if (view.owner) parts.push(`owner ${view.owner}`);
-		const active = view.peerRows.find((row) => row.status === "running");
-		if (active) parts.push(`running ${active.label}`);
-	}
-	const recovery = view.connection === "expired" ? " — run /wechat login to reconnect" : "";
-	return `wechat: ${parts.join(SEPARATORS.item)}${recovery}`;
-}
-
 /** Label column width in the screen body. */
 const LABEL_WIDTH = 11;
 
-/**
- * The refusal count with the senders named: naming them is what makes
- * `allowedPeers` usable, and either id form can be pasted into the config.
- */
-function refusedValue(view: StatusView): string {
-	const who = view.refusedPeers.length > 0 ? ` (${view.refusedPeers.join(", ")})` : "";
-	return `${view.refused}${who}`;
-}
-
 /** One body row: a `meta` label column and a value in `valueRole`. */
 function row(theme: Theme, width: number, label: string, value: string, valueRole: TuiRole = "label"): string {
 	return keyValueRow(theme, width, { label, value, labelWidth: LABEL_WIDTH, labelRole: "meta", valueRole });
@@ -302,12 +203,12 @@ export class StatusScreenComponent implements Component {
 	private hints(view: StatusView): ScreenHint[] {
 		const hints: ScreenHint[] = ["Esc close"];
 		if (view.peerRows.length > 0) {
-			hints.push("j/k move", { text: "s stop", color: "warning" }, { text: "d reset", color: "warning" }, "h history");
+			hints.push("j/k move", { text: "s stop", color: "warn" }, { text: "d reset", color: "warn" }, "h history");
 		}
 		hints.push(
 			{ text: "l login", color: "accent" },
 			{ text: "n new", color: "accent" },
-			{ text: "o logout", color: "error" },
+			{ text: "o logout", color: "bad" },
 			"r refresh",
 		);
 		return hints;

package/extensions/worktree/commands.ts

@@ -16,19 +16,16 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { messageOf } from "../../lib/errors.ts";
-import { planModeRefusal } from "../../lib/plan-entry.ts";
-import { isPlanModeEnabled } from "../../lib/plan-state.ts";
-import { withRailsSuppressed } from "../../lib/rails.ts";
 import {
+	enteredWorktree,
 	enterWorktree,
 	exitWorktree,
 	formatWorktreeStatus,
 	isWorktreeCancelled,
 	pruneWorktrees,
-	enteredWorktree,
 	worktreeSnapshot,
 } from "./lifecycle.ts";
-import { type WorktreeAction, WorktreeListComponent } from "./screen.ts";
+import type { WorktreeAction } from "./screen.ts";
 
 interface Completion {
 	value: string;
@@ -45,8 +42,10 @@ const SUBCOMMANDS: Completion[] = [
 const USAGE = "Usage: /worktree [enter [name]|exit|prune]";
 
 /** Refuse a lifecycle change while plan mode is read-only, as `/check` does. */
-function refuseInPlanMode(ctx: ExtensionContext): boolean {
+async function refuseInPlanMode(ctx: ExtensionContext): Promise<boolean> {
+	const { isPlanModeEnabled } = await import("../../lib/plan-state.ts");
 	if (!isPlanModeEnabled(ctx.sessionManager.getBranch())) return false;
+	const { planModeRefusal } = await import("../../lib/plan-entry.ts");
 	ctx.ui.notify(planModeRefusal("changing worktrees"), "warning");
 	return true;
 }
@@ -71,7 +70,7 @@ async function reportLifecycle(ctx: ExtensionContext, verb: string, run: () => P
 }
 
 async function runEnter(pi: ExtensionAPI, ctx: ExtensionContext, name: string | undefined): Promise<void> {
-	if (refuseInPlanMode(ctx)) return;
+	if (await refuseInPlanMode(ctx)) return;
 	// The path on its own line: a command's answer is read without a tool result beside it,
 	// and "which directory am I in now" is the question entering answers.
 	await reportLifecycle(ctx, "Enter", async () => {
@@ -81,12 +80,12 @@ async function runEnter(pi: ExtensionAPI, ctx: ExtensionContext, name: string |
 }
 
 async function runExit(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
-	if (refuseInPlanMode(ctx)) return;
+	if (await refuseInPlanMode(ctx)) return;
 	await reportLifecycle(ctx, "Exit", async () => (await exitWorktree(pi, ctx, {})).output);
 }
 
 async function runPrune(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
-	if (refuseInPlanMode(ctx)) return;
+	if (await refuseInPlanMode(ctx)) return;
 	ctx.ui.notify(await pruneWorktrees(pi, ctx), "info");
 }
 
@@ -100,6 +99,9 @@ async function showWorktrees(pi: ExtensionAPI, ctx: ExtensionContext): Promise<v
 	// The screen closes before an enter or exit runs: both change the session
 	// binding, and `exitWorktree` asks through `ctx.ui.select`, which cannot nest
 	// inside a mounted screen. Prune runs in place, so its verb stays on the screen.
+	const { withRailsSuppressed } = await import("../../lib/rails.ts");
+	const { WorktreeListComponent } = await import("./screen.ts");
+	const { isPlanModeEnabled } = await import("../../lib/plan-state.ts");
 	const action = await withRailsSuppressed(pi, () =>
 		ctx.ui.custom<WorktreeAction | undefined>((tui, theme, _keybindings, done) => {
 			return new WorktreeListComponent({

package/extensions/worktree/enter.ts

@@ -110,7 +110,7 @@ export async function enterWorktree(
 	}
 	if (current) {
 		throw new Error(
-			`Already working in a worktree (${worktreeLabel(current)}). Run /worktree exit, or call exit_worktree, before entering another.`,
+			`Already working in a worktree (${worktreeLabel(current)}). Run /worktree exit, or call \`worktree\` action \`exit\`, before entering another.`,
 		);
 	}
 
@@ -269,7 +269,7 @@ export async function enterWorktree(
 	setStatus(ctx, `${GLYPHS.worktree} ${worktreeLabel(state)}`);
 	const summary =
 		`Entered worktree.\n${stateSummary(state)}\n\n` +
-		`Relative paths now resolve inside the worktree. When finished, call exit_worktree.` +
+		`Relative paths now resolve inside the worktree. When finished, call \`worktree\` action \`exit\`.` +
 		(copiedIncludes.length > 0 ? `\n\nCopied ${copiedIncludes.length} gitignored file(s).` : "");
 	return { state, summary };
 }