skillio 0.1.13 → 0.1.15

package/README.md

@@ -78,15 +78,16 @@ skillio                                # equivalent
 # subcommands
 skl ls                                 # list skills per source with diffs
 skl cost                               # ambient ballast cost (frontmatter tokens) per skill
-skl cst                                # alias for cost
+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 --all                           # remove all skills in scope
-skl rm --yes brainstorming             # skip confirmation
-skl rm --dry-run brainstorming         # preview only
-skl rm --force-lock brainstorming      # also remove the lock entry
+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
@@ -158,7 +159,7 @@ skillio list            # local skills-lock.json
 skillio list --global   # ~/.agents/.skill-lock.json
 ```
 
-### `skillio cost` / `co`
+### `skillio cost` / `cs`
 
 ```sh
 skillio cost            # local: per-skill frontmatter tokens with verdict
@@ -168,14 +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 --all                      # remove all skills in scope
-skillio remove --force-lock <skill-name>  # also remove the lock entry
-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,18 +1,18 @@
 #!/usr/bin/env node
 import {
   __require,
+  countLockLinesToRemove,
   cyan,
   detectColorSupport,
   discoverSkills,
   getLockPath,
   green,
-  promptText,
   readLock,
   red,
   removeSkillFromLock,
   setColorEnabled,
   yellow
-} from "./shared/chunk-2gt0ysd1.js";
+} from "./shared/chunk-nkpp3h85.js";
 
 // src/cli.ts
 import { createRequire } from "node:module";
@@ -568,7 +568,7 @@ _skillio_completions() {
   cur="\${COMP_WORDS[COMP_CWORD]}"
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
 
-  local cmds="list ls remove rm cost co cst usage us usg completion"
+  local cmds="list ls remove rm cost cs cst usage us usg completion"
   if [ "\${COMP_CWORD}" -eq 1 ]; then
     COMPREPLY=( $(compgen -W "\${cmds} -h --help -v --version" -- "\${cur}") )
     return 0
@@ -578,7 +578,7 @@ _skillio_completions() {
   case "\${sub}" in
     rm|remove)
       if [[ "\${cur}" == -* ]]; then
-        COMPREPLY=( $(compgen -W "-g --global --all --dry-run -y --yes --force-lock --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=""
@@ -609,7 +609,7 @@ _skillio() {
     'remove:Delete on-disk skill dirs'
     'rm:Alias for remove'
     'cost:Show ambient ballast cost'
-    'co:Alias for cost'
+    'cs:Alias for cost'
     'cst:Alias for cost'
     'usage:Show skill usage'
     'us:Alias for usage'
@@ -626,11 +626,10 @@ _skillio() {
       if [[ \${words[CURRENT]} == -* ]]; then
         _values 'flag' \\
           '-g[global scope]' '--global[global scope]' \\
-          '--all[remove every skill in scope]' \\
-          '--dry-run[print plan without deleting]' \\
           '-y[skip confirmation]' '--yes[skip confirmation]' \\
-          '--force-lock[also remove lock entry]' \\
-          '--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
@@ -671,18 +670,20 @@ function __skillio_using_subcommand
   test "$cmd[2]" = "$argv[1]"
 end
 
-complete -c skl -n __skillio_needs_command -a 'list ls remove rm cost co cst usage us usg completion'
-complete -c skillio -n __skillio_needs_command -a 'list ls remove rm cost co cst usage us usg completion'
+complete -c skl -n __skillio_needs_command -a 'list ls remove rm cost cs cst usage us usg completion'
+complete -c skillio -n __skillio_needs_command -a 'list ls remove rm cost cs cst usage us usg completion'
 
 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 all -d 'Remove every skill in 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" -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
@@ -881,13 +882,9 @@ var listCommand = defineCommand({
     const claudeNames = rows.claude.names.map((n) => n.name);
     const agentsNames = rows.agents.names.map((n) => n.name);
     const lockNames = rows.lock.names.map((n) => n.name);
-    const lockOnly = lockNames.filter((n) => !claudeNames.includes(n) && !agentsNames.includes(n));
     const claudeNotInLock = claudeNames.filter((n) => !lockNames.includes(n));
     const agentsNotInLock = agentsNames.filter((n) => !lockNames.includes(n));
     const diffs = [];
-    if (lockOnly.length) {
-      diffs.push(`skills-lock.json has ${lockOnly.length} skill${lockOnly.length === 1 ? "" : "s"} missing on disk: ${lockOnly.map(cyan).join(", ")}`);
-    }
     if (claudeNotInLock.length) {
       diffs.push(`.claude/skills has ${claudeNotInLock.length} skill${claudeNotInLock.length === 1 ? "" : "s"} not in lock: ${claudeNotInLock.map(cyan).join(", ")}`);
     }
@@ -903,7 +900,7 @@ var listCommand = defineCommand({
 });
 
 // src/commands/remove.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync3, lstatSync as lstatSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
 
@@ -916,13 +913,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);
@@ -969,6 +966,26 @@ 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";
@@ -992,6 +1009,21 @@ 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) {
@@ -1005,103 +1037,136 @@ function rmSkillDir(path, opts) {
 }
 
 // src/commands/remove.ts
-var q = (name) => `"${cyan(name)}"`;
+function buildLocation(dir) {
+  if (!existsSync3(dir))
+    return { kind: "missing", folders: 0, files: 0 };
+  if (lstatSync3(dir).isSymbolicLink())
+    return { kind: "symlink", folders: 0, files: 0 };
+  const { folders, files } = countFoldersAndFiles(dir);
+  return { kind: "real", 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 files = 0;
+  let symlinks = 0;
+  for (const info of infos) {
+    if (info.kind === "real") {
+      folders += info.folders;
+      files += info.files;
+    } else if (info.kind === "symlink") {
+      symlinks += 1;
+    }
   }
-  return n;
+  return { folders, 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 diskLine(label, singleName, infos, variant) {
+  const displayLabel = singleName ? `${label}/${singleName}/` : label;
+  const agg = aggregateLocations(infos);
+  if (!agg.found)
+    return `  ${displayLabel}  (not found)`;
+  const parts = [];
+  if (agg.folders > 0 || agg.files > 0) {
+    const text = `${plural(agg.folders, "folder")}, ${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 `  ${displayLabel}  (${parts.join(", ")})`;
+}
+function lockLine(n, variant) {
+  const label = "skills-lock.json";
+  if (n === 0)
+    return `  ${label}  (not in lock)`;
+  if (variant === "kept")
+    return `  ${green(`${label}  (${plural(n, "line")} kept)`)}`;
+  return `  ${red(`${label}  (${plural(n, "line")})`)}`;
+}
+function printBlock(targets, scope, verb, lockLinesToRemove, diskVariant, lockVariant) {
+  console.log(header(targets, verb));
+  const singleName = targets.length === 1 ? targets[0]?.name : undefined;
+  if (scope === "all" || scope === "agents-only") {
+    console.log(diskLine(".agents/skills", singleName, targets.map((t) => t.agents), diskVariant));
+  }
+  if (scope === "all" || scope === "claude-only") {
+    console.log(diskLine(".claude/skills", singleName, targets.map((t) => t.claude), diskVariant));
+  }
+  if (scope === "all" || scope === "lock-only") {
+    console.log(lockLine(lockLinesToRemove, lockVariant));
   }
-  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" },
-    all: { type: "boolean", default: false, description: "Remove every skill in scope" },
-    "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: "Remove only the skills-lock.json entry; keep on-disk directories"
+      description: "Only remove from .agents/skills; keep .claude/skills and the lock entry"
+    },
+    "claude-only": {
+      type: "boolean",
+      alias: "co",
+      default: false,
+      description: "Only remove from .claude/skills; keep .agents/skills and the lock entry"
     }
   },
   async run({ args }) {
     const {
       global: isGlobal,
-      "dry-run": dryRun,
       yes,
-      all,
-      "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 names = process.argv.slice(subcmdIdx + 1).filter((a) => !a.startsWith("-"));
+    const rawNames = process.argv.slice(subcmdIdx + 1).filter((a) => !a.startsWith("-"));
+    const all = rawNames.includes(".");
+    const names = rawNames.filter((n) => n !== ".");
     if (all && names.length > 0) {
-      console.error("--all is mutually exclusive with positional skill names");
+      console.error('"." (all skills) is mutually exclusive with positional skill names');
       process.exit(1);
     }
     if (!all && names.length === 0) {
@@ -1114,83 +1179,47 @@ 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;
-    if (all) {
-      const subject = lockOnly ? `ALL ${plans.length} lock entries (disk preserved)` : `ALL ${plans.length} skills`;
-      const interactive = process.stdin.isTTY && process.stdout.isTTY;
-      if (interactive) {
-        const phrase = await promptText(`This will remove ${subject}. Type "all" to confirm:`);
-        if (phrase !== "all") {
-          console.log("Aborted");
-          process.exit(1);
-        }
-      } else if (!yes) {
-        const ok = await confirm(`Remove ${subject}?`);
-        if (!ok) {
-          console.log("Aborted");
-          process.exit(1);
-        }
-      }
-    } else if (!yes) {
-      const ok = await confirm("Proceed?");
+    const lockLinesToRemove = countLockLinesToRemove(lockPath, targets.map((t) => t.name));
+    printBlock(targets, scope, "will be removed from:", lockLinesToRemove, "plan", "removed");
+    const ask = createConfirmer();
+    if (!yes) {
+      const ok = await ask("Proceed?");
       if (!ok) {
         console.log("Aborted");
         process.exit(1);
       }
     }
     const allowedRoots = [isGlobal ? homedir2() : dirname2(resolve3(lockPath)), homedir2()];
-    for (const { target } of plans) {
-      if (target.inLock) {
-        if (lockOnly || modifyLock) {
-          const r = removeSkillFromLock(lockPath, target.name);
-          if (r.removed)
-            console.log(`Removed ${q(target.name)} from skills-lock.json`);
-        } else {
-          console.log(`Kept ${q(target.name)} in skills-lock.json (no --force-lock)`);
-        }
-      } else {
-        console.log(`Skipped skills-lock.json (not in lock)`);
-      }
-      if (lockOnly) {
-        if (target.claudeDir)
-          console.log(`Kept .claude/skills/${target.name}/ (--lock-only)`);
-        else
-          console.log("Skipped .claude/skills (not found)");
-        if (target.agentsDir)
-          console.log(`Kept .agents/skills/${target.name}/ (--lock-only)`);
-        else
-          console.log("Skipped .agents/skills (not found)");
-        continue;
-      }
-      if (target.claudeDir) {
-        const r = rmSkillDir(target.claudeDir, { allowedRoots });
-        console.log(`Removed ${q(target.name)} from .claude/skills (${r.fileCount} files)`);
-      } else {
-        console.log("Skipped .claude/skills (not found)");
-      }
-      if (target.agentsDir) {
-        const r = rmSkillDir(target.agentsDir, { allowedRoots });
-        console.log(`Removed ${q(target.name)} from .agents/skills (${r.fileCount} files)`);
-      } else {
-        console.log("Skipped .agents/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) {
+      const cleanLock = yes || await ask(`Clean skills-lock.json (${plural(lockLinesToRemove, "line")})?`);
+      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");
   }
 });
 
@@ -1962,7 +1991,7 @@ var SUBCOMMAND_NAMES = new Set([
   "remove",
   "rm",
   "cost",
-  "co",
+  "cs",
   "cst",
   "usage",
   "us",
@@ -1999,8 +2028,8 @@ 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",
-    "  cost, co, cst    Show ambient ballast cost (per-skill frontmatter tokens) sorted desc",
+    "  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)"
   ];
@@ -2023,31 +2052,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 --all 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)",
-    "      --all        Remove every skill in scope (mutually exclusive with SKILL)",
-    "      --dry-run    Print plan without deleting",
-    "  -y, --yes        Skip confirmation prompt (non-TTY only for --all)",
-    "      --force-lock Also remove entry from skills-lock.json (default: lock preserved)",
-    "      --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 --all --dry-run",
-    "  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(`
 `));
@@ -2097,7 +2125,7 @@ var main = defineCommand({
       return;
     const interactive = process.stdout.isTTY && process.stdin.isTTY;
     if (interactive) {
-      const { runPicker } = await import("./shared/chunk-ajnqh9j9.js");
+      const { runPicker } = await import("./shared/chunk-dwrjph29.js");
       const status = await runPicker({
         global: args.global ?? false
       });
@@ -2115,7 +2143,7 @@ var main = defineCommand({
     remove: removeCommand,
     rm: removeCommand,
     cost: costCommand,
-    co: costCommand,
+    cs: costCommand,
     cst: costCommand,
     usage: usageCommand,
     us: usageCommand,