@gavin-hu/my-pi-agent 0.16.0 → 0.17.0

package/extensions/bytefly/panel/commands.ts

@@ -1,9 +1,10 @@
 /**
- * The `/bytefly` surface: one command, `/bytefly [doctor] [settings] [update] [extension] [refresh]`.
+ * The `/bytefly` surface: one command, `/bytefly [doctor] [settings] [skills] [update] [extension] [refresh]`.
  *
- * Without `doctor` it opens the extension screen: the dock in `tui`, the
+ * Without a section word it opens the extension screen: the dock in `tui`, the
  * grouped listing elsewhere. `settings` opens the Settings section, or prints
- * its grouped listing outside `tui` without resolving packages. `update`
+ * its grouped listing outside `tui` without resolving packages. `skills` opens
+ * the Skills section and lists the resolved skills in text modes. `update`
  * re-runs the published-version check and reports what it found, which is the
  * one place a request is made on demand. With `doctor` it produces the doctor
  * report — the same text `run_doctor` returns — for the whole set or one named
@@ -23,12 +24,13 @@ 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, discoverExtensions, type DiscoveryDeps } from "../picker/discovery.ts";
-import { createExtensionsPickerRuntime, type ExtensionsPickerRuntime } from "../picker/runtime.ts";
+import { createSettingsStores, discoverResources, type DiscoveryDeps } from "../picker/discovery.ts";
+import { createPickerRuntime, type PickerRuntime } from "../picker/runtime.ts";
 import type { Discovery } from "../picker/types.ts";
-import { formatListing, formatSettingsListing } from "./format.ts";
-import { buildPanelModel, extensionName } from "./join.ts";
+import { formatListing, formatSettingsListing, SKILL_NOUN } from "./format.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 { shippedThemeNames } from "./themes.ts";
 import { PanelComponent } from "./tui.ts";
 import type { PanelSection } from "./types.ts";
@@ -43,6 +45,8 @@ export interface PanelCommandDeps {
 	discover?: (deps: DiscoveryDeps) => Promise<Discovery>;
 	/** The Settings runtime seam. */
 	settings?: (deps: SettingsRuntimeDeps) => SettingsRuntime;
+	/** The skill-metadata seam; `loadSkillIndex` unless a test supplies one. */
+	skills?: (paths: readonly string[], cwd: string, agentDir: string) => SkillIndex;
 }
 
 /**
@@ -52,19 +56,21 @@ export interface PanelCommandDeps {
  */
 function selectableNames(discovery: Discovery): Set<string> {
 	const names = new Set<string>(Object.keys(REQUIREMENTS));
-	for (const item of [...discovery.global, ...discovery.effective]) names.add(extensionName(item.path));
+	for (const item of [...discovery.extensions.global, ...discovery.extensions.effective]) {
+		names.add(extensionName(item.path));
+	}
 	return names;
 }
 
 /** The values a bare `/bytefly <tab>` offers, in screen order. */
-const FIRST_TOKENS = ["doctor", "settings", "update", ...Object.keys(REQUIREMENTS), "refresh"] as const;
+const FIRST_TOKENS = ["doctor", "settings", "skills", "update", ...Object.keys(REQUIREMENTS), "refresh"] as const;
 
 /**
  * Argument completions. The host replaces the whole argument text with the
  * returned `value`, so a second token returns the full `doctor <name>` or
- * `<name> refresh` argument rather than just the word. `/bytefly settings` and
- * `/bytefly update` take no name, and `refresh` is never followed by another
- * token.
+ * `<name> refresh` argument rather than just the word. `/bytefly settings`,
+ * `/bytefly skills`, and `/bytefly update` take no name, and `refresh` is never
+ * followed by another token.
  */
 function completions(prefix: string): Array<{ value: string; label: string }> | null {
 	const [first = "", second, ...rest] = prefix.trimStart().split(/\s+/);
@@ -73,7 +79,7 @@ function completions(prefix: string): Array<{ value: string; label: string }> |
 		const options = FIRST_TOKENS.filter((option) => option.startsWith(first));
 		return options.length > 0 ? options.map((option) => ({ value: `${option} `, label: option })) : null;
 	}
-	if (first === "settings" || first === "refresh" || first === "update") return null;
+	if (first === "settings" || first === "skills" || first === "refresh" || first === "update") return null;
 	const options = (first === "doctor" ? [...Object.keys(REQUIREMENTS), "refresh"] : ["refresh"]).filter((option) =>
 		option.startsWith(second),
 	);
@@ -94,7 +100,7 @@ interface PanelArgs {
 	refresh: boolean;
 }
 
-/** Parse `/bytefly [doctor] [settings] [update] [extension] [refresh]`; extra tokens are ignored. */
+/** Parse `/bytefly [doctor] [settings] [skills] [update] [extension] [refresh]`; extra tokens are ignored. */
 function parseArgs(args: string): PanelArgs {
 	const parts = args.trim().split(/\s+/).filter(Boolean);
 	const refresh = parts.includes("refresh");
@@ -104,6 +110,7 @@ function parseArgs(args: string): PanelArgs {
 	// beside it is accepted and ignored rather than refused.
 	if (rest[0] === "update") return { mode: "update", section: "extensions", refresh };
 	if (rest[0] === "settings") return { mode: "screen", section: "settings", name: rest[1], refresh };
+	if (rest[0] === "skills") return { mode: "screen", section: "skills", name: rest[1], refresh };
 	return { mode: "screen", section: "extensions", name: rest[0], refresh };
 }
 
@@ -115,14 +122,14 @@ function notifyExtension(
 	ctx: ExtensionCommandContext,
 	name: string,
 	reports: readonly ExtensionReport[],
-	runtime: ExtensionsPickerRuntime,
+	runtime: PickerRuntime,
 ): void {
 	const report = reports.find((entry) => entry.extension === name);
 	if (report) {
 		ctx.ui.notify(formatExtension(report), hasProblems([report]) ? "warning" : "info");
 		return;
 	}
-	const item = runtime.items().find((entry) => extensionName(entry.path) === name);
+	const item = runtime.items("extensions").find((entry) => extensionName(entry.path) === name);
 	ctx.ui.notify(
 		item
 			? `bytefly: ${sanitizeLine(item.path)} — no doctor report`
@@ -146,15 +153,16 @@ function settingsThemeNames(ctx: ExtensionCommandContext): string[] {
 
 /** Register the single `/bytefly` command. */
 export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
-	const discover = deps.discover ?? discoverExtensions;
+	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);
-		// `/bytefly settings` has no extension argument; a stray word is a typo, not
-		// a filter, so say so rather than ignoring it.
-		if (section === "settings" && name !== undefined) {
-			ctx.ui.notify(`bytefly: /bytefly settings takes no extension name (got "${sanitizeLine(name)}").`, "warning");
+		// Only the Extensions section takes an extension argument; a stray word is a
+		// typo, not a filter, so say so rather than ignoring it.
+		if (section !== "extensions" && name !== undefined) {
+			ctx.ui.notify(`bytefly: /bytefly ${section} takes no extension name (got "${sanitizeLine(name)}").`, "warning");
 			return;
 		}
 		const cwd = ctx.cwd ?? process.cwd();
@@ -195,7 +203,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 		try {
 			discovery = await discover({ cwd, agentDir, trusted });
 		} catch (error) {
-			ctx.ui.notify(`Could not list extensions: ${error instanceof Error ? error.message : String(error)}`, "error");
+			ctx.ui.notify(`Could not list resources: ${error instanceof Error ? error.message : String(error)}`, "error");
 			return;
 		}
 
@@ -208,7 +216,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			onError: settingsNotice,
 		});
 
-		const runtime = createExtensionsPickerRuntime({
+		const runtime = createPickerRuntime({
 			discovery,
 			cwd,
 			agentDir,
@@ -222,6 +230,18 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 			return;
 		}
 
+		// 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",
+			);
+			return;
+		}
+
 		// Text modes print the report, so they probe now. The dock screen opens on
 		// the session cache and probes on its first Extensions view instead, which
 		// keeps `/bytefly` and `/bytefly settings` instant.
@@ -243,7 +263,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 				ctx.ui.notify(formatReport(reports), hasProblems(reports) ? "warning" : "info");
 				return;
 			}
-			const model = buildPanelModel({ items: runtime.items(), reports, agentDir });
+			const model = buildPanelModel({ items: runtime.items("extensions"), reports, agentDir });
 			ctx.ui.notify(formatListing(model, runtime.scope()), "info");
 			return;
 		}
@@ -269,6 +289,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 					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 });
 					},
@@ -293,7 +314,7 @@ export function registerPanel(pi: ExtensionAPI, deps: PanelCommandDeps): void {
 
 	pi.registerCommand("bytefly", {
 		description:
-			"Open the bytefly control center: /bytefly [extension] [refresh] lists extensions, /bytefly settings opens settings; /bytefly doctor [extension] [refresh] prints the doctor report",
+			"Open the bytefly control center: /bytefly [extension] [refresh] lists extensions, /bytefly skills lists skills, /bytefly settings opens settings; /bytefly doctor [extension] [refresh] prints the doctor report",
 		getArgumentCompletions: completions,
 		handler,
 	});

package/extensions/bytefly/panel/format.ts

@@ -3,7 +3,7 @@
  *
  * Every mode other than `tui` gets the same facts the screen shows, as plain
  * text: a headline with the scope and the counts, then the picker's grouped
- * listing with a health suffix on each row. The Settings listing uses the same
+ * listing with a verdict suffix on each row. The Settings listing uses the same
  * headline and groups with `Label: Value` rows. A single named extension prints
  * its full findings instead. Nothing here touches the host, and every string
  * from a probe or a settings file is sanitized before it is printed.
@@ -32,17 +32,35 @@ export interface SummarySegment {
 
 /** Row and problem counts over a model. */
 interface PanelCounts {
-	extensions: number;
+	rows: number;
 	/** Rows switched off in settings (the picker's checkbox), not the env flag. */
 	off: number;
 	missing: number;
 	degraded: number;
 }
 
+/** How one row is counted in the headline, singular, plural, and abbreviated. */
+export interface CountNoun {
+	one: string;
+	many: string;
+	/** The form a narrow terminal uses. */
+	compact: string;
+}
+
+/** Extensions are the default noun; Skills pass their own. */
+export const EXTENSION_NOUN: CountNoun = { one: "extension", many: "extensions", compact: "ext" };
+
+/** The Skills section's noun: `4 skills`, and the same word when narrowed. */
+export const SKILL_NOUN: CountNoun = { one: "skill", many: "skills", compact: "skills" };
+
 /** Options for the plain-text headline and listing. */
 export interface PanelTextOptions {
 	/** Abbreviate counts (`15 ext · 3 off`) for a narrow terminal. */
 	compact?: boolean;
+	/** What one row is called; extensions by default. */
+	noun?: CountNoun;
+	/** What the listing says when it has no rows. */
+	emptyLabel?: string;
 }
 
 /** Options for the TUI headline, which can also name a narrowed extension. */
@@ -72,7 +90,7 @@ export function panelCounts(model: PanelModel): PanelCounts {
 		missing += report.findings.filter((finding) => finding.severity === "missing").length;
 		degraded += report.findings.filter((finding) => finding.severity === "degraded").length;
 	}
-	return { extensions: model.rows.length, off, missing, degraded };
+	return { rows: model.rows.length, off, missing, degraded };
 }
 
 /**
@@ -81,12 +99,13 @@ export function panelCounts(model: PanelModel): PanelCounts {
  */
 export function summarySegments(model: PanelModel, scope: PanelScope, options: SummaryOptions = {}): SummarySegment[] {
 	const counts = panelCounts(model);
+	const forms = options.noun ?? EXTENSION_NOUN;
 	const segments: SummarySegment[] = [{ text: scope === "global" ? "Global" : "Project", color: "accent" }];
 	if (options.filter !== undefined) {
 		segments.push({ text: `${options.filter} only`, color: "meta" });
 	} else {
-		const noun = options.compact ? "ext" : counts.extensions === 1 ? "extension" : "extensions";
-		segments.push({ text: `${counts.extensions} ${noun}`, color: "meta" });
+		const noun = options.compact ? forms.compact : counts.rows === 1 ? forms.one : forms.many;
+		segments.push({ text: `${counts.rows} ${noun}`, color: "meta" });
 		if (counts.off > 0) segments.push({ text: `${counts.off} off`, color: "meta" });
 	}
 	const problems: string[] = [];
@@ -98,15 +117,25 @@ export function summarySegments(model: PanelModel, scope: PanelScope, options: S
 	return segments;
 }
 
+/** The sections left to right, as the bar reads them. */
+export const SECTION_ORDER: readonly PanelSection[] = ["extensions", "skills", "settings"];
+
+/** One section's name in the bar. */
+const SECTION_LABELS: Record<PanelSection, string> = {
+	extensions: "Extensions",
+	skills: "Skills",
+	settings: "Settings",
+};
+
 /**
- * The section bar's two segments, in screen order. The active section takes the
- * accent and the other recedes, so the bar reads as a two-way switch.
+ * The section bar's segments, in screen order. The active section takes the
+ * accent and the others recede, so the bar reads as a left-to-right switch.
  */
 export function sectionSegments(active: PanelSection): SummarySegment[] {
-	return [
-		{ text: "Extensions", color: active === "extensions" ? "accent" : "faint" },
-		{ text: "Settings", color: active === "settings" ? "accent" : "faint" },
-	];
+	return SECTION_ORDER.map((section) => ({
+		text: SECTION_LABELS[section],
+		color: active === section ? "accent" : "faint",
+	}));
 }
 
 /** The Settings section's counts: the scope and how many rows it shows. */
@@ -151,15 +180,21 @@ 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
+ * 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
- * rather than sharing the word: `env disabled`. The glyph marks what needs
+ * 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
  * 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" };
+	// A skill's verdict comes from its own file, not from a probed report: a file
+	// Pi refused is a warning, and one hidden from the model still loads by name.
+	if (row.skill?.problem !== undefined) return { glyph: GLYPHS.warn, role: "warn", text: "not loaded" };
+	if (row.skill?.modelHidden === true) return { role: "faint", text: "hidden" };
 	const report = row.report;
 	if (!report) return { role: "faint" };
 	if (!report.enabled) return { glyph: GLYPHS.disabled, role: "faint", text: "env disabled" };
@@ -185,7 +220,7 @@ export function formatRow(row: PanelRow): string {
 export function formatListing(model: PanelModel, scope: PanelScope, options: PanelTextOptions = {}): string {
 	const lines = [formatHeadline(model, scope, options)];
 	if (model.rows.length === 0) {
-		lines.push("", "No extensions found.");
+		lines.push("", options.emptyLabel ?? "No extensions found.");
 		return lines.join("\n");
 	}
 	for (const group of model.groups) {

package/extensions/bytefly/panel/join.ts

@@ -1,9 +1,10 @@
 /**
- * The merge behind the unified panel: one row per extension resource, joining
- * the picker's resolved items to the doctor's reports.
+ * The merge behind the unified panel: one row per resolved resource, joining the
+ * picker's items to whatever describes them — the doctor's report for an
+ * extension, the loaded `SKILL.md` metadata for a skill.
  *
- * The join key is the extension directory (`basename(dirname(path))`), not the
- * display name: a subfolder resource is shown as `web-access/index.ts` but its
+ * The join key for an extension is its directory (`basename(dirname(path))`), not
+ * the display name: a subfolder resource is shown as `web-access/index.ts` but its
  * report is named `web-access`. A directory name is only usable when it maps to
  * exactly one unique resource path — two unrelated extensions can share a
  * directory name (a user `plan` beside the package's `plan`) and every flat file
@@ -15,14 +16,15 @@
  * for a report with no item) so the cursor survives a rebuild even when two
  * rows share a directory name. Items keep the picker's grouping and order, and
  * a row never invents health: an item without a report carries no glyph and no
- * summary.
+ * summary. Skills skip the report half entirely and take their label and detail
+ * text from the skill index instead.
  */
 
 import { basename, dirname } from "node:path";
 import type { ExtensionReport } from "../../../lib/requirements.ts";
 import { buildEntries, resourceKey } from "../picker/resources.ts";
-import type { ResourceItem } from "../picker/types.ts";
-import type { PanelGroup, PanelModel, PanelRow } from "./types.ts";
+import type { ResourceItem, ResourceKind } from "../picker/types.ts";
+import type { PanelGroup, PanelModel, PanelRow, SkillInfo } from "./types.ts";
 
 /** The extension directory name that joins a resolved item to its report. */
 export function extensionName(path: string): string {
@@ -44,11 +46,13 @@ export interface PanelJoinOptions {
 	agentDir: string;
 	/** Narrow to one extension directory or report name, or `undefined` for the full list. */
 	filter?: string;
+	/** Which resource kind the list is, for labels and grouping. */
+	kind?: ResourceKind;
 }
 
 /** Build the merged model for the current items and reports. */
 export function buildPanelModel(options: PanelJoinOptions): PanelModel {
-	const { items, reports, agentDir, filter } = options;
+	const { items, reports, agentDir, filter, kind = "extensions" } = options;
 	const byName = new Map(reports.map((report) => [report.extension, report]));
 
 	// A directory name may claim a report only when exactly one unique resource
@@ -68,7 +72,7 @@ export function buildPanelModel(options: PanelJoinOptions): PanelModel {
 	const rows: PanelRow[] = [];
 	let current: PanelGroup | undefined;
 
-	for (const entry of buildEntries([...items], agentDir)) {
+	for (const entry of buildEntries([...items], agentDir, kind)) {
 		if (entry.kind === "group") {
 			current = { key: entry.key, label: entry.label, count: 0 };
 			groups.push(current);
@@ -96,3 +100,25 @@ export function buildPanelModel(options: PanelJoinOptions): PanelModel {
 
 	return { groups: groups.filter((group) => group.count > 0), rows };
 }
+
+/**
+ * The Skills model: the grouped list an extension screen shows, labelled by the
+ * skill's declared name and carrying what its detail pane needs. There is no
+ * doctor report for a skill, so the only join is to the loaded metadata; a file
+ * Pi refused keeps the name its path gives it and carries the reason.
+ */
+export function buildSkillModel(options: {
+	items: readonly ResourceItem[];
+	index: ReadonlyMap<string, SkillInfo>;
+	agentDir: string;
+}): PanelModel {
+	const model = buildPanelModel({ items: options.items, reports: [], agentDir: options.agentDir, kind: "skills" });
+	return {
+		groups: model.groups,
+		rows: model.rows.map((row) => {
+			const skill = row.item ? options.index.get(row.item.path) : undefined;
+			if (skill === undefined) return row;
+			return { ...row, label: skill.name ?? row.label, skill };
+		}),
+	};
+}

package/extensions/bytefly/panel/settings.ts

@@ -18,7 +18,7 @@
  *
  * Three sections have a normalizer here, so the screen shows what the notifier,
  * the doctor, and the footer keep. The three owned by other extensions (`rewind`,
- * `job`, `watch`) are read as the file states them, because importing their
+ * `job`, `plan`) are read as the file states them, because importing their
  * normalizer would be one extension importing another's module; each such row
  * declares the loader's default, and `test/settings-coverage.test.ts` holds the
  * pair together.
@@ -61,7 +61,7 @@ interface TextRule {
 }
 
 /** The `bytefly.json` sections a row still reaches. */
-export type ConfigSectionName = "notify" | "doctor" | "price" | "rewind" | "job" | "watch";
+export type ConfigSectionName = "notify" | "doctor" | "price" | "rewind" | "job" | "plan";
 
 /** Where a `bytefly.json` row lives: a section, and the path to its leaf. */
 interface SettingConfig {
@@ -125,14 +125,6 @@ const ON_OFF: readonly SettingOption[] = [
 ];
 
 /** The notify section's delivery methods, labeled by the surface each reaches. */
-const METHOD_OPTIONS: readonly SettingOption[] = [
-	{ value: "auto", label: "Auto" },
-	{ value: "osc777", label: "OSC 777" },
-	{ value: "osc99", label: "OSC 99" },
-	{ value: "toast", label: "Windows toast" },
-	{ value: "osascript", label: "macOS" },
-	{ value: "notify-send", label: "Linux" },
-];
 
 /**
  * A text rule for a money amount inside an inclusive range: a whole number or a
@@ -155,8 +147,9 @@ function amountRule(min: number, max: number): TextRule {
 /**
  * The catalogue, in screen order.
  *
- * Global scope lists all fourteen; Project lists the twelve `bytefly.json` rows,
- * because Pi's setters write the personal `settings.json` only.
+ * Global scope lists all thirteen; Project lists the eleven `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.
  */
 export const SETTING_ROWS: readonly SettingDescriptor[] = [
 	{
@@ -235,16 +228,6 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		options: ON_OFF,
 		config: { section: "notify", path: ["matchFound"] },
 	},
-	{
-		id: "notify.method",
-		label: "Delivery method",
-		description: "How a notification is delivered; Auto picks from the terminal, then the platform.",
-		source: "bytefly",
-		kind: "enum",
-		fallback: "auto",
-		options: METHOD_OPTIONS,
-		config: { section: "notify", path: ["method"] },
-	},
 	{
 		id: "job.wakeOnFinish",
 		label: "Wake when a job finishes",
@@ -257,15 +240,15 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		config: { section: "job", path: ["wakeOnFinish"] },
 	},
 	{
-		id: "watch.wakeOnMatch",
-		label: "Wake on a match",
-		description: "Start one agent turn when a watcher matches while the agent is idle.",
+		id: "plan.goalPrompt",
+		label: "Offer the session goal",
+		description: "Ask before recording an approved plan as the session goal; off records it without asking.",
 		source: "bytefly",
 		kind: "boolean",
-		fallback: "false",
+		fallback: "true",
 		json: "boolean",
 		options: ON_OFF,
-		config: { section: "watch", path: ["wakeOnMatch"] },
+		config: { section: "plan", path: ["goalPrompt"] },
 	},
 	{
 		id: "rewind.autoSnapshots",

package/extensions/bytefly/panel/skills.ts

@@ -0,0 +1,51 @@
+/**
+ * Skill metadata for the panel.
+ *
+ * One `loadSkills` call reads every resolved `SKILL.md` and hands back the
+ * declared name, description, and model-invocation flag, keyed by file path so
+ * the row model can join it. Pi's loader also reports why it refused a file, and
+ * that reason travels with the row so the screen can say `not loaded` instead of
+ * silently showing a name. Nothing here renders or writes; the panel reads the
+ * index when the Skills section first becomes visible.
+ */
+
+import { loadSkills } from "@earendil-works/pi-coding-agent";
+import type { Discovery } from "../picker/types.ts";
+import type { SkillInfo } from "./types.ts";
+
+/** Loaded skill metadata keyed by the resolved resource path. */
+export type SkillIndex = ReadonlyMap<string, SkillInfo>;
+
+/** Every skill file either discovery view resolves, once, for the loader. */
+export function resolvedSkillPaths(discovery: Discovery): string[] {
+	const paths = [...discovery.skills.global, ...discovery.skills.effective].map((item) => item.path);
+	return [...new Set(paths)];
+}
+
+/**
+ * Read the metadata for every resolved skill path. A path may be a `SKILL.md`
+ * or a standalone Markdown skill; both are what the resolver hands the panel.
+ *
+ * A diagnostic names the file Pi refused, so it becomes that row's `problem`. A
+ * warning about a file that still loaded is dropped: the row's own name and
+ * description already come from the same loader, and `not loaded` would be a
+ * lie about a skill the model can use.
+ */
+export function loadSkillIndex(paths: readonly string[], cwd: string, agentDir: string): SkillIndex {
+	if (paths.length === 0) return new Map();
+	const { skills, diagnostics } = loadSkills({ cwd, agentDir, skillPaths: [...paths], includeDefaults: false });
+	const index = new Map<string, SkillInfo>();
+	for (const skill of skills) {
+		index.set(skill.filePath, {
+			name: skill.name,
+			description: skill.description,
+			modelHidden: skill.disableModelInvocation,
+		});
+	}
+	for (const diagnostic of diagnostics) {
+		const path = diagnostic.path;
+		if (path === undefined || index.has(path)) continue;
+		index.set(path, { description: "", modelHidden: false, problem: diagnostic.message });
+	}
+	return index;
+}

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

@@ -1,54 +1,19 @@
 /**
- * The Extensions section: its summary line, one row per resolved extension, and
- * the detail pane for the focused row.
+ * The Extensions section's focused-row pane.
  *
- * Pure functions over the merged model — the component owns the cursor, the
- * filter, and the probe state, and passes them in.
+ * The row, the summary, and the key hints are the shared list grammar; what is
+ * specific here is the doctor's findings, including the resource path when a row
+ * has no verdict.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import type { ScreenHint } from "../../../../lib/tui/chrome.ts";
 import { sanitizeLine } from "../../../../lib/format.ts";
 import { clip } from "../../../../lib/tui/columns.ts";
-import { checkbox, listRow } from "../../../../lib/tui/rows.ts";
 import { paint } from "../../../../lib/tui/tokens.ts";
 import { detailLines as reportDetailLines } from "../../doctor/format.ts";
-import { rowBadge, summarySegments, type PanelScope } from "../format.ts";
-import type { PanelModel, PanelRow } from "../types.ts";
-import { countsLine, savedLine } from "./frame.ts";
-
-/** The section's hits, its scope, and how many need attention. */
-export function extensionSummary(
-	theme: Theme,
-	width: number,
-	model: PanelModel,
-	scope: PanelScope,
-	filter: string | undefined,
-): string {
-	return countsLine(theme, width, summarySegments(model, scope, { filter, compact: width < 72 }));
-}
-
-/** One extension row: its checkbox, health glyph, name, and verdict. */
-export function extensionRow(theme: Theme, width: number, row: PanelRow, selected: boolean): string {
-	const badge = rowBadge(row);
-	return listRow(theme, width, {
-		selected,
-		// A reported-only row has no enable pattern, but still reserves the box
-		// column so the list stays aligned.
-		leading: row.item ? checkbox(theme, row.item.enabled) : " ",
-		glyph: badge.glyph ?? " ",
-		glyphRole: badge.role,
-		label: sanitizeLine(row.label),
-		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",
-	});
-}
+import { rowBadge } from "../format.ts";
+import type { PanelRow } from "../types.ts";
+import { savedLine } from "./frame.ts";
 
 /** The focused extension's findings and the pending-changes note. */
 export function extensionDetail(
@@ -73,22 +38,3 @@ export function extensionDetail(
 	lines.push(...savedLine(theme, width, dirty));
 	return lines;
 }
-
-/** The section's key hints, in the order they drop as the width runs out. */
-export function extensionHints(options: {
-	expanded: boolean;
-	refreshing: boolean;
-	projectScope: boolean;
-}): ScreenHint[] {
-	return [
-		"Esc close",
-		"←/→",
-		{ text: "Space toggle", color: "accent" },
-		{ text: options.expanded ? "Enter collapse" : "Enter detail", color: "accent" },
-		"Tab scope",
-		// Only Project scope can hold an override, so the key is not offered elsewhere.
-		...(options.projectScope ? ["x inherit"] : []),
-		options.refreshing ? "refreshing…" : "r refresh",
-		"↑/↓ select",
-	];
-}