pi-toggle-skills 0.1.0

package/README.md

@@ -0,0 +1,186 @@
+<div align="center">
+
+# 🔘 pi-toggle-skills
+
+**Toggle skill visibility in [pi](https://github.com/earendil-works/pi-coding-agent)'s system prompt**
+
+_Flip `disable-model-invocation` on skills so the model only sees the ones you want._
+
+[![pi extension](https://img.shields.io/badge/pi-extension-blueviolet)](https://github.com/earendil-works/pi-coding-agent)
+[![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
+
+</div>
+
+---
+
+## The Problem
+
+Pi loads skills from multiple directories and includes their names and descriptions in the system prompt. If you have many skills installed, the prompt gets noisy — the model sees every skill and may inappropriately trigger ones you rarely use.
+
+Pi supports `disable-model-invocation: true` in SKILL.md frontmatter to hide a skill from the system prompt, but toggling it requires manually editing each YAML file. There's no interactive way to manage skill visibility.
+
+## The Solution
+
+`pi-toggle-skills` gives you an interactive TUI to toggle which skills are visible to the model:
+
+- Discover all skills from the standard directories (`~/.pi/agent/skills/`, `.pi/skills/`, etc.)
+- Interactive `/toggle-skills` command — search, toggle, done
+- Flips `disable-model-invocation` directly in each SKILL.md's YAML frontmatter
+- Auto-reloads pi after saving so changes take effect immediately
+- Subcommands for quick CLI-style enable/disable
+
+When a skill has `disable-model-invocation: true`, pi excludes it from the system prompt entirely. The skill is still available via explicit `/skill:name` commands — it just won't be suggested to the model automatically.
+
+## Usage
+
+### Interactive Commands
+
+| Command                         | What it does                                    |
+| ------------------------------- | ----------------------------------------------- |
+| `/toggle-skills`                | Open interactive TUI to toggle skill visibility |
+| `/toggle-skills status`         | Show current skills and their visibility status |
+| `/toggle-skills disable <name>` | Hide a skill from the system prompt             |
+| `/toggle-skills enable <name>`  | Show a skill in the system prompt               |
+| `/toggle-skills list`           | Same as `/toggle-skills status`                 |
+| `/toggle-skills help`           | Show usage reference                            |
+
+### Interactive TUI Keybindings
+
+| Key      | Action                                  |
+| -------- | --------------------------------------- |
+| `Enter`  | Toggle selected skill                   |
+| `Ctrl+A` | Disable all (filtered if search active) |
+| `Ctrl+D` | Enable all (filtered if search active)  |
+| `Ctrl+S` | Save changes (run /reload to apply)       |
+| `Esc`    | Cancel (discard changes)                |
+| `Ctrl+C` | Clear search, or cancel if empty        |
+| ↑/↓      | Navigate the list                       |
+
+### CLI Examples
+
+```
+/toggle-skills disable brave-search
+→ Disabled: "brave-search" — hidden from system prompt. Run /reload to apply.
+
+/toggle-skills enable brave-search
+→ Enabled: "brave-search" — visible in system prompt. Run /reload to apply.
+```
+
+## Installation
+
+```bash
+pi install https://github.com/monotykamary/pi-toggle-skills
+```
+
+Or in `~/.pi/agent/settings.json`:
+
+```json
+{
+  "packages": ["https://github.com/monotykamary/pi-toggle-skills"]
+}
+```
+
+Then `/reload` or restart pi.
+
+For quick one-off tests:
+
+```bash
+pi -e ./toggle-skills.ts
+```
+
+## How It Works
+
+```
+Session starts
+  → Extension discovers skills from standard directories
+  → Parses SKILL.md YAML frontmatter to check disable-model-invocation
+  → Notifies how many visible/hidden skills
+
+/toggle-skills (interactive):
+  → Opens TUI selector listing all skills
+  → Changes collected in-memory (no disk writes until Ctrl+S)
+  → Ctrl+S: writes changed SKILL.md files, notifies user to /reload
+  → Esc: discards changes, no files modified
+
+/toggle-skills disable/enable:
+  → Toggles disable-model-invocation in SKILL.md frontmatter
+  → Adds the key when disabling, removes it when enabling (false is the default)
+  → Uses gray-matter for safe YAML round-tripping
+  → User must /reload for changes to take effect
+```
+
+The extension does NOT monkey-patch any pi internals. It modifies SKILL.md files on disk and relies on pi's skill re-scanning on `/reload` to apply changes.
+
+### Frontmatter Changes
+
+When disabling a skill, the extension adds `disable-model-invocation: true` to the SKILL.md frontmatter:
+
+```yaml
+---
+name: my-skill
+description: Does things
+disable-model-invocation: true # ← added
+---
+```
+
+When enabling, the key is removed entirely (since `false`/absent are equivalent):
+
+```yaml
+---
+name: my-skill
+description: Things done
+---
+```
+
+### Skill Directories Scanned
+
+The extension scans the same directories pi uses:
+
+| Directory             | Scope                    |
+| --------------------- | ------------------------ |
+| `~/.pi/agent/skills/` | Global (pi-specific)     |
+| `~/.agents/skills/`   | Global (agent-standard)  |
+| `.pi/skills/`         | Project (pi-specific)    |
+| `.agents/skills/`     | Project (agent-standard) |
+
+Package skills, settings skills, and `--skill` paths are not currently scanned (they require reading `settings.json` and CLI args).
+
+## Comparison with Alternatives
+
+| Approach                    | Pros                                                                                                      | Cons                                                                |
+| --------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
+| **pi-toggle-skills** (this) | Interactive TUI; directly modifies SKILL.md; no intermediate config; auto-reload; batch changes with undo | Changes require `/reload`; doesn't scan package/settings/CLI skills|
+| Manual SKILL.md editing     | No extension needed                                                                                       | Tedious; error-prone YAML editing; must remember frontmatter syntax |
+| Deleting SKILL.md files     | Effective                                                                                                 | Destructive; must restore to re-enable; can't toggle back easily    |
+
+## Development
+
+```bash
+npm install
+npm test          # Vitest unit tests
+npm run typecheck # TypeScript validation (pi-tui import error is expected — types resolve at runtime)
+npm run lint:dead # Dead code detection (knip)
+```
+
+### Structure
+
+```
+.
+├── toggle-skills.ts        # Main extension
+├── src/
+│   ├── index.ts             # Constants, types, and utilities
+│   ├── skill-discovery.ts   # Skill directory scanning, frontmatter parsing/writing
+│   └── skill-selector.ts    # Interactive TUI component
+├── __tests__/
+│   └── unit/
+│       ├── toggle-skills.test.ts
+│       └── skill-discovery.test.ts
+├── package.json
+├── tsconfig.json
+├── vitest.config.ts
+└── knip.json
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "pi-toggle-skills",
+  "version": "0.1.0",
+  "description": "Toggle skill visibility in pi's system prompt — flip disable-model-invocation on skills via an interactive TUI",
+  "type": "module",
+  "author": "Tom X Nguyen",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monotykamary/pi-toggle-skills.git"
+  },
+  "homepage": "https://github.com/monotykamary/pi-toggle-skills#readme",
+  "bugs": {
+    "url": "https://github.com/monotykamary/pi-toggle-skills/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "extension",
+    "skills",
+    "toggle",
+    "disable-model-invocation",
+    "visibility"
+  ],
+  "files": [
+    "*.ts",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint:dead": "knip --no-gitignore"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "0.75.4",
+    "@types/node": "25.9.1",
+    "@vitest/coverage-v8": "4.1.7",
+    "knip": "6.14.1",
+    "typescript": "6.0.3",
+    "vitest": "4.1.7"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3"
+  },
+  "pi": {
+    "extensions": [
+      "./toggle-skills.ts"
+    ]
+  }
+}

package/src/index.ts

@@ -0,0 +1,112 @@
+/**
+ * Shared constants, types, and utilities for pi-toggle-skills.
+ */
+
+/** Description shown in the / commands list. */
+export const TOGGLE_COMMAND_DESCRIPTION = "Toggle which skills are visible to the model (disable-model-invocation)";
+
+/** Frontmatter key that controls skill visibility. */
+export const DISABLE_MODEL_INVOCATION_KEY = "disable-model-invocation";
+
+/** A discovered skill with its toggle state. */
+export interface ToggleSkill {
+  /** Skill name from frontmatter (or parent directory as fallback). */
+  name: string;
+  /** Description from frontmatter. */
+  description: string;
+  /** Absolute path to the SKILL.md file. */
+  filePath: string;
+  /** Directory containing the SKILL.md. */
+  baseDir: string;
+  /** Whether disable-model-invocation is currently true. */
+  disabled: boolean;
+}
+
+/** Snapshot of a skill's original state before any in-memory toggles. */
+export interface SkillToggleChange {
+  filePath: string;
+  originalDisabled: boolean;
+  newDisabled: boolean;
+}
+
+/**
+ * Check whether a frontmatter object has disable-model-invocation set to true.
+ */
+export function isDisabled(frontmatter: Record<string, unknown>): boolean {
+  return frontmatter[DISABLE_MODEL_INVOCATION_KEY] === true;
+}
+
+/**
+ * Format a skill's status for display.
+ */
+export function formatSkillStatus(skill: ToggleSkill): string {
+  return skill.disabled ? "✗ hidden" : "✓ visible";
+}
+
+/**
+ * Format a skill for one-line display (e.g. in status list).
+ */
+export function formatSkillLine(skill: ToggleSkill): string {
+  const status = skill.disabled ? "hidden" : "visible";
+  return `${skill.name} [${status}] — ${skill.description}`;
+}
+
+/**
+ * Deduplicate skills by filePath — keep the first occurrence.
+ */
+export function deduplicateSkills(skills: ReadonlyArray<ToggleSkill>): ToggleSkill[] {
+  const seen = new Set<string>();
+  return skills.filter((skill) => {
+    if (seen.has(skill.filePath)) return false;
+    seen.add(skill.filePath);
+    return true;
+  });
+}
+
+/**
+ * Compute the set of changes between original skills and current (toggled) state.
+ */
+export function computeChanges(
+  originals: ReadonlyArray<ToggleSkill>,
+  current: ReadonlyArray<ToggleSkill>,
+): SkillToggleChange[] {
+  const currentByPath = new Map<string, ToggleSkill>();
+  for (const skill of current) {
+    currentByPath.set(skill.filePath, skill);
+  }
+
+  const changes: SkillToggleChange[] = [];
+  for (const original of originals) {
+    const currentSkill = currentByPath.get(original.filePath);
+    if (currentSkill && currentSkill.disabled !== original.disabled) {
+      changes.push({
+        filePath: original.filePath,
+        originalDisabled: original.disabled,
+        newDisabled: currentSkill.disabled,
+      });
+    }
+  }
+
+  return changes;
+}
+
+/**
+ * Validate a skill name per the Agent Skills spec.
+ * Returns array of error messages (empty if valid).
+ */
+export function validateSkillName(name: string): string[] {
+  const errors: string[] = [];
+  if (name.length > 64) {
+    errors.push(`name exceeds 64 characters (${name.length})`);
+  }
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    errors.push("name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)");
+  }
+  if (name.startsWith("-") || name.endsWith("-")) {
+    errors.push("name must not start or end with a hyphen");
+  }
+  if (name.includes("--")) {
+    errors.push("name must not contain consecutive hyphens");
+  }
+  return errors;
+}

package/src/skill-discovery.ts

@@ -0,0 +1,247 @@
+/**
+ * Skill discovery and frontmatter manipulation for pi-toggle-skills.
+ *
+ * Scans the standard pi skill directories to find SKILL.md files,
+ * parses their YAML frontmatter, and provides safe round-trip editing
+ * via gray-matter.
+ */
+
+import {
+  type ToggleSkill,
+  DISABLE_MODEL_INVOCATION_KEY,
+  isDisabled,
+  deduplicateSkills,
+} from "./index.js";
+import matter from "gray-matter";
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join, basename, dirname } from "node:path";
+import { homedir } from "node:os";
+
+// Skill directories to scan (in priority order, matching pi's discovery)
+
+function getGlobalPiSkillDirs(): string[] {
+  return [join(homedir(), ".pi", "agent", "skills")];
+}
+
+function getGlobalAgentsSkillDirs(): string[] {
+  return [join(homedir(), ".agents", "skills")];
+}
+
+function getProjectSkillDirs(cwd: string): string[] {
+  return [join(cwd, ".pi", "skills"), join(cwd, ".agents", "skills")];
+}
+
+/** Skill source identifier for diagnostics. */
+type SkillSource = "global-pi" | "global-agents" | "project-pi" | "project-agents";
+
+export interface SkillDir {
+  path: string;
+  source: SkillSource;
+}
+
+function getAllSkillDirs(cwd: string): SkillDir[] {
+  const dirs: SkillDir[] = [];
+
+  for (const path of getGlobalPiSkillDirs()) {
+    dirs.push({ path, source: "global-pi" });
+  }
+  for (const path of getGlobalAgentsSkillDirs()) {
+    dirs.push({ path, source: "global-agents" });
+  }
+  for (const path of getProjectSkillDirs(cwd)) {
+    dirs.push({ path, source: "project-pi" });
+  }
+  // Deduplicate by path
+  const seen = new Set<string>();
+  return dirs.filter((d) => {
+    if (seen.has(d.path)) return false;
+    seen.add(d.path);
+    return true;
+  });
+}
+
+/** Options for discoverSkills. */
+export interface DiscoverSkillsOptions {
+  /** If provided, override the skill directories to scan (for testing). */
+  skillDirs?: SkillDir[];
+}
+
+/**
+ * Discover all skills across standard locations.
+ * Returns deduplicated skills (first found wins, matching pi's behavior).
+ */
+export function discoverSkills(cwd: string, options?: DiscoverSkillsOptions): ToggleSkill[] {
+  const allSkills: ToggleSkill[] = [];
+  const dirs = options?.skillDirs ?? getAllSkillDirs(cwd);
+
+  for (const dir of dirs) {
+    if (!existsSync(dir.path)) continue;
+    const skills = loadSkillsFromDir(dir.path, dir.source);
+    allSkills.push(...skills);
+  }
+
+  return deduplicateSkills(allSkills);
+}
+
+/**
+ * Load skills from a directory tree.
+ *
+ * Mirrors pi's discovery rules:
+ * - If a directory contains SKILL.md, treat it as a skill (don't recurse further)
+ * - Otherwise, load direct .md children in the root
+ * - Recurse into subdirectories to find SKILL.md
+ */
+function loadSkillsFromDir(dir: string, source: SkillSource): ToggleSkill[] {
+  const skills: ToggleSkill[] = [];
+
+  if (!existsSync(dir)) return skills;
+
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+
+    // Check for SKILL.md in this directory
+    for (const entry of entries) {
+      if (entry.name !== "SKILL.md") continue;
+
+      const fullPath = join(dir, entry.name);
+      const skill = loadSkillFromFile(fullPath);
+      if (skill) skills.push(skill);
+
+      // SKILL.md found — don't look for other .md files or recurse
+      return skills;
+    }
+
+    // No SKILL.md — check root .md files (only in .pi/skills/ and ~/.pi/agent/skills/)
+    const isDiscoverableRoot = source === "global-pi" || source === "project-pi";
+    if (isDiscoverableRoot) {
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        if (entry.name === "node_modules") continue;
+        if (!entry.name.endsWith(".md")) continue;
+
+        const fullPath = join(dir, entry.name);
+        let isFile = entry.isFile();
+        if (entry.isSymbolicLink()) {
+          try { isFile = statSync(fullPath).isFile(); } catch { continue; }
+        }
+        if (!isFile) continue;
+
+        const skill = loadSkillFromFile(fullPath);
+        if (skill) skills.push(skill);
+      }
+    }
+
+    // Recurse into subdirectories
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      if (entry.name === "node_modules") continue;
+
+      const fullPath = join(dir, entry.name);
+      let isDirectory = entry.isDirectory();
+
+      if (entry.isSymbolicLink()) {
+        try { isDirectory = statSync(fullPath).isDirectory(); } catch { continue; }
+      }
+      if (!isDirectory) continue;
+
+      const subSkills = loadSkillsFromDir(fullPath, source);
+      skills.push(...subSkills);
+    }
+  } catch {
+    // Permission errors, etc. — skip silently.
+  }
+
+  return skills;
+}
+
+/**
+ * Load a single skill from a SKILL.md (or root .md) file.
+ * Returns null if the file can't be parsed or is missing a description.
+ */
+function loadSkillFromFile(filePath: string): ToggleSkill | null {
+  try {
+    const rawContent = readFileSync(filePath, "utf8");
+    const { data: frontmatter } = parseFrontmatter(rawContent);
+    const skillDir = dirname(filePath);
+    const parentDirName = basename(skillDir);
+
+    const name = (frontmatter.name as string) || parentDirName;
+    const description = frontmatter.description as string;
+
+    // Skills without description are not loaded by pi — skip them
+    if (!description || description.trim() === "") return null;
+
+    return {
+      name,
+      description,
+      filePath,
+      baseDir: skillDir,
+      disabled: isDisabled(frontmatter),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse YAML frontmatter from a string using gray-matter.
+ */
+export function parseFrontmatter(content: string): { data: Record<string, unknown>; content: string } {
+  const parsed = matter(content);
+  return { data: parsed.data as Record<string, unknown>, content: parsed.content };
+}
+
+/**
+ * Toggle disable-model-invocation in a SKILL.md file.
+ *
+ * When disabling: sets `disable-model-invocation: true`
+ * When enabling: removes the key entirely (false is the default)
+ *
+ * Returns true if the file was written, false on error.
+ */
+export function toggleSkillInvocation(filePath: string, disabled: boolean): boolean {
+  try {
+    const rawContent = readFileSync(filePath, "utf8");
+    const parsed = matter(rawContent);
+
+    if (disabled) {
+      parsed.data[DISABLE_MODEL_INVOCATION_KEY] = true;
+    } else {
+      // Remove the key when enabling (false is the default / absent state)
+      delete parsed.data[DISABLE_MODEL_INVOCATION_KEY];
+    }
+
+    const output = matter.stringify(parsed.content, parsed.data);
+    writeFileSync(filePath, output, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Apply a batch of toggle changes to disk.
+ * Returns the list of filePaths that were successfully written.
+ */
+export function applyChanges(
+  skills: ReadonlyArray<ToggleSkill>,
+  changes: ReadonlyArray<{ filePath: string; newDisabled: boolean }>,
+): string[] {
+  const written: string[] = [];
+  const skillsByPath = new Map<string, ToggleSkill>();
+  for (const skill of skills) {
+    skillsByPath.set(skill.filePath, skill);
+  }
+
+  for (const change of changes) {
+    const skill = skillsByPath.get(change.filePath);
+    // Only write if the target state differs from what we last read
+    if (skill && skill.disabled !== change.newDisabled) {
+      if (toggleSkillInvocation(change.filePath, change.newDisabled)) {
+        written.push(change.filePath);
+      }
+    }
+  }
+
+  return written;
+}

package/src/skill-selector.ts

@@ -0,0 +1,424 @@
+/**
+ * ToggleSkillSelectorComponent — an interactive TUI for toggling which
+ * skills are visible in pi's system prompt.
+ *
+ * Modeled after pi-hide-providers' HideProviderSelectorComponent:
+ * - Lists all discovered skills with their enabled/disabled status
+ * - Search/filter via Input component
+ * - Enter toggles disable-model-invocation for the selected skill
+ * - Ctrl+A / Ctrl+D bulk disable/enable (respects search filter)
+ * - Ctrl+S to save changes to disk and reload pi
+ * - Esc to cancel (discard in-memory toggles)
+ *
+ * Changes are collected in-memory and only written to disk on Ctrl+S.
+ * After writing, the user runs /reload so the skill list in the system prompt updates.
+ */
+
+import {
+  Container,
+  type Component,
+  fuzzyFilter,
+  getKeybindings,
+  Input,
+  Key,
+  matchesKey,
+  Spacer,
+  Text,
+} from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder, keyText } from "@earendil-works/pi-coding-agent";
+import { type ToggleSkill, formatSkillStatus } from "./index.js";
+
+interface DisplayItem {
+  name: string;
+  description: string;
+  filePath: string;
+  disabled: boolean;
+}
+
+export interface ToggleSkillSelectorResult {
+  /** Skills with their final toggle states. */
+  skills: ToggleSkill[];
+  /** If true, the user cancelled and changes should not be written. */
+  cancelled: boolean;
+}
+
+export class ToggleSkillSelectorComponent implements Component {
+  private theme: Theme;
+  private done: (result: ToggleSkillSelectorResult) => void;
+
+  // All skill items (immutable original list)
+  private allItems: DisplayItem[] = [];
+
+  // Current in-memory toggle states (keyed by filePath)
+  private disabledMap: Map<string, boolean> = new Map();
+
+  // UI state
+  private lastWidth = 80;
+  private filteredItems: DisplayItem[] = [];
+  private selectedIndex = 0;
+  private maxVisible = 10;
+  private searchInput: Input;
+  private listContainer: Container;
+  private footerText: Text;
+  private hasChanges = false;
+  private originalSkills: ToggleSkill[] = [];
+
+  // Focusable
+  private _focused = false;
+  get focused(): boolean {
+    return this._focused;
+  }
+  set focused(value: boolean) {
+    this._focused = value;
+    this.searchInput.focused = value;
+  }
+
+  constructor(
+    theme: Theme,
+    skills: ToggleSkill[],
+    done: (result: ToggleSkillSelectorResult) => void,
+  ) {
+    this.theme = theme;
+    this.done = done;
+    this.originalSkills = skills;
+
+    // Build display items and initial state map
+    for (const skill of skills) {
+      this.allItems.push({
+        name: skill.name,
+        description: skill.description,
+        filePath: skill.filePath,
+        disabled: skill.disabled,
+      });
+      this.disabledMap.set(skill.filePath, skill.disabled);
+    }
+    this.filteredItems = [...this.allItems];
+
+    this.searchInput = new Input();
+    this.listContainer = new Container();
+    this.footerText = new Text(this.getFooterText(), 0, 0);
+
+    this.searchInput.onSubmit = () => {
+      if (this.filteredItems[this.selectedIndex]) {
+        this.toggleItem(this.filteredItems[this.selectedIndex]);
+      }
+    };
+
+    this.updateList();
+  }
+
+  render(width: number): string[] {
+    if (this.lastWidth !== width) {
+      this.lastWidth = width;
+      this.updateList();
+    }
+    const lines: string[] = [];
+
+    lines.push(...new DynamicBorder((s) => this.theme.fg("accent", s)).render(width));
+    lines.push("");
+    lines.push(this.theme.fg("accent", this.theme.bold("Toggle Skill Visibility")));
+    lines.push(
+      this.theme.fg(
+        "muted",
+        `Toggle disable-model-invocation on skills. Hidden skills won't appear in the system prompt.`,
+      ),
+    );
+    lines.push("");
+    lines.push(...this.searchInput.render(width));
+    lines.push("");
+    lines.push(...this.listContainer.render(width));
+    lines.push("");
+    lines.push(...this.footerText.render(width));
+    lines.push(...new DynamicBorder((s) => this.theme.fg("accent", s)).render(width));
+
+    return lines;
+  }
+
+  handleInput(data: string): void {
+    const kb = getKeybindings();
+
+    if (kb.matches(data, "tui.select.up")) {
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex =
+        this.selectedIndex === 0
+          ? this.filteredItems.length - 1
+          : this.selectedIndex - 1;
+      this.updateList();
+      return;
+    }
+
+    if (kb.matches(data, "tui.select.down")) {
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex =
+        this.selectedIndex === this.filteredItems.length - 1
+          ? 0
+          : this.selectedIndex + 1;
+      this.updateList();
+      return;
+    }
+
+    // Enter — toggle selected item
+    if (kb.matches(data, "tui.select.confirm")) {
+      const item = this.filteredItems[this.selectedIndex];
+      if (item) {
+        this.toggleItem(item);
+      }
+      return;
+    }
+
+    // Ctrl+A — disable all (filtered if search active)
+    if (matchesKey(data, Key.ctrl("a"))) {
+      const targets = this.getFilterTargets();
+      this.disableSkills(targets);
+      this.hasChanges = true;
+      this.refresh();
+      return;
+    }
+
+    // Ctrl+D — enable all (filtered if search active)
+    if (matchesKey(data, Key.ctrl("d"))) {
+      const targets = this.getFilterTargets();
+      this.enableSkills(targets);
+      this.hasChanges = true;
+      this.refresh();
+      return;
+    }
+
+    // Ctrl+S — save and close
+    if (matchesKey(data, Key.ctrl("s"))) {
+      this.finish(false);
+      return;
+    }
+
+    // Escape — cancel
+    if (matchesKey(data, Key.escape)) {
+      this.finish(true);
+      return;
+    }
+
+    // Ctrl+C — clear search or cancel if empty
+    if (matchesKey(data, Key.ctrl("c"))) {
+      if (this.searchInput.getValue()) {
+        this.searchInput.setValue("");
+        this.refresh();
+      } else {
+        this.finish(true);
+      }
+      return;
+    }
+
+    // Pass everything else to search input
+    this.searchInput.handleInput(data);
+    this.refresh();
+  }
+
+  invalidate(): void {
+    this.searchInput.invalidate();
+    this.listContainer.invalidate();
+    this.footerText.invalidate();
+  }
+
+  // Internal helpers
+
+  private getFilterTargets(): DisplayItem[] {
+    const query = this.searchInput.getValue();
+    return query ? this.filteredItems : this.allItems;
+  }
+
+  private getFooterText(): string {
+    const allCount = this.allItems.length;
+    const hiddenCount = this.allItems.filter((item) => this.disabledMap.get(item.filePath) ?? item.disabled).length;
+    const visibleCount = allCount - hiddenCount;
+
+    const parts: string[] = [
+      `${keyText("tui.select.confirm")} toggle`,
+      `ctrl+a hide all`,
+      `ctrl+d show all`,
+      `ctrl+s save & reload`,
+      `${visibleCount} visible · ${hiddenCount} hidden`,
+    ];
+
+    const text = parts.join(" · ");
+    return this.hasChanges
+      ? this.theme.fg("dim", `  ${text} `) + this.theme.fg("warning", "(unsaved)")
+      : this.theme.fg("dim", `  ${text}`);
+  }
+
+  private refresh(): void {
+    const query = this.searchInput.getValue();
+    this.filteredItems = query
+      ? fuzzyFilter(
+          this.allItems,
+          query,
+          (item: DisplayItem) => `${item.name} ${item.description} ${item.filePath}`,
+        )
+      : [...this.allItems];
+
+    // Update disabled status from the map
+    for (const item of this.filteredItems) {
+      item.disabled = this.disabledMap.get(item.filePath) ?? item.disabled;
+    }
+
+    this.selectedIndex = Math.min(
+      this.selectedIndex,
+      Math.max(0, this.filteredItems.length - 1),
+    );
+    this.updateList();
+  }
+
+  private updateList(): void {
+    this.listContainer.clear();
+
+    if (this.filteredItems.length === 0) {
+      this.listContainer.addChild(
+        new Text(this.theme.fg("muted", "  No matching skills"), 0, 0),
+      );
+      this.footerText.setText(this.getFooterText());
+      return;
+    }
+
+    const startIndex = Math.max(
+      0,
+      Math.min(
+        this.selectedIndex - Math.floor(this.maxVisible / 2),
+        this.filteredItems.length - this.maxVisible,
+      ),
+    );
+    const endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
+
+    for (let i = startIndex; i < endIndex; i++) {
+      const item = this.filteredItems[i];
+      if (!item) continue;
+
+      const isSelected = i === this.selectedIndex;
+      const prefix = isSelected ? this.theme.fg("accent", "→ ") : "  ";
+      const nameText = isSelected
+        ? this.theme.fg("accent", item.name)
+        : item.name;
+      const status = item.disabled
+        ? this.theme.fg("warning", " ✗")
+        : this.theme.fg("success", " ✓");
+
+      this.listContainer.addChild(
+        new Text(`${prefix}${nameText}${status}`, 0, 0),
+      );
+    }
+
+    // Scroll indicator
+    if (startIndex > 0 || endIndex < this.filteredItems.length) {
+      this.listContainer.addChild(
+        new Text(
+          this.theme.fg("muted", `  (${this.selectedIndex + 1}/${this.filteredItems.length})`),
+          0,
+          0,
+        ),
+      );
+    }
+
+    // Detail area for the selected item
+    if (this.filteredItems.length > 0) {
+      const selected = this.filteredItems[this.selectedIndex];
+      this.listContainer.addChild(new Spacer(1));
+      this.listContainer.addChild(
+        new Text(
+          this.theme.fg("dim", `  Source: ${selected.filePath}`),
+          0,
+          0,
+        ),
+      );
+      const descLines = this.wrapDescription(selected.description);
+      for (let i = 0; i < descLines.length; i++) {
+        const prefix = i === 0 ? "  Description: " : "               ";
+        this.listContainer.addChild(
+          new Text(this.theme.fg("muted", `${prefix}${descLines[i]}`), 0, 0),
+        );
+      }
+    }
+
+    this.footerText.setText(this.getFooterText());
+  }
+
+  /** Toggle a single item between disabled and enabled. */
+  private toggleItem(item: DisplayItem): void {
+    const current = this.disabledMap.get(item.filePath) ?? item.disabled;
+    this.disabledMap.set(item.filePath, !current);
+    this.hasChanges = this.hasChanges || current !== this.getOriginalState(item.filePath);
+    // Recompute hasChanges against originals
+    this.recheckHasChanges();
+    this.refresh();
+  }
+
+  /** Disable all given items. */
+  private disableSkills(items: DisplayItem[]): void {
+    for (const item of items) {
+      this.disabledMap.set(item.filePath, true);
+    }
+    this.recheckHasChanges();
+    this.refresh();
+  }
+
+  /** Enable all given items. */
+  private enableSkills(items: DisplayItem[]): void {
+    for (const item of items) {
+      this.disabledMap.set(item.filePath, false);
+    }
+    this.recheckHasChanges();
+    this.refresh();
+  }
+
+  /** Word-wrap a description string, fitting the terminal width. */
+  private wrapDescription(text: string): string[] {
+    const label = "  Description: ";
+    const indent = "               ";
+    const firstLineWidth = Math.max(20, this.lastWidth - label.length);
+    const contLineWidth = Math.max(20, this.lastWidth - indent.length);
+    const words = text.split(/\s+/).filter((w) => w.length > 0);
+    const lines: string[] = [];
+    let currentLine = "";
+
+    for (const word of words) {
+      const lineLen = currentLine.length === 0 ? 0 : currentLine.length + 1;
+      const limit = lines.length === 0 ? firstLineWidth : contLineWidth;
+      if (lineLen + word.length > limit && currentLine.length > 0) {
+        lines.push(currentLine);
+        currentLine = word;
+      } else {
+        currentLine = currentLine.length === 0 ? word : `${currentLine} ${word}`;
+      }
+    }
+    if (currentLine.length > 0) {
+      lines.push(currentLine);
+    }
+
+    return lines;
+  }
+
+  /** Check if any item's state differs from its original. */
+  private getOriginalState(filePath: string): boolean {
+    return this.originalSkills.find((s) => s.filePath === filePath)?.disabled ?? false;
+  }
+
+  private recheckHasChanges(): void {
+    this.hasChanges = this.allItems.some((item) => {
+      const current = this.disabledMap.get(item.filePath) ?? item.disabled;
+      return current !== this.getOriginalState(item.filePath);
+    });
+  }
+
+  /** Build final skill list from current toggle states and close. */
+  private finish(cancelled: boolean): void {
+    if (cancelled) {
+      this.done({ skills: this.originalSkills, cancelled: true });
+      return;
+    }
+
+    // Build updated skills from original + current toggle states
+    const updatedSkills: ToggleSkill[] = this.originalSkills.map((skill) => ({
+      ...skill,
+      disabled: this.disabledMap.get(skill.filePath) ?? skill.disabled,
+    }));
+
+    this.done({ skills: updatedSkills, cancelled: false });
+  }
+}

package/toggle-skills.ts

@@ -0,0 +1,298 @@
+/**
+ * pi-toggle-skills — toggle skill visibility in pi's system prompt.
+ *
+ * Toggles `disable-model-invocation` in SKILL.md frontmatter to control
+ * whether a skill appears in the model's available skills list.
+ *
+ * When a skill has `disable-model-invocation: true`, pi excludes it from
+ * the system prompt entirely. Users can still invoke it explicitly via
+ * /skill:name commands.
+ *
+ * This extension modifies SKILL.md files on disk. Changes require a /reload
+ * to take effect.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  TOGGLE_COMMAND_DESCRIPTION,
+  type ToggleSkill,
+  computeChanges,
+} from "./src/index.js";
+import {
+  discoverSkills,
+  toggleSkillInvocation,
+  applyChanges,
+} from "./src/skill-discovery.js";
+import { ToggleSkillSelectorComponent, type ToggleSkillSelectorResult } from "./src/skill-selector.js";
+
+export default function (pi: ExtensionAPI) {
+  let currentSkills: ToggleSkill[] = [];
+
+  pi.on("session_start", async (_event, ctx) => {
+    currentSkills = discoverSkills(ctx.cwd);
+
+    if (currentSkills.length > 0) {
+      const hidden = currentSkills.filter((s) => s.disabled).length;
+      const visible = currentSkills.length - hidden;
+
+      if (ctx.hasUI) {
+        ctx.ui.notify(
+          `pi-toggle-skills: ${visible} visible, ${hidden} hidden skill(s) — use /toggle-skills to manage`,
+          "info",
+        );
+      }
+    }
+  });
+
+  pi.registerCommand("toggle-skills", {
+    description: TOGGLE_COMMAND_DESCRIPTION,
+    getArgumentCompletions(prefix: string) {
+      const subcommands = ["status", "enable", "disable", "list", "help"];
+      const matches = subcommands.filter((s) => s.startsWith(prefix));
+      return matches.length > 0 ? matches.map((s) => ({ value: s, label: s })) : null;
+    },
+    handler: async (args, ctx) => {
+      await handleToggleCommand(ctx, args.trim(), currentSkills, (skills) => {
+        currentSkills = skills;
+      });
+    },
+  });
+}
+
+async function handleToggleCommand(
+  ctx: ExtensionCommandContext,
+  args: string,
+  currentSkills: ToggleSkill[],
+  setSkills: (skills: ToggleSkill[]) => void,
+): Promise<void> {
+  const parts = args.split(/\s+/);
+  const subcommand = parts[0]?.toLowerCase() ?? "";
+  const rest = parts.slice(1).join(" ");
+
+  // /toggle-skills — open interactive TUI selector (default)
+  if (!subcommand) {
+    await showToggleSelector(ctx, currentSkills, setSkills);
+    return;
+  }
+
+  // /toggle-skills list — show skills and their status
+  if (subcommand === "list") {
+    showStatus(ctx, currentSkills);
+    return;
+  }
+
+  // /toggle-skills status — same as list
+  if (subcommand === "status") {
+    showStatus(ctx, currentSkills);
+    return;
+  }
+
+  // /toggle-skills disable <name> — hide a skill from the system prompt
+  if (subcommand === "disable") {
+    if (!rest) {
+      ctx.ui.notify(
+        "Usage: /toggle-skills disable <skill-name>",
+        "warning",
+      );
+      return;
+    }
+
+    const skill = findSkillByName(currentSkills, rest);
+    if (!skill) {
+      ctx.ui.notify(`Skill not found: "${rest}". Use /toggle-skills list to see available skills.`, "warning");
+      return;
+    }
+
+    if (skill.disabled) {
+      ctx.ui.notify(`Skill "${skill.name}" is already hidden.`, "info");
+      return;
+    }
+
+    if (toggleSkillInvocation(skill.filePath, true)) {
+      skill.disabled = true;
+      ctx.ui.notify(
+        `Disabled: "${skill.name}" — hidden from system prompt. Run /reload to apply.`,
+        "info",
+      );
+    } else {
+      ctx.ui.notify(`Failed to toggle skill "${skill.name}". Check file permissions.`, "error");
+    }
+    return;
+  }
+
+  // /toggle-skills enable <name> — show a skill in the system prompt
+  if (subcommand === "enable") {
+    if (!rest) {
+      ctx.ui.notify(
+        "Usage: /toggle-skills enable <skill-name>",
+        "warning",
+      );
+      return;
+    }
+
+    const skill = findSkillByName(currentSkills, rest);
+    if (!skill) {
+      ctx.ui.notify(`Skill not found: "${rest}". Use /toggle-skills list to see available skills.`, "warning");
+      return;
+    }
+
+    if (!skill.disabled) {
+      ctx.ui.notify(`Skill "${skill.name}" is already visible.`, "info");
+      return;
+    }
+
+    if (toggleSkillInvocation(skill.filePath, false)) {
+      skill.disabled = false;
+      ctx.ui.notify(
+        `Enabled: "${skill.name}" — visible in system prompt. Run /reload to apply.`,
+        "info",
+      );
+    } else {
+      ctx.ui.notify(`Failed to toggle skill "${skill.name}". Check file permissions.`, "error");
+    }
+    return;
+  }
+
+  // /toggle-skills help
+  if (subcommand === "help") {
+    ctx.ui.notify(
+      [
+        "pi-toggle-skills commands:",
+        "  /toggle-skills               Open interactive TUI to toggle skill visibility",
+        "  /toggle-skills status        Show current skills and their visibility",
+        "  /toggle-skills list          Same as /toggle-skills status",
+        "  /toggle-skills disable <n>   Hide a skill from the system prompt",
+        "  /toggle-skills enable <n>    Show a skill in the system prompt",
+        "  /toggle-skills help          This message",
+        "",
+        "Mechanism: toggles disable-model-invocation in SKILL.md frontmatter.",
+        "  When true, the skill is excluded from the system prompt.",
+        "  Users can still invoke hidden skills via /skill:name commands.",
+        "  Changes require /reload to take effect.",
+      ].join("\n"),
+      "info",
+    );
+    return;
+  }
+
+  ctx.ui.notify(
+    `Unknown subcommand: "${subcommand}". Use /toggle-skills help for usage.`,
+    "warning",
+  );
+}
+
+// Open the interactive TUI selector.
+async function showToggleSelector(
+  ctx: ExtensionCommandContext,
+  currentSkills: ToggleSkill[],
+  setSkills: (skills: ToggleSkill[]) => void,
+): Promise<void> {
+  if (currentSkills.length === 0) {
+    ctx.ui.notify("No skills found. Add skills to ~/.pi/agent/skills/ or .pi/skills/ first.", "warning");
+    return;
+  }
+
+  const result = await ctx.ui.custom<ToggleSkillSelectorResult>(
+    (tui, theme, _kb, done) => {
+      const selector = new ToggleSkillSelectorComponent(
+        theme,
+        currentSkills,
+        (result) => done(result),
+      );
+
+      return {
+        render(width: number) {
+          return selector.render(width);
+        },
+        invalidate() {
+          selector.invalidate();
+        },
+        handleInput(data: string) {
+          selector.handleInput(data);
+          tui.requestRender();
+        },
+      };
+    },
+  );
+
+  if (!result || result.cancelled) {
+    ctx.ui.notify("Toggle selector cancelled.", "info");
+    return;
+  }
+
+  // Compute what changed
+  const changes = computeChanges(currentSkills, result.skills);
+  if (changes.length === 0) {
+    ctx.ui.notify("No changes to apply.", "info");
+    return;
+  }
+
+  // Write changes to disk
+  const written = applyChanges(currentSkills, changes);
+  if (written.length === 0) {
+    ctx.ui.notify("No files were written. Check file permissions.", "warning");
+    return;
+  }
+
+  setSkills(result.skills);
+
+  // Summarize what changed
+  const disabled = changes.filter((c) => c.newDisabled).length;
+  const enabled = changes.length - disabled;
+  const parts: string[] = [];
+  if (enabled > 0) parts.push(`${enabled} enabled`);
+  if (disabled > 0) parts.push(`${disabled} disabled`);
+  const summary = parts.join(", ");
+
+  ctx.ui.notify(
+    `Skills updated: ${summary}. Run /reload to apply.`,
+    "info",
+  );
+}
+
+function findSkillByName(skills: ReadonlyArray<ToggleSkill>, name: string): ToggleSkill | undefined {
+  // Exact match first
+  const exact = skills.find((s) => s.name === name);
+  if (exact) return exact;
+
+  // Prefix match
+  const prefix = skills.find((s) => s.name.startsWith(name));
+  if (prefix) return prefix;
+
+  // Fuzzy: contains
+  const fuzzy = skills.find((s) => s.name.includes(name));
+  return fuzzy;
+}
+
+function showStatus(
+  ctx: ExtensionCommandContext,
+  skills: ReadonlyArray<ToggleSkill>,
+): void {
+  const lines: string[] = [];
+
+  if (skills.length === 0) {
+    lines.push("No skills found. Add skills to ~/.pi/agent/skills/ or .pi/skills/.");
+  } else {
+    const visible = skills.filter((s) => !s.disabled);
+    const hidden = skills.filter((s) => s.disabled);
+
+    if (hidden.length > 0) {
+      lines.push(`Visible skills (${visible.length}):`);
+      for (const skill of visible) {
+        lines.push(`  ✓ ${skill.name}`);
+      }
+      lines.push("");
+      lines.push(`Hidden skills (${hidden.length}):`);
+      for (const skill of hidden) {
+        lines.push(`  ✗ ${skill.name}`);
+      }
+    } else {
+      lines.push(`All skills visible (${skills.length}):`);
+      for (const skill of skills) {
+        lines.push(`  ✓ ${skill.name}`);
+      }
+    }
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["__tests__/**/*.test.ts"],
+    exclude: ["node_modules", "dist", ".idea", ".git", ".cache"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: ["node_modules/", "**/*.d.ts", "**/*.test.ts"],
+    },
+  },
+});