get-skill 1.3.8 → 1.3.10

package/dist/cli.js

@@ -36,39 +36,622 @@ import {
 // src/index.ts
 import { Command as Command13 } from "commander";
 import { readFileSync as readFileSync3 } from "fs";
-import pc15 from "picocolors";
+import pc17 from "picocolors";
 
 // src/commands/lint.ts
 import { Command } from "commander";
 import { writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { resolve as resolve2 } from "path";
+import pc4 from "picocolors";
+
+// src/prompts.ts
+import { ConfirmPrompt, MultiSelectPrompt, PasswordPrompt, SelectPrompt, TextPrompt, block } from "@clack/core";
 import pc2 from "picocolors";
-import * as p from "@clack/prompts";
+
+// src/brand.ts
+import pc from "picocolors";
+
+// src/env.ts
+function detectHostAgent(env = process.env) {
+  if (env.CLAUDECODE) return "claude-code";
+  if (env.CURSOR_AGENT || env.CURSOR_EXTENSION_HOST_ROLE === "agent-exec") return "cursor";
+  if (env.CODEX_SANDBOX || env.CODEX_THREAD_ID) return "codex";
+  if (env.GEMINI_CLI) return "gemini-cli";
+  if (env.CI && env.CI !== "false" && env.CI !== "0") return "ci";
+  return null;
+}
+var realTerminal = () => ({
+  stdinTTY: Boolean(process.stdin.isTTY),
+  stdoutTTY: Boolean(process.stdout.isTTY),
+  env: process.env
+});
+function isInteractive(flags, term = realTerminal()) {
+  if (flags.yes || flags.json) return false;
+  if (!term.stdinTTY || !term.stdoutTTY) return false;
+  return detectHostAgent(term.env) === null;
+}
+function scopesFor(flags) {
+  return flags.global && !flags.project ? [true] : flags.project && !flags.global ? [false] : [false, true];
+}
+function nonInteractiveHint(flags) {
+  return `Interactive prompt required but stdin is not a terminal. Nothing was changed. Re-run with ${flags} to run non-interactively.`;
+}
+function promptIf(flags, prompt) {
+  const term = { stdinTTY: Boolean(process.stdin.isTTY), stdoutTTY: Boolean(process.stdout.isTTY), env: flags.env ?? process.env };
+  return isInteractive(flags, term) ? { prompt } : {};
+}
+
+// src/brand.ts
+function unicodeSupported(env = process.env, platform = process.platform) {
+  if (platform !== "win32") return env.TERM !== "linux";
+  return Boolean(env.CI) || Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || env.TERM_PROGRAM === "Terminus-Sublime" || env.TERM_PROGRAM === "vscode" || env.TERM === "xterm-256color" || env.TERM === "alacritty" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+function truecolor(env = process.env) {
+  if (/^(truecolor|24bit)$/i.test(env.COLORTERM ?? "")) return true;
+  if (env.WT_SESSION || env.KITTY_WINDOW_ID) return true;
+  if (/^(vscode|iTerm\.app|WezTerm|Hyper|ghostty)$/.test(env.TERM_PROGRAM ?? "")) return true;
+  return /(truecolor|24bit|direct|kitty|ghostty)/i.test(env.TERM ?? "");
+}
+function orange(text2, env = process.env, colour = pc.isColorSupported) {
+  if (!colour) return text2;
+  const open = truecolor(env) ? "\x1B[38;2;214;83;41m" : "\x1B[38;5;166m";
+  return `${open}${text2}\x1B[39m`;
+}
+function canAnimate(stream, env = process.env) {
+  return Boolean(stream.isTTY) && detectHostAgent(env) === null && env.TERM !== "dumb" && unicodeSupported(env);
+}
+var SPINNERS = {
+  drop: { frames: ["  ", "\u2580 ", "\u2584 ", "\u2584\u2580", "\u2584\u2580", "\u2584\u2580", "\u2584\u2580", "\u2584\u2580", "  "], interval: 90 },
+  hop: { frames: ["\u2584\u2580", "\u2580\u2584"], interval: 240 },
+  walk: { frames: ["\u2584\u2580  ", " \u2584\u2580 ", "  \u2584\u2580", "   \u2584", "    ", "\u2580   "], interval: 110 }
+};
+var ASCII_SPINNER = { frames: ["\u2022", "o", "O", "0"], interval: 120 };
+async function waitFor(kind, message, work, opts = {}) {
+  const stream = opts.stream ?? process.stderr;
+  const env = opts.env ?? process.env;
+  const job = typeof work === "function" ? work() : work;
+  const show = !opts.json && canAnimate(stream, env) && canAnimate(opts.also ?? process.stdout, env);
+  if (!show) return job;
+  const { frames, interval } = SPINNERS[kind];
+  const text2 = message.replace(/[.…]+$/, "");
+  let i = 0;
+  const draw = () => stream.write(`\r\x1B[2K${orange(frames[i++ % frames.length], env)} ${text2}\u2026`);
+  stream.write("\x1B[?25l");
+  draw();
+  const timer = setInterval(draw, interval);
+  const restore = () => stream.write("\x1B[?25h");
+  process.once("exit", restore);
+  try {
+    return await job;
+  } finally {
+    clearInterval(timer);
+    stream.write("\r\x1B[2K\x1B[?25h");
+    process.removeListener("exit", restore);
+  }
+}
+var LETTERS = [
+  { x: 0, rows: { 3: ".########", 4: "#########", 5: "##.......", 6: "########.", 7: ".########", 8: ".......##", 9: "#########", 10: "########." } },
+  // s
+  { x: 10, rows: { 0: "##", 1: "##", 2: "##", 3: "##...##", 4: "##..##", 5: "##.##", 6: "####", 7: "####", 8: "##.##", 9: "##..##", 10: "##...##" } },
+  // k
+  { x: 18, rows: { 0: "##", 1: "##", 3: "##", 4: "##", 5: "##", 6: "##", 7: "##", 8: "##", 9: "##", 10: "##" } },
+  // i
+  { x: 21, rows: Object.fromEntries([...Array(11).keys()].map((r) => [r, "##"])) },
+  // l
+  { x: 24, rows: Object.fromEntries([...Array(11).keys()].map((r) => [r, "##"])) },
+  // l
+  { x: 28, md: true, rows: { 3: ".#########", 4: "##########", 5: "##...##...##", 6: "##...##...##", 7: "##...##...##", 8: "##...##...##", 9: "##...##...##", 10: "##...##...##" } },
+  // m
+  { x: 41, md: true, rows: { 0: "......##", 1: "......##", 2: "......##", 3: ".#######", 4: "########", 5: "##....##", 6: "##....##", 7: "##....##", 8: "##....##", 9: "######", 10: "######" } }
+  // d
+];
+var WORDMARK_WIDTH = 54;
+var CANVAS_ROWS = 12;
+var SQUARES = [{ x: 50, y: 10 }, { x: 52, y: 8 }];
+function wordmarkLines(squares = SQUARES, paint = (s2) => orange(s2)) {
+  const grid = [...Array(CANVAS_ROWS)].map(() => Array(WORDMARK_WIDTH).fill(null));
+  for (const L of LETTERS) {
+    for (const [r, row] of Object.entries(L.rows)) {
+      [...row].forEach((c, i) => {
+        if (c === "#") grid[Number(r) + 1][L.x + i] = L.md ? "md" : "ink";
+      });
+    }
+  }
+  for (const sq of squares) {
+    for (let dy = 0; dy < 2; dy++) for (let dx = 0; dx < 2; dx++) {
+      const y = Math.round(sq.y) + dy, x = Math.round(sq.x) + dx;
+      if (y >= 0 && y < CANVAS_ROWS && x >= 0 && x < WORDMARK_WIDTH) grid[y][x] = "md";
+    }
+  }
+  const lines = [];
+  for (let r = 0; r < CANVAS_ROWS; r += 2) {
+    let line = "";
+    let run2 = "";
+    let runMd = false;
+    const flush = () => {
+      if (run2) line += runMd ? paint(run2) : run2;
+      run2 = "";
+    };
+    let end = WORDMARK_WIDTH;
+    while (end > 0 && !grid[r][end - 1] && !grid[r + 1][end - 1]) end--;
+    for (let x = 0; x < end; x++) {
+      const top = grid[r][x], bottom = grid[r + 1][x];
+      const md = (top ?? bottom) === "md";
+      const ch = top && bottom ? "\u2588" : top ? "\u2580" : bottom ? "\u2584" : " ";
+      if (ch !== " " && md !== runMd) flush();
+      if (ch !== " ") runMd = md;
+      run2 += ch;
+    }
+    flush();
+    lines.push(line);
+  }
+  return lines;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var easeIn = (t) => t * t;
+async function playLogo(opts = {}) {
+  const out = opts.out ?? process.stdout;
+  const input = opts.input ?? process.stdin;
+  const env = opts.env ?? process.env;
+  const indent = opts.indent ?? "  ";
+  const animate = opts.animate ?? (canAnimate(out, env) && pc.isColorSupported && Boolean(input.isTTY));
+  const show = (lines) => lines.map((l) => l ? indent + l : "").join("\n");
+  if (!animate) {
+    out.write(`${show(wordmarkLines())}
+`);
+    return;
+  }
+  let skipped = false;
+  const onKey = (key) => {
+    skipped = true;
+    if (key.toString() === "") {
+      out.write("\x1B[?25h\n");
+      process.exit(130);
+    }
+  };
+  const restoreCursor = () => out.write("\x1B[?25h");
+  out.write("\x1B[?25l");
+  process.once("exit", restoreCursor);
+  input.setRawMode?.(true);
+  input.on("data", onKey);
+  input.resume();
+  let drawn = 0;
+  const paint = (squares) => {
+    const lines = wordmarkLines(squares);
+    out.write(`${drawn ? `\x1B[${drawn}A` : ""}${lines.map((l) => `\x1B[2K${l ? indent + l : ""}`).join("\n")}
+`);
+    drawn = lines.length;
+  };
+  try {
+    paint([]);
+    await sleep(160);
+    const [first, second] = SQUARES;
+    for (const [n, target] of [first, second].entries()) {
+      const landed = n === 0 ? [] : [first];
+      const steps = 9;
+      for (let s2 = 0; s2 <= steps && !skipped; s2++) {
+        paint([...landed, { x: target.x, y: -2 + (target.y + 2) * easeIn(s2 / steps) }]);
+        await sleep(22);
+      }
+      if (skipped) break;
+      paint([...landed, { x: target.x, y: target.y - 1 }]);
+      await sleep(40);
+      paint([...landed, target]);
+      await sleep(90);
+    }
+  } finally {
+    paint(SQUARES);
+    input.removeListener("data", onKey);
+    input.setRawMode?.(false);
+    input.pause();
+    out.write("\x1B[?25h");
+    process.removeListener("exit", restoreCursor);
+  }
+}
+function brandWord(env = process.env, colour = pc.isColorSupported) {
+  return `${colour ? pc.bold("skill") : "skill"}${colour ? pc.bold(orange("md", env, colour)) : "md"}`;
+}
+
+// src/prompts.ts
+import { isCancel } from "@clack/core";
+var unicode = unicodeSupported();
+var s = (c, fallback) => unicode ? c : fallback;
+var S_STEP_ACTIVE = s("\u25C6", "*");
+var S_STEP_CANCEL = s("\u25A0", "x");
+var S_STEP_ERROR = s("\u25B2", "x");
+var S_STEP_SUBMIT = s("\u25C7", "o");
+var S_BAR_START = s("\u250C", "T");
+var S_BAR = s("\u2502", "|");
+var S_BAR_END = s("\u2514", "\u2014");
+var S_RADIO_ACTIVE = s("\u25CF", ">");
+var S_RADIO_INACTIVE = s("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = s("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = s("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = s("\u25FB", "[ ]");
+var S_PASSWORD_MASK = s("\u25AA", "\u2022");
+var S_BAR_H = s("\u2500", "-");
+var S_CORNER_TOP_RIGHT = s("\u256E", "+");
+var S_CONNECT_LEFT = s("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = s("\u256F", "+");
+var S_INFO = s("\u25CF", "\u2022");
+var S_SUCCESS = s("\u25C6", "*");
+var S_WARN = s("\u25B2", "!");
+var S_ERROR = s("\u25A0", "x");
+var accent = (text2) => orange(text2);
+var bar = pc2.gray(S_BAR);
+var symbol = (state) => {
+  switch (state) {
+    case "initial":
+    case "active":
+      return accent(S_STEP_ACTIVE);
+    case "cancel":
+      return pc2.red(S_STEP_CANCEL);
+    case "error":
+      return pc2.yellow(S_STEP_ERROR);
+    case "submit":
+      return accent(S_STEP_SUBMIT);
+  }
+};
+var skipLead = false;
+function startFrameAfterLogo() {
+  skipLead = true;
+}
+var lead = () => {
+  if (skipLead) {
+    skipLead = false;
+    return "";
+  }
+  return `${bar}
+`;
+};
+var hint = (text2) => text2 ? `  ${pc2.dim(text2)}` : "";
+var keys = (text2) => pc2.dim(text2);
+function limitOptions(params) {
+  const { cursor, options, style } = params;
+  const outputMaxItems = Math.max((process.stdout.rows ?? 24) - 4, 0);
+  const maxItems = Math.min(outputMaxItems, Math.max(params.maxItems ?? Infinity, 5));
+  let window = 0;
+  if (cursor >= window + maxItems - 3) window = Math.max(Math.min(cursor - maxItems + 3, options.length - maxItems), 0);
+  else if (cursor < window + 2) window = Math.max(cursor - 2, 0);
+  const topEllipsis = maxItems < options.length && window > 0;
+  const bottomEllipsis = maxItems < options.length && window + maxItems < options.length;
+  return options.slice(window, window + maxItems).map((option, i, arr) => i === 0 && topEllipsis || i === arr.length - 1 && bottomEllipsis ? pc2.dim("...") : style(option, i + window === cursor));
+}
+var text = (opts) => {
+  const top = lead();
+  return new TextPrompt({
+    validate: opts.validate,
+    placeholder: opts.placeholder,
+    defaultValue: opts.defaultValue,
+    initialValue: opts.initialValue,
+    render() {
+      const title = `${top}${symbol(this.state)}  ${opts.message}
+`;
+      const placeholder = opts.placeholder ? pc2.inverse(opts.placeholder[0]) + pc2.dim(opts.placeholder.slice(1)) : pc2.inverse(pc2.hidden("_"));
+      const value = !this.value ? placeholder : this.valueWithCursor;
+      switch (this.state) {
+        case "error":
+          return `${title.trim()}
+${pc2.yellow(S_BAR)}  ${value}
+${pc2.yellow(S_BAR_END)}  ${pc2.yellow(this.error)}
+`;
+        case "submit":
+          return `${title}${bar}  ${pc2.dim(this.value || opts.placeholder || "")}`;
+        case "cancel":
+          return `${title}${bar}  ${pc2.strikethrough(pc2.dim(this.value ?? ""))}${this.value?.trim() ? `
+${bar}` : ""}`;
+        default:
+          return `${title}${bar}  ${value}
+${pc2.gray(S_BAR_END)}
+`;
+      }
+    }
+  }).prompt();
+};
+var password = (opts) => {
+  const top = lead();
+  return new PasswordPrompt({
+    validate: opts.validate,
+    mask: opts.mask ?? S_PASSWORD_MASK,
+    render() {
+      const title = `${top}${symbol(this.state)}  ${opts.message}
+`;
+      const masked = this.masked;
+      switch (this.state) {
+        case "error":
+          return `${title.trim()}
+${pc2.yellow(S_BAR)}  ${masked}
+${pc2.yellow(S_BAR_END)}  ${pc2.yellow(this.error)}
+`;
+        case "submit":
+          return `${title}${bar}  ${pc2.dim(masked)}`;
+        case "cancel":
+          return `${title}${bar}  ${pc2.strikethrough(pc2.dim(masked ?? ""))}${masked ? `
+${bar}` : ""}`;
+        default:
+          return `${title}${bar}  ${this.valueWithCursor}
+${pc2.gray(S_BAR_END)}
+`;
+      }
+    }
+  }).prompt();
+};
+var confirm = (opts) => {
+  const active = opts.active ?? "Yes";
+  const inactive = opts.inactive ?? "No";
+  const top = lead();
+  return new ConfirmPrompt({
+    active,
+    inactive,
+    initialValue: opts.initialValue ?? true,
+    render() {
+      const title = `${top}${symbol(this.state)}  ${opts.message}
+`;
+      const value = this.value ? active : inactive;
+      switch (this.state) {
+        case "submit":
+          return `${title}${bar}  ${pc2.dim(value)}`;
+        case "cancel":
+          return `${title}${bar}  ${pc2.strikethrough(pc2.dim(value))}
+${bar}`;
+        default: {
+          const on = (label2) => `${accent(S_RADIO_ACTIVE)} ${label2}`;
+          const off = (label2) => `${pc2.dim(S_RADIO_INACTIVE)} ${pc2.dim(label2)}`;
+          return `${title}${bar}  ${this.value ? on(active) : off(active)} ${pc2.dim("/")} ${!this.value ? on(inactive) : off(inactive)}
+${pc2.gray(S_BAR_END)}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var select = (opts) => {
+  const opt = (option, state) => {
+    const label2 = option.label ?? String(option.value);
+    switch (state) {
+      case "selected":
+        return pc2.dim(label2);
+      case "active":
+        return `${accent(S_RADIO_ACTIVE)} ${label2}${hint(option.hint)}`;
+      case "cancelled":
+        return pc2.strikethrough(pc2.dim(label2));
+      default:
+        return `${pc2.dim(S_RADIO_INACTIVE)} ${pc2.dim(label2)}`;
+    }
+  };
+  const top = lead();
+  return new SelectPrompt({
+    options: opts.options,
+    initialValue: opts.initialValue,
+    render() {
+      const title = `${top}${symbol(this.state)}  ${opts.message}
+`;
+      switch (this.state) {
+        case "submit":
+          return `${title}${bar}  ${opt(this.options[this.cursor], "selected")}`;
+        case "cancel":
+          return `${title}${bar}  ${opt(this.options[this.cursor], "cancelled")}
+${bar}`;
+        default:
+          return `${title}${bar}  ${limitOptions({
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: opts.maxItems,
+            style: (item, isActive) => opt(item, isActive ? "active" : "inactive")
+          }).join(`
+${bar}  `)}
+${pc2.gray(S_BAR_END)}  ${keys("\u2191/\u2193 to move \xB7 enter to choose")}
+`;
+      }
+    }
+  }).prompt();
+};
+var multiselect = (opts) => {
+  const opt = (option, state) => {
+    const label2 = option.label ?? String(option.value);
+    switch (state) {
+      case "active":
+        return `${accent(S_CHECKBOX_ACTIVE)} ${label2}${hint(option.hint)}`;
+      case "selected":
+        return `${accent(S_CHECKBOX_SELECTED)} ${pc2.dim(label2)}`;
+      case "cancelled":
+        return pc2.strikethrough(pc2.dim(label2));
+      case "active-selected":
+        return `${accent(S_CHECKBOX_SELECTED)} ${label2}${hint(option.hint)}`;
+      case "submitted":
+        return pc2.dim(label2);
+      default:
+        return `${pc2.dim(S_CHECKBOX_INACTIVE)} ${pc2.dim(label2)}`;
+    }
+  };
+  const top = lead();
+  return new MultiSelectPrompt({
+    options: opts.options,
+    initialValues: opts.initialValues,
+    required: opts.required ?? true,
+    cursorAt: opts.cursorAt,
+    validate(selected) {
+      if (this.required && selected.length === 0) {
+        return `Please select at least one option.
+${pc2.reset(pc2.dim("Press space to select, enter to confirm"))}`;
+      }
+    },
+    render() {
+      const title = `${top}${symbol(this.state)}  ${opts.message}
+`;
+      const styleOption = (option, isActive) => {
+        const selected = this.value.includes(option.value);
+        if (isActive && selected) return opt(option, "active-selected");
+        if (selected) return opt(option, "selected");
+        return opt(option, isActive ? "active" : "inactive");
+      };
+      const list = (edge) => limitOptions({
+        options: this.options,
+        cursor: this.cursor,
+        maxItems: opts.maxItems,
+        style: styleOption
+      }).join(`
+${edge}  `);
+      switch (this.state) {
+        case "submit":
+          return `${title}${bar}  ${this.options.filter(({ value }) => this.value.includes(value)).map((o) => opt(o, "submitted")).join(pc2.dim(", ")) || pc2.dim("none")}`;
+        case "cancel": {
+          const label2 = this.options.filter(({ value }) => this.value.includes(value)).map((o) => opt(o, "cancelled")).join(pc2.dim(", "));
+          return `${title}${bar}  ${label2.trim() ? `${label2}
+${bar}` : ""}`;
+        }
+        case "error": {
+          const footer = this.error.split("\n").map((ln, i) => i === 0 ? `${pc2.yellow(S_BAR_END)}  ${pc2.yellow(ln)}` : `   ${ln}`).join("\n");
+          return `${title}${pc2.yellow(S_BAR)}  ${list(pc2.yellow(S_BAR))}
+${footer}
+`;
+        }
+        default:
+          return `${title}${bar}  ${list(bar)}
+${pc2.gray(S_BAR_END)}  ${keys("space to select \xB7 enter to confirm")}
+`;
+      }
+    }
+  }).prompt();
+};
+var strip = (str) => str.replace(ansiRegex(), "");
+var note = (message = "", title = "") => {
+  const lines = `
+${message}
+`.split("\n");
+  const titleLen = strip(title).length;
+  const len = Math.max(lines.reduce((max, ln) => Math.max(max, strip(ln).length), 0), titleLen) + 2;
+  const msg2 = lines.map((ln) => `${bar}  ${pc2.dim(ln)}${" ".repeat(len - strip(ln).length)}${bar}`).join("\n");
+  process.stdout.write(
+    `${lead()}${accent(S_STEP_SUBMIT)}  ${pc2.reset(title)} ${pc2.gray(S_BAR_H.repeat(Math.max(len - titleLen - 1, 1)) + S_CORNER_TOP_RIGHT)}
+${msg2}
+${pc2.gray(S_CONNECT_LEFT + S_BAR_H.repeat(len + 2) + S_CORNER_BOTTOM_RIGHT)}
+`
+  );
+};
+var cancel = (message = "") => {
+  process.stdout.write(`${pc2.gray(S_BAR_END)}  ${pc2.red(message)}
+
+`);
+};
+var intro = (title = "") => {
+  skipLead = false;
+  process.stdout.write(`${pc2.gray(S_BAR_START)}  ${title}
+`);
+};
+var outro = (message = "") => {
+  process.stdout.write(`${bar}
+${pc2.gray(S_BAR_END)}  ${message}
+
+`);
+};
+var log = {
+  message: (message = "", { symbol: mark = bar } = {}) => {
+    const top = lead().replace(/\n$/, "");
+    const parts = top ? [top] : [];
+    if (message) {
+      const [first, ...rest] = message.split("\n");
+      parts.push(`${mark}  ${first}`, ...rest.map((ln) => `${bar}  ${ln}`));
+    }
+    process.stdout.write(`${parts.join("\n")}
+`);
+  },
+  info: (message) => log.message(message, { symbol: accent(S_INFO) }),
+  success: (message) => log.message(message, { symbol: pc2.green(S_SUCCESS) }),
+  step: (message) => log.message(message, { symbol: accent(S_STEP_SUBMIT) }),
+  warn: (message) => log.message(message, { symbol: pc2.yellow(S_WARN) }),
+  warning: (message) => log.warn(message),
+  error: (message) => log.message(message, { symbol: pc2.red(S_ERROR) })
+};
+var spinner = (kind = "drop") => {
+  const { frames, interval } = unicode ? SPINNERS[kind] : ASCII_SPINNER;
+  let unblock = () => {
+  };
+  let loop;
+  let active = false;
+  let message = "";
+  const handleExit = (code) => {
+    if (active) stop(code > 1 ? "Something went wrong" : "Canceled", code);
+  };
+  const onError = () => handleExit(2);
+  const onSignal = () => handleExit(1);
+  const registerHooks = () => {
+    process.on("uncaughtExceptionMonitor", onError);
+    process.on("unhandledRejection", onError);
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    process.on("exit", handleExit);
+  };
+  const clearHooks = () => {
+    process.removeListener("uncaughtExceptionMonitor", onError);
+    process.removeListener("unhandledRejection", onError);
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    process.removeListener("exit", handleExit);
+  };
+  const start = (msg2 = "") => {
+    active = true;
+    unblock = block();
+    message = msg2.replace(/[.…]+$/, "");
+    process.stdout.write(lead());
+    let i = 0;
+    const draw = () => {
+      process.stdout.write(`\r\x1B[J${accent(frames[i])} ${message}\u2026`);
+      i = (i + 1) % frames.length;
+    };
+    process.stdout.write("\x1B[?25l");
+    registerHooks();
+    draw();
+    loop = setInterval(draw, interval);
+  };
+  const stop = (msg2 = "", code = 0) => {
+    message = msg2 || message;
+    active = false;
+    if (loop) clearInterval(loop);
+    const mark = code === 0 ? pc2.green(S_STEP_SUBMIT) : code === 1 ? pc2.red(S_STEP_CANCEL) : pc2.red(S_STEP_ERROR);
+    process.stdout.write(`\r\x1B[J${mark}  ${message}
+\x1B[?25h`);
+    clearHooks();
+    unblock();
+  };
+  return { start, stop, message: (msg2 = "") => {
+    message = msg2 || message;
+  } };
+};
+function ansiRegex() {
+  const pattern = [
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+  ].join("|");
+  return new RegExp(pattern, "g");
+}
+
+// src/commands/lint.ts
 import { lint, toJson, toSarif, toGithub } from "@skillmds/core";
 
 // src/ui.ts
 import { homedir } from "os";
 import { relative, resolve, sep } from "path";
-import pc from "picocolors";
-var decorate = (text3, kind) => {
+import pc3 from "picocolors";
+var decorate = (text2, kind) => {
   switch (kind) {
     case "error":
-      return pc.red(text3);
+      return pc3.red(text2);
     case "warn":
-      return pc.yellow(text3);
+      return pc3.yellow(text2);
     case "info":
-      return pc.cyan(text3);
+      return pc3.cyan(text2);
     case "ok":
-      return pc.green(text3);
+      return pc3.green(text2);
     case "dim":
-      return pc.dim(text3);
+      return pc3.dim(text2);
   }
 };
 var SEV_COLOR = {
-  error: pc.red,
-  warn: pc.yellow,
-  info: pc.cyan
+  error: pc3.red,
+  warn: pc3.yellow,
+  info: pc3.cyan
 };
 var GLYPH = {
   error: "\u2716",
@@ -84,7 +667,7 @@ var SEV_ORDER = ["error", "warn", "info"];
 function chips(result) {
   const bySev = { error: [], warn: [], info: [] };
   for (const d of result.diagnostics) bySev[d.severity].push(d.id);
-  return SEV_ORDER.filter((s) => bySev[s].length).map((s) => `${GLYPH[s]} ${SEV_COLOR[s](bySev[s].join(" "))}`).join("   ");
+  return SEV_ORDER.filter((s2) => bySev[s2].length).map((s2) => `${GLYPH[s2]} ${SEV_COLOR[s2](bySev[s2].join(" "))}`).join("   ");
 }
 var SEC_LABEL = {
   network_calls: "Calls Network",
@@ -92,7 +675,7 @@ var SEC_LABEL = {
   reads_secrets: "Reads Secrets"
 };
 var titleCase = (flag) => flag.split("_").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
-var scoreColor = (s) => s >= 80 ? pc.green : s >= 50 ? pc.yellow : pc.red;
+var scoreColor = (s2) => s2 >= 80 ? pc3.green : s2 >= 50 ? pc3.yellow : pc3.red;
 function label(file) {
   const parts = file.split(/[\\/]/).filter(Boolean);
   const i = parts.lastIndexOf("SKILL.md");
@@ -103,27 +686,27 @@ function securityFlags(result) {
 }
 function secLabels(result) {
   const flags = securityFlags(result);
-  return flags.map((f) => pc.magenta(`${SEC_GLYPH} ${SEC_LABEL[f] ?? titleCase(f)}`)).join("  ");
+  return flags.map((f) => pc3.magenta(`${SEC_GLYPH} ${SEC_LABEL[f] ?? titleCase(f)}`)).join("  ");
 }
 function statusDot(result) {
-  if (!result.ok) return pc.red("\u25CF");
+  if (!result.ok) return pc3.red("\u25CF");
   const attention = result.diagnostics.some((d) => d.severity === "warn") || securityFlags(result).length > 0;
-  return attention ? pc.yellow("\u25CF") : pc.green("\u25CF");
+  return attention ? pc3.yellow("\u25CF") : pc3.green("\u25CF");
 }
 function failureBlock(file, result) {
-  const lines = [`${pc.red(GLYPH.error)} ${pc.bold(label(file))}`];
+  const lines = [`${pc3.red(GLYPH.error)} ${pc3.bold(label(file))}`];
   for (const d of result.diagnostics.filter((x) => x.severity === "error")) {
-    const loc = d.line !== void 0 ? pc.dim(`:${d.line}`) : "";
+    const loc = d.line !== void 0 ? pc3.dim(`:${d.line}`) : "";
     lines.push(`    ${SEV_COLOR.error(d.id)}${loc}  ${d.message}`);
   }
-  lines.push(`    ${pc.dim(file)}`);
+  lines.push(`    ${pc3.dim(file)}`);
   return lines.join("\n");
 }
 function renderOne(file, result) {
-  const status = result.ok ? pc.green("\u25CF PASS") : pc.red("\u25CF FAIL");
-  const out = [`${status}  ${pc.bold(label(file))}  ${pc.dim("quality")} ${scoreColor(result.score)(`${result.score}/100`)}`];
+  const status = result.ok ? pc3.green("\u25CF PASS") : pc3.red("\u25CF FAIL");
+  const out = [`${status}  ${pc3.bold(label(file))}  ${pc3.dim("quality")} ${scoreColor(result.score)(`${result.score}/100`)}`];
   for (const d of result.diagnostics) {
-    const loc = d.line !== void 0 ? pc.dim(`:${d.line}`) : "";
+    const loc = d.line !== void 0 ? pc3.dim(`:${d.line}`) : "";
     out.push(`  ${GLYPH[d.severity]} ${SEV_COLOR[d.severity](d.id)}${loc}  ${d.message}`);
   }
   const sec = secLabels(result);
@@ -147,32 +730,32 @@ function renderMany(results) {
   const failed = results.filter((r) => !r.result.ok).length;
   const warned = results.filter((r) => r.result.ok && r.result.diagnostics.some((d) => d.severity === "warn")).length;
   const clean = results.length - failed - warned;
-  const avg = Math.round(results.reduce((s, r) => s + r.result.score, 0) / results.length);
+  const avg = Math.round(results.reduce((s2, r) => s2 + r.result.score, 0) / results.length);
   out.push("");
-  const parts = [pc.green(`${clean} clean`)];
-  if (warned) parts.push(pc.yellow(`${warned} warn`));
-  if (failed) parts.push(pc.red(`${failed} fail`));
-  out.push(`${parts.join(pc.dim(" \xB7 "))}   ${pc.dim("avg score")} ${scoreColor(avg)(`${avg}/100`)}`);
-  if (anySec) out.push(pc.dim(`${SEC_GLYPH} = risky behaviour, factored into the score alongside spec correctness and completeness`));
+  const parts = [pc3.green(`${clean} clean`)];
+  if (warned) parts.push(pc3.yellow(`${warned} warn`));
+  if (failed) parts.push(pc3.red(`${failed} fail`));
+  out.push(`${parts.join(pc3.dim(" \xB7 "))}   ${pc3.dim("avg score")} ${scoreColor(avg)(`${avg}/100`)}`);
+  if (anySec) out.push(pc3.dim(`${SEC_GLYPH} = risky behaviour, factored into the score alongside spec correctness and completeness`));
   const fails = results.filter((r) => !r.result.ok);
   if (fails.length) {
     out.push("");
-    out.push(pc.red(pc.bold(`Failed (${fails.length}):`)));
+    out.push(pc3.red(pc3.bold(`Failed (${fails.length}):`)));
     for (const f of fails.slice(0, 25)) out.push(failureBlock(f.file, f.result));
-    if (fails.length > 25) out.push(pc.dim(`  \u2026and ${fails.length - 25} more \u2014 run with --errors-only to see all`));
+    if (fails.length > 25) out.push(pc3.dim(`  \u2026and ${fails.length - 25} more \u2014 run with --errors-only to see all`));
   }
   return out.join("\n");
 }
 function renderFailuresView(results) {
   const fails = results.filter((r) => !r.result.ok);
-  if (!fails.length) return pc.green(`${GLYPH.ok} No failures across ${results.length} skill${results.length === 1 ? "" : "s"}.`);
+  if (!fails.length) return pc3.green(`${GLYPH.ok} No failures across ${results.length} skill${results.length === 1 ? "" : "s"}.`);
   const out = fails.map((f) => failureBlock(f.file, f.result));
   out.push("");
-  out.push(`${pc.red(`${fails.length} failed`)} ${pc.dim(`of ${results.length}`)}`);
+  out.push(`${pc3.red(`${fails.length} failed`)} ${pc3.dim(`of ${results.length}`)}`);
   return out.join("\n");
 }
 function renderReport(results, opts = {}) {
-  if (results.length === 0) return pc.dim("No skills found.");
+  if (results.length === 0) return pc3.dim("No skills found.");
   if (opts.errorsOnly) return renderFailuresView(results);
   if (results.length === 1) return renderOne(results[0].file, results[0].result);
   return renderMany(results);
@@ -186,11 +769,11 @@ function exitCodeFor(results, policy = {}) {
   }
   return 0;
 }
-function shortPath(p7, ctx = {}) {
+function shortPath(p, ctx = {}) {
   const home = resolve(ctx.home ?? homedir());
   const cwd = resolve(ctx.cwd ?? process.cwd());
-  const abs = resolve(p7);
-  const norm = (s) => s.split(sep).join("/");
+  const abs = resolve(p);
+  const norm = (s2) => s2.split(sep).join("/");
   if (abs === cwd) return ".";
   if (abs.startsWith(cwd + sep)) return `./${norm(relative(cwd, abs))}`;
   if (abs === home) return "~";
@@ -200,20 +783,20 @@ function shortPath(p7, ctx = {}) {
 var SGR = /\x1b\[[0-9;]*m/g;
 var SGR_AT = /\x1b\[[0-9;]*m/y;
 var RESET = "\x1B[0m";
-function stripAnsi(s) {
-  return s.replace(SGR, "");
+function stripAnsi(s2) {
+  return s2.replace(SGR, "");
 }
-var visible = (s) => stripAnsi(s).length;
-function truncateVisible(s, max) {
+var visible = (s2) => stripAnsi(s2).length;
+function truncateVisible(s2, max) {
   if (max <= 0) return "";
-  if (visible(s) <= max) return s;
+  if (visible(s2) <= max) return s2;
   let out = "";
   let shown = 0;
   let open = false;
-  for (let i = 0; i < s.length && shown < max - 1; ) {
-    if (s[i] === "\x1B") {
+  for (let i = 0; i < s2.length && shown < max - 1; ) {
+    if (s2[i] === "\x1B") {
       SGR_AT.lastIndex = i;
-      const m = SGR_AT.exec(s);
+      const m = SGR_AT.exec(s2);
       if (m) {
         out += m[0];
         open = m[0] !== RESET && m[0] !== "\x1B[m";
@@ -221,7 +804,7 @@ function truncateVisible(s, max) {
         continue;
       }
     }
-    out += s[i];
+    out += s2[i];
     shown++;
     i++;
   }
@@ -252,7 +835,7 @@ function renderInstallSummary(i, ctx = {}) {
   const width = termWidth(ctx.width);
   const src = i.source.startsWith("local:") ? `local:${shortPath(i.source.slice(6), ctx)}` : i.source;
   const head = truncateVisible(
-    pc.green(`${GLYPH.ok} ${i.name}`) + pc.dim(`  score ${i.score}${i.flags.length ? `  ${i.flags.join(", ")}` : ""}  from ${src}`),
+    pc3.green(`${GLYPH.ok} ${i.name}`) + pc3.dim(`  score ${i.score}${i.flags.length ? `  ${i.flags.join(", ")}` : ""}  from ${src}`),
     width
   );
   const byPath = /* @__PURE__ */ new Map();
@@ -261,13 +844,13 @@ function renderInstallSummary(i, ctx = {}) {
     if (e) e.agents.push(t.agent);
     else byPath.set(t.path, { agents: [t.agent], mode: t.mode });
   }
-  const rows = [...byPath.entries()].map(([path, e]) => [pc.cyan(e.agents.join(", ")), pc.dim(e.mode), shortPath(path, ctx)]);
-  const body = rows.length ? table(rows, { width, indent: "  " }) : truncateVisible(pc.dim(`  ${shortPath(i.canonical, ctx)}  canonical only`), width);
-  const skipped = i.skipped.map((s) => truncateVisible(pc.dim(`  ${GLYPH.skip} ${s.agent}: ${s.reason}`), width));
-  const replaced = i.replaced ? [truncateVisible(pc.yellow(`  ${GLYPH.replaced} replaced previous install (${i.replaced === "untracked" ? "untracked directory" : i.replaced})`), width)] : [];
+  const rows = [...byPath.entries()].map(([path, e]) => [pc3.cyan(e.agents.join(", ")), pc3.dim(e.mode), shortPath(path, ctx)]);
+  const body = rows.length ? table(rows, { width, indent: "  " }) : truncateVisible(pc3.dim(`  ${shortPath(i.canonical, ctx)}  canonical only`), width);
+  const skipped = i.skipped.map((s2) => truncateVisible(pc3.dim(`  ${GLYPH.skip} ${s2.agent}: ${s2.reason}`), width));
+  const replaced = i.replaced ? [truncateVisible(pc3.yellow(`  ${GLYPH.replaced} replaced previous install (${i.replaced === "untracked" ? "untracked directory" : i.replaced})`), width)] : [];
   return [head, body, ...skipped, ...replaced].join("\n");
 }
-var banner = () => pc.bgCyan(pc.black(" skillmd "));
+var banner = () => brandWord();
 
 // src/commands/lint.ts
 function applyLicenseFix(raw) {
@@ -312,23 +895,23 @@ function lintCommand() {
   return new Command("lint").description("Validate SKILL.md file(s) against the spec and report a quality score").argument("[target]", "local path or GitHub source", ".").option("--format <fmt>", "text | json | sarif | github", "text").option("--strict", "treat warnings as errors").option("--fail-on-warning", "exit non-zero when warnings exist").option("--fix", "apply safe automatic fixes (e.g. add missing license)").option("--errors-only", "show only skills that failed").action(async (target, opts) => {
     const ui = Boolean(process.stdout.isTTY) && opts.format === "text";
     if (resolve2(target) === homedir2()) {
-      process.stderr.write(pc2.yellow(`Warning: scanning your entire home directory. Pass a narrower path, e.g. skillmd lint ./my-skill
+      process.stderr.write(pc4.yellow(`Warning: scanning your entire home directory. Pass a narrower path, e.g. skillmd lint ./my-skill
 `));
     }
     if (ui) {
-      p.intro(pc2.bgCyan(pc2.black(" skillmd lint ")));
-      const s = p.spinner();
-      s.start(`Scanning ${target}`);
+      intro(`${brandWord()}  ${pc4.dim("lint")}`);
+      const s2 = spinner("walk");
+      s2.start(`Scanning ${target}`);
       try {
         const run3 = await runLint(target, opts);
-        s.stop(`Scanned ${run3.results.length} skill${run3.results.length === 1 ? "" : "s"}`);
+        s2.stop(`Scanned ${run3.results.length} skill${run3.results.length === 1 ? "" : "s"}`);
         console.log(run3.output);
         const failed = run3.results.filter((r) => !r.result.ok).length;
-        p.outro(failed === 0 ? pc2.green("All good") : pc2.red(`${failed} skill${failed === 1 ? "" : "s"} failed \u2014 details above`));
+        outro(failed === 0 ? pc4.green("All good") : pc4.red(`${failed} skill${failed === 1 ? "" : "s"} failed \u2014 details above`));
         process.exitCode = run3.exitCode;
       } catch (err) {
-        s.stop(pc2.red("No skills found"));
-        p.outro(err instanceof Error ? err.message : String(err));
+        s2.stop(pc4.red("No skills found"));
+        outro(err instanceof Error ? err.message : String(err));
         process.exitCode = 1;
       }
       return;
@@ -344,7 +927,7 @@ function lintCommand() {
 // src/commands/scan.ts
 import { Command as Command2 } from "commander";
 import { scanSecurity, parseSkillMd } from "@skillmds/core";
-import pc3 from "picocolors";
+import pc5 from "picocolors";
 async function runScan(target, flags) {
   const resolved = await resolveSource(target);
   const deny = new Set(flags.deny ?? []);
@@ -363,11 +946,11 @@ async function runScan(target, flags) {
     const lines = [];
     for (const e of entries) {
       const flagStr = e.security.flags.join(", ");
-      const head = e.denied.length ? pc3.red(`DENY ${e.file}`) : pc3.green(`OK   ${e.file}`);
-      lines.push(`${head}  ${pc3.dim(flagStr)}`);
+      const head = e.denied.length ? pc5.red(`DENY ${e.file}`) : pc5.green(`OK   ${e.file}`);
+      lines.push(`${head}  ${pc5.dim(flagStr)}`);
       for (const f of e.security.findings) {
-        const mark = deny.has(f.flag) ? pc3.red(f.flag) : pc3.yellow(f.flag);
-        lines.push(`  ${mark}  :${f.line}  ${pc3.dim(f.snippet)}`);
+        const mark = deny.has(f.flag) ? pc5.red(f.flag) : pc5.yellow(f.flag);
+        lines.push(`  ${mark}  :${f.line}  ${pc5.dim(f.snippet)}`);
       }
     }
     output = lines.join("\n");
@@ -385,7 +968,7 @@ function scanCommand() {
 // src/commands/rules.ts
 import { Command as Command3 } from "commander";
 import { RULES } from "@skillmds/core";
-import pc4 from "picocolors";
+import pc6 from "picocolors";
 function rulesCommand() {
   return new Command3("rules").description("List lint rules, or show detail for one rule id").argument("[id]", "a rule id, e.g. SK010").option("--json", "machine-readable output").action((id, opts) => {
     const list = id ? RULES.filter((r) => r.id.toLowerCase() === id.toLowerCase()) : RULES;
@@ -398,9 +981,9 @@ function rulesCommand() {
       console.log(JSON.stringify(list.map((r) => ({ id: r.id, severity: r.severity, description: r.description })), null, 2));
       return;
     }
-    const badge = (sev) => sev === "error" ? pc4.bgRed(pc4.white(" error ")) : sev === "warn" ? pc4.bgYellow(pc4.black(" warn  ")) : pc4.bgCyan(pc4.black(" info  "));
-    console.log(pc4.bold("\nLint rules\n"));
-    for (const r of list) console.log(`  ${pc4.bold(r.id)}  ${badge(r.severity)}  ${r.description}`);
+    const badge = (sev) => sev === "error" ? pc6.bgRed(pc6.white(" error ")) : sev === "warn" ? pc6.bgYellow(pc6.black(" warn  ")) : pc6.bgCyan(pc6.black(" info  "));
+    console.log(pc6.bold("\nLint rules\n"));
+    for (const r of list) console.log(`  ${pc6.bold(r.id)}  ${badge(r.severity)}  ${r.description}`);
     console.log("");
   });
 }
@@ -410,40 +993,7 @@ import { Command as Command4 } from "commander";
 import { mkdirSync, writeFileSync as writeFileSync2, existsSync } from "fs";
 import { join } from "path";
 import { slugify } from "@skillmds/core";
-import * as p2 from "@clack/prompts";
-import pc5 from "picocolors";
-
-// src/env.ts
-function detectHostAgent(env = process.env) {
-  if (env.CLAUDECODE) return "claude-code";
-  if (env.CURSOR_AGENT || env.CURSOR_EXTENSION_HOST_ROLE === "agent-exec") return "cursor";
-  if (env.CODEX_SANDBOX || env.CODEX_THREAD_ID) return "codex";
-  if (env.GEMINI_CLI) return "gemini-cli";
-  if (env.CI && env.CI !== "false" && env.CI !== "0") return "ci";
-  return null;
-}
-var realTerminal = () => ({
-  stdinTTY: Boolean(process.stdin.isTTY),
-  stdoutTTY: Boolean(process.stdout.isTTY),
-  env: process.env
-});
-function isInteractive(flags, term = realTerminal()) {
-  if (flags.yes || flags.json) return false;
-  if (!term.stdinTTY || !term.stdoutTTY) return false;
-  return detectHostAgent(term.env) === null;
-}
-function scopesFor(flags) {
-  return flags.global && !flags.project ? [true] : flags.project && !flags.global ? [false] : [false, true];
-}
-function nonInteractiveHint(flags) {
-  return `Interactive prompt required but stdin is not a terminal. Nothing was changed. Re-run with ${flags} to run non-interactively.`;
-}
-function promptIf(flags, prompt) {
-  const term = { stdinTTY: Boolean(process.stdin.isTTY), stdoutTTY: Boolean(process.stdout.isTTY), env: flags.env ?? process.env };
-  return isInteractive(flags, term) ? { prompt } : {};
-}
-
-// src/commands/init.ts
+import pc7 from "picocolors";
 function skillTemplate(name, description, license) {
   const desc = description.trim() || `A skill that helps agents with ${name}.`;
   return `---
@@ -480,8 +1030,8 @@ function initSkill(name, opts = {}) {
   return file;
 }
 var defaultInitDeps = (flags) => promptIf(flags, async () => {
-  const answer = await p2.text({ message: "Skill name?", placeholder: "my-skill" });
-  return p2.isCancel(answer) ? null : answer;
+  const answer = await text({ message: "Skill name?", placeholder: "my-skill" });
+  return isCancel(answer) ? null : answer;
 });
 function finish(flags, result, doc) {
   return flags.json ? { ...result, output: JSON.stringify(doc, null, 2) } : result;
@@ -491,22 +1041,22 @@ async function runInit(nameArg, flags, deps = defaultInitDeps(flags)) {
   if (!name) {
     if (!deps.prompt) {
       const error = nonInteractiveHint("a name argument or --name <name>");
-      return finish(flags, { exitCode: 1, output: pc5.red(error) }, { ok: false, error });
+      return finish(flags, { exitCode: 1, output: pc7.red(error) }, { ok: false, error });
     }
     const answer = await deps.prompt();
-    if (answer === null) return finish(flags, { exitCode: 0, output: pc5.dim("Cancelled.") }, { ok: false, cancelled: true });
+    if (answer === null) return finish(flags, { exitCode: 0, output: pc7.dim("Cancelled.") }, { ok: false, cancelled: true });
     name = answer;
   }
   if (!name) {
     const error = "A skill name is required (pass a name or --name).";
-    return finish(flags, { exitCode: 1, output: pc5.red(error) }, { ok: false, error });
+    return finish(flags, { exitCode: 1, output: pc7.red(error) }, { ok: false, error });
   }
   try {
     const file = initSkill(name, { dir: flags.dir, description: flags.description, license: flags.license });
     return { exitCode: 0, file, output: flags.json ? JSON.stringify({ ok: true, file }, null, 2) : `Created ${file}` };
   } catch (e) {
     const msg2 = e instanceof Error ? e.message : String(e);
-    return { exitCode: 1, output: flags.json ? JSON.stringify({ ok: false, error: msg2 }, null, 2) : pc5.red(msg2) };
+    return { exitCode: 1, output: flags.json ? JSON.stringify({ ok: false, error: msg2 }, null, 2) : pc7.red(msg2) };
   }
 }
 function initCommand() {
@@ -519,7 +1069,7 @@ function initCommand() {
 
 // src/commands/search.ts
 import { Command as Command5 } from "commander";
-import pc6 from "picocolors";
+import pc8 from "picocolors";
 var MAX_LINE_WIDTH = 100;
 function formatStars(n) {
   if (n >= 1e6) {
@@ -532,19 +1082,19 @@ function formatStars(n) {
   }
   return String(n);
 }
-function truncate(text3, width) {
-  if (text3.length <= width) return text3;
+function truncate(text2, width) {
+  if (text2.length <= width) return text2;
   if (width <= 1) return "\u2026";
-  return `${text3.slice(0, width - 1).trimEnd()}\u2026`;
+  return `${text2.slice(0, width - 1).trimEnd()}\u2026`;
 }
 function formatSearchResult(item, width = process.stdout.columns ?? 80) {
-  const stars = item.repo_stars != null ? pc6.dim(`\u2605 ${formatStars(item.repo_stars)}`) : "";
-  const check = item.verified ? pc6.green("\u2713") : "";
-  const pack = item.type === "pack" ? pc6.dim("[pack]") : "";
-  const head = [pc6.bold(safeText(item.slug, 200)), stars, check, pack].filter(Boolean).join(" ");
+  const stars = item.repo_stars != null ? pc8.dim(`\u2605 ${formatStars(item.repo_stars)}`) : "";
+  const check = item.verified ? pc8.green("\u2713") : "";
+  const pack = item.type === "pack" ? pc8.dim("[pack]") : "";
+  const head = [pc8.bold(safeText(item.slug, 200)), stars, check, pack].filter(Boolean).join(" ");
   const indent = "  ";
   const lineWidth = Math.max(10, Math.min(width, MAX_LINE_WIDTH) - indent.length);
-  const desc = `${indent}${pc6.dim(truncate(safeText(item.description ?? ""), lineWidth))}`;
+  const desc = `${indent}${pc8.dim(truncate(safeText(item.description ?? ""), lineWidth))}`;
   return `${head}
 ${desc}`;
 }
@@ -558,63 +1108,63 @@ async function runSearch(query, flags) {
   const r = await api(`/api/search?${params}`);
   const items = r.items ?? [];
   if (flags.json) return { items, output: JSON.stringify(items, null, 2) };
-  const lines = items.map((s) => formatSearchResult(s));
+  const lines = items.map((s2) => formatSearchResult(s2));
   return { items, output: lines.join("\n\n") || "No skills found." };
 }
 function searchCommand() {
   return new Command5("search").description("Search the SkillMD registry").argument("<query>", "search terms").option("--category <slug>", "filter by category").option("--verified", "only verified skills").option("--type <type>", "single | pack").option("--min-rating <n>", "minimum average rating (0-5)").option("--limit <n>", "max results", "20").option("--json", "machine-readable output").action(async (query, opts, cmd) => {
     const merged = { ...cmd.parent?.opts(), ...opts };
-    const run2 = await runSearch(query, merged);
+    const run2 = await waitFor("hop", `Searching for ${query}`, runSearch(query, merged), { json: Boolean(merged.json) });
     console.log(run2.output);
   });
 }
 
 // src/commands/info.ts
 import { Command as Command6 } from "commander";
-import pc7 from "picocolors";
+import pc9 from "picocolors";
 async function runInfo(slug, flags, deps = {}) {
   const [owner, name] = slug.split("/");
   if (!owner || !name || slug.split("/").length !== 2) {
-    return { ok: false, exitCode: 1, output: pc7.red("Expected owner/name, e.g. anthropic/pdf") };
+    return { ok: false, exitCode: 1, output: pc9.red("Expected owner/name, e.g. anthropic/pdf") };
   }
   const api = deps.api ?? createClient(flags).api;
-  let s;
+  let s2;
   try {
-    s = await api(`/api/skills/${owner}/${name}`);
+    s2 = await api(`/api/skills/${owner}/${name}`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     if (/^SkillMD API 404 /.test(message)) {
-      return { ok: false, exitCode: 1, output: pc7.red(`Skill not found on the registry: ${slug}`) };
+      return { ok: false, exitCode: 1, output: pc9.red(`Skill not found on the registry: ${slug}`) };
     }
-    return { ok: false, exitCode: 1, output: pc7.red(`Could not reach the SkillMD registry: ${message}`) };
+    return { ok: false, exitCode: 1, output: pc9.red(`Could not reach the SkillMD registry: ${message}`) };
   }
-  if (flags.json) return { ok: true, exitCode: 0, output: JSON.stringify(s, null, 2), skill: s };
-  const slugTxt = safeText(s.slug, 200);
+  if (flags.json) return { ok: true, exitCode: 0, output: JSON.stringify(s2, null, 2), skill: s2 };
+  const slugTxt = safeText(s2.slug, 200);
   const lines = [];
   lines.push(
-    `${pc7.bold(slugTxt)} ${pc7.dim(`[${safeText(s.type ?? "single", 40)}]`)} ${s.verified ? pc7.green("\u2713 verified") : pc7.yellow("unverified")}`
+    `${pc9.bold(slugTxt)} ${pc9.dim(`[${safeText(s2.type ?? "single", 40)}]`)} ${s2.verified ? pc9.green("\u2713 verified") : pc9.yellow("unverified")}`
   );
-  lines.push(`  ${safeText(s.description)}`);
+  lines.push(`  ${safeText(s2.description)}`);
   lines.push(
-    pc7.dim(
-      `  category: ${safeText(s.category ?? "-", 100) || "-"} \xB7 rating: ${s.avg_rating != null ? s.avg_rating.toFixed(1) : "-"} (${s.rating_count ?? 0}) \xB7 installs: ${s.install_count ?? 0}`
+    pc9.dim(
+      `  category: ${safeText(s2.category ?? "-", 100) || "-"} \xB7 rating: ${s2.avg_rating != null ? s2.avg_rating.toFixed(1) : "-"} (${s2.rating_count ?? 0}) \xB7 installs: ${s2.install_count ?? 0}`
     )
   );
-  const securityFlags2 = (s.security_flags ?? []).map((f) => safeText(f, 60)).filter(Boolean);
+  const securityFlags2 = (s2.security_flags ?? []).map((f) => safeText(f, 60)).filter(Boolean);
   lines.push(
-    pc7.dim(`  security: ${securityFlags2.join(", ") || "unscanned"} \xB7 license: ${safeText(s.provenance?.license ?? s.license ?? "unknown", 100) || "unknown"}`)
+    pc9.dim(`  security: ${securityFlags2.join(", ") || "unscanned"} \xB7 license: ${safeText(s2.provenance?.license ?? s2.license ?? "unknown", 100) || "unknown"}`)
   );
-  const sourceRepo = safeText(s.provenance?.source_repo ?? s.source_repo, 300);
-  const commitSha = safeText(s.provenance?.commit_sha ?? s.commit_sha, 100);
-  if (sourceRepo) lines.push(pc7.dim(`  source: ${sourceRepo}${commitSha ? ` @ ${commitSha.slice(0, 8)}` : ""}`));
-  lines.push(pc7.dim(`  page: https://skillmd.com/skills/${slugTxt}`));
-  lines.push(pc7.dim(`  install: ${safeText(s.install?.cli, 300) || `npx get-skill add ${slugTxt}`}`));
-  return { ok: true, exitCode: 0, output: lines.join("\n"), skill: s };
+  const sourceRepo = safeText(s2.provenance?.source_repo ?? s2.source_repo, 300);
+  const commitSha = safeText(s2.provenance?.commit_sha ?? s2.commit_sha, 100);
+  if (sourceRepo) lines.push(pc9.dim(`  source: ${sourceRepo}${commitSha ? ` @ ${commitSha.slice(0, 8)}` : ""}`));
+  lines.push(pc9.dim(`  page: https://skillmd.com/skills/${slugTxt}`));
+  lines.push(pc9.dim(`  install: ${safeText(s2.install?.cli, 300) || `npx get-skill add ${slugTxt}`}`));
+  return { ok: true, exitCode: 0, output: lines.join("\n"), skill: s2 };
 }
 function infoCommand() {
   return new Command6("info").description("Show registry details for a skill: verification, security flags, provenance, rating").argument("<slug>", "owner/name, e.g. anthropic/pdf").action(async (slug, _opts, cmd) => {
     const flags = { ...cmd.parent?.opts() };
-    const run2 = await runInfo(slug, flags);
+    const run2 = await waitFor("drop", `Fetching ${slug}`, runInfo(slug, flags), { json: flags.json });
     if (run2.output) (run2.ok ? console.log : console.error)(run2.output);
     process.exitCode = run2.exitCode;
   });
@@ -623,9 +1173,8 @@ function infoCommand() {
 // src/commands/add.ts
 import { Command as Command7, Option } from "commander";
 import { homedir as homedir4 } from "os";
-import * as p3 from "@clack/prompts";
 import { dirname as dirname2, resolve as resolve3 } from "path";
-import pc8 from "picocolors";
+import pc10 from "picocolors";
 import { lint as lint2, parseSkillMd as parseSkillMd2 } from "@skillmds/core";
 
 // src/claudePlugin.ts
@@ -669,7 +1218,7 @@ function exec(deps) {
   });
 }
 function marketplacePluginName(owner, slug) {
-  const clean = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const clean = (s2) => s2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   const base = clean(slug) || "plugin";
   return owner.toLowerCase() === "skillmd" ? base : `${clean(owner)}-${base}`;
 }
@@ -707,21 +1256,21 @@ ${r.stderr}`;
 }
 function msg(e) {
   if (e && typeof e === "object" && "stderr" in e) {
-    const s = String(e.stderr ?? "").trim();
-    if (s) return s.split(/\r?\n/)[0];
+    const s2 = String(e.stderr ?? "").trim();
+    if (s2) return s2.split(/\r?\n/)[0];
   }
   return e instanceof Error ? e.message.split(/\r?\n/)[0] : String(e);
 }
 var SITE_URL = "https://skillmd.com";
 function readJson(path) {
-  let text3;
+  let text2;
   try {
-    text3 = readFileSync(path, "utf8");
+    text2 = readFileSync(path, "utf8");
   } catch {
     return "absent";
   }
   try {
-    const v = JSON.parse(text3);
+    const v = JSON.parse(text2);
     return v && typeof v === "object" && !Array.isArray(v) ? v : "unparsable";
   } catch {
     return "unparsable";
@@ -812,7 +1361,7 @@ async function installPluginNatively(owner, slug, deps = {}) {
     const plugins = obj(installedDoc.plugins);
     const prior = Array.isArray(plugins[qualified]) ? plugins[qualified] : [];
     plugins[qualified] = [
-      ...prior.filter((p7) => p7?.scope !== "user"),
+      ...prior.filter((p) => p?.scope !== "user"),
       { scope: "user", installPath, version: version2, installedAt: now, lastUpdated: now }
     ];
     installedDoc.plugins = plugins;
@@ -831,22 +1380,22 @@ async function installPluginNatively(owner, slug, deps = {}) {
 }
 
 // src/commands/add.ts
-var infoNotice = (text3) => ({ text: text3, style: "info" });
-var warnNotice = (text3) => ({ text: text3, style: "warn" });
-var skipNotice = (text3) => ({ text: text3, style: "skip" });
-var replacedNotice = (text3) => ({ text: text3, style: "warn", suppressInSummary: true });
+var infoNotice = (text2) => ({ text: text2, style: "info" });
+var warnNotice = (text2) => ({ text: text2, style: "warn" });
+var skipNotice = (text2) => ({ text: text2, style: "skip" });
+var replacedNotice = (text2) => ({ text: text2, style: "warn", suppressInSummary: true });
 function noticeLine(n) {
   switch (n.style) {
     case "info":
-      return pc8.dim(`${GLYPH.info} ${n.text}`);
+      return pc10.dim(`${GLYPH.info} ${n.text}`);
     case "skip":
-      return pc8.dim(`${GLYPH.skip} ${n.text}`);
+      return pc10.dim(`${GLYPH.skip} ${n.text}`);
     case "warn":
-      return pc8.yellow(`${GLYPH.warn} ${n.text}`);
+      return pc10.yellow(`${GLYPH.warn} ${n.text}`);
   }
 }
 async function promptScopeInteractive(ctx) {
-  const choice = await p3.select({
+  const choice = await select({
     message: "Installation scope",
     initialValue: ctx.suggestGlobal,
     options: [
@@ -854,7 +1403,7 @@ async function promptScopeInteractive(ctx) {
       { value: true, label: "Global", hint: "install in your home directory (available across all projects)" }
     ]
   });
-  return p3.isCancel(choice) ? null : choice;
+  return isCancel(choice) ? null : choice;
 }
 function agentsPromptMessage(managed) {
   return managed ? `Claude Code already has ${managed} as a plugin. Which other agents should get its skills too?` : "Which agents do you want to install to?";
@@ -862,13 +1411,13 @@ function agentsPromptMessage(managed) {
 async function promptAgentsInteractive(ctx) {
   if (ctx.detected.length < 2) return ctx.detected;
   const remembered = (readConfig().lastAgents ?? []).filter((id) => ctx.detected.includes(id));
-  const picked = await p3.multiselect({
+  const picked = await multiselect({
     message: agentsPromptMessage(ctx.managed),
     options: ctx.detected.map((id) => ({ value: id, label: id, hint: ctx.dirFor(id) })),
     initialValues: remembered.length ? remembered : ctx.detected,
     required: true
   });
-  return p3.isCancel(picked) ? null : picked;
+  return isCancel(picked) ? null : picked;
 }
 function unverifiedFilesNote(n) {
   const [f, it] = n === 1 ? ["file", "it"] : ["files", "them"];
@@ -1144,7 +1693,7 @@ function finish2(flags, outcome) {
       };
     }
     case "list": {
-      const human = outcome.skills.length ? outcome.skills.map((s) => `${pc8.bold(s.name)}  ${pc8.dim(s.description)}`).join("\n") : "No skills found.";
+      const human = outcome.skills.length ? outcome.skills.map((s2) => `${pc10.bold(s2.name)}  ${pc10.dim(s2.description)}`).join("\n") : "No skills found.";
       return { written: [], blocked: [], exitCode: 0, output: json ? JSON.stringify({ ok: true, skills: outcome.skills }, null, 2) : human };
     }
     case "cancel": {
@@ -1154,7 +1703,7 @@ function finish2(flags, outcome) {
         blocked: [],
         exitCode: 0,
         cancelled: true,
-        output: json ? JSON.stringify(doc, null, 2) : pc8.dim("Installation cancelled \u2014 nothing was installed.")
+        output: json ? JSON.stringify(doc, null, 2) : pc10.dim("Installation cancelled \u2014 nothing was installed.")
       };
     }
     case "fail": {
@@ -1164,7 +1713,7 @@ function finish2(flags, outcome) {
       if (warnings.length) doc.warnings = warnings;
       const human = [
         ...(outcome.notices ?? []).map(noticeLine),
-        ...outcome.blocked?.length ? outcome.blocked.map((b) => pc8.red(`${GLYPH.blocked} ${b.name} blocked \u2014 ${b.reason}`)) : [pc8.red(outcome.error)]
+        ...outcome.blocked?.length ? outcome.blocked.map((b) => pc10.red(`${GLYPH.blocked} ${b.name} blocked \u2014 ${b.reason}`)) : [pc10.red(outcome.error)]
       ].join("\n");
       return { written: [], blocked: outcome.blocked ?? [], exitCode: 1, output: json ? JSON.stringify(doc, null, 2) : human };
     }
@@ -1174,7 +1723,7 @@ function renderHuman(notices, records, paths) {
   const lines = notices.map(noticeLine);
   for (const r of records) {
     if (r.kind === "blocked") {
-      lines.push(pc8.red(r.message));
+      lines.push(pc10.red(r.message));
       continue;
     }
     const { doc } = r;
@@ -1386,32 +1935,39 @@ function addCommand() {
   });
 }
 var clackUI = {
-  intro: (m) => p3.intro(m),
-  spinner: () => p3.spinner(),
-  message: (m) => p3.log.message(m),
-  outro: (m) => p3.outro(m),
-  cancel: (m) => p3.cancel(m),
+  intro: (m) => intro(m),
+  spinner: () => spinner("drop"),
+  message: (m) => log.message(m),
+  outro: (m) => outro(m),
+  cancel: (m) => cancel(m),
   confirm: async (m) => {
-    const answer = await p3.confirm({ message: m, initialValue: true });
-    return p3.isCancel(answer) ? null : answer;
+    const answer = await confirm({ message: m, initialValue: true });
+    return isCancel(answer) ? null : answer;
   }
 };
-var FIND_SKILLS = "skillmd/find-skills";
+var FIND_A_SKILL = "skillmd/find-a-skill";
+var FIND_A_SKILL_SOURCES = [`registry:${FIND_A_SKILL}`, "registry:skillmd/find-skills"];
+function failureReason(r) {
+  const blocked = r.blocked[0]?.reason;
+  if (blocked) return blocked;
+  const lines = stripAnsi(r.output).split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  return lines.at(-1);
+}
 async function offerFindSkills(source, flags, run2, ui, deps) {
   if (!ui.confirm || run2.exitCode !== 0 || !run2.written.length || !run2.scope || !run2.agents?.length) return;
-  if (source.replace(/^registry:/, "").toLowerCase() === FIND_SKILLS) return;
+  if (FIND_A_SKILL_SOURCES.includes(`registry:${source.replace(/^registry:/, "").toLowerCase()}`)) return;
   const cfg = readConfig(flags.home);
   if (cfg.findSkillsOffered) return;
   const global = run2.scope === "global";
   const lock = readLock({ global, cwd: flags.cwd, home: flags.home });
-  if (Object.values(lock.skills).some((e) => e.source === `registry:${FIND_SKILLS}`)) return;
+  if (Object.values(lock.skills).some((e) => FIND_A_SKILL_SOURCES.includes(e.source))) return;
   try {
     writeConfig({ ...cfg, findSkillsOffered: true }, flags.home);
   } catch {
   }
-  const yes = await ui.confirm("Also add find-skills, so your agent can look for more skills on SkillMD when a task needs one?");
+  const yes = await ui.confirm("Also add find-a-skill, so your agent can look for more skills on SkillMD when a task needs one?");
   if (!yes) return;
-  const r = await runAdd(FIND_SKILLS, {
+  const r = await runAdd(FIND_A_SKILL, {
     ...flags,
     yes: true,
     json: false,
@@ -1422,7 +1978,8 @@ async function offerFindSkills(source, flags, run2, ui, deps) {
     project: !global,
     agent: run2.agents
   }, deps);
-  ui.message(r.exitCode === 0 ? `${pc8.green(GLYPH.ok)} find-skills added` : pc8.yellow(`${GLYPH.warn} find-skills could not be added. Try later: npx get-skill add ${FIND_SKILLS}`));
+  const why = r.exitCode === 0 ? "" : failureReason(r);
+  ui.message(r.exitCode === 0 ? `${pc10.green(GLYPH.ok)} find-a-skill added` : pc10.yellow(`${GLYPH.warn} find-a-skill was not added${why ? `: ${why}` : ""}. To add it yourself: npx get-skill add ${FIND_A_SKILL}`));
 }
 async function runAddWithUI(source, flags, opts = {}) {
   const term = opts.term ?? { ...realTerminal(), env: flags.env ?? process.env };
@@ -1439,14 +1996,14 @@ async function runAddWithUI(source, flags, opts = {}) {
       // this spread.
       ...base,
       resolve: async (arg, f) => {
-        const s = ui.spinner();
-        s.start(`Resolving ${arg}`);
+        const s2 = ui.spinner();
+        s2.start(`Resolving ${arg}`);
         try {
           const c = await base.resolve(arg, f);
-          s.stop(`${c.length} skill${c.length === 1 ? "" : "s"} found`);
+          s2.stop(`${c.length} skill${c.length === 1 ? "" : "s"} found`);
           return c;
         } catch (e) {
-          s.stop(pc8.red("Could not resolve the source"));
+          s2.stop(pc10.red("Could not resolve the source"));
           throw e;
         }
       }
@@ -1457,10 +2014,10 @@ async function runAddWithUI(source, flags, opts = {}) {
     }
     ui.message(run2.output);
     await offerFindSkills(source, flags, run2, ui, base);
-    ui.outro(run2.exitCode === 0 ? `Done. Run ${pc8.cyan("npx get-skill list")} to see everything installed.` : pc8.red("Some skills were not installed."));
+    ui.outro(run2.exitCode === 0 ? `Done. Run ${pc10.cyan("npx get-skill list")} to see everything installed.` : pc10.red("Some skills were not installed."));
     return { run: run2, printed: true };
   } catch (e) {
-    ui.outro(pc8.red("Nothing was installed."));
+    ui.outro(pc10.red("Nothing was installed."));
     throw e;
   }
 }
@@ -1469,20 +2026,20 @@ async function runAddWithUI(source, flags, opts = {}) {
 import { Command as Command8 } from "commander";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { join as join4 } from "path";
-import pc9 from "picocolors";
+import pc11 from "picocolors";
 import { parseSkillMd as parseSkillMd3 } from "@skillmds/core";
 function runList(flags = {}) {
   const scopes = scopesFor(flags);
   let items = [];
   for (const global of scopes) {
-    for (const s of listInstalled({ global, cwd: flags.cwd, home: flags.home })) {
-      const md = join4(s.path, "SKILL.md");
+    for (const s2 of listInstalled({ global, cwd: flags.cwd, home: flags.home })) {
+      const md = join4(s2.path, "SKILL.md");
       let description = "";
       if (existsSync3(md)) {
         const parsed = parseSkillMd3(readFileSync2(md, "utf8"));
         description = "error" in parsed ? `(invalid SKILL.md \u2014 ${parsed.error})` : parsed.description;
       }
-      items.push({ ...s, description: safeText(description, 80) });
+      items.push({ ...s2, description: safeText(description, 80) });
     }
   }
   if (flags.agent?.length) items = items.filter((i) => i.agents.some((a) => flags.agent.includes(a)));
@@ -1490,13 +2047,13 @@ function runList(flags = {}) {
   if (flags.json) {
     return { items, output: JSON.stringify(items.map(({ name, scope, path, agents, source, mode, tracked, description }) => ({ name, scope, path, agents, source: source ?? null, mode, tracked, description })), null, 2) };
   }
-  if (items.length === 0) return { items, output: pc9.dim("No installed skills found. Install one with `npx get-skill add owner/name`.") };
+  if (items.length === 0) return { items, output: pc11.dim("No installed skills found. Install one with `npx get-skill add owner/name`.") };
   const w = Math.max(...items.map((i) => i.name.length), 4);
   const lines = items.map((i) => {
-    const tag = i.tracked ? pc9.dim(i.source ?? "") : pc9.yellow("untracked");
+    const tag = i.tracked ? pc11.dim(i.source ?? "") : pc11.yellow("untracked");
     const modes = [...new Set(Object.values(i.mode))].join("/");
-    return `${pc9.bold(i.name.padEnd(w))}  ${pc9.cyan(i.scope.padEnd(7))}  ${i.agents.join(", ").padEnd(24)}  ${pc9.dim(modes.padEnd(9))}  ${tag}
-${" ".repeat(w + 2)}${pc9.dim(i.description)}`;
+    return `${pc11.bold(i.name.padEnd(w))}  ${pc11.cyan(i.scope.padEnd(7))}  ${i.agents.join(", ").padEnd(24)}  ${pc11.dim(modes.padEnd(9))}  ${tag}
+${" ".repeat(w + 2)}${pc11.dim(i.description)}`;
   });
   return { items, output: lines.join("\n") };
 }
@@ -1510,16 +2067,15 @@ function listCommand() {
 import { Command as Command9 } from "commander";
 import { rmSync } from "fs";
 import { join as join5, resolve as resolve4 } from "path";
-import * as p4 from "@clack/prompts";
-import pc10 from "picocolors";
+import pc12 from "picocolors";
 var defaultDeps = (flags) => isInteractive(flags) ? {
   confirm: async (msg2) => {
-    const a = await p4.confirm({ message: msg2, initialValue: false });
-    return !p4.isCancel(a) && a;
+    const a = await confirm({ message: msg2, initialValue: false });
+    return !isCancel(a) && a;
   },
   pick: async ({ names }) => {
-    const a = await p4.multiselect({ message: "Which skills do you want to remove?", options: names.map((n) => ({ value: n, label: n })), required: true });
-    return p4.isCancel(a) ? null : a;
+    const a = await multiselect({ message: "Which skills do you want to remove?", options: names.map((n) => ({ value: n, label: n })), required: true });
+    return isCancel(a) ? null : a;
   }
 } : {};
 function finish3(flags, result, doc) {
@@ -1532,32 +2088,32 @@ async function runRemove(names, flags, deps = defaultDeps(flags)) {
   const lines = [];
   if (flags.all && names.length) {
     const error = "--all cannot be combined with skill names";
-    return finish3(flags, { removed: [], exitCode: 1, output: pc10.red(error) }, { ok: false, error });
+    return finish3(flags, { removed: [], exitCode: 1, output: pc12.red(error) }, { ok: false, error });
   }
   const perScope = scopes.map((scope) => ({ scope, installed: listInstalled(scope) }));
-  const allNames = [...new Set(perScope.flatMap((s) => s.installed.map((i) => i.name)))];
+  const allNames = [...new Set(perScope.flatMap((s2) => s2.installed.map((i) => i.name)))];
   const nothingInstalled = `No installed skills found in ${where} scope.`;
   let targets = names;
   if (flags.all) {
     if (allNames.length === 0) {
-      return finish3(flags, { removed: [], exitCode: 1, output: pc10.dim(nothingInstalled) }, { ok: false, error: nothingInstalled });
+      return finish3(flags, { removed: [], exitCode: 1, output: pc12.dim(nothingInstalled) }, { ok: false, error: nothingInstalled });
     }
     targets = allNames;
   } else if (targets.length === 0) {
     if (!deps.pick) {
       const error = "Give one or more skill names, or --all.";
-      return finish3(flags, { removed: [], exitCode: 1, output: pc10.red(`${error} `) + pc10.dim(nonInteractiveHint("skill names and -y")) }, { ok: false, error });
+      return finish3(flags, { removed: [], exitCode: 1, output: pc12.red(`${error} `) + pc12.dim(nonInteractiveHint("skill names and -y")) }, { ok: false, error });
     }
     if (allNames.length === 0) {
-      return finish3(flags, { removed: [], exitCode: 1, output: pc10.dim(nothingInstalled) }, { ok: false, error: nothingInstalled });
+      return finish3(flags, { removed: [], exitCode: 1, output: pc12.dim(nothingInstalled) }, { ok: false, error: nothingInstalled });
     }
     const picked = await deps.pick({ names: allNames });
-    if (!picked) return finish3(flags, { removed: [], exitCode: 0, cancelled: true, output: pc10.dim("Nothing removed.") }, { ok: true, removed: [], cancelled: true });
+    if (!picked) return finish3(flags, { removed: [], exitCode: 0, cancelled: true, output: pc12.dim("Nothing removed.") }, { ok: true, removed: [], cancelled: true });
     targets = picked;
   }
   const known = targets.filter((n) => allNames.includes(n));
   const missing = targets.filter((n) => !known.includes(n));
-  for (const n of missing) lines.push(pc10.yellow(`- ${n} not installed (${where} scope)`));
+  for (const n of missing) lines.push(pc12.yellow(`- ${n} not installed (${where} scope)`));
   if (known.length === 0) {
     const output = lines.join("\n");
     return finish3(flags, { removed: [], exitCode: 1, output }, { ok: false, error: `not installed: ${missing.join(", ")}`, missing });
@@ -1567,17 +2123,17 @@ async function runRemove(names, flags, deps = defaultDeps(flags)) {
     const ok = deps.confirm ? await deps.confirm(`Remove ${known.length} skill${known.length === 1 ? "" : "s"} (${known.join(", ")}) ${what} in ${where} scope?`) : null;
     if (ok === null) {
       const error = nonInteractiveHint("-y");
-      return finish3(flags, { removed: [], exitCode: 1, output: pc10.red(error) }, { ok: false, error });
+      return finish3(flags, { removed: [], exitCode: 1, output: pc12.red(error) }, { ok: false, error });
     }
-    if (!ok) return finish3(flags, { removed: [], exitCode: 0, cancelled: true, output: pc10.dim("Nothing removed.") }, { ok: true, removed: [], cancelled: true });
+    if (!ok) return finish3(flags, { removed: [], exitCode: 0, cancelled: true, output: pc12.dim("Nothing removed.") }, { ok: true, removed: [], cancelled: true });
   }
   const removed = [];
   const skipped = [];
   let changed = 0;
   for (const name of known) {
     for (const { scope, installed } of perScope) {
-      if (!installed.some((s) => s.name === name)) continue;
-      const tag = scopes.length > 1 ? pc10.dim(` [${scopeLabel(scope)}]`) : "";
+      if (!installed.some((s2) => s2.name === name)) continue;
+      const tag = scopes.length > 1 ? pc12.dim(` [${scopeLabel(scope)}]`) : "";
       if (flags.agent?.length) {
         const lock = readLock({ global: Boolean(scope.global), cwd: scope.cwd, home: scope.home });
         const entry = lock.skills[name];
@@ -1588,11 +2144,11 @@ async function runRemove(names, flags, deps = defaultDeps(flags)) {
           try {
             dir = agentDir(a, scope);
           } catch (e) {
-            lines.push(pc10.yellow(`- ${a}: ${e instanceof Error ? e.message : String(e)}`));
+            lines.push(pc12.yellow(`- ${a}: ${e instanceof Error ? e.message : String(e)}`));
             continue;
           }
           if (resolve4(dir) === canonRoot || entry?.mode[a] === "canonical") {
-            lines.push(pc10.dim(`${GLYPH.skip} ${name}: ${a} reads the canonical copy directly \u2014 unlinking is a no-op (use remove without -a to delete the skill)`));
+            lines.push(pc12.dim(`${GLYPH.skip} ${name}: ${a} reads the canonical copy directly \u2014 unlinking is a no-op (use remove without -a to delete the skill)`));
             skipped.push({ skill: name, agent: a, scope: scopeLabel(scope), reason: "reads the canonical copy directly" });
             acted = true;
             continue;
@@ -1602,17 +2158,17 @@ async function runRemove(names, flags, deps = defaultDeps(flags)) {
             rmSync(pth, { recursive: true, force: true });
             removed.push(pth);
             acted = true;
-            lines.push(pc10.green(`${GLYPH.ok} removed ${name} from ${a}`) + tag);
+            lines.push(pc12.green(`${GLYPH.ok} removed ${name} from ${a}`) + tag);
           }
         }
-        if (!acted) lines.push(pc10.yellow(`- ${name} is not linked into ${flags.agent.join(", ")}`) + tag);
+        if (!acted) lines.push(pc12.yellow(`- ${name} is not linked into ${flags.agent.join(", ")}`) + tag);
         if (entry) {
           const left = entry.agents.filter((a) => !flags.agent.includes(a));
           if (left.length) upsertEntry({ global: Boolean(scope.global), cwd: scope.cwd, home: scope.home }, name, { ...entry, agents: left, mode: Object.fromEntries(Object.entries(entry.mode).filter(([a]) => left.includes(a))) });
           else {
             const r2 = uninstallSkill(name, scope);
             removed.push(...r2.removed);
-            lines.push(pc10.dim(`  (no agents left \u2014 removed the canonical copy too)`));
+            lines.push(pc12.dim(`  (no agents left \u2014 removed the canonical copy too)`));
           }
         }
         if (acted) changed++;
@@ -1621,7 +2177,7 @@ async function runRemove(names, flags, deps = defaultDeps(flags)) {
       const r = uninstallSkill(name, scope);
       removed.push(...r.removed);
       changed++;
-      lines.push(pc10.green(`${GLYPH.ok} removed ${name}`) + tag + pc10.dim(` (${r.removed.length} path${r.removed.length === 1 ? "" : "s"}${r.untracked ? ", untracked" : ""})`));
+      lines.push(pc12.green(`${GLYPH.ok} removed ${name}`) + tag + pc12.dim(` (${r.removed.length} path${r.removed.length === 1 ? "" : "s"}${r.untracked ? ", untracked" : ""})`));
     }
   }
   const exitCode = changed ? 0 : 1;
@@ -1639,7 +2195,7 @@ function removeCommand() {
 
 // src/commands/update.ts
 import { Command as Command10 } from "commander";
-import pc11 from "picocolors";
+import pc13 from "picocolors";
 import { lint as lint3 } from "@skillmds/core";
 function pickSkillTree(files, want) {
   const norm = files.map((f) => ({ path: f.path.replace(/\\/g, "/"), contents: f.contents }));
@@ -1702,64 +2258,64 @@ async function runUpdate(names, flags, deps = defaultUpdateDeps) {
   for (const global of scopes) {
     const scope = { global, cwd: flags.cwd, home: flags.home };
     const lock = readLock(scope);
-    const installed = listInstalled(scope).filter((s) => names.length === 0 || names.includes(s.name));
-    for (const s of installed) {
-      seen.add(s.name);
-      const label2 = `${s.name}${scopes.length > 1 ? pc11.dim(` [${s.scope}]`) : ""}`;
-      const entry = lock.skills[s.name];
+    const installed = listInstalled(scope).filter((s2) => names.length === 0 || names.includes(s2.name));
+    for (const s2 of installed) {
+      seen.add(s2.name);
+      const label2 = `${s2.name}${scopes.length > 1 ? pc13.dim(` [${s2.scope}]`) : ""}`;
+      const entry = lock.skills[s2.name];
       if (!entry) {
-        lines.push(pc11.dim(`- ${label2} untracked \u2014 reinstall with \`npx get-skill add\` to track updates`));
+        lines.push(pc13.dim(`- ${label2} untracked \u2014 reinstall with \`npx get-skill add\` to track updates`));
         continue;
       }
       if (entry.source.startsWith("local:")) {
-        lines.push(pc11.dim(`- ${label2} local source \u2014 not auto-updated`));
+        lines.push(pc13.dim(`- ${label2} local source \u2014 not auto-updated`));
         continue;
       }
       try {
-        const latest = await deps.fetchLatest(entry.source, flags, s.name);
+        const latest = await deps.fetchLatest(entry.source, flags, s2.name);
         if (!latest) {
-          failed.push(s.name);
-          lines.push(pc11.red(`${GLYPH.blocked} ${label2} no longer available upstream (${entry.source})`));
+          failed.push(s2.name);
+          lines.push(pc13.red(`${GLYPH.blocked} ${label2} no longer available upstream (${entry.source})`));
           continue;
         }
         if (entry.source.startsWith("registry:") && latest.commit_sha && entry.commit_sha && latest.commit_sha === entry.commit_sha) {
-          lines.push(pc11.dim(`- ${label2} up to date`));
+          lines.push(pc13.dim(`- ${label2} up to date`));
           continue;
         }
         if (digestOf(latest.files) === entry.digest) {
-          lines.push(pc11.dim(`- ${label2} up to date`));
+          lines.push(pc13.dim(`- ${label2} up to date`));
           continue;
         }
         if (flags.check) {
-          available.push(s.name);
-          lines.push(pc11.yellow(`\u2191 ${label2} update available`));
+          available.push(s2.name);
+          lines.push(pc13.yellow(`\u2191 ${label2} update available`));
           continue;
         }
         const md = latest.files.find((f) => f.path === "SKILL.md");
         const raw = md ? typeof md.contents === "string" ? md.contents : md.contents.toString("utf8") : "";
-        const result = lint3(raw, { slug: s.name });
+        const result = lint3(raw, { slug: s2.name });
         if (!result.ok) {
-          failed.push(s.name);
-          lines.push(pc11.red(`${GLYPH.blocked} ${label2} update failed lint (${result.diagnostics.filter((d) => d.severity === "error").map((d) => d.id).join(", ")}) \u2014 kept the installed version`));
+          failed.push(s2.name);
+          lines.push(pc13.red(`${GLYPH.blocked} ${label2} update failed lint (${result.diagnostics.filter((d) => d.severity === "error").map((d) => d.id).join(", ")}) \u2014 kept the installed version`));
           continue;
         }
-        await installSkill({ name: s.name, files: latest.files, source: entry.source, commit_sha: latest.commit_sha, scope, agents: entry.agents, explicitAgents: true, mode: Object.values(entry.mode).includes("copy") ? "copy" : "link" });
-        updated.push(s.name);
-        lines.push(pc11.green(`${GLYPH.ok} ${label2} updated`));
+        await installSkill({ name: s2.name, files: latest.files, source: entry.source, commit_sha: latest.commit_sha, scope, agents: entry.agents, explicitAgents: true, mode: Object.values(entry.mode).includes("copy") ? "copy" : "link" });
+        updated.push(s2.name);
+        lines.push(pc13.green(`${GLYPH.ok} ${label2} updated`));
       } catch (e) {
-        failed.push(s.name);
-        lines.push(pc11.red(`${GLYPH.blocked} ${label2} ${e instanceof Error ? e.message : String(e)}`));
+        failed.push(s2.name);
+        lines.push(pc13.red(`${GLYPH.blocked} ${label2} ${e instanceof Error ? e.message : String(e)}`));
       }
     }
   }
   for (const n of names) {
     if (seen.has(n)) continue;
     failed.push(n);
-    lines.push(pc11.yellow(`- ${n} not installed`));
+    lines.push(pc13.yellow(`- ${n} not installed`));
   }
   const exitCode = failed.length ? 1 : 0;
   if (flags.json) return { updated, available, failed, exitCode, output: JSON.stringify({ ok: exitCode === 0, updated: [...new Set(updated)], available: [...new Set(available)], failed: [...new Set(failed)] }, null, 2) };
-  if (lines.length === 0) lines.push(pc11.dim("No installed skills found."));
+  if (lines.length === 0) lines.push(pc13.dim("No installed skills found."));
   return { updated, available, failed, exitCode, output: lines.join("\n") };
 }
 function scopeOptions(cmd) {
@@ -1767,14 +2323,16 @@ function scopeOptions(cmd) {
 }
 function updateCommand() {
   return scopeOptions(new Command10("update").description("Update installed skills from the source recorded in the lock file (re-lints before writing)").argument("[names...]", "specific skills (default: all tracked)").option("--check", "only report which skills have updates")).action(async (names, opts, cmd) => {
-    const run2 = await runUpdate(names, { ...cmd.parent?.opts(), ...opts });
+    const flags = { ...cmd.parent?.opts(), ...opts };
+    const run2 = await waitFor("walk", flags.check ? "Checking for updates" : "Updating skills", runUpdate(names, flags), { json: flags.json });
     console.log(run2.output);
     process.exitCode = run2.exitCode;
   });
 }
 function checkCommand() {
   return scopeOptions(new Command10("check").description("Report installed skills that have updates (alias of `update --check`)").argument("[names...]", "specific skills (default: all tracked)")).action(async (names, opts, cmd) => {
-    const run2 = await runUpdate(names, { ...cmd.parent?.opts(), ...opts, check: true });
+    const flags = { ...cmd.parent?.opts(), ...opts, check: true };
+    const run2 = await waitFor("walk", "Checking for updates", runUpdate(names, flags), { json: flags.json });
     console.log(run2.output);
     process.exitCode = run2.exitCode;
   });
@@ -1782,7 +2340,7 @@ function checkCommand() {
 
 // src/commands/publish.ts
 import { Command as Command11 } from "commander";
-import pc12 from "picocolors";
+import pc14 from "picocolors";
 import { lint as lint4, toText } from "@skillmds/core";
 var defaultDeps2 = {
   resolve: resolveSource,
@@ -1806,25 +2364,25 @@ async function runPublish(target, flags, deps = defaultDeps2) {
   const report = toText([{ file: src.path, result }], { decorate });
   if (!result.ok) {
     return { result, published: false, exitCode: 1, output: `${report}
-${pc12.red("\u2717 Refusing to publish: fix the errors above.")}` };
+${pc14.red("\u2717 Refusing to publish: fix the errors above.")}` };
   }
   const hasWarn = result.diagnostics.some((d) => d.severity === "warn");
   if (hasWarn && !flags.force) {
     return { result, published: false, exitCode: 1, output: `${report}
-${pc12.yellow("\u2717 Warnings present. Re-run with --force to publish anyway.")}` };
+${pc14.yellow("\u2717 Warnings present. Re-run with --force to publish anyway.")}` };
   }
   if (flags.dryRun) {
     return { result, published: false, exitCode: 0, output: `${report}
-${pc12.green("\u2713 Dry run: would publish.")}` };
+${pc14.green("\u2713 Dry run: would publish.")}` };
   }
   const res = await deps.submit({ content: src.raw, type: flags.type ?? "single" }, flags);
   return { result, published: true, slug: res.slug, exitCode: 0, output: `${report}
-${pc12.green(`\u2713 Published ${res.slug ?? src.slug} (status: ${res.status ?? "pending"})`)}` };
+${pc14.green(`\u2713 Published ${res.slug ?? src.slug} (status: ${res.status ?? "pending"})`)}` };
 }
 function publishCommand() {
   return new Command11("publish").alias("submit").description("Publish a skill to the registry (refuses to publish on lint errors)").argument("[target]", "local path to the skill", ".").option("--type <type>", "single | pack", "single").option("--force", "publish despite warnings (never bypasses errors)").option("--dry-run", "lint only; do not publish").action(async (target, opts, cmd) => {
     const merged = { ...cmd.parent?.opts(), ...opts };
-    const run2 = await runPublish(target, merged);
+    const run2 = await waitFor("walk", merged.dryRun ? "Checking" : "Publishing", runPublish(target, merged));
     console.log(run2.output);
     process.exitCode = run2.exitCode;
   });
@@ -1832,11 +2390,10 @@ function publishCommand() {
 
 // src/commands/login.ts
 import { Command as Command12 } from "commander";
-import * as p5 from "@clack/prompts";
-import pc13 from "picocolors";
+import pc15 from "picocolors";
 var defaultLoginDeps = (flags) => promptIf(flags, async () => {
-  const answer = await p5.password({ message: "Paste your SkillMD token (from your account page)" });
-  return p5.isCancel(answer) ? null : answer;
+  const answer = await password({ message: "Paste your SkillMD token (from your account page)" });
+  return isCancel(answer) ? null : answer;
 });
 function finish4(flags, result, doc) {
   return flags.json ? { ...result, output: JSON.stringify(doc, null, 2) } : result;
@@ -1847,15 +2404,15 @@ async function runLogin(flags, deps = defaultLoginDeps(flags)) {
   if (!token) {
     if (!deps.prompt) {
       const error = nonInteractiveHint("--token <token> (or set SKILLMD_TOKEN)");
-      return finish4(flags, { exitCode: 1, output: pc13.red(error) }, { ok: false, error });
+      return finish4(flags, { exitCode: 1, output: pc15.red(error) }, { ok: false, error });
     }
     const answer = await deps.prompt();
-    if (answer === null) return finish4(flags, { exitCode: 0, output: pc13.dim("Cancelled.") }, { ok: false, cancelled: true });
+    if (answer === null) return finish4(flags, { exitCode: 0, output: pc15.dim("Cancelled.") }, { ok: false, cancelled: true });
     token = answer;
   }
   if (!token) {
     const error = "A token is required.";
-    return finish4(flags, { exitCode: 1, output: pc13.red(error) }, { ok: false, error });
+    return finish4(flags, { exitCode: 1, output: pc15.red(error) }, { ok: false, error });
   }
   const cfg = readConfig(flags.home);
   let host;
@@ -1863,7 +2420,7 @@ async function runLogin(flags, deps = defaultLoginDeps(flags)) {
     host = hostOf(resolveApi({ api: flags.api, insecureHttp: flags.insecureHttp }, { env, config: { ...cfg, api: flags.api ?? cfg.api } }));
   } catch (e) {
     const msg2 = e instanceof Error ? e.message : String(e);
-    return { exitCode: 1, output: flags.json ? JSON.stringify({ ok: false, error: msg2 }, null, 2) : pc13.red(msg2) };
+    return { exitCode: 1, output: flags.json ? JSON.stringify({ ok: false, error: msg2 }, null, 2) : pc15.red(msg2) };
   }
   cfg.token = token;
   if (flags.api) cfg.api = flags.api;
@@ -1902,11 +2459,10 @@ function logoutCommand() {
 }
 
 // src/commands/interactive.ts
-import * as p6 from "@clack/prompts";
-import pc14 from "picocolors";
+import pc16 from "picocolors";
 function bail(v) {
-  if (p6.isCancel(v)) {
-    p6.cancel("Cancelled.");
+  if (isCancel(v)) {
+    cancel("Cancelled.");
     return true;
   }
   return false;
@@ -1914,7 +2470,7 @@ function bail(v) {
 async function browseSearchResults(items) {
   const cols = process.stdout.columns ?? 80;
   for (; ; ) {
-    const picked = await p6.select({
+    const picked = await select({
       message: "Search results",
       options: [
         ...items.map((item2) => {
@@ -1922,7 +2478,7 @@ async function browseSearchResults(items) {
           const checkTxt = item2.verified ? " \u2713" : "";
           const slugTxt = safeText(item2.slug, 200);
           const plainLabel = `${slugTxt}${starsTxt}${checkTxt}`;
-          const label2 = `${pc14.bold(slugTxt)}${starsTxt ? pc14.dim(starsTxt) : ""}${checkTxt ? pc14.green(checkTxt) : ""}`;
+          const label2 = `${pc16.bold(slugTxt)}${starsTxt ? pc16.dim(starsTxt) : ""}${checkTxt ? pc16.green(checkTxt) : ""}`;
           const hintWidth = Math.max(10, cols - plainLabel.length - 6);
           return {
             value: item2.slug,
@@ -1933,7 +2489,7 @@ async function browseSearchResults(items) {
         { value: "__back", label: "\u2190 Back to menu" }
       ]
     });
-    if (p6.isCancel(picked) || picked === "__back") return;
+    if (isCancel(picked) || picked === "__back") return;
     const item = items.find((i) => i.slug === picked);
     if (!item) continue;
     await browseOneResult(item);
@@ -1944,12 +2500,12 @@ async function browseOneResult(item) {
   const slugTxt = safeText(item.slug, 200);
   const meta = [
     starsTxt,
-    item.verified ? pc14.green("\u2713 verified") : "unverified",
+    item.verified ? pc16.green("\u2713 verified") : "unverified",
     item.type === "pack" ? "pack" : ""
   ].filter(Boolean).join(" \xB7 ");
-  p6.note([safeText(item.description ?? ""), pc14.dim(meta)].join("\n"), slugTxt);
+  note([safeText(item.description ?? ""), pc16.dim(meta)].join("\n"), slugTxt);
   for (; ; ) {
-    const action = await p6.select({
+    const action = await select({
       message: "What next?",
       options: [
         { value: "project", label: "Install to this project" },
@@ -1958,26 +2514,31 @@ async function browseOneResult(item) {
         { value: "back", label: "\u2190 Back to results" }
       ]
     });
-    if (p6.isCancel(action) || action === "back") return;
+    if (isCancel(action) || action === "back") return;
     if (action === "url") {
-      p6.log.message(pc14.dim(`https://skillmd.com/skills/${slugTxt}`));
+      log.message(pc16.dim(`https://skillmd.com/skills/${slugTxt}`));
       continue;
     }
-    p6.log.step(`Installing ${slugTxt}\u2026`);
+    log.step(`Installing ${slugTxt}\u2026`);
     try {
       const run2 = await runAdd(item.slug, action === "global" ? { global: true } : { project: true });
       console.log(run2.output);
-      if (run2.exitCode === 0) p6.log.success("Installed.");
-      else p6.log.warn("Not installed.");
+      if (run2.exitCode === 0) log.success("Installed.");
+      else log.warn("Not installed.");
     } catch (err) {
-      p6.log.error(err instanceof Error ? err.message : String(err));
+      log.error(err instanceof Error ? err.message : String(err));
     }
   }
 }
-async function runInteractive() {
-  p6.intro(banner());
+async function runInteractive(opts = {}) {
+  console.log();
+  await playLogo();
+  console.log(`
+  ${pc16.dim("Teach your agent anything.")}${opts.version ? `  ${pc16.dim(`v${opts.version}`)}` : ""}
+`);
+  startFrameAfterLogo();
   for (; ; ) {
-    const action = await p6.select({
+    const action = await select({
       message: "What would you like to do?",
       options: [
         { value: "lint", label: "Lint a skill", hint: "validate a SKILL.md" },
@@ -1996,66 +2557,66 @@ async function runInteractive() {
     switch (action) {
       case "lint":
       case "scan": {
-        const path = await p6.text({ message: "Path to a skill or folder", placeholder: ".", defaultValue: "." });
+        const path = await text({ message: "Path to a skill or folder", placeholder: ".", defaultValue: "." });
         if (bail(path)) break;
         const target = String(path || ".");
-        const s = p6.spinner();
-        s.start(action === "lint" ? "Linting" : "Scanning");
+        const s2 = spinner("walk");
+        s2.start(action === "lint" ? "Linting" : "Scanning");
         try {
           const run2 = action === "lint" ? await runLint(target, { format: "text" }) : await runScan(target, { format: "text" });
-          s.stop("Done");
+          s2.stop("Done");
           console.log(run2.output);
           process.exitCode = run2.exitCode;
         } catch (err) {
-          s.stop(pc14.red(err instanceof Error ? err.message : String(err)));
+          s2.stop(pc16.red(err instanceof Error ? err.message : String(err)));
           process.exitCode = 1;
         }
         break;
       }
       case "search": {
-        const query = await p6.text({ message: "Search the registry for" });
+        const query = await text({ message: "Search the registry for" });
         if (bail(query)) break;
-        const verified = await p6.confirm({ message: "Verified skills only?", initialValue: false });
+        const verified = await confirm({ message: "Verified skills only?", initialValue: false });
         if (bail(verified)) break;
-        const s = p6.spinner();
-        s.start("Searching");
+        const s2 = spinner("hop");
+        s2.start(`Searching for ${safeText(String(query))}`);
         try {
           const run2 = await runSearch(String(query), { verified: Boolean(verified), limit: "20" });
-          s.stop(`${run2.items.length} result${run2.items.length === 1 ? "" : "s"}`);
+          s2.stop(`${run2.items.length} result${run2.items.length === 1 ? "" : "s"}`);
           if (run2.items.length === 0) {
-            p6.log.info("No results.");
+            log.info("No results.");
             break;
           }
           await browseSearchResults(run2.items);
         } catch (err) {
-          s.stop(pc14.red(err instanceof Error ? err.message : String(err)));
+          s2.stop(pc16.red(err instanceof Error ? err.message : String(err)));
           process.exitCode = 1;
         }
         break;
       }
       case "init": {
-        const name = await p6.text({ message: "Skill name", placeholder: "my-skill" });
+        const name = await text({ message: "Skill name", placeholder: "my-skill" });
         if (bail(name)) break;
-        const description = await p6.text({ message: "One-line description", placeholder: "What this skill helps an agent do" });
+        const description = await text({ message: "One-line description", placeholder: "What this skill helps an agent do" });
         if (bail(description)) break;
         try {
           const file = initSkill(String(name), { description: String(description || "") });
-          p6.log.success(`Created ${pc14.bold(file)}`);
+          log.success(`Created ${pc16.bold(file)}`);
         } catch (err) {
-          p6.log.error(err instanceof Error ? err.message : String(err));
+          log.error(err instanceof Error ? err.message : String(err));
           process.exitCode = 1;
         }
         break;
       }
       case "install": {
-        const src = await p6.text({ message: "Skill source", placeholder: "owner/name, https://github.com/\u2026, or ./path" });
+        const src = await text({ message: "Skill source", placeholder: "owner/name, https://github.com/\u2026, or ./path" });
         if (bail(src)) break;
         try {
           const run2 = await runAdd(String(src), {});
           console.log(run2.output);
           process.exitCode = run2.exitCode;
         } catch (err) {
-          p6.log.error(err instanceof Error ? err.message : String(err));
+          log.error(err instanceof Error ? err.message : String(err));
           process.exitCode = 1;
         }
         break;
@@ -2065,12 +2626,16 @@ async function runInteractive() {
         break;
       }
       case "update": {
+        const s2 = spinner("walk");
+        s2.start("Updating installed skills");
         try {
           const run2 = await runUpdate([], {});
+          const n = new Set(run2.updated).size;
+          s2.stop(n ? `Updated ${n} skill${n === 1 ? "" : "s"}` : "Done", run2.exitCode === 0 ? 0 : 2);
           console.log(run2.output);
           process.exitCode = run2.exitCode;
         } catch (err) {
-          p6.log.error(err instanceof Error ? err.message : String(err));
+          s2.stop(pc16.red(err instanceof Error ? err.message : String(err)), 2);
           process.exitCode = 1;
         }
         break;
@@ -2081,23 +2646,23 @@ async function runInteractive() {
           console.log(run2.output);
           process.exitCode = run2.exitCode;
         } catch (err) {
-          p6.log.error(err instanceof Error ? err.message : String(err));
+          log.error(err instanceof Error ? err.message : String(err));
           process.exitCode = 1;
         }
         break;
       }
       case "help": {
-        p6.note(
+        note(
           [
-            `${pc14.bold("lint")} [path]      validate SKILL.md + quality score`,
-            `${pc14.bold("scan")} [path]      security scan`,
-            `${pc14.bold("search")} <query>   search the registry`,
-            `${pc14.bold("add")} <source>     install a skill (lints first)`,
-            `${pc14.bold("info")} <slug>      registry details for a skill`,
-            `${pc14.bold("init")} [name]      scaffold a new skill`,
-            `${pc14.bold("list / remove / update")}   manage installed skills`,
-            `${pc14.bold("publish")} [path]   publish (fails on lint errors)`,
-            `${pc14.bold("rules / login")}`
+            `${pc16.bold("lint")} [path]      validate SKILL.md + quality score`,
+            `${pc16.bold("scan")} [path]      security scan`,
+            `${pc16.bold("search")} <query>   search the registry`,
+            `${pc16.bold("add")} <source>     install a skill (lints first)`,
+            `${pc16.bold("info")} <slug>      registry details for a skill`,
+            `${pc16.bold("init")} [name]      scaffold a new skill`,
+            `${pc16.bold("list / remove / update")}   manage installed skills`,
+            `${pc16.bold("publish")} [path]   publish (fails on lint errors)`,
+            `${pc16.bold("rules / login")}`
           ].join("\n"),
           "Commands (run: skillmd <command>)"
         );
@@ -2105,7 +2670,7 @@ async function runInteractive() {
       }
     }
   }
-  p6.outro(pc14.dim("skillmd.com"));
+  outro(pc16.dim("skillmd.com"));
 }
 
 // src/index.ts
@@ -2135,7 +2700,7 @@ Docs: https://skillmd.com/docs/cli`);
 program.hook("preAction", (thisCmd) => {
   const opts = thisCmd.opts();
   if (opts.token && process.stderr.isTTY) {
-    console.error(pc15.yellow("\u26A0 --token is visible in your shell history and process list; prefer `npx get-skill login` or SKILLMD_TOKEN."));
+    console.error(pc17.yellow("\u26A0 --token is visible in your shell history and process list; prefer `npx get-skill login` or SKILLMD_TOKEN."));
   }
 });
 program.addCommand(lintCommand());
@@ -2154,7 +2719,7 @@ program.addCommand(loginCommand());
 program.addCommand(logoutCommand());
 if (process.argv.slice(2).length === 0) {
   if (process.stdout.isTTY) {
-    await runInteractive();
+    await runInteractive({ version });
     process.exit(process.exitCode ?? 0);
   }
   program.outputHelp();