@gavin-hu/my-pi-agent 0.14.0 → 0.15.0

package/extensions/bytefly/block/component.ts

@@ -28,7 +28,7 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { type Component, stripTerminalSequences, truncateToWidth } from "@earendil-works/pi-tui";
 import { sanitizeLine } from "../../../lib/format.ts";
-import { BODY_INDENT, bodyLines, indentBlockLines } from "../../../lib/tui/indent.ts";
+import { BODY_INDENT, bodyLines, indentBlockLines, isBlank } from "../../../lib/tui/indent.ts";
 import { RenderCache } from "../../../lib/tui/render-cache.ts";
 import { paintPrefix } from "../../../lib/tui/tokens.ts";
 
@@ -174,14 +174,6 @@ export function isRewritable(component: Component): component is Component & Rew
 	return typeof candidate.text === "string" && typeof candidate.setText === "function";
 }
 
-/**
- * Whether a line has no visible text. Tested after stripping terminal sequences,
- * so a line carrying only a background or the indent counts as blank.
- */
-function isBlankLine(line: string): boolean {
-	return stripTerminalSequences(line).trim().length === 0;
-}
-
 /**
  * Whether a call line degenerated to the tool name alone, so the rest of it —
  * the path, the command — moved onto the body lines under it.
@@ -195,7 +187,7 @@ function isBlankLine(line: string): boolean {
  */
 function isBareHeadline(body: readonly string[], toolName: string | undefined): boolean {
 	if (!toolName) return false;
-	const headline = body.find((line) => !isBlankLine(line));
+	const headline = body.find((line) => !isBlank(line));
 	return headline !== undefined && stripTerminalSequences(headline).trim() === sanitizeLine(toolName);
 }
 
@@ -206,9 +198,9 @@ function isBareHeadline(body: readonly string[], toolName: string | undefined):
  */
 function callContinuationCount(body: readonly string[], toolName: string | undefined): number {
 	if (!isBareHeadline(body, toolName)) return 0;
-	let index = body.findIndex((line) => !isBlankLine(line)) + 1;
+	let index = body.findIndex((line) => !isBlank(line)) + 1;
 	let count = 0;
-	while (index < body.length && !isBlankLine(body[index] ?? "")) {
+	while (index < body.length && !isBlank(body[index] ?? "")) {
 		count++;
 		index++;
 	}
@@ -228,7 +220,7 @@ function frameLines(
 	options: ToolBlockOptions = {},
 ): string[] {
 	const w = Math.max(1, width);
-	const indent = (outputPad ?? 0) + BODY_INDENT;
+	const indent = outputPad + BODY_INDENT;
 	const lines = indentBlockLines(body, w, {
 		indent,
 		rail: options.rail,
@@ -277,7 +269,7 @@ export function toolBlockLines(
 	options: ToolBlockOptions = {},
 ): string[] {
 	const w = Math.max(1, width);
-	const indent = (outputPad ?? 0) + BODY_INDENT;
+	const indent = outputPad + BODY_INDENT;
 	return frameLines(bodyLines(inner, w, indent), w, outputPad, options);
 }
 
@@ -307,7 +299,7 @@ export class ToolBlock implements Component {
 
 	render(width: number): string[] {
 		const w = Math.max(1, width);
-		const indent = (this.outputPad ?? 0) + BODY_INDENT;
+		const indent = this.outputPad + BODY_INDENT;
 		const body = bodyLines(this.inner, w, indent);
 		return this.cache.lines(w, body, () => frameLines(body, w, this.outputPad, this.options));
 	}

package/extensions/bytefly/block/register.ts

@@ -55,7 +55,12 @@ import { isRewritable, recolorCallHeadline, recolorShellCall, ToolBlock } from "
 import { BLOCK_CONFIG, type BlockStatus } from "./config.ts";
 import { callFallback, resultFallback } from "./fallback.ts";
 
-/** Per-row memory of the base renderer's own components, kept off Pi's state. */
+/**
+ * Per-row memory of the base renderer's own components, stored in the `state`
+ * Pi creates for one tool row and hands to both its call and its result
+ * renderer. Keeping the base components there is what lets the row keep them
+ * while `lastComponent` points at this frame instead.
+ */
 interface BlockMemory {
 	byteflyBaseCall?: Component;
 	byteflyBaseResult?: Component;

package/extensions/bytefly/doctor/register.ts

@@ -45,7 +45,11 @@ export function registerDoctor(pi: ExtensionAPI, deps: DoctorDeps = {}): DoctorR
 	// without importing the extension.
 	pi.events.on(WEB_SEARCH_PROVIDER_CHANNEL, (facts) => runtime.noteSearchFacts(facts));
 
-	pi.on("session_start", async (_event, ctx) => {
+	// Bumped when a session starts or ends, so a probe that outlives its session
+	// cannot post its notice into the next one (a reload re-registers the surface).
+	let probeToken = 0;
+
+	pi.on("session_start", (_event, ctx) => {
 		const config = loadConfig(ctx.cwd);
 		runtime.configure({ cwd: ctx.cwd, config });
 		if (!config.proactive || !ctx.hasUI) return;
@@ -55,12 +59,27 @@ export function registerDoctor(pi: ExtensionAPI, deps: DoctorDeps = {}): DoctorR
 		if (pi.getSettings?.().quietStartup !== true) return;
 
 		// Only hard requirements can break an enabled extension, so the startup
-		// probe is limited to the extensions that declare one, in parallel.
-		const missing = missingFindings(await runtime.probeRequired());
-		if (missing.length > 0) pi.sendMessage(warningNotice(missing));
+		// probe is limited to the extensions that declare one, in parallel. Fired
+		// without awaiting: Pi awaits every `session_start` handler, and these
+		// probes spawn processes, so holding the first prompt on them is the cost
+		// this avoids. The notice lands a moment later, in the flow, as before.
+		const token = ++probeToken;
+		void runtime
+			.probeRequired()
+			.then((reports) => {
+				if (token !== probeToken) return;
+				const missing = missingFindings(reports);
+				if (missing.length > 0) pi.sendMessage(warningNotice(missing));
+			})
+			.catch(() => {
+				// A background check never surfaces an error, and the report is advice.
+			});
 	});
 
-	pi.on("session_shutdown", () => runtime.reset());
+	pi.on("session_shutdown", () => {
+		probeToken += 1;
+		runtime.reset();
+	});
 
 	return runtime;
 }

package/extensions/bytefly/doctor/tools.ts

@@ -57,7 +57,11 @@ export function registerTools(pi: ExtensionAPI, runtime: DoctorRuntime): void {
 		],
 		parameters: DoctorParams,
 		outputSchema: DoctorOutput,
+		// `refresh` reaches the configured search endpoint, but that URL comes from
+		// config, not from the model, so the tool stays closed-world for the policy.
+		// `probeAll` writes the session's report cache, so its calls are ordered.
 		annotations: { readOnlyHint: true, openWorldHint: false },
+		executionMode: "sequential",
 
 		async execute(_toolCallId, params, _signal, onUpdate, _ctx) {
 			const args = params as DoctorArgs;

package/extensions/bytefly/footer/collect/snapshot.ts

@@ -48,6 +48,7 @@ export function createSnapshotReader(config: ByteflyConfig, delegation: Delegati
 	let delegationTotals = { runs: 0, usage: emptyUsage() };
 	let cacheHitRate: number | null = null;
 	let context: ContextInfo = { tokens: null, contextWindow: 0, percent: null };
+	let sessionName: string | null = null;
 
 	let last: UsageTotals | undefined;
 
@@ -70,6 +71,10 @@ export function createSnapshotReader(config: ByteflyConfig, delegation: Delegati
 				contextWindow: usageInfo?.contextWindow ?? current?.contextWindow ?? 0,
 				percent: usageInfo?.percent ?? null,
 			};
+			// The host walks the file backwards for the latest `session_info`, and a
+			// session renamed early makes that the whole transcript. A rename appends
+			// an entry, which moves the leaf, so the memo key already covers it.
+			sessionName = session.getSessionName() ?? null;
 			key = nextKey;
 			last = usage;
 		}
@@ -80,7 +85,7 @@ export function createSnapshotReader(config: ByteflyConfig, delegation: Delegati
 
 		return {
 			cwd: ctx.cwd,
-			sessionName: ctx.sessionManager.getSessionName() ?? null,
+			sessionName,
 			branch: footerData.getGitBranch(),
 			statuses: footerData.getExtensionStatuses(),
 			model,

package/extensions/bytefly/footer/config.ts

@@ -1,8 +1,8 @@
 /**
  * Tuning for the two-line status bar.
  *
- * The bar's own content and layout: context thresholds, gauge glyphs and
- * widths, separators, icons, status keys, and label limits. Segment weights
+ * The bar's own content and layout: context thresholds, gauge widths,
+ * separators, icons, status keys, and label limits. Segment weights
  * live on the segments themselves (see `../render/segments.ts`); the price
  * configuration is `bytefly.json`, read by `../price/config.ts`.
  */
@@ -12,10 +12,14 @@ import { GLYPHS, SEPARATORS, STATUS_KEYS } from "../../../lib/tui/glyphs.ts";
 export const CONFIG = {
 	/** Context percentage thresholds. */
 	thresholds: { warn: 70, danger: 90 },
-	/** Gauge glyphs, and the block counts the gauge steps down through. */
-	gauge: { full: GLYPHS.gaugeFull, empty: GLYPHS.gaugeEmpty, widths: [10, 5, 3, 0] as const },
-	/** Separators printed before grouped and other segments. */
-	separators: { group: SEPARATORS.group, item: SEPARATORS.item },
+	/** The block counts the context gauge steps down through. */
+	gauge: { widths: [10, 5, 3, 0] as const },
+	/**
+	 * Separators printed before grouped and other segments. The group divider is
+	 * the footer's own solid `│`, not the shared `╎`: that glyph is the transcript
+	 * rail (and `chrome.rail`'s default), and a status line is not a rail.
+	 */
+	separators: { group: " │ ", item: SEPARATORS.item },
 	icons: {
 		branch: GLYPHS.branch,
 		detached: GLYPHS.detached,

package/extensions/bytefly/footer/price/price.ts

@@ -11,7 +11,7 @@
 import { emptyUsage } from "../collect/entries.ts";
 import type { ByteflyConfig, ModelRates } from "./types.ts";
 import type { UsageRecord, UsageTotals } from "../types.ts";
-import { findRates } from "./rates.ts";
+import { createRateLookup } from "./rates.ts";
 import { isPeak, peakFormatter } from "./schedule.ts";
 
 const TOKENS_PER_MILLION = 1_000_000;
@@ -37,7 +37,9 @@ export function createPricer(config: ByteflyConfig): (records: readonly UsageRec
 	// Both currencies price from `rates` and the tariff; they differ only in what
 	// an unmatched model falls back to, and Pi's recorded cost is already dollars.
 	const dollars = config.currency.code === "USD";
-	// Building a formatter is the expensive part, and only a schedule needs one.
+	// Both are built once per config, never per record: the table splits every key
+	// and remembers the last match, and the formatter is the expensive part.
+	const lookup = createRateLookup(config.rates);
 	const format = config.peak.windows.length > 0 ? peakFormatter(config.peak.timezone) : null;
 
 	return (records) => {
@@ -47,7 +49,7 @@ export function createPricer(config: ByteflyConfig): (records: readonly UsageRec
 			totals.output += record.output;
 			totals.cacheRead += record.cacheRead;
 			totals.cacheWrite += record.cacheWrite;
-			const rates = findRates(config.rates, record.provider, record.model);
+			const rates = lookup(record.provider, record.model);
 			if (rates !== undefined) {
 				totals.cost += ratedCost(config, format, record, rates);
 				continue;

package/extensions/bytefly/footer/price/rates.ts

@@ -2,13 +2,31 @@
  * Rate lookup for a usage record.
  *
  * A key is `provider/model`, and either segment may be a wildcard: `*` matches
- * anything, and a trailing star matches a prefix (`gpt-*`). The most specific
- * key wins and the model segment outranks the provider one, so the documented
- * order is `provider/model`, then `any/model`, then `provider/any`, then `*`.
+ * anything, and a trailing star matches a prefix (`gpt-*`). The key splits at
+ * its first slash, so the model segment may itself contain one — an OpenRouter
+ * id is `anthropic/claude-fable-5`, and its key is
+ * `openrouter/anthropic/claude-fable-5`. The most specific key wins and the
+ * model segment outranks the provider one, so the documented order is
+ * `provider/model`, then `any/model`, then `provider/any`, then `*`.
+ *
+ * `createRateLookup` prepares the table once for a config: the keys are split
+ * at build time, and the last match is remembered, because a session prices
+ * hundreds of records from one model in a row. Splitting every key per record
+ * would rebuild the whole table on the footer's hot path, once per record.
  */
 
 import type { ModelRates } from "./types.ts";
 
+/** A prepared rate table: call once per record, not once per key. */
+export type RateLookup = (provider: string | null, model: string | null) => ModelRates | undefined;
+
+/** One compiled key: both segments already split out of the config string. */
+interface CompiledRate {
+	provider: string;
+	model: string;
+	value: ModelRates;
+}
+
 /** One segment's score against a value: exact 2, prefix 1, wildcard 0, no match -1. */
 function segmentScore(pattern: string, value: string): number {
 	if (pattern === "*") return 0;
@@ -17,38 +35,57 @@ function segmentScore(pattern: string, value: string): number {
 }
 
 /**
- * How specifically `key` matches a record, or `-1` when it does not.
+ * How specifically a compiled key matches a record, or `-1` when it does not.
  *
  * The model segment dominates: the score is weighted so every model score
  * outranks any provider score.
  */
-function matchKey(key: string, provider: string, model: string): number {
-	const parts = key.split("/");
-	if (parts.length === 1) return key === "*" ? 0 : -1;
-	if (parts.length !== 2) return -1;
-	const providerScore = segmentScore(parts[0], provider);
-	const modelScore = segmentScore(parts[1], model);
+function matchRate(entry: CompiledRate, provider: string, model: string): number {
+	const providerScore = segmentScore(entry.provider, provider);
+	const modelScore = segmentScore(entry.model, model);
 	if (providerScore < 0 || modelScore < 0) return -1;
 	return modelScore * 3 + providerScore;
 }
 
-/** The most specific configured rate, or `undefined` when none matches. */
-export function findRates(
-	rates: Readonly<Record<string, ModelRates>>,
-	provider: string | null,
-	model: string | null,
-): ModelRates | undefined {
-	// A record that names no model can only be priced by the catch-all.
-	if (!provider || !model) return rates["*"];
-	let best: ModelRates | undefined;
-	let bestScore = -1;
+/** Prepare `rates` for one config; the returned lookup remembers its last match. */
+export function createRateLookup(rates: Readonly<Record<string, ModelRates>>): RateLookup {
+	const compiled: CompiledRate[] = [];
+	let catchAll: ModelRates | undefined;
 	for (const [key, value] of Object.entries(rates)) {
-		const score = matchKey(key, provider, model);
-		// `>` keeps the first key in config order when two are equally specific.
-		if (score > bestScore) {
-			best = value;
-			bestScore = score;
+		const slash = key.indexOf("/");
+		if (slash < 0) {
+			// A bare key is the catch-all only when it is `*`; anything else is
+			// malformed and never matches.
+			if (key === "*") {
+				catchAll = value;
+				compiled.push({ provider: "*", model: "*", value });
+			}
+			continue;
 		}
+		compiled.push({ provider: key.slice(0, slash), model: key.slice(slash + 1), value });
 	}
-	return best;
+
+	let lastProvider: string | null = null;
+	let lastModel: string | null = null;
+	let last: ModelRates | undefined;
+
+	return (provider, model) => {
+		// A record that names no model can only be priced by the catch-all.
+		if (!provider || !model) return catchAll;
+		if (provider === lastProvider && model === lastModel) return last;
+		let best: ModelRates | undefined;
+		let bestScore = -1;
+		for (const entry of compiled) {
+			const score = matchRate(entry, provider, model);
+			// `>` keeps the first key in config order when two are equally specific.
+			if (score > bestScore) {
+				best = entry.value;
+				bestScore = score;
+			}
+		}
+		lastProvider = provider;
+		lastModel = model;
+		last = best;
+		return best;
+	};
 }

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

@@ -12,13 +12,13 @@ import { stripTerminalSequences } from "@earendil-works/pi-tui";
 /**
  * Compact a status to its icon form for a narrow bar, keeping its own colour.
  *
- * An icon plus a label (`⋮ plan`) keeps only the icon. An icon plus a bare
+ * An icon plus a label (`≡ plan`) keeps only the icon. An icon plus a bare
  * count (`↺ 2`) is a badge: it keeps the count and drops the space (`↺2`),
  * because the number is the state. The leading open and trailing reset SGR
  * sequences are reattached around the compacted text, so a red `✗1` stays red
  * instead of losing its colour exactly when the bar tightens. Requiring exactly
  * two tokens (rather than "the last token is numeric") keeps a numeric label
- * like `⋮ plan · 2024` from being mistaken for a count.
+ * like `≡ plan · 2024` from being mistaken for a count.
  */
 export function compactStatus(status: string): string {
 	const prefix = status.match(/^(?:\x1b\[[0-9;]*m)*/)?.[0] ?? "";
@@ -33,7 +33,7 @@ export function compactStatus(status: string): string {
 /**
  * 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 `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.
  */

package/extensions/bytefly/header/component.ts

@@ -85,8 +85,9 @@ export class ByteflyHeader implements Component {
 
 	/**
 	 * The header is static, so the lines are memoized on everything they read: the
-	 * width, the theme, the resolved shape, and the key chords the help rows print.
-	 * `keyText` is re-read every frame, so a live rebind still shows.
+	 * width, the theme the getter returned, the resolved shape, and the key chords
+	 * the help rows print. `keyText` is re-read every frame, so a live rebind still
+	 * shows.
 	 */
 	render(width: number): string[] {
 		const w = Math.max(1, width);

package/extensions/bytefly/index.ts

@@ -8,7 +8,7 @@
  * `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/` (the published-version check behind the header's update marker).
+ * `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 marker,
@@ -47,7 +47,7 @@ export interface ByteflyDeps {
 	doctor?: DoctorDeps;
 	/** Seams for the notify capability. */
 	notify?: NotifyDeps;
-	/** Seams for the published-version check. */
+	/** Seams for the package-update surface. */
 	update?: UpdateDeps;
 }
 
@@ -55,7 +55,7 @@ export interface ByteflyDeps {
 export default function bytefly(pi: ExtensionAPI, deps: ByteflyDeps = {}): void {
 	if (!isExtensionEnabled("bytefly")) return;
 
-	// One store per load: the update check writes the newest published version and
+	// One store per load: the update check writes this package's new version and
 	// the header reads it, so the marker and every re-install agree.
 	const updates = createUpdateState();
 	const header = registerHeader(pi, updates);

package/extensions/bytefly/notice/component.ts

@@ -24,14 +24,19 @@ import { NOTICE_CONFIG } from "./config.ts";
 /** Severity order, so the rail can carry the worst one. */
 const SEVERITY_RANK: Readonly<Record<NoticeSeverity, number>> = { info: 0, ok: 1, warn: 2, bad: 3 };
 
+/** A severity this module knows, or `fallback` for a value from stored data. */
+function knownSeverity(value: NoticeSeverity | undefined, fallback: NoticeSeverity): NoticeSeverity {
+	return value !== undefined && Object.hasOwn(SEVERITY_RANK, value) ? value : fallback;
+}
+
 /** The severity a row draws with, falling back to the notice's own. */
 function severityOf(item: NoticeItem, fallback: NoticeSeverity): NoticeSeverity {
-	return item.severity ?? fallback;
+	return knownSeverity(item.severity, fallback);
 }
 
 /** The worst severity across the headline and its rows; the rail's role. */
 function worstSeverity(details: NoticeDetails): NoticeSeverity {
-	const fallback = details.severity ?? "info";
+	const fallback = knownSeverity(details.severity, "info");
 	let worst: NoticeSeverity = fallback;
 	for (const item of details.items ?? []) {
 		const severity = severityOf(item, fallback);
@@ -65,7 +70,7 @@ export function noticeLines(
 	const title = paint(theme, NOTICE_CONFIG.titleRole, sanitizeLine(details.title));
 	const items = details.items ?? [];
 	const shown = items.slice(0, NOTICE_CONFIG.maxItems);
-	const fallback = details.severity ?? "info";
+	const fallback = knownSeverity(details.severity, "info");
 	const gap = " ".repeat(GLYPH_GAP);
 
 	const rows = shown.map((item) => {

package/extensions/bytefly/notify/config.ts

@@ -14,7 +14,7 @@
  * flags then narrow what is announced.
  */
 
-import { cleanString, loadConfigSection } from "../../../lib/config.ts";
+import { asBoolean, cleanString, loadConfigSection } from "../../../lib/config.ts";
 import { NOTIFY_METHODS, type NotifyConfig, type NotifyMethod } from "./types.ts";
 
 /** A notification title longer than this is clamped; it is a label, not a message. */
@@ -30,11 +30,6 @@ export const DEFAULT_NOTIFY_CONFIG: NotifyConfig = {
 	title: "Pi",
 };
 
-/** A boolean, or the fallback. */
-function bool(value: unknown, fallback: boolean): boolean {
-	return typeof value === "boolean" ? value : fallback;
-}
-
 /** One of the known methods, or the fallback. */
 function method(value: unknown, fallback: NotifyMethod): NotifyMethod {
 	return typeof value === "string" && (NOTIFY_METHODS as readonly string[]).includes(value)
@@ -46,11 +41,11 @@ function method(value: unknown, fallback: NotifyMethod): NotifyMethod {
 export function normalizeNotifyConfig(raw: Record<string, unknown> | undefined, base: NotifyConfig): NotifyConfig {
 	if (!raw) return base;
 	return {
-		enabled: bool(raw.enabled, base.enabled),
-		turnFinished: bool(raw.turnFinished, base.turnFinished),
-		needsInput: bool(raw.needsInput, base.needsInput),
-		jobFinished: bool(raw.jobFinished, base.jobFinished),
-		matchFound: bool(raw.matchFound, base.matchFound),
+		enabled: asBoolean(raw.enabled, base.enabled),
+		turnFinished: asBoolean(raw.turnFinished, base.turnFinished),
+		needsInput: asBoolean(raw.needsInput, base.needsInput),
+		jobFinished: asBoolean(raw.jobFinished, base.jobFinished),
+		matchFound: asBoolean(raw.matchFound, base.matchFound),
 		method: method(raw.method, base.method),
 		title: cleanString(raw.title, base.title).slice(0, MAX_TITLE_LENGTH),
 	};

package/extensions/bytefly/notify/dispatch.ts

@@ -14,7 +14,7 @@
  * to smuggle a control character into an escape sequence or a shell argument.
  */
 
-import { execFile } from "node:child_process";
+import { spawn } from "node:child_process";
 import { sanitizeLine } from "../../../lib/format.ts";
 import type { NotifyConfig, NotifyMethod } from "./types.ts";
 
@@ -30,7 +30,7 @@ export interface NotifySeams {
 	run(command: string, args: string[]): void;
 }
 
-/** The production seams: this process's platform, environment, stdout, and `execFile`. */
+/** The production seams: this process's platform, environment, stdout, and a detached notifier. */
 export function defaultSeams(): NotifySeams {
 	return {
 		platform: process.platform,
@@ -38,9 +38,14 @@ export function defaultSeams(): NotifySeams {
 		stdout: process.stdout,
 		run: (command, args) => {
 			try {
-				execFile(command, args, { windowsHide: true }, () => {});
+				// No pipes and unref'd: the notifier is best-effort and must not keep
+				// Pi alive, which `/quit` right after a turn would otherwise wait out
+				// (PowerShell's cold start alone is a second).
+				const child = spawn(command, args, { windowsHide: true, stdio: "ignore" });
+				child.on("error", () => {});
+				child.unref();
 			} catch {
-				// The notifier is best-effort; a missing command must not break a turn.
+				// A missing command must not break a turn.
 			}
 		},
 	};
@@ -89,7 +94,10 @@ function windowsToastScript(title: string, body: string): string {
 	return [
 		`${mgr} > $null`,
 		`$xml = [${type}.ToastNotificationManager]::GetTemplateContent(${template})`,
-		`$xml.GetElementsByTagName('text')[0].AppendChild($xml.CreateTextNode('${powershellLiteral(body)}')) > $null`,
+		`$nodes = $xml.GetElementsByTagName('text')`,
+		// PowerShell 5.1 cannot index the live node list with `[0]`; `.Item(0)`
+		// reads the single node without enumerating a collection AppendChild mutates.
+		`$nodes.Item(0).AppendChild($xml.CreateTextNode('${powershellLiteral(body)}')) > $null`,
 		`[${type}.ToastNotificationManager]::CreateToastNotifier('${powershellLiteral(title)}').Show(${toast})`,
 	].join("; ");
 }

package/extensions/bytefly/panel/commands.ts

@@ -29,6 +29,7 @@ import type { Discovery } from "../picker/types.ts";
 import { formatListing, formatSettingsListing } from "./format.ts";
 import { buildPanelModel, extensionName } from "./join.ts";
 import { createSettingsRuntime, type SettingsRuntime, type SettingsRuntimeDeps } from "./settings-runtime.ts";
+import { shippedThemeNames } from "./themes.ts";
 import { PanelComponent } from "./tui.ts";
 import type { PanelSection } from "./types.ts";
 
@@ -130,6 +131,19 @@ function notifyExtension(
 	);
 }
 
+/**
+ * Theme names the row offers: the host's resolved list, narrowed to this
+ * package's own palettes. The list is empty outside the TUI (RPC, print, JSON),
+ * where the row still shows the stored value.
+ */
+function settingsThemeNames(ctx: ExtensionCommandContext): string[] {
+	try {
+		return shippedThemeNames(ctx.ui.getAllThemes());
+	} catch {
+		return [];
+	}
+}
+
 /** Register the single `/bytefly` command. */
 export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 	const discover = deps.discover ?? discoverExtensions;
@@ -146,6 +160,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 		const cwd = ctx.cwd ?? process.cwd();
 		const agentDir = getAgentDir();
 		const trusted = ctx.isProjectTrusted();
+		const themes = settingsThemeNames(ctx);
 		// The mounted screen owns its feedback: a refusal or a failed write belongs in
 		// 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
@@ -171,7 +186,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 		// packages or probing the doctor.
 		if (section === "settings" && ctx.mode !== "tui") {
 			const stores = createSettingsStores(cwd, agentDir, trusted);
-			const settings = makeSettings({ stores, cwd, agentDir, trusted, onError: settingsNotice });
+			const settings = makeSettings({ stores, cwd, agentDir, trusted, themes, onError: settingsNotice });
 			ctx.ui.notify(formatSettingsListing(settings.views("global")), "info");
 			return;
 		}
@@ -189,6 +204,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			cwd,
 			agentDir,
 			trusted: discovery.trusted,
+			themes,
 			onError: settingsNotice,
 		});
 
@@ -236,6 +252,9 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 		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,
@@ -257,6 +276,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 						// A late error falls back to the transcript, never a disposed screen.
 						panel = undefined;
 						unsubscribe();
+						unsubscribeSettings();
 						done();
 					},
 				});

package/extensions/bytefly/panel/format.ts

@@ -158,8 +158,10 @@ interface RowBadge {
  * The row's badge. Settings is the enablement axis the checkbox already shows,
  * so an off extension gets one verdict (`off`) instead of a health word that
  * contradicts it. `PI_DISABLED_EXTENSIONS` is a different axis, so it is named
- * rather than sharing the word: `env disabled`. A row without a report leaves
- * the glyph and the word blank instead of claiming `ok`.
+ * rather than sharing the word: `env disabled`. The glyph marks what needs
+ * attention — a warning, a miss, a disable — so a row with nothing to report
+ * carries no glyph at all, and the column reads as one shape instead of a
+ * checkmark that comes and goes.
  */
 export function rowBadge(row: PanelRow): RowBadge {
 	if (row.item && !row.item.enabled) return { glyph: GLYPHS.disabled, role: "faint", text: "off" };
@@ -167,6 +169,7 @@ export function rowBadge(row: PanelRow): RowBadge {
 	if (!report) return { role: "faint" };
 	if (!report.enabled) return { glyph: GLYPHS.disabled, role: "faint", text: "env disabled" };
 	const severity = reportSeverity(report);
+	if (severity === "ok") return { role: "faint", text: reportSummary(report) };
 	return { glyph: severityGlyphChar(severity), role: severityRole(severity), text: reportSummary(report) };
 }