@caik.dev/cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -2,9 +2,9 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname5, join as join8 } from "path";
 import chalk2 from "chalk";
 
 // src/errors.ts
@@ -186,6 +186,9 @@ function error(msg) {
 function info(msg) {
   return chalk.cyan(`\u2192 ${msg}`);
 }
+function warn(msg) {
+  return chalk.yellow(`\u26A0 ${msg}`);
+}
 function dim(msg) {
   return chalk.dim(msg);
 }
@@ -291,17 +294,908 @@ ${result.total} result${result.total !== 1 ? "s" : ""} found.`);
 }
 
 // src/commands/install.ts
+import { existsSync as existsSync7 } from "fs";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname3, resolve } from "path";
+import { execSync as execSync3 } from "child_process";
+import { createInterface } from "readline/promises";
+
+// src/platform/detect.ts
 import { existsSync as existsSync2 } from "fs";
-import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { dirname, resolve } from "path";
 import { execSync } from "child_process";
-import { createInterface } from "readline/promises";
-function detectPlatform() {
-  if (existsSync2(".claude") || existsSync2("CLAUDE.md")) return "claude";
-  if (existsSync2(".cursor")) return "cursor";
-  if (existsSync2("node_modules") || existsSync2("package.json")) return "node";
-  return void 0;
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectClaudeCode() {
+  const home = homedir2();
+  const claudeDir = join2(home, ".claude");
+  if (!existsSync2(claudeDir)) return null;
+  const hasSettings = existsSync2(join2(claudeDir, "settings.json"));
+  const hasMcpConfig = existsSync2(join2(claudeDir, "mcp.json"));
+  const hasAnyMarker = hasSettings || hasMcpConfig || existsSync2(join2(claudeDir, "statsig"));
+  if (!hasAnyMarker) return null;
+  const configPaths = [];
+  if (hasSettings) configPaths.push(join2(claudeDir, "settings.json"));
+  if (hasMcpConfig) configPaths.push(join2(claudeDir, "mcp.json"));
+  return {
+    name: "claude-code",
+    tier: "full-plugin",
+    configPaths,
+    capabilities: { hooks: true, mcp: true, skills: true }
+  };
+}
+function detectOpenClaw() {
+  const home = homedir2();
+  const openclawDir = join2(home, ".openclaw");
+  const cwdConfig = join2(process.cwd(), "openclaw.json");
+  if (!existsSync2(openclawDir) && !existsSync2(cwdConfig)) return null;
+  const configPaths = [];
+  if (existsSync2(cwdConfig)) configPaths.push(cwdConfig);
+  if (existsSync2(join2(openclawDir, "openclaw.json"))) {
+    configPaths.push(join2(openclawDir, "openclaw.json"));
+  }
+  return {
+    name: "openclaw",
+    tier: "hook-enabled",
+    configPaths,
+    capabilities: { hooks: true, mcp: true, skills: true }
+  };
+}
+function detectCursor() {
+  const home = homedir2();
+  const cursorDir = join2(home, ".cursor");
+  const cwdCursor = join2(process.cwd(), ".cursor");
+  if (!existsSync2(cursorDir) && !existsSync2(cwdCursor)) return null;
+  const configPaths = [];
+  if (existsSync2(join2(cwdCursor, "mcp.json"))) {
+    configPaths.push(join2(cwdCursor, "mcp.json"));
+  }
+  if (existsSync2(join2(cursorDir, "mcp.json"))) {
+    configPaths.push(join2(cursorDir, "mcp.json"));
+  }
+  return {
+    name: "cursor",
+    tier: "hook-enabled",
+    configPaths,
+    capabilities: { hooks: true, mcp: true, skills: true }
+  };
+}
+function detectCodex() {
+  if (!commandExists("codex")) return null;
+  return {
+    name: "codex",
+    tier: "cli-mcp",
+    configPaths: [],
+    capabilities: { hooks: false, mcp: true, skills: false }
+  };
+}
+function detectWindsurf() {
+  const home = homedir2();
+  const windsurfDir = join2(home, ".windsurf");
+  const cwdWindsurf = join2(process.cwd(), ".windsurf");
+  if (!existsSync2(windsurfDir) && !existsSync2(cwdWindsurf)) return null;
+  const configPaths = [];
+  if (existsSync2(join2(cwdWindsurf, "mcp.json"))) {
+    configPaths.push(join2(cwdWindsurf, "mcp.json"));
+  }
+  return {
+    name: "windsurf",
+    tier: "cli-mcp",
+    configPaths,
+    capabilities: { hooks: false, mcp: true, skills: false }
+  };
+}
+var detectors = [
+  detectClaudeCode,
+  detectOpenClaw,
+  detectCursor,
+  detectCodex,
+  detectWindsurf
+];
+function detectPlatforms() {
+  const detected = [];
+  for (const detect of detectors) {
+    try {
+      const result = detect();
+      if (result) detected.push(result);
+    } catch {
+    }
+  }
+  return detected;
+}
+
+// src/platform/registry.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { join as join3 } from "path";
+var REGISTRY_VERSION = 1;
+function getRegistryPath() {
+  return join3(getConfigDir(), "registry.json");
+}
+function emptyRegistry() {
+  return { version: REGISTRY_VERSION, entries: [] };
+}
+function readRegistry() {
+  const path = getRegistryPath();
+  if (!existsSync3(path)) return emptyRegistry();
+  try {
+    const raw = readFileSync2(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.entries || !Array.isArray(parsed.entries)) return emptyRegistry();
+    return parsed;
+  } catch {
+    return emptyRegistry();
+  }
+}
+function writeRegistry(registry) {
+  const dir = getConfigDir();
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true, mode: 448 });
+  }
+  const path = getRegistryPath();
+  writeFileSync2(path, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+}
+function upsertRegistryEntry(entry) {
+  const registry = readRegistry();
+  const idx = registry.entries.findIndex(
+    (e) => e.slug === entry.slug && e.platform === entry.platform
+  );
+  if (idx >= 0) {
+    registry.entries[idx] = entry;
+  } else {
+    registry.entries.push(entry);
+  }
+  writeRegistry(registry);
+}
+function removeRegistryEntry(slug, platform) {
+  const registry = readRegistry();
+  const idx = registry.entries.findIndex(
+    (e) => e.slug === slug && e.platform === platform
+  );
+  if (idx < 0) return null;
+  const [removed] = registry.entries.splice(idx, 1);
+  writeRegistry(registry);
+  return removed;
+}
+function findRegistryEntry(slug, platform) {
+  const registry = readRegistry();
+  return registry.entries.find(
+    (e) => e.slug === slug && (!platform || e.platform === platform)
+  ) ?? null;
+}
+function listRegistryEntries(platform) {
+  const registry = readRegistry();
+  if (!platform) return registry.entries;
+  return registry.entries.filter((e) => e.platform === platform);
+}
+function cleanupFiles(entry) {
+  const failed = [];
+  for (const file of entry.files) {
+    try {
+      if (existsSync3(file)) {
+        unlinkSync(file);
+      }
+    } catch {
+      failed.push(file);
+    }
+  }
+  return failed;
+}
+
+// src/platform/claude-code.ts
+import {
+  existsSync as existsSync4,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3,
+  mkdirSync as mkdirSync3,
+  readdirSync,
+  rmSync
+} from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+var MCP_KEY = "caik";
+var ClaudeCodeAdapter = class {
+  name = "claude-code";
+  tier = "full-plugin";
+  get claudeDir() {
+    return join4(homedir3(), ".claude");
+  }
+  get mcpPath() {
+    return join4(this.claudeDir, "mcp.json");
+  }
+  get settingsPath() {
+    return join4(this.claudeDir, "settings.json");
+  }
+  get skillsDir() {
+    return join4(this.claudeDir, "skills", "caik");
+  }
+  get pluginsCacheDir() {
+    return join4(this.claudeDir, "plugins", "cache");
+  }
+  // ---------------------------------------------------------------------------
+  // JSON helpers
+  // ---------------------------------------------------------------------------
+  readJson(path) {
+    if (!existsSync4(path)) return {};
+    try {
+      const raw = readFileSync3(path, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  writeJson(path, data) {
+    const dir = join4(path, "..");
+    if (!existsSync4(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync3(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  }
+  // ---------------------------------------------------------------------------
+  // Plugin detection
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if CAIK is installed as a Claude Code plugin.
+   * Looks for "caik" in enabledPlugins in settings.json, or for a caik
+   * directory in the plugins cache.
+   */
+  isPluginInstalled() {
+    const settings = this.readJson(this.settingsPath);
+    const enabledPlugins = settings.enabledPlugins;
+    if (enabledPlugins) {
+      for (const key of Object.keys(enabledPlugins)) {
+        if (key.toLowerCase().includes("caik") && enabledPlugins[key] !== false) {
+          return true;
+        }
+      }
+    }
+    if (existsSync4(this.pluginsCacheDir)) {
+      try {
+        const publishers = readdirSync(this.pluginsCacheDir);
+        for (const publisher of publishers) {
+          const publisherDir = join4(this.pluginsCacheDir, publisher);
+          const caikDir = join4(publisherDir, "caik");
+          if (existsSync4(caikDir)) {
+            return true;
+          }
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns the current install method:
+   * - "plugin" if CAIK plugin is installed via marketplace
+   * - "manual" if CAIK is registered in mcp.json manually
+   * - "none" if not installed
+   */
+  getInstallMethod() {
+    if (this.isPluginInstalled()) return "plugin";
+    if (existsSync4(this.mcpPath)) {
+      const config = this.readJson(this.mcpPath);
+      const servers = config.mcpServers;
+      if (servers && MCP_KEY in servers) return "manual";
+    }
+    return "none";
+  }
+  // ---------------------------------------------------------------------------
+  // PlatformAdapter implementation
+  // ---------------------------------------------------------------------------
+  async detect() {
+    if (!existsSync4(this.claudeDir)) return null;
+    const hasSettings = existsSync4(this.settingsPath);
+    const hasMcp = existsSync4(this.mcpPath);
+    const hasStatsig = existsSync4(join4(this.claudeDir, "statsig"));
+    if (!hasSettings && !hasMcp && !hasStatsig) return null;
+    const configPaths = [];
+    if (hasSettings) configPaths.push(this.settingsPath);
+    if (hasMcp) configPaths.push(this.mcpPath);
+    return {
+      name: this.name,
+      tier: this.tier,
+      configPaths,
+      capabilities: { hooks: true, mcp: true, skills: true }
+    };
+  }
+  async registerMcp(serverConfig) {
+    if (this.isPluginInstalled()) {
+      console.log(
+        "CAIK plugin is installed \u2014 MCP server is managed by the plugin."
+      );
+      return;
+    }
+    const config = this.readJson(this.mcpPath);
+    const servers = config.mcpServers ?? {};
+    servers[MCP_KEY] = {
+      command: serverConfig.command,
+      args: serverConfig.args,
+      ...serverConfig.env && Object.keys(serverConfig.env).length > 0 ? { env: serverConfig.env } : {}
+    };
+    config.mcpServers = servers;
+    this.writeJson(this.mcpPath, config);
+  }
+  async unregisterMcp() {
+    if (!existsSync4(this.mcpPath)) return;
+    const config = this.readJson(this.mcpPath);
+    const servers = config.mcpServers;
+    if (!servers || !(MCP_KEY in servers)) return;
+    delete servers[MCP_KEY];
+    config.mcpServers = servers;
+    this.writeJson(this.mcpPath, config);
+  }
+  async registerHooks(hookConfig) {
+    if (this.isPluginInstalled()) {
+      console.log(
+        "CAIK plugin is installed \u2014 hooks are managed by the plugin."
+      );
+      return;
+    }
+    const settings = this.readJson(this.settingsPath);
+    const existingHooks = settings.hooks ?? {};
+    for (const [event, entries] of Object.entries(hookConfig.hooks)) {
+      const newEntries = Array.isArray(entries) ? entries : [entries];
+      const existing = Array.isArray(existingHooks[event]) ? existingHooks[event] : [];
+      const filtered = existing.filter((group) => {
+        if (typeof group === "object" && group !== null) {
+          const g = group;
+          if (Array.isArray(g.hooks)) {
+            const hasCAIK = g.hooks.some(
+              (h) => typeof h.command === "string" && h.command.includes("caik")
+            );
+            if (hasCAIK) return false;
+          }
+          if ("command" in g) {
+            return !g.command.includes("caik");
+          }
+        }
+        return true;
+      });
+      const wrappedEntries = newEntries.map((entry) => {
+        if (typeof entry === "object" && entry !== null) {
+          const e = entry;
+          const hookEntry = {
+            type: "command",
+            timeout: 10,
+            ...e
+          };
+          return { hooks: [hookEntry] };
+        }
+        return entry;
+      });
+      existingHooks[event] = [...filtered, ...wrappedEntries];
+    }
+    settings.hooks = existingHooks;
+    this.writeJson(this.settingsPath, settings);
+  }
+  async unregisterHooks() {
+    if (!existsSync4(this.settingsPath)) return;
+    const settings = this.readJson(this.settingsPath);
+    const hooks = settings.hooks;
+    if (!hooks) return;
+    for (const event of Object.keys(hooks)) {
+      const entries = hooks[event];
+      if (!Array.isArray(entries)) continue;
+      hooks[event] = entries.filter((group) => {
+        if (typeof group === "object" && group !== null) {
+          const g = group;
+          if (Array.isArray(g.hooks)) {
+            const hasCAIK = g.hooks.some(
+              (h) => typeof h.command === "string" && h.command.includes("caik")
+            );
+            if (hasCAIK) return false;
+          }
+          if ("command" in g) {
+            return !g.command.includes("caik");
+          }
+        }
+        return true;
+      });
+      if (hooks[event].length === 0) {
+        delete hooks[event];
+      }
+    }
+    if (Object.keys(hooks).length === 0) {
+      delete settings.hooks;
+    } else {
+      settings.hooks = hooks;
+    }
+    this.writeJson(this.settingsPath, settings);
+  }
+  async installSkill(slug, content, files) {
+    const skillDir = join4(this.skillsDir, slug);
+    if (!existsSync4(skillDir)) {
+      mkdirSync3(skillDir, { recursive: true });
+    }
+    writeFileSync3(join4(skillDir, "SKILL.md"), content, "utf-8");
+    if (files) {
+      for (const file of files) {
+        const filePath = join4(skillDir, file.path);
+        const fileDir = join4(filePath, "..");
+        if (!existsSync4(fileDir)) {
+          mkdirSync3(fileDir, { recursive: true });
+        }
+        writeFileSync3(filePath, file.content, "utf-8");
+      }
+    }
+  }
+  async uninstallSkill(slug) {
+    const skillDir = join4(this.skillsDir, slug);
+    if (!existsSync4(skillDir)) return;
+    try {
+      rmSync(skillDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  getConfigPath() {
+    return this.mcpPath;
+  }
+  async readConfig() {
+    return this.readJson(this.mcpPath);
+  }
+  async isRegistered() {
+    if (this.isPluginInstalled()) return true;
+    if (!existsSync4(this.mcpPath)) return false;
+    const config = this.readJson(this.mcpPath);
+    const servers = config.mcpServers;
+    return !!servers && MCP_KEY in servers;
+  }
+};
+
+// src/platform/openclaw.ts
+import {
+  existsSync as existsSync5,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync4,
+  mkdirSync as mkdirSync4,
+  rmSync as rmSync2
+} from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join5, dirname } from "path";
+import { homedir as homedir4 } from "os";
+var MCP_KEY2 = "caik";
+var OpenClawAdapter = class {
+  name = "openclaw";
+  tier = "hook-enabled";
+  // --- Path helpers --------------------------------------------------------
+  get openclawDir() {
+    return join5(homedir4(), ".openclaw");
+  }
+  /** OpenClaw's own config — NOT where MCP servers go. */
+  get openclawConfigPath() {
+    return join5(this.openclawDir, "openclaw.json");
+  }
+  /** Project-level `.mcp.json` — where MCP servers are registered. */
+  get mcpConfigPath() {
+    return join5(process.cwd(), ".mcp.json");
+  }
+  /** Skills directory following OpenClaw convention. */
+  get skillsBaseDir() {
+    return join5(homedir4(), ".agents", "skills");
+  }
+  get skillDir() {
+    return join5(this.skillsBaseDir, "caik");
+  }
+  get skillLockPath() {
+    return join5(homedir4(), ".agents", ".skill-lock.json");
+  }
+  // --- JSON helpers --------------------------------------------------------
+  readJson(path) {
+    if (!existsSync5(path)) return {};
+    try {
+      const raw = readFileSync4(path, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  writeJson(path, data) {
+    const dir = dirname(path);
+    if (!existsSync5(dir)) {
+      mkdirSync4(dir, { recursive: true });
+    }
+    writeFileSync4(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  }
+  readSkillLock() {
+    if (!existsSync5(this.skillLockPath)) {
+      return { version: 3, skills: {} };
+    }
+    try {
+      const raw = readFileSync4(this.skillLockPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return {
+        version: parsed.version ?? 3,
+        skills: parsed.skills ?? {}
+      };
+    } catch {
+      return { version: 3, skills: {} };
+    }
+  }
+  writeSkillLock(lock) {
+    const dir = dirname(this.skillLockPath);
+    if (!existsSync5(dir)) {
+      mkdirSync4(dir, { recursive: true });
+    }
+    writeFileSync4(
+      this.skillLockPath,
+      JSON.stringify(lock, null, 2) + "\n",
+      "utf-8"
+    );
+  }
+  /** Check if `openclaw` binary is in PATH. */
+  isInPath() {
+    try {
+      execSync2("which openclaw", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- PlatformAdapter implementation --------------------------------------
+  async detect() {
+    const hasDir = existsSync5(this.openclawDir);
+    const inPath = this.isInPath();
+    if (!hasDir && !inPath) return null;
+    const configPaths = [];
+    if (existsSync5(this.openclawConfigPath)) {
+      configPaths.push(this.openclawConfigPath);
+    }
+    if (existsSync5(this.mcpConfigPath)) {
+      configPaths.push(this.mcpConfigPath);
+    }
+    return {
+      name: this.name,
+      tier: this.tier,
+      configPaths,
+      capabilities: { hooks: true, mcp: true, skills: true }
+    };
+  }
+  async registerMcp(serverConfig) {
+    const config = this.readJson(this.mcpConfigPath);
+    const servers = config.mcpServers ?? {};
+    servers[MCP_KEY2] = {
+      type: "stdio",
+      command: serverConfig.command,
+      args: serverConfig.args,
+      ...serverConfig.env && Object.keys(serverConfig.env).length > 0 ? { env: serverConfig.env } : {}
+    };
+    config.mcpServers = servers;
+    this.writeJson(this.mcpConfigPath, config);
+  }
+  async unregisterMcp() {
+    if (!existsSync5(this.mcpConfigPath)) return;
+    const config = this.readJson(this.mcpConfigPath);
+    const servers = config.mcpServers;
+    if (!servers || !(MCP_KEY2 in servers)) return;
+    delete servers[MCP_KEY2];
+    config.mcpServers = servers;
+    this.writeJson(this.mcpConfigPath, config);
+  }
+  async registerHooks(_hookConfig) {
+    console.error(
+      "[caik] To enable CAIK telemetry hooks in OpenClaw, install the CAIK hook pack:\n    openclaw hooks install @caik.dev/openclaw-hooks\n  (Hook pack not yet available \u2014 hooks are optional, CAIK works without them.)"
+    );
+  }
+  async unregisterHooks() {
+    console.error(
+      "[caik] To remove CAIK hooks from OpenClaw, run:\n    openclaw hooks uninstall @caik.dev/openclaw-hooks"
+    );
+  }
+  async installSkill(_slug, content, files) {
+    if (!existsSync5(this.skillDir)) {
+      mkdirSync4(this.skillDir, { recursive: true });
+    }
+    writeFileSync4(join5(this.skillDir, "SKILL.md"), content, "utf-8");
+    if (files) {
+      for (const file of files) {
+        const filePath = join5(this.skillDir, file.path);
+        const fileDir = dirname(filePath);
+        if (!existsSync5(fileDir)) {
+          mkdirSync4(fileDir, { recursive: true });
+        }
+        writeFileSync4(filePath, file.content, "utf-8");
+      }
+    }
+    const lock = this.readSkillLock();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = lock.skills["caik"];
+    lock.skills["caik"] = {
+      source: "@caik.dev/cli",
+      sourceType: "local",
+      sourceUrl: "",
+      skillPath: "skills/caik/SKILL.md",
+      skillFolderHash: "",
+      installedAt: existing?.installedAt ?? now,
+      updatedAt: now
+    };
+    this.writeSkillLock(lock);
+  }
+  async uninstallSkill(_slug) {
+    if (existsSync5(this.skillDir)) {
+      try {
+        rmSync2(this.skillDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    const lock = this.readSkillLock();
+    if ("caik" in lock.skills) {
+      delete lock.skills["caik"];
+      this.writeSkillLock(lock);
+    }
+  }
+  getConfigPath() {
+    return this.openclawConfigPath;
+  }
+  async readConfig() {
+    return this.readJson(this.openclawConfigPath);
+  }
+  async isRegistered() {
+    if (!existsSync5(this.mcpConfigPath)) return false;
+    const config = this.readJson(this.mcpConfigPath);
+    const servers = config.mcpServers;
+    return !!servers && MCP_KEY2 in servers;
+  }
+};
+
+// src/platform/cursor.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5, rmSync as rmSync3 } from "fs";
+import { join as join6, dirname as dirname2 } from "path";
+import { homedir as homedir5 } from "os";
+var MCP_KEY3 = "caik";
+function readJsonFile(path) {
+  try {
+    if (!existsSync6(path)) return null;
+    const raw = readFileSync5(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(path, data) {
+  mkdirSync5(dirname2(path), { recursive: true });
+  writeFileSync5(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+var CursorAdapter = class {
+  name = "cursor";
+  tier = "hook-enabled";
+  /** Project-level .cursor dir (preferred for MCP config). */
+  get projectDir() {
+    return join6(process.cwd(), ".cursor");
+  }
+  /** Global ~/.cursor dir. */
+  get globalDir() {
+    return join6(homedir5(), ".cursor");
+  }
+  /** Preferred MCP config path (project-level). */
+  get mcpConfigPath() {
+    return join6(this.projectDir, "mcp.json");
+  }
+  /** Global MCP config path (fallback). */
+  get globalMcpConfigPath() {
+    return join6(this.globalDir, "mcp.json");
+  }
+  /** Hooks config path (project-level). */
+  get hooksConfigPath() {
+    return join6(this.projectDir, "hooks.json");
+  }
+  /** Skills directory. */
+  get skillsDir() {
+    return join6(this.globalDir, "skills", "caik");
+  }
+  // ── Detection ─────────────────────────────────────────────
+  async detect() {
+    const hasGlobal = existsSync6(this.globalDir);
+    const hasProject = existsSync6(this.projectDir);
+    if (!hasGlobal && !hasProject) return null;
+    const configPaths = [];
+    if (existsSync6(this.mcpConfigPath)) configPaths.push(this.mcpConfigPath);
+    if (existsSync6(this.globalMcpConfigPath)) configPaths.push(this.globalMcpConfigPath);
+    return {
+      name: "cursor",
+      tier: "hook-enabled",
+      configPaths,
+      capabilities: { hooks: true, mcp: true, skills: true }
+    };
+  }
+  // ── MCP Registration ──────────────────────────────────────
+  async registerMcp(serverConfig) {
+    const configPath = existsSync6(this.projectDir) ? this.mcpConfigPath : this.globalMcpConfigPath;
+    const config = readJsonFile(configPath) ?? {};
+    config.mcpServers = config.mcpServers ?? {};
+    config.mcpServers[MCP_KEY3] = serverConfig;
+    writeJsonFile(configPath, config);
+  }
+  async unregisterMcp() {
+    for (const configPath of [this.mcpConfigPath, this.globalMcpConfigPath]) {
+      const config = readJsonFile(configPath);
+      if (!config?.mcpServers?.[MCP_KEY3]) continue;
+      delete config.mcpServers[MCP_KEY3];
+      if (Object.keys(config.mcpServers).length === 0) {
+        delete config.mcpServers;
+      }
+      writeJsonFile(configPath, config);
+    }
+  }
+  // ── Hooks ─────────────────────────────────────────────────
+  async registerHooks(_hookConfig) {
+    const defaultHooks = [
+      { event: "sessionStart", script: "npx -y @caik.dev/cli hook cursor-session-start", decision: "allow" },
+      { event: "beforeMCPExecution", script: "npx -y @caik.dev/cli hook cursor-mcp-exec --server=$SERVER --tool=$TOOL", decision: "allow" },
+      { event: "stop", script: "npx -y @caik.dev/cli hook cursor-session-end", decision: "allow" }
+    ];
+    try {
+      const config = readJsonFile(this.hooksConfigPath) ?? {};
+      const existing = config.hooks ?? [];
+      const filtered = existing.filter(
+        (h) => !h.script?.includes("caik") || !h.script?.includes("hook cursor-")
+      );
+      config.hooks = [...filtered, ...defaultHooks];
+      writeJsonFile(this.hooksConfigPath, config);
+    } catch {
+      process.stderr.write(
+        "[caik] Warning: Could not register hooks \u2014 Cursor hooks require v1.7+. Skipping.\n"
+      );
+    }
+  }
+  async unregisterHooks() {
+    try {
+      const config = readJsonFile(this.hooksConfigPath);
+      if (!config?.hooks) return;
+      config.hooks = config.hooks.filter(
+        (h) => !h.script?.includes("caik") || !h.script?.includes("hook cursor-")
+      );
+      if (config.hooks.length === 0) {
+        delete config.hooks;
+      }
+      writeJsonFile(this.hooksConfigPath, config);
+    } catch {
+    }
+  }
+  // ── Skills ────────────────────────────────────────────────
+  async installSkill(slug, content, files) {
+    const skillDir = join6(this.skillsDir, slug);
+    mkdirSync5(skillDir, { recursive: true });
+    writeFileSync5(join6(skillDir, "SKILL.md"), content, "utf-8");
+    if (files) {
+      for (const file of files) {
+        const filePath = join6(skillDir, file.path);
+        mkdirSync5(dirname2(filePath), { recursive: true });
+        writeFileSync5(filePath, file.content, "utf-8");
+      }
+    }
+  }
+  async uninstallSkill(slug) {
+    const skillDir = join6(this.skillsDir, slug);
+    try {
+      if (existsSync6(skillDir)) {
+        rmSync3(skillDir, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+  // ── Config Accessors ──────────────────────────────────────
+  getConfigPath() {
+    if (existsSync6(this.mcpConfigPath)) return this.mcpConfigPath;
+    if (existsSync6(this.globalMcpConfigPath)) return this.globalMcpConfigPath;
+    return this.mcpConfigPath;
+  }
+  async readConfig() {
+    const configPath = this.getConfigPath();
+    return readJsonFile(configPath) ?? {};
+  }
+  async isRegistered() {
+    for (const configPath of [this.mcpConfigPath, this.globalMcpConfigPath]) {
+      const config = readJsonFile(configPath);
+      if (config?.mcpServers?.[MCP_KEY3]) return true;
+    }
+    return false;
+  }
+};
+
+// src/platform/generic.ts
+var GenericAdapter = class {
+  name;
+  tier = "cli-mcp";
+  constructor(name) {
+    this.name = name;
+  }
+  // ── Detection ─────────────────────────────────────────────
+  async detect() {
+    return null;
+  }
+  // ── MCP Registration ──────────────────────────────────────
+  async registerMcp(serverConfig) {
+    const snippet = {
+      mcpServers: {
+        caik: {
+          command: serverConfig.command,
+          args: serverConfig.args,
+          ...serverConfig.env && Object.keys(serverConfig.env).length > 0 ? { env: serverConfig.env } : {}
+        }
+      }
+    };
+    const json = JSON.stringify(snippet, null, 2);
+    process.stdout.write(
+      `
+CAIK MCP server configuration for ${this.name}:
+
+Add the following to your MCP configuration file:
+
+${json}
+
+Refer to your platform's documentation for the correct config file location.
+
+`
+    );
+  }
+  async unregisterMcp() {
+    process.stdout.write(
+      `
+To unregister CAIK from ${this.name}, remove the "caik" entry
+from the "mcpServers" section in your MCP configuration file.
+
+`
+    );
+  }
+  // ── No hooks support ──────────────────────────────────────
+  // registerHooks / unregisterHooks intentionally omitted (cli-mcp tier)
+  // ── No skills support ─────────────────────────────────────
+  // installSkill / uninstallSkill intentionally omitted (cli-mcp tier)
+  // ── Config Accessors ──────────────────────────────────────
+  getConfigPath() {
+    return "";
+  }
+  async readConfig() {
+    return {};
+  }
+  async isRegistered() {
+    return false;
+  }
+};
+
+// src/platform/index.ts
+var adapters = {
+  "claude-code": () => new ClaudeCodeAdapter(),
+  "openclaw": () => new OpenClawAdapter(),
+  "cursor": () => new CursorAdapter(),
+  "codex": () => new GenericAdapter("codex"),
+  "windsurf": () => new GenericAdapter("windsurf"),
+  "generic": () => new GenericAdapter("generic")
+};
+function getPlatformAdapter(name) {
+  const factory = adapters[name];
+  if (!factory) {
+    return new GenericAdapter(name);
+  }
+  return factory();
+}
+function getDefaultMcpConfig() {
+  return {
+    command: "npx",
+    args: ["-y", "@caik.dev/mcp"]
+  };
 }
+
+// src/commands/install.ts
+var legacyPlatformMap = {
+  claude: "claude-code",
+  cursor: "cursor",
+  node: "generic"
+};
 function registerInstallCommand(program2) {
   program2.command("install <slug>").description("Install an artifact from the CAIK registry").option("--platform <platform>", "Target platform (auto-detected if not specified)").option("-y, --yes", "Skip confirmation prompts (for CI/scripting)").addHelpText("after", `
 Examples:
@@ -310,7 +1204,17 @@ Examples:
     const globalOpts = program2.opts();
     const { apiUrl, apiKey } = resolveConfig(globalOpts);
     const client = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
-    const platform = opts.platform ?? detectPlatform();
+    let detectedPlatform;
+    if (opts.platform) {
+      const raw = opts.platform;
+      detectedPlatform = legacyPlatformMap[raw] ?? raw;
+    } else {
+      const detected = detectPlatforms();
+      if (detected.length > 0) {
+        detectedPlatform = detected[0].name;
+      }
+    }
+    const platform = detectedPlatform;
     const spinner = createSpinner(`Fetching ${slug}...`);
     if (!globalOpts.json) spinner.start();
     const params = { platform };
@@ -333,7 +1237,7 @@ Examples:
           spinner.start();
           continue;
         }
-        safeFiles.push({ resolvedPath, content: file.content });
+        safeFiles.push({ resolvedPath, content: file.content ?? "" });
       }
     }
     const hasFiles = safeFiles.length > 0;
@@ -365,15 +1269,15 @@ Examples:
       spinner.start();
     }
     for (const file of safeFiles) {
-      const dir = dirname(file.resolvedPath);
-      if (!existsSync2(dir)) {
-        mkdirSync2(dir, { recursive: true });
+      const dir = dirname3(file.resolvedPath);
+      if (!existsSync7(dir)) {
+        mkdirSync6(dir, { recursive: true });
       }
-      writeFileSync2(file.resolvedPath, file.content, "utf-8");
+      writeFileSync6(file.resolvedPath, file.content, "utf-8");
     }
     if (installInfo.installCommand) {
       try {
-        execSync(installInfo.installCommand, { stdio: "pipe" });
+        execSync3(installInfo.installCommand, { stdio: "pipe" });
       } catch (err) {
         spinner.stop();
         console.error(error(`Install command failed: ${err instanceof Error ? err.message : String(err)}`));
@@ -389,7 +1293,7 @@ Examples:
     }
     if (installInfo.postInstallHook) {
       try {
-        execSync(installInfo.postInstallHook, { stdio: "pipe" });
+        execSync3(installInfo.postInstallHook, { stdio: "pipe" });
       } catch {
       }
     }
@@ -398,6 +1302,31 @@ Examples:
     if (installInfo.contract?.touchedPaths) {
       console.log(info(`Files: ${installInfo.contract.touchedPaths.join(", ")}`));
     }
+    const resolvedPlatform = detectedPlatform ?? "generic";
+    upsertRegistryEntry({
+      slug,
+      version: installInfo.artifact.version ?? "0.0.0",
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      platform: resolvedPlatform,
+      files: safeFiles.map((f) => f.resolvedPath),
+      artifactType: installInfo.artifact.primitive ?? "unknown"
+    });
+    const adapter = getPlatformAdapter(resolvedPlatform);
+    const primitive = installInfo.artifact.primitive;
+    if (primitive === "connector") {
+      try {
+        await adapter.registerMcp(getDefaultMcpConfig());
+      } catch {
+      }
+    }
+    if ((primitive === "executable" || primitive === "composition") && adapter.installSkill) {
+      try {
+        const content = safeFiles.map((f) => f.content).join("\n");
+        await adapter.installSkill(slug, content);
+      } catch {
+      }
+    }
     client.post("/telemetry/install", {
       artifactSlug: slug,
       platform,
@@ -414,7 +1343,7 @@ function registerInitCommand(program2) {
   program2.command("init").description("Configure the CAIK CLI").option("--auth", "Set up authentication (opens browser)").addHelpText("after", `
 Examples:
   caik init
-  caik init --auth`).action(async (opts) => {
+  caik init --auth`).action(async (_opts) => {
     const rl = createInterface2({ input: stdin, output: stdout });
     try {
       const config = readConfig();
@@ -432,12 +1361,36 @@ Examples:
       if (config.apiKey) {
         const client = new CaikApiClient({ apiUrl: config.apiUrl, apiKey: config.apiKey });
         try {
-          const karma = await client.get("/me/karma");
+          await client.get("/me/karma");
           console.log(success("API connection verified \u2014 authenticated"));
         } catch {
           console.log(error("Could not verify API connection. Check your API key."));
         }
       }
+      const detected = detectPlatforms();
+      if (detected.length > 0) {
+        console.log("");
+        console.log(heading("Platform Integration"));
+        console.log("\u2500".repeat(40));
+        for (const p of detected) {
+          console.log(`  ${success(p.name)} detected`);
+        }
+        console.log("");
+        const hasClaude = detected.some((p) => p.name === "claude-code");
+        const hasOpenClaw = detected.some((p) => p.name === "openclaw");
+        if (hasClaude) {
+          console.log(info("Claude Code: Install the CAIK plugin for the best experience:"));
+          console.log(dim("  claude plugin marketplace add https://github.com/caik-dev/claude-code-plugin"));
+          console.log(dim("  claude plugin install caik@caik-dev"));
+          console.log("");
+        }
+        if (hasOpenClaw) {
+          console.log(info("OpenClaw: Add the CAIK MCP server to your project's .mcp.json:"));
+          console.log(dim('  { "mcpServers": { "caik": { "type": "stdio", "command": "npx", "args": ["-y", "@caik.dev/mcp"] } } }'));
+          console.log("");
+        }
+        console.log(info("Or run `caik setup` for interactive platform configuration."));
+      }
     } finally {
       rl.close();
     }
@@ -445,22 +1398,56 @@ Examples:
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 function registerStatusCommand(program2) {
   program2.command("status").description("Show CLI configuration and connectivity status").action(async () => {
     const globalOpts = program2.opts();
-    const config = readConfig();
     const { apiUrl, apiKey } = resolveConfig(globalOpts);
-    if (globalOpts.json) {
-      const data = {
-        apiUrl,
-        apiKeyConfigured: !!apiKey,
-        platforms: {
-          claude: existsSync3(".claude") || existsSync3("CLAUDE.md"),
-          cursor: existsSync3(".cursor"),
-          node: existsSync3("node_modules") || existsSync3("package.json")
-        }
+    const detected = detectPlatforms();
+    const platformResults = [];
+    for (const dp of detected) {
+      const adapter = getPlatformAdapter(dp.name);
+      let registered = false;
+      try {
+        registered = await adapter.isRegistered();
+      } catch {
+      }
+      platformResults.push({
+        name: dp.name,
+        tier: dp.tier,
+        registered,
+        driftWarnings: []
+      });
+    }
+    const registryEntries = listRegistryEntries();
+    const driftEntries = [];
+    for (const entry of registryEntries) {
+      const missing = entry.files.filter((f) => !existsSync8(f));
+      if (missing.length > 0) {
+        driftEntries.push({ slug: entry.slug, missingFiles: missing });
+      }
+    }
+    for (const drift of driftEntries) {
+      const entry = registryEntries.find((e) => e.slug === drift.slug);
+      if (entry) {
+        const pr = platformResults.find((p) => p.name === entry.platform);
+        if (pr) {
+          pr.driftWarnings.push(
+            `${drift.slug}: ${drift.missingFiles.length} missing file(s)`
+          );
+        }
+      }
+    }
+    if (globalOpts.json) {
+      const data = {
+        apiUrl,
+        apiKeyConfigured: !!apiKey,
+        platforms: platformResults,
+        installedArtifacts: registryEntries.length
       };
+      if (driftEntries.length > 0) {
+        data.driftWarnings = driftEntries;
+      }
       const client2 = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
       try {
         if (apiKey) {
@@ -493,15 +1480,26 @@ function registerStatusCommand(program2) {
       console.log(`API Reachable:    ${error("no")}`);
     }
     console.log("");
-    console.log(heading("Local Platforms Detected"));
+    console.log(heading("Platform Integration"));
     console.log("\u2500".repeat(40));
-    const platforms = [
-      { name: "Claude", check: existsSync3(".claude") || existsSync3("CLAUDE.md") },
-      { name: "Cursor", check: existsSync3(".cursor") },
-      { name: "Node.js", check: existsSync3("node_modules") || existsSync3("package.json") }
-    ];
-    for (const p of platforms) {
-      console.log(`  ${p.name}: ${p.check ? success("detected") : dim("not found")}`);
+    if (platformResults.length === 0) {
+      console.log(`  ${dim("No platforms detected")}`);
+    } else {
+      const maxLen = Math.max(...platformResults.map((p) => p.name.length));
+      for (const p of platformResults) {
+        const label = `${p.name}:`.padEnd(maxLen + 2);
+        const mcpStatus = p.registered ? `(MCP: ${success("registered")})` : `(MCP: ${dim("not registered")})`;
+        console.log(`  ${label}${success("detected")} ${mcpStatus}`);
+      }
+    }
+    console.log("");
+    console.log(`Installed Artifacts: ${registryEntries.length}`);
+    if (driftEntries.length > 0) {
+      const count = driftEntries.length;
+      const noun = count === 1 ? "artifact has" : "artifacts have";
+      console.log(
+        `  ${warn(`${count} ${noun} missing files`)} \u2014 run \`caik setup\` to reconfigure`
+      );
     }
   });
 }
@@ -552,7 +1550,7 @@ Examples:
 }
 
 // src/commands/publish.ts
-import { readFileSync as readFileSync2, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync9 } from "fs";
 function registerPublishCommand(program2) {
   program2.command("publish [path]").description("Publish an artifact to the CAIK registry").requiredOption("--name <name>", "Artifact name").requiredOption("--description <desc>", "Artifact description (min 20 chars)").option("--slug <slug>", "Custom slug (auto-generated from name if omitted)").option("--primitive <type>", "Primitive type", "executable").option("--platform <platform>", "Target platform(s) (comma-separated)", "claude").option("--tag <tag>", "Add a tag (can be repeated)", (val, prev) => [...prev, val], []).option("--source-url <url>", "Source code URL").addHelpText("after", `
 Examples:
@@ -566,10 +1564,10 @@ Examples:
     const client = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
     let content;
     if (path) {
-      if (!existsSync4(path)) {
+      if (!existsSync9(path)) {
         throw new CaikError(`File not found: ${path}`);
       }
-      content = readFileSync2(path, "utf-8");
+      content = readFileSync6(path, "utf-8");
     }
     const tags = opts.tag.length > 0 ? opts.tag : ["general"];
     const platforms = opts.platform.split(",").map((p) => p.trim());
@@ -730,16 +1728,340 @@ Examples:
 }
 
 // src/commands/update.ts
+import { existsSync as existsSync10 } from "fs";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname4, resolve as resolve2 } from "path";
+import { execSync as execSync4 } from "child_process";
+import { createInterface as createInterface3 } from "readline/promises";
 function registerUpdateCommand(program2) {
-  program2.command("update [slug]").description("Check for and apply artifact updates").option("--yes", "Skip confirmation prompt").action(async (slug) => {
-    console.log(info("Update checking is not yet available. Reinstall artifacts with 'caik install <slug>' to get the latest version."));
+  program2.command("update [slug]").description("Check for and apply artifact updates").option("--platform <platform>", "Filter by platform").option("-y, --yes", "Skip confirmation prompts").addHelpText("after", `
+Examples:
+  caik update              # Check all installed artifacts for updates
+  caik update auth-skill   # Update a specific artifact
+  caik update --yes        # Update all without confirmation`).action(async (slug, opts) => {
+    const globalOpts = program2.opts();
+    const { apiUrl, apiKey } = resolveConfig(globalOpts);
+    const client = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
+    const skipConfirm = Boolean(opts?.yes);
+    const platformFilter = opts?.platform;
+    if (slug) {
+      const entry = findRegistryEntry(slug, platformFilter);
+      if (!entry) {
+        console.log(error(`Artifact "${slug}" is not in the install registry.`));
+        console.log(info("Use 'caik install <slug>' to install it first."));
+        process.exit(1);
+      }
+      const spinner = createSpinner(`Checking for updates to ${slug}...`);
+      if (!globalOpts.json) spinner.start();
+      let remote;
+      try {
+        remote = await client.get(`/artifacts/${encodeURIComponent(slug)}`);
+      } catch (err) {
+        spinner.stop();
+        console.log(error(`Failed to fetch artifact info: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+      if (globalOpts.json) {
+        spinner.stop();
+        outputResult({
+          slug,
+          installedVersion: entry.version,
+          remoteUpdatedAt: remote.updatedAt,
+          localUpdatedAt: entry.updatedAt,
+          updateAvailable: remote.updatedAt > entry.updatedAt
+        }, { json: true });
+        return;
+      }
+      if (remote.updatedAt <= entry.updatedAt) {
+        spinner.stop();
+        console.log(success(`${slug} is already up to date.`));
+        return;
+      }
+      spinner.stop();
+      console.log(info(`Update available for ${slug} (installed: ${entry.updatedAt.slice(0, 10)}, latest: ${remote.updatedAt.slice(0, 10)})`));
+      await performUpdate(client, entry, skipConfirm, globalOpts);
+    } else {
+      const entries = listRegistryEntries(platformFilter);
+      if (entries.length === 0) {
+        console.log(info("No installed artifacts found."));
+        console.log(info("Install artifacts with 'caik install <slug>' first."));
+        return;
+      }
+      const spinner = createSpinner(`Checking ${entries.length} artifact(s) for updates...`);
+      if (!globalOpts.json) spinner.start();
+      const candidates = [];
+      const errors = [];
+      for (const entry of entries) {
+        try {
+          const remote = await client.get(`/artifacts/${encodeURIComponent(entry.slug)}`);
+          if (remote.updatedAt > entry.updatedAt) {
+            candidates.push({ entry, remote });
+          }
+        } catch (err) {
+          errors.push({
+            slug: entry.slug,
+            message: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      spinner.stop();
+      if (globalOpts.json) {
+        outputResult({
+          total: entries.length,
+          updatesAvailable: candidates.length,
+          updates: candidates.map((c) => ({
+            slug: c.entry.slug,
+            platform: c.entry.platform,
+            installedAt: c.entry.updatedAt,
+            remoteUpdatedAt: c.remote.updatedAt
+          })),
+          errors
+        }, { json: true });
+        return;
+      }
+      if (errors.length > 0) {
+        for (const e of errors) {
+          console.log(warn(`Could not check ${e.slug}: ${e.message}`));
+        }
+      }
+      if (candidates.length === 0) {
+        console.log(success("All installed artifacts are up to date."));
+        return;
+      }
+      const rows = candidates.map((c) => [
+        c.entry.slug,
+        c.entry.platform,
+        c.entry.updatedAt.slice(0, 10),
+        c.remote.updatedAt.slice(0, 10)
+      ]);
+      console.log(renderTable(["Artifact", "Platform", "Installed", "Latest"], rows));
+      console.log(info(`${candidates.length} update(s) available.`));
+      if (!skipConfirm) {
+        const rl = createInterface3({ input: process.stdin, output: process.stdout });
+        const answer = await rl.question("\nUpdate all? (y/N) ");
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log(info("Update cancelled."));
+          return;
+        }
+      }
+      let updated = 0;
+      for (const candidate of candidates) {
+        try {
+          await performUpdate(client, candidate.entry, true, globalOpts);
+          updated++;
+        } catch (err) {
+          console.log(error(`Failed to update ${candidate.entry.slug}: ${err instanceof Error ? err.message : String(err)}`));
+        }
+      }
+      console.log(success(`Updated ${updated}/${candidates.length} artifact(s).`));
+    }
+  });
+}
+async function performUpdate(client, entry, skipConfirm, globalOpts) {
+  const spinner = createSpinner(`Updating ${entry.slug}...`);
+  if (!globalOpts.json) spinner.start();
+  const params = { platform: entry.platform };
+  let installInfo;
+  try {
+    installInfo = await client.get(`/install/${encodeURIComponent(entry.slug)}`, params);
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+  const cwd = process.cwd();
+  const safeFiles = [];
+  if (installInfo.files && installInfo.files.length > 0) {
+    for (const file of installInfo.files) {
+      const resolvedPath = resolve2(cwd, file.path);
+      if (!resolvedPath.startsWith(cwd + "/") && resolvedPath !== cwd) {
+        spinner.stop();
+        console.log(error(`Rejected file path outside working directory: ${file.path}`));
+        spinner.start();
+        continue;
+      }
+      safeFiles.push({ resolvedPath, content: file.content });
+    }
+  }
+  if (!skipConfirm && safeFiles.length > 0) {
+    spinner.stop();
+    console.log(info("\n--- Update plan ---"));
+    console.log(info("Files to write:"));
+    for (const f of safeFiles) {
+      console.log(info(`  ${f.resolvedPath}`));
+    }
+    if (installInfo.installCommand) {
+      console.log(info(`Install command: ${installInfo.installCommand}`));
+    }
+    console.log();
+    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question("Continue? (y/N) ");
+    rl.close();
+    if (answer.toLowerCase() !== "y") {
+      console.log(info("Update cancelled."));
+      return;
+    }
+    spinner.start();
+  }
+  const writtenFiles = [];
+  for (const file of safeFiles) {
+    const dir = dirname4(file.resolvedPath);
+    if (!existsSync10(dir)) {
+      mkdirSync7(dir, { recursive: true });
+    }
+    writeFileSync7(file.resolvedPath, file.content, "utf-8");
+    writtenFiles.push(file.resolvedPath);
+  }
+  if (installInfo.installCommand) {
+    try {
+      execSync4(installInfo.installCommand, { stdio: "pipe" });
+    } catch (err) {
+      spinner.stop();
+      console.log(error(`Install command failed: ${err instanceof Error ? err.message : String(err)}`));
+      client.post("/telemetry/install", {
+        artifactSlug: entry.slug,
+        platform: entry.platform,
+        success: false,
+        errorMessage: err instanceof Error ? err.message : String(err)
+      }).catch(() => {
+      });
+      throw err;
+    }
+  }
+  if (installInfo.postInstallHook) {
+    try {
+      execSync4(installInfo.postInstallHook, { stdio: "pipe" });
+    } catch {
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  upsertRegistryEntry({
+    ...entry,
+    updatedAt: now,
+    files: writtenFiles.length > 0 ? writtenFiles : entry.files
+  });
+  spinner.stop();
+  console.log(success(`Updated ${installInfo.artifact.name}`));
+  client.post("/telemetry/install", {
+    artifactSlug: entry.slug,
+    platform: entry.platform,
+    success: true
+  }).catch(() => {
   });
 }
 
 // src/commands/uninstall.ts
+import { createInterface as createInterface4 } from "readline/promises";
 function registerUninstallCommand(program2) {
-  program2.command("uninstall <slug>").description("Remove an installed artifact").action(async (slug) => {
-    console.log(info("Uninstall is not yet available. Manually remove the artifact files to uninstall."));
+  program2.command("uninstall <slug>").description("Remove an installed artifact").option("--platform <platform>", "Target platform (disambiguates if installed on multiple)").option("-y, --yes", "Skip confirmation prompts").addHelpText("after", `
+Examples:
+  caik uninstall auth-skill
+  caik uninstall my-mcp --platform claude-code
+  caik uninstall old-rules --yes`).action(async (slug, opts) => {
+    const globalOpts = program2.opts();
+    const { apiUrl, apiKey } = resolveConfig(globalOpts);
+    const client = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
+    const skipConfirm = Boolean(opts.yes);
+    const platformOpt = opts.platform;
+    const allEntries = listRegistryEntries();
+    const matchingEntries = allEntries.filter(
+      (e) => e.slug === slug && (!platformOpt || e.platform === platformOpt)
+    );
+    if (matchingEntries.length === 0) {
+      if (globalOpts.json) {
+        outputResult({ error: "not_found", slug }, { json: true });
+        return;
+      }
+      console.log(error(`Artifact "${slug}" not found in install registry.`));
+      console.log(info("It may have been installed manually or already uninstalled."));
+      process.exit(1);
+    }
+    if (matchingEntries.length > 1 && !platformOpt) {
+      if (globalOpts.json) {
+        outputResult({
+          error: "ambiguous",
+          slug,
+          platforms: matchingEntries.map((e) => e.platform)
+        }, { json: true });
+        return;
+      }
+      console.log(warn(`"${slug}" is installed on multiple platforms: ${matchingEntries.map((e) => e.platform).join(", ")}`));
+      console.log(info("Use --platform <platform> to specify which to uninstall."));
+      process.exit(1);
+    }
+    const entry = matchingEntries[0];
+    if (globalOpts.json) {
+    } else {
+      console.log(info(`
+Artifact: ${entry.slug} (${entry.artifactType})`));
+      console.log(info(`Platform: ${entry.platform}`));
+      console.log(info(`Installed: ${entry.installedAt.slice(0, 10)}`));
+      if (entry.files.length > 0) {
+        console.log(info("Files to remove:"));
+        for (const f of entry.files) {
+          console.log(info(`  ${f}`));
+        }
+      }
+      if (!skipConfirm) {
+        const rl = createInterface4({ input: process.stdin, output: process.stdout });
+        const answer = await rl.question("\nUninstall? (y/N) ");
+        rl.close();
+        if (answer.toLowerCase() !== "y") {
+          console.log(info("Uninstall cancelled."));
+          return;
+        }
+      }
+    }
+    const spinner = createSpinner(`Uninstalling ${slug}...`);
+    if (!globalOpts.json) spinner.start();
+    const failedFiles = cleanupFiles(entry);
+    const adapter = getPlatformAdapter(entry.platform);
+    if (entry.artifactType === "mcp-server") {
+      try {
+        await adapter.unregisterMcp();
+      } catch (err) {
+        if (!globalOpts.json) {
+          spinner.stop();
+          console.log(warn(`Could not unregister MCP server: ${err instanceof Error ? err.message : String(err)}`));
+          spinner.start();
+        }
+      }
+    }
+    if ((entry.artifactType === "skill" || entry.artifactType === "subagent" || entry.artifactType === "command") && adapter.uninstallSkill) {
+      try {
+        await adapter.uninstallSkill(slug);
+      } catch (err) {
+        if (!globalOpts.json) {
+          spinner.stop();
+          console.log(warn(`Could not uninstall skill: ${err instanceof Error ? err.message : String(err)}`));
+          spinner.start();
+        }
+      }
+    }
+    removeRegistryEntry(slug, entry.platform);
+    spinner.stop();
+    if (globalOpts.json) {
+      outputResult({
+        slug,
+        platform: entry.platform,
+        removed: true,
+        filesRemoved: entry.files.length - failedFiles.length,
+        filesFailed: failedFiles
+      }, { json: true });
+      return;
+    }
+    console.log(success(`Uninstalled ${slug} from ${entry.platform}`));
+    if (failedFiles.length > 0) {
+      console.log(warn(`Could not remove ${failedFiles.length} file(s):`));
+      for (const f of failedFiles) {
+        console.log(warn(`  ${f}`));
+      }
+    }
+    client.post("/telemetry/uninstall", {
+      artifactSlug: slug,
+      platform: entry.platform
+    }).catch(() => {
+    });
   });
 }
 
@@ -769,13 +2091,497 @@ function registerKarmaCommand(program2) {
   });
 }
 
+// src/commands/hook.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, existsSync as existsSync11 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
+var PENDING_EVENTS_PATH = join7(homedir6(), ".caik", "pending-events.json");
+var FLUSH_THRESHOLD = 50;
+var API_TIMEOUT_MS = 2e3;
+function readPendingEvents() {
+  try {
+    if (!existsSync11(PENDING_EVENTS_PATH)) return [];
+    const raw = readFileSync7(PENDING_EVENTS_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function writePendingEvents(events) {
+  const dir = join7(homedir6(), ".caik");
+  if (!existsSync11(dir)) {
+    mkdirSync8(dir, { recursive: true, mode: 448 });
+  }
+  writeFileSync8(PENDING_EVENTS_PATH, JSON.stringify(events, null, 2) + "\n", "utf-8");
+}
+function bufferEvent(event) {
+  const events = readPendingEvents();
+  events.push(event);
+  writePendingEvents(events);
+  return events;
+}
+function clearPendingEvents() {
+  writePendingEvents([]);
+}
+async function postEventsWithTimeout(client, events) {
+  if (events.length === 0) return;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+  try {
+    await Promise.race([
+      client.post("/events", { events }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), API_TIMEOUT_MS)
+      )
+    ]);
+    clearPendingEvents();
+  } catch {
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function postSingleEventWithTimeout(client, event) {
+  try {
+    await Promise.race([
+      client.post("/events", { events: [event] }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), API_TIMEOUT_MS)
+      )
+    ]);
+  } catch {
+  }
+}
+function createClient(program2) {
+  const globalOpts = program2.opts();
+  const { apiUrl, apiKey } = resolveConfig(globalOpts);
+  return new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
+}
+function registerHookCommand(program2) {
+  const hook = program2.command("hook").description("Platform hook callbacks (observation only, never gates agent actions)");
+  hook.command("session-start").description("Log session start event").action(async () => {
+    try {
+      const client = createClient(program2);
+      const event = {
+        type: "session_start",
+        platform: "claude-code",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await postSingleEventWithTimeout(client, event);
+    } catch {
+    }
+    process.exit(0);
+  });
+  hook.command("session-end").description("Flush pending events and log session end").action(async () => {
+    try {
+      const client = createClient(program2);
+      const pending = readPendingEvents();
+      const endEvent = {
+        type: "session_end",
+        platform: "claude-code",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      pending.push(endEvent);
+      await postEventsWithTimeout(client, pending);
+    } catch {
+    }
+    process.exit(0);
+  });
+  hook.command("post-tool-use").description("Buffer a tool-use event").option("--tool <name>", "Tool name").option("--success <bool>", "Whether the tool call succeeded").action(async (opts) => {
+    try {
+      const event = {
+        type: "tool_use",
+        platform: "claude-code",
+        tool: opts.tool,
+        success: opts.success === "true" || opts.success === true,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const events = bufferEvent(event);
+      if (events.length >= FLUSH_THRESHOLD) {
+        const client = createClient(program2);
+        await postEventsWithTimeout(client, events);
+      }
+    } catch {
+    }
+    process.exit(0);
+  });
+  hook.command("cursor-session-start").description("Log Cursor session start event").action(async () => {
+    try {
+      const client = createClient(program2);
+      const event = {
+        type: "session_start",
+        platform: "cursor",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await postSingleEventWithTimeout(client, event);
+    } catch {
+    }
+    process.exit(0);
+  });
+  hook.command("cursor-mcp-exec").description("Buffer a Cursor MCP tool execution event").option("--server <name>", "MCP server name").option("--tool <name>", "Tool name").action(async (opts) => {
+    try {
+      const event = {
+        type: "mcp_exec",
+        platform: "cursor",
+        server: opts.server,
+        tool: opts.tool,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const events = bufferEvent(event);
+      if (events.length >= FLUSH_THRESHOLD) {
+        const client = createClient(program2);
+        await postEventsWithTimeout(client, events);
+      }
+    } catch {
+    }
+    process.exit(0);
+  });
+  hook.command("cursor-session-end").description("Flush pending events and log Cursor session end").action(async () => {
+    try {
+      const client = createClient(program2);
+      const pending = readPendingEvents();
+      const endEvent = {
+        type: "session_end",
+        platform: "cursor",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      pending.push(endEvent);
+      await postEventsWithTimeout(client, pending);
+    } catch {
+    }
+    process.exit(0);
+  });
+}
+
+// src/commands/setup.ts
+import { createInterface as createInterface5 } from "readline/promises";
+
+// src/platform/templates/claude-code-skill.ts
+function getClaudeCodeSkillContent() {
+  return `# CAIK \u2014 AI Artifact Registry
+
+CAIK is a community-driven registry for AI coding artifacts \u2014 skills, rules, prompts, MCP servers, and knowledge packs. Use CAIK to discover, install, and share reusable building blocks across projects.
+
+## Available MCP Tools
+
+When the CAIK MCP server is running, these tools are available:
+
+| Tool | Description |
+|------|-------------|
+| \`search\` | Search the CAIK registry for artifacts |
+| \`get_artifact\` | Get full details for an artifact by slug |
+| \`install_artifact\` | Install an artifact into the current project |
+| \`report_outcome\` | Report whether an artifact worked well or poorly |
+| \`get_alternatives\` | Find similar artifacts |
+
+## Quick Commands
+
+If MCP is unavailable, use the CLI directly:
+
+- **Search:** \`caik search <query>\`
+- **Install:** \`caik install <slug>\`
+- **Status:** \`caik status\`
+- **Update:** \`caik update [slug]\`
+- **Uninstall:** \`caik uninstall <slug>\`
+
+## Contributing Back
+
+When an artifact works well for a task, use \`report_outcome\` (MCP) or \`caik flag --positive <slug>\` to help the community. Your contributions earn karma on the CAIK leaderboard.
+
+## Discovery
+
+Ask your agent: "Find CAIK artifacts for [your use case]" \u2014 the agent will use the \`search\` tool to find relevant artifacts from the registry.
+`;
+}
+
+// src/platform/templates/cursor-skill.ts
+function getCursorSkillContent() {
+  return `# CAIK \u2014 AI Artifact Registry
+
+CAIK is a community-driven registry for AI coding artifacts. Use CAIK to discover and install rules, prompts, and knowledge packs into your Cursor workspace.
+
+## Cursor Rules Integration
+
+CAIK artifacts install directly into your \`.cursorrules\` file. Installed rules are automatically loaded by Cursor's AI features.
+
+## MCP Tools
+
+If the CAIK MCP server is configured, these tools are available:
+
+| Tool | Description |
+|------|-------------|
+| \`search\` | Search the CAIK registry for artifacts |
+| \`get_artifact\` | Get full details for an artifact by slug |
+| \`install_artifact\` | Install an artifact into the current project |
+| \`report_outcome\` | Report whether an artifact worked well or poorly |
+
+## CLI Fallback
+
+- **Search:** \`caik search <query>\`
+- **Install:** \`caik install <slug>\`
+- **Status:** \`caik status\`
+- **Uninstall:** \`caik uninstall <slug>\`
+
+## Discovery
+
+Ask Cursor: "Find CAIK artifacts for [your use case]" to search the registry.
+`;
+}
+
+// src/platform/templates/openclaw-skill.ts
+function getOpenClawSkillContent() {
+  return `# CAIK \u2014 AI Artifact Registry
+
+CAIK is a community-driven registry for AI coding artifacts \u2014 skills, rules, prompts, MCP servers, and knowledge packs. Use CAIK to discover and install reusable building blocks.
+
+## Skill Capabilities
+
+CAIK artifacts integrate with OpenClaw's skill system. Installed skills are available as callable capabilities within your OpenClaw agent.
+
+## Hook Telemetry
+
+CAIK uses OpenClaw lifecycle hooks to track artifact usage. When you invoke a CAIK-installed skill, outcome data is reported automatically to improve community rankings. You can disable telemetry with \`caik config set telemetry false\`.
+
+## MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| \`search\` | Search the CAIK registry for artifacts |
+| \`get_artifact\` | Get full details for an artifact by slug |
+| \`install_artifact\` | Install an artifact into the current project |
+| \`report_outcome\` | Report whether an artifact worked well or poorly |
+| \`get_alternatives\` | Find similar artifacts |
+
+## CLI Fallback
+
+- **Search:** \`caik search <query>\`
+- **Install:** \`caik install <slug>\`
+- **Status:** \`caik status\`
+- **Update:** \`caik update [slug]\`
+- **Uninstall:** \`caik uninstall <slug>\`
+
+## Discovery
+
+Ask your agent: "Find CAIK artifacts for [your use case]" to search the registry.
+`;
+}
+
+// src/platform/templates/index.ts
+function getSkillContent(platform) {
+  switch (platform) {
+    case "claude-code":
+      return getClaudeCodeSkillContent();
+    case "cursor":
+      return getCursorSkillContent();
+    case "openclaw":
+      return getOpenClawSkillContent();
+    default:
+      return getGenericSkillContent();
+  }
+}
+function getGenericSkillContent() {
+  return `# CAIK \u2014 AI Artifact Registry
+
+CAIK is a community-driven registry for AI coding artifacts \u2014 skills, rules, prompts, MCP servers, and knowledge packs.
+
+## CLI Commands
+
+- **Search:** \`caik search <query>\`
+- **Install:** \`caik install <slug>\`
+- **Status:** \`caik status\`
+- **Update:** \`caik update [slug]\`
+- **Uninstall:** \`caik uninstall <slug>\`
+
+## MCP Tools
+
+If the CAIK MCP server is configured, these tools are available:
+
+| Tool | Description |
+|------|-------------|
+| \`search\` | Search the CAIK registry for artifacts |
+| \`get_artifact\` | Get full details for an artifact by slug |
+| \`install_artifact\` | Install an artifact into the current project |
+| \`report_outcome\` | Report whether an artifact worked well or poorly |
+
+## Discovery
+
+Ask your agent: "Find CAIK artifacts for [your use case]" to search the registry.
+`;
+}
+
+// src/commands/setup.ts
+function getHookConfig(platform) {
+  if (platform === "claude-code") {
+    return {
+      hooks: {
+        SessionStart: [{ type: "command", command: "npx -y @caik.dev/cli hook session-start" }],
+        PostToolUse: [{ type: "command", command: "npx -y @caik.dev/cli hook post-tool-use" }],
+        SessionEnd: [{ type: "command", command: "npx -y @caik.dev/cli hook session-end" }]
+      }
+    };
+  }
+  if (platform === "cursor") {
+    return {
+      hooks: {
+        sessionStart: "npx -y @caik.dev/cli hook cursor-session-start",
+        beforeMCPExecution: "npx -y @caik.dev/cli hook cursor-mcp-exec",
+        stop: "npx -y @caik.dev/cli hook cursor-session-end"
+      }
+    };
+  }
+  return {
+    hooks: {
+      session_start: "npx -y @caik.dev/cli hook session-start",
+      session_end: "npx -y @caik.dev/cli hook session-end",
+      after_tool_call: "npx -y @caik.dev/cli hook post-tool-use"
+    }
+  };
+}
+function registerSetupCommand(program2) {
+  program2.command("setup").description("Interactive setup wizard \u2014 configure CAIK for your agent platforms").option("--platform <name>", "Skip detection, configure a specific platform").option("--skip-hooks", "Register MCP only, skip hook registration").option("--skip-stacks", "Skip stack recommendations").option("-y, --yes", "Accept all defaults (non-interactive)").addHelpText("after", `
+Examples:
+  caik setup
+  caik setup --platform claude-code
+  caik setup --yes --skip-hooks`).action(async (opts) => {
+    const globalOpts = program2.opts();
+    const { apiKey } = resolveConfig(globalOpts);
+    const skipHooks = Boolean(opts.skipHooks);
+    const skipStacks = Boolean(opts.skipStacks);
+    const autoYes = Boolean(opts.yes);
+    const platformFlag = opts.platform;
+    console.log(heading("\nCAIK Setup Wizard"));
+    console.log("\u2550".repeat(40));
+    console.log();
+    let detected;
+    if (platformFlag) {
+      const adapter = getPlatformAdapter(platformFlag);
+      const det = await adapter.detect();
+      if (det) {
+        detected = [det];
+      } else {
+        detected = [{
+          name: platformFlag,
+          tier: "cli-mcp",
+          configPaths: [],
+          capabilities: { hooks: false, mcp: true, skills: false }
+        }];
+        console.log(warn(`Platform "${platformFlag}" was not detected but will be configured anyway.`));
+      }
+    } else {
+      const spinner = createSpinner("Detecting installed platforms...");
+      spinner.start();
+      detected = detectPlatforms();
+      spinner.stop();
+      if (detected.length === 0) {
+        console.log(warn("No supported agent platforms detected."));
+        console.log(info("Supported platforms: claude-code, cursor, openclaw, codex, windsurf"));
+        console.log(info("Use --platform <name> to configure a specific platform."));
+        return;
+      }
+      console.log(info(`Detected ${detected.length} platform(s):`));
+      for (const p of detected) {
+        console.log(`  ${success(p.name)} ${dim(`(${p.tier})`)}`);
+      }
+      console.log();
+    }
+    let selected;
+    if (autoYes || detected.length === 1 || platformFlag) {
+      selected = detected;
+    } else {
+      const rl = createInterface5({ input: process.stdin, output: process.stdout });
+      console.log(info("Which platforms would you like to configure?"));
+      for (let i = 0; i < detected.length; i++) {
+        console.log(`  ${i + 1}. ${detected[i].name}`);
+      }
+      console.log(`  a. All`);
+      const answer = await rl.question("\nSelect (numbers separated by commas, or 'a' for all): ");
+      rl.close();
+      if (answer.toLowerCase() === "a" || answer.trim() === "") {
+        selected = detected;
+      } else {
+        const indices = answer.split(",").map((s) => parseInt(s.trim(), 10) - 1);
+        selected = indices.filter((i) => i >= 0 && i < detected.length).map((i) => detected[i]);
+        if (selected.length === 0) {
+          console.log(warn("No valid platforms selected. Exiting."));
+          return;
+        }
+      }
+    }
+    console.log();
+    for (const platform of selected) {
+      console.log(heading(`Configuring ${platform.name}...`));
+      console.log("\u2500".repeat(40));
+      const adapter = getPlatformAdapter(platform.name);
+      const mcpConfig = getDefaultMcpConfig();
+      const mcpSpinner = createSpinner("Registering MCP server...");
+      mcpSpinner.start();
+      try {
+        await adapter.registerMcp(mcpConfig);
+        mcpSpinner.stop();
+        console.log(success("MCP server registered"));
+      } catch (err) {
+        mcpSpinner.stop();
+        console.log(error(`Failed to register MCP server: ${err instanceof Error ? err.message : String(err)}`));
+      }
+      if (!skipHooks && adapter.registerHooks && platform.capabilities.hooks) {
+        const hookSpinner = createSpinner("Registering hooks...");
+        hookSpinner.start();
+        try {
+          const hookConfig = getHookConfig(platform.name);
+          await adapter.registerHooks(hookConfig);
+          hookSpinner.stop();
+          console.log(success("Hooks registered"));
+        } catch (err) {
+          hookSpinner.stop();
+          console.log(error(`Failed to register hooks: ${err instanceof Error ? err.message : String(err)}`));
+        }
+      } else if (!skipHooks && !platform.capabilities.hooks) {
+        console.log(dim("  Hooks not supported on this platform \u2014 skipped"));
+      } else if (skipHooks) {
+        console.log(dim("  Hooks skipped (--skip-hooks)"));
+      }
+      if (adapter.installSkill && platform.capabilities.skills) {
+        const skillSpinner = createSpinner("Installing SKILL.md...");
+        skillSpinner.start();
+        try {
+          const content = getSkillContent(platform.name);
+          await adapter.installSkill("caik", content);
+          skillSpinner.stop();
+          console.log(success("SKILL.md installed"));
+        } catch (err) {
+          skillSpinner.stop();
+          console.log(error(`Failed to install SKILL.md: ${err instanceof Error ? err.message : String(err)}`));
+        }
+      }
+      console.log();
+    }
+    if (!skipStacks) {
+      console.log(dim("Stack recommendations: coming soon"));
+      console.log();
+    }
+    if (!apiKey) {
+      console.log(warn("Not authenticated. Run `caik init --auth` to connect your account."));
+      console.log();
+    }
+    console.log(heading("Setup Complete"));
+    console.log("\u2550".repeat(40));
+    console.log(success(`Configured ${selected.length} platform(s): ${selected.map((p) => p.name).join(", ")}`));
+    if (!apiKey) {
+      console.log(info("Next step: run `caik init --auth` to authenticate"));
+    } else {
+      console.log(info("Next step: run `caik search <query>` to find artifacts"));
+    }
+    console.log();
+  });
+}
+
 // src/index.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
+var __dirname = dirname5(__filename);
 var version = "0.0.1";
 try {
-  const pkgPath = join2(__dirname, "..", "package.json");
-  const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+  const pkgPath = join8(__dirname, "..", "package.json");
+  const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
   version = pkg.version;
 } catch {
 }
@@ -793,6 +2599,8 @@ registerAlternativesCommand(program);
 registerUpdateCommand(program);
 registerUninstallCommand(program);
 registerKarmaCommand(program);
+registerHookCommand(program);
+registerSetupCommand(program);
 program.exitOverride();
 async function main() {
   try {