skillio 0.1.14 → 0.1.16

package/README.md

@@ -81,13 +81,13 @@ skl cost                               # ambient ballast cost (frontmatter token
 skl cs                                 # alias for cost (also: cst)
 skl usage                              # consumption: usage count × frontmatter tokens
 skl usg                                # alias for usage
-skl rm brainstorming                   # delete on-disk dir; lock kept (Y/n prompt)
-skl rm brainstorming writing-plans     # remove multiple
-skl rm .                               # remove all skills in scope (lock kept)
-skl rm . -fl                           # remove all, including lock entries
-skl rm --yes brainstorming             # skip confirmation
-skl rm --dry-run brainstorming         # preview only
-skl rm --force-lock brainstorming      # also remove the lock entry (-fl)
+skl rm brainstorming                   # colored plan, Proceed? [y/n], then Clean lock? [y/n]
+skl rm brainstorming writing-plans     # remove multiple, one pair of prompts
+skl rm .                               # remove all skills in scope
+skl rm --yes brainstorming             # skip both prompts
+skl rm brainstorming --lock-only       # only the lock entry (alias --lo)
+skl rm brainstorming --agents-only     # only .agents/skills (alias --ao)
+skl rm brainstorming --claude-only     # only .claude/skills (alias --co)
 
 # scope flags
 skl -g                                 # force global scope on any subcommand
@@ -169,15 +169,14 @@ skillio cost --global   # same, against ~/.agents/.skill-lock.json
 ### `skillio remove` / `rm`
 
 ```sh
-skillio remove <skill-name>               # delete on-disk dir; lock kept
+skillio remove <skill-name>               # colored plan/summary, two prompts (disk, then lock)
 skillio remove <skill-one> <skill-two>
-skillio remove .                          # remove all skills in scope (lock kept)
-skillio remove . -fl                      # remove all, including lock entries
-skillio remove --force-lock <skill-name>  # also remove the lock entry (alias -fl)
-skillio remove --lock-only <skill-name>   # only the lock entry; keep on disk
+skillio remove .                          # remove all skills in scope
+skillio remove --lock-only <skill-name>   # only the lock entry; keep on disk (alias --lo)
+skillio remove --agents-only <skill-name> # only .agents/skills; keep .claude/skills and lock (alias --ao)
+skillio remove --claude-only <skill-name> # only .claude/skills; keep .agents/skills and lock (alias --co)
 skillio remove --global <skill-name>
-skillio remove --dry-run <skill-name>     # preview only
-skillio remove --yes <skill-name>         # skip confirmation prompt
+skillio remove --yes <skill-name>         # skip both confirmation prompts
 ```
 
 ### Shell completion

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   __require,
+  countLockLinesToRemove,
   cyan,
   detectColorSupport,
   discoverSkills,
@@ -11,7 +12,7 @@ import {
   removeSkillFromLock,
   setColorEnabled,
   yellow
-} from "./shared/chunk-0qvp6v8g.js";
+} from "./shared/chunk-nkpp3h85.js";
 
 // src/cli.ts
 import { createRequire } from "node:module";
@@ -577,7 +578,7 @@ _skillio_completions() {
   case "\${sub}" in
     rm|remove)
       if [[ "\${cur}" == -* ]]; then
-        COMPREPLY=( $(compgen -W "-g --global --dry-run -y --yes --force-lock -fl --lock-only -h --help" -- "\${cur}") )
+        COMPREPLY=( $(compgen -W "-g --global -y --yes --lock-only --lo --agents-only --ao --claude-only --co -h --help" -- "\${cur}") )
       else
         local names
         local scope=""
@@ -625,10 +626,10 @@ _skillio() {
       if [[ \${words[CURRENT]} == -* ]]; then
         _values 'flag' \\
           '-g[global scope]' '--global[global scope]' \\
-          '--dry-run[print plan without deleting]' \\
           '-y[skip confirmation]' '--yes[skip confirmation]' \\
-          '--force-lock[also remove lock entry]' '-fl[alias for --force-lock]' \\
-          '--lock-only[remove only lock entry, keep disk]'
+          '--lock-only[only remove lock entry]' '--lo[alias for --lock-only]' \\
+          '--agents-only[only remove from .agents/skills]' '--ao[alias for --agents-only]' \\
+          '--claude-only[only remove from .claude/skills]' '--co[alias for --claude-only]'
       else
         local scope=""
         for w in \${words[@]}; do
@@ -676,11 +677,13 @@ for sub in rm remove
   complete -c skl -n "__skillio_using_subcommand $sub" -f -a '(__skillio_skill_names)'
   complete -c skillio -n "__skillio_using_subcommand $sub" -f -a '(__skillio_skill_names)'
   complete -c skl -n "__skillio_using_subcommand $sub" -s g -l global -d 'Use global scope'
-  complete -c skl -n "__skillio_using_subcommand $sub" -l dry-run -d 'Print plan without deleting'
   complete -c skl -n "__skillio_using_subcommand $sub" -s y -l yes -d 'Skip confirmation prompt'
-  complete -c skl -n "__skillio_using_subcommand $sub" -l force-lock -d 'Also remove lock entry'
-  complete -c skl -n "__skillio_using_subcommand $sub" -o fl -d 'Alias for --force-lock'
-  complete -c skl -n "__skillio_using_subcommand $sub" -l lock-only -d 'Remove only lock entry, keep disk'
+  complete -c skl -n "__skillio_using_subcommand $sub" -l lock-only -d 'Only remove lock entry'
+  complete -c skl -n "__skillio_using_subcommand $sub" -l lo -d 'Alias for --lock-only'
+  complete -c skl -n "__skillio_using_subcommand $sub" -l agents-only -d 'Only remove from .agents/skills'
+  complete -c skl -n "__skillio_using_subcommand $sub" -l ao -d 'Alias for --agents-only'
+  complete -c skl -n "__skillio_using_subcommand $sub" -l claude-only -d 'Only remove from .claude/skills'
+  complete -c skl -n "__skillio_using_subcommand $sub" -l co -d 'Alias for --claude-only'
 end
 
 for sub in completion
@@ -858,9 +861,8 @@ var listCommand = defineCommand({
         render: () => {
           if (rows.lock.totalCount === 0)
             return "";
-          if (orphans.length === 0)
-            return green("All skills onboard!");
-          return orphans.map((n) => red(n.name)).join(" ");
+          const orphanSet = new Set(orphans.map((n) => n.name));
+          return rows.lock.names.map((n) => orphanSet.has(n.name) ? red(n.name) : n.name).join(" ");
         }
       }
     ];
@@ -897,7 +899,6 @@ var listCommand = defineCommand({
 });
 
 // src/commands/remove.ts
-import { existsSync as existsSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
 
@@ -910,13 +911,13 @@ async function confirm(question, opts = {}) {
     const { createInterface } = await import("node:readline/promises");
     const rl = createInterface({ input, output });
     try {
-      const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+      const answer = (await rl.question(`${question} [y/n] `)).trim().toLowerCase();
       return answer === "y" || answer === "yes";
     } finally {
       rl.close();
     }
   }
-  output.write(`${question} [y/N] `);
+  output.write(`${question} [y/n] `);
   emitKeypressEvents(input);
   if (input.setRawMode)
     input.setRawMode(true);
@@ -963,19 +964,46 @@ async function confirm(question, opts = {}) {
     input.on("keypress", onKey);
   });
 }
+function createConfirmer(opts = {}) {
+  const input = opts.input ?? process.stdin;
+  const output = opts.output ?? process.stdout;
+  if (input.isTTY && output.isTTY) {
+    return (question) => confirm(question, { input, output });
+  }
+  let queue;
+  return async (question) => {
+    if (queue === undefined) {
+      let raw = "";
+      for await (const chunk of input)
+        raw += chunk;
+      queue = raw.split(`
+`);
+    }
+    output.write(`${question} [y/n] `);
+    const line = (queue.shift() ?? "").trim().toLowerCase();
+    return line === "y" || line === "yes";
+  };
+}
 
 // src/utils/fs-rm.ts
-import { existsSync as existsSync2, lstatSync as lstatSync2, readdirSync, rmSync } from "node:fs";
+import { lstatSync as lstatSync2, readdirSync, rmSync } from "node:fs";
 import { join as join2, resolve as resolve2 } from "node:path";
 function isInside(target, root) {
   const t = resolve2(target);
   const r = resolve2(root);
   return t === r || t.startsWith(`${r}/`);
 }
+function lstatOrNull(path) {
+  try {
+    return lstatSync2(path);
+  } catch {
+    return null;
+  }
+}
 function countFiles(path) {
-  if (!existsSync2(path))
+  const stat = lstatOrNull(path);
+  if (!stat)
     return 0;
-  const stat = lstatSync2(path);
   if (stat.isFile())
     return 1;
   if (!stat.isDirectory())
@@ -986,12 +1014,27 @@ function countFiles(path) {
   }
   return n;
 }
+function countFoldersAndFiles(dir) {
+  let folders = 0;
+  let files = 0;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      folders++;
+      const nested = countFoldersAndFiles(join2(dir, entry.name));
+      folders += nested.folders;
+      files += nested.files;
+    } else {
+      files++;
+    }
+  }
+  return { folders, files };
+}
 function rmSkillDir(path, opts) {
   const safe = opts.allowedRoots.some((root) => isInside(path, root));
   if (!safe) {
     throw new Error(`Refusing to delete: "${path}" is outside allowed roots`);
   }
-  if (!existsSync2(path))
+  if (!lstatOrNull(path))
     return { removed: false, fileCount: 0 };
   const fileCount = countFiles(path);
   rmSync(path, { recursive: true, force: true });
@@ -999,97 +1042,141 @@ function rmSkillDir(path, opts) {
 }
 
 // src/commands/remove.ts
-var q = (name) => `"${cyan(name)}"`;
+function buildLocation(dir) {
+  const stat = lstatOrNull(dir);
+  if (!stat)
+    return { kind: "missing", subfolders: 0, files: 0 };
+  if (stat.isSymbolicLink())
+    return { kind: "symlink", subfolders: 0, files: 0 };
+  const { folders, files } = countFoldersAndFiles(dir);
+  return { kind: "real", subfolders: folders, files };
+}
+function rootFor2(base, isGlobal, lockPath) {
+  return isGlobal ? join3(homedir2(), base, "skills") : join3(dirname2(resolve3(lockPath)), base, "skills");
+}
 function buildTarget(name, isGlobal, lockPath) {
-  const lock = readLock(lockPath);
-  const inLock = Object.hasOwn(lock.skills, name);
-  const baseClaude = isGlobal ? join3(homedir2(), ".claude", "skills") : join3(dirname2(resolve3(lockPath)), ".claude", "skills");
-  const baseAgents = isGlobal ? join3(homedir2(), ".agents", "skills") : join3(dirname2(resolve3(lockPath)), ".agents", "skills");
-  const claudeDir = existsSync3(join3(baseClaude, name)) ? join3(baseClaude, name) : undefined;
-  const agentsDir = existsSync3(join3(baseAgents, name)) ? join3(baseAgents, name) : undefined;
-  return { name, inLock, claudeDir, agentsDir };
+  const agentsDir = join3(rootFor2(".agents", isGlobal, lockPath), name);
+  const claudeDir = join3(rootFor2(".claude", isGlobal, lockPath), name);
+  return {
+    name,
+    agentsDir,
+    claudeDir,
+    agents: buildLocation(agentsDir),
+    claude: buildLocation(claudeDir)
+  };
 }
 function collectAllTargets(isGlobal, lockPath) {
   const map = discoverSkills({ isGlobal, cwd: process.cwd(), lockPath });
   return [...map.keys()].sort().map((name) => buildTarget(name, isGlobal, lockPath));
 }
-function fileCount(dir) {
-  const { readdirSync: readdirSync2, statSync } = __require("node:fs");
-  let n = 0;
-  const stack = [dir];
-  while (stack.length) {
-    const cur = stack.pop();
-    const stat = statSync(cur);
-    if (stat.isFile())
-      n++;
-    else if (stat.isDirectory())
-      for (const e of readdirSync2(cur))
-        stack.push(join3(cur, e));
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function header(targets, verb) {
+  const names = targets.map((t) => red(t.name)).join(" ");
+  return `${plural(targets.length, "skill")} ${names} ${verb}`;
+}
+function aggregateLocations(infos) {
+  let folders = 0;
+  let subfolders = 0;
+  let files = 0;
+  let symlinks = 0;
+  for (const info of infos) {
+    if (info.kind === "real") {
+      folders += 1;
+      subfolders += info.subfolders;
+      files += info.files;
+    } else if (info.kind === "symlink") {
+      symlinks += 1;
+    }
   }
-  return n;
+  return { folders, subfolders, files, symlinks, found: infos.some((i) => i.kind !== "missing") };
 }
-function printPlan(plan, modifyLock, lockOnly) {
-  const { target } = plan;
-  console.log(`Will remove ${q(target.name)}:`);
-  if (target.inLock) {
-    if (lockOnly || modifyLock)
-      console.log("  - skills-lock.json");
-    else
-      console.log("  - skills-lock.json (kept; use --force-lock to remove lock entry)");
-  } else {
-    console.log("  - skills-lock.json (not in lock)");
-  }
-  if (lockOnly) {
-    if (target.claudeDir)
-      console.log(`  - .claude/skills/${target.name}/  (kept; --lock-only)`);
-    else
-      console.log("  - .claude/skills/  (not found)");
-    if (target.agentsDir)
-      console.log(`  - .agents/skills/${target.name}/  (kept; --lock-only)`);
-    else
-      console.log("  - .agents/skills/  (not found)");
-    return;
+function diskCell(infos, variant) {
+  const agg = aggregateLocations(infos);
+  if (!agg.found)
+    return "not found";
+  const parts = [];
+  if (agg.folders > 0 || agg.files > 0) {
+    const text = `${plural(agg.folders, "folder")}, ${plural(agg.subfolders, "subfolder")}, ${plural(agg.files, "file")}`;
+    parts.push(variant === "summary" ? red(text) : green(text));
+  }
+  if (agg.symlinks > 0) {
+    const text = plural(agg.symlinks, "symlink");
+    parts.push(variant === "summary" ? red(text) : yellow(text));
+  }
+  return parts.join(", ");
+}
+function lockCell(n, variant) {
+  if (n === 0)
+    return "not in lock";
+  if (variant === "kept")
+    return green(`${plural(n, "line")} kept`);
+  return red(plural(n, "line"));
+}
+function printBlock(targets, scope, verb, lockLinesToRemove, diskVariant, lockVariant) {
+  console.log(header(targets, verb));
+  const rows = [];
+  if (scope === "all" || scope === "agents-only") {
+    rows.push([
+      ".agents/skills/",
+      diskCell(targets.map((t) => t.agents), diskVariant)
+    ]);
+  }
+  if (scope === "all" || scope === "claude-only") {
+    rows.push([
+      ".claude/skills/",
+      diskCell(targets.map((t) => t.claude), diskVariant)
+    ]);
+  }
+  if (scope === "all" || scope === "lock-only") {
+    rows.push(["skills-lock.json", lockCell(lockLinesToRemove, lockVariant)]);
+  }
+  const labelWidth = Math.max(...rows.map(([label]) => label.length));
+  for (const [label, cell] of rows) {
+    console.log(`${label.padEnd(labelWidth)}  ${cell}`);
   }
-  if (target.claudeDir)
-    console.log(`  - .claude/skills/${target.name}/  (${plan.claudeFileCount} files)`);
-  else
-    console.log("  - .claude/skills/  (not found)");
-  if (target.agentsDir)
-    console.log(`  - .agents/skills/${target.name}/  (${plan.agentsFileCount} files)`);
-  else
-    console.log("  - .agents/skills/  (not found)");
 }
 var removeCommand = defineCommand({
   meta: {
-    description: "Remove one or more skills from on-disk dirs (lock preserved unless --force-lock)"
+    description: "Remove one or more skills from on-disk dirs and/or skills-lock.json"
   },
   args: {
     global: { type: "boolean", alias: "g", default: false, description: "Use global scope" },
-    "dry-run": { type: "boolean", default: false, description: "Print plan, do not delete" },
-    yes: { type: "boolean", alias: "y", default: false, description: "Skip confirmation prompt" },
-    "force-lock": {
+    yes: { type: "boolean", alias: "y", default: false, description: "Skip confirmation prompts" },
+    "lock-only": {
       type: "boolean",
+      alias: "lo",
       default: false,
-      description: "Also remove entry from skills-lock.json (default is to keep lock untouched)"
+      description: "Only remove the skills-lock.json entry; keep on-disk directories"
     },
-    "lock-only": {
+    "agents-only": {
+      type: "boolean",
+      alias: "ao",
+      default: false,
+      description: "Only remove from .agents/skills; keep .claude/skills and the lock entry"
+    },
+    "claude-only": {
       type: "boolean",
+      alias: "co",
       default: false,
-      description: "Remove only the skills-lock.json entry; keep on-disk directories"
+      description: "Only remove from .claude/skills; keep .agents/skills and the lock entry"
     }
   },
   async run({ args }) {
     const {
       global: isGlobal,
-      "dry-run": dryRun,
       yes,
-      "force-lock": modifyLock,
-      "lock-only": lockOnly
+      "lock-only": lockOnly,
+      "agents-only": agentsOnly,
+      "claude-only": claudeOnly
     } = args;
-    if (lockOnly && modifyLock) {
-      console.error("--lock-only is mutually exclusive with --force-lock");
+    const onlyFlagCount = [lockOnly, agentsOnly, claudeOnly].filter(Boolean).length;
+    if (onlyFlagCount > 1) {
+      console.error("--lock-only, --agents-only, and --claude-only are mutually exclusive");
       process.exit(1);
     }
+    const scope = lockOnly ? "lock-only" : agentsOnly ? "agents-only" : claudeOnly ? "claude-only" : "all";
     const subcmdIdx = process.argv.findIndex((a) => a === "remove" || a === "rm");
     const rawNames = process.argv.slice(subcmdIdx + 1).filter((a) => !a.startsWith("-"));
     const all = rawNames.includes(".");
@@ -1108,82 +1195,57 @@ var removeCommand = defineCommand({
       console.log("No skills to remove in scope.");
       return;
     }
-    const orphan = targets.filter((t) => !t.inLock && !t.claudeDir && !t.agentsDir);
+    const lockNames = new Set(Object.keys(readLock(lockPath).skills));
+    const orphan = targets.filter((t) => t.agents.kind === "missing" && t.claude.kind === "missing" && !lockNames.has(t.name));
     if (orphan.length) {
       for (const o of orphan)
-        console.log(`${q(o.name)} is not in lock or on disk`);
+        console.log(`"${o.name}" is not in lock or on disk`);
       process.exit(1);
     }
-    const plans = targets.map((t) => ({
-      target: t,
-      claudeFileCount: t.claudeDir ? fileCount(t.claudeDir) : undefined,
-      agentsFileCount: t.agentsDir ? fileCount(t.agentsDir) : undefined
-    }));
-    for (const p of plans) {
-      printPlan(p, modifyLock, lockOnly);
-      console.log("");
-    }
-    if (dryRun)
-      return;
+    const lockLinesToRemove = countLockLinesToRemove(lockPath, targets.map((t) => t.name));
+    printBlock(targets, scope, "will be removed from:", lockLinesToRemove, "plan", "removed");
+    const ask = createConfirmer();
     if (!yes) {
-      let question = "Proceed?";
-      if (all) {
-        const subject = lockOnly ? `ALL ${plans.length} lock entries (disk preserved)` : `ALL ${plans.length} skills`;
-        question = `Remove ${subject}?`;
-      }
-      const ok = await confirm(question);
+      console.log("");
+      const ok = await ask("Proceed?");
       if (!ok) {
         console.log("Aborted");
         process.exit(1);
       }
     }
     const allowedRoots = [isGlobal ? homedir2() : dirname2(resolve3(lockPath)), homedir2()];
-    const removed = (s) => red("removed") + s;
-    const kept = (s) => green("kept") + s;
-    const skipped = (s) => yellow("skipped") + s;
-    for (const { target } of plans) {
-      console.log("");
-      console.log(q(target.name));
-      if (lockOnly) {
-        if (target.agentsDir)
-          console.log(kept(" .agents/skills (--lock-only)"));
-        else
-          console.log(skipped(" .agents/skills (not found)"));
-        if (target.claudeDir)
-          console.log(kept(" .claude/skills (--lock-only)"));
-        else
-          console.log(skipped(" .claude/skills (not found)"));
-      } else {
-        if (target.agentsDir) {
-          const r = rmSkillDir(target.agentsDir, { allowedRoots });
-          console.log(removed(` from .agents/skills (${r.fileCount} files)`));
-        } else {
-          console.log(skipped(" .agents/skills (not found)"));
-        }
-        if (target.claudeDir) {
-          const r = rmSkillDir(target.claudeDir, { allowedRoots });
-          console.log(removed(` from .claude/skills (${r.fileCount} files)`));
-        } else {
-          console.log(skipped(" .claude/skills (not found)"));
-        }
+    if (scope === "all" || scope === "agents-only") {
+      for (const t of targets)
+        rmSkillDir(t.agentsDir, { allowedRoots });
+    }
+    if (scope === "all" || scope === "claude-only") {
+      for (const t of targets)
+        rmSkillDir(t.claudeDir, { allowedRoots });
+    }
+    let lockCleaned = false;
+    if (scope === "lock-only") {
+      for (const t of targets)
+        removeSkillFromLock(lockPath, t.name);
+      lockCleaned = true;
+    } else if (scope === "all" && lockLinesToRemove > 0) {
+      let cleanLock = yes;
+      if (!yes) {
+        console.log("");
+        cleanLock = await ask(`Clean skills-lock.json (${plural(lockLinesToRemove, "line")})?`);
       }
-      if (target.inLock) {
-        if (lockOnly || modifyLock) {
-          const r = removeSkillFromLock(lockPath, target.name);
-          if (r.removed)
-            console.log(removed(" from skills-lock.json"));
-        } else {
-          console.log(kept(" in skills-lock.json"));
-        }
-      } else {
-        console.log(skipped(" skills-lock.json (not in lock)"));
+      if (cleanLock) {
+        for (const t of targets)
+          removeSkillFromLock(lockPath, t.name);
+        lockCleaned = true;
       }
     }
+    console.log("");
+    printBlock(targets, scope, "removed from:", lockLinesToRemove, "summary", lockCleaned ? "removed" : "kept");
   }
 });
 
 // src/commands/usage.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { join as join7 } from "node:path";
 
 // src/readers/claude.ts
@@ -1517,10 +1579,10 @@ function readClaudeUsage(options) {
 }
 
 // src/readers/codex.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 
 // src/utils/scope.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname3, join as join6 } from "node:path";
 function detectScope(opts) {
@@ -1542,7 +1604,7 @@ function encodeClaudeProjectDir(absPath) {
 function findGitRoot(start) {
   let dir = start;
   while (true) {
-    if (existsSync4(join6(dir, ".git")))
+    if (existsSync2(join6(dir, ".git")))
       return dir;
     const parent = dirname3(dir);
     if (parent === dir)
@@ -1615,7 +1677,7 @@ function readCodexMentions(options) {
   const historyPath = expandHome(options.history ?? "~/.codex/history.jsonl");
   const counts = new Map;
   let linesRead = 0;
-  if (!existsSync5(historyPath))
+  if (!existsSync3(historyPath))
     return { counts, filesRead: 0, linesRead: 0 };
   for (const line of readFileSync3(historyPath, "utf8").split(`
 `)) {
@@ -1725,7 +1787,7 @@ async function runUsage(args) {
   });
   const claudeProjectsRoot = expandHome("~/.claude/projects");
   const claudeRoot = args.root ?? (scope.projectRoot ? join7(claudeProjectsRoot, encodeClaudeProjectDir(scope.projectRoot)) : claudeProjectsRoot);
-  const claudeRootMissing = !args.root && !!scope.projectRoot && !existsSync6(claudeRoot);
+  const claudeRootMissing = !args.root && !!scope.projectRoot && !existsSync4(claudeRoot);
   const lockPath = getLockPath(args.global);
   const skillUniverse = discoverSkills({
     isGlobal: args.global,
@@ -1969,10 +2031,7 @@ function reorderRootFlagsToSubcommand(argv) {
     return argv;
   return [argv[0] ?? "", argv[1] ?? "", sub, ...before, ...after];
 }
-function normalizeShortFlags(argv) {
-  return argv.map((tok) => tok === "-fl" ? "--force-lock" : tok);
-}
-process.argv = reorderRootFlagsToSubcommand(normalizeShortFlags(mergeAgentArgs(process.argv)));
+process.argv = reorderRootFlagsToSubcommand(mergeAgentArgs(process.argv));
 function printRootHelp() {
   const lines = [
     `Audit and manage AI agent skills (skillio v${version})`,
@@ -1990,7 +2049,7 @@ function printRootHelp() {
     "COMMANDS",
     "",
     "  list, ls         List skills per source: install type, lock orphans, disk/lock diff",
-    "  remove, rm       Delete on-disk skill dirs; lock kept unless --force-lock",
+    "  remove, rm       Delete on-disk skill dirs and/or skills-lock.json (interactive)",
     "  cost, cs, cst    Show ambient ballast cost (per-skill frontmatter tokens) sorted desc",
     "  usage, us, usg   Show skill usage × cost (consumption) with missed rows",
     "  completion       Print shell completion script (bash, zsh, fish)"
@@ -2014,32 +2073,30 @@ function isRemoveHelp(argv) {
 }
 function printRemoveHelp() {
   const lines = [
-    "Remove skills from on-disk dirs (lock preserved unless --force-lock).",
+    "Remove skills from on-disk dirs and/or skills-lock.json.",
     "",
     "USAGE skillio remove [SKILL...] [OPTIONS]",
     "       skillio rm [SKILL...] [OPTIONS]",
     "",
     "ARGUMENTS",
     "",
-    '  SKILL...         One or more skill names. Use "." to target every skill in scope.',
+    '  SKILL...            One or more skill names. Use "." to target every skill in scope.',
     "",
     "OPTIONS",
     "",
-    "  -g, --global       Use global scope (default: false)",
-    "      --dry-run      Print plan without deleting",
-    '  -y, --yes          Skip confirmation prompt (non-TTY only for ".")',
-    "      --force-lock   Also remove entry from skills-lock.json (default: lock preserved)",
-    "  -fl                Alias for --force-lock",
-    "      --lock-only    Remove only the lock entry; keep on-disk directories",
+    "  -g, --global         Use global scope (default: false)",
+    "  -y, --yes            Skip confirmation prompts",
+    "      --lock-only      Only remove the skills-lock.json entry (alias --lo)",
+    "      --agents-only    Only remove from .agents/skills (alias --ao)",
+    "      --claude-only    Only remove from .claude/skills (alias --co)",
     "",
     "EXAMPLES",
     "",
     "  skillio rm brainstorming",
     "  skillio rm brainstorming writing-plans --yes",
-    "  skillio rm . --dry-run",
-    "  skillio rm . -fl",
-    "  skillio rm --force-lock obsolete-skill",
-    "  skillio rm --lock-only stale-entry"
+    "  skillio rm .",
+    "  skillio rm brainstorming --agents-only",
+    "  skillio rm brainstorming --lock-only"
   ];
   console.log(lines.join(`
 `));
@@ -2089,7 +2146,7 @@ var main = defineCommand({
       return;
     const interactive = process.stdout.isTTY && process.stdin.isTTY;
     if (interactive) {
-      const { runPicker } = await import("./shared/chunk-vwrhawsv.js");
+      const { runPicker } = await import("./shared/chunk-dwrjph29.js");
       const status = await runPicker({
         global: args.global ?? false
       });

package/dist/shared/{chunk-vwrhawsv.js → chunk-dwrjph29.js}

@@ -3,7 +3,7 @@ import {
   discoverSkills,
   getLockPath,
   red
-} from "./chunk-0qvp6v8g.js";
+} from "./chunk-nkpp3h85.js";
 
 // src/commands/picker.ts
 import { spawnSync } from "node:child_process";
@@ -219,7 +219,7 @@ async function runPicker(args) {
       { value: "usage", label: "usage  — count of skill invocations" },
       { value: "cost", label: "cost   — per-skill ambient tokens" },
       { value: "list", label: "list   — installed skills per source" },
-      { value: "remove", label: "remove — delete a skill (disk-only; lock with --force-lock)" },
+      { value: "remove", label: "remove — delete a skill (asks about lock cleanup)" },
       { value: "quit", label: "quit" }
     ]
   });

package/dist/shared/{chunk-0qvp6v8g.js → chunk-nkpp3h85.js}

@@ -13,13 +13,28 @@ function readLock(path) {
     return { skills: {} };
   return JSON.parse(readFileSync(path, "utf8"));
 }
+function serialize(lock) {
+  return `${JSON.stringify(lock, null, 2)}
+`;
+}
 function writeLock(path, lock) {
   mkdirSync(dirname(path), { recursive: true });
   const tmp = join(dirname(path), `.${Date.now()}.skill-lock.json`);
-  writeFileSync(tmp, `${JSON.stringify(lock, null, 2)}
-`);
+  writeFileSync(tmp, serialize(lock));
   renameSync(tmp, path);
 }
+function countLockLinesToRemove(path, names) {
+  if (!existsSync(path))
+    return 0;
+  const lock = readLock(path);
+  const before = serialize(lock);
+  const after = { skills: { ...lock.skills } };
+  for (const name of names)
+    delete after.skills[name];
+  return before.split(`
+`).length - serialize(after).split(`
+`).length;
+}
 function removeSkillFromLock(path, skill) {
   if (!existsSync(path))
     return { removed: false };
@@ -135,4 +150,4 @@ function discoverSkills(input) {
   return out;
 }
 
-export { __require, getLockPath, readLock, removeSkillFromLock, setColorEnabled, detectColorSupport, green, yellow, red, cyan, discoverSkills };
+export { __require, getLockPath, readLock, countLockLinesToRemove, removeSkillFromLock, setColorEnabled, detectColorSupport, green, yellow, red, cyan, discoverSkills };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillio",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Audit and manage AI agent skills for Claude Code and Codex",
   "license": "MIT",
   "author": "ihororlovskyi",