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

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

@@ -0,0 +1,352 @@
+/**
+ * The control center's key table: the binding, the hint row it appears in, and
+ * the help block `?` prints.
+ *
+ * One table, so a help line cannot drift from a binding: the component dispatches
+ * through {@link keyFor}, the hint row is {@link hintsFor}, and the help block is
+ * {@link helpRows}. Movement is not here — `lib/tui/cursor.ts` owns the arrows,
+ * `j`/`k`, PgUp/PgDn and Home/End for every screen in the package — so the help
+ * block names movement in its own row and the table stays the actions this screen
+ * alone defines.
+ *
+ * Value-only: pure functions, the theme passed in.
+ */
+
+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 { BODY_INDENT } from "../../../../lib/tui/indent.ts";
+import { paint } from "../../../../lib/tui/tokens.ts";
+import type { PanelSection } from "../types.ts";
+import { hintLine, noticeLine } from "./frame.ts";
+import { editHints } from "./settings-view.ts";
+
+/** One action the screen binds. */
+export type PanelKeyId =
+	| "close"
+	| "previousSection"
+	| "nextSection"
+	| "toggle"
+	| "change"
+	| "detail"
+	| "scope"
+	| "filter"
+	| "attention"
+	| "refresh"
+	| "reload"
+	| "reset"
+	| "json"
+	| "inherit"
+	| "help";
+
+/** One binding, its hint label, and what the help block says about it. */
+export interface PanelKey {
+	id: PanelKeyId;
+	/** The keys as the hint row and the help block print them. */
+	label: string;
+	/** The sections that offer it. A key absent from a section is not hinted there. */
+	sections: readonly PanelSection[];
+	/** One plain sentence for the help block. */
+	help: string;
+	/** Whether `data` is this key. */
+	match(data: string): boolean;
+}
+
+/** Every section, and the two resource lists that share a set of keys. */
+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[] = [
+	{
+		id: "close",
+		label: "Esc",
+		sections: ALL,
+		help: "Close the screen",
+		match: (data) => isCloseKey(data),
+	},
+	{
+		id: "previousSection",
+		label: "←",
+		sections: ALL,
+		help: "Previous section",
+		match: (data) =>
+			matchesKey(data, Key.left) || data === "h" || matchesKey(data, Key.shift("tab")) || data === SHIFT_TAB,
+	},
+	{
+		id: "nextSection",
+		label: "→",
+		sections: ALL,
+		help: "Next section",
+		match: (data) => matchesKey(data, Key.right) || data === "l" || matchesKey(data, Key.tab),
+	},
+	{
+		id: "toggle",
+		label: "Space",
+		sections: LISTS,
+		help: "Enable or disable, and re-probe when it changes",
+		match: (data) => matchesKey(data, Key.space),
+	},
+	{
+		id: "detail",
+		label: "Enter",
+		sections: LISTS,
+		help: "Show or hide the focused row's findings",
+		match: (data) => matchesKey(data, Key.enter),
+	},
+	{
+		id: "change",
+		label: "Space",
+		sections: ["settings"],
+		help: "Change the focused value",
+		match: (data) => matchesKey(data, Key.space) || matchesKey(data, Key.enter),
+	},
+	{
+		id: "reset",
+		label: "u",
+		sections: ["settings"],
+		help: "Reset the focused value to its default",
+		match: (data) => data === "u",
+	},
+	{
+		id: "json",
+		label: "J",
+		sections: ["settings"],
+		help: "Show the whole `bytefly.json` section the value lives in",
+		match: (data) => data === "J",
+	},
+	{
+		id: "scope",
+		label: "s",
+		sections: ALL,
+		help: "Switch where a change is written: Global or Project",
+		match: (data) => data === "s",
+	},
+	{
+		id: "filter",
+		label: "/",
+		sections: ALL,
+		help: "Filter the rows by text; Esc clears it",
+		match: (data) => matchesKey(data, Key.slash),
+	},
+	{
+		id: "attention",
+		label: "!",
+		sections: ALL,
+		help: "Show only the rows that need attention",
+		match: (data) => matchesKey(data, Key.exclamation),
+	},
+	{
+		id: "refresh",
+		label: "r",
+		sections: ["extensions"],
+		help: "Re-probe every extension's requirements",
+		match: (data) => data === "r",
+	},
+	{
+		id: "inherit",
+		label: "x",
+		sections: LISTS,
+		help: "Drop the Project override, so Global applies again",
+		match: (data) => data === "x",
+	},
+	{
+		id: "reload",
+		label: "R",
+		sections: ALL,
+		help: "Reload now, to apply what you changed",
+		match: (data) => data === "R",
+	},
+	{
+		id: "help",
+		label: "?",
+		sections: ALL,
+		help: "Show every key, in place of the focused row's facts",
+		match: (data) => matchesKey(data, Key.question),
+	},
+];
+
+/** The binding for `id`; a table with no row would be a bug, not a key state. */
+export function keyOf(id: PanelKeyId): PanelKey {
+	const key = PANEL_KEYS.find((entry) => entry.id === id);
+	if (key === undefined) throw new Error(`No panel key "${id}"`);
+	return key;
+}
+
+/** The action `data` asks for in `section`, or `undefined` for anything else. */
+export function keyFor(data: string, section: PanelSection): PanelKeyId | undefined {
+	for (const key of PANEL_KEYS) {
+		if (key.sections.includes(section) && key.match(data)) return key.id;
+	}
+	return undefined;
+}
+
+/** What the hint row needs to know about the screen's state. */
+export interface HintState {
+	/** The focused row's findings are expanded (lists only). */
+	expanded: boolean;
+	/** A probe is in flight, so the refresh key is not offered. */
+	refreshing: boolean;
+	/** Project scope can hold an override, Global cannot (lists only). */
+	projectScope: boolean;
+	/** Something was changed this session, so the reload key applies. */
+	dirty: boolean;
+	/** The help block is open. */
+	help: boolean;
+}
+
+/** One pale, dim hint, or an accented primary one. */
+function hint(text: string, primary = false): ScreenHint {
+	return primary ? { text, color: "accent" } : text;
+}
+
+/**
+ * The hint row for a section, most useful first: whole hints drop from the right
+ * as the width runs out, so the close and section keys survive on a narrow
+ * terminal and `?` is the one that leaves first.
+ */
+export function hintsFor(section: PanelSection, state: HintState): ScreenHint[] {
+	const hints: ScreenHint[] = [
+		hint("Esc close"),
+		hint("←/→ section"),
+		section === "settings" ? hint("Space change", true) : hint("Space toggle", true),
+		...(section === "settings" ? [] : [hint(state.expanded ? "Enter collapse" : "Enter detail", true)]),
+		hint("/ filter"),
+	];
+	if (section === "settings") {
+		hints.push(hint("u reset"), hint(state.help ? "? hide" : "? keys"));
+		return hints;
+	}
+	hints.push(hint(state.help ? "? hide" : "? keys"));
+	if (section === "extensions") hints.push(hint(state.refreshing ? "refreshing…" : "r refresh"));
+	if (state.dirty) hints.push(hint("R reload", true));
+	hints.push(hint("s scope"));
+	if (state.projectScope) hints.push(hint("x inherit"));
+	hints.push(hint("↑/↓ select"));
+	return hints;
+}
+
+/**
+ * The hint row a section shows: an editor's own keys while one is open, else the
+ * transient notice, else the section's hints. The three cases are exclusive, so a
+ * notice never shares the row with a hint that could not work.
+ */
+export function hintRow(options: {
+	theme: Theme;
+	width: number;
+	section: PanelSection;
+	state: HintState;
+	/** A settings row or the filter is being typed into. */
+	editing: boolean;
+	/** The last refusal or failure, shown until the next key. */
+	notice?: string;
+}): string {
+	const { theme, width, section, state, editing, notice } = options;
+	if (editing) return hintLine(theme, width, editHints());
+	if (notice !== undefined) return noticeLine(theme, width, notice);
+	return hintLine(theme, width, hintsFor(section, state));
+}
+
+/**
+ * One help row: the keys it names, and what they do.
+ *
+ * A row naming one binding takes that binding's own sentence, so the two cannot
+ * disagree; a row that explains a verb for this section — `!` narrows settings to
+ * what changed, not to what is broken — states its own.
+ */
+interface HelpRow {
+	/** Table bindings this row documents; empty for a row over shared movement keys. */
+	ids: readonly PanelKeyId[];
+	/** The keys as printed; joined from the bindings unless the row sets its own. */
+	label?: string;
+	/** What the keys do here; the single binding's own sentence when omitted. */
+	help?: string;
+}
+
+/** Rows over the movement keys, which `lib/tui/cursor.ts` owns for every screen. */
+const MOVEMENT: readonly HelpRow[] = [
+	{ ids: [], label: "↑/↓ j/k", help: "Move to the next or previous row" },
+	{ ids: [], label: "g G", help: "Jump to the first or last row" },
+	{ ids: [], label: "[ ]", help: "Jump to the next or previous group" },
+];
+
+/** The help block per section: the table's own rows, plus movement and the close pair. */
+const HELP: Record<PanelSection, readonly HelpRow[]> = {
+	extensions: [
+		{ ids: ["close", "previousSection", "nextSection"], help: "Close, or change section" },
+		...MOVEMENT,
+		{ ids: ["toggle"], help: "Enable or disable the focused extension" },
+		{ ids: ["detail"], help: "Show or hide its findings" },
+		{ ids: ["attention"], help: "Show only the rows that need attention" },
+		{ ids: ["filter"], help: "Filter the rows by text; Esc clears it" },
+		{ ids: ["scope"], help: "Switch where a change is written" },
+		{ ids: ["refresh"], help: "Re-probe every extension's requirements" },
+		{ ids: ["inherit"], help: "Drop the Project override" },
+		{ ids: ["reload"], help: "Reload to apply what you changed" },
+		{ ids: ["help"], help: "Show or hide this key list" },
+	],
+	skills: [
+		{ ids: ["close", "previousSection", "nextSection"], help: "Close, or change section" },
+		...MOVEMENT,
+		{ ids: ["toggle"], help: "Enable or disable the focused skill" },
+		{ ids: ["detail"], help: "Show or hide what its `SKILL.md` declares" },
+		{ ids: ["attention"], help: "Show only the rows that need attention" },
+		{ ids: ["filter"], help: "Filter the rows by text; Esc clears it" },
+		{ ids: ["scope"], help: "Switch where a change is written" },
+		{ ids: ["inherit"], help: "Drop the Project override" },
+		{ ids: ["reload"], help: "Reload to apply what you changed" },
+		{ ids: ["help"], help: "Show or hide this key list" },
+	],
+	settings: [
+		{ ids: ["close", "previousSection", "nextSection"], help: "Close, or change section" },
+		...MOVEMENT,
+		{ ids: ["change"], help: "Change the focused value" },
+		{ ids: ["reset"], help: "Reset it to its default" },
+		{ ids: ["json"], help: "Show the section it lives in" },
+		{ ids: ["attention"], help: "Show only the values you changed" },
+		{ ids: ["filter"], help: "Filter the rows by text; Esc clears it" },
+		{ ids: ["scope"], help: "Switch where a change is written" },
+		{ ids: ["reload"], help: "Reload to apply what you changed" },
+		{ ids: ["help"], help: "Show or hide this key list" },
+	],
+};
+
+/** The bindings a section's help block documents, for the drift test. */
+export function helpKeyIds(section: PanelSection): PanelKeyId[] {
+	return HELP[section].flatMap((row) => [...row.ids]);
+}
+
+/** The keys a help row prints, from the bindings it names. */
+function helpLabel(row: HelpRow): string {
+	if (row.label !== undefined) return row.label;
+	return row.ids.map((id) => keyOf(id).label).join(" ");
+}
+
+/** What a help row says: its own sentence, or the single binding's. */
+function helpText(row: HelpRow): string {
+	if (row.help !== undefined) return row.help;
+	return row.ids.map((id) => keyOf(id).help).join("; ");
+}
+
+/**
+ * The help block for a section: one `keys  action` line per row, the key column
+ * padded to the widest label so the sentences line up. Every binding the section
+ * offers has a row, and every row names a binding the section offers —
+ * `keys.test.ts` holds both directions.
+ */
+export function helpRows(theme: Theme, width: number, section: PanelSection): string[] {
+	const rows = HELP[section].map((row) => ({ label: helpLabel(row), help: helpText(row) }));
+	const column = Math.max(...rows.map((row) => row.label.length)) + 2;
+	const indent = " ".repeat(BODY_INDENT);
+	return rows.map((row) =>
+		clip(
+			`${indent}${paint(theme, "faint", padTo(row.label, column))}${paint(theme, "meta", row.help)}`,
+			Math.max(1, width),
+		),
+	);
+}

package/extensions/bytefly/panel/tui/list-view.ts

@@ -1,35 +1,38 @@
 /**
- * The grouped list sections' shared pieces: the headline counts, one row, and
- * the key hints.
+ * The resource row: the one row grammar Extensions and Skills share.
  *
- * Extensions and Skills draw the same row grammar — a checkbox, a verdict, and
- * the resource's name — and offer the same keys, so the row, the summary, and
- * the hint row live here and each section supplies only what it can say about
- * the focused row and whether it has anything to refresh.
+ * A row is a checkbox, a status glyph, the resource's name, and one verdict word.
+ * A clean row carries no glyph and no word, so the column reads as one shape
+ * instead of a checkmark that comes and goes, and the eye finds the rows that
+ * need it.
+ *
+ * Pure: the theme, the width and the model row come in, one clipped line comes out.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { sanitizeLine } from "../../../../lib/format.ts";
-import type { ScreenHint } from "../../../../lib/tui/chrome.ts";
+import { clip, padTo } from "../../../../lib/tui/columns.ts";
 import { checkbox, listRow } from "../../../../lib/tui/rows.ts";
-import { rowBadge, type PanelScope, summarySegments, type SummaryOptions } from "../format.ts";
-import type { PanelModel, PanelRow } from "../types.ts";
-import { countsLine } from "./frame.ts";
+import { rowBadge } from "../format.ts";
+import type { PanelRow } from "../types.ts";
+
+/** Columns the verdict keeps before the name is clipped instead. */
+const MIN_VERDICT_WIDTH = 9;
 
-/** The section's headline: the scope, the row count, and what is off. */
-export function resourceSummary(
-	theme: Theme,
-	width: number,
-	model: PanelModel,
-	scope: PanelScope,
-	options: SummaryOptions = {},
-): string {
-	return countsLine(theme, width, summarySegments(model, scope, { ...options, compact: width < 72 }));
+/** The widest verdict the visible rows carry, so the column lines up. */
+export function verdictColumn(rows: readonly PanelRow[]): number {
+	return rows.reduce((columns, row) => Math.max(columns, (rowBadge(row).text ?? "").length), 0);
 }
 
-/** One resource row: its checkbox, verdict, and name. */
-export function resourceRow(theme: Theme, width: number, row: PanelRow, selected: boolean): string {
+/** One resource row: its checkbox, verdict glyph, name, and verdict word. */
+export function resourceRow(theme: Theme, width: number, row: PanelRow, selected: boolean, verdicts = 0): string {
 	const badge = rowBadge(row);
+	const name = sanitizeLine(row.label);
+	// The verdict sits in its own column instead of against the name, so a column
+	// of rows can be read down rather than across; a long name loses its tail
+	// before the verdict loses its word.
+	const room = Math.max(MIN_VERDICT_WIDTH, Math.min(verdicts, Math.max(0, width - 22)));
+	const nameCell = verdicts > 0 ? padTo(clip(name, Math.max(1, width - 22)), room) : name;
 	return listRow(theme, width, {
 		selected,
 		// A reported-only row has no enable pattern, but still reserves the box
@@ -37,36 +40,12 @@ export function resourceRow(theme: Theme, width: number, row: PanelRow, selected
 		leading: row.item ? checkbox(theme, row.item.enabled) : " ",
 		glyph: badge.glyph ?? " ",
 		glyphRole: badge.role,
-		label: sanitizeLine(row.label),
+		label: nameCell,
 		labelRole: selected ? "accent" : row.item && !row.item.enabled ? "faint" : "label",
 		trailing: badge.text,
 		// The glyph carries the status colour; the word stays quiet unless it is a
 		// problem, so a clean row does not shout.
 		trailingRole: badge.role === "bad" || badge.role === "warn" ? badge.role : "faint",
-		// The verdict sits beside the name instead of at the far edge of a wide
-		// terminal, where a two-word verdict would be unreadable.
 		align: "inline",
 	});
 }
-
-export interface SectionHintOptions {
-	expanded: boolean;
-	projectScope: boolean;
-	/** The refresh key's state; omitted by a section with nothing to refresh. */
-	refreshing?: boolean;
-}
-
-/** The section's key hints, in the order they drop as the width runs out. */
-export function sectionHints({ expanded, projectScope, refreshing }: SectionHintOptions): ScreenHint[] {
-	return [
-		"Esc close",
-		"←/→",
-		{ text: "Space toggle", color: "accent" },
-		{ text: expanded ? "Enter collapse" : "Enter detail", color: "accent" },
-		"Tab scope",
-		// Only Project scope can hold an override, so the key is not offered elsewhere.
-		...(projectScope ? ["x inherit"] : []),
-		...(refreshing === undefined ? [] : [refreshing ? "refreshing…" : "r refresh"]),
-		"↑/↓ select",
-	];
-}

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

@@ -0,0 +1,76 @@
+/**
+ * The two-pane split: where the side pane starts, how wide each side is, and how
+ * one row of each is laid on one terminal line.
+ *
+ * Above the breakpoint the focused row's facts sit beside the list; below it the
+ * frame keeps the single column and the facts move under the list. The side lines
+ * are *composed onto* the list's lines rather than appended, so the two panes cost
+ * exactly the rows the list already spends — the frame's row budget is the same at
+ * every width.
+ *
+ * Value-only: pure functions, the theme passed in.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { clip, padTo } from "../../../../lib/tui/columns.ts";
+import { GLYPHS } from "../../../../lib/tui/glyphs.ts";
+import { paint } from "../../../../lib/tui/tokens.ts";
+
+/** The narrowest terminal that gets a side pane. */
+export const WIDE_MIN = 96;
+
+/** The side pane's width bounds, in columns. */
+export const SIDE_MIN = 36;
+export const SIDE_MAX = 56;
+
+/** Columns between the list and the side pane, on each side of the divider. */
+const GAP = 1;
+
+/** Whether this width gets a side pane. */
+export function isWide(width: number): boolean {
+	return width >= WIDE_MIN;
+}
+
+/**
+ * The side pane's width: two fifths of the terminal, clamped. Reading the list
+ * and its facts at the same height is the point, so the side never grows past
+ * what keeps a row and its verdict readable on the left.
+ */
+export function sideWidth(width: number): number {
+	return Math.max(SIDE_MIN, Math.min(SIDE_MAX, Math.floor(width * 0.42)));
+}
+
+/** The columns the list keeps, divider and gaps included in the accounting. */
+export function listWidth(width: number): number {
+	return Math.max(1, width - sideWidth(width) - GAP * 2 - 1);
+}
+
+/**
+ * Compose one line pair: the list row padded to its column, the divider, and the
+ * side row. A pair with no side content still draws the divider, so the pane keeps
+ * one edge down the body instead of appearing and disappearing row by row.
+ */
+export function composeRow(theme: Theme, width: number, list: string, side: string): string {
+	const left = padTo(clip(list, listWidth(width)), listWidth(width));
+	const divider = paint(theme, "rule", GLYPHS.divider);
+	const room = Math.max(0, width - listWidth(width) - GAP * 2 - 1);
+	return clip(`${left}${" ".repeat(GAP)}${divider}${" ".repeat(GAP)}${clip(side, room)}`, width);
+}
+
+/** Compose a body of list rows with a side pane, one line pair per row. */
+export function composeRows(theme: Theme, width: number, list: readonly string[], side: readonly string[]): string[] {
+	return list.map((line, index) => composeRow(theme, width, line, side[index] ?? ""));
+}
+
+/**
+ * Cut the side block to the rows it has, keeping the reader informed: the last row
+ * says how many lines are left out, which is the same convention the JSON pane uses.
+ */
+export function clipRows(rows: readonly string[], budget: number, width: number): string[] {
+	const room = Math.max(0, Math.floor(budget));
+	if (rows.length <= room) return [...rows];
+	if (room === 0) return [];
+	const kept = rows.slice(0, room - 1);
+	const hidden = rows.length - kept.length;
+	return [...kept, clip(`… ${hidden} more line${hidden === 1 ? "" : "s"}`, width)];
+}

package/extensions/bytefly/panel/tui/section-view.ts

@@ -0,0 +1,126 @@
+/**
+ * What the sections show, derived from the session's sources: the counts on the
+ * tabs, the one body height they share, the attention in the header, the filter
+ * chips, and the merged model the rows are drawn from.
+ *
+ * One module because these are one question asked five ways — "what is on this
+ * screen, and what does it add up to" — and because the component should be left
+ * with the state it mutates and the keys it reads, not the arithmetic over it.
+ *
+ * Pure: the source is handed in, no host is touched, and nothing is cached.
+ */
+
+import type { ExtensionReport } from "../../../../lib/requirements.ts";
+import { filterChips, isFiltering, rowMatches, type PanelFilter } from "../filter.ts";
+import { attentionSegments, panelCounts, type SummarySegment } from "../format.ts";
+import { buildPanelModel, buildSkillModel, groupedEntryCount } from "../join.ts";
+import type { ResourceItem, ResourceKind, WriteScope } from "../../picker/types.ts";
+import type { SettingsSurface } from "../settings-runtime.ts";
+import type { PanelModel, PanelRow, PanelSection, SkillInfo } from "../types.ts";
+import { settingEntries } from "./entries.ts";
+
+/** Everything the screen derives its content from. */
+export interface ViewSource {
+	/** The write scope the settings rows are read in. */
+	scope: WriteScope;
+	/** The resolved resources of one kind. */
+	items(kind: ResourceKind): readonly ResourceItem[];
+	/** The current doctor reports. */
+	reports(): readonly ExtensionReport[];
+	/** The settings surface, for its rows. */
+	settings: SettingsSurface;
+	/** The agent directory the resource groups are labelled from. */
+	agentDir: string;
+	/** What the reader narrowed the rows to. */
+	filter: PanelFilter;
+	/** The extension the command narrowed to, if it named one. */
+	commandFilter?: string;
+	/** Something was changed this session. */
+	dirty: boolean;
+}
+
+/**
+ * The merged model for a list section. `filtered` off skips the reader's filter,
+ * which is what the header's attention counts need: narrowing the list must not
+ * hide a problem.
+ */
+export function modelFor(
+	source: ViewSource,
+	kind: ResourceKind,
+	skills: () => ReadonlyMap<string, SkillInfo>,
+	filtered = true,
+): PanelModel {
+	const where = filtered && isFiltering(source.filter) ? (row: PanelRow) => rowMatches(row, source.filter) : undefined;
+	if (kind === "skills") {
+		return buildSkillModel({ items: source.items("skills"), index: skills(), agentDir: source.agentDir, where });
+	}
+	return buildPanelModel({
+		items: source.items("extensions"),
+		reports: source.reports(),
+		agentDir: source.agentDir,
+		filter: source.commandFilter,
+		where,
+	});
+}
+
+/**
+ * The section sizes the tabs print: the resources each section holds. They count
+ * what the section has, not what a filter left, so a tab does not shrink while
+ * another section is being narrowed.
+ */
+export function sectionCounts(source: ViewSource): Record<PanelSection, number> {
+	return {
+		extensions: source.items("extensions").length,
+		skills: source.items("skills").length,
+		settings: source.settings.views(source.scope).length,
+	};
+}
+
+/**
+ * The tallest section's entry count, group headings included. All three sections
+ * pad their body to it, which is what keeps the dock from resizing when the tabs
+ * change. Counted through `groupedEntryCount`, so measuring Skills never reads a
+ * `SKILL.md`.
+ */
+export function tallestBody(source: ViewSource): number {
+	const lists = (["extensions", "skills"] as const).map((kind) =>
+		groupedEntryCount(source.items(kind), source.agentDir, kind),
+	);
+	const settings = settingEntries(source.settings.views(source.scope)).length;
+	return Math.max(1, ...lists, settings);
+}
+
+/** The header's attention, over every extension rather than the filter. */
+export function attentionFor(source: ViewSource): SummarySegment[] {
+	return attentionSegments(panelCounts(modelFor(source, "extensions", () => new Map(), false)), source.dirty);
+}
+
+/** The chips the tab row shows: the filter editor while open, else what applies. */
+export function chipsFor(
+	source: ViewSource,
+	section: PanelSection,
+	editing: { buffer: string } | undefined,
+): SummarySegment[] {
+	if (editing !== undefined) return [{ text: `/${editing.buffer}▏`, color: "accent" }];
+	const chips = filterChips(source.filter, section === "settings" ? "settings" : "rows");
+	// The command's own narrowing (`/bytefly plan`) is a filter the reader did not
+	// ask for this time, so the tab row says why the list is short.
+	if (source.commandFilter !== undefined && section === "extensions") {
+		chips.unshift({ text: `${source.commandFilter} only`, color: "meta" });
+	}
+	return chips;
+}
+
+/** The line a section shows in place of its body. */
+export function emptyLabelFor(filter: PanelFilter, section: PanelSection): string {
+	if (isFiltering(filter)) return "Nothing matches the filter.";
+	if (section === "skills") return "No skills found.";
+	if (section === "settings") return "No settings found.";
+	return "No extensions found.";
+}
+
+/** The group heading a row sits under, for the block's `Source` fact. */
+export function groupLabelFor(model: PanelModel | undefined, row: PanelRow | undefined): string | undefined {
+	if (model === undefined || row === undefined) return undefined;
+	return model.groups.find((group) => group.key === row.group)?.label;
+}