agent-loadout 0.1.0 → 1.0.0

package/dist/index.js

@@ -1,392 +1,79 @@
 #!/usr/bin/env node
+import {
+  PRESETS,
+  TOOLS,
+  getToolsByIds,
+  getToolsByPreset,
+  validateToolIds
+} from "./chunk-JYIPAISH.js";
 
 // src/index.ts
 import { Command } from "commander";
-import chalk6 from "chalk";
+import chalk10 from "chalk";
 
-// src/catalog.ts
-var PRESETS = [
-  {
-    id: "core",
-    name: "Core",
-    description: "Fundamentals every terminal should have",
-    defaultOn: true
-  },
-  {
-    id: "agent",
-    name: "Agent",
-    description: "Tools that specifically improve LLM workflows",
-    defaultOn: true
-  },
-  {
-    id: "media",
-    name: "Media",
-    description: "Image, audio, and video pipeline tools",
-    defaultOn: false
-  },
-  {
-    id: "dx",
-    name: "DX",
-    description: "Developer experience and quality of life",
-    defaultOn: false
-  },
-  {
-    id: "security",
-    name: "Security",
-    description: "Scanning and CI hygiene",
-    defaultOn: false
+// src/platform.ts
+import { execa } from "execa";
+async function hasCommand(cmd) {
+  try {
+    await execa(cmd, ["--version"], { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
   }
-];
-var TOOLS = [
-  // ── Core ──────────────────────────────────────────────
-  {
-    id: "rg",
-    name: "ripgrep",
-    package: "ripgrep",
-    installMethod: "brew",
-    verify: "rg --version",
-    description: "Fast code search",
-    preset: "core"
-  },
-  {
-    id: "fd",
-    name: "fd",
-    package: "fd",
-    installMethod: "brew",
-    verify: "fd --version",
-    description: "Fast file finder",
-    preset: "core"
-  },
-  {
-    id: "jq",
-    name: "jq",
-    package: "jq",
-    installMethod: "brew",
-    verify: "jq --version",
-    description: "JSON processor",
-    preset: "core"
-  },
-  {
-    id: "yq",
-    name: "yq",
-    package: "yq",
-    installMethod: "brew",
-    verify: "yq --version",
-    description: "YAML processor",
-    preset: "core"
-  },
-  {
-    id: "bat",
-    name: "bat",
-    package: "bat",
-    installMethod: "brew",
-    verify: "bat --version",
-    description: "Cat with syntax highlighting",
-    preset: "core"
-  },
-  {
-    id: "tree",
-    name: "tree",
-    package: "tree",
-    installMethod: "brew",
-    verify: "tree --version",
-    description: "Directory structure viewer",
-    preset: "core"
-  },
-  {
-    id: "gh",
-    name: "GitHub CLI",
-    package: "gh",
-    installMethod: "brew",
-    verify: "gh --version",
-    description: "GitHub CLI for PRs, issues, releases",
-    preset: "core"
-  },
-  {
-    id: "fzf",
-    name: "fzf",
-    package: "fzf",
-    installMethod: "brew",
-    verify: "fzf --version",
-    description: "Fuzzy finder",
-    preset: "core"
-  },
-  {
-    id: "xh",
-    name: "xh",
-    package: "xh",
-    installMethod: "brew",
-    verify: "xh --version",
-    description: "Friendly HTTP client",
-    preset: "core"
-  },
-  // ── Agent ─────────────────────────────────────────────
-  {
-    id: "shellcheck",
-    name: "shellcheck",
-    package: "shellcheck",
-    installMethod: "brew",
-    verify: "shellcheck --version",
-    description: "Static analysis for shell scripts",
-    preset: "agent"
-  },
-  {
-    id: "ast-grep",
-    name: "ast-grep",
-    package: "ast-grep",
-    installMethod: "brew",
-    verify: "sg --version",
-    description: "Structural code search/replace",
-    preset: "agent"
-  },
-  {
-    id: "just",
-    name: "just",
-    package: "just",
-    installMethod: "brew",
-    verify: "just --version",
-    description: "Command runner (agent-readable task menu)",
-    preset: "agent"
-  },
-  {
-    id: "grex",
-    name: "grex",
-    package: "grex",
-    installMethod: "brew",
-    verify: "grex --version",
-    description: "Generate regex from examples",
-    preset: "agent"
-  },
-  {
-    id: "knip",
-    name: "knip",
-    package: "knip",
-    installMethod: "npm",
-    verify: "knip --version",
-    description: "Find unused code/deps in TS/JS",
-    preset: "agent"
-  },
-  {
-    id: "sd",
-    name: "sd",
-    package: "sd",
-    installMethod: "brew",
-    verify: "sd --version",
-    description: "Simpler sed replacement",
-    preset: "agent"
-  },
-  {
-    id: "hyperfine",
-    name: "hyperfine",
-    package: "hyperfine",
-    installMethod: "brew",
-    verify: "hyperfine --version",
-    description: "CLI benchmarking",
-    preset: "agent"
-  },
-  {
-    id: "tokei",
-    name: "tokei",
-    package: "tokei",
-    installMethod: "brew",
-    verify: "tokei --version",
-    description: "Code statistics",
-    preset: "agent"
-  },
-  {
-    id: "tldr",
-    name: "tldr",
-    package: "tldr",
-    installMethod: "brew",
-    verify: "tldr --version",
-    description: "Quick man page summaries",
-    preset: "agent"
-  },
-  {
-    id: "biome",
-    name: "biome",
-    package: "biome",
-    installMethod: "brew",
-    verify: "biome --version",
-    description: "Lint + format JS/TS",
-    preset: "agent"
-  },
-  {
-    id: "difftastic",
-    name: "difftastic",
-    package: "difftastic",
-    installMethod: "brew",
-    verify: "difft --version",
-    description: "Structural/AST diff",
-    preset: "agent"
-  },
-  // ── Media ─────────────────────────────────────────────
-  {
-    id: "ffmpeg",
-    name: "ffmpeg",
-    package: "ffmpeg",
-    installMethod: "brew",
-    verify: "ffmpeg -version",
-    description: "Audio/video Swiss army knife",
-    preset: "media"
-  },
-  {
-    id: "exiftool",
-    name: "exiftool",
-    package: "exiftool",
-    installMethod: "brew",
-    verify: "exiftool -ver",
-    description: "Image/media metadata",
-    preset: "media"
-  },
-  {
-    id: "imagemagick",
-    name: "ImageMagick",
-    package: "imagemagick",
-    installMethod: "brew",
-    verify: "magick -version",
-    description: "Image transforms",
-    preset: "media"
-  },
-  {
-    id: "svgo",
-    name: "svgo",
-    package: "svgo",
-    installMethod: "npm",
-    verify: "svgo --version",
-    description: "SVG optimiser",
-    preset: "media"
-  },
-  // ── DX ────────────────────────────────────────────────
-  {
-    id: "eza",
-    name: "eza",
-    package: "eza",
-    installMethod: "brew",
-    verify: "eza --version",
-    description: "Modern ls replacement",
-    preset: "dx"
-  },
-  {
-    id: "zoxide",
-    name: "zoxide",
-    package: "zoxide",
-    installMethod: "brew",
-    verify: "zoxide --version",
-    description: "Smarter cd",
-    preset: "dx"
-  },
-  {
-    id: "delta",
-    name: "delta",
-    package: "git-delta",
-    installMethod: "brew",
-    verify: "delta --version",
-    description: "Better git diffs",
-    preset: "dx"
-  },
-  {
-    id: "glow",
-    name: "glow",
-    package: "glow",
-    installMethod: "brew",
-    verify: "glow --version",
-    description: "Terminal markdown renderer",
-    preset: "dx"
-  },
-  {
-    id: "mise",
-    name: "mise",
-    package: "mise",
-    installMethod: "brew",
-    verify: "mise --version",
-    description: "Runtime version manager",
-    preset: "dx"
-  },
-  {
-    id: "watchexec",
-    name: "watchexec",
-    package: "watchexec",
-    installMethod: "brew",
-    verify: "watchexec --version",
-    description: "Run commands on file change",
-    preset: "dx"
-  },
-  {
-    id: "mkcert",
-    name: "mkcert",
-    package: "mkcert",
-    installMethod: "brew",
-    verify: "mkcert --version",
-    description: "Local HTTPS certs",
-    preset: "dx"
-  },
-  {
-    id: "lazygit",
-    name: "lazygit",
-    package: "lazygit",
-    installMethod: "brew",
-    verify: "lazygit --version",
-    description: "TUI git client",
-    preset: "dx"
-  },
-  {
-    id: "dust",
-    name: "dust",
-    package: "dust",
-    installMethod: "brew",
-    verify: "dust --version",
-    description: "Disk usage tree",
-    preset: "dx"
-  },
-  {
-    id: "btm",
-    name: "bottom",
-    package: "bottom",
-    installMethod: "brew",
-    verify: "btm --version",
-    description: "System monitor TUI",
-    preset: "dx"
-  },
-  // ── Security ──────────────────────────────────────────
-  {
-    id: "trivy",
-    name: "trivy",
-    package: "trivy",
-    installMethod: "brew",
-    verify: "trivy --version",
-    description: "Vulnerability scanner",
-    preset: "security"
-  },
-  {
-    id: "act",
-    name: "act",
-    package: "act",
-    installMethod: "brew",
-    verify: "act --version",
-    description: "Run GitHub Actions locally",
-    preset: "security"
-  },
-  {
-    id: "gitleaks",
-    name: "gitleaks",
-    package: "gitleaks",
-    installMethod: "brew",
-    verify: "gitleaks version",
-    description: "Secrets scanner",
-    preset: "security"
+}
+var CANDIDATES = {
+  darwin: ["brew", "npm"],
+  linux: ["apt", "npm", "cargo"],
+  win32: ["scoop", "npm", "cargo"]
+};
+async function detectPlatform() {
+  const platform = process.platform;
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+  const candidates = CANDIDATES[platform] ?? [];
+  const checks = await Promise.all(
+    candidates.map(async (mgr) => {
+      const cmd = mgr === "apt" ? "apt-get" : mgr;
+      const found = await hasCommand(cmd);
+      return found ? mgr : null;
+    })
+  );
+  const available = checks.filter((m) => m !== null);
+  if (!available.includes("npm")) available.push("npm");
+  return { platform, arch, available };
+}
+
+// src/resolve.ts
+function resolveInstallPlan(tools, info) {
+  const resolved = [];
+  const skipped = [];
+  for (const tool of tools) {
+    const platformInstalls = tool.install[info.platform];
+    if (platformInstalls === null) {
+      skipped.push({ tool, reason: "not available on this platform" });
+      continue;
+    }
+    const match = platformInstalls.find((pi) => info.available.includes(pi.method));
+    if (!match) {
+      const required = platformInstalls.map((pi) => pi.method).join(" or ");
+      skipped.push({ tool, reason: `requires ${required}` });
+      continue;
+    }
+    resolved.push({ tool, method: match.method, package: match.package });
   }
-];
-function getToolsByPreset(presetId) {
-  return TOOLS.filter((t) => t.preset === presetId);
+  return { resolved, skipped };
 }
-function getToolsByIds(ids) {
-  return TOOLS.filter((t) => ids.includes(t.id));
+function getVerifyCommand(tool, platform) {
+  const v = tool.verify;
+  if (typeof v === "string") return v;
+  return v[platform] ?? v.darwin ?? Object.values(v)[0] ?? "";
 }
 
-// src/brew.ts
+// src/installers/index.ts
+import chalk6 from "chalk";
+
+// src/installers/brew.ts
 import { writeFile } from "fs/promises";
-import { execa } from "execa";
+import { execa as execa2 } from "execa";
 import chalk from "chalk";
 
 // src/paths.ts
@@ -394,34 +81,33 @@ import { homedir } from "os";
 import { join } from "path";
 import { mkdir } from "fs/promises";
 var BASE_DIR = join(homedir(), ".agent-loadout");
-var SKILLS_DIR = join(homedir(), ".claude", "skills");
+var GENERIC_SKILLS = join(BASE_DIR, "skills");
+var SKILL_TARGETS = {
+  claude: join(homedir(), ".claude", "skills")
+};
 var paths = {
   base: BASE_DIR,
   receipt: join(BASE_DIR, "receipt.json"),
-  brewfile: join(BASE_DIR, "Brewfile"),
-  skills: SKILLS_DIR
+  /** null on non-darwin platforms */
+  brewfile: process.platform === "darwin" ? join(BASE_DIR, "Brewfile") : null,
+  localBin: join(homedir(), ".local", "bin"),
+  skillTargets: SKILL_TARGETS,
+  genericSkills: GENERIC_SKILLS
 };
 async function ensureDir() {
   await mkdir(paths.base, { recursive: true });
 }
-async function ensureSkillsDir() {
-  await mkdir(paths.skills, { recursive: true });
-}
-
-// src/brew.ts
-async function checkBrewInstalled() {
-  try {
-    await execa("brew", ["--version"]);
-    return true;
-  } catch {
-    return false;
+async function ensureSkillDirs() {
+  for (const dir of Object.values(paths.skillTargets)) {
+    await mkdir(dir, { recursive: true });
   }
+  await mkdir(paths.genericSkills, { recursive: true });
 }
-function generateBrewfile(tools) {
-  const brewTools = tools.filter((t) => t.installMethod === "brew");
-  if (brewTools.length === 0) return "";
-  const lines = brewTools.map((t) => `brew "${t.package}"`);
-  return lines.join("\n") + "\n";
+
+// src/installers/brew.ts
+function generateBrewfile(packages) {
+  if (packages.length === 0) return "";
+  return packages.map((r) => `brew "${r.package}"`).join("\n") + "\n";
 }
 async function writeBrewfile(content) {
   await ensureDir();
@@ -429,84 +115,192 @@ async function writeBrewfile(content) {
 }
 async function runBrewBundle() {
   try {
-    await execa("brew", ["bundle", "--file", paths.brewfile], {
+    await execa2("brew", ["bundle", "--file", paths.brewfile], {
       stdio: "inherit"
     });
   } catch {
     console.log(
       chalk.yellow(
-        "\n  Some brew packages may have failed to install. Run 'brew bundle --file ~/.agent-loadout/Brewfile' to retry."
+        "\n  Some brew packages may have failed. Run 'brew bundle --file ~/.agent-loadout/Brewfile' to retry."
       )
     );
   }
 }
+async function runBrewInstall(packages) {
+  if (packages.length === 0) return;
+  const brewfile = generateBrewfile(packages);
+  await writeBrewfile(brewfile);
+  await runBrewBundle();
+}
 
-// src/npm.ts
-import { execa as execa2 } from "execa";
+// src/installers/npm.ts
+import { execa as execa3 } from "execa";
 import chalk2 from "chalk";
-async function checkNpmInstalled() {
+async function runNpmInstall(packages) {
+  if (packages.length === 0) return;
+  const pkgNames = packages.map((r) => r.package);
   try {
-    await execa2("npm", ["--version"]);
-    return true;
+    await execa3("npm", ["install", "-g", ...pkgNames], { stdio: "inherit" });
   } catch {
-    return false;
+    console.log(
+      chalk2.yellow(
+        `
+  npm install failed. Try manually: npm install -g ${pkgNames.join(" ")}`
+      )
+    );
   }
 }
-function getNpmTools(tools) {
-  return tools.filter((t) => t.installMethod === "npm");
-}
-function getNpmInstallCommand(tools) {
-  const npmTools = getNpmTools(tools);
-  if (npmTools.length === 0) return [];
-  return npmTools.map((t) => t.package);
+
+// src/installers/apt.ts
+import { execa as execa4 } from "execa";
+import chalk3 from "chalk";
+async function runAptInstall(packages) {
+  if (packages.length === 0) return;
+  const pkgNames = packages.map((r) => r.package);
+  try {
+    console.log(chalk3.dim("  Running apt-get update..."));
+    await execa4("sudo", ["apt-get", "update", "-qq"], { stdio: "inherit" });
+    await execa4("sudo", ["apt-get", "install", "-y", "-qq", ...pkgNames], {
+      stdio: "inherit"
+    });
+  } catch {
+    console.log(
+      chalk3.yellow(
+        `
+  apt install failed. Try manually: sudo apt-get install -y ${pkgNames.join(" ")}`
+      )
+    );
+  }
 }
-async function runNpmInstall(packages) {
-  if (packages.length === 0) return true;
+
+// src/installers/scoop.ts
+import { execa as execa5 } from "execa";
+import chalk4 from "chalk";
+var EXTRAS_PACKAGES = /* @__PURE__ */ new Set([
+  "lazygit",
+  "delta",
+  "bottom",
+  "glow",
+  "gum",
+  "mkcert"
+]);
+async function runScoopInstall(packages) {
+  if (packages.length === 0) return;
+  const needsExtras = packages.some((r) => EXTRAS_PACKAGES.has(r.package));
+  if (needsExtras) {
+    try {
+      await execa5("scoop", ["bucket", "add", "extras"], { stdio: "inherit" });
+    } catch {
+    }
+  }
+  const pkgNames = packages.map((r) => r.package);
   try {
-    await execa2("npm", ["install", "-g", ...packages], { stdio: "inherit" });
-    return true;
+    await execa5("scoop", ["install", ...pkgNames], { stdio: "inherit" });
   } catch {
     console.log(
-      chalk2.yellow(
+      chalk4.yellow(
         `
-  npm install failed. Try manually: npm install -g ${packages.join(" ")}`
+  scoop install failed. Try manually: scoop install ${pkgNames.join(" ")}`
       )
     );
-    return false;
+  }
+}
+
+// src/installers/cargo.ts
+import { execa as execa6 } from "execa";
+import chalk5 from "chalk";
+async function runCargoInstall(packages) {
+  if (packages.length === 0) return;
+  console.log(chalk5.dim("  Note: cargo installs compile from source \u2014 this may take a while."));
+  for (const { package: pkg } of packages) {
+    try {
+      await execa6("cargo", ["install", pkg], { stdio: "inherit" });
+    } catch {
+      console.log(
+        chalk5.yellow(`
+  cargo install ${pkg} failed. Try manually: cargo install ${pkg}`)
+      );
+    }
+  }
+}
+
+// src/installers/index.ts
+var INSTALLERS = {
+  brew: runBrewInstall,
+  npm: runNpmInstall,
+  apt: runAptInstall,
+  scoop: runScoopInstall,
+  cargo: runCargoInstall
+};
+function getInstallerFn(method) {
+  return INSTALLERS[method];
+}
+async function runInstallPlan(plan) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of plan.resolved) {
+    const group = groups.get(item.method) ?? [];
+    group.push(item);
+    groups.set(item.method, group);
+  }
+  for (const [method, packages] of groups) {
+    console.log(chalk6.bold(`
+Installing via ${method}...`));
+    await getInstallerFn(method)(packages);
   }
 }
 
 // src/verify.ts
-import { execa as execa3 } from "execa";
-import chalk3 from "chalk";
-async function checkTool(tool) {
+import { execa as execa7 } from "execa";
+import chalk7 from "chalk";
+function getExtraPaths(platform) {
+  if (platform === "darwin") {
+    return "/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin";
+  }
+  if (platform === "linux") {
+    const home = process.env.HOME ?? "";
+    return `${home}/.local/bin:${home}/.cargo/bin`;
+  }
+  if (platform === "win32") {
+    const userProfile = process.env.USERPROFILE ?? "";
+    return `${userProfile}\\scoop\\shims:${userProfile}\\.cargo\\bin`;
+  }
+  return "";
+}
+async function checkTool(tool, platform) {
   try {
-    const [cmd, ...args] = tool.verify.split(" ");
-    const result = await execa3(cmd, args, { timeout: 5e3 });
+    const cmd = getVerifyCommand(tool, platform);
+    const [bin, ...args] = cmd.split(" ");
+    const extraPaths = getExtraPaths(platform);
+    const pathSep = platform === "win32" ? ";" : ":";
+    const env = {
+      ...process.env,
+      PATH: `${extraPaths}${pathSep}${process.env.PATH}`
+    };
+    const result = await execa7(bin, args, { timeout: 5e3, env });
     const version = result.stdout.split("\n")[0].trim();
     return { id: tool.id, name: tool.name, installed: true, version };
   } catch {
     return { id: tool.id, name: tool.name, installed: false, version: "" };
   }
 }
-async function verifyTools(tools) {
-  return Promise.all(tools.map(checkTool));
+async function verifyTools(tools, platform = process.platform) {
+  return Promise.all(tools.map((t) => checkTool(t, platform)));
 }
 function printVerifyResults(results) {
   const maxName = Math.max(...results.map((r) => r.name.length));
   for (const r of results) {
     const name = r.name.padEnd(maxName);
     if (r.installed) {
-      console.log(`  ${chalk3.green("\u2713")} ${name}  ${chalk3.dim(r.version)}`);
+      console.log(`  ${chalk7.green("\u2713")} ${name}  ${chalk7.dim(r.version)}`);
     } else {
-      console.log(`  ${chalk3.red("\u2717")} ${name}  ${chalk3.red("not found")}`);
+      console.log(`  ${chalk7.red("\u2717")} ${name}  ${chalk7.red("not found")}`);
     }
   }
   const installed = results.filter((r) => r.installed).length;
   const total = results.length;
   console.log();
   console.log(
-    installed === total ? chalk3.green(`  All ${total} tools installed.`) : chalk3.yellow(`  ${installed}/${total} tools installed.`)
+    installed === total ? chalk7.green(`  All ${total} tools installed.`) : chalk7.yellow(`  ${installed}/${total} tools installed.`)
   );
 }
 function verifyResultsToJson(results) {
@@ -519,7 +313,7 @@ function verifyResultsToJson(results) {
 
 // src/receipt.ts
 import { readFile, writeFile as writeFile2 } from "fs/promises";
-import chalk4 from "chalk";
+import chalk8 from "chalk";
 async function readReceipt() {
   try {
     const raw = await readFile(paths.receipt, "utf-8");
@@ -527,7 +321,7 @@ async function readReceipt() {
   } catch (err) {
     if (err instanceof SyntaxError) {
       console.log(
-        chalk4.yellow(
+        chalk8.yellow(
           "  Warning: ~/.agent-loadout/receipt.json is corrupted. Ignoring."
         )
       );
@@ -542,7 +336,7 @@ async function writeReceipt(receipt) {
 
 // src/ui.ts
 import { checkbox, confirm } from "@inquirer/prompts";
-import chalk5 from "chalk";
+import chalk9 from "chalk";
 async function selectPresets() {
   return checkbox({
     message: "Which presets do you want to install?",
@@ -562,9 +356,9 @@ async function selectTools(presetIds) {
   const selectedIds = await checkbox({
     message: "Toggle individual tools (all selected by default)",
     choices: available.map((t) => {
-      const badge = installedIds.has(t.id) ? chalk5.green(" (installed)") : "";
+      const badge = installedIds.has(t.id) ? chalk9.green(" (installed)") : "";
       return {
-        name: `${t.name}${badge} \u2014 ${chalk5.dim(t.description)}`,
+        name: `${t.name}${badge} \u2014 ${chalk9.dim(t.description)}`,
         value: t.id,
         checked: true
       };
@@ -572,22 +366,51 @@ async function selectTools(presetIds) {
   });
   return TOOLS.filter((t) => selectedIds.includes(t.id));
 }
-function printPreview(tools) {
-  const brewfile = generateBrewfile(tools);
-  const npmPackages = getNpmInstallCommand(tools);
+function printPreview(tools, plan, platformInfo) {
+  const platformLabel = chalk9.cyan(platformInfo.platform);
+  const archLabel = chalk9.dim(platformInfo.arch);
+  console.log(`
+Platform: ${platformLabel} ${archLabel}`);
+  if (plan.skipped.length > 0) {
+    console.log(chalk9.yellow(`
+Skipped (${plan.skipped.length} tools unavailable on this platform):`));
+    for (const { tool, reason } of plan.skipped) {
+      console.log(chalk9.dim(`  \u2022 ${tool.name} \u2014 ${reason}`));
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const { method, package: pkg } of plan.resolved) {
+    const list = groups.get(method) ?? [];
+    list.push(pkg);
+    groups.set(method, list);
+  }
+  if (groups.size === 0) {
+    console.log(chalk9.dim("\nNothing to install."));
+    return;
+  }
   console.log();
-  if (brewfile) {
-    console.log(chalk5.bold("Brewfile:"));
-    console.log(chalk5.dim(brewfile));
-    console.log(
-      chalk5.dim("  \u2192 brew bundle --file ~/.agent-loadout/Brewfile")
-    );
+  for (const [method, packages] of groups) {
+    const label = chalk9.bold(`${method}:`);
+    console.log(label);
+    const preview = getInstallPreview(method, packages);
+    console.log(chalk9.dim(`  ${preview}`));
     console.log();
   }
-  if (npmPackages.length > 0) {
-    console.log(chalk5.bold("npm globals:"));
-    console.log(chalk5.dim(`  \u2192 npm install -g ${npmPackages.join(" ")}`));
-    console.log();
+}
+function getInstallPreview(method, packages) {
+  switch (method) {
+    case "brew":
+      return `brew bundle --file ~/.agent-loadout/Brewfile`;
+    case "npm":
+      return `npm install -g ${packages.join(" ")}`;
+    case "apt":
+      return `sudo apt-get install -y ${packages.join(" ")}`;
+    case "scoop":
+      return `scoop install ${packages.join(" ")}`;
+    case "cargo":
+      return `cargo install ${packages.join(" ")}`;
+    default:
+      return packages.join(" ");
   }
 }
 async function confirmInstall() {
@@ -595,7 +418,7 @@ async function confirmInstall() {
 }
 
 // src/skills.ts
-import { writeFile as writeFile3 } from "fs/promises";
+import { access, writeFile as writeFile3 } from "fs/promises";
 import { join as join2 } from "path";
 
 // src/skills/rg.ts
@@ -614,13 +437,19 @@ Search file contents across a codebase. Faster than grep, respects .gitignore by
 - Files only (no content): \`rg -l "pattern"\`
 - Count matches: \`rg -c "pattern"\`
 - Case insensitive: \`rg -i "pattern"\`
+- JSON output (agent-parseable): \`rg "pattern" --json\`
+- Exit non-zero if no matches: \`rg --exit-status "pattern"\`
 
 ## Output format
 \`file:line:column:matched_text\` \u2014 one match per line, stable and parseable.
 
+## Why it matters for agents
+\`--json\` output is directly parseable; rg is the backbone of fast codebase search. \`--exit-status\` makes it composable in CI pipelines and shell conditionals.
+
 ## Gotchas
 - Skips hidden files and .gitignore'd paths by default. Use \`--hidden\` or \`--no-ignore\` to include them.
 - For literal dots, brackets etc. in patterns, use \`-F\` (fixed string) to avoid regex escaping issues.
+- \`--json\` emits structured events (match, begin, end, summary) \u2014 parse with \`jq\` for agent workflows.
 `.trim();
 
 // src/skills/fd.ts
@@ -641,9 +470,13 @@ Find files by name pattern. Faster than \`find\`, respects .gitignore, sane defa
 ## Output format
 One path per line, relative to search root.
 
+## Why it matters for agents
+\`-x\` flag enables batch file operations without shell loops \u2014 agents can use \`fd -e ts -x sd 'old' 'new' {}\` to safely refactor across many files.
+
 ## Gotchas
 - Regex by default. Use \`-g\` for glob patterns.
 - Ignores .gitignore'd files by default. Use \`--no-ignore\` to include.
+- On Debian/Ubuntu the binary is \`fdfind\`, not \`fd\`. Use \`alias fd=fdfind\` or install via cargo.
 `.trim();
 
 // src/skills/jq.ts
@@ -701,6 +534,14 @@ View file contents with syntax highlighting, line numbers, and git diff indicato
 - Show line range: \`bat -r 10:20 file.ts\`
 - Force language: \`bat -l json file.txt\`
 - Use as pager for other commands: \`command | bat -l json\`
+- Disable pager for scripts: \`bat --paging=never file.ts\`
+
+## Why it matters for agents
+\`-l\` flag lets agents force syntax for stdin \u2014 useful for highlighting API responses or generated content piped through bat.
+
+## Gotchas
+- On Debian/Ubuntu the binary is \`batcat\`, not \`bat\`. Use \`alias bat=batcat\` or install via cargo.
+- Use \`--paging=never\` in scripts to suppress the interactive pager.
 `.trim();
 
 // src/skills/tree.ts
@@ -716,6 +557,14 @@ Visualise directory structure as a tree. Useful for understanding project layout
 - Show only directories: \`tree -d\`
 - Ignore patterns: \`tree -I 'node_modules|dist'\`
 - With file sizes: \`tree -sh\`
+- JSON output: \`tree -J path/\`
+
+## Why it matters for agents
+\`-J\` gives a JSON file tree \u2014 lets agents understand project structure in one call without recursive \`ls\` loops.
+
+## Gotchas
+- Use \`--charset ascii\` for plain output in non-unicode terminals or CI logs.
+- \`-J\` JSON output includes type, name, and children \u2014 structured project map in one call.
 `.trim();
 
 // src/skills/gh.ts
@@ -735,13 +584,20 @@ Create PRs, manage issues, check CI status, manage releases \u2014 all without l
 - View repo: \`gh repo view\`
 - API calls: \`gh api repos/owner/repo/pulls/123/comments\`
 - Clone: \`gh repo clone owner/repo\`
+- List workflow runs: \`gh run list --json name,status,conclusion\`
+- Watch a run live: \`gh run watch\`
+- Cross-repo PR list: \`gh pr list -R owner/repo --json number,title,state\`
 
 ## Output format
 Supports \`--json\` on most commands for structured output. E.g. \`gh pr list --json number,title,state\`.
 
+## Why it matters for agents
+\`--json\` on every command + \`gh api\` unlocks full GitHub automation without parsing HTML. Agents can open PRs, check CI, and comment on issues programmatically.
+
 ## Gotchas
 - Requires authentication: \`gh auth login\`
 - \`gh api\` is very powerful for anything not covered by built-in commands.
+- In CI, set \`GH_TOKEN\` env var instead of running \`gh auth login\`.
 `.trim();
 
 // src/skills/fzf.ts
@@ -775,10 +631,14 @@ Lint shell scripts (bash, sh, dash) for common mistakes: quoting issues, unset v
 - GCC-style output: \`shellcheck --format=gcc script.sh\`
 - Exclude specific rules: \`shellcheck --exclude=SC2034 script.sh\`
 - Check from stdin: \`echo '#!/bin/bash' | shellcheck -\`
+- Errors only (no warnings): \`shellcheck --severity error script.sh\`
 
 ## Output format
 Default output is human-readable with line numbers and fix suggestions. Use \`--format=json\` for structured output.
 
+## Why it matters for agents
+Agents frequently generate shell scripts \u2014 shellcheck catches quoting bugs, unset variables, and portability issues before they cause failures. Use \`--format=json\` to parse results programmatically.
+
 ## Gotchas
 - Scripts need a shebang (\`#!/bin/bash\`) or use \`--shell=\` flag.
 - SC codes (e.g. SC2086) link to detailed wiki explanations.
@@ -845,7 +705,10 @@ Generate a regular expression from a set of example strings. Useful when you kno
 - Verbose regex: \`grex --verbose "foo-123" "bar-456"\`
 
 ## Gotchas
-- Output is a regex string, not a replacement. Useful as input for rg, sd, or code.
+- Output is a raw regex string \u2014 pipe directly into \`rg\`, \`sd\`, or save to a variable.
+
+## Why it matters for agents
+Lets agents generate correct regex from test cases rather than hallucinating patterns \u2014 eliminates a whole class of regex bugs.
 `.trim();
 
 // src/skills/knip.ts
@@ -860,12 +723,16 @@ Detect unused files, exports, dependencies, and types in TypeScript/JavaScript p
 - Unused files only: \`knip --include files\`
 - Unused exports only: \`knip --include exports\`
 - Unused deps only: \`knip --include dependencies\`
-- JSON output: \`knip --reporter json\`
+- Machine-readable with scopes: \`knip --reporter json --include files,exports,dependencies\`
+
+## Why it matters for agents
+Identifies dead code before large refactors \u2014 agents can safely delete unused files and exports flagged by knip without breaking the build.
 
 ## Gotchas
 - Must be run at project root (where package.json lives).
 - May need a knip.json config for monorepos or non-standard project structures.
 - Some frameworks have plugins (Next.js, Remix, etc.) \u2014 check docs if results seem wrong.
+- Exits 1 if issues found \u2014 CI-friendly; pipe to \`jq\` to filter specific categories.
 `.trim();
 
 // src/skills/sd.ts
@@ -884,6 +751,9 @@ Find and replace in files. Like sed but with intuitive syntax \u2014 no escaping
 ## Gotchas
 - Uses regex by default. Use \`-F\` for fixed/literal strings.
 - Modifies files in place when given a filename. Use \`-p\` to preview first.
+
+## Why it matters for agents
+Safer than sed for multi-line replacements \u2014 predictable escaping without shell quoting nightmares. Combine with \`fd -x\` for safe bulk refactors across many files.
 `.trim();
 
 // src/skills/hyperfine.ts
@@ -899,6 +769,11 @@ Benchmark commands to compare performance. Runs commands multiple times and repo
 - With warmup: \`hyperfine --warmup 3 'command'\`
 - Export results: \`hyperfine --export-json results.json 'command'\`
 - Min runs: \`hyperfine --min-runs 20 'command'\`
+- Non-interactive + export: \`hyperfine --style basic --export-json results.json 'cmd1' 'cmd2'\`
+- With prepare step: \`hyperfine --prepare 'make clean' 'make build'\`
+
+## Why it matters for agents
+\`--export-json\` lets agents compare builds and commands quantitatively \u2014 structured results include mean, stddev, min, max per command.
 
 ## Gotchas
 - Wrap commands in quotes.
@@ -917,10 +792,16 @@ Get a quick overview of a codebase: languages, lines of code, comments, blanks.
 - Specific path: \`tokei src/\`
 - JSON output: \`tokei --output json\`
 - Sort by lines: \`tokei --sort lines\`
+- Exclude dirs: \`tokei --output json --exclude node_modules,dist src/\`
+- Filter languages: \`tokei --languages TypeScript,Rust\`
+- Per-file breakdown: \`tokei --files src/\`
 
 ## Output format
 Table with language, files, lines, code, comments, blanks.
 Use \`--output json\` for structured output.
+
+## Why it matters for agents
+Gives agents a language/complexity map before large refactors \u2014 quickly understand the scale and dominant languages of an unfamiliar codebase.
 `.trim();
 
 // src/skills/ffmpeg.ts
@@ -972,6 +853,9 @@ Read, write, and strip metadata (EXIF, IPTC, XMP) from images and media files.
 ## Gotchas
 - Field names are case-insensitive.
 - Use \`-json\` for structured output.
+
+## Why it matters for agents
+\`-json\` output enables structured metadata extraction from any media file \u2014 agents can batch-read EXIF data, filter by GPS coordinates, or rename files by capture date programmatically.
 `.trim();
 
 // src/skills/imagemagick.ts
@@ -994,6 +878,9 @@ Resize, crop, convert, and manipulate images from the command line.
 
 ## Gotchas
 - The binary is \`magick\` (ImageMagick 7). Older versions used \`convert\`.
+
+## Why it matters for agents
+Batch image processing without opening apps \u2014 useful for automated asset pipelines. Agents can resize, convert formats, and generate thumbnails in a single \`mogrify\` invocation.
 `.trim();
 
 // src/skills/svgo.ts
@@ -1008,10 +895,15 @@ Optimise SVG files by removing unnecessary metadata, comments, and reducing prec
 - Optimise in place: \`svgo input.svg\`
 - Folder: \`svgo -f ./icons/ -o ./icons-optimised/\`
 - Show savings: \`svgo input.svg --pretty\`
+- Multipass (better compression): \`svgo --multipass input.svg -o output.svg\`
+- Check savings without writing: \`svgo --dry-run input.svg\`
 
 ## Gotchas
 - Default plugins are usually fine. Override with \`--config svgo.config.js\` if needed.
 - In-place by default when no \`-o\` specified. Pipe or use \`-o\` for safety.
+
+## Why it matters for agents
+Automated SVG optimisation in build pipelines \u2014 measurable, reproducible size savings. Agents can run \`svgo -f ./icons/\` after any icon library update.
 `.trim();
 
 // src/skills/eza.ts
@@ -1070,6 +962,9 @@ Add to ~/.gitconfig:
 
 ## Gotchas
 - The brew package is called \`git-delta\`, but the binary is \`delta\`.
+
+## Why it matters for agents
+Makes \`git diff\` and \`git log -p\` output readable \u2014 useful when agents are reviewing code changes or summarising commits for users.
 `.trim();
 
 // src/skills/glow.ts
@@ -1083,6 +978,11 @@ Render markdown files beautifully in the terminal. Great for reading READMEs, do
 - Render file: \`glow README.md\`
 - Render with pager: \`glow -p README.md\`
 - Render from stdin: \`cat CHANGELOG.md | glow\`
+- Disable pager: \`glow --no-pager README.md\`
+- Fixed width: \`glow --width 100 README.md\`
+
+## Why it matters for agents
+Renders markdown cleanly in terminal output \u2014 useful for displaying skill files, changelogs, or generated docs to users without raw markdown symbols.
 `.trim();
 
 // src/skills/mise.ts
@@ -1105,6 +1005,9 @@ Uses \`.mise.toml\` or \`.tool-versions\` in project root. This ensures determin
 
 ## Gotchas
 - Run \`mise activate zsh\` (or bash/fish) in your shell profile for automatic version switching.
+
+## Why it matters for agents
+Manages runtime versions declaratively via \`.mise.toml\` \u2014 agents can use \`mise exec -- node script.js\` to pin the exact Node/Python/Ruby version without modifying global state.
 `.trim();
 
 // src/skills/watchexec.ts
@@ -1123,6 +1026,9 @@ Watch files for changes and re-run a command. Language-agnostic alternative to n
 ## Gotchas
 - Use \`-e\` to filter by extension, \`-w\` to filter by directory.
 - Use \`--restart\` for long-running processes (servers), otherwise it waits for completion.
+
+## Why it matters for agents
+Enables live-reload dev loops \u2014 agents can set up reactive pipelines (\`watchexec -e ts "pnpm typecheck"\`) and report on each change without polling.
 `.trim();
 
 // src/skills/mkcert.ts
@@ -1136,10 +1042,15 @@ Generate locally-trusted HTTPS certificates for development. No more "insecure"
 - First-time setup: \`mkcert -install\` (installs local CA)
 - Generate cert: \`mkcert localhost 127.0.0.1 ::1\`
 - Generate for custom domain: \`mkcert "myapp.local" "*.myapp.local"\`
+- Custom output paths: \`mkcert -cert-file cert.pem -key-file key.pem localhost\`
+- Wildcard + Docker/VM: \`mkcert -install && mkcert "*.local" localhost 127.0.0.1\`
 
 ## Gotchas
 - \`mkcert -install\` only needs to run once per machine.
 - Output is two files: cert.pem and key.pem. Point your dev server at them.
+
+## Why it matters for agents
+Enables local HTTPS in one command \u2014 no CA setup complexity. Agents scaffolding full-stack dev environments can run \`mkcert -install && mkcert localhost\` to get HTTPS working immediately.
 `.trim();
 
 // src/skills/trivy.ts
@@ -1155,10 +1066,17 @@ Scan filesystems, container images, and code repos for known vulnerabilities.
 - Scan a container image: \`trivy image myapp:latest\`
 - Only critical/high: \`trivy fs --severity CRITICAL,HIGH .\`
 - Scan for secrets: \`trivy fs --scanners secret .\`
+- CI gate (fail on findings): \`trivy fs --severity CRITICAL,HIGH --exit-code 1 --no-progress .\`
+- Offline (skip DB update): \`trivy fs --skip-update --format json .\`
+
+## Why it matters for agents
+Gives agents a security gate before deployments. \`--format json --exit-code 1\` creates a composable CI step \u2014 agents can parse findings and summarise critical vulnerabilities.
 
 ## Gotchas
 - First run downloads a vulnerability database (can be slow).
 - Use \`--format json\` for structured output.
+- Use \`--exit-code 1\` to fail CI pipelines on findings; omit for reporting-only mode.
+- \`--no-progress\` keeps CI logs clean.
 `.trim();
 
 // src/skills/act.ts
@@ -1174,11 +1092,16 @@ Test GitHub Actions workflows without pushing. Runs workflows in Docker containe
 - Run specific event: \`act push\`
 - Run specific job: \`act -j build\`
 - Dry run: \`act -n\`
+- Pass secrets: \`act push --secret MY_TOKEN="value"\`
+- List available jobs: \`act --list\`
 
 ## Gotchas
 - Requires Docker to be running.
 - Not all GitHub Actions features are supported locally (secrets, some contexts).
 - Use \`-n\` (dry run) first to see what would happen.
+
+## Why it matters for agents
+Test CI workflows locally before pushing \u2014 saves agent roundtrips to GitHub. Agents can run \`act -n\` to validate workflow YAML without Docker overhead.
 `.trim();
 
 // src/skills/xh.ts
@@ -1196,11 +1119,17 @@ Send HTTP requests from the terminal. Cleaner syntax than curl, JSON-first, colo
 - Follow redirects: \`xh --follow get example.com\`
 - Save response to file: \`xh get example.com/file.zip > file.zip\`
 - Show request/response headers: \`xh --print=hHbB get httpbin.org/get\`
+- Fail on 4xx/5xx: \`xh --check-status get api.example.com\`
+- Response body only: \`xh -b get api.example.com\`
+- Headers only: \`xh -h get api.example.com\`
+- Download file: \`xh --download get example.com/file.zip\`
+
+## Why it matters for agents
+Cleaner than curl for API testing \u2014 \`key=value\` JSON syntax removes quoting complexity. \`--check-status\` makes error handling trivial: non-zero exit on any 4xx/5xx.
 
 ## Gotchas
 - \`key=value\` sends as JSON string; \`key:=value\` sends raw JSON (numbers, bools, arrays).
 - Defaults to HTTPS if scheme is omitted.
-- Use \`--check-status\` to exit non-zero on 4xx/5xx responses.
 `.trim();
 
 // src/skills/tldr.ts
@@ -1242,6 +1171,9 @@ Fast, zero-config linter and formatter for JavaScript/TypeScript projects. Repla
 - Requires a \`biome.json\` config or \`--config-path\` flag; \`biome init\` generates a sensible default.
 - Not 100% compatible with all ESLint rules \u2014 check the migration guide when switching existing projects.
 - \`biome check\` is read-only by default; pass \`--write\` to apply fixes.
+
+## Why it matters for agents
+Zero-config lint+format in one command \u2014 drop-in for eslint+prettier in CI. \`biome ci .\` exits 1 on issues and is non-destructive.
 `.trim();
 
 // src/skills/difftastic.ts
@@ -1262,6 +1194,9 @@ Compare files by syntax tree, not line-by-line. Understands code structure so re
 - Supports most languages automatically via file extension detection.
 - Output is always side-by-side; pipe width matters \u2014 use a wide terminal.
 - Falls back to line-diff for unsupported file types.
+
+## Why it matters for agents
+Understands code structure \u2014 avoids false-positive diffs from formatting changes. Agents using \`GIT_EXTERNAL_DIFF=difft git diff\` get semantic change summaries, not noise.
 `.trim();
 
 // src/skills/lazygit.ts
@@ -1289,6 +1224,9 @@ Interactive terminal UI for git \u2014 stage hunks, commit, branch, rebase, and
 - Requires git to be installed (it's a UI wrapper, not a replacement).
 - Config lives at \`~/.config/lazygit/config.yml\`.
 - Mouse support is on by default \u2014 click panels to navigate.
+
+## Why it matters for agents
+Note: interactive TUI only \u2014 not suitable for agent automation. For scripted git operations use \`git\` CLI directly; for GitHub automation use \`gh\`.
 `.trim();
 
 // src/skills/dust.ts
@@ -1310,6 +1248,9 @@ Visualise what's eating disk space in a directory tree. Faster and more readable
 - Output is proportional bars + sizes; percentages are relative to the scanned root, not total disk.
 - Use \`-d 1\` for a quick top-level summary before drilling down.
 - Symlinks are not followed by default \u2014 add \`-L\` to follow them.
+
+## Why it matters for agents
+Identifies large directories before disk operations \u2014 agents can quickly find what to clean up with \`dust -d 1\` before running builds or copying large directories.
 `.trim();
 
 // src/skills/btm.ts
@@ -1336,6 +1277,9 @@ Real-time TUI system monitor \u2014 CPU, memory, network, disk, and process list
 ## Gotchas
 - Config lives at \`~/.config/bottom/bottom.toml\` \u2014 customise colours and layout there.
 - \`--basic\` mode is useful in constrained terminals or for quick checks.
+
+## Why it matters for agents
+Note: interactive TUI \u2014 not suitable for scripting. For programmatic process info use \`procs --json\`; for one-shot CPU/memory snapshots use \`ps\` or \`top -l 1\`.
 `.trim();
 
 // src/skills/gitleaks.ts
@@ -1359,10 +1303,336 @@ gitleaks protect --staged   # pre-commit hook
 gitleaks detect             # CI full scan
 \`\`\`
 
+## Why it matters for agents
+Agents editing configuration files or adding credentials must scan before committing. Exit code 1 on findings makes it trivially composable as a pre-commit gate.
+
 ## Gotchas
 - Findings include file, line, rule, and matched secret fragment \u2014 review before dismissing.
 - Use a \`.gitleaksignore\` file to whitelist known false positives.
 - Does not redact secrets from history \u2014 use \`git filter-repo\` to remove them.
+- Returns exit code 1 if leaks found, 0 if clean \u2014 use directly in CI pipelines.
+- Custom rules: \`gitleaks detect --config custom-rules.toml --report-format json\`
+`.trim();
+
+// src/skills/pandoc.ts
+var pandoc_default = `
+# pandoc \u2014 Universal document converter
+
+## When to use
+Convert between document formats: markdown, HTML, PDF, docx, LaTeX, RST, EPUB, and dozens more. The single tool for any "convert X to Y" task.
+
+## Trusted commands
+- Markdown to HTML: \`pandoc input.md -o output.html\`
+- Markdown to PDF: \`pandoc input.md -o output.pdf\` (requires LaTeX or --pdf-engine=weasyprint)
+- Markdown to docx: \`pandoc input.md -o output.docx\`
+- HTML to markdown: \`pandoc input.html -o output.md\`
+- With standalone template: \`pandoc input.md -s -o output.html\`
+- Custom CSS: \`pandoc input.md -s --css=style.css -o output.html\`
+- List supported formats: \`pandoc --list-input-formats\` / \`pandoc --list-output-formats\`
+
+## Why it matters for agents
+Agents frequently need to transform content between formats for delivery. Pandoc handles the conversion so the agent focuses on content.
+
+## Gotchas
+- PDF output requires a PDF engine (wkhtmltopdf, weasyprint, or LaTeX). Use \`--pdf-engine=weasyprint\` if LaTeX isn't installed.
+- Output format is inferred from the file extension.
+- Use \`-s\` (standalone) for complete documents with headers, not fragments.
+`.trim();
+
+// src/skills/duckdb.ts
+var duckdb_default = `
+# duckdb \u2014 SQL analytics on files
+
+## When to use
+Query CSV, JSON, Parquet, or Excel files with SQL. No database setup, no import step \u2014 just point and query.
+
+## Trusted commands
+- Query a CSV: \`duckdb -c "SELECT * FROM 'data.csv' LIMIT 10"\`
+- Aggregate: \`duckdb -c "SELECT col, COUNT(*) FROM 'data.csv' GROUP BY col"\`
+- Query JSON: \`duckdb -c "SELECT * FROM read_json_auto('data.json')"\`
+- Query Parquet: \`duckdb -c "SELECT * FROM 'data.parquet'"\`
+- Join files: \`duckdb -c "SELECT a.*, b.name FROM 'users.csv' a JOIN 'orders.csv' b ON a.id = b.user_id"\`
+- Export result: \`duckdb -c "COPY (SELECT * FROM 'data.csv') TO 'out.parquet' (FORMAT PARQUET)"\`
+- Interactive REPL: \`duckdb\`
+
+## Why it matters for agents
+When an agent encounters a data file, duckdb lets it explore and answer questions via SQL instead of writing custom Python/JS parsing code. Massive time saver for any data task.
+
+## Gotchas
+- Auto-detects CSV headers and types. Use \`read_csv('file.csv', header=false)\` to disable.
+- For one-off queries, use \`-c\`. For multiple, use the REPL or a .sql file.
+- Outputs to stdout in table format by default. Use \`-csv\` or \`-json\` for machine-readable output.
+`.trim();
+
+// src/skills/htmlq.ts
+var htmlq_default = `
+# htmlq \u2014 jq for HTML
+
+## When to use
+Extract content from HTML files or piped HTML using CSS selectors. Like jq but for HTML/web content.
+
+## Trusted commands
+- Extract by selector: \`cat page.html | htmlq '.article-title'\`
+- Get attribute: \`cat page.html | htmlq 'a' --attribute href\`
+- Text only (strip tags): \`cat page.html | htmlq '.content' --text\`
+- Pipe from curl: \`curl -s https://example.com | htmlq 'h1'\`
+- Multiple selectors: \`cat page.html | htmlq 'h1, h2, h3'\`
+- Pretty print: \`cat page.html | htmlq --pretty 'body'\`
+
+## Why it matters for agents
+When agents fetch web content or work with HTML files, htmlq extracts exactly what's needed without writing a parser.
+
+## Gotchas
+- Reads from stdin \u2014 always pipe input to it.
+- CSS selectors only (not XPath).
+- Use \`--text\` to get text content without HTML tags.
+`.trim();
+
+// src/skills/typos.ts
+var typos_default = `
+# typos \u2014 Source code spell checker
+
+## When to use
+Find and fix typos in source code, comments, docs, filenames, and variable names. Runs in milliseconds across entire codebases.
+
+## Trusted commands
+- Check current directory: \`typos\`
+- Check specific path: \`typos src/\`
+- Auto-fix typos: \`typos --write-changes\`
+- Diff mode (show what would change): \`typos --diff\`
+- Check specific file types: \`typos --type rust src/\`
+- Ignore a word: add to \`_typos.toml\`: \`[default.extend-words]\` \u2192 \`teh = "teh"\`
+
+## Why it matters for agents
+Agents generate a lot of code. Running typos as a final pass catches misspellings in variable names, comments, and docs that slip past linters.
+
+## Gotchas
+- Configure exceptions in \`_typos.toml\` or \`.typos.toml\` at project root.
+- Understands common programming conventions (camelCase, snake_case, etc.).
+- Very fast \u2014 designed to run on every commit.
+`.trim();
+
+// src/skills/gum.ts
+var gum_default = `
+# gum \u2014 Interactive UI components for shell scripts
+
+## When to use
+Add interactive prompts, spinners, confirmations, file pickers, and styled text to shell scripts without complex TUI code.
+
+## Trusted commands
+- Confirm (y/n): \`gum confirm "Deploy to production?"\`
+- Choose from list: \`gum choose "option1" "option2" "option3"\`
+- Text input: \`gum input --placeholder "Enter name"\`
+- Multi-line input: \`gum write --placeholder "Description"\`
+- Spinner while running: \`gum spin --title "Building..." -- make build\`
+- Filter list (fuzzy): \`echo "a\\nb\\nc" | gum filter\`
+- Styled text: \`gum style --foreground 212 --bold "Done!"\`
+- File picker: \`gum file .\`
+
+## Why it matters for agents
+When agents create shell scripts or automation, gum adds polished interactivity with single commands. No dependency on dialog, whiptail, or complex TUI libraries.
+
+## Gotchas
+- Each command returns the selected/entered value to stdout \u2014 capture with \`$(gum ...)\`.
+- Part of the Charm ecosystem (same as glow, lazygit).
+- \`gum confirm\` returns exit code 0 (yes) or 1 (no).
+`.trim();
+
+// src/skills/direnv.ts
+var direnv_default = `
+# direnv \u2014 Auto-load env vars per directory
+
+## When to use
+Automatically load and unload environment variables when entering/leaving a directory. Each project gets its own env without polluting your shell.
+
+## Trusted commands
+- Allow current .envrc: \`direnv allow\`
+- Block current .envrc: \`direnv deny\`
+- Edit .envrc: \`direnv edit .\`
+- Check status: \`direnv status\`
+- Reload: \`direnv reload\`
+
+## Common .envrc patterns
+- Set vars: \`export API_KEY=xxx\`
+- Add to PATH: \`PATH_add ./bin\`
+- Use a specific Node version: \`use node 20\` (with mise/nvm layout)
+- Load .env file: \`dotenv\`
+
+## Gotchas
+- Requires shell hook \u2014 add \`eval "$(direnv hook zsh)"\` to .zshrc (or bash equivalent).
+- New .envrc files must be explicitly allowed with \`direnv allow\` (security feature).
+- Changes to .envrc require re-allowing.
+`.trim();
+
+// src/skills/procs.ts
+var procs_default = `
+# procs \u2014 Modern ps replacement
+
+## When to use
+List and search running processes with structured, colourful output. Replacement for \`ps aux | grep\`.
+
+## Trusted commands
+- List all processes: \`procs\`
+- Search by name: \`procs node\`
+- Tree view: \`procs --tree\`
+- Watch mode: \`procs --watch\`
+- Sort by CPU: \`procs --sortd cpu\`
+- Sort by memory: \`procs --sortd mem\`
+
+## Why it matters for agents
+Agents diagnosing "port in use" or runaway process issues get structured output without pipe chains.
+
+## Gotchas
+- Output is human-readable by default. For scripting, pipe through \`--color=never\` or use standard \`ps\` + jq.
+- Search matches against command name and full command line.
+`.trim();
+
+// src/skills/uv.ts
+var uv_default = `
+# uv \u2014 Fast Python package and env manager
+
+## When to use
+Manage Python virtual environments and install packages. 10-100x faster than pip. Drop-in replacement for pip, pip-tools, and virtualenv.
+
+## Trusted commands
+- Create venv: \`uv venv\`
+- Install package: \`uv pip install requests\`
+- Install from requirements: \`uv pip install -r requirements.txt\`
+- Compile requirements (lock): \`uv pip compile requirements.in -o requirements.txt\`
+- Run a script with deps: \`uv run --with requests script.py\`
+- Init a new project: \`uv init my-project\`
+- Add dependency: \`uv add requests\`
+- Sync project: \`uv sync\`
+
+## Why it matters for agents
+When agents set up Python projects or install dependencies, uv makes it near-instant. No waiting for pip's dependency resolver.
+
+## Gotchas
+- Creates \`.venv/\` by default (same as standard venv).
+- \`uv pip\` commands are pip-compatible \u2014 same flags and syntax.
+- \`uv run\` can run scripts with inline dependencies without a project.
+`.trim();
+
+// src/skills/hexyl.ts
+var hexyl_default = `
+# hexyl \u2014 Hex viewer
+
+## When to use
+Inspect binary files, check file headers/magic bytes, debug encoding issues, or examine corrupted data.
+
+## Trusted commands
+- View file: \`hexyl file.bin\`
+- First N bytes: \`hexyl -n 256 file.bin\`
+- Skip to offset: \`hexyl -s 0x100 file.bin\`
+- Pipe from stdin: \`echo "hello" | hexyl\`
+- Specific range: \`hexyl -r 0x10..0x20 file.bin\`
+
+## Why it matters for agents
+Agents encountering unknown binary files can quickly identify format (via magic bytes), spot encoding issues, or verify file integrity.
+
+## Gotchas
+- Output is always to stdout \u2014 not interactive/scrollable. Pipe to \`less -R\` for large files.
+- Colour codes bytes by type: NULL, ASCII printable, ASCII whitespace, non-ASCII.
+`.trim();
+
+// src/skills/taplo.ts
+var taplo_default = `
+# taplo \u2014 TOML toolkit
+
+## When to use
+Lint, format, and query TOML files. Completes the config format toolkit: jq (JSON) + yq (YAML) + taplo (TOML).
+
+## Trusted commands
+- Format a file: \`taplo fmt Cargo.toml\`
+- Format all TOML: \`taplo fmt\`
+- Check formatting: \`taplo fmt --check\`
+- Lint: \`taplo lint Cargo.toml\`
+- Get a value: \`taplo get -f pyproject.toml "project.name"\`
+
+## Why it matters for agents
+Agents editing Cargo.toml, pyproject.toml, or any .toml config can validate and format cleanly. Prevents syntax errors in config files.
+
+## Gotchas
+- Config via \`taplo.toml\` or \`.taplo.toml\` at project root.
+- \`taplo get\` uses dot-notation paths for querying.
+- Supports schema validation for known TOML formats (Cargo, pyproject, etc.).
+- \`taplo fmt --check\` exits 1 on formatting diffs \u2014 CI-friendly.
+- Use \`--colored=off\` for clean CI output.
+`.trim();
+
+// src/skills/semgrep.ts
+var semgrep_default = `
+# semgrep \u2014 Multi-language static analysis
+
+## When to use
+Scan code for security vulnerabilities, bugs, and anti-patterns across 30+ languages. Write custom rules or use community rulesets.
+
+## Trusted commands
+- Scan with auto rules: \`semgrep scan --config auto\`
+- Scan specific directory: \`semgrep scan --config auto src/\`
+- Security-focused scan: \`semgrep scan --config p/security-audit\`
+- OWASP top 10: \`semgrep scan --config p/owasp-top-ten\`
+- Specific language: \`semgrep scan --config p/typescript\`
+- Scan single file: \`semgrep scan --config auto path/to/file.ts\`
+- JSON output: \`semgrep scan --config auto --json\`
+
+## Why it matters for agents
+Agents can run security and quality scans before committing code. Much broader language coverage than shellcheck or biome alone.
+
+## Gotchas
+- First run downloads rules (needs internet). Subsequent runs use cache.
+- \`--config auto\` selects rules based on detected languages.
+- Community rules at semgrep.dev/explore \u2014 use \`--config p/RULESET\` to reference them.
+- Can write custom rules in YAML for project-specific patterns.
+`.trim();
+
+// src/skills/age.ts
+var age_default = `
+# age \u2014 Simple file encryption
+
+## When to use
+Encrypt and decrypt files with a passphrase or public key. Modern replacement for GPG \u2014 much simpler API.
+
+## Trusted commands
+- Encrypt with passphrase: \`age -p -o secret.age secret.txt\`
+- Decrypt: \`age -d -o secret.txt secret.age\`
+- Generate key pair: \`age-keygen -o key.txt\`
+- Encrypt to recipient: \`age -r age1... -o secret.age secret.txt\`
+- Encrypt to multiple recipients: \`age -r age1... -r age1... -o secret.age secret.txt\`
+- Pipe: \`echo "secret" | age -p > encrypted.age\`
+
+## Why it matters for agents
+When agents handle .env files, API keys, or sensitive configs, age provides simple encrypt/decrypt without GPG complexity.
+
+## Gotchas
+- Passphrase mode (\`-p\`) prompts interactively. For scripting, pipe passphrase or use recipient mode.
+- Output file must be specified with \`-o\` (doesn't overwrite input).
+- age-keygen outputs private key to file, prints public key to stderr.
+`.trim();
+
+// src/skills/doggo.ts
+var doggo_default = `
+# doggo \u2014 Modern DNS client
+
+## When to use
+Look up DNS records for domains. Modern alternative to dig/nslookup with coloured output and JSON support.
+
+## Trusted commands
+- Basic lookup: \`doggo example.com\`
+- Specific record type: \`doggo example.com MX\`
+- All common types: \`doggo example.com A AAAA MX TXT CNAME\`
+- Use specific nameserver: \`doggo example.com @8.8.8.8\`
+- DNS over HTTPS: \`doggo example.com @https://dns.google/dns-query\`
+- JSON output: \`doggo example.com --json\`
+- Short output: \`doggo example.com --short\`
+
+## Why it matters for agents
+Agents verifying domain setups, debugging DNS issues, or checking propagation get structured output they can parse.
+
+## Gotchas
+- Defaults to system resolver. Specify \`@server\` to use a specific nameserver.
+- Supports DoH (DNS over HTTPS) and DoT (DNS over TLS).
+- JSON output with \`--json\` is ideal for piping to jq.
 `.trim();
 
 // src/skills.ts
@@ -1404,18 +1674,67 @@ var SKILL_CONTENT = {
   lazygit: lazygit_default,
   dust: dust_default,
   btm: btm_default,
-  gitleaks: gitleaks_default
+  gitleaks: gitleaks_default,
+  pandoc: pandoc_default,
+  duckdb: duckdb_default,
+  htmlq: htmlq_default,
+  typos: typos_default,
+  gum: gum_default,
+  direnv: direnv_default,
+  procs: procs_default,
+  uv: uv_default,
+  hexyl: hexyl_default,
+  taplo: taplo_default,
+  semgrep: semgrep_default,
+  age: age_default,
+  doggo: doggo_default
 };
-function skillPath(toolId) {
-  return join2(paths.skills, `${PREFIX}-${toolId}.md`);
+function skillFilename(toolId) {
+  return `${PREFIX}-${toolId}.md`;
+}
+function buildFrontmatter(tool) {
+  const lines = [
+    "---",
+    `tool: ${tool.id}`,
+    `name: ${tool.name}`,
+    `description: ${tool.description}`,
+    `category: ${tool.preset}`
+  ];
+  if (tool.tags?.length) {
+    lines.push(`tags: [${tool.tags.join(", ")}]`);
+  }
+  if (tool.seeAlso?.length) {
+    lines.push(`see-also: [${tool.seeAlso.join(", ")}]`);
+  }
+  lines.push("source: agent-loadout", "---", "");
+  return lines.join("\n");
+}
+async function findToolsMissingSkills(toolIds, dir = paths.skillTargets.claude) {
+  const results = await Promise.all(
+    toolIds.map(async (id) => {
+      const filePath = join2(dir, skillFilename(id));
+      try {
+        await access(filePath);
+        return null;
+      } catch {
+        return id;
+      }
+    })
+  );
+  return results.filter((id) => id !== null);
 }
 async function writeSkills(tools) {
-  await ensureSkillsDir();
+  await ensureSkillDirs();
+  const allDirs = [...Object.values(paths.skillTargets), paths.genericSkills];
   let written = 0;
   for (const tool of tools) {
     const content = SKILL_CONTENT[tool.id];
     if (!content) continue;
-    await writeFile3(skillPath(tool.id), content + "\n");
+    const filename = skillFilename(tool.id);
+    const frontmatter = buildFrontmatter(tool);
+    for (const dir of allDirs) {
+      await writeFile3(join2(dir, filename), frontmatter + content + "\n");
+    }
     written++;
   }
   return written;
@@ -1423,24 +1742,26 @@ async function writeSkills(tools) {
 
 // src/index.ts
 var program = new Command();
-program.name("agent-loadout").description("One command to load out your terminal for agentic coding").version("0.1.0");
+program.name("agent-loadout").description("One command to load out your terminal for agentic coding").version("1.0.0");
 process.on("SIGINT", () => {
-  console.log(chalk6.dim("\n  Cancelled."));
+  console.log(chalk10.dim("\n  Cancelled."));
   process.exit(0);
 });
-program.command("install", { isDefault: true }).description("Install tools (interactive by default)").option("--preset <presets...>", "Install specific presets without prompts").option("--all", "Install everything").option("--apply", "Actually run the install (default is preview only)").action(async (opts) => {
-  const hasBrew = await checkBrewInstalled();
-  if (!hasBrew) {
-    console.log(chalk6.red("Homebrew is required but not installed."));
-    console.log(
-      chalk6.dim(
-        'Install it: https://brew.sh  \u2192  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'
-      )
-    );
-    process.exit(1);
-  }
+program.command("install", { isDefault: true }).description("Install tools (interactive by default)").option("--preset <presets...>", "Install specific presets without prompts").option("--tool <tools...>", "Install specific tools by ID").option("--skip <tools...>", "Exclude specific tools by ID").option("--all", "Install everything").option("--apply", "Actually run the install (default is preview only)").action(async (opts) => {
+  const platformInfo = await detectPlatform();
   let tools;
-  if (opts.all) {
+  if (opts.tool) {
+    const { valid, invalid } = validateToolIds(opts.tool);
+    if (invalid.length > 0) {
+      console.log(
+        chalk10.red(
+          `Unknown tool${invalid.length > 1 ? "s" : ""}: ${invalid.map((t) => `'${t}'`).join(", ")}. Run ${chalk10.dim("agent-loadout list --json")} to see all tool IDs.`
+        )
+      );
+      process.exit(1);
+    }
+    tools = getToolsByIds(valid);
+  } else if (opts.all) {
     tools = TOOLS;
   } else if (opts.preset) {
     const rawIds = opts.preset;
@@ -1448,7 +1769,7 @@ program.command("install", { isDefault: true }).description("Install tools (inte
     const invalid = rawIds.filter((p) => !validIds.includes(p));
     if (invalid.length > 0) {
       console.log(
-        chalk6.red(
+        chalk10.red(
           `Unknown preset${invalid.length > 1 ? "s" : ""}: ${invalid.map((p) => `'${p}'`).join(", ")}. Available: ${validIds.join(", ")}`
         )
       );
@@ -1459,79 +1780,76 @@ program.command("install", { isDefault: true }).description("Install tools (inte
   } else {
     const presetIds = await selectPresets();
     if (presetIds.length === 0) {
-      console.log(chalk6.dim("No presets selected. Nothing to install."));
+      console.log(chalk10.dim("No presets selected. Nothing to install."));
       return;
     }
     tools = await selectTools(presetIds);
     if (tools.length === 0) {
-      console.log(chalk6.dim("No tools selected. Nothing to install."));
+      console.log(chalk10.dim("No tools selected. Nothing to install."));
       return;
     }
   }
-  printPreview(tools);
-  if (!opts.apply && (opts.all || opts.preset)) {
-    console.log(
-      chalk6.yellow("Dry run \u2014 add --apply to install. Example:")
-    );
+  if (opts.skip) {
+    const skipSet = new Set(opts.skip);
+    tools = tools.filter((t) => !skipSet.has(t.id));
+    if (tools.length === 0) {
+      console.log(chalk10.dim("All tools were skipped. Nothing to install."));
+      return;
+    }
+  }
+  const plan = resolveInstallPlan(tools, platformInfo);
+  printPreview(tools, plan, platformInfo);
+  if (!opts.apply && (opts.all || opts.preset || opts.tool)) {
+    const parts = [];
+    if (opts.tool) parts.push(`--tool ${opts.tool.join(" ")}`);
+    else if (opts.all) parts.push("--all");
+    else parts.push(`--preset ${opts.preset.join(" ")}`);
+    if (opts.skip) parts.push(`--skip ${opts.skip.join(" ")}`);
+    console.log(chalk10.yellow("Dry run \u2014 add --apply to install. Example:"));
     console.log(
-      chalk6.dim(
-        `  npx agent-loadout install ${opts.all ? "--all" : `--preset ${opts.preset.join(" ")}`} --apply`
-      )
+      chalk10.dim(`  npx agent-loadout install ${parts.join(" ")} --apply`)
     );
     return;
   }
-  if (!opts.all && !opts.preset) {
+  if (plan.resolved.length === 0) {
+    console.log(chalk10.dim("No installable tools for this platform."));
+    return;
+  }
+  if (!opts.all && !opts.preset && !opts.tool) {
     const proceed = await confirmInstall();
     if (!proceed) {
-      console.log(chalk6.dim("Cancelled."));
+      console.log(chalk10.dim("Cancelled."));
       return;
     }
   }
-  const npmPackages = getNpmInstallCommand(tools);
-  if (npmPackages.length > 0) {
-    const hasNpm = await checkNpmInstalled();
-    if (!hasNpm) {
-      console.log(
-        chalk6.yellow(
-          `npm is required for: ${npmPackages.join(", ")}. Skipping npm packages (install Node.js to include them).`
-        )
-      );
-    }
-  }
-  console.log();
-  const brewfile = generateBrewfile(tools);
-  if (brewfile) {
-    console.log(chalk6.bold("Installing brew packages..."));
-    await writeBrewfile(brewfile);
-    await runBrewBundle();
-  }
-  if (npmPackages.length > 0 && await checkNpmInstalled()) {
-    console.log(chalk6.bold("Installing npm globals..."));
-    await runNpmInstall(npmPackages);
-  }
+  await runInstallPlan(plan);
   console.log();
-  console.log(chalk6.bold("Verifying..."));
-  const results = await verifyTools(tools);
+  console.log(chalk10.bold("Verifying..."));
+  const resolvedTools = plan.resolved.map((r) => r.tool);
+  const results = await verifyTools(resolvedTools, platformInfo.platform);
   printVerifyResults(results);
-  const skillCount = await writeSkills(tools);
+  const skillCount = await writeSkills(resolvedTools);
   if (skillCount > 0) {
+    const targets = Object.keys(paths.skillTargets).join(", ");
     console.log(
-      chalk6.dim(`
-  ${skillCount} skill files written to ~/.claude/skills/`)
+      chalk10.dim(`
+  ${skillCount} skill files written to ${targets} + ~/.agent-loadout/skills/`)
     );
   }
   await writeReceipt({
+    platform: platformInfo.platform,
     selections: tools.map((t) => t.id),
     installed: verifyResultsToJson(results),
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   });
-  console.log(chalk6.dim("  Receipt saved to ~/.agent-loadout/receipt.json"));
+  console.log(chalk10.dim("  Receipt saved to ~/.agent-loadout/receipt.json"));
 });
 program.command("verify").alias("doctor").description("Check which tools are installed").option("--json", "Output as JSON").action(async (opts) => {
+  const platformInfo = await detectPlatform();
   const receipt = await readReceipt();
   const toolIds = receipt?.selections ?? TOOLS.map((t) => t.id);
   const tools = getToolsByIds(toolIds);
-  const results = await verifyTools(tools);
+  const results = await verifyTools(tools, platformInfo.platform);
   const installed = results.filter((r) => r.installed).length;
   const allInstalled = installed === results.length;
   if (opts.json) {
@@ -1539,6 +1857,7 @@ program.command("verify").alias("doctor").description("Check which tools are ins
       JSON.stringify(
         {
           ok: allInstalled,
+          platform: platformInfo.platform,
           installed,
           total: results.length,
           tools: results
@@ -1552,26 +1871,67 @@ program.command("verify").alias("doctor").description("Check which tools are ins
   }
   process.exit(allInstalled ? 0 : 1);
 });
-program.command("list").description("Print the tool catalog").option("--json", "Output as JSON").action((opts) => {
+program.command("list").description("Print the tool catalog").option("--json", "Output as JSON").option("--brewfile", "Output macOS Brewfile (darwin only)").action(async (opts) => {
+  if (opts.brewfile) {
+    const { generateBrewfileFromCatalog } = await import("./catalog-PTLCQEDW.js");
+    console.log(generateBrewfileFromCatalog());
+    return;
+  }
   if (opts.json) {
     console.log(JSON.stringify({ presets: PRESETS, tools: TOOLS }, null, 2));
     return;
   }
+  const platformInfo = await detectPlatform();
   for (const preset of PRESETS) {
-    const marker = preset.defaultOn ? chalk6.green("\u25CF") : chalk6.dim("\u25CB");
+    const marker = preset.defaultOn ? chalk10.green("\u25CF") : chalk10.dim("\u25CB");
     console.log(
       `
-${marker} ${chalk6.bold(preset.name)} \u2014 ${preset.description}`
+${marker} ${chalk10.bold(preset.name)} \u2014 ${preset.description}`
     );
     const presetTools = TOOLS.filter((t) => t.preset === preset.id);
     const maxName = Math.max(...presetTools.map((t) => t.name.length));
     for (const t of presetTools) {
-      const method = t.installMethod === "npm" ? chalk6.cyan("npm") : chalk6.yellow("brew");
+      const platformInstalls = t.install[platformInfo.platform];
+      const method = platformInstalls ? chalk10.yellow(platformInstalls[0].method) : chalk10.dim("n/a");
       console.log(
-        `    ${t.name.padEnd(maxName)}  ${method}  ${chalk6.dim(t.description)}`
+        `    ${t.name.padEnd(maxName)}  ${method}  ${chalk10.dim(t.description)}`
       );
     }
   }
   console.log();
 });
+program.command("skills").description("Write skill files for installed tools (fills gaps by default)").option("--force", "Rewrite skill files for all installed tools").action(async (opts) => {
+  const platformInfo = await detectPlatform();
+  const results = await verifyTools(TOOLS, platformInfo.platform);
+  const installedIds = new Set(results.filter((r) => r.installed).map((r) => r.id));
+  const installedTools = TOOLS.filter((t) => installedIds.has(t.id));
+  if (installedTools.length === 0) {
+    console.log(chalk10.dim("  No installed tools found."));
+    return;
+  }
+  if (opts.force) {
+    console.log(chalk10.dim(`  Writing skills for ${installedTools.length} installed tools...`));
+    const written2 = await writeSkills(installedTools);
+    const targets2 = Object.keys(paths.skillTargets).join(", ");
+    console.log(
+      chalk10.green(`  ${written2} skill files written to ${targets2} + ~/.agent-loadout/skills/`)
+    );
+    return;
+  }
+  console.log(chalk10.dim(`  Scanning ${installedTools.length} installed tools...`));
+  const missingIds = await findToolsMissingSkills(installedTools.map((t) => t.id));
+  if (missingIds.length === 0) {
+    console.log(chalk10.green(`  \u2713 All ${installedTools.length} installed tools already have skill files.`));
+    return;
+  }
+  const alreadyHave = installedTools.length - missingIds.length;
+  console.log(chalk10.dim(`  ${alreadyHave} already have skill files`));
+  console.log(chalk10.dim(`  Writing ${missingIds.length} missing: ${missingIds.join(", ")}`));
+  const toolsToWrite = installedTools.filter((t) => missingIds.includes(t.id));
+  const written = await writeSkills(toolsToWrite);
+  const targets = Object.keys(paths.skillTargets).join(", ");
+  console.log(
+    chalk10.green(`  ${written} skill files written to ${targets} + ~/.agent-loadout/skills/`)
+  );
+});
 program.parse();