@heurist-network/skills 0.1.0 → 0.1.1

package/dist/cli.js

@@ -0,0 +1,1554 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api.ts
+function getBaseUrl() {
+  return process.env["HEURIST_SKILLS_API"] || DEFAULT_API_URL;
+}
+async function fetchJson(path) {
+  const url = `${getBaseUrl()}${path}`;
+  const resp = await fetch(url, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!resp.ok) {
+    throw new Error(`API error ${resp.status}: ${resp.statusText} (${url})`);
+  }
+  return resp.json();
+}
+async function listSkills(opts) {
+  const params = new URLSearchParams();
+  if (opts?.category) params.set("category", opts.category);
+  if (opts?.search) params.set("search", opts.search);
+  if (opts?.offset) params.set("offset", String(opts.offset));
+  if (opts?.limit) params.set("limit", String(opts.limit));
+  const qs = params.toString();
+  return fetchJson(`/skills${qs ? `?${qs}` : ""}`);
+}
+async function getSkill(slug) {
+  return fetchJson(`/skills/${slug}`);
+}
+async function listSkillFiles(slug) {
+  return fetchJson(`/skills/${slug}/files`);
+}
+async function downloadSkill(slug) {
+  const url = `${getBaseUrl()}/skills/${slug}/download`;
+  const resp = await fetch(url, {
+    signal: AbortSignal.timeout(6e4)
+  });
+  if (!resp.ok) {
+    throw new Error(`Download failed ${resp.status}: ${resp.statusText}`);
+  }
+  const sha256 = resp.headers.get("X-Skill-SHA256") || "";
+  const disposition = resp.headers.get("Content-Disposition") || "";
+  const contentType = resp.headers.get("Content-Type") || "";
+  const isZip = contentType.includes("zip") || disposition.includes(".zip");
+  const filenameMatch = disposition.match(/filename="(.+?)"/);
+  const filename = filenameMatch?.[1] || `${slug}-SKILL.md`;
+  const arrayBuffer = await resp.arrayBuffer();
+  const content = Buffer.from(arrayBuffer);
+  return { content, sha256, isZip, filename };
+}
+async function checkUpdates(installed) {
+  const url = `${getBaseUrl()}/check-updates`;
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ installed }),
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!resp.ok) {
+    throw new Error(`Check updates failed ${resp.status}: ${resp.statusText}`);
+  }
+  const data = await resp.json();
+  return data.updates;
+}
+var DEFAULT_API_URL;
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    DEFAULT_API_URL = "https://mesh.heurist.ai";
+  }
+});
+
+// src/agents.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+async function detectInstalledAgents() {
+  const installed = [];
+  for (const key of Object.keys(agents)) {
+    if (await agents[key].detectInstalled()) {
+      installed.push(key);
+    }
+  }
+  return installed;
+}
+function isValidAgent(value) {
+  return value in agents;
+}
+function isUniversalAgent(type) {
+  return agents[type].skillsDir === ".agents/skills";
+}
+function getUniversalAgents() {
+  return Object.keys(agents).filter(isUniversalAgent);
+}
+function getNonUniversalAgents() {
+  return Object.keys(agents).filter((type) => !isUniversalAgent(type));
+}
+var home, configHome, codexHome, claudeHome, agents;
+var init_agents = __esm({
+  "src/agents.ts"() {
+    "use strict";
+    home = homedir();
+    configHome = process.env["XDG_CONFIG_HOME"]?.trim() || join(home, ".config");
+    codexHome = process.env["CODEX_HOME"]?.trim() || join(home, ".codex");
+    claudeHome = process.env["CLAUDE_CONFIG_DIR"]?.trim() || join(home, ".claude");
+    agents = {
+      "claude-code": {
+        name: "claude-code",
+        displayName: "Claude Code",
+        skillsDir: ".claude/skills",
+        globalSkillsDir: join(claudeHome, "skills"),
+        detectInstalled: () => existsSync(claudeHome)
+      },
+      cursor: {
+        name: "cursor",
+        displayName: "Cursor",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: join(home, ".cursor/skills"),
+        detectInstalled: () => existsSync(join(home, ".cursor"))
+      },
+      codex: {
+        name: "codex",
+        displayName: "Codex",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: join(codexHome, "skills"),
+        detectInstalled: () => existsSync(codexHome) || existsSync("/etc/codex")
+      },
+      opencode: {
+        name: "opencode",
+        displayName: "OpenCode",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: join(configHome, "opencode/skills"),
+        detectInstalled: () => existsSync(join(configHome, "opencode"))
+      },
+      cline: {
+        name: "cline",
+        displayName: "Cline",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: join(home, ".agents/skills"),
+        detectInstalled: () => existsSync(join(home, ".cline"))
+      },
+      windsurf: {
+        name: "windsurf",
+        displayName: "Windsurf",
+        skillsDir: ".windsurf/skills",
+        globalSkillsDir: join(home, ".codeium/windsurf/skills"),
+        detectInstalled: () => existsSync(join(home, ".codeium/windsurf"))
+      },
+      "gemini-cli": {
+        name: "gemini-cli",
+        displayName: "Gemini CLI",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: join(home, ".gemini/skills"),
+        detectInstalled: () => existsSync(join(home, ".gemini"))
+      },
+      "github-copilot": {
+        name: "github-copilot",
+        displayName: "GitHub Copilot",
+        skillsDir: ".agents/skills",
+        globalSkillsDir: join(home, ".copilot/skills"),
+        detectInstalled: () => existsSync(join(home, ".copilot"))
+      },
+      roo: {
+        name: "roo",
+        displayName: "Roo Code",
+        skillsDir: ".roo/skills",
+        globalSkillsDir: join(home, ".roo/skills"),
+        detectInstalled: () => existsSync(join(home, ".roo"))
+      },
+      continue: {
+        name: "continue",
+        displayName: "Continue",
+        skillsDir: ".continue/skills",
+        globalSkillsDir: join(home, ".continue/skills"),
+        detectInstalled: () => existsSync(join(process.cwd(), ".continue")) || existsSync(join(home, ".continue"))
+      }
+    };
+  }
+});
+
+// src/installer.ts
+import {
+  access,
+  lstat,
+  mkdir,
+  readlink,
+  rm,
+  symlink,
+  writeFile
+} from "fs/promises";
+import { homedir as homedir2, platform } from "os";
+import { dirname, join as join2, normalize, relative, resolve, sep } from "path";
+import { inflateRawSync } from "zlib";
+function sanitizeName(name) {
+  const sanitized = name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "");
+  return sanitized.substring(0, 255) || "unnamed-skill";
+}
+function isPathSafe(basePath, targetPath) {
+  const normalizedBase = normalize(resolve(basePath));
+  const normalizedTarget = normalize(resolve(targetPath));
+  return normalizedTarget === normalizedBase || normalizedTarget.startsWith(normalizedBase + sep);
+}
+function getCanonicalSkillsDir(scope, cwd = process.cwd()) {
+  const baseDir = scope === "global" ? homedir2() : cwd;
+  return join2(baseDir, ".agents", "skills");
+}
+function getCanonicalPath(scope, slug, cwd = process.cwd()) {
+  const canonicalBase = getCanonicalSkillsDir(scope, cwd);
+  const canonicalPath = join2(canonicalBase, sanitizeName(slug));
+  if (!isPathSafe(canonicalBase, canonicalPath)) {
+    throw new Error("Invalid skill slug: potential path traversal detected.");
+  }
+  return canonicalPath;
+}
+function getAgentBaseDir(scope, agentType, cwd = process.cwd()) {
+  if (isUniversalAgent(agentType)) {
+    return getCanonicalSkillsDir(scope, cwd);
+  }
+  const agent = agents[agentType];
+  if (scope === "global") {
+    if (!agent.globalSkillsDir) {
+      throw new Error(`${agent.displayName} does not support global skill installation.`);
+    }
+    return agent.globalSkillsDir;
+  }
+  return join2(cwd, agent.skillsDir);
+}
+function getInstallPath(scope, agentType, slug, cwd = process.cwd()) {
+  const baseDir = getAgentBaseDir(scope, agentType, cwd);
+  const installPath = join2(baseDir, sanitizeName(slug));
+  if (!isPathSafe(baseDir, installPath)) {
+    throw new Error("Invalid skill slug: potential path traversal detected.");
+  }
+  return installPath;
+}
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function removePathIfExists(path) {
+  try {
+    await rm(path, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function cleanAndCreateDirectory(path) {
+  await rm(path, { recursive: true, force: true }).catch(() => void 0);
+  await mkdir(path, { recursive: true });
+}
+async function createRelativeSymlink(target, linkPath) {
+  try {
+    const resolvedTarget = resolve(target);
+    const resolvedLinkPath = resolve(linkPath);
+    if (resolvedTarget === resolvedLinkPath) {
+      return true;
+    }
+    const existing = await lstat(linkPath).catch(() => null);
+    if (existing) {
+      if (existing.isSymbolicLink()) {
+        const currentTarget = await readlink(linkPath).catch(() => "");
+        if (resolve(dirname(linkPath), currentTarget) === resolvedTarget) {
+          return true;
+        }
+      }
+      await rm(linkPath, { recursive: true, force: true });
+    }
+    const linkDir = dirname(linkPath);
+    await mkdir(linkDir, { recursive: true });
+    const relativeTarget = relative(linkDir, target);
+    const symlinkType = platform() === "win32" ? "junction" : void 0;
+    await symlink(relativeTarget, linkPath, symlinkType);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeSkillBundle(targetDir, content, isZip) {
+  await cleanAndCreateDirectory(targetDir);
+  if (!isZip) {
+    await writeFile(join2(targetDir, "SKILL.md"), content);
+    return;
+  }
+  const entries = parseZipEntries(content);
+  for (const entry of entries) {
+    const fullPath = join2(targetDir, entry.path);
+    if (!isPathSafe(targetDir, fullPath)) {
+      continue;
+    }
+    if (entry.isDirectory) {
+      await mkdir(fullPath, { recursive: true });
+      continue;
+    }
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, entry.content);
+  }
+}
+async function installDownloadedSkill(options) {
+  const cwd = options.cwd || process.cwd();
+  const canonicalPath = getCanonicalPath(options.scope, options.slug, cwd);
+  const writtenPaths = /* @__PURE__ */ new Set();
+  const agentInstalls = {};
+  const symlinkFallbackAgents = [];
+  const ensureBundleAt = async (path) => {
+    if (writtenPaths.has(path)) return;
+    await writeSkillBundle(path, options.content, options.isZip);
+    writtenPaths.add(path);
+  };
+  if (options.mode === "symlink") {
+    await ensureBundleAt(canonicalPath);
+  }
+  for (const agentType of options.agents) {
+    const agentPath = getInstallPath(options.scope, agentType, options.slug, cwd);
+    if (options.mode === "copy") {
+      await ensureBundleAt(agentPath);
+      agentInstalls[agentType] = {
+        path: agentPath,
+        kind: agentPath === canonicalPath ? "canonical" : "copy"
+      };
+      continue;
+    }
+    if (agentPath === canonicalPath) {
+      agentInstalls[agentType] = {
+        path: canonicalPath,
+        kind: "canonical"
+      };
+      continue;
+    }
+    const linked = await createRelativeSymlink(canonicalPath, agentPath);
+    if (linked) {
+      agentInstalls[agentType] = {
+        path: agentPath,
+        kind: "symlink"
+      };
+      continue;
+    }
+    await ensureBundleAt(agentPath);
+    agentInstalls[agentType] = {
+      path: agentPath,
+      kind: "copy"
+    };
+    symlinkFallbackAgents.push(agentType);
+  }
+  return {
+    canonicalPath,
+    agentInstalls,
+    symlinkFallbackAgents
+  };
+}
+function parseZipEntries(buf) {
+  const entries = [];
+  let eocdOffset = -1;
+  for (let i = buf.length - 22; i >= 0; i--) {
+    if (buf[i] === 80 && buf[i + 1] === 75 && buf[i + 2] === 5 && buf[i + 3] === 6) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) {
+    throw new Error("Invalid zip: cannot find end of central directory.");
+  }
+  const centralDirOffset = buf.readUInt32LE(eocdOffset + 16);
+  const numEntries = buf.readUInt16LE(eocdOffset + 10);
+  let offset = centralDirOffset;
+  for (let i = 0; i < numEntries; i++) {
+    if (buf.readUInt32LE(offset) !== 33639248) {
+      break;
+    }
+    const compressedSize = buf.readUInt32LE(offset + 20);
+    const uncompressedSize = buf.readUInt32LE(offset + 24);
+    const filenameLen = buf.readUInt16LE(offset + 28);
+    const extraLen = buf.readUInt16LE(offset + 30);
+    const commentLen = buf.readUInt16LE(offset + 32);
+    const localHeaderOffset = buf.readUInt32LE(offset + 42);
+    const compressionMethod = buf.readUInt16LE(offset + 10);
+    const filename = buf.toString("utf-8", offset + 46, offset + 46 + filenameLen);
+    const isDirectory = filename.endsWith("/");
+    if (isDirectory) {
+      entries.push({ path: filename, isDirectory: true, content: Buffer.alloc(0) });
+      offset += 46 + filenameLen + extraLen + commentLen;
+      continue;
+    }
+    const localFilenameLen = buf.readUInt16LE(localHeaderOffset + 26);
+    const localExtraLen = buf.readUInt16LE(localHeaderOffset + 28);
+    const dataOffset = localHeaderOffset + 30 + localFilenameLen + localExtraLen;
+    let fileContent;
+    if (compressionMethod === 0) {
+      fileContent = buf.subarray(dataOffset, dataOffset + uncompressedSize);
+    } else if (compressionMethod === 8) {
+      const compressed = buf.subarray(dataOffset, dataOffset + compressedSize);
+      fileContent = inflateRawSync(compressed);
+    } else {
+      offset += 46 + filenameLen + extraLen + commentLen;
+      continue;
+    }
+    entries.push({
+      path: filename,
+      isDirectory: false,
+      content: fileContent
+    });
+    offset += 46 + filenameLen + extraLen + commentLen;
+  }
+  return entries;
+}
+var init_installer = __esm({
+  "src/installer.ts"() {
+    "use strict";
+    init_agents();
+  }
+});
+
+// src/lock.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+function getProjectLockPath(cwd = process.cwd()) {
+  return join3(cwd, "skills-lock.json");
+}
+function getGlobalLockPath() {
+  return join3(homedir3(), ".agents", ".skill-lock.json");
+}
+function readProjectLock(cwd = process.cwd()) {
+  return readLockFile(getProjectLockPath(cwd));
+}
+function readGlobalLock() {
+  return readLockFile(getGlobalLockPath());
+}
+function writeProjectLock(lock, cwd = process.cwd()) {
+  writeLockFile(getProjectLockPath(cwd), lock, true);
+}
+function writeGlobalLock(lock) {
+  writeLockFile(getGlobalLockPath(), lock, false);
+}
+function readLock(scope, cwd = process.cwd()) {
+  return scope === "global" ? readGlobalLock() : readProjectLock(cwd);
+}
+function writeLock(scope, lock, cwd = process.cwd()) {
+  if (scope === "global") {
+    writeGlobalLock(lock);
+    return;
+  }
+  writeProjectLock(lock, cwd);
+}
+function getLockEntry(scope, slug, cwd = process.cwd()) {
+  return readLock(scope, cwd).skills[slug];
+}
+function upsertLockEntry(scope, entry, cwd = process.cwd()) {
+  const lock = readLock(scope, cwd);
+  lock.skills[entry.slug] = entry;
+  writeLock(scope, lock, cwd);
+}
+function removeLockEntry(scope, slug, cwd = process.cwd()) {
+  const lock = readLock(scope, cwd);
+  if (!(slug in lock.skills)) {
+    return false;
+  }
+  delete lock.skills[slug];
+  writeLock(scope, lock, cwd);
+  return true;
+}
+function getInstalledEntries(scope = "all", cwd = process.cwd()) {
+  const entries = [];
+  if (scope === "all" || scope === "local") {
+    for (const entry of Object.values(readProjectLock(cwd).skills)) {
+      entries.push({ ...entry, scope: "local" });
+    }
+  }
+  if (scope === "all" || scope === "global") {
+    for (const entry of Object.values(readGlobalLock().skills)) {
+      entries.push({ ...entry, scope: "global" });
+    }
+  }
+  return entries;
+}
+function readLockFile(path) {
+  const raw = readRawLockFile(path);
+  if (!raw || typeof raw !== "object") {
+    return createEmptyLock();
+  }
+  const skills = isRecord(raw["skills"]) ? raw["skills"] : {};
+  const normalizedSkills = {};
+  for (const [slug, entry] of Object.entries(skills)) {
+    if (isLockEntry(entry)) {
+      normalizedSkills[slug] = entry;
+    }
+  }
+  return {
+    version: typeof raw["version"] === "number" ? raw["version"] : LOCK_VERSION,
+    skills: normalizedSkills
+  };
+}
+function writeLockFile(path, lock, sortSkills) {
+  const dir = dirname2(path);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const sortedSkills = sortSkills ? Object.fromEntries(
+    Object.entries(lock.skills).sort(
+      ([left], [right]) => left.localeCompare(right)
+    )
+  ) : lock.skills;
+  const raw = readRawLockFile(path);
+  const foreignSkills = isRecord(raw?.["skills"]) ? Object.fromEntries(
+    Object.entries(raw["skills"]).filter(([, entry]) => !isLockEntry(entry))
+  ) : {};
+  writeFileSync(
+    path,
+    JSON.stringify(
+      {
+        ...raw && typeof raw === "object" ? raw : {},
+        version: typeof raw?.["version"] === "number" ? raw["version"] : LOCK_VERSION,
+        skills: {
+          ...foreignSkills,
+          ...sortedSkills
+        }
+      },
+      null,
+      2
+    ) + "\n"
+  );
+}
+function createEmptyLock() {
+  return {
+    version: LOCK_VERSION,
+    skills: {}
+  };
+}
+function readRawLockFile(path) {
+  if (!existsSync2(path)) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    return isRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isLockEntry(value) {
+  if (!isRecord(value)) return false;
+  if (typeof value["slug"] !== "string") return false;
+  if (typeof value["name"] !== "string") return false;
+  if (typeof value["sha256"] !== "string") return false;
+  if (typeof value["installed_at"] !== "string") return false;
+  if (typeof value["is_zip"] !== "boolean") return false;
+  if (value["install_method"] !== "symlink" && value["install_method"] !== "copy") {
+    return false;
+  }
+  if (typeof value["canonical_path"] !== "string") return false;
+  return isRecord(value["agent_installs"]);
+}
+var LOCK_VERSION;
+var init_lock = __esm({
+  "src/lock.ts"() {
+    "use strict";
+    LOCK_VERSION = 1;
+  }
+});
+
+// src/commands/add.ts
+var add_exports = {};
+__export(add_exports, {
+  addCommand: () => addCommand
+});
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+async function addCommand(args) {
+  const options = parseAddOptions(args);
+  let slug = options.slug;
+  if (!slug) {
+    slug = await interactiveSearch();
+    if (!slug) return;
+  }
+  const spinner5 = p.spinner();
+  spinner5.start(`Fetching skill info for ${pc.cyan(slug)}`);
+  let detail;
+  try {
+    detail = await getSkill(slug);
+  } catch (err) {
+    spinner5.stop("Skill lookup failed.");
+    if (err instanceof Error && err.message.includes("API error 404")) {
+      throw new Error(`Skill ${slug} not found.`);
+    }
+    throw err;
+  }
+  if (detail.verification_status !== "verified") {
+    spinner5.stop(
+      `Skill ${pc.red(slug)} is ${pc.yellow(detail.verification_status)} and cannot be installed.`
+    );
+    throw new Error("Only verified skills can be installed.");
+  }
+  spinner5.stop(`Found: ${pc.cyan(detail.name)} \u2014 ${detail.description}`);
+  const warnings = getCapabilityWarnings(detail.capabilities);
+  if (warnings.length > 0) {
+    p.log.warn(
+      pc.yellow("Capabilities:") + "\n" + warnings.map((w) => `  - ${w}`).join("\n")
+    );
+    if (!options.skipConfirm) {
+      const proceed = await p.confirm({
+        message: "This skill has sensitive capabilities. Continue?"
+      });
+      if (!proceed || typeof proceed === "symbol") {
+        p.log.info("Cancelled.");
+        return;
+      }
+    }
+  }
+  const targetAgents = await resolveTargetAgents(options);
+  const scope = await resolveScope(options);
+  const installMode = await resolveInstallMode(options);
+  const existing = getLockEntry(scope, slug);
+  if (existing && !options.skipConfirm) {
+    const shouldOverwrite = await p.confirm({
+      message: `${pc.yellow(slug)} is already installed (${scope}). Reinstall?`
+    });
+    if (!shouldOverwrite || typeof shouldOverwrite === "symbol") {
+      p.log.info("Cancelled.");
+      return;
+    }
+  }
+  const summaryLines = buildSummaryLines({
+    slug,
+    scope,
+    mode: installMode,
+    agents: targetAgents
+  });
+  console.log();
+  p.note(summaryLines.join("\n"), "Installation Summary");
+  if (!options.skipConfirm) {
+    const confirmed = await p.confirm({ message: "Proceed with installation?" });
+    if (!confirmed || typeof confirmed === "symbol") {
+      p.log.info("Cancelled.");
+      return;
+    }
+  }
+  if (existing) {
+    await cleanupLockEntry(existing);
+  }
+  spinner5.start(`Downloading ${pc.cyan(slug)}`);
+  const download = await downloadSkill(slug);
+  spinner5.stop(
+    `Downloaded ${pc.green(download.filename)} (${formatBytes(download.content.length)})`
+  );
+  spinner5.start(`Installing to ${scope} scope`);
+  const installResult = await installDownloadedSkill({
+    scope,
+    slug,
+    content: download.content,
+    isZip: download.isZip,
+    agents: targetAgents,
+    mode: installMode
+  });
+  spinner5.stop(`Installed to ${pc.dim(installResult.canonicalPath)}`);
+  upsertLockEntry(scope, {
+    slug,
+    name: detail.name,
+    sha256: download.sha256,
+    installed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    is_zip: download.isZip,
+    install_method: installMode,
+    canonical_path: installResult.canonicalPath,
+    agent_installs: installResult.agentInstalls
+  });
+  if (installResult.symlinkFallbackAgents.length > 0) {
+    p.log.warn(
+      `Symlinks failed for ${installResult.symlinkFallbackAgents.map((agent) => agents[agent].displayName).join(", ")}.`
+    );
+    p.log.message(pc.dim("Files were copied instead."));
+  }
+  p.log.success(`${pc.green("+")} ${pc.bold(detail.name)} installed successfully.`);
+}
+function parseAddOptions(args) {
+  const options = {
+    requestedAgents: [],
+    global: false,
+    skipConfirm: false,
+    copy: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-g" || arg === "--global") {
+      options.global = true;
+      continue;
+    }
+    if (arg === "-y" || arg === "--yes") {
+      options.skipConfirm = true;
+      continue;
+    }
+    if (arg === "--copy") {
+      options.copy = true;
+      continue;
+    }
+    if (arg === "-a" || arg === "--agent") {
+      while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        options.requestedAgents.push(args[++i]);
+      }
+      continue;
+    }
+    if (!arg.startsWith("-") && !options.slug) {
+      options.slug = arg;
+    }
+  }
+  return options;
+}
+async function resolveTargetAgents(options) {
+  if (options.requestedAgents.length > 0) {
+    const invalid = options.requestedAgents.filter((agent) => !isValidAgent(agent));
+    if (invalid.length > 0) {
+      throw new Error(
+        `Invalid agent${invalid.length > 1 ? "s" : ""}: ${invalid.join(", ")}`
+      );
+    }
+    return ensureUniversalAgents(options.requestedAgents);
+  }
+  const detectedAgents = await detectInstalledAgents();
+  const universalAgents = new Set(getUniversalAgents());
+  const detectedNonUniversal = detectedAgents.filter((agent) => !universalAgents.has(agent));
+  if (options.skipConfirm) {
+    return ensureUniversalAgents(detectedNonUniversal);
+  }
+  if (detectedNonUniversal.length === 1) {
+    const agent = detectedNonUniversal[0];
+    p.log.info(`Installing to: ${pc.cyan(agents[agent].displayName)}`);
+    return ensureUniversalAgents([agent]);
+  }
+  const selectableAgents = getNonUniversalAgents();
+  const selected = await p.multiselect({
+    message: detectedNonUniversal.length > 1 ? "Select additional agents to install to:" : "Select agents to install to:",
+    options: selectableAgents.map((agent) => ({
+      value: agent,
+      label: agents[agent].displayName,
+      hint: options.global ? agents[agent].globalSkillsDir : agents[agent].skillsDir
+    })),
+    initialValues: detectedNonUniversal
+  });
+  if (typeof selected === "symbol") {
+    throw new Error("Installation cancelled.");
+  }
+  return ensureUniversalAgents(selected);
+}
+async function resolveScope(options) {
+  if (options.global) {
+    return "global";
+  }
+  if (options.skipConfirm) {
+    return "local";
+  }
+  const selected = await p.select({
+    message: "Installation scope",
+    options: [
+      {
+        value: "local",
+        label: "Project",
+        hint: "Install in the current repository"
+      },
+      {
+        value: "global",
+        label: "Global",
+        hint: "Install in your home directory"
+      }
+    ]
+  });
+  if (typeof selected === "symbol") {
+    throw new Error("Installation cancelled.");
+  }
+  return selected;
+}
+async function resolveInstallMode(options) {
+  if (options.copy) {
+    return "copy";
+  }
+  if (options.skipConfirm) {
+    return "symlink";
+  }
+  const selected = await p.select({
+    message: "Installation method",
+    options: [
+      {
+        value: "symlink",
+        label: "Symlink (Recommended)",
+        hint: "Single source of truth, easier updates"
+      },
+      {
+        value: "copy",
+        label: "Copy",
+        hint: "Write separate copies into each agent directory"
+      }
+    ]
+  });
+  if (typeof selected === "symbol") {
+    throw new Error("Installation cancelled.");
+  }
+  return selected;
+}
+function ensureUniversalAgents(selectedAgents) {
+  const combined = new Set(getUniversalAgents());
+  for (const agent of selectedAgents) {
+    combined.add(agent);
+  }
+  return Array.from(combined);
+}
+function buildSummaryLines(options) {
+  const lines = [];
+  const canonicalPath = getCanonicalPath(options.scope, options.slug);
+  lines.push(`${pc.dim("scope:")} ${options.scope}`);
+  lines.push(`${pc.dim("method:")} ${options.mode}`);
+  lines.push(`${pc.dim("canonical:")} ${canonicalPath}`);
+  lines.push(
+    `${pc.dim("agents:")} ${options.agents.map((agent) => agents[agent].displayName).join(", ")}`
+  );
+  if (options.mode === "copy") {
+    for (const agent of options.agents) {
+      lines.push(
+        `${pc.dim(`${agents[agent].displayName}:`)} ${getInstallPath(options.scope, agent, options.slug)}`
+      );
+    }
+  }
+  return lines;
+}
+async function cleanupLockEntry(entry) {
+  const paths = /* @__PURE__ */ new Set();
+  paths.add(entry.canonical_path);
+  for (const install of Object.values(entry.agent_installs)) {
+    if (install?.path) {
+      paths.add(install.path);
+    }
+  }
+  for (const path of paths) {
+    await removePathIfExists(path);
+  }
+}
+async function interactiveSearch() {
+  const searchTerm = await p.text({
+    message: "Search skills:",
+    placeholder: "e.g. defi, swap, analytics"
+  });
+  if (typeof searchTerm === "symbol" || !searchTerm) return void 0;
+  const spinner5 = p.spinner();
+  spinner5.start("Searching marketplace...");
+  const result = await listSkills({ search: searchTerm, limit: 20 });
+  spinner5.stop(`Found ${result.skills.length} skill(s).`);
+  if (result.skills.length === 0) {
+    p.log.warn("No skills found matching that query.");
+    return void 0;
+  }
+  const selected = await p.select({
+    message: "Select a skill to install:",
+    options: result.skills.map((skill) => ({
+      value: skill.slug,
+      label: `${skill.name} ${pc.dim(`[${skill.category || "uncategorized"}]`)}`,
+      hint: skill.description
+    }))
+  });
+  if (typeof selected === "symbol") return void 0;
+  return selected;
+}
+function getCapabilityWarnings(capabilities) {
+  const warnings = [];
+  if (capabilities.requires_private_keys) warnings.push("Requires private keys");
+  if (capabilities.can_sign_transactions) warnings.push("Can sign transactions");
+  if (capabilities.uses_leverage) warnings.push("Uses leverage");
+  if (capabilities.requires_exchange_api_keys) warnings.push("Requires exchange API keys");
+  return warnings;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var init_add = __esm({
+  "src/commands/add.ts"() {
+    "use strict";
+    init_api();
+    init_agents();
+    init_installer();
+    init_lock();
+  }
+});
+
+// src/commands/remove.ts
+var remove_exports = {};
+__export(remove_exports, {
+  removeCommand: () => removeCommand
+});
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+async function removeCommand(args) {
+  const options = parseRemoveOptions(args);
+  const requestedAgents = resolveRequestedAgents(options.requestedAgents);
+  const installed = getInstalledEntries(options.global ? "global" : "all");
+  if (installed.length === 0) {
+    p2.log.info("No skills installed.");
+    return;
+  }
+  const targets = await resolveTargets(installed, options);
+  if (targets.length === 0) {
+    p2.log.info("Nothing to remove.");
+    return;
+  }
+  if (!options.skipConfirm) {
+    const confirm3 = await p2.confirm({
+      message: `Remove ${targets.length} skill install(s)?`
+    });
+    if (!confirm3 || typeof confirm3 === "symbol") {
+      p2.log.info("Cancelled.");
+      return;
+    }
+  }
+  for (const target of targets) {
+    const result = await removeFromEntry(target, requestedAgents);
+    if (!result.changed) {
+      p2.log.warn(result.message);
+      continue;
+    }
+    if (result.remainingAgents.length > 0) {
+      p2.log.success(
+        `${pc2.red("-")} ${target.slug} updated (${target.scope}); remaining agents: ${result.remainingAgents.map((agent) => agents[agent].displayName).join(", ")}`
+      );
+    } else {
+      p2.log.success(`${pc2.red("-")} ${target.slug} removed (${target.scope}).`);
+    }
+  }
+}
+function parseRemoveOptions(args) {
+  const options = {
+    global: false,
+    skipConfirm: false,
+    removeAll: false,
+    requestedAgents: [],
+    slugs: []
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-g" || arg === "--global") {
+      options.global = true;
+      continue;
+    }
+    if (arg === "-y" || arg === "--yes") {
+      options.skipConfirm = true;
+      continue;
+    }
+    if (arg === "--all") {
+      options.removeAll = true;
+      continue;
+    }
+    if (arg === "-a" || arg === "--agent") {
+      while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        options.requestedAgents.push(args[++i]);
+      }
+      continue;
+    }
+    if (!arg.startsWith("-")) {
+      options.slugs.push(arg);
+    }
+  }
+  return options;
+}
+function resolveRequestedAgents(requestedAgents) {
+  if (requestedAgents.length === 0) {
+    return void 0;
+  }
+  const invalid = requestedAgents.filter((agent) => !isValidAgent(agent));
+  if (invalid.length > 0) {
+    throw new Error(
+      `Invalid agent${invalid.length > 1 ? "s" : ""}: ${invalid.join(", ")}`
+    );
+  }
+  return requestedAgents;
+}
+async function resolveTargets(installed, options) {
+  if (options.removeAll) {
+    return installed;
+  }
+  if (options.slugs.length > 0) {
+    const targets = [];
+    for (const slug of options.slugs) {
+      const matches = installed.filter((entry) => entry.slug === slug);
+      if (matches.length === 0) {
+        p2.log.warn(`${slug} is not installed.`);
+        continue;
+      }
+      if (matches.length === 1 || options.global) {
+        targets.push(matches[0]);
+        continue;
+      }
+      const localMatch = matches.find((entry) => entry.scope === "local");
+      const globalMatch = matches.find((entry) => entry.scope === "global");
+      if (localMatch && globalMatch && !options.skipConfirm) {
+        const selected2 = await p2.select({
+          message: `${slug} is installed in both project and global scope. Remove from:`,
+          options: [
+            { value: "local", label: "Project" },
+            { value: "global", label: "Global" },
+            { value: "both", label: "Both" }
+          ]
+        });
+        if (typeof selected2 === "symbol") {
+          continue;
+        }
+        if (selected2 === "both") {
+          targets.push(localMatch, globalMatch);
+          continue;
+        }
+        targets.push(selected2 === "local" ? localMatch : globalMatch);
+        continue;
+      }
+      targets.push(localMatch || matches[0]);
+      if (localMatch && globalMatch && options.skipConfirm) {
+        p2.log.info(`${slug} is also installed globally. Use --global to remove that copy.`);
+      }
+    }
+    return targets;
+  }
+  const selected = await p2.multiselect({
+    message: "Select installs to remove:",
+    options: installed.map((entry) => ({
+      value: `${entry.scope}:${entry.slug}`,
+      label: `${entry.slug} \u2014 ${entry.name}`,
+      hint: entry.scope
+    }))
+  });
+  if (typeof selected === "symbol") {
+    return [];
+  }
+  const selectedValues = new Set(selected);
+  return installed.filter((entry) => selectedValues.has(`${entry.scope}:${entry.slug}`));
+}
+async function removeFromEntry(entry, requestedAgents) {
+  const agentInstalls = { ...entry.agent_installs };
+  const installedAgents = Object.keys(agentInstalls);
+  const targetAgents = requestedAgents ? installedAgents.filter((agent) => requestedAgents.includes(agent)) : installedAgents;
+  if (targetAgents.length === 0) {
+    return {
+      changed: false,
+      message: `${entry.slug} is not installed for the selected agents.`,
+      remainingAgents: installedAgents
+    };
+  }
+  for (const agent of targetAgents) {
+    const install = agentInstalls[agent];
+    if (!install) continue;
+    if (install.kind !== "canonical") {
+      await removePathIfExists(install.path);
+    }
+    delete agentInstalls[agent];
+  }
+  const remainingInstalls = Object.values(agentInstalls).filter(
+    (install) => Boolean(install)
+  );
+  const remainingNeedsCanonical = remainingInstalls.some((install) => install.kind !== "copy");
+  if (!remainingNeedsCanonical) {
+    await removePathIfExists(entry.canonical_path);
+  }
+  if (remainingInstalls.length === 0) {
+    removeLockEntry(entry.scope, entry.slug);
+  } else {
+    upsertLockEntry(entry.scope, {
+      ...stripScope(entry),
+      agent_installs: agentInstalls
+    });
+  }
+  return {
+    changed: true,
+    message: "",
+    remainingAgents: Object.keys(agentInstalls)
+  };
+}
+function stripScope(entry) {
+  return {
+    slug: entry.slug,
+    name: entry.name,
+    sha256: entry.sha256,
+    installed_at: entry.installed_at,
+    is_zip: entry.is_zip,
+    install_method: entry.install_method,
+    canonical_path: entry.canonical_path,
+    agent_installs: entry.agent_installs
+  };
+}
+var init_remove = __esm({
+  "src/commands/remove.ts"() {
+    "use strict";
+    init_agents();
+    init_installer();
+    init_lock();
+  }
+});
+
+// src/commands/list.ts
+var list_exports = {};
+__export(list_exports, {
+  listCommand: () => listCommand,
+  listRemote: () => listRemote
+});
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+async function listCommand(args) {
+  const options = parseListOptions(args);
+  if (options.showRemote) {
+    await listRemote(options);
+    return;
+  }
+  await listLocal(options.global ? "global" : "local", options.agentFilter);
+}
+function parseListOptions(args) {
+  const options = {
+    showRemote: false,
+    global: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--remote" || arg === "-r") {
+      options.showRemote = true;
+      continue;
+    }
+    if (arg === "-g" || arg === "--global") {
+      options.global = true;
+      continue;
+    }
+    if (arg === "--category" || arg === "-c") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("-")) {
+        options.category = value;
+        i++;
+      }
+      continue;
+    }
+    if (arg === "--search" || arg === "-s") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("-")) {
+        options.search = value;
+        i++;
+      }
+      continue;
+    }
+    if (arg === "-a" || arg === "--agent") {
+      const selected = [];
+      while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        const value = args[++i];
+        if (!isValidAgent(value)) {
+          throw new Error(`Invalid agent: ${value}`);
+        }
+        selected.push(value);
+      }
+      options.agentFilter = selected;
+    }
+  }
+  return options;
+}
+async function listLocal(scope, agentFilter) {
+  const installed = getInstalledEntries(scope).sort((left, right) => left.slug.localeCompare(right.slug));
+  if (installed.length === 0) {
+    p3.log.info(
+      scope === "global" ? "No global skills installed." : "No project skills installed."
+    );
+    return;
+  }
+  const visibleSkills = (await Promise.all(installed.map((entry) => resolveVisibleInstall(entry)))).filter((entry) => Boolean(entry));
+  const filtered = agentFilter ? visibleSkills.filter(
+    (entry) => entry.activeAgents.some((agent) => agentFilter.includes(agent))
+  ) : visibleSkills;
+  if (filtered.length === 0) {
+    p3.log.info("No skills matched the selected filters.");
+    return;
+  }
+  p3.log.info(pc3.bold(`${scope === "global" ? "Global" : "Project"} skills (${filtered.length}):`));
+  console.log();
+  for (const entry of filtered) {
+    const folder = entry.isZip ? pc3.dim(" [folder]") : "";
+    console.log(`  ${pc3.cyan(entry.slug)} \u2014 ${entry.name}${folder}`);
+    console.log(`    ${pc3.dim(entry.displayPath)}`);
+    console.log(
+      `    ${pc3.dim(`agents: ${entry.activeAgents.map((agent) => agents[agent].displayName).join(", ")}`)}`
+    );
+    console.log(`    ${pc3.dim(`sha256: ${entry.sha256.slice(0, 16)}...`)}`);
+    console.log();
+  }
+}
+async function listRemote(options) {
+  const spinner5 = p3.spinner();
+  spinner5.start("Fetching skills from marketplace...");
+  const result = await listSkills({
+    category: options.category || void 0,
+    search: options.search || void 0,
+    limit: 50
+  });
+  spinner5.stop(`Showing ${result.skills.length} verified skill(s).`);
+  if (result.skills.length === 0) {
+    p3.log.warn("No skills found.");
+    return;
+  }
+  const installed = new Set(getInstalledEntries("all").map((entry) => entry.slug));
+  console.log();
+  for (const skill of result.skills) {
+    const status = installed.has(skill.slug) ? pc3.green(" [installed]") : "";
+    const category = skill.category ? pc3.dim(` [${skill.category}]`) : "";
+    const risk = skill.risk_tier ? pc3.dim(` risk:${skill.risk_tier}`) : "";
+    console.log(`  ${pc3.cyan(skill.slug)}${category}${risk}${status}`);
+    console.log(`    ${skill.description}`);
+    const warnings = [];
+    if (skill.capabilities.requires_private_keys) warnings.push("private-keys");
+    if (skill.capabilities.can_sign_transactions) warnings.push("sign-tx");
+    if (skill.capabilities.uses_leverage) warnings.push("leverage");
+    if (warnings.length > 0) {
+      console.log(`    ${pc3.yellow(`caps: ${warnings.join(", ")}`)}`);
+    }
+    console.log();
+  }
+}
+async function resolveVisibleInstall(entry) {
+  const canonicalExists = await pathExists(entry.canonical_path);
+  const activeAgents = [];
+  let displayPath = canonicalExists ? entry.canonical_path : "";
+  for (const [agentName, install] of Object.entries(entry.agent_installs)) {
+    if (install.kind === "canonical") {
+      if (canonicalExists) {
+        activeAgents.push(agentName);
+      }
+      continue;
+    }
+    if (await pathExists(install.path)) {
+      activeAgents.push(agentName);
+      if (!displayPath) {
+        displayPath = install.path;
+      }
+    }
+  }
+  if (activeAgents.length === 0) {
+    return void 0;
+  }
+  return {
+    slug: entry.slug,
+    name: entry.name,
+    sha256: entry.sha256,
+    isZip: entry.is_zip,
+    displayPath,
+    activeAgents
+  };
+}
+var init_list = __esm({
+  "src/commands/list.ts"() {
+    "use strict";
+    init_api();
+    init_agents();
+    init_installer();
+    init_lock();
+  }
+});
+
+// src/commands/find.ts
+var find_exports = {};
+__export(find_exports, {
+  findCommand: () => findCommand
+});
+async function findCommand(args) {
+  let search;
+  let category;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if ((arg === "--category" || arg === "-c") && args[i + 1] && !args[i + 1].startsWith("-")) {
+      category = args[++i];
+    } else if (!arg.startsWith("-") && search === void 0) {
+      search = arg;
+    }
+  }
+  const options = { showRemote: true, global: false, search, category };
+  await listRemote(options);
+}
+var init_find = __esm({
+  "src/commands/find.ts"() {
+    "use strict";
+    init_list();
+  }
+});
+
+// src/commands/info.ts
+var info_exports = {};
+__export(info_exports, {
+  infoCommand: () => infoCommand
+});
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
+async function infoCommand(args) {
+  const slug = args.filter((arg) => !arg.startsWith("-"))[0];
+  if (!slug) {
+    p4.log.error("Usage: heurist-skills info <slug>");
+    return;
+  }
+  const spinner5 = p4.spinner();
+  spinner5.start(`Fetching info for ${pc4.cyan(slug)}`);
+  let detail;
+  try {
+    detail = await getSkill(slug);
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("API error 404")) {
+      spinner5.stop(`Skill ${pc4.red(slug)} not found.`);
+      throw new Error(`Skill ${slug} not found.`);
+    }
+    spinner5.stop(`Failed to fetch info for ${pc4.cyan(slug)}.`);
+    throw err;
+  }
+  spinner5.stop(`${pc4.bold(detail.slug)}`);
+  console.log();
+  console.log(`  ${pc4.bold("Name:")}         ${detail.name}`);
+  console.log(`  ${pc4.bold("Slug:")}         ${detail.slug}`);
+  console.log(`  ${pc4.bold("Description:")}  ${detail.description}`);
+  console.log(`  ${pc4.bold("Category:")}     ${detail.category || "\u2014"}`);
+  console.log(`  ${pc4.bold("Risk Tier:")}    ${detail.risk_tier || "\u2014"}`);
+  console.log(`  ${pc4.bold("Status:")}       ${detail.verification_status}`);
+  console.log(`  ${pc4.bold("Source:")}       ${detail.source_url || "\u2014"}`);
+  if (detail.author?.display_name) {
+    console.log(`  ${pc4.bold("Author:")}       ${detail.author.display_name}`);
+  }
+  if (detail.author?.github_username) {
+    console.log(`  ${pc4.bold("GitHub:")}       ${detail.author.github_username}`);
+  }
+  console.log();
+  console.log(`  ${pc4.bold("Capabilities:")}`);
+  const caps = detail.capabilities;
+  const capList = [
+    ["requires_secrets", caps.requires_secrets],
+    ["requires_private_keys", caps.requires_private_keys],
+    ["requires_exchange_api_keys", caps.requires_exchange_api_keys],
+    ["can_sign_transactions", caps.can_sign_transactions],
+    ["uses_leverage", caps.uses_leverage],
+    ["accesses_user_portfolio", caps.accesses_user_portfolio]
+  ];
+  for (const [name, value] of capList) {
+    console.log(`    ${name}: ${value ? pc4.yellow("yes") : pc4.dim("no")}`);
+  }
+  try {
+    const filesInfo = await listSkillFiles(slug);
+    console.log();
+    console.log(`  ${pc4.bold("Files:")} (${filesInfo.file_count})`);
+    for (const file of filesInfo.files) {
+      console.log(`    ${pc4.dim(file.path)}`);
+    }
+  } catch {
+  }
+  const installed = getInstalledEntries("all").filter((entry) => entry.slug === slug);
+  if (installed.length > 0) {
+    console.log();
+    console.log(`  ${pc4.bold("Installed:")}`);
+    for (const entry of installed) {
+      const canonicalExists = await pathExists(entry.canonical_path);
+      const activeAgents = Object.entries(entry.agent_installs).filter(([, install]) => {
+        if (!install) return false;
+        if (install.kind === "canonical") {
+          return canonicalExists;
+        }
+        return true;
+      }).map(([agent]) => agents[agent].displayName);
+      console.log(`    ${entry.scope}: ${pc4.dim(entry.canonical_path)}`);
+      console.log(`      sha256: ${pc4.dim(`${entry.sha256.slice(0, 32)}...`)}`);
+      if (activeAgents.length > 0) {
+        console.log(`      agents: ${pc4.dim(activeAgents.join(", "))}`);
+      }
+    }
+  }
+  console.log();
+}
+var init_info = __esm({
+  "src/commands/info.ts"() {
+    "use strict";
+    init_api();
+    init_agents();
+    init_installer();
+    init_lock();
+  }
+});
+
+// src/commands/check-updates.ts
+var check_updates_exports = {};
+__export(check_updates_exports, {
+  checkUpdatesCommand: () => checkUpdatesCommand
+});
+import * as p5 from "@clack/prompts";
+import pc5 from "picocolors";
+async function checkUpdatesCommand(_args) {
+  const installed = getInstalledEntries("all");
+  if (installed.length === 0) {
+    p5.log.info("No skills installed. Nothing to check.");
+    return;
+  }
+  const spinner5 = p5.spinner();
+  spinner5.start(
+    `Checking updates for ${installed.length} installed skill(s)...`
+  );
+  const uniqueInstalled = Array.from(
+    new Map(
+      installed.map((entry) => [`${entry.slug}:${entry.sha256}`, {
+        slug: entry.slug,
+        sha256: entry.sha256
+      }])
+    ).values()
+  );
+  const updates = await checkUpdates(uniqueInstalled);
+  const updatesBySlug = new Map(
+    updates.map((update) => [update.slug, update.approved_sha256])
+  );
+  const outdated = installed.filter((entry) => {
+    const approvedSha = updatesBySlug.get(entry.slug);
+    return approvedSha && approvedSha !== entry.sha256;
+  });
+  if (outdated.length === 0) {
+    spinner5.stop(pc5.green("All skills are up to date."));
+    return;
+  }
+  spinner5.stop(pc5.yellow(`${outdated.length} update(s) available:`));
+  console.log();
+  for (const entry of outdated) {
+    const approvedSha = updatesBySlug.get(entry.slug) || "unknown";
+    console.log(`  ${pc5.cyan(entry.slug)} ${pc5.dim(`[${entry.scope}]`)}`);
+    console.log(`    current: ${pc5.dim(entry.sha256.slice(0, 16))}...`);
+    console.log(`    latest:  ${pc5.dim(approvedSha.slice(0, 16))}...`);
+    console.log();
+  }
+  p5.log.info(
+    `Run ${pc5.cyan("heurist-skills add <slug>")} with the original scope to reinstall an approved update.`
+  );
+}
+var init_check_updates = __esm({
+  "src/commands/check-updates.ts"() {
+    "use strict";
+    init_api();
+    init_lock();
+  }
+});
+
+// src/cli.ts
+import "dotenv/config";
+import * as p6 from "@clack/prompts";
+import pc6 from "picocolors";
+var VERSION = "0.1.0";
+var LOGO = `
+${pc6.cyan("\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}
+${pc6.cyan("\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D")}
+${pc6.cyan("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551")}
+${pc6.cyan("\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551")}
+${pc6.cyan("\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551")}
+${pc6.cyan("\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D")}
+${pc6.dim(`  skills v${VERSION}`)}
+`;
+function printHelp() {
+  console.log(LOGO);
+  console.log(`${pc6.bold("Usage:")} heurist-skills <command> [options]`);
+  console.log();
+  console.log(`${pc6.bold("Commands:")}`);
+  console.log(`  ${pc6.cyan("add")} <slug>          Install a skill from the marketplace  (aliases: install)`);
+  console.log(`  ${pc6.cyan("remove")} <slug>       Uninstall a skill                    (aliases: rm, uninstall)`);
+  console.log(`  ${pc6.cyan("list")}                List project-installed skills          (aliases: ls)`);
+  console.log(`  ${pc6.cyan("list")} --global       List global-installed skills`);
+  console.log(`  ${pc6.cyan("find")} [query]        Search the skill marketplace          (aliases: search, f)`);
+  console.log(`  ${pc6.cyan("info")} <slug>         Show detailed skill info              (aliases: show)`);
+  console.log(`  ${pc6.cyan("check")}               Check for available updates           (aliases: check-updates, update-check)`);
+  console.log(`  ${pc6.cyan("help")}                Show this help`);
+  console.log();
+  console.log(`${pc6.bold("Options:")}`);
+  console.log(`  ${pc6.dim("-g, --global")}         Use the global scope (~/.agents/skills/)`);
+  console.log(`  ${pc6.dim("-a, --agent <agent>")}  Target or filter specific agents`);
+  console.log(`  ${pc6.dim("--copy")}               Copy files instead of symlinking`);
+  console.log(`  ${pc6.dim("-y, --yes")}            Skip confirmation prompts`);
+  console.log(`  ${pc6.dim("--category, -c")}       Filter by category (use with find/list --remote)`);
+  console.log(`  ${pc6.dim("--search, -s")}         Filter by search term (use with list --remote)`);
+  console.log();
+  console.log(`${pc6.bold("Environment:")}`);
+  console.log(`  ${pc6.dim("HEURIST_SKILLS_API")}   Override marketplace API URL`);
+  console.log(`                       ${pc6.dim("(default: https://mesh.heurist.ai)")}`);
+  console.log();
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const commandArgs = args.slice(1);
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  if (command === "--version" || command === "-v") {
+    console.log(VERSION);
+    return;
+  }
+  p6.intro(pc6.cyan("heurist-skills"));
+  try {
+    switch (command) {
+      case "add":
+      case "install": {
+        const { addCommand: addCommand2 } = await Promise.resolve().then(() => (init_add(), add_exports));
+        await addCommand2(commandArgs);
+        break;
+      }
+      case "remove":
+      case "uninstall":
+      case "rm": {
+        const { removeCommand: removeCommand2 } = await Promise.resolve().then(() => (init_remove(), remove_exports));
+        await removeCommand2(commandArgs);
+        break;
+      }
+      case "list":
+      case "ls": {
+        const { listCommand: listCommand2 } = await Promise.resolve().then(() => (init_list(), list_exports));
+        await listCommand2(commandArgs);
+        break;
+      }
+      case "find":
+      case "f":
+      case "search": {
+        const { findCommand: findCommand2 } = await Promise.resolve().then(() => (init_find(), find_exports));
+        await findCommand2(commandArgs);
+        break;
+      }
+      case "info":
+      case "show": {
+        const { infoCommand: infoCommand2 } = await Promise.resolve().then(() => (init_info(), info_exports));
+        await infoCommand2(commandArgs);
+        break;
+      }
+      case "check":
+      case "check-updates":
+      case "update-check": {
+        const { checkUpdatesCommand: checkUpdatesCommand2 } = await Promise.resolve().then(() => (init_check_updates(), check_updates_exports));
+        await checkUpdatesCommand2(commandArgs);
+        break;
+      }
+      default:
+        p6.log.error(`Unknown command: ${pc6.red(command)}`);
+        console.log();
+        printHelp();
+        process.exit(1);
+    }
+  } catch (err) {
+    p6.log.error(err.message);
+    process.exit(1);
+  }
+  p6.outro(pc6.dim("Done."));
+}
+main();