@mrclrchtr/supi-skills 7.2.1 → 7.3.1

package/README.md

@@ -56,6 +56,12 @@ Use `enabled` or `disabled` as the stored value. An absent record or field inher
 
 Older versions stored boolean values in `skills.modelInvocation`. SuPi reads that format and migrates valid entries on the next settings write. Invalid values remain preserved, marked as invalid, and produce a warning until they are repaired. A conflicting legacy fallback is kept under `$legacyModelInvocation` until the invalid record is repaired.
 
+## Session visibility
+
+Install `@mrclrchtr/supi-extras` to use `/supi-capabilities`. Its Skills tab lists skills that PI has loaded and that persistent settings allow in the model catalog. It does not list unloaded skills or skills that persistent settings block.
+
+A session visibility override hides a skill from the model prompt for the current session. It does not change PI settings or SuPi skill settings. The user can still run `/skill:name` or use `$name`. Resume restores the override. A fork copies it. Use **Reset Skills** to show all eligible skills again.
+
 ## Input shortcut
 
 `$skill-name` expands to `/skill:skill-name`. Skill-only autocomplete is active while the cursor is in a `$...` token.

package/node_modules/@mrclrchtr/supi-core/README.md

@@ -23,6 +23,7 @@ pnpm add @mrclrchtr/supi-core
 - `@mrclrchtr/supi-core/api` — reusable helpers for other packages and extensions
 - `@mrclrchtr/supi-core/llm` — PI-owned direct model requests and JSON helpers
 - `@mrclrchtr/supi-core/report` — shared text/report rendering helpers for TUI and plain-text summaries
+- `@mrclrchtr/supi-core/tui` — shared terminal UI helpers for list titles, rows, menus, and descriptions
 
 ## What you get from the API
 
@@ -70,6 +71,14 @@ Both completion helpers require a stable `affinityScope`. PI owns auth and endpo
 - active-branch session helper: `getActiveBranchEntries()`
 - terminal helpers such as `formatTitle()`, `signalWaiting()`, and `signalDone()`
 
+### TUI helpers
+
+- `formatTuiTitleLine()` — use the shared title style in terminal lists
+- `renderSelectableRow()` — render a selected row with an aligned value
+- `renderDescriptionViewport()` — show a fixed-height description preview
+- `renderTuiHintLine()` — render short key hints in one line
+- `createSelectListMenu()` — build an action menu with shared key hints
+
 ### Report helpers
 
 - `clampReportWidth()` — enforce a minimum readable report width
@@ -125,3 +134,4 @@ export default function myExtension(pi: ExtensionAPI) {
 - `src/debug-timing.ts` — monotonic total and phase timers for Debug Event Producers
 - `src/settings/` — settings registry, schema, scope resolution, and persistence
 - `src/report.ts` — shared text/report rendering helpers
+- `src/tui.ts` — shared terminal UI list and action-menu helpers

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "7.2.1",
+  "version": "7.3.1",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {
@@ -67,6 +67,7 @@
     "./settings": "./src/settings.ts",
     "./spinner-frames": "./src/spinner-frames.ts",
     "./status-spinner": "./src/status-spinner.ts",
-    "./terminal": "./src/terminal.ts"
+    "./terminal": "./src/terminal.ts",
+    "./tui": "./src/tui.ts"
   }
 }

package/node_modules/@mrclrchtr/supi-core/src/api.ts

@@ -38,3 +38,5 @@ export * from "./spinner-frames.ts";
 export * from "./status-spinner.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./terminal.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./tui.ts";

package/node_modules/@mrclrchtr/supi-core/src/index.ts

@@ -34,3 +34,5 @@ export * from "./settings.ts";
 export * from "./status-spinner.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./terminal.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./tui.ts";

package/node_modules/@mrclrchtr/supi-core/src/session-capabilities.ts

@@ -0,0 +1,188 @@
+/** Session-only tool and skill visibility state. */
+export interface SessionCapabilityState {
+  version: 1;
+  eligibleToolNames: string[];
+  initiallyInactiveToolNames: string[];
+  toolDenylist: string[];
+  /** Tools that the user explicitly enabled for this session. */
+  toolEnabledNames?: string[];
+  hiddenSkillNames: string[];
+}
+
+/** A model-visible skill that a provider can offer to the selector. */
+export interface SessionCapabilitySkill {
+  name: string;
+  description: string;
+}
+
+/** Skill inventory provider registered by the skills extension. */
+export interface SessionCapabilitySkillProvider<TContext = unknown> {
+  listEligibleSkills(
+    context: TContext,
+  ): Promise<SessionCapabilitySkill[]> | SessionCapabilitySkill[];
+}
+
+/** Custom session-entry type used for hidden capability snapshots. */
+export const SESSION_CAPABILITIES_ENTRY = "supi-capabilities";
+
+const REGISTRY_PREFIX = "@mrclrchtr/supi-core/session-capabilities/";
+const STATE_KEY = Symbol.for(`${REGISTRY_PREFIX}state`);
+const PROVIDER_KEY = Symbol.for(`${REGISTRY_PREFIX}skill-providers`);
+const FORK_KEY = Symbol.for(`${REGISTRY_PREFIX}pending-forks`);
+
+type GlobalRegistry = typeof globalThis & Record<symbol, unknown>;
+
+type SkillProviderMap = Map<string, SessionCapabilitySkillProvider<unknown>>;
+type ForkStateMap = Map<string, SessionCapabilityState>;
+
+function getStateMap(): Map<string, SessionCapabilityState> {
+  const target = globalThis as GlobalRegistry;
+  let map = target[STATE_KEY] as Map<string, SessionCapabilityState> | undefined;
+  if (!map) {
+    map = new Map();
+    target[STATE_KEY] = map;
+  }
+  return map;
+}
+
+function getProviderMap(): SkillProviderMap {
+  const target = globalThis as GlobalRegistry;
+  let map = target[PROVIDER_KEY] as SkillProviderMap | undefined;
+  if (!map) {
+    map = new Map();
+    target[PROVIDER_KEY] = map;
+  }
+  return map;
+}
+
+function getForkMap(): ForkStateMap {
+  const target = globalThis as GlobalRegistry;
+  let map = target[FORK_KEY] as ForkStateMap | undefined;
+  if (!map) {
+    map = new Map();
+    target[FORK_KEY] = map;
+  }
+  return map;
+}
+
+function stringList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return Array.from(new Set(value.filter((item): item is string => typeof item === "string")));
+}
+
+/** Create an empty state snapshot. */
+export function createEmptySessionCapabilityState(): SessionCapabilityState {
+  return {
+    version: 1,
+    eligibleToolNames: [],
+    initiallyInactiveToolNames: [],
+    toolDenylist: [],
+    toolEnabledNames: [],
+    hiddenSkillNames: [],
+  };
+}
+
+/** Validate and copy one stored snapshot. */
+export function decodeSessionCapabilities(value: unknown): SessionCapabilityState | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const record = value as Record<string, unknown>;
+  if (record.version !== 1) return undefined;
+
+  const initiallyInactiveToolNames = stringList(record.initiallyInactiveToolNames);
+  const initiallyInactive = new Set(initiallyInactiveToolNames);
+  const eligibleToolNames = stringList(record.eligibleToolNames).filter(
+    (name) => !initiallyInactive.has(name),
+  );
+  const eligible = new Set(eligibleToolNames);
+  const toolDenylist = stringList(record.toolDenylist).filter((name) => eligible.has(name));
+  const denied = new Set(toolDenylist);
+
+  return {
+    version: 1,
+    eligibleToolNames,
+    initiallyInactiveToolNames,
+    toolDenylist,
+    toolEnabledNames: stringList(record.toolEnabledNames).filter(
+      (name) => eligible.has(name) && !denied.has(name),
+    ),
+    hiddenSkillNames: stringList(record.hiddenSkillNames),
+  };
+}
+
+/** Return a safe copy of the latest valid snapshot in all session entries. */
+export function findSessionCapabilities(
+  entries: readonly unknown[],
+): SessionCapabilityState | undefined {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (typeof entry !== "object" || entry === null) continue;
+    const record = entry as Record<string, unknown>;
+    if (record.type !== "custom" || record.customType !== SESSION_CAPABILITIES_ENTRY) continue;
+    const state = decodeSessionCapabilities(record.data);
+    if (state) return state;
+  }
+  return undefined;
+}
+
+/** Shared session state. Session IDs keep sessions in the same cwd separate. */
+export const sessionCapabilityState = {
+  get(sessionId: string): SessionCapabilityState | undefined {
+    const state = getStateMap().get(sessionId);
+    return state ? decodeSessionCapabilities(state) : undefined;
+  },
+  set(sessionId: string, state: SessionCapabilityState): void {
+    const decoded = decodeSessionCapabilities(state);
+    if (decoded) getStateMap().set(sessionId, decoded);
+  },
+  clear(sessionId: string): void {
+    getStateMap().delete(sessionId);
+  },
+};
+
+/** Register the current session's skill inventory provider. */
+export function registerSessionCapabilitySkillProvider<TContext>(
+  sessionId: string,
+  provider: SessionCapabilitySkillProvider<TContext>,
+): () => void {
+  const providers = getProviderMap();
+  providers.set(sessionId, provider as SessionCapabilitySkillProvider<unknown>);
+  return () => {
+    if (providers.get(sessionId) === provider) providers.delete(sessionId);
+  };
+}
+
+/** Get the current session's skill inventory provider, if one is loaded. */
+export function getSessionCapabilitySkillProvider<TContext = unknown>(
+  sessionId: string,
+): SessionCapabilitySkillProvider<TContext> | undefined {
+  return getProviderMap().get(sessionId) as SessionCapabilitySkillProvider<TContext> | undefined;
+}
+
+function forkKey(sourceSessionFile: string | undefined): string {
+  return sourceSessionFile ?? "<memory-session>";
+}
+
+/** Hold a state copy until PI starts the forked session. */
+export function setPendingSessionCapabilityFork(
+  sourceSessionFile: string | undefined,
+  state: SessionCapabilityState,
+): void {
+  const decoded = decodeSessionCapabilities(state);
+  if (decoded) getForkMap().set(forkKey(sourceSessionFile), decoded);
+}
+
+/** Take the state copy for one fork. The copy is used once. */
+export function readPendingSessionCapabilityFork(
+  sourceSessionFile: string | undefined,
+): SessionCapabilityState | undefined {
+  const forks = getForkMap();
+  const key = forkKey(sourceSessionFile);
+  const state = forks.get(key);
+  forks.delete(key);
+  return state ? decodeSessionCapabilities(state) : undefined;
+}
+
+/** Clear pending fork copies after a cancelled or unrelated transition. */
+export function clearPendingSessionCapabilityForks(): void {
+  getForkMap().clear();
+}

package/node_modules/@mrclrchtr/supi-core/src/session.ts

@@ -1,6 +1,23 @@
 // supi-core session domain — session utilities and registries.
 
 export { createRegistry, createSessionStateRegistry } from "./registry-utils.ts";
+export type {
+  SessionCapabilitySkill,
+  SessionCapabilitySkillProvider,
+  SessionCapabilityState,
+} from "./session-capabilities.ts";
+export {
+  clearPendingSessionCapabilityForks,
+  createEmptySessionCapabilityState,
+  decodeSessionCapabilities,
+  findSessionCapabilities,
+  getSessionCapabilitySkillProvider,
+  readPendingSessionCapabilityFork,
+  registerSessionCapabilitySkillProvider,
+  SESSION_CAPABILITIES_ENTRY,
+  sessionCapabilityState,
+  setPendingSessionCapabilityFork,
+} from "./session-capabilities.ts";
 export type { SessionNameTrackerHost } from "./session-utils.ts";
 export {
   createSessionNameTracker,

package/node_modules/@mrclrchtr/supi-core/src/tui.ts

@@ -0,0 +1,141 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  type SelectItem,
+  SelectList,
+  type TuiMouseEvent,
+  type TuiMouseEventResult,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+/** The theme methods used by the shared TUI list renderers. */
+export type TuiTheme = Pick<Theme, "fg" | "bold">;
+
+/** Settings for one selectable row in a themed list. */
+export interface SelectableRowOptions {
+  /** The row label. */
+  label: string;
+  /** The value shown beside the label. */
+  value: string;
+  /** The row indent in terminal columns. */
+  indent: number;
+  /** The largest indent used by the list. */
+  maxIndent: number;
+  /** The label column width. */
+  maxLabelWidth: number;
+  /** The row width in terminal columns. */
+  width: number;
+  /** True when this row is selected. */
+  selected: boolean;
+  /** Theme used for row colors. */
+  theme: TuiTheme;
+}
+
+/** Settings for a shared action menu. */
+export interface SelectListMenuOptions {
+  /** The title shown above the choices. */
+  title: string;
+  /** The choices shown in the menu. */
+  items: SelectItem[];
+  /** Theme used for menu colors. */
+  theme: TuiTheme;
+  /** Called when the user selects a choice. */
+  onSelect: (item: SelectItem) => void;
+  /** Called when the user closes the menu without a choice. */
+  onCancel: () => void;
+}
+
+/** Component methods for a shared action menu. */
+export interface SelectListMenuComponent {
+  render(width: number): string[];
+  invalidate(): void;
+  handleInput(data: string): void;
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+}
+
+/** Build a title line with optional right-side tabs in the shared TUI style. */
+export function formatTuiTitleLine(title: string, theme: TuiTheme, trailing = ""): string {
+  const titleText = theme.fg("accent", theme.bold(title));
+  return ` ${titleText}${trailing ? `  ${trailing}` : ""}`;
+}
+
+/** Render one row with a selected marker and an aligned value column. */
+export function renderSelectableRow(options: SelectableRowOptions): string {
+  const indent = Math.max(0, options.indent);
+  const maxIndent = Math.max(indent, options.maxIndent);
+  const maxLabelWidth = Math.max(0, options.maxLabelWidth);
+  const width = Math.max(0, options.width);
+  const label = truncateToWidth(options.label, maxLabelWidth, "");
+  const labelWidth = visibleWidth(label);
+  const prefix = options.selected
+    ? `${" ".repeat(Math.max(0, indent - 2))}${options.theme.fg("accent", "→ ")}`
+    : " ".repeat(indent);
+  const labelPadding = " ".repeat(maxIndent - indent + maxLabelWidth - labelWidth);
+  const valueWidth = Math.max(0, width - maxIndent - maxLabelWidth - 4);
+  const value = truncateToWidth(options.value, valueWidth, "");
+  const labelText = options.theme.fg(options.selected ? "accent" : "text", label + labelPadding);
+  const valueText = options.theme.fg(options.selected ? "accent" : "muted", value);
+
+  return truncateToWidth(`${prefix}${labelText}  ${valueText}`, width);
+}
+
+/** Render a fixed-height, four-line description preview for a selected row. */
+export function renderDescriptionViewport(
+  description: string | undefined,
+  width: number,
+): string[] {
+  const height = 4;
+  const indent = "  ";
+  const contentWidth = Math.max(1, width - 4);
+  const wrapped = description ? wrapTextWithAnsi(description, contentWidth) : [];
+  const visible = wrapped.slice(0, height);
+
+  if (wrapped.length > height) {
+    const lastIndex = height - 1;
+    visible[lastIndex] = truncateToWidth(`${visible[lastIndex] ?? ""}…`, contentWidth, "…");
+  }
+
+  while (visible.length < height) visible.push("");
+  return visible.map((line) => (line ? `${indent}${line}` : ""));
+}
+
+/** Render a dimmed hint line with the shared separator and truncation rules. */
+export function renderTuiHintLine(hints: string[], theme: TuiTheme, width: number): string {
+  return truncateToWidth(theme.fg("dim", hints.join(" · ")), width);
+}
+
+/** Build the shared title, choices, and key hints for an action menu. */
+export function createSelectListMenu(options: SelectListMenuOptions): SelectListMenuComponent {
+  const { items, onSelect, onCancel, theme, title } = options;
+  const selectList = new SelectList(items, Math.min(items.length + 2, 15), {
+    selectedPrefix: (text) => theme.fg("accent", text),
+    selectedText: (text) => theme.fg("accent", text),
+    description: (text) => theme.fg("muted", text),
+    scrollInfo: (text) => theme.fg("dim", text),
+    noMatch: (text) => theme.fg("warning", text),
+  });
+  selectList.onSelect = onSelect;
+  selectList.onCancel = onCancel;
+
+  return {
+    render(width) {
+      return [
+        truncateToWidth(theme.fg("accent", `  ${title}`), width),
+        ...selectList.render(width),
+        "",
+        renderTuiHintLine(["  ↑↓ navigate", "Enter select", "Esc cancel"], theme, width),
+      ];
+    },
+    invalidate() {
+      selectList.invalidate();
+    },
+    handleInput(data) {
+      selectList.handleInput(data);
+    },
+    handleMouse(event) {
+      if (event.y < 1) return undefined;
+      return selectList.handleMouse({ ...event, y: event.y - 1 });
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-skills",
-  "version": "7.2.1",
+  "version": "7.3.1",
   "description": "Scoped skill controls and skill input shortcuts for PI",
   "license": "MIT",
   "repository": {
@@ -30,7 +30,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@mrclrchtr/supi-core": "7.2.1"
+    "@mrclrchtr/supi-core": "7.3.1"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core"

package/src/skill-model-invocation.ts

@@ -38,12 +38,14 @@ export function applyPromptOverrides({
   cwd,
   projectTrusted,
   homeDir,
+  hiddenSkillNames = new Set(),
 }: {
   options: BuildSystemPromptOptions;
   systemPrompt: string;
   cwd: string;
   projectTrusted: boolean;
   homeDir?: string;
+  hiddenSkillNames?: ReadonlySet<string>;
 }): string | undefined {
   const selectedTools = options.selectedTools;
   const skillFileReadTool =
@@ -52,17 +54,20 @@ export function applyPromptOverrides({
       : (["read", "bash"] as const).find((tool) => selectedTools.includes(tool));
   if (!skillFileReadTool) return undefined;
   const skills = options.skills ?? [];
-  const effective = skills.map((skill) => ({
-    ...skill,
-    disableModelInvocation: resolveInvocation({
-      name: skill.name,
-      sourceDefault: skill.disableModelInvocation,
-      scope: "project",
-      cwd,
-      projectTrusted,
-      homeDir,
-    }).disabled,
-  }));
+  const effective = skills
+    .filter((skill) => !hiddenSkillNames.has(skill.name))
+    .map((skill) => ({
+      ...skill,
+      disableModelInvocation: resolveInvocation({
+        name: skill.name,
+        sourceDefault: skill.disableModelInvocation,
+        scope: "project",
+        cwd,
+        projectTrusted,
+        homeDir,
+      }).disabled,
+    }));
+  const effectiveByName = new Map(effective.map((skill) => [skill.name, skill]));
   const original = formatSkillsForPrompt(skills, skillFileReadTool);
   const replacement = formatSkillsForPrompt(effective, skillFileReadTool);
   if (original === replacement) return undefined;
@@ -97,10 +102,12 @@ export function applyPromptOverrides({
     data: {
       skillCount: skills.length,
       changedSkills: skills
-        .filter(
-          (skill, index) =>
-            skill.disableModelInvocation !== effective[index]?.disableModelInvocation,
-        )
+        .filter((skill) => {
+          const activeSkill = effectiveByName.get(skill.name);
+          return (
+            !activeSkill || skill.disableModelInvocation !== activeSkill.disableModelInvocation
+          );
+        })
         .map((skill) => skill.name),
       forceSystemPrompt: true,
       hasSkillsSection: systemPrompt.includes("<skills>"),

package/src/skill-settings-controller.ts

@@ -0,0 +1,365 @@
+import {
+  DefaultPackageManager,
+  type ExtensionCommandContext,
+  type ExtensionContext,
+  getAgentDir,
+  type ResolvedResource,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import type { SessionCapabilitySkill } from "@mrclrchtr/supi-core/session";
+import type {
+  ScopedFieldValue,
+  SettingsAction,
+  SettingsApplyResult,
+  SettingsScope,
+  ValueSource,
+} from "@mrclrchtr/supi-core/settings";
+import {
+  buildSkillCatalog,
+  mergeRuntimeSkills,
+  type SkillCatalog,
+  type SkillRecord,
+  skillSourceIdentity,
+} from "./skill-catalog.ts";
+import {
+  hasExactSkillLoadOverride,
+  type SkillLoadOverride,
+  updateSkillLoadOverrides,
+} from "./skill-load-settings.ts";
+import {
+  DISABLED,
+  ENABLED,
+  MODEL_DISABLED,
+  persistInvocation,
+  resolveInvocation,
+} from "./skill-model-invocation.ts";
+
+export interface SkillSettingsOptions {
+  agentDir?: string;
+  homeDir?: string;
+}
+interface SkillSettingsControllerOptions {
+  cwd: string;
+  agentDir: string;
+  homeDir?: string;
+  projectTrusted: boolean;
+  settingsManager: SettingsManager;
+  globalSettingsManager: SettingsManager;
+}
+
+function recordResources(record: SkillRecord): ResolvedResource[] {
+  return record.sources.flatMap((source) => (source.resource ? [source.resource] : []));
+}
+function isLoaded(record: SkillRecord): boolean {
+  return (
+    record.activeSkill !== undefined ||
+    record.sources.some((source) => source.runtime || source.resource?.enabled)
+  );
+}
+function canDisable(record: SkillRecord): boolean {
+  return record.sources.length > 0 && record.sources.every((source) => !source.runtime);
+}
+
+function sourceDefault(record: SkillRecord): boolean {
+  const winner =
+    record.activeSkill ??
+    record.sources.find((source) => source.runtime || source.resource?.enabled)?.skill ??
+    record.sources[0]?.skill;
+  return winner?.disableModelInvocation ?? false;
+}
+
+function moreSpecificSource(left: ValueSource, right: ValueSource): ValueSource {
+  const rank: Record<ValueSource, number> = { default: 0, global: 1, project: 2 };
+  return rank[left] >= rank[right] ? left : right;
+}
+
+function displayValue(value: string, source: ValueSource): string {
+  return `${value} (${source})`;
+}
+
+function validateAction(record: SkillRecord, action: SettingsAction): void {
+  if (action.kind !== "set") return;
+  if (![ENABLED, MODEL_DISABLED, DISABLED].includes(action.value)) {
+    throw new Error(`Invalid skill state: "${action.value}"`);
+  }
+  if (action.value === DISABLED && !canDisable(record)) {
+    throw new Error(`Full disable is unavailable for skill "${record.name}"`);
+  }
+}
+
+function loadOverride(
+  record: SkillRecord,
+  action: SettingsAction,
+  hasExactOverride: boolean,
+): SkillLoadOverride | undefined {
+  if (action.kind === "unset") return hasExactOverride ? "inherit" : undefined;
+  if (action.value === DISABLED) return "unload";
+  return isLoaded(record) ? undefined : "load";
+}
+
+export class SkillSettingsController {
+  private readonly cwd: string;
+  private readonly agentDir: string;
+  private readonly homeDir: string | undefined;
+  private readonly projectTrusted: boolean;
+  private readonly settingsManager: SettingsManager;
+  private readonly globalSettingsManager: SettingsManager;
+  private readonly pendingDisabled = new Map<string, Set<string>>();
+  private globalCatalog: SkillCatalog = new Map();
+  private projectCatalog: SkillCatalog = new Map();
+
+  private constructor(options: SkillSettingsControllerOptions) {
+    this.cwd = options.cwd;
+    this.agentDir = options.agentDir;
+    this.homeDir = options.homeDir;
+    this.projectTrusted = options.projectTrusted;
+    this.settingsManager = options.settingsManager;
+    this.globalSettingsManager = options.globalSettingsManager;
+  }
+
+  static async create(
+    cwd: string,
+    projectTrusted: boolean,
+    options: SkillSettingsOptions,
+  ): Promise<SkillSettingsController> {
+    const agentDir = options.agentDir ?? getAgentDir();
+    const controller = new SkillSettingsController({
+      cwd,
+      agentDir,
+      homeDir: options.homeDir,
+      projectTrusted,
+      settingsManager: SettingsManager.create(cwd, agentDir, { projectTrusted }),
+      globalSettingsManager: SettingsManager.create(cwd, agentDir, { projectTrusted: false }),
+    });
+    await controller.refreshCatalogs();
+    return controller;
+  }
+
+  private async refreshCatalogs(): Promise<void> {
+    await Promise.all([this.settingsManager.reload(), this.globalSettingsManager.reload()]);
+    const [globalPaths, projectPaths] = await Promise.all([
+      new DefaultPackageManager({
+        cwd: this.cwd,
+        agentDir: this.agentDir,
+        settingsManager: this.globalSettingsManager,
+      }).resolve(async () => "skip"),
+      new DefaultPackageManager({
+        cwd: this.cwd,
+        agentDir: this.agentDir,
+        settingsManager: this.settingsManager,
+      }).resolve(async () => "skip"),
+    ]);
+    this.globalCatalog = buildSkillCatalog(globalPaths.skills, this.cwd, this.agentDir);
+    this.projectCatalog = buildSkillCatalog(projectPaths.skills, this.cwd, this.agentDir);
+  }
+
+  private records(scope: SettingsScope, ctx?: ExtensionContext): SkillCatalog {
+    return mergeRuntimeSkills(
+      scope === "project" ? this.projectCatalog : this.globalCatalog,
+      ctx,
+      scope,
+      this.pendingDisabled,
+    );
+  }
+
+  /**
+   * Prefer original global provenance when a project support path resolves the
+   * same file as a project resource. This lets Unset remove both the exact
+   * override and the generated support path after a catalog refresh.
+   */
+  private actionResources(record: SkillRecord, scope: SettingsScope): ResolvedResource[] {
+    const globalResources =
+      scope === "project" ? recordResources(this.globalCatalog.get(record.name) ?? record) : [];
+    const unique = new Map<string, ResolvedResource>();
+    for (const resource of [...globalResources, ...recordResources(record)]) {
+      const key = `${resource.path}\0${resource.metadata.origin}\0${resource.metadata.source}`;
+      if (!unique.has(key)) unique.set(key, resource);
+    }
+    return Array.from(unique.values());
+  }
+
+  /**
+   * Attribute the effective load value to the narrowest scoped override.
+   * Project resources can be support-path surrogates, so attribution compares
+   * their effective load state with the original global catalog.
+   */
+  private loadSource(record: SkillRecord, scope: SettingsScope): ValueSource {
+    const resources = recordResources(record);
+    const exact = hasExactSkillLoadOverride({
+      settingsManager: this.settingsManager,
+      resources,
+      scope,
+      cwd: this.cwd,
+      agentDir: this.agentDir,
+    });
+    if (exact) return scope;
+    if (scope === "global") {
+      return resources.some((resource) => !resource.enabled) ? "global" : "default";
+    }
+    if (resources.some((resource) => resource.metadata.scope === "project" && !resource.enabled)) {
+      return "project";
+    }
+    const globalRecord = this.globalCatalog.get(record.name);
+    if (!globalRecord) return "default";
+    const globalResources = recordResources(globalRecord);
+    const projectLoaded = resources.some((resource) => resource.enabled);
+    const globalLoaded = globalResources.some((resource) => resource.enabled);
+    if (projectLoaded !== globalLoaded) return "project";
+    return this.loadSource(globalRecord, "global");
+  }
+
+  private rowSource(
+    record: SkillRecord,
+    scope: SettingsScope,
+    invocationSource: ValueSource,
+  ): ValueSource {
+    return moreSpecificSource(this.loadSource(record, scope), invocationSource);
+  }
+
+  private row(record: SkillRecord, scope: SettingsScope): ScopedFieldValue {
+    const invocation = resolveInvocation({
+      name: record.name,
+      sourceDefault: sourceDefault(record),
+      scope,
+      cwd: this.cwd,
+      projectTrusted: this.projectTrusted,
+      homeDir: this.homeDir,
+    });
+    const value = !isLoaded(record) ? DISABLED : invocation.disabled ? MODEL_DISABLED : ENABLED;
+    const source = this.rowSource(record, scope, invocation.source);
+    const values = canDisable(record)
+      ? [ENABLED, MODEL_DISABLED, DISABLED]
+      : [ENABLED, MODEL_DISABLED];
+    const sourceCount = record.sources.length;
+    const limitation = canDisable(record)
+      ? ""
+      : " Full disable is unavailable because PI does not expose a load setting for one or more sources.";
+    return {
+      field: {
+        kind: "enum",
+        key: record.name,
+        label: record.name,
+        values,
+        description: `${record.description}${sourceCount > 1 ? ` ${sourceCount} sources.` : ""}${limitation}`,
+      },
+      displayValue: displayValue(value, source),
+      editValue: value,
+      source,
+      ...(scope === "project" && source === "project"
+        ? {
+            inheritanceSource:
+              this.globalRowSource(record.name) === "global" ? "global" : "default",
+          }
+        : {}),
+    };
+  }
+
+  private globalRowSource(name: string): ValueSource {
+    const record = this.globalCatalog.get(name);
+    if (!record) return "default";
+    const invocation = resolveInvocation({
+      name,
+      sourceDefault: sourceDefault(record),
+      scope: "global",
+      cwd: this.cwd,
+      projectTrusted: false,
+      homeDir: this.homeDir,
+    });
+    return this.rowSource(record, "global", invocation.source);
+  }
+
+  read(scope: SettingsScope, ctx?: ExtensionContext): ScopedFieldValue[] {
+    return Array.from(this.records(scope, ctx).values())
+      .sort((left, right) => left.name.localeCompare(right.name))
+      .map((record) => this.row(record, scope));
+  }
+
+  /** Return PI's loaded skill winners that persistent settings allow in the prompt. */
+  eligibleModelSkills(ctx: ExtensionCommandContext): SessionCapabilitySkill[] {
+    const records = this.records("project", ctx);
+    return (ctx.getSystemPromptOptions().skills ?? [])
+      .filter((skill) => {
+        const record = records.get(skill.name);
+        return !resolveInvocation({
+          name: skill.name,
+          sourceDefault: record ? sourceDefault(record) : (skill.disableModelInvocation ?? false),
+          scope: "project",
+          cwd: this.cwd,
+          projectTrusted: this.projectTrusted,
+          homeDir: this.homeDir,
+        }).disabled;
+      })
+      .map((skill) => ({ name: skill.name, description: skill.description }))
+      .sort((left, right) => left.name.localeCompare(right.name));
+  }
+
+  private updatePendingDisabled(
+    fieldKey: string,
+    nextLoadOverride: SkillLoadOverride,
+    activeSkillIdentity: string | undefined,
+  ): void {
+    if (nextLoadOverride !== "unload") {
+      this.pendingDisabled.delete(fieldKey);
+      return;
+    }
+    if (activeSkillIdentity) {
+      this.pendingDisabled.set(fieldKey, new Set([activeSkillIdentity]));
+    }
+  }
+
+  async apply(
+    scope: SettingsScope,
+    fieldKey: string,
+    action: SettingsAction,
+    ctx?: ExtensionContext,
+  ): Promise<SettingsApplyResult> {
+    if (scope === "project" && !this.projectTrusted) {
+      throw new Error("Project is not trusted; refusing to write project skill settings");
+    }
+    const record = this.records(scope, ctx).get(fieldKey);
+    if (!record) return {};
+    validateAction(record, action);
+    const activeSkillIdentity = record.activeSkill
+      ? skillSourceIdentity(record.activeSkill)
+      : undefined;
+
+    if (action.kind !== "set" || action.value !== DISABLED) {
+      persistInvocation({
+        name: fieldKey,
+        disabled: action.kind === "set" ? action.value === MODEL_DISABLED : undefined,
+        scope,
+        cwd: this.cwd,
+        homeDir: this.homeDir,
+      });
+    }
+
+    const resources = this.actionResources(record, scope);
+    const hasLoadOverride = hasExactSkillLoadOverride({
+      settingsManager: this.settingsManager,
+      resources,
+      scope,
+      cwd: this.cwd,
+      agentDir: this.agentDir,
+    });
+    const nextLoadOverride = loadOverride(record, action, hasLoadOverride);
+    if (nextLoadOverride && resources.length > 0) {
+      updateSkillLoadOverrides({
+        settingsManager: this.settingsManager,
+        resources,
+        scope,
+        state: nextLoadOverride,
+        cwd: this.cwd,
+        agentDir: this.agentDir,
+      });
+      await this.settingsManager.flush();
+      const error = this.settingsManager.drainErrors()[0];
+      await this.refreshCatalogs();
+      if (error) throw error.error;
+      this.updatePendingDisabled(fieldKey, nextLoadOverride, activeSkillIdentity);
+      return {
+        notice: { message: "Reload required for skill load changes", level: "info" },
+      };
+    }
+    return {};
+  }
+}

package/src/skill-settings.ts

@@ -1,398 +1,91 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import {
-  DefaultPackageManager,
-  type ExtensionAPI,
-  type ExtensionContext,
-  getAgentDir,
-  type ResolvedResource,
-  SettingsManager,
-} from "@earendil-works/pi-coding-agent";
-import {
-  registerSettings,
-  type ScopedFieldValue,
-  type SettingsAction,
-  type SettingsApplyResult,
-  type SettingsContext,
-  type SettingsModule,
-  type SettingsScope,
-  type ValueSource,
-} from "@mrclrchtr/supi-core/settings";
-import {
-  buildSkillCatalog,
-  mergeRuntimeSkills,
-  type SkillCatalog,
-  type SkillRecord,
-  skillSourceIdentity,
-} from "./skill-catalog.ts";
-import {
-  hasExactSkillLoadOverride,
-  type SkillLoadOverride,
-  updateSkillLoadOverrides,
-} from "./skill-load-settings.ts";
-import {
-  applyPromptOverrides,
-  DISABLED,
-  ENABLED,
-  MODEL_DISABLED,
-  notifyInvocationConfigWarnings,
-  persistInvocation,
-  resolveInvocation,
-} from "./skill-model-invocation.ts";
+  registerSessionCapabilitySkillProvider,
+  sessionCapabilityState,
+} from "@mrclrchtr/supi-core/session";
+import { registerSettings, type SettingsModule } from "@mrclrchtr/supi-core/settings";
+import { applyPromptOverrides, notifyInvocationConfigWarnings } from "./skill-model-invocation.ts";
+import { SkillSettingsController, type SkillSettingsOptions } from "./skill-settings-controller.ts";
 
 const SETTINGS_SECTION_ID = "skills";
-interface SkillSettingsOptions {
-  agentDir?: string;
-  homeDir?: string;
-}
-interface SkillSettingsControllerOptions {
-  cwd: string;
-  agentDir: string;
-  homeDir?: string;
-  projectTrusted: boolean;
-  settingsManager: SettingsManager;
-  globalSettingsManager: SettingsManager;
-}
-
-function recordResources(record: SkillRecord): ResolvedResource[] {
-  return record.sources.flatMap((source) => (source.resource ? [source.resource] : []));
-}
-function isLoaded(record: SkillRecord): boolean {
-  return (
-    record.activeSkill !== undefined ||
-    record.sources.some((source) => source.runtime || source.resource?.enabled)
-  );
-}
-function canDisable(record: SkillRecord): boolean {
-  return record.sources.length > 0 && record.sources.every((source) => !source.runtime);
-}
-
-function sourceDefault(record: SkillRecord): boolean {
-  const winner =
-    record.activeSkill ??
-    record.sources.find((source) => source.runtime || source.resource?.enabled)?.skill ??
-    record.sources[0]?.skill;
-  return winner?.disableModelInvocation ?? false;
-}
-
-function moreSpecificSource(left: ValueSource, right: ValueSource): ValueSource {
-  const rank: Record<ValueSource, number> = { default: 0, global: 1, project: 2 };
-  return rank[left] >= rank[right] ? left : right;
-}
-
-function displayValue(value: string, source: ValueSource): string {
-  return `${value} (${source})`;
-}
+type SkillControllerGetter = (
+  cwd: string,
+  projectTrusted: boolean,
+) => Promise<SkillSettingsController>;
 
-function validateAction(record: SkillRecord, action: SettingsAction): void {
-  if (action.kind !== "set") return;
-  if (![ENABLED, MODEL_DISABLED, DISABLED].includes(action.value)) {
-    throw new Error(`Invalid skill state: "${action.value}"`);
-  }
-  if (action.value === DISABLED && !canDisable(record)) {
-    throw new Error(`Full disable is unavailable for skill "${record.name}"`);
-  }
-}
-
-function loadOverride(
-  record: SkillRecord,
-  action: SettingsAction,
-  hasExactOverride: boolean,
-): SkillLoadOverride | undefined {
-  if (action.kind === "unset") return hasExactOverride ? "inherit" : undefined;
-  if (action.value === DISABLED) return "unload";
-  return isLoaded(record) ? undefined : "load";
-}
-
-class SkillSettingsController {
-  private readonly cwd: string;
-  private readonly agentDir: string;
-  private readonly homeDir: string | undefined;
-  private readonly projectTrusted: boolean;
-  private readonly settingsManager: SettingsManager;
-  private readonly globalSettingsManager: SettingsManager;
-  private readonly pendingDisabled = new Map<string, Set<string>>();
-  private globalCatalog: SkillCatalog = new Map();
-  private projectCatalog: SkillCatalog = new Map();
-
-  private constructor(options: SkillSettingsControllerOptions) {
-    this.cwd = options.cwd;
-    this.agentDir = options.agentDir;
-    this.homeDir = options.homeDir;
-    this.projectTrusted = options.projectTrusted;
-    this.settingsManager = options.settingsManager;
-    this.globalSettingsManager = options.globalSettingsManager;
-  }
-
-  static async create(
-    cwd: string,
-    projectTrusted: boolean,
-    options: SkillSettingsOptions,
-  ): Promise<SkillSettingsController> {
-    const agentDir = options.agentDir ?? getAgentDir();
-    const controller = new SkillSettingsController({
-      cwd,
-      agentDir,
-      homeDir: options.homeDir,
-      projectTrusted,
-      settingsManager: SettingsManager.create(cwd, agentDir, { projectTrusted }),
-      globalSettingsManager: SettingsManager.create(cwd, agentDir, { projectTrusted: false }),
-    });
-    await controller.refreshCatalogs();
-    return controller;
-  }
-
-  private async refreshCatalogs(): Promise<void> {
-    await Promise.all([this.settingsManager.reload(), this.globalSettingsManager.reload()]);
-    const [globalPaths, projectPaths] = await Promise.all([
-      new DefaultPackageManager({
-        cwd: this.cwd,
-        agentDir: this.agentDir,
-        settingsManager: this.globalSettingsManager,
-      }).resolve(async () => "skip"),
-      new DefaultPackageManager({
-        cwd: this.cwd,
-        agentDir: this.agentDir,
-        settingsManager: this.settingsManager,
-      }).resolve(async () => "skip"),
-    ]);
-    this.globalCatalog = buildSkillCatalog(globalPaths.skills, this.cwd, this.agentDir);
-    this.projectCatalog = buildSkillCatalog(projectPaths.skills, this.cwd, this.agentDir);
-  }
-
-  private records(scope: SettingsScope, ctx?: ExtensionContext): SkillCatalog {
-    return mergeRuntimeSkills(
-      scope === "project" ? this.projectCatalog : this.globalCatalog,
-      ctx,
-      scope,
-      this.pendingDisabled,
-    );
-  }
-
-  /**
-   * Prefer original global provenance when a project support path resolves the
-   * same file as a project resource. This lets Unset remove both the exact
-   * override and the generated support path after a catalog refresh.
-   */
-  private actionResources(record: SkillRecord, scope: SettingsScope): ResolvedResource[] {
-    const globalResources =
-      scope === "project" ? recordResources(this.globalCatalog.get(record.name) ?? record) : [];
-    const unique = new Map<string, ResolvedResource>();
-    for (const resource of [...globalResources, ...recordResources(record)]) {
-      const key = `${resource.path}\0${resource.metadata.origin}\0${resource.metadata.source}`;
-      if (!unique.has(key)) unique.set(key, resource);
-    }
-    return Array.from(unique.values());
-  }
-
-  /**
-   * Attribute the effective load value to the narrowest scoped override.
-   * Project resources can be support-path surrogates, so attribution compares
-   * their effective load state with the original global catalog.
-   */
-  private loadSource(record: SkillRecord, scope: SettingsScope): ValueSource {
-    const resources = recordResources(record);
-    const exact = hasExactSkillLoadOverride({
-      settingsManager: this.settingsManager,
-      resources,
-      scope,
-      cwd: this.cwd,
-      agentDir: this.agentDir,
-    });
-    if (exact) return scope;
-    if (scope === "global") {
-      return resources.some((resource) => !resource.enabled) ? "global" : "default";
-    }
-    if (resources.some((resource) => resource.metadata.scope === "project" && !resource.enabled)) {
-      return "project";
-    }
-    const globalRecord = this.globalCatalog.get(record.name);
-    if (!globalRecord) return "default";
-    const globalResources = recordResources(globalRecord);
-    const projectLoaded = resources.some((resource) => resource.enabled);
-    const globalLoaded = globalResources.some((resource) => resource.enabled);
-    if (projectLoaded !== globalLoaded) return "project";
-    return this.loadSource(globalRecord, "global");
-  }
-
-  private rowSource(
-    record: SkillRecord,
-    scope: SettingsScope,
-    invocationSource: ValueSource,
-  ): ValueSource {
-    return moreSpecificSource(this.loadSource(record, scope), invocationSource);
-  }
-
-  private row(record: SkillRecord, scope: SettingsScope): ScopedFieldValue {
-    const invocation = resolveInvocation({
-      name: record.name,
-      sourceDefault: sourceDefault(record),
-      scope,
-      cwd: this.cwd,
-      projectTrusted: this.projectTrusted,
-      homeDir: this.homeDir,
-    });
-    const value = !isLoaded(record) ? DISABLED : invocation.disabled ? MODEL_DISABLED : ENABLED;
-    const source = this.rowSource(record, scope, invocation.source);
-    const values = canDisable(record)
-      ? [ENABLED, MODEL_DISABLED, DISABLED]
-      : [ENABLED, MODEL_DISABLED];
-    const sourceCount = record.sources.length;
-    const limitation = canDisable(record)
-      ? ""
-      : " Full disable is unavailable because PI does not expose a load setting for one or more sources.";
-    return {
-      field: {
-        kind: "enum",
-        key: record.name,
-        label: record.name,
-        values,
-        description: `${record.description}${sourceCount > 1 ? ` ${sourceCount} sources.` : ""}${limitation}`,
-      },
-      displayValue: displayValue(value, source),
-      editValue: value,
-      source,
-      ...(scope === "project" && source === "project"
-        ? {
-            inheritanceSource:
-              this.globalRowSource(record.name) === "global" ? "global" : "default",
-          }
-        : {}),
-    };
-  }
-
-  private globalRowSource(name: string): ValueSource {
-    const record = this.globalCatalog.get(name);
-    if (!record) return "default";
-    const invocation = resolveInvocation({
-      name,
-      sourceDefault: sourceDefault(record),
-      scope: "global",
-      cwd: this.cwd,
-      projectTrusted: false,
-      homeDir: this.homeDir,
-    });
-    return this.rowSource(record, "global", invocation.source);
-  }
-
-  read(scope: SettingsScope, ctx?: ExtensionContext): ScopedFieldValue[] {
-    return Array.from(this.records(scope, ctx).values())
-      .sort((left, right) => left.name.localeCompare(right.name))
-      .map((record) => this.row(record, scope));
-  }
-
-  private updatePendingDisabled(
-    fieldKey: string,
-    nextLoadOverride: SkillLoadOverride,
-    activeSkillIdentity: string | undefined,
-  ): void {
-    if (nextLoadOverride !== "unload") {
-      this.pendingDisabled.delete(fieldKey);
-      return;
-    }
-    if (activeSkillIdentity) {
-      this.pendingDisabled.set(fieldKey, new Set([activeSkillIdentity]));
-    }
-  }
-
-  async apply(
-    scope: SettingsScope,
-    fieldKey: string,
-    action: SettingsAction,
-    ctx?: ExtensionContext,
-  ): Promise<SettingsApplyResult> {
-    if (scope === "project" && !this.projectTrusted) {
-      throw new Error("Project is not trusted; refusing to write project skill settings");
-    }
-    const record = this.records(scope, ctx).get(fieldKey);
-    if (!record) return {};
-    validateAction(record, action);
-    const activeSkillIdentity = record.activeSkill
-      ? skillSourceIdentity(record.activeSkill)
-      : undefined;
-
-    if (action.kind !== "set" || action.value !== DISABLED) {
-      persistInvocation({
-        name: fieldKey,
-        disabled: action.kind === "set" ? action.value === MODEL_DISABLED : undefined,
-        scope,
-        cwd: this.cwd,
-        homeDir: this.homeDir,
-      });
-    }
-
-    const resources = this.actionResources(record, scope);
-    const hasLoadOverride = hasExactSkillLoadOverride({
-      settingsManager: this.settingsManager,
-      resources,
-      scope,
-      cwd: this.cwd,
-      agentDir: this.agentDir,
-    });
-    const nextLoadOverride = loadOverride(record, action, hasLoadOverride);
-    if (nextLoadOverride && resources.length > 0) {
-      updateSkillLoadOverrides({
-        settingsManager: this.settingsManager,
-        resources,
-        scope,
-        state: nextLoadOverride,
-        cwd: this.cwd,
-        agentDir: this.agentDir,
-      });
-      await this.settingsManager.flush();
-      const error = this.settingsManager.drainErrors()[0];
-      await this.refreshCatalogs();
-      if (error) throw error.error;
-      this.updatePendingDisabled(fieldKey, nextLoadOverride, activeSkillIdentity);
-      return {
-        notice: { message: "Reload required for skill load changes", level: "info" },
-      };
-    }
-    return {};
-  }
-}
-
-function createSkillSettingsModule(options: SkillSettingsOptions): SettingsModule {
+function createSkillControllerGetter(options: SkillSettingsOptions): SkillControllerGetter {
   let controllerKey: string | undefined;
   let controllerPromise: Promise<SkillSettingsController> | undefined;
-
-  const getController = (context: SettingsContext): Promise<SkillSettingsController> => {
-    const projectTrusted = context.ctx?.isProjectTrusted() ?? false;
-    const key = `${context.cwd}\0${projectTrusted}`;
+  return (cwd, projectTrusted) => {
+    const key = `${cwd}\0${projectTrusted}`;
     if (!controllerPromise || controllerKey !== key) {
       controllerKey = key;
-      controllerPromise = SkillSettingsController.create(context.cwd, projectTrusted, options);
+      controllerPromise = SkillSettingsController.create(cwd, projectTrusted, options);
     }
     return controllerPromise;
   };
+}
 
+function createSkillSettingsModule(
+  options: SkillSettingsOptions,
+  getController: SkillControllerGetter,
+): SettingsModule {
   return {
     id: SETTINGS_SECTION_ID,
     label: "Skills",
     read: async (context) => {
       if (context.ctx) notifyInvocationConfigWarnings(context.ctx, options.homeDir);
-      return { rows: (await getController(context)).read(context.scope, context.ctx) };
+      const projectTrusted = context.ctx?.isProjectTrusted() ?? false;
+      return {
+        rows: (await getController(context.cwd, projectTrusted)).read(context.scope, context.ctx),
+      };
     },
-    apply: async (request) =>
-      (await getController(request)).apply(
+    apply: async (request) => {
+      const projectTrusted = request.ctx?.isProjectTrusted() ?? false;
+      return (await getController(request.cwd, projectTrusted)).apply(
         request.scope,
         request.fieldKey,
         request.action,
         request.ctx,
-      ),
+      );
+    },
   };
 }
 
 /** Register scoped skill availability settings and prompt overrides. */
 export default function skillSettings(pi: ExtensionAPI, options: SkillSettingsOptions = {}): void {
-  registerSettings(pi, createSkillSettingsModule(options));
+  const getController = createSkillControllerGetter(options);
+  const providerDisposers = new Map<string, () => void>();
+  registerSettings(pi, createSkillSettingsModule(options, getController));
+
+  pi.on("session_start", (_event, ctx) => {
+    const sessionId = ctx.sessionManager.getSessionId();
+    providerDisposers.get(sessionId)?.();
+    const dispose = registerSessionCapabilitySkillProvider<ExtensionCommandContext>(sessionId, {
+      listEligibleSkills: async (commandCtx) => {
+        const controller = await getController(commandCtx.cwd, commandCtx.isProjectTrusted());
+        return controller.eligibleModelSkills(commandCtx);
+      },
+    });
+    providerDisposers.set(sessionId, dispose);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    const sessionId = ctx.sessionManager.getSessionId();
+    providerDisposers.get(sessionId)?.();
+    providerDisposers.delete(sessionId);
+  });
 
   pi.on("before_agent_start", (event, ctx) => {
     notifyInvocationConfigWarnings(ctx, options.homeDir);
+    const state = sessionCapabilityState.get(ctx.sessionManager.getSessionId());
     const systemPrompt = applyPromptOverrides({
       options: event.systemPromptOptions,
       systemPrompt: event.systemPrompt,
       cwd: ctx.cwd,
       projectTrusted: ctx.isProjectTrusted(),
       homeDir: options.homeDir,
+      hiddenSkillNames: new Set(state?.hiddenSkillNames ?? []),
     });
     return systemPrompt === undefined ? undefined : { systemPrompt };
   });