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

package/extensions/bytefly/panel/types.ts

@@ -2,16 +2,32 @@
  * Types for the unified bytefly panel: the merged row model the formatter and
  * the screen both read.
  *
- * A row is the union of one picker item and its doctor report, joined on the
- * extension directory name. Either side may be absent: an item without a report
- * renders no health, and a report without an item has no checkbox.
+ * A row is one picker item, optionally joined to its doctor report (extensions)
+ * or to what its `SKILL.md` declares (skills). Either side may be absent: an item
+ * without a report renders no health, a report without an item has no checkbox,
+ * and a skill Pi refused to load carries the reason instead.
  */
 
 import type { ExtensionReport } from "../../../lib/requirements.ts";
 import type { ResourceItem } from "../picker/types.ts";
 
-/** The control center's surfaces: the extension list and the settings list. */
-export type PanelSection = "extensions" | "settings";
+/** The control center's sections: the two resource lists and the settings list. */
+export type PanelSection = "extensions" | "skills" | "settings";
+
+/**
+ * What a skill's `SKILL.md` declares, as Pi loaded it. A file Pi refused carries
+ * `problem` and no name, so the row keeps the name its path gives it.
+ */
+export interface SkillInfo {
+	/** Frontmatter name; absent when Pi did not load the file. */
+	name?: string;
+	/** Frontmatter description, empty when Pi did not load the file. */
+	description: string;
+	/** `disable-model-invocation`: reachable only through `/skill:<name>`. */
+	modelHidden: boolean;
+	/** Why Pi did not load the file, when it did not. */
+	problem?: string;
+}
 
 /** One group header in the merged model. */
 export interface PanelGroup {
@@ -23,18 +39,20 @@ export interface PanelGroup {
 	count: number;
 }
 
-/** One extension row: a picker item, a doctor report, or both. */
+/** One resource row: a picker item, a doctor report, or both. */
 export interface PanelRow {
 	/**
 	 * Unique row identity: `source:path` for an item, `report:<name>` for a
 	 * report-only row. Never the directory name, which two rows can share.
 	 */
 	key: string;
-	/** The resolved extension item, when the picker has one. */
+	/** The resolved resource item, when the picker has one. */
 	item?: ResourceItem;
 	/** The doctor report, when one exists for this directory. */
 	report?: ExtensionReport;
-	/** Picker display name (`folder/file.ts`), or the report name when no item. */
+	/** What the skill's `SKILL.md` declares, on a Skills row. */
+	skill?: SkillInfo;
+	/** Picker display name (`folder/file.ts`, a skill name), or the report name when no item. */
 	label: string;
 	/** Key of the group this row belongs to. */
 	group: string;

package/extensions/bytefly/picker/discovery.ts

@@ -3,24 +3,20 @@
  *
  * Builds the two settings views the screen shows — personal (`global`) and the
  * effective one the session sees (`effective`) — from Pi's public
- * `SettingsManager` and `DefaultPackageManager`. Both managers and resolvers
- * are built through a small factory seam so tests can supply in-memory doubles
- * instead of touching real settings files or installed packages.
+ * `SettingsManager` and `DefaultPackageManager`, for both resource kinds the
+ * screen lists. Both managers and resolvers are built through a small factory
+ * seam so tests can supply in-memory doubles instead of touching real settings
+ * files or installed packages.
  */
 
-import {
-	DefaultPackageManager,
-	getAgentDir,
-	type ResolvedResource,
-	SettingsManager,
-} from "@earendil-works/pi-coding-agent";
+import { DefaultPackageManager, getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
 import { isSelf } from "./resources.ts";
-import type { Discovery, ExtensionResolver, SettingsStore } from "./types.ts";
+import type { Discovery, ResolvedResources, ResourceResolver, SettingsStore } from "./types.ts";
 
-/** One settings view: the store to write through and its resolved extensions. */
+/** One settings view: the store to write through and its resolved resources. */
 interface View {
 	store: SettingsStore;
-	resolve(): Promise<ResolvedResource[]>;
+	resolve(): Promise<ResolvedResources>;
 }
 
 /** Builds isolated global and project views. Injected by tests. */
@@ -44,8 +40,10 @@ export function createSettingsStore(manager: SettingsManager): SettingsStore {
 		projectSettings: () => manager.getProjectSettings(),
 		packages: () => manager.getPackages(),
 		setExtensionPaths: (paths) => manager.setExtensionPaths(paths),
+		setSkillPaths: (paths) => manager.setSkillPaths(paths),
 		setPackages: (packages) => manager.setPackages(packages),
 		setProjectExtensionPaths: (paths) => manager.setProjectExtensionPaths(paths),
+		setProjectSkillPaths: (paths) => manager.setProjectSkillPaths(paths),
 		setProjectPackages: (packages) => manager.setProjectPackages(packages),
 		setQuietStartup: (quiet) => manager.setQuietStartup(quiet),
 		setOutputPad: (padding) => manager.setOutputPad(padding),
@@ -76,18 +74,16 @@ export function createSettingsStores(
 
 /** The slice of `DefaultPackageManager` the resolver uses. */
 export interface ResolverManager {
-	resolve(
-		onMissing?: (source: string) => Promise<"install" | "skip" | "error">,
-	): Promise<{ extensions: ResolvedResource[] }>;
+	resolve(onMissing?: (source: string) => Promise<"install" | "skip" | "error">): Promise<ResolvedResources>;
 }
 
-/** Resolve a settings view's packages into extension resources, never installing. */
+/** Resolve a settings view's packages into resources, never installing. */
 export function createResolver(
 	settingsManager: SettingsManager,
 	cwd: string,
 	agentDir: string,
 	manager?: ResolverManager,
-): ExtensionResolver {
+): ResourceResolver {
 	const packages =
 		manager ??
 		new DefaultPackageManager({
@@ -99,7 +95,10 @@ export function createResolver(
 			builtinExtensions: [],
 		});
 	return {
-		resolve: async () => (await packages.resolve(async () => "skip")).extensions,
+		resolve: async () => {
+			const resolved = await packages.resolve(async () => "skip");
+			return { extensions: resolved.extensions, skills: resolved.skills };
+		},
 	};
 }
 
@@ -119,31 +118,37 @@ export function createDiscoveryFactory(cwd: string, agentDir: string): Discovery
  * can read or write project configuration.
  *
  * `bytefly`'s entrypoint — the extension that hosts this picker — is dropped
- * from every view, so the picker does not list itself and the row set, the
- * disabled count, and the text listing all agree.
+ * from the extension views, so the picker does not list itself and the row set,
+ * the disabled count, and the text listing all agree. Skills have no such self
+ * entry, so their lists are passed through untouched.
  */
-export async function discoverExtensions(deps: DiscoveryDeps): Promise<Discovery> {
+export async function discoverResources(deps: DiscoveryDeps): Promise<Discovery> {
 	const agentDir = deps.agentDir ?? getAgentDir();
 	const factory = deps.factory ?? createDiscoveryFactory(deps.cwd, agentDir);
 
 	const globalView = factory.global();
-	const global = (await globalView.resolve()).filter((item) => !isSelf(item));
+	const global = withoutSelf(await globalView.resolve());
 
 	if (!deps.trusted) {
 		return {
-			global,
-			effective: global,
+			extensions: { global: global.extensions, effective: global.extensions },
+			skills: { global: global.skills, effective: global.skills },
 			stores: { global: globalView.store, project: globalView.store },
 			trusted: false,
 		};
 	}
 
 	const projectView = factory.project();
-	const effective = (await projectView.resolve()).filter((item) => !isSelf(item));
+	const effective = withoutSelf(await projectView.resolve());
 	return {
-		global,
-		effective,
+		extensions: { global: global.extensions, effective: effective.extensions },
+		skills: { global: global.skills, effective: effective.skills },
 		stores: { global: globalView.store, project: projectView.store },
 		trusted: true,
 	};
 }
+
+/** Drop this extension's own entrypoint from the extension list, and only that. */
+function withoutSelf(resources: ResolvedResources): ResolvedResources {
+	return { extensions: resources.extensions.filter((item) => !isSelf(item)), skills: resources.skills };
+}

package/extensions/bytefly/picker/resources.ts

@@ -4,14 +4,14 @@
  *
  * The pattern functions are a trimmed port of Pi's own config selector
  * (`dist/modes/interactive/components/config-selector.js`) restricted to the
- * `extensions` resource type. Keeping them here, pure and separately tested,
- * makes a future drift from the built-in easy to diff.
+ * two resource types the screen toggles. Keeping them here, pure and separately
+ * tested, makes a future drift from the built-in easy to diff.
  */
 
 import { homedir } from "node:os";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { CONFIG_DIR_NAME, type PathMetadata } from "@earendil-works/pi-coding-agent";
-import type { Entry, ResourceItem } from "./types.ts";
+import type { Entry, ResourceItem, ResourceKind } from "./types.ts";
 
 /** Settings scope of a single resource, in the config selector's vocabulary. */
 type ItemScope = "user" | "project";
@@ -133,11 +133,18 @@ export function isSelf(item: ResourceItem): boolean {
 	return basename(dirname(item.path)) === SELF_EXTENSION_DIR;
 }
 
-/** Short name for one extension: `folder/file.ts` when it sits in a subfolder. */
-export function getDisplayName(item: ResourceItem): string {
+/** The file name that makes a directory a skill root. */
+const SKILL_FILE = "SKILL.md";
+
+/**
+ * Short name for one resource: `folder/file.ts` for a subfolder extension, the
+ * frontmatter-free folder name for a skill, and a standalone skill's file stem.
+ */
+export function getDisplayName(item: ResourceItem, kind: ResourceKind = "extensions"): string {
 	const fileName = basename(item.path);
 	const parentFolder = basename(dirname(item.path));
 	if (item.metadata.source === "builtin") return fileName;
+	if (kind === "skills") return fileName === SKILL_FILE ? parentFolder : fileName.replace(/\.md$/i, "");
 	return parentFolder === "extensions" ? fileName : `${parentFolder}/${fileName}`;
 }
 
@@ -164,7 +171,7 @@ interface Group {
  * Flatten resources into group headers and item rows, sorted packages-first,
  * then user-before-project, then by source; items sort by display name.
  */
-export function buildEntries(items: ResourceItem[], agentDir: string): Entry[] {
+export function buildEntries(items: ResourceItem[], agentDir: string, kind: ResourceKind = "extensions"): Entry[] {
 	const groups = new Map<string, Group>();
 	for (const item of items) {
 		const { metadata } = item;
@@ -192,9 +199,10 @@ export function buildEntries(items: ResourceItem[], agentDir: string): Entry[] {
 
 	const entries: Entry[] = [];
 	for (const group of sorted) {
-		const items = [...group.items].sort((a, b) => getDisplayName(a).localeCompare(getDisplayName(b)));
+		const items = [...group.items].sort((a, b) => getDisplayName(a, kind).localeCompare(getDisplayName(b, kind)));
 		entries.push({ kind: "group", key: group.key, label: group.label, count: items.length });
-		for (const item of items) entries.push({ kind: "item", key: resourceKey(item), item, label: getDisplayName(item) });
+		for (const item of items)
+			entries.push({ kind: "item", key: resourceKey(item), item, label: getDisplayName(item, kind) });
 	}
 	return entries;
 }

package/extensions/bytefly/picker/runtime.ts

@@ -1,10 +1,10 @@
 /**
- * Stateful core of the extensions picker, independent of rendering.
+ * Stateful core of the resource picker, independent of rendering.
  *
- * Owns the active write scope and the live copies of both resource views,
+ * Owns the active write scope and the live copies of both kinds' views,
  * computes toggles through the pure `toggle.ts` helpers, and persists them
  * through the scope's `SettingsStore`. The TUI subscribes with `onChange` and
- * reads `items()` on every render, so it stays a derived view of this state.
+ * reads `items(kind)` on every render, so it stays a derived view of this state.
  */
 
 import { getDisplayName, getPackageResourcePattern, getResourcePattern } from "./resources.ts";
@@ -16,7 +16,7 @@ import {
 	nextProjectTopLevelList,
 	nextTopLevelList,
 } from "./toggle.ts";
-import type { Discovery, ResourceItem, SettingsStore, WriteScope } from "./types.ts";
+import type { Discovery, ResourceItem, ResourceKind, Settings, SettingsStore, WriteScope } from "./types.ts";
 
 export interface RuntimeDeps {
 	discovery: Discovery;
@@ -25,16 +25,16 @@ export interface RuntimeDeps {
 	onError?: (message: string) => void;
 }
 
-export interface ExtensionsPickerRuntime {
+export interface PickerRuntime {
 	scope(): WriteScope;
 	setScope(scope: WriteScope): void;
-	items(): ResourceItem[];
-	disabledCount(): number;
+	items(kind: ResourceKind): ResourceItem[];
+	disabledCount(kind: ResourceKind): number;
 	projectAvailable(): boolean;
 	isDirty(): boolean;
-	toggle(item: ResourceItem): Promise<void>;
+	toggle(kind: ResourceKind, item: ResourceItem): Promise<void>;
 	/** Drop `item`'s project override in Project scope; a no-op when it has none. */
-	clearOverride(item: ResourceItem): Promise<void>;
+	clearOverride(kind: ResourceKind, item: ResourceItem): Promise<void>;
 	onChange(listener: () => void): () => void;
 }
 
@@ -48,42 +48,69 @@ function sameResource(left: ResourceItem, right: ResourceItem): boolean {
 	return left.metadata.source === right.metadata.source && left.path === right.path;
 }
 
-export function createExtensionsPickerRuntime(deps: RuntimeDeps): ExtensionsPickerRuntime {
+/** How one resource kind is stored: its settings list and the writers beside it. */
+interface ResourceOps {
+	read(settings: Settings): string[];
+	write(store: SettingsStore, paths: string[]): void;
+	writeProject(store: SettingsStore, paths: string[]): void;
+}
+
+/** The two settings keys the picker toggles, and their setters. */
+const RESOURCE_OPS: Record<ResourceKind, ResourceOps> = {
+	extensions: {
+		read: (settings) => settings.extensions ?? [],
+		write: (store, paths) => store.setExtensionPaths(paths),
+		writeProject: (store, paths) => store.setProjectExtensionPaths(paths),
+	},
+	skills: {
+		read: (settings) => settings.skills ?? [],
+		write: (store, paths) => store.setSkillPaths(paths),
+		writeProject: (store, paths) => store.setProjectSkillPaths(paths),
+	},
+};
+
+/** A fresh copy of one list, so a toggle mutates this runtime's view. */
+function copies(items: readonly ResourceItem[]): ResourceItem[] {
+	return items.map((item) => ({ ...item }));
+}
+
+export function createPickerRuntime(deps: RuntimeDeps): PickerRuntime {
 	const { discovery, cwd, agentDir } = deps;
 	let scope: WriteScope = "global";
 	let dirty = false;
 	const listeners = new Set<() => void>();
-	// Copies so a toggle mutates this runtime's view, not the discovery result.
-	const views: Record<WriteScope, ResourceItem[]> = {
-		global: discovery.global.map((item) => ({ ...item })),
-		project: discovery.effective.map((item) => ({ ...item })),
+	const views: Record<WriteScope, Record<ResourceKind, ResourceItem[]>> = {
+		global: { extensions: copies(discovery.extensions.global), skills: copies(discovery.skills.global) },
+		project: { extensions: copies(discovery.extensions.effective), skills: copies(discovery.skills.effective) },
 	};
 
-	const current = (): ResourceItem[] => (scope === "global" ? views.global : views.project);
+	const current = (kind: ResourceKind): ResourceItem[] => views[scope][kind];
 
 	const emit = (): void => {
 		for (const listener of listeners) listener();
 	};
 
-	const persistGlobal = (item: ResourceItem, enabled: boolean): void => {
+	const persistGlobal = (kind: ResourceKind, item: ResourceItem, enabled: boolean): void => {
 		const store = storeFor(discovery, "global");
+		const ops = RESOURCE_OPS[kind];
 		if (item.metadata.origin === "top-level") {
 			const pattern = getResourcePattern(item, cwd, agentDir);
-			store.setExtensionPaths(nextTopLevelList(store.globalSettings().extensions ?? [], pattern, enabled));
+			ops.write(store, nextTopLevelList(ops.read(store.globalSettings()), pattern, enabled));
 			return;
 		}
 		const pattern = getPackageResourcePattern(item);
-		store.setPackages(nextGlobalPackages(store.packages(), item.metadata.source, pattern, enabled));
+		store.setPackages(nextGlobalPackages(store.packages(), item.metadata.source, pattern, enabled, kind));
 	};
 
-	const persistProject = (item: ResourceItem, enabled: boolean): void => {
+	const persistProject = (kind: ResourceKind, item: ResourceItem, enabled: boolean): void => {
 		const store = storeFor(discovery, "project");
+		const ops = RESOURCE_OPS[kind];
 		if (item.metadata.origin === "top-level") {
-			const currentPaths = store.projectSettings().extensions ?? [];
-			store.setProjectExtensionPaths(nextProjectTopLevelList(currentPaths, item, enabled, cwd, agentDir));
+			const currentPaths = ops.read(store.projectSettings());
+			ops.writeProject(store, nextProjectTopLevelList(currentPaths, item, enabled, cwd, agentDir));
 			return;
 		}
-		store.setProjectPackages(nextProjectPackages(store.packages(), item, enabled, cwd, agentDir));
+		store.setProjectPackages(nextProjectPackages(store.packages(), item, enabled, cwd, agentDir, kind));
 	};
 
 	/**
@@ -91,17 +118,18 @@ export function createExtensionsPickerRuntime(deps: RuntimeDeps): ExtensionsPick
 	 * absent override returns `false` without touching the store, so a stray key
 	 * press cannot dirty the file.
 	 */
-	const clearFromStore = (item: ResourceItem): boolean => {
+	const clearFromStore = (kind: ResourceKind, item: ResourceItem): boolean => {
 		const store = storeFor(discovery, "project");
+		const ops = RESOURCE_OPS[kind];
 		if (item.metadata.origin === "top-level") {
-			const paths = store.projectSettings().extensions ?? [];
+			const paths = ops.read(store.projectSettings());
 			const next = clearProjectTopLevelList(paths, item, cwd, agentDir);
 			if (next === paths) return false;
-			store.setProjectExtensionPaths(next);
+			ops.writeProject(store, next);
 			return true;
 		}
 		const packages = store.packages();
-		const next = clearProjectPackages(packages, item, cwd, agentDir);
+		const next = clearProjectPackages(packages, item, cwd, agentDir, kind);
 		if (next === packages) return false;
 		store.setProjectPackages(next);
 		return true;
@@ -116,14 +144,14 @@ export function createExtensionsPickerRuntime(deps: RuntimeDeps): ExtensionsPick
 			emit();
 		},
 		items: current,
-		disabledCount: () => current().filter((item) => !item.enabled).length,
+		disabledCount: (kind) => current(kind).filter((item) => !item.enabled).length,
 		projectAvailable: () => discovery.trusted,
 		isDirty: () => dirty,
-		toggle: async (item) => {
+		toggle: async (kind, item) => {
 			const enabled = !item.enabled;
 			try {
-				if (scope === "global") persistGlobal(item, enabled);
-				else persistProject(item, enabled);
+				if (scope === "global") persistGlobal(kind, item, enabled);
+				else persistProject(kind, item, enabled);
 				const store = storeFor(discovery, scope);
 				await store.flush();
 				for (const error of store.drainErrors()) deps.onError?.(error.error.message);
@@ -135,15 +163,15 @@ export function createExtensionsPickerRuntime(deps: RuntimeDeps): ExtensionsPick
 			dirty = true;
 			emit();
 		},
-		clearOverride: async (item) => {
+		clearOverride: async (kind, item) => {
 			if (scope !== "project") {
 				deps.onError?.("Overrides are cleared in Project scope; switch with Tab.");
 				return;
 			}
 			const store = storeFor(discovery, "project");
 			try {
-				if (!clearFromStore(item)) {
-					deps.onError?.(`No project override for ${getDisplayName(item)}.`);
+				if (!clearFromStore(kind, item)) {
+					deps.onError?.(`No project override for ${getDisplayName(item, kind)}.`);
 					return;
 				}
 				await store.flush();
@@ -154,7 +182,7 @@ export function createExtensionsPickerRuntime(deps: RuntimeDeps): ExtensionsPick
 			}
 			// With the override gone the row shows the inherited state again; a
 			// project-only resource has no global twin and keeps its value.
-			const inherited = views.global.find((entry) => sameResource(entry, item));
+			const inherited = views.global[kind].find((entry) => sameResource(entry, item));
 			if (inherited) item.enabled = inherited.enabled;
 			dirty = true;
 			emit();

package/extensions/bytefly/picker/toggle.ts

@@ -20,7 +20,7 @@ import {
 	isLocalPath,
 	resolveLocalSource,
 } from "./resources.ts";
-import type { ResourceItem } from "./types.ts";
+import type { ResourceItem, ResourceKind } from "./types.ts";
 
 /** Replace any prior pattern for `pattern` and append `+pattern` / `-pattern`. */
 export function nextTopLevelList(current: string[], pattern: string, enabled: boolean): string[] {
@@ -30,15 +30,17 @@ export function nextTopLevelList(current: string[], pattern: string, enabled: bo
 }
 
 /**
- * Toggle one extension inside a package entry, converting a string source to
+ * Toggle one resource inside a package entry, converting a string source to
  * object form when needed and collapsing it back when no filters remain.
- * Packages not present in `packages` are returned unchanged.
+ * Packages not present in `packages` are returned unchanged. `kind` names which
+ * filter list on the entry the pattern lands in.
  */
 export function nextGlobalPackages(
 	packages: PackageSource[],
 	source: string,
 	pattern: string,
 	enabled: boolean,
+	kind: ResourceKind,
 ): PackageSource[] {
 	const updated = [...packages];
 	const index = updated.findIndex((entry) => (typeof entry === "string" ? entry : entry.source) === source);
@@ -49,8 +51,9 @@ export function nextGlobalPackages(
 		pkg = { source: pkg };
 		updated[index] = pkg;
 	}
-	pkg.extensions = nextTopLevelList(pkg.extensions ?? [], pattern, enabled);
-	updated[index] = pkg.extensions.length > 0 ? pkg : pkg.source;
+	const filters = nextTopLevelList(pkg[kind] ?? [], pattern, enabled);
+	pkg[kind] = filters;
+	updated[index] = filters.length > 0 ? pkg : pkg.source;
 	return updated;
 }
 
@@ -107,7 +110,7 @@ export function nextProjectTopLevelList(
 }
 
 /**
- * Toggle one extension inside a package in project settings. A missing project
+ * Toggle one resource inside a package in project settings. A missing project
  * entry is created with `autoload: false` so it filters the personal entry
  * rather than replacing it; an entry left with no filters is removed.
  */
@@ -117,6 +120,7 @@ export function nextProjectPackages(
 	enabled: boolean,
 	cwd: string,
 	agentDir: string,
+	kind: ResourceKind,
 ): PackageSource[] {
 	const updated = [...packages];
 	let index = updated.findIndex((entry) =>
@@ -133,8 +137,9 @@ export function nextProjectPackages(
 		updated[index] = pkg;
 	}
 	const pattern = getPackageResourcePattern(item);
-	pkg.extensions = nextTopLevelList(pkg.extensions ?? [], pattern, enabled);
-	if (pkg.extensions.length > 0) {
+	const filters = nextTopLevelList(pkg[kind] ?? [], pattern, enabled);
+	pkg[kind] = filters;
+	if (filters.length > 0) {
 		updated[index] = pkg;
 	} else if (pkg.autoload === false) {
 		updated.splice(index, 1);
@@ -181,6 +186,7 @@ export function clearProjectPackages(
 	item: ResourceItem,
 	cwd: string,
 	agentDir: string,
+	kind: ResourceKind,
 ): PackageSource[] {
 	const index = packages.findIndex((entry) =>
 		packageSourceMatches(item, typeof entry === "string" ? entry : entry.source, "project", cwd, agentDir),
@@ -189,12 +195,12 @@ export function clearProjectPackages(
 	if (entry === undefined || typeof entry === "string") return packages;
 
 	const pattern = getPackageResourcePattern(item);
-	const filters = entry.extensions ?? [];
+	const filters = entry[kind] ?? [];
 	if (!filters.some((filter) => getPatternEntryTarget(filter) === pattern)) return packages;
 
 	const updated = [...packages];
 	const remaining = filters.filter((filter) => getPatternEntryTarget(filter) !== pattern);
-	if (remaining.length > 0) updated[index] = { ...entry, extensions: remaining };
+	if (remaining.length > 0) updated[index] = { ...entry, [kind]: remaining };
 	else if (entry.autoload === false) updated.splice(index, 1);
 	else updated[index] = entry.source;
 	return updated;

package/extensions/bytefly/picker/types.ts

@@ -1,11 +1,12 @@
 /**
- * Shared types and host seams for the extensions picker.
+ * Shared types and host seams for the resource picker.
  *
- * The manager only lists and toggles the `extensions` resource type. Every
- * host capability it needs is behind a small interface here so the pure logic
- * can be tested without a Pi runtime: `SettingsStore` wraps the settings file,
- * `ExtensionResolver` wraps package resolution, and `Discovery` is the pair of
- * views (global and effective) the screen shows.
+ * The manager lists and toggles the two resource types the screen offers:
+ * extensions and skills. Every host capability it needs is behind a small
+ * interface here so the pure logic can be tested without a Pi runtime:
+ * `SettingsStore` wraps the settings file, `ResourceResolver` wraps package
+ * resolution, and `Discovery` is the pair of views (global and effective) each
+ * kind is shown from.
  */
 
 import type { PackageSource, QuietStartup, ResolvedResource, SettingsManager } from "@earendil-works/pi-coding-agent";
@@ -16,10 +17,19 @@ export type Settings = ReturnType<SettingsManager["getSettings"]>;
 /** Which settings file a toggle is written to. */
 export type WriteScope = "global" | "project";
 
-/** One resolved extension and where it came from. */
+/** One resolved resource and where it came from. */
 export type ResourceItem = ResolvedResource;
 
-/** A flattened list row: a source-group header or an extension item. */
+/** The resource types the picker can list and toggle. */
+export type ResourceKind = "extensions" | "skills";
+
+/** Both resource arrays Pi resolves in one pass. */
+export interface ResolvedResources {
+	extensions: ResourceItem[];
+	skills: ResourceItem[];
+}
+
+/** A flattened list row: a source-group header or a resource item. */
 export type Entry =
 	| { kind: "group"; key: string; label: string; count: number }
 	| { kind: "item"; key: string; item: ResourceItem; label: string };
@@ -30,8 +40,10 @@ export interface SettingsStore {
 	projectSettings(): Settings;
 	packages(): PackageSource[];
 	setExtensionPaths(paths: string[]): void;
+	setSkillPaths(paths: string[]): void;
 	setPackages(packages: PackageSource[]): void;
 	setProjectExtensionPaths(paths: string[]): void;
+	setProjectSkillPaths(paths: string[]): void;
 	setProjectPackages(packages: PackageSource[]): void;
 	/** App preferences are written to the personal settings file. */
 	setQuietStartup(quiet: QuietStartup): void;
@@ -44,17 +56,23 @@ export interface SettingsStore {
 	drainErrors(): Array<{ error: Error }>;
 }
 
-/** Resolves every configured package into its extension resources. */
-export interface ExtensionResolver {
-	resolve(): Promise<ResolvedResource[]>;
+/** Resolves every configured package into its resource lists. */
+export interface ResourceResolver {
+	resolve(): Promise<ResolvedResources>;
 }
 
-/** Both settings views plus the stores a toggle writes through. */
-export interface Discovery {
+/** One resource kind's two views: personal settings, and what the session sees. */
+export interface ResourceViews {
 	/** Resources as configured by personal settings only. */
 	global: ResourceItem[];
 	/** Resources as the session actually sees them (project applied when trusted). */
 	effective: ResourceItem[];
+}
+
+/** Both settings views plus the stores a toggle writes through. */
+export interface Discovery {
+	extensions: ResourceViews;
+	skills: ResourceViews;
 	stores: { global: SettingsStore; project: SettingsStore };
 	/** Whether the project settings file may be read and written. */
 	trusted: boolean;