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

package/extensions/bytefly/panel/commands.ts

@@ -26,8 +26,8 @@ import { formatExtension, formatReport, hasProblems } from "../doctor/format.ts"
 import type { DoctorRuntime } from "../doctor/runtime.ts";
 import { updateOutcomeText } from "../update/format.ts";
 import type { UpdateHandle } from "../update/register.ts";
-import { createSettingsStores, discoverResources, type DiscoveryDeps } from "../picker/discovery.ts";
-import { createPickerRuntime, type PickerRuntime } from "../picker/runtime.ts";
+import type { DiscoveryDeps } from "../picker/discovery.ts";
+import type { PickerRuntime } from "../picker/runtime.ts";
 import type { Discovery } from "../picker/types.ts";
 import { usageRecords } from "../footer/collect/entries.ts";
 import { loadByteflyConfig } from "../footer/price/config.ts";
@@ -35,10 +35,9 @@ import { createPricer } from "../footer/price/price.ts";
 import { formatListing, formatSettingsListing, SKILL_NOUN } from "./format.ts";
 import { pricesReport } from "./prices.ts";
 import { buildPanelModel, buildSkillModel, extensionName } from "./join.ts";
-import { createSettingsRuntime, type SettingsRuntime, type SettingsRuntimeDeps } from "./settings-runtime.ts";
-import { loadSkillIndex, resolvedSkillPaths, type SkillIndex } from "./skills.ts";
+import type { SettingsRuntime, SettingsRuntimeDeps } from "./settings-runtime.ts";
+import type { SkillIndex } from "./skills.ts";
 import { shippedThemeNames } from "./themes.ts";
-import { PanelComponent } from "./tui.ts";
 import type { PanelSection } from "./types.ts";
 
 /** Host seams for the panel command, injected by tests and the composition root. */
@@ -174,12 +173,186 @@ function settingsThemeNames(ctx: ExtensionCommandContext): string[] {
 	}
 }
 
+/** The state one `/bytefly` invocation carries into the branch that answers it. */
+interface PanelRun {
+	pi: ExtensionAPI;
+	deps: PanelCommandDeps;
+	ctx: ExtensionCommandContext;
+	cwd: string;
+	agentDir: string;
+	trusted: boolean;
+	themes: string[];
+	section: PanelSection;
+	name: string | undefined;
+	refresh: boolean;
+	mode: PanelMode;
+}
+
+/** The mounted panel, so a notice before the screen exists still reaches the transcript. */
+interface PanelHolder {
+	current: InstanceType<typeof import("./tui.ts").PanelComponent> | undefined;
+}
+
+/** `/bytefly prices`: one question about the transcript, no discovery. */
+function pricesAnswer(ctx: ExtensionCommandContext, cwd: string): void {
+	const config = loadByteflyConfig(cwd);
+	const active = ctx.model ? { provider: ctx.model.provider, model: ctx.model.id } : undefined;
+	const scanned = usageRecords(ctx.sessionManager.getEntries(), active);
+	ctx.ui.notify(pricesReport(createPricer(config)(scanned.records), config.currency).join("\n"), "info");
+}
+
+/** `/bytefly update` and `/bytefly upgrade`: the check, and the install it offers. */
+async function updateAnswer(
+	deps: PanelCommandDeps,
+	mode: "update" | "upgrade",
+	ctx: ExtensionCommandContext,
+): Promise<void> {
+	if (mode === "update") {
+		const outcome = await deps.update.recheck();
+		const { text, severity } = updateOutcomeText(outcome, pkg.version);
+		ctx.ui.notify(text, severity);
+		return;
+	}
+	const confirmed = await ctx.ui.confirm(
+		"Update packages?",
+		`Run Pi's package manager for every configured package, then reload to use it.`,
+	);
+	if (!confirmed) {
+		ctx.ui.notify("bytefly: update cancelled.", "info");
+		return;
+	}
+	const outcome = await deps.update.apply();
+	const { text, severity } = updateOutcomeText(outcome, pkg.version);
+	ctx.ui.notify(text, severity);
+}
+
+/** Settings outside `tui`: the grouped listing without resolving packages. */
+function settingsText(
+	run: PanelRun,
+	makeSettings: NonNullable<PanelCommandDeps["settings"]>,
+	createSettingsStores: (cwd: string, agentDir: string, trusted: boolean) => Discovery["stores"],
+	surfaceNotice: (message: string, kind?: "warning" | "error") => void,
+): void {
+	const stores = createSettingsStores(run.cwd, run.agentDir, run.trusted);
+	const settings = makeSettings({
+		stores,
+		cwd: run.cwd,
+		agentDir: run.agentDir,
+		trusted: run.trusted,
+		themes: run.themes,
+		onError: (message) => surfaceNotice(message, "warning"),
+	});
+	run.ctx.ui.notify(formatSettingsListing(settings.views("global")), "info");
+}
+
+/** Skills outside `tui`: the grouped listing from Pi's metadata, with no probe. */
+function skillsText(
+	run: PanelRun,
+	runtime: PickerRuntime,
+	discovery: Discovery,
+	loadSkills: (paths: readonly string[], cwd: string, agentDir: string) => SkillIndex,
+	resolveSkillPaths: (discovery: Discovery) => string[],
+): void {
+	const index = loadSkills(resolveSkillPaths(discovery), run.cwd, run.agentDir);
+	const model = buildSkillModel({ items: runtime.items("skills"), index, agentDir: run.agentDir });
+	run.ctx.ui.notify(
+		formatListing(model, runtime.scope(), { noun: SKILL_NOUN, emptyLabel: "No skills found." }),
+		"info",
+	);
+}
+
+/** Text modes: probe now, then print the report, a named extension, or the listing. */
+async function reportText(run: PanelRun, runtime: PickerRuntime): Promise<void> {
+	let reports: ExtensionReport[];
+	try {
+		reports = await run.deps.doctor.probeAll({ refresh: run.refresh });
+	} catch (error) {
+		run.ctx.ui.notify(`Could not probe extensions: ${error instanceof Error ? error.message : String(error)}`, "error");
+		return;
+	}
+	if (run.name !== undefined) {
+		notifyExtension(run.ctx, run.name, reports, runtime);
+		return;
+	}
+	if (run.mode === "doctor") {
+		run.ctx.ui.notify(formatReport(reports), hasProblems(reports) ? "warning" : "info");
+		return;
+	}
+	const model = buildPanelModel({ items: runtime.items("extensions"), reports, agentDir: run.agentDir });
+	run.ctx.ui.notify(formatListing(model, runtime.scope()), "info");
+}
+
+/** The TUI branch: mount the screen, then apply any pending write. */
+async function mountPanel(
+	run: PanelRun,
+	state: {
+		runtime: PickerRuntime;
+		settings: SettingsRuntime;
+		discovery: Discovery;
+		loadSkills: (paths: readonly string[], cwd: string, agentDir: string) => SkillIndex;
+		resolveSkillPaths: (discovery: Discovery) => string[];
+		cached: ExtensionReport[] | undefined;
+		holder: PanelHolder;
+	},
+): Promise<void> {
+	const { runtime, settings, discovery, loadSkills, resolveSkillPaths, cached, holder } = state;
+	const { ctx, section, name, refresh, agentDir, cwd } = run;
+	let reports: ExtensionReport[] = cached ?? [];
+
+	const { PanelComponent } = await import("./tui.ts");
+	// The dock screen owns the editor slot; hide the rails for its lifetime.
+	await withRailsSuppressed(run.pi, () =>
+		ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+			const unsubscribe = runtime.onChange(() => tui.requestRender());
+			// The settings runtime re-reads its snapshot after a write; without a
+			// subscriber that repaint depends on every write chain's own callback.
+			const unsubscribeSettings = settings.onChange(() => tui.requestRender());
+			const component = new PanelComponent({
+				runtime,
+				reports: () => reports,
+				settings,
+				filter: section === "extensions" ? name : undefined,
+				section,
+				theme,
+				agentDir,
+				cwd,
+				// A cached session probes only when the command asked for it.
+				needsProbe: cached === undefined || refresh,
+				initialRefresh: refresh,
+				viewportRows: () => tui.terminal?.rows,
+				requestRender: () => tui.requestRender(),
+				skills: () => loadSkills(resolveSkillPaths(discovery), cwd, agentDir),
+				refresh: async (force) => {
+					reports = await run.deps.doctor.probeAll({ refresh: force === true });
+				},
+				reload: async () => {
+					// The reload takes the session, so the screen asks first and says
+					// what will change; a refusal leaves the dock exactly as it was.
+					const reload = await ctx.ui.confirm("Reload to apply changes?", "Changes take effect after a reload.");
+					if (!reload) return;
+					await ctx.reload();
+				},
+				onClose: () => {
+					// A late error falls back to the transcript, never a disposed screen.
+					holder.current = undefined;
+					unsubscribe();
+					unsubscribeSettings();
+					done();
+				},
+			});
+			holder.current = component;
+			component.prime();
+			return component;
+		}),
+	);
+
+	if (!runtime.isDirty() && !settings.isDirty()) return;
+	const reload = await ctx.ui.confirm("Reload to apply changes?", "Changes take effect after a reload.");
+	if (reload) await ctx.reload();
+}
+
 /** Register the single `/bytefly` command. */
 export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
-	const discover = deps.discover ?? discoverResources;
-	const makeSettings = deps.settings ?? createSettingsRuntime;
-	const loadSkills = deps.skills ?? loadSkillIndex;
-
 	const handler = async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
 		const { mode, section, name, refresh } = parseArgs(args);
 		// Only the Extensions section takes an extension argument; a stray word is a
@@ -193,13 +366,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 		// prices what the transcript already recorded and names what that left out. It runs
 		// in every mode, because the footer that would carry the same fact exists only in
 		// `tui`.
-		if (mode === "prices") {
-			const config = loadByteflyConfig(cwd);
-			const active = ctx.model ? { provider: ctx.model.provider, model: ctx.model.id } : undefined;
-			const scanned = usageRecords(ctx.sessionManager.getEntries(), active);
-			ctx.ui.notify(pricesReport(createPricer(config)(scanned.records), config.currency).join("\n"), "info");
-			return;
-		}
+		if (mode === "prices") return pricesAnswer(ctx, cwd);
 
 		const agentDir = getAgentDir();
 		const trusted = ctx.isProjectTrusted();
@@ -208,47 +375,28 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 		// the frame, not appended to the transcript behind it. Before the screen
 		// exists (the non-TUI settings path, a pre-mount failure) the transcript is
 		// the only surface.
-		let panel: PanelComponent | undefined;
+		const holder: PanelHolder = { current: undefined };
 		const surfaceNotice = (message: string, kind: "warning" | "error" = "warning"): void => {
-			if (panel) panel.notify(message);
+			if (holder.current) holder.current.notify(message);
 			else ctx.ui.notify(message, kind);
 		};
 		const settingsNotice = (message: string): void => surfaceNotice(message, "warning");
+		const run: PanelRun = { pi, deps, ctx, cwd, agentDir, trusted, themes, section, name, refresh, mode };
 
-		// `/bytefly update` answers one question and resolves nothing: no package
-		// discovery, no doctor probe, no screen. It is the one path a version check
-		// takes on demand, so the request happens here and nowhere else.
-		if (mode === "update") {
-			const outcome = await deps.update.recheck();
-			const { text, severity } = updateOutcomeText(outcome, pkg.version);
-			ctx.ui.notify(text, severity);
-			return;
-		}
+		// `/bytefly update` answers one question and resolves nothing; `upgrade` is the
+		// same subject one verb further, behind a confirmation because it writes.
+		if (mode === "update" || mode === "upgrade") return updateAnswer(deps, mode, ctx);
 
-		// `/bytefly upgrade` is the only path here that writes, and it writes outside
-		// the session: Pi's package manager replaces the installed files, so the
-		// confirmation and the reload line are part of the answer, not decoration.
-		if (mode === "upgrade") {
-			const confirmed = await ctx.ui.confirm(
-				"Update packages?",
-				`Run Pi's package manager for every configured package, then reload to use it.`,
-			);
-			if (!confirmed) {
-				ctx.ui.notify("bytefly: update cancelled.", "info");
-				return;
-			}
-			const outcome = await deps.update.apply();
-			const { text, severity } = updateOutcomeText(outcome, pkg.version);
-			ctx.ui.notify(text, severity);
-			return;
-		}
+		// Settings, discovery, and the picker are the command's, not registration's: the
+		// price, update, and upgrade answers above resolve none of them.
+		const makeSettings = deps.settings ?? (await import("./settings-runtime.ts")).createSettingsRuntime;
+		const { createSettingsStores, discoverResources } = await import("../picker/discovery.ts");
+		const discover = deps.discover ?? discoverResources;
 
 		// Settings outside `tui` prints its grouped listing without resolving
 		// packages or probing the doctor.
 		if (section === "settings" && ctx.mode !== "tui") {
-			const stores = createSettingsStores(cwd, agentDir, trusted);
-			const settings = makeSettings({ stores, cwd, agentDir, trusted, themes, onError: settingsNotice });
-			ctx.ui.notify(formatSettingsListing(settings.views("global")), "info");
+			settingsText(run, makeSettings, createSettingsStores, surfaceNotice);
 			return;
 		}
 
@@ -269,6 +417,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			onError: settingsNotice,
 		});
 
+		const { createPickerRuntime } = await import("../picker/runtime.ts");
 		const runtime = createPickerRuntime({
 			discovery,
 			cwd,
@@ -283,15 +432,13 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			return;
 		}
 
+		const { loadSkillIndex, resolvedSkillPaths } = await import("./skills.ts");
+		const loadSkills = deps.skills ?? loadSkillIndex;
+
 		// Skills outside `tui` print the same grouped listing, from the metadata Pi's
 		// loader reads; there is no report to probe for and no package to resolve.
 		if (section === "skills" && ctx.mode !== "tui") {
-			const index = loadSkills(resolvedSkillPaths(discovery), cwd, agentDir);
-			const model = buildSkillModel({ items: runtime.items("skills"), index, agentDir });
-			ctx.ui.notify(
-				formatListing(model, runtime.scope(), { noun: SKILL_NOUN, emptyLabel: "No skills found." }),
-				"info",
-			);
+			skillsText(run, runtime, discovery, loadSkills, resolvedSkillPaths);
 			return;
 		}
 
@@ -299,77 +446,20 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 		// the session cache and probes on its first Extensions view instead, which
 		// keeps `/bytefly` and `/bytefly settings` instant.
 		const cached = deps.doctor.peek();
-		let reports: ExtensionReport[] = cached ?? [];
-
 		if (ctx.mode !== "tui") {
-			try {
-				reports = await deps.doctor.probeAll({ refresh });
-			} catch (error) {
-				ctx.ui.notify(`Could not probe extensions: ${error instanceof Error ? error.message : String(error)}`, "error");
-				return;
-			}
-			if (name !== undefined) {
-				notifyExtension(ctx, name, reports, runtime);
-				return;
-			}
-			if (mode === "doctor") {
-				ctx.ui.notify(formatReport(reports), hasProblems(reports) ? "warning" : "info");
-				return;
-			}
-			const model = buildPanelModel({ items: runtime.items("extensions"), reports, agentDir });
-			ctx.ui.notify(formatListing(model, runtime.scope()), "info");
+			await reportText(run, runtime);
 			return;
 		}
 
-		// The dock screen owns the editor slot; hide the rails for its lifetime.
-		await withRailsSuppressed(pi, () =>
-			ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
-				const unsubscribe = runtime.onChange(() => tui.requestRender());
-				// The settings runtime re-reads its snapshot after a write; without a
-				// subscriber that repaint depends on every write chain's own callback.
-				const unsubscribeSettings = settings.onChange(() => tui.requestRender());
-				const component = new PanelComponent({
-					runtime,
-					reports: () => reports,
-					settings,
-					filter: section === "extensions" ? name : undefined,
-					section,
-					theme,
-					agentDir,
-					cwd,
-					// A cached session probes only when the command asked for it.
-					needsProbe: cached === undefined || refresh,
-					initialRefresh: refresh,
-					viewportRows: () => tui.terminal?.rows,
-					requestRender: () => tui.requestRender(),
-					skills: () => loadSkills(resolvedSkillPaths(discovery), cwd, agentDir),
-					refresh: async (force) => {
-						reports = await deps.doctor.probeAll({ refresh: force === true });
-					},
-					reload: async () => {
-						// The reload takes the session, so the screen asks first and says
-						// what will change; a refusal leaves the dock exactly as it was.
-						const reload = await ctx.ui.confirm("Reload to apply changes?", "Changes take effect after a reload.");
-						if (!reload) return;
-						await ctx.reload();
-					},
-					onClose: () => {
-						// A late error falls back to the transcript, never a disposed screen.
-						panel = undefined;
-						unsubscribe();
-						unsubscribeSettings();
-						done();
-					},
-				});
-				panel = component;
-				component.prime();
-				return component;
-			}),
-		);
-
-		if (!runtime.isDirty() && !settings.isDirty()) return;
-		const reload = await ctx.ui.confirm("Reload to apply changes?", "Changes take effect after a reload.");
-		if (reload) await ctx.reload();
+		await mountPanel(run, {
+			runtime,
+			settings,
+			discovery,
+			loadSkills,
+			resolveSkillPaths: resolvedSkillPaths,
+			cached,
+			holder,
+		});
 	};
 
 	pi.registerCommand("bytefly", {

package/extensions/bytefly/panel/format.ts

@@ -9,9 +9,9 @@
  * from a probe or a settings file is sanitized before it is printed.
  *
  * A row has two enablement axes: the picker's settings (`◼`/`◻`) and this
- * session's `PI_DISABLED_EXTENSIONS`. `rowBadge` is the one place that decides
- * how they read, so the screen, the text listing, and the counts cannot
- * contradict each other.
+ * session's environment — the disable list, and the opt-in list a default-off
+ * extension needs. `rowBadge` is the one place that decides how they read, so
+ * the screen, the text listing, and the counts cannot contradict each other.
  */
 
 import { sanitizeLine } from "../../../lib/format.ts";
@@ -182,7 +182,7 @@ interface RowBadge {
 /**
  * The row's badge. Settings is the enablement axis the checkbox already shows,
  * so an off row gets one verdict (`off`) instead of a health word that
- * contradicts it. `PI_DISABLED_EXTENSIONS` is a different axis, so it is named
+ * contradicts it. The environment switch is a different axis, so it is named
  * rather than sharing the word: `env disabled`. A skill has no probed report, so
  * its own file supplies the verdict: `not loaded` when Pi refused it, `hidden`
  * when it is reachable only through `/skill:<name>`. The glyph marks what needs

package/extensions/bytefly/panel/settings.ts

@@ -9,8 +9,9 @@
  * The catalogue is the shortlist a session changes, not the whole document: every
  * row is one a workflow differs on, and each states its own rule so a value the
  * screen accepts is a value the loader keeps. The catalogue order is the screen's
- * order, and it is capped so the section fits a 24-row terminal (`settings.test.ts`
- * holds the ceiling); a new row has to displace one. Everything else stays
+ * order, and it is capped — fifteen rows and their five headings want a 28-row
+ * terminal, and a shorter one scrolls the list rather than the frame
+ * (`settings.test.ts` holds the ceiling); a new row has to displace one. Everything else stays
  * `bytefly.json` — a list (`doctor.skip`), a table (`price.rates`), a schedule
  * (`price.peak`), and the tuning numbers and labels this screen deliberately does
  * not carry — documented in `docs/configuration.md` and reachable from the JSON
@@ -25,6 +26,9 @@
  */
 
 import { configSection, configValueAt } from "../../../lib/config.ts";
+import { DEFAULT_BOARD_CONFIG, normalizeBoardConfig } from "../../../lib/board/config.ts";
+import { MAX_LABEL } from "../../../lib/session-label.ts";
+import { MAX_WIP } from "../../../lib/board/limits.ts";
 import { DEFAULT_CONFIG as DEFAULT_DOCTOR_CONFIG, normalizeConfig as normalizeDoctorConfig } from "../doctor/config.ts";
 import {
 	CURRENCY_DEFAULTS,
@@ -53,7 +57,7 @@ type SettingOrigin = "default" | "global" | "project" | "inherited";
  * rows read as four short lists: what a session starts with, what it tells you
  * about, what it keeps, and what it costs.
  */
-export type SettingGroup = "Startup" | "Notifications" | "Session" | "Price";
+export type SettingGroup = "Startup" | "Notifications" | "Session" | "Board" | "Price";
 
 /** One curated value a row can take. */
 interface SettingOption {
@@ -70,7 +74,7 @@ interface TextRule {
 }
 
 /** The `bytefly.json` sections a row still reaches. */
-export type ConfigSectionName = "notify" | "doctor" | "price" | "rewind" | "job";
+export type ConfigSectionName = "notify" | "doctor" | "price" | "rewind" | "job" | "board";
 
 /** Where a `bytefly.json` row lives: a section, and the path to its leaf. */
 interface SettingConfig {
@@ -153,12 +157,29 @@ function amountRule(min: number, max: number): TextRule {
 	};
 }
 
+/**
+ * A text rule for a whole number inside an inclusive range: the board's two WIP limits, at the
+ * `1..MAX_WIP` the loader clamps to, so the screen cannot save a number the board would shorten.
+ */
+function countRule(min: number, max: number): TextRule {
+	return {
+		maxLength: 2,
+		validate(raw) {
+			const text = raw.trim();
+			if (!/^\d+$/.test(text)) return `Use a whole number, ${min} to ${max}.`;
+			const value = Number(text);
+			if (value < min || value > max) return `Out of range: ${min} to ${max}.`;
+			return undefined;
+		},
+	};
+}
+
 /**
  * The catalogue, in screen order.
  *
- * Global scope lists all twelve; Project lists the ten `bytefly.json` rows,
+ * Global scope lists all fifteen; Project lists the thirteen `bytefly.json` rows,
  * because Pi's setters write the personal `settings.json` only. The list is
- * capped so the screen keeps fitting a 24-row terminal.
+ * capped, and the cap with its reason is stated where the screen's height is.
  */
 export const SETTING_ROWS: readonly SettingDescriptor[] = [
 	{
@@ -281,6 +302,50 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		options: ON_OFF,
 		config: { section: "doctor", path: ["proactive"] },
 	},
+	{
+		id: "board.wip.plan",
+		group: "Board",
+		label: "Plan limit",
+		description: "How many cards the board lets a repository plan at once, 1 to 20; `bytefly.json` `board.wip.plan`.",
+		source: "bytefly",
+		kind: "text",
+		fallback: String(DEFAULT_BOARD_CONFIG.wip.plan),
+		json: "number",
+		options: [],
+		text: countRule(1, MAX_WIP),
+		config: { section: "board", path: ["wip", "plan"] },
+	},
+	{
+		id: "board.wip.execute",
+		group: "Board",
+		label: "Execute limit",
+		description:
+			"How many cards the board lets a repository execute at once, 1 to 20; `bytefly.json` `board.wip.execute`.",
+		source: "bytefly",
+		kind: "text",
+		fallback: String(DEFAULT_BOARD_CONFIG.wip.execute),
+		json: "number",
+		options: [],
+		text: countRule(1, MAX_WIP),
+		config: { section: "board", path: ["wip", "execute"] },
+	},
+	{
+		id: "board.lead",
+		group: "Board",
+		label: "Lead",
+		description:
+			"The team name whose signature approves a contract and spot-checks the work; a card's holder never signs.",
+		source: "bytefly",
+		kind: "text",
+		fallback: DEFAULT_BOARD_CONFIG.lead,
+		options: [],
+		text: {
+			maxLength: MAX_LABEL,
+			validate: (raw) =>
+				raw.trim() === "" ? "A lead needs a name; `u` clears the key and the default comes back." : undefined,
+		},
+		config: { section: "board", path: ["lead"] },
+	},
 	{
 		id: "price.currency.code",
 		group: "Price",
@@ -432,6 +497,8 @@ const SECTION_READERS: Partial<Record<ConfigSectionName, SectionReader>> = {
 		configValueAt(normalizeDoctorConfig(projectRaw, normalizeDoctorConfig(globalRaw, DEFAULT_DOCTOR_CONFIG)), path),
 	price: (globalRaw, projectRaw, path) =>
 		configValueAt(normalizeByteflyConfig(projectRaw, normalizeByteflyConfig(globalRaw, DEFAULT_BYTEFLY_CONFIG)), path),
+	board: (globalRaw, projectRaw, path) =>
+		configValueAt(normalizeBoardConfig(projectRaw, normalizeBoardConfig(globalRaw, DEFAULT_BOARD_CONFIG)), path),
 };
 
 /**

package/extensions/bytefly/panel/tui/keys.ts

@@ -16,7 +16,7 @@ import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey } from "@earendil-works/pi-tui";
 import type { ScreenHint } from "../../../../lib/tui/chrome.ts";
 import { clip, padTo } from "../../../../lib/tui/columns.ts";
-import { isCloseKey } from "../../../../lib/tui/cursor.ts";
+import { isCloseKey, isShiftTab } from "../../../../lib/tui/cursor.ts";
 import { BODY_INDENT } from "../../../../lib/tui/indent.ts";
 import { paint } from "../../../../lib/tui/tokens.ts";
 import type { PanelSection } from "../types.ts";
@@ -58,9 +58,6 @@ export interface PanelKey {
 const ALL: readonly PanelSection[] = ["extensions", "skills", "settings"];
 const LISTS: readonly PanelSection[] = ["extensions", "skills"];
 
-/** Shift+Tab arrives as this sequence on terminals without the Kitty protocol. */
-const SHIFT_TAB = "\u001b[Z";
-
 /** The screen's keys, in help order. */
 export const PANEL_KEYS: readonly PanelKey[] = [
 	{
@@ -75,8 +72,7 @@ export const PANEL_KEYS: readonly PanelKey[] = [
 		label: "←",
 		sections: ALL,
 		help: "Previous section",
-		match: (data) =>
-			matchesKey(data, Key.left) || data === "h" || matchesKey(data, Key.shift("tab")) || data === SHIFT_TAB,
+		match: (data) => matchesKey(data, Key.left) || data === "h" || isShiftTab(data),
 	},
 	{
 		id: "nextSection",

package/extensions/bytefly/update/cache.ts

@@ -21,7 +21,7 @@ import { writeConfigFile } from "../../../lib/config.ts";
 import type { PackageUpdate } from "./types.ts";
 import { parseVersion } from "./version.ts";
 
-/** The file name under `<agentDir>/bytefly/`. */
+/** The file name under `<agent-dir>/bytefly/`. */
 export const UPDATE_CACHE_FILE = "update.json";
 
 /** How long a cached snapshot is reused before the next session re-reads. */

package/extensions/bytefly/update/register.ts

@@ -30,7 +30,7 @@ import {
 import { applyUpdates, fetchAvailableUpdates, fetchLatestVersion } from "./check.ts";
 import { isOwnPackage, updateNotice } from "./format.ts";
 import { paintLatest, type UpdateOutcome, type UpdateSource } from "./state.ts";
-import { suppressPiPackageUpdates, type UpdateSuppression } from "./suppress.ts";
+import type { UpdateSuppression } from "./suppress.ts";
 import type { PackageUpdate, PackageUpdateCheck } from "./types.ts";
 import { isNewerVersion } from "./version.ts";
 
@@ -112,7 +112,7 @@ export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: Up
 	const offline = deps.isOffline ?? isOffline;
 	const cache = deps.cache ?? diskCache();
 	const now = deps.now ?? Date.now;
-	const suppress = deps.suppress ?? suppressPiPackageUpdates;
+	const suppress = deps.suppress ?? (async () => (await import("./suppress.ts")).suppressPiPackageUpdates());
 	// A session is announced at most once per load, even if `session_start` fires
 	// again after a resume or a session replacement.
 	let announced = false;
@@ -203,12 +203,12 @@ export function registerUpdate(pi: ExtensionAPI, updates: UpdateSource, deps: Up
 		}
 	};
 
-	pi.on("session_start", (_event, ctx) => {
+	pi.on("session_start", async (_event, ctx) => {
 		// `/bytefly update` can answer in any mode; only the TUI installs the host
 		// shim and posts a notice.
 		context = ctx;
 		if (ctx.mode !== "tui") return;
-		suppression ??= suppress();
+		suppression ??= await suppress();
 		const cached = cache.read();
 		const key = keyFor(ctx);
 		if (offline()) {

package/extensions/bytefly/working/config.ts

@@ -1,19 +1,17 @@
 /**
  * Tuning for bytefly's live working line.
  *
- * While Pi's working row is up, the message is written into the row beside Pi's
- * spinner. Edit this file to change the words or how often the count advances.
+ * While the composer's top border carries Pi's working indicator, the message is
+ * written into the border beside Pi's spinner. Edit this file to change the word
+ * or how often the count advances.
  */
 
 export const WORKING_CONFIG = {
-	/** Word before the count, before the first tool starts. */
-	working: "Working",
-	/** Between the word and the count. */
-	ellipsis: "…",
+	/** The word the line leads with, after Pi's spinner. */
+	working: "working",
 	/** How often the count advances, in milliseconds. */
 	intervalMs: 1000,
 } as const satisfies {
 	working: string;
-	ellipsis: string;
 	intervalMs: number;
 };