@dealdeploy/skl 0.1.6 → 0.1.8

package/index.ts

@@ -17,11 +17,15 @@ import {
   mkdirSync,
   existsSync,
   rmSync,
+  renameSync,
+  cpSync,
+  readSync,
 } from "fs";
 import { join, resolve } from "path";
 import { homedir } from "os";
 
-const VERSION = "0.1.5";
+// @ts-ignore - bun supports JSON imports
+const { version: VERSION } = await import("./package.json");
 
 // ── Flags ────────────────────────────────────────────────────────────
 const arg = process.argv[2];
@@ -35,6 +39,10 @@ if (arg === "add") {
   await import("./add.ts");
   process.exit(0);
 }
+if (arg === "update") {
+  await import("./update.ts");
+  process.exit(0);
+}
 
 try {
 
@@ -42,6 +50,7 @@ try {
 
 const LIBRARY = join(homedir(), "dotfiles/skills");
 const GLOBAL_DIR = join(homedir(), ".agents/skills");
+const GLOBAL_CLAUDE_DIR = join(homedir(), ".claude/skills");
 
 if (!existsSync(LIBRARY)) {
   console.error(`skl: library not found at ${LIBRARY}`);
@@ -56,15 +65,17 @@ function ellipsize(text: string, max: number): string {
   return `${text.slice(0, max - 1)}…`;
 }
 
-// Safety: ensure GLOBAL_DIR is a real directory, not a symlink to the library
-try {
-  if (lstatSync(GLOBAL_DIR).isSymbolicLink()) {
-    console.error(`ERROR: ${GLOBAL_DIR} is a symlink — it must be a real directory.`);
-    console.error("Remove it and create a real directory: rm ~/.agents/skills && mkdir ~/.agents/skills");
-    process.exit(1);
+// Safety: ensure skill dirs aren't symlinks pointing at the library itself
+for (const [dir, label] of [[GLOBAL_DIR, "~/.agents/skills"], [GLOBAL_CLAUDE_DIR, "~/.claude/skills"]] as const) {
+  try {
+    if (lstatSync(dir).isSymbolicLink() && resolve(readlinkSync(dir)) === resolve(LIBRARY)) {
+      console.error(`ERROR: ${label} is a symlink to the library — it must be a real directory.`);
+      console.error(`Remove it and create a real directory: rm ${label} && mkdir ${label}`);
+      process.exit(1);
+    }
+  } catch {
+    // doesn't exist yet, that's fine — toggle will mkdir
   }
-} catch {
-  // doesn't exist yet, that's fine — toggle will mkdir
 }
 
 function isLibraryLink(dir: string, name: string): boolean {
@@ -88,8 +99,35 @@ function nonLibraryExists(dir: string, name: string): boolean {
   }
 }
 
+function isLocalDir(dir: string): boolean {
+  return dir !== GLOBAL_DIR && dir !== GLOBAL_CLAUDE_DIR;
+}
+
+function isEnabled(dir: string, name: string): boolean {
+  if (isLocalDir(dir)) return existsSync(join(dir, name));
+  return isLibraryLink(dir, name);
+}
+
+function isBlocked(dir: string, name: string): boolean {
+  if (isLocalDir(dir)) return false;
+  return nonLibraryExists(dir, name);
+}
+
 function toggle(dir: string, name: string): boolean {
   const full = join(dir, name);
+  if (isLocalDir(dir)) {
+    // Copy-based toggle for project-local dirs
+    if (existsSync(full)) {
+      rmSync(full, { recursive: true, force: true });
+      return true;
+    }
+    // Remove any broken symlink left from old behavior
+    try { rmSync(full, { force: true }); } catch {}
+    mkdirSync(dir, { recursive: true });
+    cpSync(join(LIBRARY, name), full, { recursive: true });
+    return true;
+  }
+  // Symlink-based toggle for global dirs
   if (isLibraryLink(dir, name)) {
     unlinkSync(full);
     return true;
@@ -114,23 +152,163 @@ function ensureLocalDir(): string {
   mkdirSync(dir, { recursive: true });
   localDir = dir;
   localLabel = dir.replace(homedir(), "~");
-  colLocal.content = ellipsize(localLabel, 20);
+  colLocal.content = ellipsize(localLabel, COL_W - 1);
   refreshAll();
   return dir;
 }
 
+function findLocalClaudeDir(): string | null {
+  const dir = join(process.cwd(), ".claude/skills");
+  if (existsSync(dir)) return dir;
+  return null;
+}
+
+function ensureLocalClaudeDir(): string {
+  if (localClaudeDir) return localClaudeDir;
+  const dir = join(process.cwd(), ".claude/skills");
+  mkdirSync(dir, { recursive: true });
+  localClaudeDir = dir;
+  localClaudeLabel = dir.replace(homedir(), "~");
+  colLocalClaude.content = ellipsize(localClaudeLabel, COL_W - 1);
+  refreshAll();
+  return dir;
+}
+
+// ── Migration check ──────────────────────────────────────────────────
+{
+  // Only migrate global dirs — project-local dirs use copies, not symlinks
+  const dirsToCheck: [string, string][] = [
+    [GLOBAL_DIR, "~/.agents/skills"],
+    [GLOBAL_CLAUDE_DIR, "~/.claude/skills"],
+  ];
+
+  const migrations: { dir: string; label: string; name: string; conflict: boolean }[] = [];
+
+  for (const [dir, label] of dirsToCheck) {
+    try {
+      for (const name of readdirSync(dir)) {
+        if (!isLibraryLink(dir, name)) {
+          migrations.push({ dir, label, name, conflict: existsSync(join(LIBRARY, name)) });
+        }
+      }
+    } catch {
+      // dir doesn't exist
+    }
+  }
+
+  if (migrations.length > 0) {
+    console.log("\nFound skills not managed by library:");
+    for (const m of migrations) {
+      console.log(`  ${m.label}/${m.name}${m.conflict ? "  (already in library)" : ""}`);
+    }
+    process.stdout.write(`\nMigrate to ${LIBRARY.replace(homedir(), "~")} and replace with symlinks? [y/N] `);
+
+    const buf = new Uint8Array(100);
+    const n = readSync(0, buf);
+    const answer = new TextDecoder().decode(buf.subarray(0, n)).trim().toLowerCase();
+
+    if (answer === "y" || answer === "yes") {
+      let migrated = 0;
+      for (const m of migrations) {
+        const src = join(m.dir, m.name);
+        const dest = join(LIBRARY, m.name);
+        if (m.conflict) {
+          // Library already has this skill — remove local and symlink to library
+          rmSync(src, { recursive: true, force: true });
+          symlinkSync(dest, src);
+          console.log(`  replaced ${m.name} (library version kept)`);
+        } else {
+          try {
+            renameSync(src, dest);
+          } catch {
+            // cross-device fallback
+            cpSync(src, dest, { recursive: true });
+            rmSync(src, { recursive: true, force: true });
+          }
+          symlinkSync(dest, src);
+          console.log(`  migrated ${m.name}`);
+        }
+        migrated++;
+      }
+      console.log(`\n${migrated} migrated\n`);
+    } else {
+      console.log("Skipping migration.\n");
+    }
+  }
+}
+
+// ── Local symlink → copy conversion ─────────────────────────────────
+{
+  const localDirsToCheck: [string, string][] = [];
+  const ld = findLocalDir();
+  if (ld) localDirsToCheck.push([ld, ld.replace(homedir(), "~")]);
+  const lcd = findLocalClaudeDir();
+  if (lcd) localDirsToCheck.push([lcd, lcd.replace(homedir(), "~")]);
+
+  const localSymlinks: { dir: string; label: string; name: string; target: string }[] = [];
+
+  for (const [dir, label] of localDirsToCheck) {
+    try {
+      for (const name of readdirSync(dir)) {
+        const full = join(dir, name);
+        try {
+          if (lstatSync(full).isSymbolicLink()) {
+            localSymlinks.push({ dir, label, name, target: readlinkSync(full) });
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+
+  if (localSymlinks.length > 0) {
+    console.log("\nFound symlinked skills in project-local dirs:");
+    for (const s of localSymlinks) {
+      console.log(`  ${s.label}/${s.name} → ${s.target}`);
+    }
+    process.stdout.write("\nConvert to local copies? (recommended for portability) [y/N] ");
+
+    const buf = new Uint8Array(100);
+    const n = readSync(0, buf);
+    const answer = new TextDecoder().decode(buf.subarray(0, n)).trim().toLowerCase();
+
+    if (answer === "y" || answer === "yes") {
+      let converted = 0;
+      for (const s of localSymlinks) {
+        const full = join(s.dir, s.name);
+        const libPath = join(LIBRARY, s.name);
+        unlinkSync(full);
+        if (existsSync(libPath)) {
+          cpSync(libPath, full, { recursive: true });
+          console.log(`  converted ${s.name}`);
+          converted++;
+        } else {
+          console.log(`  removed ${s.name} (not in library)`);
+        }
+      }
+      console.log(`\n${converted} converted\n`);
+    } else {
+      console.log("Skipping conversion.\n");
+    }
+  }
+}
+
 const allSkills = readdirSync(LIBRARY).sort();
 
 // ── State ───────────────────────────────────────────────────────────
 
+type ColId = "global" | "globalClaude" | "local" | "localClaude";
+
 let cursor = 0; // index into filteredIndices
-let cursorCol: "global" | "local" = "global";
+let cursorCol: ColId = "global";
+let focusArea: "search" | "grid" = "search";
 let localDir = findLocalDir();
+let localClaudeDir = findLocalClaudeDir();
 let statusTimeout: ReturnType<typeof setTimeout> | null = null;
 let pendingDelete: number | null = null; // allSkills index awaiting confirmation
 const deletedSkills = new Set<number>();
 let searchQuery = "";
 let filteredIndices: number[] = allSkills.map((_, i) => i);
+const COL_ORDER: ColId[] = ["global", "globalClaude", "local", "localClaude"];
 
 // ── Colors ──────────────────────────────────────────────────────────
 
@@ -179,15 +357,22 @@ const outer = new BoxRenderable(renderer, {
   backgroundColor: C.bg,
 });
 
-// Search bar (always visible at top, type-to-filter)
+// Search bar (lives inside scrollBox as the first row)
+const searchRow = new BoxRenderable(renderer, {
+  id: "search-row",
+  flexDirection: "row",
+  height: 1,
+  width: "100%",
+  paddingLeft: 1,
+  backgroundColor: C.rowBg,
+});
 const searchBar = new TextRenderable(renderer, {
   id: "search-bar",
   content: "",
   fg: C.search,
-  width: "100%",
   height: 1,
-  visible: true,
 });
+searchRow.add(searchBar);
 
 const colHeaderRow = new BoxRenderable(renderer, {
   id: "col-header-row",
@@ -196,38 +381,65 @@ const colHeaderRow = new BoxRenderable(renderer, {
   paddingLeft: 1,
 });
 
+let COL_W = 14;
+let NAME_W = 34;
+
+function calcWidths() {
+  const w = process.stdout.columns || 80;
+  COL_W = Math.max(5, Math.min(14, Math.floor((w - 20) / 4)));
+  NAME_W = Math.min(34, Math.max(15, w - COL_W * 4 - 1));
+}
+calcWidths();
+
 const colName = new TextRenderable(renderer, {
   id: "col-name",
   content: "Skill",
   fg: C.fgDim,
   attributes: TextAttributes.BOLD,
-  width: 34,
+  width: NAME_W,
 });
 const colGlobal = new TextRenderable(renderer, {
   id: "col-global",
   content: "~/.agents",
   fg: C.fgDim,
   attributes: TextAttributes.BOLD,
-  width: 12,
+  width: COL_W,
+});
+const colGlobalClaude = new TextRenderable(renderer, {
+  id: "col-global-claude",
+  content: "~/.claude",
+  fg: C.fgDim,
+  attributes: TextAttributes.BOLD,
+  width: COL_W,
 });
-let localLabel = localDir ? localDir.replace(homedir(), "~") : ".agents (n/a)";
-const localLabelHeader = ellipsize(localLabel, 20);
+let localLabel = localDir ? localDir.replace(homedir(), "~") : ".agents/skills";
 const colLocal = new TextRenderable(renderer, {
   id: "col-local",
-  content: localLabelHeader,
+  content: ellipsize(localLabel, COL_W - 1),
   fg: C.fgDim,
   attributes: TextAttributes.BOLD,
-  width: 20,
+  width: COL_W,
+});
+let localClaudeLabel = localClaudeDir ? localClaudeDir.replace(homedir(), "~") : ".claude/skills";
+const colLocalClaude = new TextRenderable(renderer, {
+  id: "col-local-claude",
+  content: ellipsize(localClaudeLabel, COL_W - 1),
+  fg: C.fgDim,
+  attributes: TextAttributes.BOLD,
+  width: COL_W,
 });
 
 colHeaderRow.add(colName);
 colHeaderRow.add(colGlobal);
+colHeaderRow.add(colGlobalClaude);
 colHeaderRow.add(colLocal);
+colHeaderRow.add(colLocalClaude);
 
 const sep = new TextRenderable(renderer, {
   id: "sep",
-  content: "─".repeat(60),
+  content: "─".repeat(200),
   fg: C.border,
+  width: "100%",
   height: 1,
 });
 
@@ -241,10 +453,14 @@ type RowRefs = {
   row: BoxRenderable;
   nameText: TextRenderable;
   globalText: TextRenderable;
+  globalClaudeText: TextRenderable;
   localText: TextRenderable;
+  localClaudeText: TextRenderable;
 };
 const rows: RowRefs[] = [];
 
+scrollBox.add(searchRow);
+
 for (let i = 0; i < allSkills.length; i++) {
   const skill = allSkills[i];
 
@@ -259,9 +475,9 @@ for (let i = 0; i < allSkills.length; i++) {
 
   const nameText = new TextRenderable(renderer, {
     id: `name-${i}`,
-    content: `  ${skill}`,
+    content: `  ${ellipsize(skill, NAME_W - 3)}`,
     fg: C.fg,
-    width: 34,
+    width: NAME_W,
   });
 
   const gChecked = isLibraryLink(GLOBAL_DIR, skill);
@@ -270,35 +486,56 @@ for (let i = 0; i < allSkills.length; i++) {
     id: `global-${i}`,
     content: checkboxStr(gChecked, gBlocked),
     fg: checkboxColor(gChecked, gBlocked, false),
-    width: 10,
+    width: COL_W,
+  });
+
+  const gcChecked = isLibraryLink(GLOBAL_CLAUDE_DIR, skill);
+  const gcBlocked = nonLibraryExists(GLOBAL_CLAUDE_DIR, skill);
+  const globalClaudeText = new TextRenderable(renderer, {
+    id: `global-claude-${i}`,
+    content: checkboxStr(gcChecked, gcBlocked),
+    fg: checkboxColor(gcChecked, gcBlocked, false),
+    width: COL_W,
   });
 
-  const lChecked = localDir ? isLibraryLink(localDir, skill) : false;
-  const lBlocked = localDir ? nonLibraryExists(localDir, skill) : false;
+  const lChecked = localDir ? isEnabled(localDir, skill) : false;
+  const lBlocked = localDir ? isBlocked(localDir, skill) : false;
   const localText = new TextRenderable(renderer, {
     id: `local-${i}`,
     content: localDir ? checkboxStr(lChecked, lBlocked) : "  -",
     fg: localDir ? checkboxColor(lChecked, lBlocked, false) : C.fgDim,
-    width: 10,
+    width: COL_W,
+  });
+
+  const lcChecked = localClaudeDir ? isEnabled(localClaudeDir, skill) : false;
+  const lcBlocked = localClaudeDir ? isBlocked(localClaudeDir, skill) : false;
+  const localClaudeText = new TextRenderable(renderer, {
+    id: `local-claude-${i}`,
+    content: localClaudeDir ? checkboxStr(lcChecked, lcBlocked) : "  -",
+    fg: localClaudeDir ? checkboxColor(lcChecked, lcBlocked, false) : C.fgDim,
+    width: COL_W,
   });
 
   row.add(nameText);
   row.add(globalText);
+  row.add(globalClaudeText);
   row.add(localText);
+  row.add(localClaudeText);
   scrollBox.add(row);
-  rows.push({ row, nameText, globalText, localText });
+  rows.push({ row, nameText, globalText, globalClaudeText, localText, localClaudeText });
 }
 
 const footerSep = new TextRenderable(renderer, {
   id: "footer-sep",
-  content: "─".repeat(60),
+  content: "─".repeat(200),
   fg: C.border,
+  width: "100%",
   height: 1,
 });
 
 const footer = new TextRenderable(renderer, {
   id: "footer",
-  content: " type to filter  ↑↓ move  ←→/tab col  enter toggle  ^a all  ^e edit  ^d del  esc quit",
+  content: " ↑↓ move  ←→/tab col  enter toggle  ^a all  ^e edit  ^d del  / search  esc quit",
   fg: C.footer,
   height: 1,
 });
@@ -310,7 +547,6 @@ const statusLine = new TextRenderable(renderer, {
   height: 1,
 });
 
-outer.add(searchBar);
 outer.add(colHeaderRow);
 outer.add(sep);
 outer.add(scrollBox);
@@ -342,7 +578,15 @@ function applyFilter() {
 }
 
 function updateSearchBar() {
-  searchBar.content = ` / ${searchQuery}█`;
+  if (focusArea === "search") {
+    searchBar.content = `▸ ${searchQuery}█`;
+    searchBar.fg = C.search;
+    searchRow.backgroundColor = C.cursorBg;
+  } else {
+    searchBar.content = searchQuery ? `  ${searchQuery}` : `  search...`;
+    searchBar.fg = C.fgDim;
+    searchRow.backgroundColor = C.rowBg;
+  }
 }
 
 // ── Update display ──────────────────────────────────────────────────
@@ -355,14 +599,14 @@ function updateRow(i: number) {
   const skill = allSkills[i];
   const r = rows[i];
   const ci = currentSkillIndex();
-  const isCursor = ci === i;
+  const isCursor = ci === i && focusArea === "grid";
 
   const visPos = filteredIndices.indexOf(i);
   const baseBg = visPos % 2 === 0 ? C.rowBg : C.rowAltBg;
   r.row.backgroundColor = isCursor ? C.cursorBg : baseBg;
 
   const pointer = isCursor ? "▸" : " ";
-  r.nameText.content = `${pointer} ${skill}`;
+  r.nameText.content = `${pointer} ${ellipsize(skill, NAME_W - 3)}`;
   r.nameText.fg = isCursor ? "#ffffff" : C.fg;
   r.nameText.attributes = isCursor ? TextAttributes.BOLD : TextAttributes.NONE;
 
@@ -374,8 +618,16 @@ function updateRow(i: number) {
   r.globalText.bg = gActive ? C.accentBg : undefined;
   r.globalText.attributes = gActive ? TextAttributes.BOLD : TextAttributes.NONE;
 
-  const lChecked = localDir ? isLibraryLink(localDir, skill) : false;
-  const lBlocked = localDir ? nonLibraryExists(localDir, skill) : false;
+  const gcChecked = isLibraryLink(GLOBAL_CLAUDE_DIR, skill);
+  const gcBlocked = nonLibraryExists(GLOBAL_CLAUDE_DIR, skill);
+  const gcActive = isCursor && cursorCol === "globalClaude";
+  r.globalClaudeText.content = checkboxStr(gcChecked, gcBlocked);
+  r.globalClaudeText.fg = checkboxColor(gcChecked, gcBlocked, gcActive);
+  r.globalClaudeText.bg = gcActive ? C.accentBg : undefined;
+  r.globalClaudeText.attributes = gcActive ? TextAttributes.BOLD : TextAttributes.NONE;
+
+  const lChecked = localDir ? isEnabled(localDir, skill) : false;
+  const lBlocked = localDir ? isBlocked(localDir, skill) : false;
   const lActive = isCursor && cursorCol === "local";
   if (localDir) {
     r.localText.content = checkboxStr(lChecked, lBlocked);
@@ -387,6 +639,20 @@ function updateRow(i: number) {
     r.localText.fg = C.fgDim;
     r.localText.bg = lActive ? C.accentBg : undefined;
   }
+
+  const lcChecked = localClaudeDir ? isEnabled(localClaudeDir, skill) : false;
+  const lcBlocked = localClaudeDir ? isBlocked(localClaudeDir, skill) : false;
+  const lcActive = isCursor && cursorCol === "localClaude";
+  if (localClaudeDir) {
+    r.localClaudeText.content = checkboxStr(lcChecked, lcBlocked);
+    r.localClaudeText.fg = checkboxColor(lcChecked, lcBlocked, lcActive);
+    r.localClaudeText.bg = lcActive ? C.accentBg : undefined;
+    r.localClaudeText.attributes = lcActive ? TextAttributes.BOLD : TextAttributes.NONE;
+  } else {
+    r.localClaudeText.content = "  -";
+    r.localClaudeText.fg = C.fgDim;
+    r.localClaudeText.bg = lcActive ? C.accentBg : undefined;
+  }
 }
 
 function setStatus(msg: string, color: string) {
@@ -398,6 +664,30 @@ function setStatus(msg: string, color: string) {
   }, 3000);
 }
 
+function relayout() {
+  calcWidths();
+  colName.width = NAME_W;
+  colGlobal.width = COL_W;
+  colGlobalClaude.width = COL_W;
+  colLocal.width = COL_W;
+  colLocal.content = ellipsize(localLabel, COL_W - 1);
+  colLocalClaude.width = COL_W;
+  colLocalClaude.content = ellipsize(localClaudeLabel, COL_W - 1);
+  for (let i = 0; i < allSkills.length; i++) {
+    const r = rows[i];
+    r.nameText.width = NAME_W;
+    r.globalText.width = COL_W;
+    r.globalClaudeText.width = COL_W;
+    r.localText.width = COL_W;
+    r.localClaudeText.width = COL_W;
+  }
+}
+
+process.stdout.on("resize", () => {
+  relayout();
+  refreshAll();
+});
+
 function refreshAll() {
   for (const i of filteredIndices) updateRow(i);
   updateSearchBar();
@@ -408,18 +698,30 @@ refreshAll();
 // ── Scrolling helper ────────────────────────────────────────────────
 
 function ensureVisible() {
-  scrollBox.scrollTo(Math.max(0, cursor - 2));
+  if (focusArea === "search") {
+    scrollBox.scrollTo(0);
+  } else {
+    // +1 offset because searchRow is child 0 in scrollBox
+    scrollBox.scrollTo(Math.max(0, cursor + 1 - 2));
+  }
 }
 
 // ── Toggle all in column ────────────────────────────────────────────
 
-function toggleAllColumn(col: "global" | "local") {
-  const dir = col === "global" ? GLOBAL_DIR : ensureLocalDir();
+function toggleAllColumn(col: ColId) {
+  let dir: string;
+  let dirLabel: string;
+  switch (col) {
+    case "global": dir = GLOBAL_DIR; dirLabel = "~/.agents"; break;
+    case "globalClaude": dir = GLOBAL_CLAUDE_DIR; dirLabel = "~/.claude"; break;
+    case "local": dir = ensureLocalDir(); dirLabel = localLabel; break;
+    case "localClaude": dir = ensureLocalClaudeDir(); dirLabel = localClaudeLabel; break;
+  }
 
   // Determine intent: if majority of visible skills are linked, unlink all; otherwise link all
   let linkedCount = 0;
   for (const i of filteredIndices) {
-    if (isLibraryLink(dir, allSkills[i])) linkedCount++;
+    if (isEnabled(dir, allSkills[i])) linkedCount++;
   }
   const shouldLink = linkedCount <= filteredIndices.length / 2;
   let changed = 0;
@@ -427,7 +729,7 @@ function toggleAllColumn(col: "global" | "local") {
 
   for (const i of filteredIndices) {
     const skill = allSkills[i];
-    const isLinked = isLibraryLink(dir, skill);
+    const isLinked = isEnabled(dir, skill);
     if (shouldLink && !isLinked) {
       if (toggle(dir, skill)) changed++;
       else skipped++;
@@ -436,7 +738,6 @@ function toggleAllColumn(col: "global" | "local") {
     }
   }
 
-  const dirLabel = col === "global" ? "~/.agents" : localLabel;
   const action = shouldLink ? "linked" : "unlinked";
   let msg = `${action} ${changed} skills in ${dirLabel}`;
   if (skipped) msg += ` (${skipped} skipped)`;
@@ -474,9 +775,11 @@ function cancelPendingDelete() {
 function deleteSkill(idx: number) {
   const skill = allSkills[idx];
 
-  // Remove symlinks first
+  // Remove from all skill dirs (symlinks for global, copies for local)
   if (isLibraryLink(GLOBAL_DIR, skill)) unlinkSync(join(GLOBAL_DIR, skill));
-  if (localDir && isLibraryLink(localDir, skill)) unlinkSync(join(localDir, skill));
+  if (isLibraryLink(GLOBAL_CLAUDE_DIR, skill)) unlinkSync(join(GLOBAL_CLAUDE_DIR, skill));
+  if (localDir && existsSync(join(localDir, skill))) rmSync(join(localDir, skill), { recursive: true, force: true });
+  if (localClaudeDir && existsSync(join(localClaudeDir, skill))) rmSync(join(localClaudeDir, skill), { recursive: true, force: true });
 
   // Remove from library
   rmSync(join(LIBRARY, skill), { recursive: true, force: true });
@@ -494,6 +797,25 @@ function deleteSkill(idx: number) {
 
 // ── Key handler ─────────────────────────────────────────────────────
 
+function dirForCol(col: ColId): { dir: string; label: string } {
+  switch (col) {
+    case "global": return { dir: GLOBAL_DIR, label: "~/.agents/skills" };
+    case "globalClaude": return { dir: GLOBAL_CLAUDE_DIR, label: "~/.claude/skills" };
+    case "local": return { dir: ensureLocalDir(), label: localLabel };
+    case "localClaude": return { dir: ensureLocalClaudeDir(), label: localClaudeLabel };
+  }
+}
+
+function colNext(col: ColId): ColId {
+  const i = COL_ORDER.indexOf(col);
+  return COL_ORDER[(i + 1) % COL_ORDER.length];
+}
+
+function colPrev(col: ColId): ColId {
+  const i = COL_ORDER.indexOf(col);
+  return COL_ORDER[(i - 1 + COL_ORDER.length) % COL_ORDER.length];
+}
+
 renderer.keyInput.on("keypress", (key: KeyEvent) => {
   // ── Delete confirmation mode ──
   if (pendingDelete !== null) {
@@ -508,13 +830,17 @@ renderer.keyInput.on("keypress", (key: KeyEvent) => {
 
   const prevIdx = currentSkillIndex();
 
-  // ── Escape: clear search or quit ──
+  // ── Escape ──
   if (key.name === "escape") {
-    if (searchQuery) {
+    if (focusArea === "search" && searchQuery) {
       searchQuery = "";
       applyFilter();
       refreshAll();
       ensureVisible();
+    } else if (focusArea === "search") {
+      focusArea = "grid";
+      refreshAll();
+      ensureVisible();
     } else {
       renderer.destroy();
       process.exit(0);
@@ -522,18 +848,41 @@ renderer.keyInput.on("keypress", (key: KeyEvent) => {
     return;
   }
 
-  // ── Backspace: delete from search ──
-  if (key.name === "backspace") {
-    if (searchQuery) {
-      searchQuery = searchQuery.slice(0, -1);
+  // ── Search-focused input ──
+  if (focusArea === "search") {
+    if (key.name === "backspace") {
+      if (searchQuery) {
+        searchQuery = searchQuery.slice(0, -1);
+        applyFilter();
+        cursor = 0;
+        refreshAll();
+        ensureVisible();
+      }
+      return;
+    }
+    if (key.name === "down" || key.name === "return") {
+      focusArea = "grid";
+      refreshAll();
+      ensureVisible();
+      return;
+    }
+    // Printable character → append to search
+    if (key.sequence && key.sequence.length === 1 && !key.ctrl && !key.meta) {
+      searchQuery += key.sequence;
       applyFilter();
       cursor = 0;
       refreshAll();
       ensureVisible();
+      return;
     }
     return;
   }
 
+  // ── Grid-focused input ──
+
+  // ── Backspace in grid: do nothing ──
+  if (key.name === "backspace") return;
+
   // ── Ctrl combos ──
   if (key.ctrl) {
     switch (key.name) {
@@ -559,22 +908,37 @@ renderer.keyInput.on("keypress", (key: KeyEvent) => {
     return;
   }
 
-  // ── Navigation & actions (arrow keys, enter, tab) ──
+  // ── "/" to focus search (vim-style) ──
+  if (key.sequence === "/") {
+    focusArea = "search";
+    refreshAll();
+    ensureVisible();
+    return;
+  }
+
+  // ── Navigation & actions ──
   switch (key.name) {
     case "down":
       if (cursor < filteredIndices.length - 1) cursor++;
       break;
     case "up":
-      if (cursor > 0) cursor--;
+      if (cursor > 0) {
+        cursor--;
+      } else {
+        // At top of grid → move to search
+        focusArea = "search";
+        refreshAll();
+        return;
+      }
       break;
     case "left":
-      cursorCol = "global";
+      cursorCol = colPrev(cursorCol);
       break;
     case "right":
-      cursorCol = "local";
+      cursorCol = colNext(cursorCol);
       break;
     case "tab":
-      cursorCol = cursorCol === "global" ? "local" : "global";
+      cursorCol = colNext(cursorCol);
       break;
     case "pagedown":
       cursor = Math.min(filteredIndices.length - 1, cursor + 10);
@@ -588,46 +952,25 @@ renderer.keyInput.on("keypress", (key: KeyEvent) => {
     case "end":
       cursor = Math.max(0, filteredIndices.length - 1);
       break;
+    case "space":
     case "return": {
       const idx = currentSkillIndex();
       if (idx === null) break;
       const skill = allSkills[idx];
-      if (cursorCol === "global") {
-        const ok = toggle(GLOBAL_DIR, skill);
-        if (ok) {
-          const linked = isLibraryLink(GLOBAL_DIR, skill);
-          setStatus(
-            linked ? `✓ ${skill} → ~/.agents/skills` : `✗ ${skill} removed from ~/.agents/skills`,
-            linked ? C.statusOk : C.statusErr
-          );
-        } else {
-          setStatus(`⚠ ${skill}: non-library file exists in ~/.agents/skills, skipped`, C.warning);
-        }
+      const { dir, label } = dirForCol(cursorCol);
+      const ok = toggle(dir, skill);
+      if (ok) {
+        const linked = isEnabled(dir, skill);
+        setStatus(
+          linked ? `✓ ${skill} → ${label}` : `✗ ${skill} removed from ${label}`,
+          linked ? C.statusOk : C.statusErr
+        );
       } else {
-        const dir = ensureLocalDir();
-        const ok = toggle(dir, skill);
-        if (ok) {
-          const linked = isLibraryLink(localDir, skill);
-          setStatus(
-            linked ? `✓ ${skill} → ${localLabel}` : `✗ ${skill} removed from ${localLabel}`,
-            linked ? C.statusOk : C.statusErr
-          );
-        } else {
-          setStatus(`⚠ ${skill}: non-library file exists in ${localLabel}, skipped`, C.warning);
-        }
+        setStatus(`⚠ ${skill}: non-library file exists in ${label}, skipped`, C.warning);
       }
       break;
     }
     default:
-      // ── Printable character → search input ──
-      if (key.sequence && key.sequence.length === 1 && !key.meta) {
-        searchQuery += key.sequence;
-        applyFilter();
-        cursor = 0;
-        refreshAll();
-        ensureVisible();
-        return;
-      }
       return;
   }