@gavin-hu/my-pi-agent 0.13.1 → 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/config.ts

@@ -14,6 +14,9 @@ import { clampInteger, loadConfigSection } from "../../../lib/config.ts";
 /** How long a single probe may take before it counts as unusable. */
 const DEFAULT_TIMEOUT_MS = 2_000;
 
+/** The probe deadline range, in milliseconds; the panel's editor offers the same bounds. */
+export const TIMEOUT_MS_RANGE = { min: 100, max: 30_000 } as const;
+
 export interface DoctorConfig {
 	/** Probe enabled extensions at session start and warn when one is broken. */
 	proactive: boolean;
@@ -34,7 +37,7 @@ export function normalizeConfig(raw: Record<string, unknown> | undefined, base:
 	if (!raw) return base;
 	return {
 		proactive: typeof raw.proactive === "boolean" ? raw.proactive : base.proactive,
-		timeoutMs: clampInteger(raw.timeoutMs, base.timeoutMs, 100, 30_000),
+		timeoutMs: clampInteger(raw.timeoutMs, base.timeoutMs, TIMEOUT_MS_RANGE.min, TIMEOUT_MS_RANGE.max),
 		skip: Array.isArray(raw.skip)
 			? raw.skip.filter((name): name is string => typeof name === "string" && name.trim().length > 0)
 			: base.skip,

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/config.ts

@@ -101,9 +101,10 @@ export const DEFAULT_BYTEFLY_CONFIG: ByteflyConfig = {
 	budget: 0,
 };
 
-const MAX_DECIMALS = 4;
+/** The highest `currency.decimals` the screen and the loader both accept. */
+export const MAX_DECIMALS = 4;
 /** Upper bound for `budget`; large enough for any real session, small enough to clamp a typo. */
-const MAX_BUDGET = 10_000_000;
+export const MAX_BUDGET = 10_000_000;
 const MAX_RATE = 1_000_000;
 const MAX_RATE_KEYS = 200;
 const MAX_WINDOWS = 16;

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

@@ -18,9 +18,9 @@ import { BODY_INDENT } from "../../../lib/tui/indent.ts";
 import { RULE_GLYPH } from "../../../lib/tui/rules.ts";
 import { paint } from "../../../lib/tui/tokens.ts";
 import { updateMarker } from "../update/format.ts";
-import { HEADER_CONFIG, type HelpEntry } from "./config.ts";
+import { HEADER_CONFIG, type HeaderHeight, type HelpEntry } from "./config.ts";
 
-/** The header's shape, resolved once per apply so `render` stays cheap. */
+/** The header's shape: everything but the live terminal height is resolved once per apply. */
 export interface HeaderView {
 	/** Print Pi's version on the agent line. */
 	showVersion: boolean;
@@ -28,6 +28,8 @@ export interface HeaderView {
 	halfBlocks: boolean;
 	/** Columns of left margin: Pi's output pad, so the nameplate sits on the transcript margin. */
 	pad: number;
+	/** Terminal rows, when the host reports them; short terminals shed help rows. */
+	rows?: number;
 	/** A newer published version of this package, when one is known. */
 	latest?: string;
 }
@@ -35,6 +37,15 @@ export interface HeaderView {
 /** The mark block is four columns on both rows, so the identity column aligns. */
 const MARK_WIDTH = 4;
 
+/**
+ * The tallest shape whose threshold the terminal meets. An unknown or impossible
+ * height keeps the full header, so a host without terminal rows still reads well.
+ */
+function heightShape(rows: number | undefined): HeaderHeight {
+	if (rows === undefined || !Number.isFinite(rows) || rows <= 0) return HEADER_CONFIG.heights[0];
+	return HEADER_CONFIG.heights.find((shape) => rows >= shape.minRows) ?? HEADER_CONFIG.heights[0];
+}
+
 /** Pad a themed mark line to the block width with plain spaces. */
 function markBlock(line: string): string {
 	return line + " ".repeat(Math.max(0, MARK_WIDTH - visibleWidth(line)));
@@ -74,14 +85,15 @@ 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);
 		const theme = this.getTheme();
 		const view = this.view();
-		const viewKey = `${view.showVersion}:${view.halfBlocks}:${view.pad}:${view.latest ?? ""}`;
+		const viewKey = `${view.showVersion}:${view.halfBlocks}:${view.pad}:${view.latest ?? ""}:${view.rows ?? ""}`;
 		const keys = this.keySignature();
 		if (
 			this.cachedWidth === w &&
@@ -111,6 +123,7 @@ export class ByteflyHeader implements Component {
 	private build(w: number, theme: Theme, view: HeaderView): string[] {
 		const { nameRole, chromeRole, detailRole, updateRole, chromeTagline, chromeName, chromeVersion, help } =
 			HEADER_CONFIG;
+		const shape = heightShape(view.rows);
 		const padWidth = Math.max(0, Math.min(Math.floor(view.pad), Math.max(0, w - 1)));
 		const pad = " ".repeat(padWidth);
 		const [markTop, markBottom] = markLines(theme, view.halfBlocks);
@@ -145,13 +158,17 @@ export class ByteflyHeader implements Component {
 
 		// The header owns its leading blank: Pi mounts the built-in header inside
 		// `Spacer(1)`s, but the `quietStartup: true` branch that hands this header the
-		// screen adds none, and `setHeader` swaps only the header child.
+		// screen adds none, and `setHeader` swaps only the header child. A short
+		// terminal gives that row back, then sheds whole help groups.
 		return [
-			"",
+			...(shape.blank ? [""] : []),
 			this.identityLine(pad, markTop, agentCell, w),
 			this.identityLine(pad, markBottom, chromeCell, w),
 			this.rule(theme, w, pad),
-			...help.map((row) => this.helpLine(theme, w, row, padWidth)),
+			...shape.helpRows.flatMap((index) => {
+				const group = help[index];
+				return group ? [this.helpLine(theme, w, group, padWidth)] : [];
+			}),
 		];
 	}
 
@@ -193,6 +210,12 @@ export class ByteflyHeader implements Component {
 }
 
 /** Header factory passed to `ctx.ui.setHeader`. */
-export function createHeader(getTheme: () => Theme, view: () => HeaderView): (tui: TUI, theme: Theme) => Component {
-	return () => new ByteflyHeader(getTheme, view, VERSION);
+export function createHeader(
+	getTheme: () => Theme,
+	view: (rows: number | undefined) => HeaderView,
+): (tui: TUI, theme: Theme) => Component {
+	// Read the height on every render, so a terminal resize reflows the header
+	// instead of keeping the shape it was installed with. Tests may pass a bare
+	// object as the host, so the terminal is optional at the boundary.
+	return (tui) => new ByteflyHeader(getTheme, () => view(tui.terminal?.rows), VERSION);
 }

package/extensions/bytefly/header/config.ts

@@ -19,6 +19,16 @@ export type HelpEntry =
 	| { readonly binding: AppKeybinding; readonly description: string }
 	| { readonly raw: string; readonly description: string };
 
+/** How much of the help block a terminal height can carry. */
+export interface HeaderHeight {
+	/** Smallest terminal height, in rows, this shape applies to. Taller tiers come first. */
+	readonly minRows: number;
+	/** Help groups to print, by index in `help`; a group is dropped whole. */
+	readonly helpRows: readonly number[];
+	/** Open with a blank row above the nameplate. */
+	readonly blank: boolean;
+}
+
 /** The header's shape and content. */
 export interface HeaderConfig {
 	/** The agent's name, shown before its version. */
@@ -49,6 +59,12 @@ export interface HeaderConfig {
 	readonly chromeVersion: string;
 	/** Grouped help rows, printed one line each under the rule. */
 	readonly help: readonly (readonly HelpEntry[])[];
+	/**
+	 * The height ladder, tallest first: the first tier the terminal meets decides
+	 * which help groups print and whether the leading blank row survives. The
+	 * floor is `minRows: 0`, so a short terminal keeps the nameplate and rule.
+	 */
+	readonly heights: readonly HeaderHeight[];
 }
 
 export const HEADER_CONFIG: HeaderConfig = {
@@ -89,4 +105,10 @@ export const HEADER_CONFIG: HeaderConfig = {
 			{ binding: "app.clipboard.pasteImage", description: "paste files" },
 		],
 	],
+	heights: [
+		{ minRows: 28, helpRows: [0, 1, 2], blank: true },
+		{ minRows: 22, helpRows: [0, 2], blank: true },
+		{ minRows: 16, helpRows: [2], blank: true },
+		{ minRows: 0, helpRows: [], blank: false },
+	],
 };

package/extensions/bytefly/header/register.ts

@@ -55,11 +55,12 @@ export function registerHeader(pi: ExtensionAPI, updates: UpdateSource = createU
 		// value the tool frame and the notice inset by. An older host without
 		// `getSettings` keeps the default margin.
 		const pad = pi.getSettings?.().outputPad ?? DEFAULT_HOST_PAD;
-		const view = (): HeaderView => ({
+		const view = (rows: number | undefined): HeaderView => ({
 			showVersion: HEADER_CONFIG.showVersion,
 			halfBlocks,
 			pad,
 			latest: updates.latest(),
+			rows,
 		});
 		ctx.ui.setHeader(createHeader(() => ctx.ui.theme, view));
 	};

package/extensions/bytefly/index.ts

@@ -4,13 +4,13 @@
  * (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 elapsed counter on Pi's working
- * row), `panel/` (the unified `/bytefly` screen and its
+ * transcript turn rule), `working/` (the live run line on Pi's working row),
+ * `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 timer are installed only in
+ * The header, footer, turn rule, and working line are installed only in
  * interactive (`tui`) sessions, and are always on; the user-message marker,
  * notice, and tool blocks register at load and take effect wherever a
  * transcript renders. `pi config` turns bytefly's chrome off. The panel and doctor work
@@ -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) => {