@caik.dev/cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -2,10 +2,10 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join2 } from "path";
-import chalk2 from "chalk";
+import { dirname as dirname5, join as join9 } from "path";
+import chalk3 from "chalk";
 
 // src/errors.ts
 var CaikError = class extends Error {
@@ -165,6 +165,11 @@ function writeConfig(config) {
   writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf-8");
   chmodSync(path, 384);
 }
+function setApiKey(key) {
+  const config = readConfig();
+  config.apiKey = key;
+  writeConfig(config);
+}
 function resolveConfig(opts) {
   const config = readConfig();
   return {
@@ -186,6 +191,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,226 +299,1534 @@ ${result.total} result${result.total !== 1 ? "s" : ""} found.`);
 }
 
 // src/commands/install.ts
+import { existsSync as existsSync7, unlinkSync as unlinkSync2 } 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 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:
-  caik install auth-middleware
-  caik install my-skill --platform claude`).action(async (slug, opts) => {
-    const globalOpts = program2.opts();
-    const { apiUrl, apiKey } = resolveConfig(globalOpts);
-    const client = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
-    const platform = opts.platform ?? detectPlatform();
-    const spinner = createSpinner(`Fetching ${slug}...`);
-    if (!globalOpts.json) spinner.start();
-    const params = { platform };
-    const installInfo = await client.get(`/install/${encodeURIComponent(slug)}`, params);
-    if (globalOpts.json) {
-      spinner.stop();
-      outputResult(installInfo, { json: true });
-      return;
+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");
+  const inPath = commandExists("openclaw");
+  if (!existsSync2(openclawDir) && !existsSync2(cwdConfig) && !inPath) 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 {
     }
-    spinner.text = `Installing ${installInfo.artifact.name}...`;
-    const skipConfirm = Boolean(opts.yes);
-    const cwd = process.cwd();
-    const safeFiles = [];
-    if (installInfo.files && installInfo.files.length > 0) {
-      for (const file of installInfo.files) {
-        const resolvedPath = resolve(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 });
+  }
+  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, platform2) {
+  const registry = readRegistry();
+  const idx = registry.entries.findIndex(
+    (e) => e.slug === slug && e.platform === platform2
+  );
+  if (idx < 0) return null;
+  const [removed] = registry.entries.splice(idx, 1);
+  writeRegistry(registry);
+  return removed;
+}
+function findRegistryEntry(slug, platform2) {
+  const registry = readRegistry();
+  return registry.entries.find(
+    (e) => e.slug === slug && (!platform2 || e.platform === platform2)
+  ) ?? null;
+}
+function listRegistryEntries(platform2) {
+  const registry = readRegistry();
+  if (!platform2) return registry.entries;
+  return registry.entries.filter((e) => e.platform === platform2);
+}
+function cleanupFiles(entry) {
+  const failed = [];
+  for (const file of entry.files) {
+    try {
+      if (existsSync3(file)) {
+        unlinkSync(file);
       }
+    } catch {
+      failed.push(file);
     }
-    const hasFiles = safeFiles.length > 0;
-    const hasInstallCmd = Boolean(installInfo.installCommand);
-    const hasPostHook = Boolean(installInfo.postInstallHook);
-    if (!skipConfirm && (hasFiles || hasInstallCmd || hasPostHook)) {
-      spinner.stop();
-      console.log(info("\n--- Install plan ---"));
-      if (hasFiles) {
-        console.log(info("Files to write:"));
-        for (const f of safeFiles) {
-          console.log(info(`  ${f.resolvedPath}`));
-        }
-      }
-      if (hasInstallCmd) {
-        console.log(info(`Install command: ${installInfo.installCommand}`));
-      }
-      if (hasPostHook) {
-        console.log(info(`Post-install hook: ${installInfo.postInstallHook}`));
-      }
-      console.log();
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      const answer = await rl.question("Continue? (y/N) ");
-      rl.close();
-      if (answer.toLowerCase() !== "y") {
-        console.log(info("Installation cancelled."));
-        return;
+  }
+  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;
       }
-      spinner.start();
+      return {};
+    } catch {
+      return {};
     }
-    for (const file of safeFiles) {
-      const dir = dirname(file.resolvedPath);
-      if (!existsSync2(dir)) {
-        mkdirSync2(dir, { recursive: true });
-      }
-      writeFileSync2(file.resolvedPath, file.content, "utf-8");
+  }
+  writeJson(path, data) {
+    const dir = join4(path, "..");
+    if (!existsSync4(dir)) {
+      mkdirSync3(dir, { recursive: true });
     }
-    if (installInfo.installCommand) {
-      try {
-        execSync(installInfo.installCommand, { stdio: "pipe" });
-      } catch (err) {
-        spinner.stop();
-        console.error(error(`Install command failed: ${err instanceof Error ? err.message : String(err)}`));
-        client.post("/telemetry/install", {
-          artifactSlug: slug,
-          platform,
-          success: false,
-          errorMessage: err instanceof Error ? err.message : String(err)
-        }).catch(() => {
-        });
-        process.exit(1);
+    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 (installInfo.postInstallHook) {
+    if (existsSync4(this.pluginsCacheDir)) {
       try {
-        execSync(installInfo.postInstallHook, { stdio: "pipe" });
+        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 {
       }
     }
-    spinner.stop();
-    console.log(success(`Installed ${installInfo.artifact.name}`));
-    if (installInfo.contract?.touchedPaths) {
-      console.log(info(`Files: ${installInfo.contract.touchedPaths.join(", ")}`));
+    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";
     }
-    client.post("/telemetry/install", {
-      artifactSlug: slug,
-      platform,
-      success: true
-    }).catch(() => {
-    });
-  });
-}
-
-// src/commands/init.ts
-import { createInterface as createInterface2 } from "readline/promises";
-import { stdin, stdout } from "process";
-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) => {
-    const rl = createInterface2({ input: stdin, output: stdout });
-    try {
-      const config = readConfig();
-      const apiUrl = await rl.question(`API URL (${config.apiUrl}): `);
-      if (apiUrl.trim()) {
-        config.apiUrl = apiUrl.trim();
-      }
-      const apiKey = await rl.question("API Key (leave blank to skip): ");
-      if (apiKey.trim()) {
-        config.apiKey = apiKey.trim();
-      }
-      writeConfig(config);
-      console.log(success("CAIK CLI configured"));
-      console.log(info(`Config saved to ~/.caik/config.json`));
-      if (config.apiKey) {
-        const client = new CaikApiClient({ apiUrl: config.apiUrl, apiKey: config.apiKey });
-        try {
-          const 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."));
+    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");
+          }
         }
-      }
-    } finally {
-      rl.close();
+        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];
     }
-  });
-}
-
-// src/commands/status.ts
-import { existsSync as existsSync3 } 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")
+    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");
+          }
         }
-      };
-      const client2 = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
-      try {
-        if (apiKey) {
-          const karma = await client2.get("/me/karma");
-          data.authenticated = true;
-          data.user = karma;
+        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 });
         }
-        data.apiReachable = true;
-      } catch {
-        data.apiReachable = false;
-        data.authenticated = false;
+        writeFileSync3(filePath, file.content, "utf-8");
       }
-      outputResult(data, { json: true });
-      return;
     }
-    console.log(heading("CAIK CLI Status"));
-    console.log("\u2550".repeat(40));
-    console.log(`API URL:          ${apiUrl}`);
-    console.log(`API Key:          ${apiKey ? `${dim("configured")} (${apiKey.slice(0, 12)}...)` : dim("not set")}`);
-    const client = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
+  }
+  async uninstallSkill(slug) {
+    const skillDir = join4(this.skillsDir, slug);
+    if (!existsSync4(skillDir)) return;
     try {
-      if (apiKey) {
-        const karma = await client.get("/me/karma");
-        console.log(`Authenticated:    ${success("yes")}`);
-        console.log(`User:             ${karma.handle ?? karma.displayName ?? "unknown"} (${karma.karmaTier})`);
-      } else {
-        console.log(`Authenticated:    ${dim("no (no API key)")}`);
+      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");
+  }
+  get managedHooksDir() {
+    return join5(this.openclawDir, "hooks");
+  }
+  get caikHookDir() {
+    return join5(this.managedHooksDir, "caik-contributions");
+  }
+  /** 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 {
-      console.log(`API Reachable:    ${error("no")}`);
+      return {};
     }
-    console.log("");
-    console.log(heading("Local Platforms Detected"));
-    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")}`);
+  }
+  writeJson(path, data) {
+    const dir = dirname(path);
+    if (!existsSync5(dir)) {
+      mkdirSync4(dir, { recursive: true });
     }
-  });
-}
-
-// src/commands/stats.ts
-var PRIMITIVES = ["executable", "knowledge", "connector", "composition", "reference"];
-function registerStatsCommand(program2) {
-  program2.command("stats").description("Show CAIK ecosystem statistics").addHelpText("after", `
-Examples:
+    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();
+    const hasCwdConfig = existsSync5(join5(process.cwd(), "openclaw.json"));
+    if (!hasDir && !inPath && !hasCwdConfig) return null;
+    const configPaths = [];
+    if (hasCwdConfig) {
+      configPaths.push(join5(process.cwd(), "openclaw.json"));
+    }
+    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) {
+    if (!existsSync5(this.caikHookDir)) {
+      mkdirSync4(this.caikHookDir, { recursive: true });
+    }
+    writeFileSync4(
+      join5(this.caikHookDir, "HOOK.md"),
+      HOOK_MD_CONTENT,
+      "utf-8"
+    );
+    writeFileSync4(
+      join5(this.caikHookDir, "handler.js"),
+      HANDLER_JS_CONTENT,
+      "utf-8"
+    );
+  }
+  async unregisterHooks() {
+    if (existsSync5(this.caikHookDir)) {
+      try {
+        rmSync2(this.caikHookDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+  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;
+  }
+};
+var HOOK_MD_CONTENT = `---
+name: caik-contributions
+description: "Track artifact usage to build your CAIK contribution level and community karma"
+metadata:
+  {
+    "openclaw":
+      {
+        "emoji": "\u{1F4E6}",
+        "events": ["command:new", "command:reset", "command:stop", "command"],
+        "install": [{ "id": "local", "kind": "local", "label": "CAIK CLI hook pack" }],
+      },
+  }
+---
+
+# CAIK Contribution Tracking
+
+Reports session lifecycle events to the CAIK API to build your contribution level and community karma.
+
+## What It Does
+
+- **Session start** (\`command:new\`): Records that a new agent session began
+- **Session end** (\`command:stop\`, \`command:reset\`): Flushes buffered tool-use events and records session end
+- **Tool use** (\`command\`): Buffers tool execution events for batch reporting
+
+## Privacy
+
+- Only sends: event type, platform name, tool name, timestamp
+- No code, file contents, or conversation data is transmitted
+- Contribution tracking can be disabled: \`caik config set contributions false\`
+
+## Configuration
+
+Set \`CAIK_API_URL\` and \`CAIK_API_KEY\` environment variables, or configure via \`caik init --auth\`.
+`;
+var HANDLER_JS_CONTENT = `/**
+ * CAIK contribution tracking hook for OpenClaw.
+ * Fire-and-forget \u2014 never blocks the agent, never throws.
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const CAIK_DIR = path.join(os.homedir(), ".caik");
+const PENDING_PATH = path.join(CAIK_DIR, "pending-events.json");
+const CONFIG_PATH = path.join(CAIK_DIR, "config.json");
+const TIMEOUT_MS = 2000;
+
+async function loadConfig() {
+  try {
+    const raw = await fs.readFile(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch { return {}; }
+}
+
+async function getApiUrl() {
+  const cfg = await loadConfig();
+  return process.env.CAIK_API_URL || cfg.apiUrl || "https://caik.dev";
+}
+
+async function getApiKey() {
+  const cfg = await loadConfig();
+  return process.env.CAIK_API_KEY || cfg.apiKey || null;
+}
+
+async function readPending() {
+  try {
+    const raw = await fs.readFile(PENDING_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch { return []; }
+}
+
+async function writePending(events) {
+  await fs.mkdir(CAIK_DIR, { recursive: true });
+  await fs.writeFile(PENDING_PATH, JSON.stringify(events) + "\\n", "utf-8");
+}
+
+async function appendEvent(event) {
+  const events = await readPending();
+  events.push(event);
+  await writePending(events);
+  return events;
+}
+
+async function clearPending() { await writePending([]); }
+
+async function postEvents(events) {
+  if (events.length === 0) return;
+  const apiUrl = await getApiUrl();
+  const apiKey = await getApiKey();
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["Authorization"] = "Bearer " + apiKey;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+  try {
+    await fetch(apiUrl + "/api/v1/events", {
+      method: "POST", headers,
+      body: JSON.stringify({ events }),
+      signal: controller.signal,
+    });
+    await clearPending();
+  } catch { /* fire-and-forget */ }
+  finally { clearTimeout(timeout); }
+}
+
+const handler = async (event) => {
+  try {
+    const cfg = await loadConfig();
+    if (cfg.contributions === false || cfg.telemetry === false) return;
+    const timestamp = (event.timestamp ?? new Date()).toISOString();
+    if (event.type === "command") {
+      const action = event.action;
+      if (action === "new") {
+        await postEvents([{ type: "session_start", platform: "openclaw", timestamp }]);
+      } else if (action === "stop" || action === "reset") {
+        const pending = await readPending();
+        pending.push({ type: "session_end", platform: "openclaw", timestamp });
+        await postEvents(pending);
+      } else {
+        await appendEvent({ type: "tool_use", platform: "openclaw", tool: action, timestamp });
+        const pending = await readPending();
+        if (pending.length >= 50) await postEvents(pending);
+      }
+    }
+  } catch { /* never fail */ }
+};
+
+export default handler;
+`;
+
+// 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:
+  caik install auth-middleware
+  caik install my-skill --platform claude`).action(async (slug, opts) => {
+    const globalOpts = program2.opts();
+    const { apiUrl, apiKey } = resolveConfig(globalOpts);
+    const client = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
+    let detectedPlatform;
+    if (opts.platform) {
+      const raw = opts.platform;
+      detectedPlatform = legacyPlatformMap[raw] ?? raw;
+    } else {
+      const detected = detectPlatforms();
+      if (detected.length > 1 && !opts.yes && !globalOpts.json) {
+        console.log(info("Multiple platforms detected:"));
+        for (let i = 0; i < detected.length; i++) {
+          const d = detected[i];
+          console.log(info(`  ${i + 1}) ${d.name} (${d.tier})`));
+        }
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await rl.question(`Select platform [1-${detected.length}]: `);
+        rl.close();
+        const idx = parseInt(answer, 10);
+        if (isNaN(idx) || idx < 1 || idx > detected.length) {
+          console.log(error("Invalid selection. Aborting."));
+          return;
+        }
+        detectedPlatform = detected[idx - 1].name;
+      } else if (detected.length > 0) {
+        detectedPlatform = detected[0].name;
+      }
+    }
+    const platform2 = detectedPlatform;
+    const spinner = createSpinner(`Fetching ${slug}...`);
+    if (!globalOpts.json) spinner.start();
+    const params = { platform: platform2 };
+    const installInfo = await client.get(`/install/${encodeURIComponent(slug)}`, params);
+    if (globalOpts.json) {
+      spinner.stop();
+      outputResult(installInfo, { json: true });
+      return;
+    }
+    spinner.text = `Installing ${installInfo.artifact.name}...`;
+    const skipConfirm = Boolean(opts.yes);
+    const cwd = process.cwd();
+    const safeFiles = [];
+    if (installInfo.files && installInfo.files.length > 0) {
+      for (const file of installInfo.files) {
+        const resolvedPath = resolve(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 ?? "" });
+      }
+    }
+    const hasFiles = safeFiles.length > 0;
+    const hasInstallCmd = Boolean(installInfo.installCommand);
+    const hasPostHook = Boolean(installInfo.postInstallHook);
+    if (!skipConfirm && (hasFiles || hasInstallCmd || hasPostHook)) {
+      spinner.stop();
+      console.log(info("\n--- Install plan ---"));
+      if (hasFiles) {
+        console.log(info("Files to write:"));
+        for (const f of safeFiles) {
+          console.log(info(`  ${f.resolvedPath}`));
+        }
+      }
+      if (hasInstallCmd) {
+        console.log(info(`Install command: ${installInfo.installCommand}`));
+      }
+      if (hasPostHook) {
+        console.log(info(`Post-install hook: ${installInfo.postInstallHook}`));
+      }
+      console.log();
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await rl.question("Continue? (y/N) ");
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log(info("Installation cancelled."));
+        return;
+      }
+      spinner.start();
+    }
+    const writtenFiles = [];
+    const resolvedPlatform = detectedPlatform ?? "generic";
+    let registryWritten = false;
+    let mcpRegistered = false;
+    let skillInstalled = false;
+    const rollback = async () => {
+      for (const filePath of writtenFiles) {
+        try {
+          if (existsSync7(filePath)) unlinkSync2(filePath);
+        } catch {
+        }
+      }
+      if (registryWritten) {
+        try {
+          removeRegistryEntry(slug, resolvedPlatform);
+        } catch {
+        }
+      }
+      const adapter2 = getPlatformAdapter(resolvedPlatform);
+      if (mcpRegistered) {
+        try {
+          await adapter2.unregisterMcp();
+        } catch {
+        }
+      }
+      if (skillInstalled && adapter2.uninstallSkill) {
+        try {
+          await adapter2.uninstallSkill(slug);
+        } catch {
+        }
+      }
+      if (writtenFiles.length > 0) {
+        console.log(info(`Rolled back ${writtenFiles.length} file(s) written during install.`));
+      }
+    };
+    try {
+      for (const file of safeFiles) {
+        const dir = dirname3(file.resolvedPath);
+        if (!existsSync7(dir)) {
+          mkdirSync6(dir, { recursive: true });
+        }
+        writeFileSync6(file.resolvedPath, file.content, "utf-8");
+        writtenFiles.push(file.resolvedPath);
+      }
+      if (installInfo.installCommand) {
+        execSync3(installInfo.installCommand, { stdio: "pipe" });
+      }
+      if (installInfo.postInstallHook) {
+        try {
+          execSync3(installInfo.postInstallHook, { stdio: "pipe" });
+        } catch {
+        }
+      }
+    } catch (err) {
+      spinner.stop();
+      console.error(error(`Install failed: ${err instanceof Error ? err.message : String(err)}`));
+      await rollback();
+      client.post("/telemetry/install", {
+        artifactSlug: slug,
+        platform: platform2,
+        success: false,
+        errorMessage: err instanceof Error ? err.message : String(err)
+      }).catch(() => {
+      });
+      process.exit(1);
+    }
+    spinner.stop();
+    console.log(success(`Installed ${installInfo.artifact.name}`));
+    if (installInfo.contract?.touchedPaths) {
+      console.log(info(`Files: ${installInfo.contract.touchedPaths.join(", ")}`));
+    }
+    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"
+    });
+    registryWritten = true;
+    const adapter = getPlatformAdapter(resolvedPlatform);
+    const primitive = installInfo.artifact.primitive;
+    if (primitive === "connector") {
+      try {
+        await adapter.registerMcp(getDefaultMcpConfig());
+        mcpRegistered = true;
+      } catch {
+      }
+    }
+    if ((primitive === "executable" || primitive === "composition") && adapter.installSkill) {
+      try {
+        const content = safeFiles.map((f) => f.content).join("\n");
+        await adapter.installSkill(slug, content);
+        skillInstalled = true;
+      } catch {
+      }
+    }
+    client.post("/telemetry/install", {
+      artifactSlug: slug,
+      platform: platform2,
+      success: true
+    }).catch(() => {
+    });
+  });
+}
+
+// src/commands/init.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin, stdout } from "process";
+
+// src/auth.ts
+import { createServer } from "http";
+import { execFile } from "child_process";
+import { URL as URL2 } from "url";
+import { platform } from "os";
+import { randomBytes } from "crypto";
+var TIMEOUT_MS = 6e4;
+function openBrowser(url) {
+  const os = platform();
+  return new Promise((resolve3) => {
+    if (os === "darwin") {
+      execFile("open", [url], (err) => resolve3(!err));
+    } else if (os === "win32") {
+      execFile("cmd", ["/c", "start", "", url], (err) => resolve3(!err));
+    } else {
+      execFile("xdg-open", [url], (err) => resolve3(!err));
+    }
+  });
+}
+async function authenticate(apiUrl, port = 0) {
+  const state = randomBytes(16).toString("hex");
+  return new Promise((resolve3, reject) => {
+    const server = createServer((req, res) => {
+      const actualPort = server.address().port;
+      const reqUrl = new URL2(req.url ?? "/", `http://localhost:${actualPort}`);
+      if (reqUrl.pathname !== "/callback") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+        return;
+      }
+      const returnedState = reqUrl.searchParams.get("state");
+      if (returnedState !== state) {
+        res.writeHead(403, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h2>Authentication failed</h2><p>Invalid state parameter (possible CSRF). You can close this tab.</p></body></html>"
+        );
+        return;
+      }
+      const apiKeyParam = reqUrl.searchParams.get("api_key");
+      if (!apiKeyParam) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h2>Authentication failed</h2><p>No API key received. You can close this tab.</p></body></html>"
+        );
+        cleanup();
+        reject(new Error("No API key received in callback"));
+        return;
+      }
+      setApiKey(apiKeyParam);
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(
+        "<html><body><h2>Authenticated!</h2><p>You can close this tab and return to your terminal.</p></body></html>"
+      );
+      cleanup();
+      resolve3(apiKeyParam);
+    });
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error("Authentication timed out after 60 seconds"));
+    }, TIMEOUT_MS);
+    function cleanup() {
+      clearTimeout(timeout);
+      server.close();
+    }
+    server.listen(port, async () => {
+      const actualPort = server.address().port;
+      const callbackUrl = `http://localhost:${actualPort}/callback`;
+      const loginUrl = `${apiUrl}/auth/signin?redirect=${encodeURIComponent(callbackUrl)}&state=${encodeURIComponent(state)}`;
+      console.log(info(`Listening on http://localhost:${actualPort} for callback...`));
+      const opened = await openBrowser(loginUrl);
+      if (opened) {
+        console.log(info("Browser opened. Complete sign-in to continue."));
+      } else {
+        console.log(
+          error("Could not open browser automatically.")
+        );
+        console.log(info(`Open this URL manually:
+  ${loginUrl}`));
+      }
+    });
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(
+        new Error(
+          `Failed to start auth server: ${err.message}`
+        )
+      );
+    });
+  });
+}
+
+// src/commands/init.ts
+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) => {
+    const config = readConfig();
+    if (opts.auth) {
+      console.log(info("Opening browser for authentication..."));
+      try {
+        const apiKey = await authenticate(config.apiUrl);
+        config.apiKey = apiKey;
+        writeConfig(config);
+        console.log(success("Authenticated and saved API key"));
+        console.log(info(`Config saved to ~/.caik/config.json`));
+      } catch (err) {
+        console.log(error(`Authentication failed: ${err instanceof Error ? err.message : String(err)}`));
+      }
+      return;
+    }
+    const rl = createInterface2({ input: stdin, output: stdout });
+    try {
+      const apiUrl = await rl.question(`API URL (${config.apiUrl}): `);
+      if (apiUrl.trim()) {
+        config.apiUrl = apiUrl.trim();
+      }
+      const apiKey = await rl.question("API Key (leave blank to skip): ");
+      if (apiKey.trim()) {
+        config.apiKey = apiKey.trim();
+      }
+      writeConfig(config);
+      console.log(success("CAIK CLI configured"));
+      console.log(info(`Config saved to ~/.caik/config.json`));
+      if (config.apiKey) {
+        const client = new CaikApiClient({ apiUrl: config.apiUrl, apiKey: config.apiKey });
+        try {
+          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();
+    }
+  });
+}
+
+// src/commands/status.ts
+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 { apiUrl, apiKey } = resolveConfig(globalOpts);
+    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) {
+          const karma = await client2.get("/me/karma");
+          data.authenticated = true;
+          data.user = karma;
+        }
+        data.apiReachable = true;
+      } catch {
+        data.apiReachable = false;
+        data.authenticated = false;
+      }
+      outputResult(data, { json: true });
+      return;
+    }
+    console.log(heading("CAIK CLI Status"));
+    console.log("\u2550".repeat(40));
+    console.log(`API URL:          ${apiUrl}`);
+    console.log(`API Key:          ${apiKey ? `${dim("configured")} (${apiKey.slice(0, 12)}...)` : dim("not set")}`);
+    const client = new CaikApiClient({ apiUrl, apiKey, verbose: globalOpts.verbose });
+    try {
+      if (apiKey) {
+        const karma = await client.get("/me/karma");
+        console.log(`Authenticated:    ${success("yes")}`);
+        console.log(`User:             ${karma.handle ?? karma.displayName ?? "unknown"} (${karma.karmaTier})`);
+      } else {
+        console.log(`Authenticated:    ${dim("no (no API key)")}`);
+      }
+    } catch {
+      console.log(`API Reachable:    ${error("no")}`);
+    }
+    console.log("");
+    console.log(heading("Platform Integration"));
+    console.log("\u2500".repeat(40));
+    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`
+      );
+    }
+  });
+}
+
+// src/commands/stats.ts
+var PRIMITIVES = ["executable", "knowledge", "connector", "composition", "reference"];
+function registerStatsCommand(program2) {
+  program2.command("stats").description("Show CAIK ecosystem statistics").addHelpText("after", `
+Examples:
   caik stats
   caik stats --json`).action(async () => {
     const globalOpts = program2.opts();
@@ -552,7 +1868,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 +1882,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 +2046,341 @@ 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 === "connector" || 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();
+        }
+      }
+    }
+    const skillTypes = /* @__PURE__ */ new Set(["executable", "composition", "skill", "subagent", "command"]);
+    if (skillTypes.has(entry.artifactType) && 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 +2410,780 @@ 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").option("--platform <name>", "Platform name", "claude-code").action(async (opts) => {
+    try {
+      const client = createClient(program2);
+      const event = {
+        type: "session_start",
+        platform: opts.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").option("--platform <name>", "Platform name", "claude-code").action(async (opts) => {
+    try {
+      const client = createClient(program2);
+      const pending = readPendingEvents();
+      const endEvent = {
+        type: "session_end",
+        platform: opts.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("--platform <name>", "Platform name", "claude-code").option("--tool <name>", "Tool name").option("--success <bool>", "Whether the tool call succeeded").action(async (opts) => {
+    try {
+      const event = {
+        type: "tool_use",
+        platform: opts.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";
+import { existsSync as existsSync12 } from "fs";
+
+// src/platform/templates/claude-code-skill.ts
+function getClaudeCodeSkillContent() {
+  return `---
+name: caik
+description: Search, install, and manage AI coding artifacts (skills, rules, prompts, MCP servers, knowledge packs) from the CAIK community registry. Use when the user wants to find reusable building blocks, install artifacts, or contribute back to the community.
+---
+
+# 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 `---
+name: caik
+description: Search, install, and manage AI coding artifacts (skills, rules, prompts, MCP servers, knowledge packs) from the CAIK community registry. Use when the user wants to find reusable building blocks, install artifacts, or contribute back to the community.
+---
+
+# 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 `---
+name: caik
+description: Search, install, and manage AI coding artifacts (skills, rules, prompts, MCP servers, knowledge packs) from the CAIK community registry. Use when the user wants to find reusable building blocks, install artifacts, or contribute back to the community.
+---
+
+# 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.
+
+## Contribution Tracking
+
+CAIK uses OpenClaw lifecycle hooks to track artifact usage. When you invoke a CAIK-installed skill, outcome data is reported automatically to build your contribution level and community karma. You can disable it with \`caik config set contributions 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(platform2) {
+  switch (platform2) {
+    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(platform2) {
+  if (platform2 === "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 (platform2 === "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 --platform openclaw",
+      session_end: "npx -y @caik.dev/cli hook session-end --platform openclaw",
+      after_tool_call: "npx -y @caik.dev/cli hook post-tool-use --platform openclaw"
+    }
+  };
+}
+async function runRepair() {
+  console.log(heading("\nCAIK Repair"));
+  console.log("\u2550".repeat(40));
+  console.log();
+  const spinner = createSpinner("Detecting platforms...");
+  spinner.start();
+  const detected = detectPlatforms();
+  spinner.stop();
+  if (detected.length === 0) {
+    console.log(warn("No supported agent platforms detected. Nothing to repair."));
+    return;
+  }
+  console.log(info(`Detected ${detected.length} platform(s): ${detected.map((p) => p.name).join(", ")}`));
+  console.log();
+  let repairedMcp = 0;
+  let repairedHooks = 0;
+  let repairedSkills = 0;
+  const registryWarnings = [];
+  for (const platform2 of detected) {
+    console.log(heading(`Checking ${platform2.name}...`));
+    console.log("\u2500".repeat(40));
+    const adapter = getPlatformAdapter(platform2.name);
+    let mcpRegistered = false;
+    try {
+      mcpRegistered = await adapter.isRegistered();
+    } catch {
+    }
+    if (mcpRegistered) {
+      console.log(`  MCP server:  ${success("registered")}`);
+    } else {
+      const mcpSpinner = createSpinner("  Re-registering MCP server...");
+      mcpSpinner.start();
+      try {
+        const mcpConfig = getDefaultMcpConfig();
+        await adapter.registerMcp(mcpConfig);
+        mcpSpinner.stop();
+        console.log(`  MCP server:  ${success("repaired")} (re-registered)`);
+        repairedMcp++;
+      } catch (err) {
+        mcpSpinner.stop();
+        console.log(`  MCP server:  ${error(`repair failed: ${err instanceof Error ? err.message : String(err)}`)}`);
+      }
+    }
+    if (adapter.registerHooks && platform2.capabilities.hooks) {
+      const hookSpinner = createSpinner("  Ensuring hooks are registered...");
+      hookSpinner.start();
+      try {
+        const hookConfig = getHookConfig(platform2.name);
+        await adapter.registerHooks(hookConfig);
+        hookSpinner.stop();
+        console.log(`  Hooks:       ${success("ensured")}`);
+        repairedHooks++;
+      } catch (err) {
+        hookSpinner.stop();
+        console.log(`  Hooks:       ${error(`repair failed: ${err instanceof Error ? err.message : String(err)}`)}`);
+      }
+    } else if (!platform2.capabilities.hooks) {
+      console.log(`  Hooks:       ${dim("not supported on this platform")}`);
+    }
+    if (adapter.installSkill && platform2.capabilities.skills) {
+      const skillSpinner = createSpinner("  Ensuring SKILL.md is installed...");
+      skillSpinner.start();
+      try {
+        const content = getSkillContent(platform2.name);
+        await adapter.installSkill("caik", content);
+        skillSpinner.stop();
+        console.log(`  SKILL.md:    ${success("ensured")}`);
+        repairedSkills++;
+      } catch (err) {
+        skillSpinner.stop();
+        console.log(`  SKILL.md:    ${error(`repair failed: ${err instanceof Error ? err.message : String(err)}`)}`);
+      }
+    } else if (!platform2.capabilities.skills) {
+      console.log(`  SKILL.md:    ${dim("not supported on this platform")}`);
+    }
+    console.log();
+  }
+  const registryEntries = listRegistryEntries();
+  if (registryEntries.length > 0) {
+    console.log(heading("Registry Integrity"));
+    console.log("\u2500".repeat(40));
+    let cleanEntries = 0;
+    for (const entry of registryEntries) {
+      const missing = entry.files.filter((f) => !existsSync12(f));
+      if (missing.length > 0) {
+        const msg = `${entry.slug} (${entry.platform}): ${missing.length} missing file(s)`;
+        registryWarnings.push(msg);
+        console.log(`  ${warn(msg)}`);
+        for (const f of missing) {
+          console.log(`    ${dim(f)}`);
+        }
+      } else {
+        cleanEntries++;
+      }
+    }
+    if (registryWarnings.length === 0) {
+      console.log(`  ${success("All")} ${registryEntries.length} registry entries have their files intact.`);
+    } else if (cleanEntries > 0) {
+      console.log(`  ${success(`${cleanEntries}`)} entries OK, ${warn(`${registryWarnings.length}`)} with missing files.`);
+    }
+    if (registryWarnings.length > 0) {
+      console.log();
+      console.log(
+        dim("  Artifact files cannot be auto-repaired. Run `caik install <slug>` to reinstall.")
+      );
+    }
+    console.log();
+  }
+  console.log(heading("Repair Summary"));
+  console.log("\u2550".repeat(40));
+  const actions = [];
+  if (repairedMcp > 0) actions.push(`${repairedMcp} MCP registration(s) repaired`);
+  if (repairedHooks > 0) actions.push(`${repairedHooks} hook registration(s) ensured`);
+  if (repairedSkills > 0) actions.push(`${repairedSkills} skill installation(s) ensured`);
+  if (registryWarnings.length > 0) actions.push(`${registryWarnings.length} registry warning(s)`);
+  if (actions.length === 0) {
+    console.log(success("Everything looks good. No repairs needed."));
+  } else {
+    for (const a of actions) {
+      console.log(`  ${info(a)}`);
+    }
+  }
+  console.log();
+}
+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("--repair", "Detect and fix configuration drift (re-register MCP, hooks, skills)").option("-y, --yes", "Accept all defaults (non-interactive)").addHelpText("after", `
+Examples:
+  caik setup
+  caik setup --platform claude-code
+  caik setup --yes --skip-hooks
+  caik setup --repair`).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;
+    const repair = Boolean(opts.repair);
+    if (repair) {
+      await runRepair();
+      return;
+    }
+    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 platform2 of selected) {
+      console.log(heading(`Configuring ${platform2.name}...`));
+      console.log("\u2500".repeat(40));
+      const adapter = getPlatformAdapter(platform2.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 && platform2.capabilities.hooks) {
+        const hookSpinner = createSpinner("Registering hooks...");
+        hookSpinner.start();
+        try {
+          const hookConfig = getHookConfig(platform2.name);
+          await adapter.registerHooks(hookConfig);
+          hookSpinner.stop();
+          console.log(success("Hooks registered"));
+          if (platform2.name === "openclaw") {
+            console.log(dim("  Restart the OpenClaw gateway to load hooks: openclaw daemon restart"));
+          }
+        } catch (err) {
+          hookSpinner.stop();
+          console.log(error(`Failed to register hooks: ${err instanceof Error ? err.message : String(err)}`));
+        }
+      } else if (!skipHooks && !platform2.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 && platform2.capabilities.skills) {
+        const skillSpinner = createSpinner("Installing SKILL.md...");
+        skillSpinner.start();
+        try {
+          const content = getSkillContent(platform2.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/commands/upgrade.ts
+import { execSync as execSync5 } from "child_process";
+
+// src/update-check.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, existsSync as existsSync13 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir7 } from "os";
+import chalk2 from "chalk";
+var PKG_NAME = "@caik.dev/cli";
+var CACHE_PATH = join8(homedir7(), ".caik", "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function readCache() {
+  try {
+    const raw = readFileSync8(CACHE_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCache(entry) {
+  const dir = join8(homedir7(), ".caik");
+  if (!existsSync13(dir)) {
+    mkdirSync9(dir, { recursive: true });
+  }
+  writeFileSync9(CACHE_PATH, JSON.stringify(entry) + "\n", "utf-8");
+}
+function getCurrentVersion() {
+  try {
+    const pkgPath = join8(
+      new URL(".", import.meta.url).pathname,
+      "..",
+      "package.json"
+    );
+    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch(
+      `https://registry.npmjs.org/${PKG_NAME}/latest`,
+      { signal: controller.signal }
+    );
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(latest, current) {
+  const a = latest.split(".").map(Number);
+  const b = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return true;
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return false;
+  }
+  return false;
+}
+async function checkForUpdate(opts = {}) {
+  const current = getCurrentVersion();
+  if (!opts.force) {
+    const cache = readCache();
+    if (cache && Date.now() - cache.checkedAt < CHECK_INTERVAL_MS) {
+      return {
+        current,
+        latest: cache.latest,
+        updateAvailable: isNewer(cache.latest, current)
+      };
+    }
+  }
+  const latest = await fetchLatestVersion();
+  if (latest) {
+    writeCache({ latest, checkedAt: Date.now() });
+  }
+  return {
+    current,
+    latest,
+    updateAvailable: latest ? isNewer(latest, current) : false
+  };
+}
+async function printUpdateHint() {
+  try {
+    const info2 = await checkForUpdate();
+    if (info2.updateAvailable && info2.latest) {
+      console.error(
+        chalk2.yellow(
+          `
+  Update available: ${info2.current} \u2192 ${info2.latest}  Run ${chalk2.bold("caik upgrade")} to update
+`
+        )
+      );
+    }
+  } catch {
+  }
+}
+
+// src/commands/upgrade.ts
+function registerUpgradeCommand(program2) {
+  program2.command("upgrade").description("Upgrade the CAIK CLI to the latest version").action(async () => {
+    const spinner = createSpinner("Checking for updates...");
+    spinner.start();
+    const update = await checkForUpdate({ force: true });
+    if (!update.latest) {
+      spinner.stop();
+      console.log(error("Could not determine the latest version. Check your network connection."));
+      return;
+    }
+    if (!update.updateAvailable) {
+      spinner.stop();
+      console.log(success(`Already on the latest version (${update.current})`));
+      return;
+    }
+    spinner.text = `Upgrading ${update.current} \u2192 ${update.latest}...`;
+    try {
+      execSync5("npm install -g @caik.dev/cli@latest", {
+        stdio: "pipe",
+        timeout: 6e4
+      });
+      spinner.stop();
+      console.log(success(`Upgraded to ${update.latest}`));
+    } catch (err) {
+      spinner.stop();
+      console.log(error("Upgrade failed. Try manually:"));
+      console.log(info("npm install -g @caik.dev/cli@latest"));
+    }
+  });
+}
+
 // 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 = join9(__dirname, "..", "package.json");
+  const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
   version = pkg.version;
 } catch {
 }
@@ -793,15 +3201,19 @@ registerAlternativesCommand(program);
 registerUpdateCommand(program);
 registerUninstallCommand(program);
 registerKarmaCommand(program);
+registerHookCommand(program);
+registerSetupCommand(program);
+registerUpgradeCommand(program);
 program.exitOverride();
 async function main() {
+  const updateHint = printUpdateHint();
   try {
     await program.parseAsync(process.argv);
   } catch (err) {
     if (err instanceof CaikError) {
-      console.error(chalk2.red(`\u2717 ${err.message}`));
+      console.error(chalk3.red(`\u2717 ${err.message}`));
       if (err.suggestion) {
-        console.error(chalk2.dim(`  ${err.suggestion}`));
+        console.error(chalk3.dim(`  ${err.suggestion}`));
       }
       process.exit(err.exitCode);
     }
@@ -809,8 +3221,9 @@ async function main() {
       const exitCode = err.exitCode;
       process.exit(exitCode);
     }
-    console.error(chalk2.red(`\u2717 Unexpected error: ${err instanceof Error ? err.message : String(err)}`));
+    console.error(chalk3.red(`\u2717 Unexpected error: ${err instanceof Error ? err.message : String(err)}`));
     process.exit(1);
   }
+  await updateHint;
 }
 main();