skillio 0.1.9 → 0.1.11

package/dist/cli.js

@@ -1,9 +1,20 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+import {
+  __require,
+  cyan,
+  detectColorSupport,
+  discoverSkills,
+  getLockPath,
+  green,
+  readLock,
+  red,
+  removeSkillFromLock,
+  setColorEnabled,
+  yellow
+} from "./shared/chunk-0qvp6v8g.js";
 
 // src/cli.ts
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire } from "node:module";
 
 // node_modules/citty/dist/_chunks/libs/scule.mjs
 var NUMBER_CHAR_RE = /\d/;
@@ -222,7 +233,7 @@ var noColor = /* @__PURE__ */ (() => {
 })();
 var _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
 var bold = /* @__PURE__ */ _c(1, 22);
-var cyan = /* @__PURE__ */ _c(36);
+var cyan2 = /* @__PURE__ */ _c(36);
 var gray = /* @__PURE__ */ _c(90);
 var underline = /* @__PURE__ */ _c(4, 24);
 function parseArgs(rawArgs, argsDef) {
@@ -274,7 +285,7 @@ function parseArgs(rawArgs, argsDef) {
       const argument = parsedArgsProxy[arg.name];
       const options = arg.options || [];
       if (argument !== undefined && options.length > 0 && !options.includes(argument))
-        throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
+        throw new CLIError(`Invalid value for argument: ${cyan2(`--${arg.name}`)} (${cyan2(argument)}). Expected one of: ${options.map((o) => cyan2(o)).join(", ")}.`, "EARG");
     } else if (arg.required && parsedArgsProxy[arg.name] === undefined)
       throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
   return parsedArgsProxy;
@@ -319,7 +330,7 @@ async function runCommand(cmd, opts) {
       if (explicitName) {
         const subCommand = await _findSubCommand(subCommands, explicitName);
         if (!subCommand)
-          throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+          throw new CLIError(`Unknown command ${cyan2(explicitName)}`, "E_UNKNOWN_COMMAND");
         await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
       } else {
         const defaultSubCommand = await resolveValue(cmd.default);
@@ -328,7 +339,7 @@ async function runCommand(cmd, opts) {
             throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
           const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
           if (!subCommand)
-            throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+            throw new CLIError(`Default sub command ${cyan2(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
           await runCommand(subCommand, { rawArgs: opts.rawArgs });
         } else if (!cmd.run)
           throw new CLIError(`No command specified.`, "E_NO_COMMAND");
@@ -432,15 +443,15 @@ async function renderUsage(cmd, parent) {
     if (arg.type === "positional") {
       const name = arg.name.toUpperCase();
       const isRequired = arg.required !== false && arg.default === undefined;
-      posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
+      posLines.push([cyan2(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
       usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
     } else {
       const isRequired = arg.required === true && arg.default === undefined;
       const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
-      argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
+      argLines.push([cyan2(argStr), renderDescription(arg, isRequired)]);
       if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
         const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
-        argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
+        argLines.push([cyan2(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
       }
       if (isRequired)
         usageLine.push(`--${arg.name}` + renderValueHint(arg));
@@ -454,7 +465,7 @@ async function renderUsage(cmd, parent) {
         continue;
       const aliases = toArray(meta?.alias);
       const label = [name, ...aliases].join(", ");
-      commandsLines.push([cyan(label), meta?.description || ""]);
+      commandsLines.push([cyan2(label), meta?.description || ""]);
       commandNames.push(name, ...aliases);
     }
     usageLine.push(commandNames.join("|"));
@@ -463,7 +474,7 @@ async function renderUsage(cmd, parent) {
   const version = cmdMeta.version || parentMeta.version;
   usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
   const hasOptions = argLines.length > 0 || posLines.length > 0;
-  usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+  usageLines.push(`${underline(bold("USAGE"))} ${cyan2(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
   if (posLines.length > 0) {
     usageLines.push(underline(bold("ARGUMENTS")), "");
     usageLines.push(formatLineColumns(posLines, "  "));
@@ -477,7 +488,7 @@ async function renderUsage(cmd, parent) {
   if (commandsLines.length > 0) {
     usageLines.push(underline(bold("COMMANDS")), "");
     usageLines.push(formatLineColumns(commandsLines, "  "));
-    usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+    usageLines.push("", `Use ${cyan2(`${commandName} <command> --help`)} for more information about a command.`);
   }
   return usageLines.filter((l) => typeof l === "string").join(`
 `);
@@ -547,138 +558,6 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
   return [`--${long}`, `-${short}`];
 }
 
-// src/lock/file.ts
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-function getLockPath(global) {
-  return global ? join(homedir(), ".agents", ".skill-lock.json") : "skills-lock.json";
-}
-function readLock(path) {
-  if (!existsSync(path))
-    return { skills: {} };
-  return JSON.parse(readFileSync(path, "utf8"));
-}
-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)}
-`);
-  renameSync(tmp, path);
-}
-function removeSkillFromLock(path, skill) {
-  if (!existsSync(path))
-    return { removed: false };
-  const lock = readLock(path);
-  if (!Object.hasOwn(lock.skills, skill))
-    return { removed: false };
-  delete lock.skills[skill];
-  writeLock(path, lock);
-  return { removed: true };
-}
-
-// src/utils/ansi.ts
-var enabled = false;
-function setColorEnabled(value) {
-  enabled = value;
-}
-function detectColorSupport() {
-  if (process.env.NO_COLOR)
-    return false;
-  return Boolean(process.stdout.isTTY);
-}
-function green(s) {
-  return enabled ? `\x1B[32m${s}\x1B[0m` : s;
-}
-function yellow(s) {
-  return enabled ? `\x1B[33m${s}\x1B[0m` : s;
-}
-function red(s) {
-  return enabled ? `\x1B[31m${s}\x1B[0m` : s;
-}
-function cyan2(s) {
-  return enabled ? `\x1B[36m${s}\x1B[0m` : s;
-}
-
-// src/utils/discover-skills.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
-
-// src/utils/skill-files.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join2, resolve } from "node:path";
-var CHARS_PER_TOKEN = 4;
-function extractFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  return match?.[1];
-}
-function estimateTokens(text) {
-  return Math.round(text.length / CHARS_PER_TOKEN);
-}
-
-// src/utils/discover-skills.ts
-function resolveRoots(input) {
-  if (input.isGlobal) {
-    return {
-      claude: join3(homedir3(), ".claude", "skills"),
-      agents: join3(homedir3(), ".agents", "skills")
-    };
-  }
-  const repo = dirname3(resolve2(input.lockPath));
-  return {
-    claude: join3(repo, ".claude", "skills"),
-    agents: join3(repo, ".agents", "skills")
-  };
-}
-function listSkillNames(root) {
-  if (!root || !existsSync3(root))
-    return [];
-  return readdirSync(root).filter((name) => {
-    const skill = join3(root, name, "SKILL.md");
-    return existsSync3(skill) && statSync(skill).isFile();
-  });
-}
-function tokensFromFile(path) {
-  const content = readFileSync3(path, "utf8");
-  const fm = extractFrontmatter(content);
-  if (fm === undefined)
-    return { status: "no-frontmatter" };
-  return { tokens: estimateTokens(fm), status: "ok" };
-}
-function discoverSkills(input) {
-  const roots = resolveRoots(input);
-  const lock = readLock(input.lockPath);
-  const lockNames = Object.keys(lock.skills);
-  const claudeNames = listSkillNames(roots.claude);
-  const agentsNames = listSkillNames(roots.agents);
-  const all = new Set([...lockNames, ...claudeNames, ...agentsNames]);
-  const out = new Map;
-  for (const name of all) {
-    const sources = [];
-    if (lockNames.includes(name))
-      sources.push("lock");
-    if (claudeNames.includes(name))
-      sources.push(".claude");
-    if (agentsNames.includes(name))
-      sources.push(".agents");
-    let skillFile;
-    if (claudeNames.includes(name) && roots.claude) {
-      skillFile = join3(roots.claude, name, "SKILL.md");
-    } else if (agentsNames.includes(name) && roots.agents) {
-      skillFile = join3(roots.agents, name, "SKILL.md");
-    }
-    if (!skillFile) {
-      out.set(name, { name, sources, status: "missing" });
-      continue;
-    }
-    const { tokens, status } = tokensFromFile(skillFile);
-    out.set(name, { name, sources, skillFile, frontmatterTokens: tokens, status });
-  }
-  return out;
-}
-
 // src/commands/cost.ts
 function classify(total) {
   if (total < 1000)
@@ -705,23 +584,28 @@ var costCommand = defineCommand({
     const rows = sortRows([...map.values()]);
     const total = rows.reduce((acc, r) => acc + (r.frontmatterTokens ?? 0), 0);
     const { message, paint } = classify(total);
-    console.log(args.global ? "Global" : "Local");
     console.log("");
+    console.log(args.global ? "Global" : "Local");
     if (rows.length === 0) {
       console.log(`No skills in ${lockPath}`);
       return;
     }
     const nameWidth = Math.max(...rows.map((r) => r.name.length));
+    const tokenWidth = Math.max(...rows.map((r) => r.status === "ok" ? `~${r.frontmatterTokens} tok`.length : r.status === "missing" ? "~? tok".length : "(no frontmatter)".length));
     for (const r of rows) {
-      let cell;
-      if (r.status === "ok")
-        cell = `~${r.frontmatterTokens} tok`;
-      else if (r.status === "missing")
-        cell = "missing";
-      else
-        cell = "(no frontmatter)";
-      const pad = " ".repeat(nameWidth - r.name.length);
-      console.log(`${cyan2(r.name)}${pad}  ${cell}`);
+      let tokenCell;
+      let suffix = "";
+      if (r.status === "ok") {
+        tokenCell = `~${r.frontmatterTokens} tok`;
+      } else if (r.status === "missing") {
+        tokenCell = "~? tok";
+        suffix = `  ${red("missing")}`;
+      } else {
+        tokenCell = "(no frontmatter)";
+      }
+      const namePad = " ".repeat(nameWidth - r.name.length);
+      const tokenPad = " ".repeat(Math.max(0, tokenWidth - tokenCell.length));
+      console.log(`${cyan(r.name)}${namePad}  ${tokenCell}${tokenPad}${suffix}`);
     }
     console.log("");
     console.log(`Total: ~${total} tok across ${rows.length} skills    ${paint(message)}`);
@@ -729,82 +613,99 @@ var costCommand = defineCommand({
 });
 
 // src/commands/list.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { dirname as dirname4, join as join4, resolve as resolve3 } from "node:path";
-function bySource(records) {
-  const claudeNames = records.filter((r) => r.sources.includes(".claude")).map((r) => r.name).sort();
-  const agentsNames = records.filter((r) => r.sources.includes(".agents")).map((r) => r.name).sort();
-  const lockNames = records.filter((r) => r.sources.includes("lock")).map((r) => r.name).sort();
-  const sumTokens = (names) => names.reduce((acc, n) => acc + (records.find((r) => r.name === n)?.frontmatterTokens ?? 0), 0);
+import { existsSync, lstatSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+function rootFor(isGlobal, lockPath, kind) {
+  if (isGlobal)
+    return join(homedir(), kind, "skills");
+  return join(dirname(resolve(lockPath)), kind, "skills");
+}
+function getInstall(root, name) {
+  const dir = join(root, name);
+  if (!existsSync(dir))
+    return;
+  return lstatSync(dir).isSymbolicLink() ? "symlink" : "real";
+}
+function paintDisk(n) {
+  if (n.install === "symlink")
+    return yellow(n.name);
+  if (n.install === "real")
+    return green(n.name);
+  return cyan(n.name);
+}
+function bySource(records, roots) {
+  const claudeRecords = records.filter((r) => r.sources.includes(".claude"));
+  const agentsRecords = records.filter((r) => r.sources.includes(".agents"));
+  const lockRecords = records.filter((r) => r.sources.includes("lock"));
+  const claudeNames = claudeRecords.map((r) => ({ name: r.name, install: getInstall(roots.claude, r.name) })).sort((a, b) => a.name.localeCompare(b.name));
+  const agentsNames = agentsRecords.map((r) => ({ name: r.name, install: getInstall(roots.agents, r.name) })).sort((a, b) => a.name.localeCompare(b.name));
+  const lockNames = lockRecords.map((r) => ({ name: r.name })).sort((a, b) => a.name.localeCompare(b.name));
   return {
-    claude: {
-      label: ".claude/skills",
-      names: claudeNames,
-      tokens: sumTokens(claudeNames),
-      exists: true
-    },
-    agents: {
-      label: ".agents/skills",
-      names: agentsNames,
-      tokens: sumTokens(agentsNames),
-      exists: true
-    },
-    lock: {
-      label: "skills-lock.json",
-      names: lockNames,
-      tokens: sumTokens(lockNames),
-      exists: true
-    }
+    agents: { label: ".agents/skills", names: agentsNames, totalCount: agentsNames.length },
+    claude: { label: ".claude/skills", names: claudeNames, totalCount: claudeNames.length },
+    lock: { label: "skills-lock.json", names: lockNames, totalCount: lockNames.length }
   };
 }
-function agentsDirExists(isGlobal, lockPath) {
-  if (isGlobal) {
-    return existsSync4(join4(process.env.HOME ?? "", ".agents", "skills"));
-  }
-  return existsSync4(join4(dirname4(resolve3(lockPath)), ".agents", "skills"));
-}
 var listCommand = defineCommand({
-  meta: { description: "List skills per source with totals and lock-vs-disk diff" },
+  meta: { description: "List skills per source with install-type coloring and lock orphan filter" },
   args: {
     global: { type: "boolean", alias: "g", default: false, description: "Use global scope" }
   },
   run({ args }) {
     const lockPath = getLockPath(args.global);
-    const map = discoverSkills({ isGlobal: args.global, cwd: process.cwd(), lockPath });
-    const records = [...map.values()];
-    const rows = bySource(records);
-    const showAgents = agentsDirExists(args.global, lockPath) || rows.agents.names.length > 0;
-    const claudeNames = rows.claude.names;
-    const agentsNames = rows.agents.names;
-    const lockNames = rows.lock.names;
-    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 sourceRows = [rows.claude];
-    if (showAgents)
-      sourceRows.push(rows.agents);
-    sourceRows.push(rows.lock);
-    const labelWidth = Math.max(...sourceRows.map((r) => r.label.length));
-    const countCells = sourceRows.map((r) => r.names.length === 0 ? "(empty)" : `${r.names.length} skill${r.names.length === 1 ? "" : "s"}`);
+    const records = [
+      ...discoverSkills({ isGlobal: args.global, cwd: process.cwd(), lockPath }).values()
+    ];
+    const roots = {
+      claude: rootFor(args.global, lockPath, ".claude"),
+      agents: rootFor(args.global, lockPath, ".agents")
+    };
+    const rows = bySource(records, roots);
+    const claudeSet = new Set(rows.claude.names.map((n) => n.name));
+    const agentsSet = new Set(rows.agents.names.map((n) => n.name));
+    const orphans = rows.lock.names.filter((n) => !claudeSet.has(n.name) && !agentsSet.has(n.name));
+    const sourceRows = [
+      {
+        row: rows.agents,
+        render: () => rows.agents.names.map(paintDisk).join(" ")
+      },
+      {
+        row: rows.claude,
+        render: () => rows.claude.names.map(paintDisk).join(" ")
+      },
+      {
+        row: rows.lock,
+        render: () => orphans.length === 0 ? green("All skills onboard!") : orphans.map((n) => red(n.name)).join(" ")
+      }
+    ];
+    const labelWidth = Math.max(...sourceRows.map((r) => r.row.label.length));
+    const countCells = sourceRows.map((r) => `${r.row.totalCount} skill${r.row.totalCount === 1 ? "" : "s"}`);
     const countWidth = Math.max(...countCells.map((c) => c.length));
     for (let i = 0;i < sourceRows.length; i++) {
-      const row = sourceRows[i];
-      if (!row)
+      const entry = sourceRows[i];
+      if (!entry)
         continue;
       const countCell = countCells[i] ?? "";
-      const namesText = row.names.length ? row.names.map(cyan2).join(" ") : "";
-      const line = `${row.label.padEnd(labelWidth)} : ${countCell.padEnd(countWidth)}${namesText ? ` : ${namesText}` : ""}`;
+      const namesText = entry.render();
+      const line = `${entry.row.label.padEnd(labelWidth)} : ${countCell.padEnd(countWidth)}${namesText ? ` : ${namesText}` : ""}`;
       console.log(line.trimEnd());
     }
+    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(cyan2).join(", ")}`);
+      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(cyan2).join(", ")}`);
+      diffs.push(`.claude/skills has ${claudeNotInLock.length} skill${claudeNotInLock.length === 1 ? "" : "s"} not in lock: ${claudeNotInLock.map(cyan).join(", ")}`);
     }
     if (agentsNotInLock.length) {
-      diffs.push(`.agents/skills has ${agentsNotInLock.length} skill${agentsNotInLock.length === 1 ? "" : "s"} not in lock: ${agentsNotInLock.map(cyan2).join(", ")}`);
+      diffs.push(`.agents/skills has ${agentsNotInLock.length} skill${agentsNotInLock.length === 1 ? "" : "s"} not in lock: ${agentsNotInLock.map(cyan).join(", ")}`);
     }
     if (diffs.length) {
       console.log("");
@@ -815,46 +716,92 @@ var listCommand = defineCommand({
 });
 
 // src/commands/remove.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname5, join as join6, resolve as resolve5 } from "node:path";
+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";
 
 // src/utils/confirm.ts
-import { createInterface } from "node:readline/promises";
+import { emitKeypressEvents } from "node:readline";
 async function confirm(question, opts = {}) {
   const input = opts.input ?? process.stdin;
   const output = opts.output ?? process.stdout;
-  const rl = createInterface({
-    input,
-    output
-  });
-  try {
-    const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
-    return answer === "y" || answer === "yes";
-  } finally {
-    rl.close();
+  if (!input.isTTY || !output.isTTY) {
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input, output });
+    try {
+      const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+      return answer === "y" || answer === "yes";
+    } finally {
+      rl.close();
+    }
   }
+  output.write(`${question} [y/N] `);
+  emitKeypressEvents(input);
+  if (input.setRawMode)
+    input.setRawMode(true);
+  input.resume();
+  return new Promise((resolve2) => {
+    const onKey = (str, key) => {
+      const lower = (str ?? "").toLowerCase();
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        output.write(`
+`);
+        resolve2(false);
+        return;
+      }
+      if (lower === "y") {
+        cleanup();
+        output.write(`y
+`);
+        resolve2(true);
+        return;
+      }
+      if (lower === "n" || key.name === "return" || key.name === "escape" || lower === "q") {
+        cleanup();
+        output.write(`${lower || "n"}
+`);
+        resolve2(false);
+        return;
+      }
+    };
+    function onSigterm() {
+      cleanup();
+      output.write(`
+`);
+      resolve2(false);
+    }
+    function cleanup() {
+      input.removeListener("keypress", onKey);
+      process.removeListener("SIGTERM", onSigterm);
+      if (input.setRawMode)
+        input.setRawMode(false);
+      input.pause();
+    }
+    process.once("SIGTERM", onSigterm);
+    input.on("keypress", onKey);
+  });
 }
 
 // src/utils/fs-rm.ts
-import { existsSync as existsSync5, lstatSync, readdirSync as readdirSync2, rmSync } from "node:fs";
-import { join as join5, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync2, lstatSync as lstatSync2, readdirSync, rmSync } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
 function isInside(target, root) {
-  const t = resolve4(target);
-  const r = resolve4(root);
+  const t = resolve2(target);
+  const r = resolve2(root);
   return t === r || t.startsWith(`${r}/`);
 }
 function countFiles(path) {
-  if (!existsSync5(path))
+  if (!existsSync2(path))
     return 0;
-  const stat = lstatSync(path);
+  const stat = lstatSync2(path);
   if (stat.isFile())
     return 1;
   if (!stat.isDirectory())
     return 0;
   let n = 0;
-  for (const entry of readdirSync2(path)) {
-    n += countFiles(join5(path, entry));
+  for (const entry of readdirSync(path)) {
+    n += countFiles(join2(path, entry));
   }
   return n;
 }
@@ -863,7 +810,7 @@ function rmSkillDir(path, opts) {
   if (!safe) {
     throw new Error(`Refusing to delete: "${path}" is outside allowed roots`);
   }
-  if (!existsSync5(path))
+  if (!existsSync2(path))
     return { removed: false, fileCount: 0 };
   const fileCount = countFiles(path);
   rmSync(path, { recursive: true, force: true });
@@ -871,38 +818,46 @@ function rmSkillDir(path, opts) {
 }
 
 // src/commands/remove.ts
-var q = (name) => `"${cyan2(name)}"`;
+var q = (name) => `"${cyan(name)}"`;
 function buildTarget(name, isGlobal, lockPath) {
   const lock = readLock(lockPath);
   const inLock = Object.hasOwn(lock.skills, name);
-  const baseClaude = isGlobal ? join6(homedir4(), ".claude", "skills") : join6(dirname5(resolve5(lockPath)), ".claude", "skills");
-  const baseAgents = isGlobal ? join6(homedir4(), ".agents", "skills") : join6(dirname5(resolve5(lockPath)), ".agents", "skills");
-  const claudeDir = existsSync6(join6(baseClaude, name)) ? join6(baseClaude, name) : undefined;
-  const agentsDir = existsSync6(join6(baseAgents, name)) ? join6(baseAgents, name) : undefined;
+  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 };
 }
+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: readdirSync3, statSync: statSync2 } = __require("node:fs");
+  const { readdirSync: readdirSync2, statSync } = __require("node:fs");
   let n = 0;
   const stack = [dir];
   while (stack.length) {
     const cur = stack.pop();
-    const stat = statSync2(cur);
+    const stat = statSync(cur);
     if (stat.isFile())
       n++;
     else if (stat.isDirectory())
-      for (const e of readdirSync3(cur))
-        stack.push(join6(cur, e));
+      for (const e of readdirSync2(cur))
+        stack.push(join3(cur, e));
   }
   return n;
 }
-function printPlan(plan) {
+function printPlan(plan, modifyLock) {
   const { target } = plan;
   console.log(`Will remove ${q(target.name)}:`);
-  if (target.inLock)
-    console.log("  - skills-lock.json");
-  else
+  if (target.inLock) {
+    if (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 (target.claudeDir)
     console.log(`  - .claude/skills/${target.name}/  (${plan.claudeFileCount} files)`);
   else
@@ -913,22 +868,38 @@ function printPlan(plan) {
     console.log("  - .agents/skills/  (not found)");
 }
 var removeCommand = defineCommand({
-  meta: { description: "Remove one or more skills from lock and delete their on-disk directories" },
+  meta: {
+    description: "Remove one or more skills from on-disk dirs (lock preserved unless --force-lock)"
+  },
   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" }
+    yes: { type: "boolean", alias: "y", default: false, description: "Skip confirmation prompt" },
+    all: { type: "boolean", default: false, description: "Remove every skill in scope" },
+    "force-lock": {
+      type: "boolean",
+      default: false,
+      description: "Also remove entry from skills-lock.json (default is to keep lock untouched)"
+    }
   },
   async run({ args }) {
-    const { global: isGlobal, "dry-run": dryRun, yes } = args;
+    const { global: isGlobal, "dry-run": dryRun, yes, all, "force-lock": modifyLock } = args;
     const subcmdIdx = process.argv.findIndex((a) => a === "remove" || a === "rm");
     const names = process.argv.slice(subcmdIdx + 1).filter((a) => !a.startsWith("-"));
-    if (names.length === 0) {
+    if (all && names.length > 0) {
+      console.error("--all is mutually exclusive with positional skill names");
+      process.exit(1);
+    }
+    if (!all && names.length === 0) {
       console.error("No skill names provided");
       process.exit(1);
     }
     const lockPath = getLockPath(isGlobal);
-    const targets = names.map((n) => buildTarget(n, isGlobal, lockPath));
+    const targets = all ? collectAllTargets(isGlobal, lockPath) : names.map((n) => buildTarget(n, isGlobal, lockPath));
+    if (all && targets.length === 0) {
+      console.log("No skills to remove in scope.");
+      return;
+    }
     const orphan = targets.filter((t) => !t.inLock && !t.claudeDir && !t.agentsDir);
     if (orphan.length) {
       for (const o of orphan)
@@ -941,27 +912,29 @@ var removeCommand = defineCommand({
       agentsFileCount: t.agentsDir ? fileCount(t.agentsDir) : undefined
     }));
     for (const p of plans) {
-      printPlan(p);
+      printPlan(p, modifyLock);
       console.log("");
     }
     if (dryRun)
       return;
     if (!yes) {
-      const ok = await confirm("Proceed?");
+      const promptText = all ? `Remove ALL ${plans.length} skills?` : "Proceed?";
+      const ok = await confirm(promptText);
       if (!ok) {
         console.log("Aborted");
         process.exit(1);
       }
     }
-    const allowedRoots = [
-      isGlobal ? homedir4() : dirname5(resolve5(lockPath)),
-      homedir4()
-    ];
+    const allowedRoots = [isGlobal ? homedir2() : dirname2(resolve3(lockPath)), homedir2()];
     for (const { target } of plans) {
       if (target.inLock) {
-        const r = removeSkillFromLock(lockPath, target.name);
-        if (r.removed)
-          console.log(`Removed ${q(target.name)} from skills-lock.json`);
+        if (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)`);
       }
@@ -982,11 +955,90 @@ var removeCommand = defineCommand({
 });
 
 // src/commands/usage.ts
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join7 } from "node:path";
 
 // src/readers/claude.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// src/utils/codex-cmd.ts
+var READ_LIKE = new Set(["cat", "sed", "head", "tail", "bat", "batcat", "less", "more"]);
+var SKILL_PATH_RE = /[^\s'"`]*\/([^\s'"`/]+)\/SKILL\.md/g;
+function stripHeredocs(s) {
+  return s.replace(/<<-?\s*['"]?(\w+)['"]?[\s\S]*?\n[\t ]*\1\s*(?:\n|$)/g, "");
+}
+function splitTopLevel(s) {
+  const out = [];
+  let buf = "";
+  let i = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  while (i < s.length) {
+    const c = s[i];
+    const next = s[i + 1];
+    if (!inDouble && !inBacktick && c === "'") {
+      inSingle = !inSingle;
+      buf += c;
+      i++;
+      continue;
+    }
+    if (!inSingle && !inBacktick && c === '"') {
+      inDouble = !inDouble;
+      buf += c;
+      i++;
+      continue;
+    }
+    if (!inSingle && !inDouble && c === "`") {
+      inBacktick = !inBacktick;
+      buf += c;
+      i++;
+      continue;
+    }
+    if (!inSingle && !inDouble && !inBacktick) {
+      if (c === "&" && next === "&" || c === "|" && next === "|") {
+        out.push(buf);
+        buf = "";
+        i += 2;
+        continue;
+      }
+      if (c === ";" || c === "|") {
+        out.push(buf);
+        buf = "";
+        i++;
+        continue;
+      }
+    }
+    buf += c;
+    i++;
+  }
+  out.push(buf);
+  return out;
+}
+function hasRedirect(segment) {
+  return /(?<![<2])>>?|&>>?/.test(segment);
+}
+function extractSkillReadsFromCmd(cmd) {
+  const stripped = stripHeredocs(cmd);
+  const segments = splitTopLevel(stripped);
+  const found = new Set;
+  for (const seg of segments) {
+    if (hasRedirect(seg))
+      continue;
+    const trimmed = seg.trimStart();
+    const firstTokenMatch = trimmed.match(/^(\S+)/);
+    if (!firstTokenMatch)
+      continue;
+    const firstToken = firstTokenMatch[1] ?? "";
+    if (!READ_LIKE.has(firstToken))
+      continue;
+    for (const m of seg.matchAll(SKILL_PATH_RE)) {
+      if (m[1])
+        found.add(m[1]);
+    }
+  }
+  return [...found];
+}
 
 // src/utils/walk.ts
 function walk(value, visit) {
@@ -1061,12 +1113,7 @@ function extractCodexActivations(entry) {
     const cmd = parsed?.cmd;
     if (typeof cmd !== "string")
       return [];
-    const paths = new Set;
-    for (const m of cmd.matchAll(/(?:^|['"\s])([^'"\s]+\/SKILL\.md)(?=$|['"\s])/g)) {
-      if (m[1])
-        paths.add(m[1]);
-    }
-    return [...paths].map(skillNameFromPath).filter((s) => s !== null);
+    return extractSkillReadsFromCmd(cmd);
   }
   return [];
 }
@@ -1113,27 +1160,49 @@ function extractCodexMentions(entry) {
   return [...seen];
 }
 
+// src/utils/claude-entry.ts
+function isUserTurnEntry(entry) {
+  if (typeof entry !== "object" || entry === null)
+    return false;
+  const e = entry;
+  if (e.type !== "user")
+    return false;
+  const msg = e.message;
+  if (!msg || msg.role !== "user")
+    return false;
+  const content = msg.content;
+  if (typeof content === "string")
+    return true;
+  if (!Array.isArray(content))
+    return false;
+  return content.some((c) => {
+    if (typeof c !== "object" || c === null)
+      return false;
+    return c.type === "text";
+  });
+}
+
 // src/utils/expand-home.ts
-import { homedir as homedir5 } from "node:os";
-import { join as join7, resolve as resolve6 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join4, resolve as resolve4 } from "node:path";
 function expandHome(p) {
   if (p === "~")
-    return homedir5();
+    return homedir3();
   if (p.startsWith("~/"))
-    return join7(homedir5(), p.slice(2));
-  return resolve6(p);
+    return join4(homedir3(), p.slice(2));
+  return resolve4(p);
 }
 
 // src/utils/jsonl.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
-import { join as join8 } from "node:path";
+import { readdirSync as readdirSync2, readFileSync, statSync } from "node:fs";
+import { join as join5 } from "node:path";
 function* findJsonlFiles(dir, since) {
-  for (const item of readdirSync3(dir, { withFileTypes: true })) {
-    const path = join8(dir, item.name);
+  for (const item of readdirSync2(dir, { withFileTypes: true })) {
+    const path = join5(dir, item.name);
     if (item.isDirectory()) {
       yield* findJsonlFiles(path, since);
     } else if (item.isFile() && item.name.endsWith(".jsonl")) {
-      if (!since || statSync2(path).mtime >= since)
+      if (!since || statSync(path).mtime >= since)
         yield path;
     }
   }
@@ -1163,7 +1232,7 @@ function readClaudeUsage(options) {
     let prevSkill = null;
     const sessionAttr = new Map;
     const sessionAct = new Map;
-    for (const line of readFileSync5(file, "utf8").split(`
+    for (const line of readFileSync2(file, "utf8").split(`
 `)) {
       if (!line.trim())
         continue;
@@ -1183,6 +1252,8 @@ function readClaudeUsage(options) {
             sessionAttr.set(cur, (sessionAttr.get(cur) ?? 0) + 1);
           }
           prevSkill = cur;
+        } else if (isUserTurnEntry(entry)) {
+          prevSkill = null;
         }
       }
       if (options.mode === "activations" || options.mode === "merged") {
@@ -1214,14 +1285,14 @@ function readClaudeUsage(options) {
 }
 
 // src/readers/codex.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
 
 // src/utils/scope.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join6 } from "node:path";
 function detectScope(opts) {
-  const home = opts.home ?? homedir6();
+  const home = opts.home ?? homedir4();
   if (opts.global || opts.rootOverride)
     return { global: true };
   if (norm(opts.cwd) === norm(home))
@@ -1239,9 +1310,9 @@ function encodeClaudeProjectDir(absPath) {
 function findGitRoot(start) {
   let dir = start;
   while (true) {
-    if (existsSync7(join9(dir, ".git")))
+    if (existsSync4(join6(dir, ".git")))
       return dir;
-    const parent = dirname6(dir);
+    const parent = dirname3(dir);
     if (parent === dir)
       return;
     dir = parent;
@@ -1255,7 +1326,7 @@ function norm(p) {
 function readSessionCwd(file) {
   let head;
   try {
-    head = readFileSync6(file, "utf8");
+    head = readFileSync3(file, "utf8");
   } catch {
     return;
   }
@@ -1288,7 +1359,7 @@ function readCodexActivations(options) {
         continue;
     }
     filesRead++;
-    for (const line of readFileSync6(file, "utf8").split(`
+    for (const line of readFileSync3(file, "utf8").split(`
 `)) {
       if (!line.trim())
         continue;
@@ -1312,9 +1383,9 @@ function readCodexMentions(options) {
   const historyPath = expandHome(options.history ?? "~/.codex/history.jsonl");
   const counts = new Map;
   let linesRead = 0;
-  if (!existsSync8(historyPath))
+  if (!existsSync5(historyPath))
     return { counts, filesRead: 0, linesRead: 0 };
-  for (const line of readFileSync6(historyPath, "utf8").split(`
+  for (const line of readFileSync3(historyPath, "utf8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -1340,20 +1411,18 @@ var MINUTE_MS = 60 * SECOND_MS;
 var HOUR_MS = 60 * MINUTE_MS;
 var DAY_MS = 24 * HOUR_MS;
 var UNITS_MS = {
-  sec: SECOND_MS,
-  min: MINUTE_MS,
+  s: SECOND_MS,
+  m: MINUTE_MS,
   h: HOUR_MS,
   d: DAY_MS,
-  w: 7 * DAY_MS,
-  m: 30 * DAY_MS,
-  y: 365 * DAY_MS
+  w: 7 * DAY_MS
 };
 function parsePeriod(period) {
   if (period === "all")
     return Number.POSITIVE_INFINITY;
-  const match = period.match(/^(\d+)(sec|min|[hdwmy])$/);
+  const match = period.match(/^(\d+)([smhdw])$/);
   if (!match) {
-    throw new Error(`Invalid period: "${period}". Use values like 30sec, 5min, 12h, 7d, 2w, 1m, 1y, all.`);
+    throw new Error(`Invalid period: "${period}". Use values like 60s, 30m, 24h, 30d, 2w, all.`);
   }
   const unit = UNITS_MS[match[2] ?? ""] ?? 0;
   return Number(match[1]) * unit;
@@ -1364,7 +1433,7 @@ function pad(n, width) {
   return String(n).padStart(width);
 }
 function formatUsageRow(row) {
-  return `${pad(row.count, row.countWidth)} ${cyan2(row.name)}`;
+  return `${pad(row.count, row.countWidth)} ${cyan(row.name)}`;
 }
 function parseAgents(agent) {
   if (!agent)
@@ -1388,7 +1457,7 @@ var usageArgs = {
     type: "string",
     alias: "p",
     default: "all",
-    description: "30sec, 5min, 12h, 7d, 2w, 1m, 1y, all"
+    description: "60s, 30m, 24h, 30d, 2w, all"
   },
   since: { type: "string", description: "yyyy-mm-dd, overrides --period" },
   mode: {
@@ -1420,8 +1489,8 @@ async function runUsage(args) {
     cwd: process.cwd()
   });
   const claudeProjectsRoot = expandHome("~/.claude/projects");
-  const claudeRoot = args.root ?? (scope.projectRoot ? join10(claudeProjectsRoot, encodeClaudeProjectDir(scope.projectRoot)) : claudeProjectsRoot);
-  const claudeRootMissing = !args.root && !!scope.projectRoot && !existsSync9(claudeRoot);
+  const claudeRoot = args.root ?? (scope.projectRoot ? join7(claudeProjectsRoot, encodeClaudeProjectDir(scope.projectRoot)) : claudeProjectsRoot);
+  const claudeRootMissing = !args.root && !!scope.projectRoot && !existsSync6(claudeRoot);
   const lockPath = getLockPath(args.global);
   const skillUniverse = discoverSkills({
     isGlobal: args.global,
@@ -1451,7 +1520,7 @@ async function runUsage(args) {
       stats = { filesRead: result.filesRead, linesRead: result.linesRead };
     }
     const universeNames = new Set([...skillUniverse.keys(), ...counts.keys()]);
-    const rows = [...universeNames].map((name) => {
+    const allRows = [...universeNames].map((name) => {
       const rec = skillUniverse.get(name);
       return {
         name,
@@ -1460,6 +1529,7 @@ async function runUsage(args) {
         status: rec?.status ?? "ok"
       };
     });
+    const rows = allRows.filter((r) => r.count > 0);
     rows.sort((a, b) => {
       const aOk = a.status === "ok";
       const bOk = b.status === "ok";
@@ -1488,12 +1558,12 @@ async function runUsage(args) {
   }
   const periodLabel = args.since ? `since ${args.since}` : args.period ?? "all";
   const scopeHeader = scope.global ? "Global" : "Local";
+  console.log("");
   console.log(scopeHeader);
   const distinct = new Set;
   let grandActivations = 0;
   for (const { agent, rows } of results) {
     const activations = rows.reduce((acc, r) => acc + r.count, 0);
-    console.log("");
     console.log(`${agent} ${rows.length} skill${rows.length === 1 ? "" : "s"} ${activations} time${activations === 1 ? "" : "s"} by ${periodLabel}`);
     if (rows.length === 0)
       continue;
@@ -1521,15 +1591,15 @@ var usageCommand = defineCommand({
 });
 
 // src/utils/update-check.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import { mkdirSync, readFileSync as readFileSync4, writeFileSync } from "node:fs";
 import { get } from "node:https";
-import { homedir as homedir7 } from "node:os";
-import { dirname as dirname7, join as join11 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname4, join as join8 } from "node:path";
 var PKG = "skillio";
 var TTL_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 1500;
 function getCachePath() {
-  return join11(homedir7(), ".cache", "skillio", "version.json");
+  return join8(homedir5(), ".cache", "skillio", "version.json");
 }
 function compareVersions(a, b) {
   const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -1544,23 +1614,23 @@ function compareVersions(a, b) {
 }
 function readCache(path = getCachePath()) {
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return;
   }
 }
 function writeCache(cache, path = getCachePath()) {
   try {
-    mkdirSync2(dirname7(path), { recursive: true });
-    writeFileSync2(path, JSON.stringify(cache));
+    mkdirSync(dirname4(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(cache));
   } catch {}
 }
 function fetchLatest() {
-  return new Promise((resolve7) => {
+  return new Promise((resolve5) => {
     const req = get(`https://registry.npmjs.org/${PKG}/latest`, { timeout: FETCH_TIMEOUT_MS }, (res) => {
       if (res.statusCode !== 200) {
         res.resume();
-        resolve7(undefined);
+        resolve5(undefined);
         return;
       }
       let body = "";
@@ -1571,16 +1641,16 @@ function fetchLatest() {
       res.on("end", () => {
         try {
           const data = JSON.parse(body);
-          resolve7(typeof data.version === "string" ? data.version : undefined);
+          resolve5(typeof data.version === "string" ? data.version : undefined);
         } catch {
-          resolve7(undefined);
+          resolve5(undefined);
         }
       });
     });
-    req.on("error", () => resolve7(undefined));
+    req.on("error", () => resolve5(undefined));
     req.on("timeout", () => {
       req.destroy();
-      resolve7(undefined);
+      resolve5(undefined);
     });
   });
 }
@@ -1607,7 +1677,7 @@ Run: npm i -g skillio
 }
 
 // src/cli.ts
-var { version } = createRequire2(import.meta.url)("../package.json");
+var { version } = createRequire(import.meta.url)("../package.json");
 function mergeAgentArgs(argv) {
   const out = [];
   const values = [];
@@ -1676,7 +1746,7 @@ function printRootHelp() {
     "  -h, --help       Show this help and exit",
     "  -v, --version    Show version and exit",
     "  -g, --global     Use global scope (default: false)",
-    "  -p, --period     Period for `usage`: 30sec, 5min, 12h, 7d, 2w, 1m, 1y, all (default: all)",
+    "  -p, --period     Period for `usage`: 60s, 30m, 24h, 30d, 2w, all (default: all)",
     "  -a, --agent      Agent for `usage`: claude-code, codex (default: both)",
     "",
     "COMMANDS",
@@ -1739,6 +1809,14 @@ var main = defineCommand({
   async run({ args }) {
     if (hasSubcommand(process.argv))
       return;
+    const interactive = process.stdout.isTTY && process.stdin.isTTY;
+    if (interactive) {
+      const { runPicker } = await import("./shared/chunk-j9jc4e4c.js");
+      const status = await runPicker({
+        global: args.global ?? false
+      });
+      process.exit(status);
+    }
     await costCommand.run?.({
       args,
       cmd: costCommand,