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

package/extensions/bytefly/footer/register.ts

@@ -10,7 +10,7 @@
  */
 
 import { homedir } from "node:os";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI, type ExtensionContext, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { SUBAGENT_FINISHED_CHANNEL } from "../../../lib/events.ts";
 import { budgetBody, budgetNotice, budgetState } from "./budget.ts";
 import { createSnapshotReader, type SnapshotReader } from "./collect/snapshot.ts";
@@ -32,6 +32,30 @@ export function registerFooter(pi: ExtensionAPI, deps: FooterDeps = {}): void {
 	const delegation = createDelegationLedger();
 	pi.events.on(SUBAGENT_FINISHED_CHANNEL, (event) => delegation.note(event));
 
+	// The label a peer knows this session by, once the follower below reports one; `null` is
+	// no record, and the bar keeps Pi's own session name.
+	let rosterLabel: string | null = null;
+	/** Whether this session's label is being followed: a tree change re-installs, it is not new. */
+	let followed = false;
+	const followLabel = (ctx: ExtensionContext): void => {
+		if (followed) return;
+		followed = true;
+		// Loaded where it is used: the follower walks the bus's layout on disk and subscribes to
+		// its label, and the registration graph is a budget that may only fall.
+		void import("./collect/label.ts")
+			.then(({ followRosterLabel }) =>
+				followRosterLabel({
+					pi,
+					ctx,
+					agentDir: getAgentDir(),
+					sink: (label) => {
+						rosterLabel = label;
+					},
+				}),
+			)
+			.catch(() => {});
+	};
+
 	/** The installed reader and the budget it was priced with, while a footer is up. */
 	let budget: { limit: number; read: SnapshotReader } | undefined;
 	/** One warning per session: the notice stays in scrollback, and a re-install must not repeat it. */
@@ -41,8 +65,11 @@ export function registerFooter(pi: ExtensionAPI, deps: FooterDeps = {}): void {
 
 	const install = (ctx: ExtensionContext): void => {
 		if (ctx.mode !== "tui") return;
+		// Not awaited: a footer is installed synchronously, and the bar draws Pi's name until the
+		// label lands — which is what a session with no record shows anyway.
+		followLabel(ctx);
 		const config = loadByteflyConfig(ctx.cwd);
-		const read = createSnapshotReader(config, delegation);
+		const read = createSnapshotReader(config, delegation, () => rosterLabel);
 		budget = { limit: config.budget, read };
 
 		ctx.ui.setFooter((tui, _theme, footerData) =>
@@ -57,9 +84,11 @@ export function registerFooter(pi: ExtensionAPI, deps: FooterDeps = {}): void {
 	};
 
 	pi.on("session_start", (_event, ctx) => {
-		// A new session in this process starts from zero: the ledger is not branch state,
-		// and a budget that was already reported is unreported again.
+		// A new session in this process starts from zero: the ledger is not branch state, the
+		// label belongs to the session, and a budget that was already reported is unreported again.
 		delegation.reset();
+		followed = false;
+		rosterLabel = null;
 		warned = false;
 		warnedUnpriced = false;
 		install(ctx);

package/extensions/bytefly/footer/render/lines.ts

@@ -1,13 +1,14 @@
 /**
  * Turn a `StatusSnapshot` into the two footer lines.
  *
- * Line 1 — state: left `pwd` and the session name, right the alert, the mode
- * chips, then `⎇ branch · ⑂ worktree · ◉ 4780`. Line 2 — meters: left
- * the context gauge and usage, right the model and thinking level.
+ * Line 1 — state: left `pwd` and the session name, right the alert, the remaining
+ * status chips, then `⎇ branch · ⑂ worktree · ◉ 4780`. Line 2 — meters: left the
+ * mode, the context gauge, and the usage; right the model and thinking level.
  *
  * The split is one job per row. The state chips change while a session runs, so
  * they ride the line with slack; the meters are the dense row, and a fact that
- * moves onto the top row is one the bottom row stops dropping to fit.
+ * moves onto the top row is one the bottom row stops dropping to fit. The mode
+ * leads the meters because it qualifies every number after it.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
@@ -19,6 +20,7 @@ import {
 	costSegment,
 	delegationSegment,
 	modelSegment,
+	modeSegment,
 	modesSegment,
 	portsSegment,
 	pwdSegment,
@@ -54,6 +56,7 @@ export function buildLines(snapshot: StatusSnapshot, theme: Theme, home: string
 	};
 
 	const line2Left = defined([
+		modeSegment(snapshot, theme),
 		contextSegment(snapshot, theme),
 		windowSegment(snapshot, theme),
 		costSegment(snapshot, theme),

package/extensions/bytefly/footer/render/segments.ts

@@ -24,7 +24,7 @@ import {
 	thinkingColor,
 	truncateLabel,
 } from "./format.ts";
-import { compactStatus, dropStatusDetail } from "./status.ts";
+import { compactStatus } from "./status.ts";
 import type { Segment, StatusSnapshot } from "../types.ts";
 
 /** Tertiary text: paths and de-emphasized meters. */
@@ -55,7 +55,11 @@ export function pwdSegment(snapshot: StatusSnapshot, theme: Theme, home: string
 }
 
 export function sessionSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
-	const name = snapshot.sessionName ? sanitizeLine(snapshot.sessionName) : "";
+	// The roster's label first: Pi's session name is what the terminal calls this session, and
+	// the label is what a card, a handoff, and `/team` use. No record means no team, so the bar
+	// keeps the name the user knows.
+	const raw = snapshot.rosterLabel ?? snapshot.sessionName;
+	const name = raw ? sanitizeLine(raw) : "";
 	if (!name) return null;
 	const short = truncateLabel(name, CONFIG.sessionLabelMax);
 	// Brackets and a brighter token keep the session name from reading as a
@@ -151,15 +155,36 @@ export function alertSegment(snapshot: StatusSnapshot, theme: Theme): Segment |
 	};
 }
 
+/**
+ * The mode: `≡ plan` while planning, `▶ auto` otherwise.
+ *
+ * Plan owns the flag, so the presence of its status key is what the bar reads; the
+ * mode's word and colour are the bar's own, so neither the plan file name nor a
+ * truncated chip can reach it. Planning wears `warn`, the same role the composer's
+ * border takes while it is on. It leads the resource line, before the gauge, so the
+ * mode is read before how much room is left. A session without `plan` still reads
+ * `auto`: that is the mode it is in.
+ */
+export function modeSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
+	if (snapshot.statuses.has(CONFIG.planStatusKey)) {
+		const plan = paint(theme, "warn", `${CONFIG.icons.planMode} ${CONFIG.labels.planMode}`);
+		return { id: "mode", weight: 1, droppable: false, separator: "", forms: [plan, compactStatus(plan)] };
+	}
+	const auto = paint(theme, "accent", `${CONFIG.icons.autoMode} ${CONFIG.labels.autoMode}`);
+	return { id: "mode", weight: 1, droppable: false, separator: "", forms: [auto] };
+}
+
 export function modesSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {
 	const others = [...snapshot.statuses.entries()]
-		.filter(([key]) => key !== CONFIG.worktreeStatusKey && key !== CONFIG.httpStatusKey && !isAlert(key))
+		.filter(
+			([key]) =>
+				key !== CONFIG.planStatusKey &&
+				key !== CONFIG.worktreeStatusKey &&
+				key !== CONFIG.httpStatusKey &&
+				!isAlert(key),
+		)
 		.sort(([a], [b]) => a.localeCompare(b))
-		.map(([key, value]) => {
-			const status = sanitize(value);
-			// The plan chip trails the plan file name; the slot shows the mode only.
-			return key === CONFIG.planStatusKey ? dropStatusDetail(status) : status;
-		})
+		.map(([, value]) => sanitize(value))
 		.filter(Boolean);
 	if (others.length === 0) return null;
 	const full = others.join(faint(theme, CONFIG.separators.item));
@@ -169,7 +194,7 @@ export function modesSegment(snapshot: StatusSnapshot, theme: Theme): Segment |
 	const icons = others.map((status) => compactStatus(status)).join(" ");
 	return {
 		id: "statuses",
-		// Weight 2, ahead of the branch: a mode is stated again by the session, while
+		// Weight 2, ahead of the branch: a status is stated again by the session, while
 		// `⎇` is the only thing on the bar that says where the work will land.
 		weight: 2,
 		droppable: true,
@@ -188,7 +213,9 @@ export function contextSegment(snapshot: StatusSnapshot, theme: Theme): Segment
 	const forms = widths.map((blocks) =>
 		blocks > 0 ? `${gaugeBar(theme, { percent, blocks, role, emptyRole: "faint" })} ${percentText}` : percentText,
 	);
-	return { id: "context", weight: 1, droppable: false, separator: "", forms };
+	// The mode always leads this segment, so the separator prints on every frame;
+	// the gauge's offset is the mode's width, not whether one is present.
+	return { id: "context", weight: 1, droppable: false, separator: faint(theme, CONFIG.separators.item), forms };
 }
 
 export function windowSegment(snapshot: StatusSnapshot, theme: Theme): Segment | null {

package/extensions/bytefly/footer/render/status.ts

@@ -29,14 +29,3 @@ export function compactStatus(status: string): string {
 	const text = tokens.length === 2 && /^\d+$/.test(tokens[1]) ? `${icon}${tokens[1]}` : icon;
 	return `${prefix}${text}${suffix}`;
 }
-
-/**
- * Drop a status's trailing ` · detail` while keeping its SGR styling.
- *
- * The `plan-mode` chip carries the plan file name as detail (`≡ plan · name`);
- * the bar shows only the mode. Matching `[^ESC]*` removes the visible suffix
- * without consuming the closing reset, so the chip's color stays balanced.
- */
-export function dropStatusDetail(status: string): string {
-	return status.replace(/ · [^\x1b]*/, "");
-}

package/extensions/bytefly/footer/types.ts

@@ -84,6 +84,13 @@ export interface StatusSnapshot {
 	cwd: string;
 	/** Session name set by the user, `null` when unnamed. */
 	sessionName: string | null;
+	/**
+	 * The name peers address this session by, when the bus has recorded one.
+	 *
+	 * `null` means no record — bytefly runs without the bus and the bar keeps Pi's own
+	 * session name, which is all a session that never joined has.
+	 */
+	rosterLabel: string | null;
 	/** Branch name, `null` when not in a repository, `"detached"` on detached HEAD. */
 	branch: string | null;
 	/** Extension status texts (from `ctx.ui.setStatus`), including `worktree`. */

package/extensions/bytefly/header/config.ts

@@ -93,7 +93,7 @@ export const HEADER_CONFIG: HeaderConfig = {
 			{ binding: "app.thinking.toggle", description: "to expand thinking" },
 			{ binding: "app.model.select", description: "to select model" },
 			{ binding: "app.model.cycleForward", description: "to cycle models" },
-			{ binding: "app.thinking.cycle", description: "to cycle thinking" },
+			{ raw: "shift+tab", description: "to toggle plan" },
 			{ binding: "app.editor.external", description: "for external editor" },
 		],
 		[

package/extensions/bytefly/index.ts

@@ -1,14 +1,15 @@
 /**
- * bytefly — the package's terminal chrome and diagnostics, composed from eleven
+ * bytefly — the package's terminal chrome and diagnostics, composed from twelve
  * feature folders: `header/` (the themed startup mark and version), `footer/`
  * (the two-line, width-adaptive status bar with its price calculation),
  * `message/` (the user-message nameplate), `notice/` (the shared transcript
  * notice renderer), `block/` (the unified tool-block frame), `separator/` (the
- * transcript turn rule), `working/` (the live run line on Pi's working row),
- * `panel/` (the unified `/bytefly` screen and its
+ * transcript turn rule), `working/` (the live run line on the composer's top
+ * border), `panel/` (the unified `/bytefly` screen and its
  * `doctor` report), `doctor/` (the `run_doctor` tool and its session-scoped
- * probe runtime), `notify/` (OS notifications for unattended runs), and
- * `update/` (Pi's package list, the host suppression, and the header marker).
+ * probe runtime), `notify/` (OS notifications for unattended runs), `mode/`
+ * (the editor's Shift+Tab plan-mode toggle and its border), and `update/` (Pi's
+ * package list, the host suppression, and the header marker).
  *
  * The header, footer, turn rule, and working line are installed
  * only in interactive (`tui`) sessions, and are always on; the user-message
@@ -22,7 +23,7 @@
  * Load with:  pi --extension ./extensions/bytefly
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isExtensionEnabled } from "../../lib/env.ts";
 import { registerToolBlocks } from "./block/register.ts";
 import { registerChrome } from "./chrome.ts";
@@ -87,4 +88,29 @@ export default function bytefly(pi: ExtensionAPI, deps: ByteflyDeps = {}): void
 	// the one repaint hook rather than installing a header of its own.
 	registerPiRelease(pi, piUpdates, { ...deps.release, onUpdate: () => header.refresh() });
 	registerPanel(pi, { doctor, update, discover: deps.extensions?.discover });
+
+	// Shift+Tab is a chord Pi reserves for the thinking cycle, so the mode key is
+	// an editor rather than a shortcut. It loads on the first TUI session and only
+	// when `plan` is loaded, so a session without it keeps Pi's key and pays for
+	// nothing; the mode module owns that availability check.
+	let detachModeKey: (() => void) | undefined;
+	let modeEpoch = 0;
+	const installModeKey = async (ctx: ExtensionContext): Promise<void> => {
+		const epoch = ++modeEpoch;
+		detachModeKey?.();
+		detachModeKey = undefined;
+		if (ctx.mode !== "tui") return;
+		const { attachModeKey } = await import("./mode/editor.ts");
+		// A shutdown or a newer session may land while the module loads; the stale
+		// reply must not install an editor nothing will release.
+		if (epoch !== modeEpoch) return;
+		detachModeKey = attachModeKey(pi, ctx);
+	};
+	pi.on("session_start", (_event, ctx) => installModeKey(ctx));
+	pi.on("session_tree", (_event, ctx) => installModeKey(ctx));
+	pi.on("session_shutdown", () => {
+		modeEpoch++;
+		detachModeKey?.();
+		detachModeKey = undefined;
+	});
 }

package/extensions/bytefly/mode/editor.ts

@@ -0,0 +1,115 @@
+/**
+ * The Shift+Tab chord at the main editor: the plan-mode toggle and the border
+ * that says which mode the composer is in, with the live working line riding it.
+ *
+ * Pi reserves `app.thinking.cycle` on Shift+Tab, so an extension shortcut for the
+ * key is refused. The editor is the narrower place to own it: an overlay or a
+ * picker has focus instead, so a dialog keeps its own Shift+Tab. Attaching also
+ * unsets the built-in cycle binding, because a key that acts and a key the help
+ * still claims are two different answers to the same press.
+ *
+ * Replacing Pi's editor means opting back into what that editor did:
+ * `embedWorkingStatus` is what makes the host hand the working indicator over for
+ * the top border, as Pi's own editor asks for. Without it the indicator falls back
+ * to a row above the composer, and the border would carry the mode colour alone.
+ *
+ * The mode is plan's to own; this module only asks over the shared channel and
+ * reads the branch for the border. Attach once per session and release with the
+ * returned cleanup, which reverts only the editor and binding it still owns.
+ * Without `plan` there is nothing to toggle, so attach does nothing and Pi keeps
+ * its thinking-cycle chord.
+ */
+
+import {
+	CustomEditor,
+	type ExtensionAPI,
+	type ExtensionContext,
+	type KeybindingsManager as AppKeybindingsManager,
+	type Theme,
+} from "@earendil-works/pi-coding-agent";
+import { type EditorTheme, getKeybindings, type KeybindingsManager, type TUI } from "@earendil-works/pi-tui";
+import { isPlanExtensionLoaded, requestPlanToggle } from "../../../lib/plan-entry.ts";
+import { isPlanModeEnabled } from "../../../lib/plan-state.ts";
+import { isShiftTab } from "../../../lib/tui/cursor.ts";
+import { paint } from "../../../lib/tui/tokens.ts";
+
+/** What the editor reads on every input and frame. */
+interface ModeEditorOptions {
+	/** Ask the mode's owner to flip it. */
+	onToggle: () => void;
+	/** The branch is the truth, whoever toggled it. */
+	isPlanning: () => boolean;
+	/** The role theme, read each frame so a theme change repaints. */
+	theme: () => Theme;
+}
+
+/** The composer with Shift+Tab bound to plan mode and its border to the mode's own colour. */
+export class ModeEditor extends CustomEditor {
+	constructor(
+		tui: TUI,
+		theme: EditorTheme,
+		keybindings: KeybindingsManager,
+		private readonly options: ModeEditorOptions,
+	) {
+		// Pi's manager carries the resolved keybindings config on top of the TUI one;
+		// the editor only calls `matches()`, which both provide. The option is the same
+		// one Pi's own editor sets, so the working line lands on this border instead of
+		// in a row of its own above the composer.
+		super(tui, theme, keybindings as unknown as AppKeybindingsManager, { embedWorkingStatus: true });
+	}
+
+	override handleInput(data: string): void {
+		if (isShiftTab(data)) {
+			this.options.onToggle();
+			return;
+		}
+		super.handleInput(data);
+	}
+
+	override render(width: number): string[] {
+		// The two roles the footer's mode segment draws, so the bar and the composer agree.
+		const role = this.options.isPlanning() ? "warn" : "accent";
+		this.borderColor = (text) => paint(this.options.theme(), role, text);
+		return super.render(width);
+	}
+}
+
+/** The binding the editor takes over; Pi's default chord for the thinking cycle. */
+const THINKING_CYCLE = "app.thinking.cycle";
+
+/**
+ * Install the mode editor and take Shift+Tab from the thinking cycle, or return
+ * `undefined` when the `plan` extension is not loaded.
+ *
+ * Returns an idempotent cleanup. It clears the editor only while ours is the
+ * installed factory, and restores the binding only while the empty override it
+ * wrote is still there, so a later extension's editor or binding is never undone.
+ */
+export function attachModeKey(
+	pi: Pick<ExtensionAPI, "events" | "getAllTools">,
+	ctx: ExtensionContext,
+): (() => void) | undefined {
+	if (!isPlanExtensionLoaded(pi)) return undefined;
+	const factory = (tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) =>
+		new ModeEditor(tui, theme, keybindings, {
+			onToggle: () => {
+				void requestPlanToggle(pi, ctx);
+			},
+			isPlanning: () => isPlanModeEnabled(ctx.sessionManager.getBranch()),
+			theme: () => ctx.ui.theme,
+		});
+	const bindings = getKeybindings();
+	const previous = bindings.getUserBindings()[THINKING_CYCLE];
+	ctx.ui.setEditorComponent(factory);
+	bindings.setUserBindings({ ...bindings.getUserBindings(), [THINKING_CYCLE]: [] });
+
+	return () => {
+		if (ctx.ui.getEditorComponent() === factory) ctx.ui.setEditorComponent(undefined);
+		const current = bindings.getUserBindings()[THINKING_CYCLE];
+		if (!Array.isArray(current) || current.length > 0) return;
+		const restored = { ...bindings.getUserBindings() };
+		if (previous === undefined) delete restored[THINKING_CYCLE];
+		else restored[THINKING_CYCLE] = previous;
+		bindings.setUserBindings(restored);
+	};
+}