pi-skillful 0.3.4 → 0.3.6

package/CHANGELOG.md

@@ -6,6 +6,19 @@ This project follows the spirit of [Keep a Changelog](https://keepachangelog.com
 
 ## [Unreleased]
 
+## [0.3.6] - 2026-05-12
+
+### Changed
+
+- Made project skill visibility and toggle slots inherit global settings until the project scope is explicitly changed.
+- Added `/skillful` menu support for assigning session toggle slots in global or project scope.
+
+## [0.3.5] - 2026-05-12
+
+### Fixed
+
+- Fixed preserving session skill toggle state across `/new` after Pi reloads extension instances.
+
 ## [0.3.4] - 2026-05-12
 
 ### Changed

package/README.md

@@ -52,7 +52,7 @@ Supported scopes:
 - Global: `~/.pi/agent/settings.json`
 - Project: `.pi/settings.json`
 
-Effective hidden skills are the union of global and project `hiddenSkills`.
+Project visibility and toggle slots inherit global settings until changed in the Project tab. When either is changed, Pi Skillful writes a full project override containing both `hiddenSkills` and `toggleSlots`. If the project state is changed back to match global, those project override keys are removed so the project inherits global again.
 
 Open the menu with:
 
@@ -60,7 +60,7 @@ Open the menu with:
 /skillful
 ```
 
-The menu lists all loaded skills alphabetically. Toggle a skill off to save it in the active scope's `hiddenSkills` list. Use the Global/Project tabs to choose which settings file to edit.
+The menu lists all loaded skills alphabetically. Toggle a skill off or on in the active scope. Use the Global/Project tabs to choose which settings file to edit. In the Project tab, inherited on/off values are shown normally; project overrides are highlighted. Press `1` through `9` on a selected skill to assign or clear that scope's session toggle slot. Visibility and toggle slots are independent.
 
 Pi's startup `[Skills]` list also highlights hidden skills in the error color (red in the default dark theme).
 
@@ -84,7 +84,7 @@ Assign skills to up to nine prompt-editor slots with JSON settings:
 }
 ```
 
-Configured slots appear on the prompt editor's top border as `N skill-name`. Long names are truncated per slot when needed so all configured slot numbers remain visible. Active slots use the theme accent color; inactive slots use the muted color. Press `alt+1` through `alt+9` by default to toggle a slot for the current session only.
+Configured slots appear on the prompt editor's top border as `N skill-name`. Project `toggleSlots`, when defined as part of a project override, replace global `toggleSlots`; otherwise global slots are used and shown in the Project tab. Long names are truncated per slot when needed so all configured slot numbers remain visible. Active slots use the theme accent color; inactive slots use the muted color. Press `alt+1` through `alt+9` by default to toggle a slot for the current session only.
 
 `toggleModifier` defaults to `"alt"`. Supported values are `"alt"`, `"ctrl"`, `"ctrl+shift"`, `"alt+shift"`, `"ctrl+alt"`, and `"ctrl+alt+shift"`. Change it if your terminal reserves `alt+number` shortcuts.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-skillful",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Pi package with skill invocation and visibility improvements.",
   "type": "module",
   "license": "MIT",

package/src/config.ts

@@ -21,6 +21,9 @@ export interface SkillToggleConfig {
 
 export interface SkillfulSettings extends SkillToggleConfig {
   hiddenSkills: string[];
+  hiddenSkillsDefined: boolean;
+  visibleSkills: string[];
+  toggleSlotsDefined: boolean;
 }
 
 export interface EffectiveSkillfulSettings extends SkillfulSettings {
@@ -107,17 +110,7 @@ async function readSettingsDocument(path: string): Promise<PiSettingsDocument> {
 
 export async function readSkillfulSettings(path: string): Promise<SkillfulSettings> {
   const settings = await readSettingsDocument(path);
-  const skillful = settings[SKILLFUL_SETTINGS_KEY];
-  const skillfulObject = skillful && typeof skillful === "object" && !Array.isArray(skillful) ? skillful : {};
-  const hiddenSkills = Array.isArray(skillfulObject.hiddenSkills)
-    ? skillfulObject.hiddenSkills.filter((name): name is string => typeof name === "string")
-    : [];
-
-  return {
-    hiddenSkills: normalizeSkillNames(hiddenSkills),
-    toggleSlots: normalizeToggleSlots(skillfulObject.toggleSlots),
-    toggleModifier: normalizeToggleModifier(skillfulObject.toggleModifier),
-  };
+  return settingsFromRecord(settings[SKILLFUL_SETTINGS_KEY]);
 }
 
 export async function readScopedSkillfulSettings(cwd: string): Promise<Record<SkillfulScope, SkillfulSettings>> {
@@ -130,17 +123,20 @@ export async function readScopedSkillfulSettings(cwd: string): Promise<Record<Sk
 
 export async function readEffectiveHiddenSkills(cwd: string): Promise<Set<string>> {
   const scoped = await readScopedSkillfulSettings(cwd);
-  return new Set([...scoped.global.hiddenSkills, ...scoped.project.hiddenSkills]);
+  return effectiveHiddenSkillSet(scoped);
 }
 
 export async function readEffectiveSkillfulSettings(cwd: string): Promise<EffectiveSkillfulSettings> {
   const scoped = await readScopedSkillfulSettings(cwd);
-  const hiddenSkills = normalizeSkillNames([...scoped.global.hiddenSkills, ...scoped.project.hiddenSkills]);
-  const toggleSlots = normalizeToggleSlots({ ...scoped.global.toggleSlots, ...scoped.project.toggleSlots });
+  const hiddenSkills = normalizeSkillNames(effectiveHiddenSkillSet(scoped));
+  const toggleSlots = scoped.project.toggleSlotsDefined ? scoped.project.toggleSlots : scoped.global.toggleSlots;
   return {
     hiddenSkills,
+    hiddenSkillsDefined: scoped.global.hiddenSkillsDefined || scoped.project.hiddenSkillsDefined,
+    visibleSkills: [],
     hiddenSkillSet: new Set(hiddenSkills),
     toggleSlots,
+    toggleSlotsDefined: scoped.global.toggleSlotsDefined || scoped.project.toggleSlotsDefined,
     toggleModifier:
       scoped.project.toggleModifier !== DEFAULT_TOGGLE_MODIFIER ? scoped.project.toggleModifier : scoped.global.toggleModifier,
   };
@@ -150,28 +146,69 @@ export async function writeHiddenSkills(
   scope: SkillfulScope,
   cwd: string,
   hiddenSkills: Iterable<string>,
+): Promise<SkillfulSettings> {
+  return updateSkillfulSettings(scope, cwd, (current) => {
+    current.hiddenSkills = normalizeSkillNames(hiddenSkills);
+  });
+}
+
+export async function writeSkillVisibility(
+  scope: SkillfulScope,
+  cwd: string,
+  hiddenSkills: Iterable<string>,
+  visibleSkills: Iterable<string> = [],
+): Promise<SkillfulSettings> {
+  return updateSkillfulSettings(scope, cwd, (current) => {
+    const visible = normalizeSkillNames(visibleSkills);
+    current.hiddenSkills = normalizeSkillNames(hiddenSkills);
+    if (visible.length === 0) delete current.visibleSkills;
+    else current.visibleSkills = visible;
+  });
+}
+
+export async function writeToggleSlots(
+  scope: SkillfulScope,
+  cwd: string,
+  toggleSlots: Partial<Record<SkillToggleSlot, string>>,
+): Promise<SkillfulSettings> {
+  return updateSkillfulSettings(scope, cwd, (current) => {
+    current.toggleSlots = normalizeToggleSlots(toggleSlots);
+  });
+}
+
+export async function writeProjectSkillfulOverride(
+  cwd: string,
+  hiddenSkills: Iterable<string> | undefined,
+  toggleSlots: Partial<Record<SkillToggleSlot, string>> | undefined,
+): Promise<SkillfulSettings> {
+  return updateSkillfulSettings("project", cwd, (current) => {
+    delete current.visibleSkills;
+    if (hiddenSkills === undefined) delete current.hiddenSkills;
+    else current.hiddenSkills = normalizeSkillNames(hiddenSkills);
+    if (toggleSlots === undefined) delete current.toggleSlots;
+    else current.toggleSlots = normalizeToggleSlots(toggleSlots);
+  });
+}
+
+async function updateSkillfulSettings(
+  scope: SkillfulScope,
+  cwd: string,
+  updater: (current: Record<string, unknown>) => void,
 ): Promise<SkillfulSettings> {
   const path = settingsPath(scope, cwd);
   const document = await readSettingsDocument(path);
-  const updated = normalizeSkillNames(hiddenSkills);
 
   const existingSkillful =
     document[SKILLFUL_SETTINGS_KEY] && typeof document[SKILLFUL_SETTINGS_KEY] === "object" && !Array.isArray(document[SKILLFUL_SETTINGS_KEY])
       ? (document[SKILLFUL_SETTINGS_KEY] as Record<string, unknown>)
       : {};
   const nextSkillful = { ...existingSkillful };
-
-  if (updated.length === 0) delete nextSkillful.hiddenSkills;
-  else nextSkillful.hiddenSkills = updated;
+  updater(nextSkillful);
 
   if (Object.keys(nextSkillful).length === 0) delete document[SKILLFUL_SETTINGS_KEY];
   else document[SKILLFUL_SETTINGS_KEY] = nextSkillful as Partial<SkillfulSettings>;
 
-  const result: SkillfulSettings = {
-    hiddenSkills: updated,
-    toggleSlots: normalizeToggleSlots(nextSkillful.toggleSlots),
-    toggleModifier: normalizeToggleModifier(nextSkillful.toggleModifier),
-  };
+  const result = settingsFromRecord(nextSkillful);
 
   if (scope === "project" && Object.keys(document).length === 0) {
     await unlinkIfExists(path);
@@ -193,6 +230,27 @@ export async function updateHiddenSkills(
   return writeHiddenSkills(scope, cwd, updater(current.hiddenSkills));
 }
 
+function settingsFromRecord(value: unknown): SkillfulSettings {
+  const skillful = value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+
+  return {
+    hiddenSkills: normalizeSkillNames(stringArray(skillful.hiddenSkills)),
+    hiddenSkillsDefined: Object.hasOwn(skillful, "hiddenSkills"),
+    visibleSkills: normalizeSkillNames(stringArray(skillful.visibleSkills)),
+    toggleSlots: normalizeToggleSlots(skillful.toggleSlots),
+    toggleSlotsDefined: Object.hasOwn(skillful, "toggleSlots"),
+    toggleModifier: normalizeToggleModifier(skillful.toggleModifier),
+  };
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
+}
+
+function effectiveHiddenSkillSet(scoped: Record<SkillfulScope, SkillfulSettings>): Set<string> {
+  return new Set(scoped.project.hiddenSkillsDefined ? scoped.project.hiddenSkills : scoped.global.hiddenSkills);
+}
+
 async function unlinkIfExists(path: string): Promise<void> {
   try {
     await unlink(path);

package/src/extensions/session-skill-toggles.ts

@@ -14,6 +14,7 @@ import { replaceSkillsSection } from "../skill-prompt.js";
 import { listLoadedSkills } from "../skills.js";
 
 const WIDGET_KEY = "pi-skillful-session-toggles";
+const STORE_KEY = Symbol.for("pi-skillful.sessionSkillTogglesStore");
 const BORDER_PREFIX = "─── ";
 const BORDER_SUFFIX = " ";
 const BORDER_PREFIX_WIDTH = visibleWidth(BORDER_PREFIX);
@@ -38,8 +39,15 @@ interface SessionToggleState {
   theme: Theme | undefined;
 }
 
+interface SessionToggleStore {
+  preservedNewSessionActiveBySkill: { cwd: string; activeBySkill: Map<string, boolean> } | undefined;
+}
+
+const store = (((globalThis as Record<PropertyKey, unknown>)[STORE_KEY] as SessionToggleStore | undefined) ??= {
+  preservedNewSessionActiveBySkill: undefined,
+}) as SessionToggleStore;
+
 let state: SessionToggleState = createEmptyState();
-let preservedNewSessionActiveBySkill: { cwd: string; activeBySkill: Map<string, boolean> } | undefined;
 
 export default function sessionSkillToggles(pi: ExtensionAPI) {
   for (const modifier of SUPPORTED_TOGGLE_MODIFIERS) {
@@ -56,18 +64,13 @@ export default function sessionSkillToggles(pi: ExtensionAPI) {
 
   pi.on("session_start", async (event, ctx) => {
     const settings = await readEffectiveSkillfulSettings(ctx.cwd);
-    const loadedSkillNames = new Set(listLoadedSkills(pi.getCommands()).map((s) => s.name));
-    const slots = SKILL_TOGGLE_SLOTS.flatMap((slot): ToggleSlotState[] => {
-      const skillName = settings.toggleSlots[slot];
-      if (!skillName || !loadedSkillNames.has(skillName)) return [];
-      return [{ slot, skillName }];
-    });
+    const slots = configuredToggleSlots(pi, settings.toggleSlots);
 
     const preservedActiveBySkill =
-      event.reason === "new" && preservedNewSessionActiveBySkill?.cwd === ctx.cwd
-        ? preservedNewSessionActiveBySkill.activeBySkill
+      event.reason === "new" && store.preservedNewSessionActiveBySkill?.cwd === ctx.cwd
+        ? store.preservedNewSessionActiveBySkill.activeBySkill
         : undefined;
-    preservedNewSessionActiveBySkill = undefined;
+    store.preservedNewSessionActiveBySkill = undefined;
 
     state = {
       cwd: ctx.cwd,
@@ -107,7 +110,7 @@ export default function sessionSkillToggles(pi: ExtensionAPI) {
   pi.on("session_shutdown", (event, ctx) => {
     if (state.installedEditor) ctx.ui.setEditorComponent(state.previousEditorFactory);
     if (state.installedWidget) ctx.ui.setWidget(WIDGET_KEY, undefined);
-    preservedNewSessionActiveBySkill =
+    store.preservedNewSessionActiveBySkill =
       event.reason === "new" ? { cwd: state.cwd, activeBySkill: new Map(state.activeBySkill) } : undefined;
     state = createEmptyState();
   });
@@ -132,6 +135,43 @@ export function hasActiveSessionSkillToggles(): boolean {
   return state.slots.length > 0;
 }
 
+export async function refreshSessionSkillToggles(pi: ExtensionAPI, cwd: string, ui: SkillfulUi): Promise<void> {
+  const settings = await readEffectiveSkillfulSettings(cwd);
+  const slots = configuredToggleSlots(pi, settings.toggleSlots);
+
+  const previousActiveBySkill = state.activeBySkill;
+  state.modifier = settings.toggleModifier;
+  state.hiddenSkills = settings.hiddenSkillSet;
+  state.slots = slots;
+  state.activeBySkill = new Map(
+    slots.map(({ skillName }) => [skillName, previousActiveBySkill.get(skillName) ?? !settings.hiddenSkillSet.has(skillName)]),
+  );
+
+  if (slots.length > 0 && !state.installedEditor && !state.installedWidget) {
+    installEditor(ui);
+  } else if (slots.length === 0) {
+    if (state.installedEditor) ui.setEditorComponent(state.previousEditorFactory);
+    if (state.installedWidget) ui.setWidget(WIDGET_KEY, undefined);
+    state.installedEditor = false;
+    state.installedWidget = false;
+    state.previousEditorFactory = undefined;
+  }
+
+  refreshUi();
+}
+
+function configuredToggleSlots(
+  pi: ExtensionAPI,
+  toggleSlots: Partial<Record<SkillToggleSlot, string>>,
+): ToggleSlotState[] {
+  const loadedSkillNames = new Set(listLoadedSkills(pi.getCommands()).map((skill) => skill.name));
+  return SKILL_TOGGLE_SLOTS.flatMap((slot): ToggleSlotState[] => {
+    const skillName = toggleSlots[slot];
+    if (!skillName || !loadedSkillNames.has(skillName)) return [];
+    return [{ slot, skillName }];
+  });
+}
+
 function isSkillActive(skillName: string): boolean {
   return state.activeBySkill.get(skillName) ?? !state.hiddenSkills.has(skillName);
 }

package/src/extensions/skill-visibility.ts

@@ -12,12 +12,16 @@ import {
   normalizeSkillNames,
   readEffectiveHiddenSkills,
   readScopedSkillfulSettings,
+  SKILL_TOGGLE_SLOTS,
   type SkillfulScope,
+  type SkillToggleSlot,
   writeHiddenSkills,
+  writeProjectSkillfulOverride,
+  writeToggleSlots,
 } from "../config.js";
 import { replaceSkillsSection } from "../skill-prompt.js";
 import { listLoadedSkills, type LoadedSkillInfo } from "../skills.js";
-import { hasActiveSessionSkillToggles } from "./session-skill-toggles.js";
+import { hasActiveSessionSkillToggles, refreshSessionSkillToggles } from "./session-skill-toggles.js";
 const SCOPES: SkillfulScope[] = ["global", "project"];
 const STORE_KEY = Symbol.for("pi-skillful.skillVisibilityStore");
 const STARTUP_PATCH_KEY = Symbol.for("pi-skillful.startupPatchV2");
@@ -51,6 +55,30 @@ const store = (((globalThis as Record<PropertyKey, unknown>)[STORE_KEY] as Skill
 }) as SkillVisibilityStore;
 
 type SkillListItem = LoadedSkillInfo;
+type HiddenSkillsByScope = Record<SkillfulScope, Set<string>>;
+type ToggleSlotsByScope = Record<SkillfulScope, Partial<Record<SkillToggleSlot, string>>>;
+type DefinedByScope = Record<SkillfulScope, boolean>;
+
+interface SkillfulVisibilityMenuOptions {
+  cwd: string;
+  skills: SkillListItem[];
+  hiddenByScope: HiddenSkillsByScope;
+  hiddenSkillsDefinedByScope: DefinedByScope;
+  toggleSlotsByScope: ToggleSlotsByScope;
+  toggleSlotsDefinedByScope: DefinedByScope;
+  theme: Theme;
+  tui: TUI;
+  notify: (message: string, type?: "info" | "warning" | "error") => void;
+  onToggleSlotsChanged: () => Promise<void>;
+  done: () => void;
+}
+
+interface SettingsListSelectionView {
+  filteredItems?: SettingItem[];
+  items?: SettingItem[];
+  selectedIndex?: number;
+  submenuComponent?: unknown;
+}
 
 export default function skillVisibility(pi: ExtensionAPI) {
   installStartupSkillListPatch();
@@ -97,9 +125,22 @@ export default function skillVisibility(pi: ExtensionAPI) {
             global: new Set(scoped.global.hiddenSkills),
             project: new Set(scoped.project.hiddenSkills),
           },
+          hiddenSkillsDefinedByScope: {
+            global: scoped.global.hiddenSkillsDefined,
+            project: scoped.project.hiddenSkillsDefined,
+          },
+          toggleSlotsByScope: {
+            global: { ...scoped.global.toggleSlots },
+            project: { ...scoped.project.toggleSlots },
+          },
+          toggleSlotsDefinedByScope: {
+            global: scoped.global.toggleSlotsDefined,
+            project: scoped.project.toggleSlotsDefined,
+          },
           theme,
           tui,
           notify: (message, type) => ctx.ui.notify(message, type),
+          onToggleSlotsChanged: () => refreshSessionSkillToggles(pi, ctx.cwd, ctx.ui),
           done,
         }),
       );
@@ -113,15 +154,15 @@ async function pruneStaleHiddenSkills(pi: ExtensionAPI, cwd: string): Promise<vo
 
   await Promise.all(
     SCOPES.map(async (scope) => {
-      const current = scoped[scope].hiddenSkills;
-      const pruned = current.filter((name) => installedNames.has(name));
-      if (pruned.length < current.length) {
-        scoped[scope] = await writeHiddenSkills(scope, cwd, pruned);
+      const currentHidden = scoped[scope].hiddenSkills;
+      const prunedHidden = currentHidden.filter((name) => installedNames.has(name));
+      if (prunedHidden.length < currentHidden.length) {
+        scoped[scope] = await writeHiddenSkills(scope, cwd, prunedHidden);
       }
     }),
   );
 
-  const hidden = new Set([...scoped.global.hiddenSkills, ...scoped.project.hiddenSkills]);
+  const hidden = new Set(scoped.project.hiddenSkillsDefined ? scoped.project.hiddenSkills : scoped.global.hiddenSkills);
   store.hiddenSkillsByCwd.set(cwd, hidden);
   store.lastHiddenSkills = hidden;
 }
@@ -204,10 +245,14 @@ function getSkillItems(pi: ExtensionAPI): SkillListItem[] {
 class SkillfulVisibilityMenu implements Component {
   private readonly cwd: string;
   private readonly skills: SkillListItem[];
-  private readonly hiddenByScope: Record<SkillfulScope, Set<string>>;
+  private readonly hiddenByScope: HiddenSkillsByScope;
+  private readonly hiddenSkillsDefinedByScope: DefinedByScope;
+  private readonly toggleSlotsByScope: ToggleSlotsByScope;
+  private readonly toggleSlotsDefinedByScope: DefinedByScope;
   private readonly theme: Theme;
   private readonly tui: TUI;
   private readonly notify: (message: string, type?: "info" | "warning" | "error") => void;
+  private readonly onToggleSlotsChanged: () => Promise<void>;
   private readonly done: () => void;
   private readonly topBorder: DynamicBorder;
   private readonly bottomBorder: DynamicBorder;
@@ -215,21 +260,17 @@ class SkillfulVisibilityMenu implements Component {
   private settingsList: SettingsList;
   private saveQueue: Promise<void> = Promise.resolve();
 
-  constructor(options: {
-    cwd: string;
-    skills: SkillListItem[];
-    hiddenByScope: Record<SkillfulScope, Set<string>>;
-    theme: Theme;
-    tui: TUI;
-    notify: (message: string, type?: "info" | "warning" | "error") => void;
-    done: () => void;
-  }) {
+  constructor(options: SkillfulVisibilityMenuOptions) {
     this.cwd = options.cwd;
     this.skills = options.skills;
     this.hiddenByScope = options.hiddenByScope;
+    this.hiddenSkillsDefinedByScope = options.hiddenSkillsDefinedByScope;
+    this.toggleSlotsByScope = options.toggleSlotsByScope;
+    this.toggleSlotsDefinedByScope = options.toggleSlotsDefinedByScope;
     this.theme = options.theme;
     this.tui = options.tui;
     this.notify = options.notify;
+    this.onToggleSlotsChanged = options.onToggleSlotsChanged;
     this.done = options.done;
     this.topBorder = new DynamicBorder((text: string) => this.theme.fg("accent", text));
     this.bottomBorder = new DynamicBorder((text: string) => this.theme.fg("accent", text));
@@ -244,7 +285,7 @@ class SkillfulVisibilityMenu implements Component {
       "",
       ...this.settingsList.render(width),
       "",
-      truncateToWidth(this.theme.fg("dim", "  Tab/←/→ switch global/project · Enter/Space toggle · Esc close"), width),
+      truncateToWidth(this.theme.fg("dim", "  Tab/←/→ switch scope · 1-9 assign/clear toggle · Enter/Space on/off · Esc close"), width),
       ...this.bottomBorder.render(width),
     ];
   }
@@ -258,6 +299,10 @@ class SkillfulVisibilityMenu implements Component {
       this.switchScope(-1);
       return;
     }
+    if (/^[1-9]$/.test(data)) {
+      this.toggleSelectedSkillSlot(data as SkillToggleSlot);
+      return;
+    }
 
     this.settingsList.handleInput(data);
     this.tui.requestRender();
@@ -289,13 +334,13 @@ class SkillfulVisibilityMenu implements Component {
 
   private createSettingsList(): SettingsList {
     const items: SettingItem[] = this.skills.map((skill) => {
-      const hidden = this.hiddenByScope[this.scope].has(skill.name);
+      const hidden = this.isHidden(this.scope, skill.name);
       return {
         id: skill.name,
         label: skill.name,
-        description: skill.description || "No skill description provided.",
-        currentValue: hidden ? "off" : "on",
-        values: ["on", "off"],
+        description: `${skill.description || "No skill description provided."}\nPress 1-9 to assign or clear this skill's toggle slot in the ${this.scope} scope.`,
+        currentValue: this.skillValue(skill.name, hidden),
+        values: [this.skillValue(skill.name, false), this.skillValue(skill.name, true)],
       };
     });
 
@@ -303,27 +348,169 @@ class SkillfulVisibilityMenu implements Component {
       items,
       12,
       getSettingsListTheme(),
-      (skillName, newValue) => {
-        const hidden = this.hiddenByScope[this.scope];
-        if (newValue === "off") hidden.add(skillName);
-        else hidden.delete(skillName);
+      (id, newValue) => {
+        this.setHidden(this.scope, id, newValue.includes("off"));
+        this.settingsList.updateValue(id, this.skillValue(id, this.isHidden(this.scope, id)));
         this.persistScope(this.scope);
       },
-      this.done,
+      () => this.close(),
       { enableSearch: true },
     );
   }
 
+  private isHidden(scope: SkillfulScope, skillName: string): boolean {
+    if (scope === "project" && !this.hiddenSkillsDefinedByScope.project) return this.hiddenByScope.global.has(skillName);
+    return this.hiddenByScope[scope].has(skillName);
+  }
+
+  private setHidden(scope: SkillfulScope, skillName: string, hidden: boolean): void {
+    const hiddenSkills = scope === "project" ? this.ensureFullProjectOverride().hiddenSkills : this.ensureWritableHiddenSkills(scope);
+    if (hidden) hiddenSkills.add(skillName);
+    else hiddenSkills.delete(skillName);
+  }
+
+  private ensureWritableHiddenSkills(scope: SkillfulScope): Set<string> {
+    if (scope === "global") this.hiddenSkillsDefinedByScope.global = true;
+    return this.hiddenByScope[scope];
+  }
+
+  private ensureFullProjectOverride(): { hiddenSkills: Set<string>; toggleSlots: Partial<Record<SkillToggleSlot, string>> } {
+    if (!this.hiddenSkillsDefinedByScope.project) {
+      this.hiddenByScope.project = new Set(this.hiddenByScope.global);
+      this.hiddenSkillsDefinedByScope.project = true;
+    }
+    if (!this.toggleSlotsDefinedByScope.project) {
+      this.toggleSlotsByScope.project = { ...this.toggleSlotsByScope.global };
+      this.toggleSlotsDefinedByScope.project = true;
+    }
+    return { hiddenSkills: this.hiddenByScope.project, toggleSlots: this.toggleSlotsByScope.project };
+  }
+
+  private skillValue(skillName: string, hidden: boolean): string {
+    const slot = SKILL_TOGGLE_SLOTS.find((candidate) => this.currentToggleSlots()[candidate] === skillName) ?? "";
+    const status = (hidden ? "off" : "on").padEnd(3, " ");
+    const statusText = this.isProjectOverride(skillName) ? this.theme.fg("accent", status) : status;
+    return `${statusText}   ${slot}`;
+  }
+
+  private currentToggleSlots(): Partial<Record<SkillToggleSlot, string>> {
+    if (this.scope === "project" && !this.toggleSlotsDefinedByScope.project) return this.toggleSlotsByScope.global;
+    return this.toggleSlotsByScope[this.scope];
+  }
+
+  private ensureWritableToggleSlots(scope: SkillfulScope): Partial<Record<SkillToggleSlot, string>> {
+    if (scope === "project") return this.ensureFullProjectOverride().toggleSlots;
+    this.toggleSlotsDefinedByScope.global = true;
+    return this.toggleSlotsByScope.global;
+  }
+
+  private isProjectOverride(skillName: string): boolean {
+    if (this.scope !== "project") return false;
+    return this.isHidden("project", skillName) !== this.isHidden("global", skillName);
+  }
+
+  private toggleSelectedSkillSlot(slot: SkillToggleSlot): void {
+    const skillName = this.selectedSkillName();
+    if (!skillName) return;
+
+    const toggleSlots = this.ensureWritableToggleSlots(this.scope);
+    const affected = new Set<string>([skillName]);
+    const previousSkill = toggleSlots[slot];
+    if (previousSkill) affected.add(previousSkill);
+
+    if (previousSkill === skillName) {
+      delete toggleSlots[slot];
+    } else {
+      for (const candidate of SKILL_TOGGLE_SLOTS) {
+        if (toggleSlots[candidate] === skillName) delete toggleSlots[candidate];
+      }
+      toggleSlots[slot] = skillName;
+    }
+
+    for (const affectedSkill of affected) {
+      this.settingsList.updateValue(affectedSkill, this.skillValue(affectedSkill, this.isHidden(this.scope, affectedSkill)));
+    }
+    this.persistToggleSlots(this.scope);
+    this.tui.requestRender();
+  }
+
+  private selectedSkillName(): string | undefined {
+    const list = this.settingsList as unknown as SettingsListSelectionView;
+    if (list.submenuComponent) return undefined;
+    const items = list.filteredItems ?? list.items ?? [];
+    const selectedIndex = list.selectedIndex ?? 0;
+    return items[selectedIndex]?.id;
+  }
+
   private persistScope(scope: SkillfulScope): void {
-    const snapshot = normalizeSkillNames(this.hiddenByScope[scope]);
+    const hiddenSnapshot = normalizeSkillNames(this.hiddenByScope[scope]);
     this.saveQueue = this.saveQueue
       .catch(() => undefined)
       .then(async () => {
-        await writeHiddenSkills(scope, this.cwd, snapshot);
+        if (scope === "project") await this.writeProjectOverrideOrInheritance();
+        else await writeHiddenSkills(scope, this.cwd, hiddenSnapshot);
         await refreshHiddenSkillCache(this.cwd);
       })
       .catch((error) => {
         this.notify(`Failed to save ${scope} skill visibility: ${error instanceof Error ? error.message : String(error)}`, "error");
       });
   }
+
+  private persistToggleSlots(scope: SkillfulScope): void {
+    const snapshot = { ...this.toggleSlotsByScope[scope] };
+    this.saveQueue = this.saveQueue
+      .catch(() => undefined)
+      .then(async () => {
+        if (scope === "project") await this.writeProjectOverrideOrInheritance();
+        else await writeToggleSlots(scope, this.cwd, snapshot);
+      })
+      .catch((error) => {
+        this.notify(`Failed to save ${scope} skill toggles: ${error instanceof Error ? error.message : String(error)}`, "error");
+      });
+  }
+
+  private close(): void {
+    this.saveQueue = this.saveQueue
+      .catch(() => undefined)
+      .then(() => this.onToggleSlotsChanged())
+      .catch((error) => {
+        this.notify(`Failed to refresh session skill toggles: ${error instanceof Error ? error.message : String(error)}`, "error");
+      })
+      .finally(() => this.done());
+  }
+
+  private async writeProjectOverrideOrInheritance(): Promise<void> {
+    if (this.projectMatchesGlobal()) {
+      this.hiddenSkillsDefinedByScope.project = false;
+      this.toggleSlotsDefinedByScope.project = false;
+      await writeProjectSkillfulOverride(this.cwd, undefined, undefined);
+      return;
+    }
+
+    this.hiddenSkillsDefinedByScope.project = true;
+    this.toggleSlotsDefinedByScope.project = true;
+    await writeProjectSkillfulOverride(this.cwd, this.hiddenByScope.project, this.toggleSlotsByScope.project);
+  }
+
+  private projectMatchesGlobal(): boolean {
+    return setsEqual(this.hiddenByScope.project, this.hiddenByScope.global) && toggleSlotsEqual(this.toggleSlotsByScope.project, this.toggleSlotsByScope.global);
+  }
+}
+
+function setsEqual(a: Set<string>, b: Set<string>): boolean {
+  if (a.size !== b.size) return false;
+  for (const value of a) {
+    if (!b.has(value)) return false;
+  }
+  return true;
+}
+
+function toggleSlotsEqual(
+  a: Partial<Record<SkillToggleSlot, string>>,
+  b: Partial<Record<SkillToggleSlot, string>>,
+): boolean {
+  for (const slot of SKILL_TOGGLE_SLOTS) {
+    if (a[slot] !== b[slot]) return false;
+  }
+  return true;
 }