skillo 0.2.5 → 0.2.8

package/dist/cli.js

@@ -1,17 +1,42 @@
 #!/usr/bin/env node
+import {
+  recordCommand,
+  setupShellCommand,
+  shellCommand
+} from "./chunk-U53QWUOR.js";
+import {
+  projectCommand,
+  trackCommand,
+  untrackCommand
+} from "./chunk-QIV4VIXA.js";
+import {
+  getServiceStatus,
+  installService,
+  isDaemonRunning,
+  logsCommand,
+  serviceCommand,
+  startCommand,
+  startDaemonProcess,
+  stopCommand
+} from "./chunk-XLJGCOVT.js";
+import {
+  logger_default
+} from "./chunk-VAQ73XPE.js";
+import "./chunk-6UGTWBUW.js";
 import {
   SkilloDatabase
-} from "./chunk-2CVEPT6U.js";
+} from "./chunk-73NUWYUO.js";
 import {
   getApiClient
-} from "./chunk-ODOZM4QV.js";
+} from "./chunk-RQ2SC5HW.js";
 import {
   getConfigValue,
   getDefaultConfig,
   loadConfig,
   saveConfig,
   setConfigValue
-} from "./chunk-CPL3P2OF.js";
+} from "./chunk-QUXHHRRK.js";
+import "./chunk-6GOJPFZ7.js";
 import {
   ensureDirectory,
   getActiveSessionsDir,
@@ -21,564 +46,265 @@ import {
   getDbPath,
   getLogFile,
   getPidFile,
-  getShellIntegrationDir,
   getSkillsDir,
   getTrackedProjectsCacheFile
-} from "./chunk-WJKZWKER.js";
+} from "./chunk-63FVALWX.js";
 
 // src/cli.ts
-import { Command as Command14 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/commands/init.ts
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { createInterface } from "readline";
+import { execSync } from "child_process";
 import { Command } from "commander";
-
-// src/utils/logger.ts
-import chalk from "chalk";
-var logger = {
-  info: (message) => {
-    console.log(chalk.cyan(message));
-  },
-  success: (message) => {
-    console.log(chalk.green(`[+] ${message}`));
-  },
-  warn: (message) => {
-    console.log(chalk.yellow(`[!] ${message}`));
-  },
-  error: (message) => {
-    console.log(chalk.red(`[x] ${message}`));
-  },
-  dim: (message) => {
-    console.log(chalk.dim(message));
-  },
-  bold: (message) => {
-    console.log(chalk.bold(message));
-  },
-  highlight: (message) => {
-    console.log(chalk.bold.cyan(message));
-  },
-  // Status indicators
-  running: (message) => {
-    console.log(chalk.green(`(*) ${message}`));
-  },
-  stopped: (message) => {
-    console.log(chalk.dim(`(-) ${message}`));
-  },
-  // For lists and tables
-  item: (label, value) => {
-    console.log(`  ${chalk.dim(label)}: ${chalk.white(value)}`);
-  },
-  // Blank line
-  blank: () => {
-    console.log();
-  },
-  // Box/panel output
-  box: (title, content) => {
-    const lines = content.split("\n");
-    const maxLen = Math.max(title.length, ...lines.map((l) => l.length));
-    const border = "\u2500".repeat(maxLen + 2);
-    console.log(chalk.dim(`\u250C${border}\u2510`));
-    console.log(chalk.dim("\u2502 ") + chalk.bold(title.padEnd(maxLen)) + chalk.dim(" \u2502"));
-    console.log(chalk.dim(`\u251C${border}\u2524`));
-    lines.forEach((line) => {
-      console.log(chalk.dim("\u2502 ") + line.padEnd(maxLen) + chalk.dim(" \u2502"));
+function statusIcon(status) {
+  if (status === "success") return "\u2713";
+  if (status === "failure") return "\u2717";
+  return "\u2298";
+}
+function askQuestion(prompt) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve, reject) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer.trim());
     });
-    console.log(chalk.dim(`\u2514${border}\u2518`));
-  },
-  // Table output
-  table: (rows) => {
-    const maxLabel = Math.max(...rows.map(([label]) => label.length));
-    rows.forEach(([label, value]) => {
-      console.log(`  ${chalk.dim(label.padEnd(maxLabel))}  ${chalk.white(value)}`);
+    rl.on("error", (err) => {
+      rl.close();
+      reject(err);
     });
+  });
+}
+function isGitRepo() {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
   }
-};
-var logger_default = logger;
-
-// src/commands/init.ts
-var initCommand = new Command("init").description("Initialize Skillo configuration and directories").option("-f, --force", "Overwrite existing configuration").action(async (options) => {
-  logger_default.blank();
-  logger_default.bold("Initializing Skillo...");
-  logger_default.blank();
-  const dataDir = getDataDir();
-  const configDir = getConfigDir();
-  const skillsDir = getSkillsDir();
-  const configFile = getConfigFile();
-  if (existsSync(configFile) && !options.force) {
-    logger_default.warn("Skillo is already initialized.");
-    logger_default.dim("Use --force to reinitialize and overwrite configuration.");
-    return;
+}
+function detectShell() {
+  if (process.platform === "win32") return "powershell";
+  const currentShell = process.env.SHELL || "";
+  if (currentShell.includes("zsh")) return "zsh";
+  if (currentShell.includes("fish")) return "fish";
+  return "bash";
+}
+function isShellIntegrationInstalled() {
+  const home = homedir();
+  const shell = detectShell();
+  const filesToCheck = [];
+  if (shell === "bash") {
+    filesToCheck.push({ path: join(home, ".bashrc"), marker: "Skillo CLI Integration" });
+  } else if (shell === "zsh") {
+    filesToCheck.push({ path: join(home, ".zshrc"), marker: "Skillo CLI Integration" });
+  } else if (shell === "powershell") {
+    filesToCheck.push({
+      path: join(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1"),
+      marker: "Skillo CLI Integration"
+    });
+  } else if (shell === "fish") {
+    filesToCheck.push({
+      path: join(home, ".config", "fish", "config.fish"),
+      marker: "Skillo CLI Integration"
+    });
   }
-  const directories = [
-    { path: dataDir, name: "~/.skillo/" },
-    { path: configDir, name: "~/.config/skillo/" },
-    { path: skillsDir, name: "~/.claude/skills/" }
-  ];
-  for (const { path: path2, name } of directories) {
-    if (ensureDirectory(path2)) {
-      logger_default.success(`Created ${name}`);
-    } else {
-      logger_default.dim(`  [-] ${name} already exists`);
+  for (const { path: path3, marker } of filesToCheck) {
+    try {
+      if (existsSync(path3) && readFileSync(path3, "utf-8").includes(marker)) {
+        return true;
+      }
+    } catch {
     }
   }
-  const config = getDefaultConfig();
-  saveConfig(config);
-  logger_default.success("Created default configuration");
-  const db = new SkilloDatabase();
-  await db.initialize();
-  db.close();
-  logger_default.success("Initialized database");
-  logger_default.blank();
-  logger_default.bold("Skillo initialized successfully!");
-  logger_default.blank();
-  logger_default.box(
-    "Next steps:",
-    `1. Start the daemon:
-   skillo start
-
-2. Use the tracked shell:
-   skillo shell
-
-3. Work normally - Skillo will notify you of patterns!`
-  );
-  logger_default.blank();
-});
-
-// src/commands/status.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { Command as Command2 } from "commander";
-
-// src/utils/os-service.ts
-import { existsSync as existsSync2, writeFileSync, unlinkSync, mkdirSync, readdirSync } from "fs";
-import { join } from "path";
-import { homedir, platform } from "os";
-import { execSync } from "child_process";
-var DAEMON_LABEL = "one.skillo.daemon";
-var TRAY_LABEL = "one.skillo.tray";
-var WIN_REG_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
-var WIN_DAEMON_VALUE = "SkilloDaemon";
-var WIN_TRAY_VALUE = "SkilloTray";
-var isWin = platform() === "win32";
-var pathSep = isWin ? ";" : ":";
-function getLaunchAgentsDir() {
-  return join(homedir(), "Library", "LaunchAgents");
-}
-function getSystemdUserDir() {
-  return join(homedir(), ".config", "systemd", "user");
-}
-function getDaemonPlistPath() {
-  return join(getLaunchAgentsDir(), `${DAEMON_LABEL}.plist`);
-}
-function getTrayPlistPath() {
-  return join(getLaunchAgentsDir(), `${TRAY_LABEL}.plist`);
-}
-function getDaemonServicePath() {
-  return join(getSystemdUserDir(), "skillo-daemon.service");
-}
-function getTrayServicePath() {
-  return join(getSystemdUserDir(), "skillo-tray.service");
-}
-function getSkilloDataDir() {
-  return join(homedir(), ".skillo");
-}
-function getWinDaemonVbsPath() {
-  return join(getSkilloDataDir(), "skillo-daemon.vbs");
+  return false;
 }
-function findSkilloBin() {
-  try {
-    const whichCmd = isWin ? "where skillo" : "which skillo";
-    const result = execSync(whichCmd, { encoding: "utf-8" }).trim();
-    const firstLine = result.split(/\r?\n/)[0].trim();
-    if (firstLine) return firstLine;
-  } catch {
+function isDaemonActuallyRunning() {
+  const pidFile = getPidFile();
+  if (!existsSync(pidFile)) {
+    return { running: false, pid: null };
   }
-  if (isWin) {
-    const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
-    const candidates = [
-      join(appData, "npm", "skillo.cmd"),
-      join(homedir(), "AppData", "Local", "fnm_multishells")
-    ];
-    for (const c of candidates) {
-      if (existsSync2(c)) return c;
+  try {
+    const pidStr = readFileSync(pidFile, "utf-8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (isNaN(pid)) {
+      return { running: false, pid: null };
     }
-  } else {
-    const candidates = [
-      "/usr/local/bin/skillo",
-      "/usr/bin/skillo"
-    ];
-    for (const c of candidates) {
-      if (existsSync2(c)) return c;
+    try {
+      process.kill(pid, 0);
+      return { running: true, pid };
+    } catch {
+      return { running: false, pid: null };
     }
+  } catch {
+    return { running: false, pid: null };
   }
-  return "skillo";
 }
-function buildPath() {
-  const paths = /* @__PURE__ */ new Set();
-  const home = homedir();
-  (process.env.PATH || "").split(pathSep).forEach((p) => paths.add(p));
-  if (isWin) {
-    const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
-    paths.add(join(appData, "npm"));
-    paths.add(join(home, "AppData", "Local", "Programs", "nodejs"));
-    const nvmHome = process.env.NVM_HOME;
-    if (nvmHome) paths.add(nvmHome);
-    const nvmSymlink = process.env.NVM_SYMLINK;
-    if (nvmSymlink) paths.add(nvmSymlink);
-    const fnmDir = join(home, ".fnm");
-    if (existsSync2(fnmDir)) paths.add(fnmDir);
-  } else {
-    const nvmDir = process.env.NVM_DIR || join(home, ".nvm");
-    if (existsSync2(nvmDir)) {
-      try {
-        const defaultAlias = join(nvmDir, "alias", "default");
-        if (existsSync2(defaultAlias)) {
-          const versionsDir = join(nvmDir, "versions", "node");
-          if (existsSync2(versionsDir)) {
-            const versions = readdirSync(versionsDir);
-            for (const v of versions) {
-              paths.add(join(versionsDir, v, "bin"));
-            }
-          }
+async function stepAuth() {
+  try {
+    const { getApiClient: getApiClient2 } = await import("./api-client-BF6GDR7Q.js");
+    const client = getApiClient2();
+    const isAuthUser = (obj) => typeof obj === "object" && obj !== null && "id" in obj && "email" in obj && "name" in obj;
+    const getUserFromAuth = (result) => {
+      const data = result.data;
+      const candidate = data?.user || result.user;
+      return isAuthUser(candidate) ? candidate : void 0;
+    };
+    if (client.hasApiKey()) {
+      const authResult = await client.authenticate();
+      if (authResult.success) {
+        const user = getUserFromAuth(authResult);
+        if (user) {
+          logger_default.success(`Already logged in as ${user.name}`);
+          return { status: "success", message: `logged in as ${user.email}`, email: user.email };
         }
-      } catch {
       }
     }
-    paths.add(join(home, ".fnm", "current", "bin"));
-    paths.add("/opt/homebrew/bin");
-    paths.add("/usr/local/bin");
-    paths.add("/usr/bin");
-    paths.add("/bin");
-    paths.add(join(home, ".npm-global", "bin"));
-    paths.add(join(home, ".local", "bin"));
-  }
-  return [...paths].filter(Boolean).join(pathSep);
-}
-function generateDaemonPlist(skilloBin, envPath) {
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>${DAEMON_LABEL}</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>${skilloBin}</string>
-        <string>start</string>
-        <string>--foreground</string>
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <dict>
-        <key>SuccessfulExit</key>
-        <false/>
-    </dict>
-    <key>ThrottleInterval</key>
-    <integer>10</integer>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>${envPath}</string>
-        <key>HOME</key>
-        <string>${homedir()}</string>
-    </dict>
-    <key>StandardOutPath</key>
-    <string>${join(homedir(), ".skillo", "launchd-stdout.log")}</string>
-    <key>StandardErrorPath</key>
-    <string>${join(homedir(), ".skillo", "launchd-stderr.log")}</string>
-</dict>
-</plist>`;
-}
-function generateTrayPlist(skilloBin, envPath) {
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>${TRAY_LABEL}</string>
-    <key>ProgramArguments</key>
-    <array>
-        <string>${skilloBin}</string>
-        <string>tray</string>
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>LimitLoadToSessionType</key>
-    <string>Aqua</string>
-    <key>KeepAlive</key>
-    <dict>
-        <key>SuccessfulExit</key>
-        <false/>
-    </dict>
-    <key>ThrottleInterval</key>
-    <integer>10</integer>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>${envPath}</string>
-        <key>HOME</key>
-        <string>${homedir()}</string>
-    </dict>
-    <key>StandardOutPath</key>
-    <string>${join(homedir(), ".skillo", "launchd-tray-stdout.log")}</string>
-    <key>StandardErrorPath</key>
-    <string>${join(homedir(), ".skillo", "launchd-tray-stderr.log")}</string>
-</dict>
-</plist>`;
-}
-function generateDaemonUnit(skilloBin, envPath) {
-  return `[Unit]
-Description=Skillo Daemon
-After=network.target
-
-[Service]
-Type=simple
-ExecStart=${skilloBin} start --foreground
-Restart=on-failure
-RestartSec=10
-Environment=PATH=${envPath}
-Environment=HOME=${homedir()}
-
-[Install]
-WantedBy=default.target
-`;
-}
-function generateTrayUnit(skilloBin, envPath) {
-  return `[Unit]
-Description=Skillo Tray Icon
-After=graphical-session.target
-PartOf=graphical-session.target
-
-[Service]
-Type=simple
-ExecStart=${skilloBin} tray
-Restart=on-failure
-RestartSec=10
-Environment=PATH=${envPath}
-Environment=HOME=${homedir()}
-Environment=DISPLAY=:0
-
-[Install]
-WantedBy=graphical-session.target
-`;
-}
-function generateDaemonVbs(skilloBin) {
-  const escaped = skilloBin.replace(/\\/g, "\\\\");
-  return `' Skillo Daemon \u2014 hidden launcher\r
-Set WshShell = CreateObject("WScript.Shell")\r
-WshShell.Run """${escaped}"" start --foreground", 0, False\r
-`;
-}
-function winRegAdd(valueName, data) {
-  execSync(
-    `reg add "${WIN_REG_KEY}" /v "${valueName}" /t REG_SZ /d "${data}" /f`,
-    { stdio: "ignore" }
-  );
-}
-function winRegDelete(valueName) {
-  try {
-    execSync(
-      `reg delete "${WIN_REG_KEY}" /v "${valueName}" /f`,
-      { stdio: "ignore" }
-    );
-  } catch {
+    const { ensureLoggedIn } = await import("./daemon-6DTCMOJB.js");
+    const loggedIn = await ensureLoggedIn();
+    if (loggedIn) {
+      const authResult = await client.authenticate();
+      const user = getUserFromAuth(authResult);
+      const email = user?.email || "unknown";
+      return { status: "success", message: `logged in as ${email}`, email };
+    }
+    return { status: "failure", message: "login failed" };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : "unknown error";
+    logger_default.error(`Authentication error: ${msg}`);
+    return { status: "failure", message: msg };
   }
 }
-function winRegExists(valueName) {
+async function stepShellIntegration() {
   try {
-    execSync(`reg query "${WIN_REG_KEY}" /v "${valueName}"`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
+    if (isShellIntegrationInstalled()) {
+      const shell2 = detectShell();
+      logger_default.success(`Shell integration already configured (${shell2})`);
+      return { status: "success", message: `${shell2} hooks installed` };
+    }
+    const { setupShellCommand: setupShellCommand2 } = await import("./shell-NZABRJLA.js");
+    await setupShellCommand2.parseAsync([], { from: "user" });
+    const shell = detectShell();
+    return { status: "success", message: `${shell} hooks installed` };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : "unknown error";
+    logger_default.error(`Shell integration error: ${msg}`);
+    return { status: "failure", message: msg };
   }
 }
-async function installService(options) {
-  const os2 = platform();
-  const skilloBin = findSkilloBin();
-  const envPath = buildPath();
-  const includeTray = options?.includeTray ?? true;
+async function stepTrackProject(loggedIn) {
   try {
-    if (os2 === "darwin") {
-      const agentsDir = getLaunchAgentsDir();
-      if (!existsSync2(agentsDir)) mkdirSync(agentsDir, { recursive: true });
-      const daemonPlist = getDaemonPlistPath();
-      writeFileSync(daemonPlist, generateDaemonPlist(skilloBin, envPath), "utf-8");
-      try {
-        execSync(`launchctl unload "${daemonPlist}" 2>/dev/null`);
-      } catch {
-      }
-      execSync(`launchctl load "${daemonPlist}"`);
-      if (includeTray) {
-        const trayPlist = getTrayPlistPath();
-        writeFileSync(trayPlist, generateTrayPlist(skilloBin, envPath), "utf-8");
-        try {
-          execSync(`launchctl unload "${trayPlist}" 2>/dev/null`);
-        } catch {
-        }
-        execSync(`launchctl load "${trayPlist}"`);
-      }
-      return { success: true };
-    } else if (os2 === "linux") {
-      const systemdDir = getSystemdUserDir();
-      if (!existsSync2(systemdDir)) mkdirSync(systemdDir, { recursive: true });
-      writeFileSync(getDaemonServicePath(), generateDaemonUnit(skilloBin, envPath), "utf-8");
-      execSync("systemctl --user daemon-reload");
-      execSync("systemctl --user enable skillo-daemon.service");
-      execSync("systemctl --user start skillo-daemon.service");
-      if (includeTray) {
-        writeFileSync(getTrayServicePath(), generateTrayUnit(skilloBin, envPath), "utf-8");
-        execSync("systemctl --user daemon-reload");
-        execSync("systemctl --user enable skillo-tray.service");
-        try {
-          execSync("systemctl --user start skillo-tray.service");
-        } catch {
-        }
-      }
-      return { success: true };
-    } else if (os2 === "win32") {
-      const dataDir = getSkilloDataDir();
-      if (!existsSync2(dataDir)) mkdirSync(dataDir, { recursive: true });
-      const vbsPath = getWinDaemonVbsPath();
-      writeFileSync(vbsPath, generateDaemonVbs(skilloBin), "utf-8");
-      winRegAdd(WIN_DAEMON_VALUE, `wscript.exe "${vbsPath}"`);
-      if (includeTray) {
-        winRegAdd(WIN_TRAY_VALUE, `"${skilloBin}" tray`);
-      }
-      return { success: true };
-    } else {
-      return { success: false, error: `Unsupported platform: ${os2}. Auto-start is available on macOS, Linux, and Windows.` };
-    }
+    if (!loggedIn) {
+      logger_default.dim("  Skipping project tracking (login required)");
+      return { status: "skipped", message: "login required" };
+    }
+    if (!isGitRepo()) {
+      logger_default.dim("  Not a git repository, skipping project tracking");
+      return { status: "skipped", message: "not a git repository" };
+    }
+    const { getApiClient: getApiClient2 } = await import("./api-client-BF6GDR7Q.js");
+    const client = getApiClient2();
+    const trackStatus = await client.isProjectTracked(process.cwd());
+    if (trackStatus.tracked) {
+      logger_default.success(`Project already tracked: ${trackStatus.project?.name || process.cwd()}`);
+      return { status: "success", message: `${process.cwd()} tracked` };
+    }
+    const answer = await askQuestion("  Track this project? (Y/n) ");
+    if (answer.toLowerCase() === "n") {
+      return { status: "skipped", message: "user declined" };
+    }
+    const { trackCommand: trackCommand2 } = await import("./project-OFU2W6MH.js");
+    await trackCommand2.parseAsync([], { from: "user" });
+    return { status: "success", message: `${process.cwd()} tracked` };
   } catch (error) {
-    return { success: false, error: error instanceof Error ? error.message : String(error) };
+    const msg = error instanceof Error ? error.message : "unknown error";
+    logger_default.error(`Project tracking error: ${msg}`);
+    return { status: "failure", message: msg };
   }
 }
-async function uninstallService() {
-  const os2 = platform();
+async function stepDaemon() {
   try {
-    if (os2 === "darwin") {
-      const daemonPlist = getDaemonPlistPath();
-      if (existsSync2(daemonPlist)) {
-        try {
-          execSync(`launchctl unload "${daemonPlist}" 2>/dev/null`);
-        } catch {
-        }
-        unlinkSync(daemonPlist);
-      }
-      const trayPlist = getTrayPlistPath();
-      if (existsSync2(trayPlist)) {
-        try {
-          execSync(`launchctl unload "${trayPlist}" 2>/dev/null`);
-        } catch {
-        }
-        unlinkSync(trayPlist);
-      }
-      return { success: true };
-    } else if (os2 === "linux") {
-      const daemonService = getDaemonServicePath();
-      if (existsSync2(daemonService)) {
-        try {
-          execSync("systemctl --user stop skillo-daemon.service 2>/dev/null");
-        } catch {
-        }
-        try {
-          execSync("systemctl --user disable skillo-daemon.service 2>/dev/null");
-        } catch {
-        }
-        unlinkSync(daemonService);
-      }
-      const trayService = getTrayServicePath();
-      if (existsSync2(trayService)) {
-        try {
-          execSync("systemctl --user stop skillo-tray.service 2>/dev/null");
-        } catch {
-        }
-        try {
-          execSync("systemctl --user disable skillo-tray.service 2>/dev/null");
-        } catch {
-        }
-        unlinkSync(trayService);
-      }
-      try {
-        execSync("systemctl --user daemon-reload");
-      } catch {
-      }
-      return { success: true };
-    } else if (os2 === "win32") {
-      winRegDelete(WIN_DAEMON_VALUE);
-      winRegDelete(WIN_TRAY_VALUE);
-      const vbsPath = getWinDaemonVbsPath();
-      if (existsSync2(vbsPath)) {
-        try {
-          unlinkSync(vbsPath);
-        } catch {
-        }
-      }
-      return { success: true };
-    } else {
-      return { success: false, error: `Unsupported platform: ${os2}` };
-    }
+    const { running, pid } = isDaemonActuallyRunning();
+    if (running && pid) {
+      logger_default.success(`Daemon already running (PID: ${pid})`);
+      return { status: "success", message: `running (PID ${pid})` };
+    }
+    const { startDaemonProcess: startDaemonProcess2 } = await import("./daemon-6DTCMOJB.js");
+    const newPid = startDaemonProcess2();
+    if (newPid) {
+      logger_default.success(`Daemon started (PID: ${newPid})`);
+      return { status: "success", message: `running (PID ${newPid})` };
+    }
+    return { status: "failure", message: "failed to start daemon" };
   } catch (error) {
-    return { success: false, error: error instanceof Error ? error.message : String(error) };
+    const msg = error instanceof Error ? error.message : "unknown error";
+    logger_default.error(`Daemon error: ${msg}`);
+    return { status: "failure", message: msg };
   }
 }
-function getServiceStatus() {
-  const os2 = platform();
-  if (os2 === "darwin") {
-    const daemonInstalled = existsSync2(getDaemonPlistPath());
-    const trayInstalled = existsSync2(getTrayPlistPath());
-    let daemonLoaded = false;
-    let trayLoaded = false;
-    try {
-      const output = execSync("launchctl list", { encoding: "utf-8" });
-      daemonLoaded = output.includes(DAEMON_LABEL);
-      trayLoaded = output.includes(TRAY_LABEL);
-    } catch {
-    }
-    return {
-      platform: "macos",
-      daemon: { installed: daemonInstalled, loaded: daemonLoaded },
-      tray: { installed: trayInstalled, loaded: trayLoaded }
-    };
-  } else if (os2 === "linux") {
-    const daemonInstalled = existsSync2(getDaemonServicePath());
-    const trayInstalled = existsSync2(getTrayServicePath());
-    let daemonLoaded = false;
-    let trayLoaded = false;
-    try {
-      execSync("systemctl --user is-active skillo-daemon.service", { encoding: "utf-8" });
-      daemonLoaded = true;
-    } catch {
-    }
-    try {
-      execSync("systemctl --user is-active skillo-tray.service", { encoding: "utf-8" });
-      trayLoaded = true;
-    } catch {
+var initCommand = new Command("init").description("Initialize Skillo configuration and interactive onboarding").option("-f, --force", "Overwrite existing configuration").action(async (options) => {
+  logger_default.blank();
+  logger_default.bold("Initializing Skillo...");
+  logger_default.blank();
+  const dataDir = getDataDir();
+  const configDir = getConfigDir();
+  const skillsDir = getSkillsDir();
+  const configFile = getConfigFile();
+  const directories = [
+    { path: dataDir, name: "~/.skillo/" },
+    { path: configDir, name: "~/.config/skillo/" },
+    { path: skillsDir, name: "~/.claude/skills/" }
+  ];
+  for (const { path: path3, name } of directories) {
+    if (ensureDirectory(path3)) {
+      logger_default.success(`Created ${name}`);
+    } else {
+      logger_default.dim(`  [-] ${name} already exists`);
     }
-    return {
-      platform: "linux",
-      daemon: { installed: daemonInstalled, loaded: daemonLoaded },
-      tray: { installed: trayInstalled, loaded: trayLoaded }
-    };
-  } else if (os2 === "win32") {
-    const daemonInstalled = winRegExists(WIN_DAEMON_VALUE);
-    const trayInstalled = winRegExists(WIN_TRAY_VALUE);
-    return {
-      platform: "windows",
-      daemon: { installed: daemonInstalled, loaded: daemonInstalled },
-      tray: { installed: trayInstalled, loaded: trayInstalled }
-    };
   }
-  return {
-    platform: "unsupported",
-    daemon: { installed: false, loaded: false },
-    tray: { installed: false, loaded: false }
-  };
-}
+  if (!existsSync(configFile) || options.force) {
+    const config = getDefaultConfig();
+    saveConfig(config);
+    logger_default.success("Created default configuration");
+  }
+  const db = new SkilloDatabase();
+  await db.initialize();
+  db.close();
+  logger_default.success("Initialized database");
+  logger_default.blank();
+  logger_default.bold("Starting onboarding...");
+  logger_default.blank();
+  logger_default.info("Step 1/4: Authentication");
+  const authResult = await stepAuth();
+  const loggedIn = authResult.status === "success";
+  logger_default.blank();
+  logger_default.info("Step 2/4: Shell Integration");
+  const shellResult = await stepShellIntegration();
+  logger_default.blank();
+  logger_default.info("Step 3/4: Project Tracking");
+  const trackResult = await stepTrackProject(loggedIn);
+  logger_default.blank();
+  logger_default.info("Step 4/4: Daemon");
+  const daemonResult = await stepDaemon();
+  logger_default.blank();
+  const pad = (s, len) => s.padEnd(len);
+  logger_default.bold("  Setup Complete!");
+  logger_default.info(`  ${statusIcon(authResult.status)} ${pad("Authentication", 20)} \u2014 ${authResult.message}`);
+  logger_default.info(`  ${statusIcon(shellResult.status)} ${pad("Shell Integration", 20)} \u2014 ${shellResult.message}`);
+  logger_default.info(`  ${statusIcon(trackResult.status)} ${pad("Project Tracking", 20)} \u2014 ${trackResult.message}`);
+  logger_default.info(`  ${statusIcon(daemonResult.status)} ${pad("Daemon", 20)} \u2014 ${daemonResult.message}`);
+  logger_default.blank();
+});
 
 // src/commands/status.ts
-function isDaemonRunning() {
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { Command as Command2 } from "commander";
+function isDaemonRunning2() {
   const pidFile = getPidFile();
-  if (!existsSync3(pidFile)) {
+  if (!existsSync2(pidFile)) {
     return { running: false, pid: null };
   }
   try {
@@ -599,7 +325,7 @@ function isDaemonRunning() {
 }
 var statusCommand = new Command2("status").description("Show daemon status and statistics").action(async () => {
   logger_default.blank();
-  const { running, pid } = isDaemonRunning();
+  const { running, pid } = isDaemonRunning2();
   if (running) {
     logger_default.running(`Daemon is running (PID: ${pid})`);
   } else {
@@ -617,7 +343,7 @@ var statusCommand = new Command2("status").description("Show daemon status and s
   if (!running) return;
   logger_default.blank();
   const dbPath = getDbPath();
-  if (!existsSync3(dbPath)) {
+  if (!existsSync2(dbPath)) {
     logger_default.warn("Database not found. Run 'skillo init' first.");
     return;
   }
@@ -634,7 +360,7 @@ var statusCommand = new Command2("status").description("Show daemon status and s
   ]);
   logger_default.blank();
   const logFile = getLogFile();
-  if (existsSync3(logFile)) {
+  if (existsSync2(logFile)) {
     logger_default.dim("Recent log entries:");
     try {
       const content = readFileSync2(logFile, "utf-8");
@@ -649,7 +375,7 @@ var statusCommand = new Command2("status").description("Show daemon status and s
 });
 
 // src/commands/config.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { Command as Command3 } from "commander";
 import YAML from "yaml";
 var configCommand = new Command3("config").description(
@@ -657,7 +383,7 @@ var configCommand = new Command3("config").description(
 );
 configCommand.command("show").description("Show current configuration").action(async () => {
   const configFile = getConfigFile();
-  if (!existsSync4(configFile)) {
+  if (!existsSync3(configFile)) {
     logger_default.error("Configuration not found.");
     logger_default.dim("Run 'skillo init' first.");
     process.exit(1);
@@ -670,7 +396,7 @@ configCommand.command("show").description("Show current configuration").action(a
 });
 configCommand.command("get <key>").description("Get a configuration value (use dot notation, e.g., patternDetection.minCount)").action(async (key) => {
   const configFile = getConfigFile();
-  if (!existsSync4(configFile)) {
+  if (!existsSync3(configFile)) {
     logger_default.error("Configuration not found.");
     process.exit(1);
   }
@@ -688,7 +414,7 @@ configCommand.command("get <key>").description("Get a configuration value (use d
 });
 configCommand.command("set <key> <value>").description("Set a configuration value").action(async (key, value) => {
   const configFile = getConfigFile();
-  if (!existsSync4(configFile)) {
+  if (!existsSync3(configFile)) {
     logger_default.error("Configuration not found.");
     process.exit(1);
   }
@@ -730,15 +456,15 @@ configCommand.command("path").description("Show configuration file path").action
 });
 
 // src/commands/patterns.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { Command as Command4 } from "commander";
-import chalk2 from "chalk";
+import chalk from "chalk";
 var patternsCommand = new Command4("patterns").description(
   "Manage detected workflow patterns"
 );
 patternsCommand.command("list").description("List detected patterns").option("-t, --type <type>", "Filter by type (terminal, conversation)").option("-s, --status <status>", "Filter by status (active, converted, ignored)").option("-n, --limit <number>", "Number of patterns to show", "20").action(async (options) => {
   const dbPath = getDbPath();
-  if (!existsSync5(dbPath)) {
+  if (!existsSync4(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -763,9 +489,9 @@ patternsCommand.command("list").description("List detected patterns").option("-t
   logger_default.blank();
   patterns.forEach((pattern, index) => {
     const shortId = pattern.id.slice(0, 8);
-    const statusColor = pattern.status === "active" ? chalk2.green : pattern.status === "converted" ? chalk2.blue : chalk2.dim;
+    const statusColor = pattern.status === "active" ? chalk.green : pattern.status === "converted" ? chalk.blue : chalk.dim;
     console.log(
-      `  ${chalk2.cyan(shortId)}  ${chalk2.white(pattern.description)}  ${chalk2.dim(`x${pattern.count}`)}  ${statusColor(pattern.status)}`
+      `  ${chalk.cyan(shortId)}  ${chalk.white(pattern.description)}  ${chalk.dim(`x${pattern.count}`)}  ${statusColor(pattern.status)}`
     );
   });
   logger_default.blank();
@@ -775,7 +501,7 @@ patternsCommand.command("list").description("List detected patterns").option("-t
 });
 patternsCommand.command("show <id>").description("Show pattern details").action(async (id) => {
   const dbPath = getDbPath();
-  if (!existsSync5(dbPath)) {
+  if (!existsSync4(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -802,7 +528,7 @@ patternsCommand.command("show <id>").description("Show pattern details").action(
   if (pattern.data.commands && Array.isArray(pattern.data.commands)) {
     logger_default.bold("Commands:");
     pattern.data.commands.forEach((cmd, i) => {
-      console.log(`  ${chalk2.dim(`${i + 1}.`)} ${cmd}`);
+      console.log(`  ${chalk.dim(`${i + 1}.`)} ${cmd}`);
     });
     logger_default.blank();
   }
@@ -818,7 +544,7 @@ patternsCommand.command("show <id>").description("Show pattern details").action(
 });
 patternsCommand.command("ignore <id>").description("Ignore a pattern (never suggest again)").option("-r, --reason <reason>", "Reason for ignoring").action(async (id, options) => {
   const dbPath = getDbPath();
-  if (!existsSync5(dbPath)) {
+  if (!existsSync4(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -839,12 +565,12 @@ patternsCommand.command("ignore <id>").description("Ignore a pattern (never sugg
   }
 });
 patternsCommand.command("generate <id>").description("Generate a skill from a pattern").option("-n, --name <name>", "Custom skill name").option("--dry-run", "Preview without creating").action(async (id, options) => {
-  const { getApiClient: getApiClient2 } = await import("./api-client-KUQW7FSC.js");
-  const { writeFileSync: writeFileSync7, mkdirSync: mkdirSync3 } = await import("fs");
-  const { join: join7 } = await import("path");
-  const { getSkillsDir: getSkillsDir2, ensureDirectory: ensureDirectory2 } = await import("./paths-INOKEM66.js");
+  const { getApiClient: getApiClient2 } = await import("./api-client-BF6GDR7Q.js");
+  const { writeFileSync: writeFileSync5, mkdirSync: mkdirSync3 } = await import("fs");
+  const { join: join6 } = await import("path");
+  const { getSkillsDir: getSkillsDir2, ensureDirectory: ensureDirectory2 } = await import("./paths-MPOZBOKE.js");
   const dbPath = getDbPath();
-  if (!existsSync5(dbPath)) {
+  if (!existsSync4(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -895,10 +621,10 @@ patternsCommand.command("generate <id>").description("Generate a skill from a pa
   } else {
     const skillsDir = getSkillsDir2();
     ensureDirectory2(skillsDir);
-    const skillDir = join7(skillsDir, skill.slug);
-    const skillFile = join7(skillDir, "SKILL.md");
+    const skillDir = join6(skillsDir, skill.slug);
+    const skillFile = join6(skillDir, "SKILL.md");
     mkdirSync3(skillDir, { recursive: true });
-    writeFileSync7(skillFile, skill.content, "utf-8");
+    writeFileSync5(skillFile, skill.content, "utf-8");
     await db.updatePatternStatus(id, "converted");
     logger_default.success(`Skill saved to: ~/.claude/skills/${skill.slug}/SKILL.md`);
     logger_default.blank();
@@ -913,7 +639,7 @@ patternsCommand.command("clear").description("Clear all patterns").option("-f, -
     return;
   }
   const dbPath = getDbPath();
-  if (!existsSync5(dbPath)) {
+  if (!existsSync4(dbPath)) {
     logger_default.error("Database not found.");
     process.exit(1);
   }
@@ -921,16 +647,16 @@ patternsCommand.command("clear").description("Clear all patterns").option("-f, -
 });
 
 // src/commands/skills.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, rmSync } from "fs";
+import { existsSync as existsSync5, readdirSync, rmSync, mkdirSync, writeFileSync } from "fs";
 import { join as join2 } from "path";
 import { Command as Command5 } from "commander";
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 var skillsCommand = new Command5("skills").description(
   "Manage generated skills"
 );
 skillsCommand.command("list").description("List all skills").option("-s, --source <source>", "Filter by source (pattern, imported, manual)").option("--sort <by>", "Sort by (name, created, usage)", "name").action(async (options) => {
   const dbPath = getDbPath();
-  if (!existsSync6(dbPath)) {
+  if (!existsSync5(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -943,11 +669,11 @@ skillsCommand.command("list").description("List all skills").option("-s, --sourc
   db.close();
   const skillsDir = getSkillsDir();
   const fsSkills = [];
-  if (existsSync6(skillsDir)) {
-    const entries = readdirSync2(skillsDir, { withFileTypes: true });
+  if (existsSync5(skillsDir)) {
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
     entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).forEach((e) => {
       const skillMd = join2(skillsDir, e.name, "SKILL.md");
-      if (existsSync6(skillMd)) {
+      if (existsSync5(skillMd)) {
         fsSkills.push(e.name);
       }
     });
@@ -966,19 +692,19 @@ skillsCommand.command("list").description("List all skills").option("-s, --sourc
   logger_default.bold(`Skills (${skills.length + unregisteredSkills.length}):`);
   logger_default.blank();
   skills.forEach((skill) => {
-    const sourceColor = skill.sourceType === "pattern" ? chalk3.green : skill.sourceType === "imported" ? chalk3.blue : chalk3.dim;
+    const sourceColor = skill.sourceType === "pattern" ? chalk2.green : skill.sourceType === "imported" ? chalk2.blue : chalk2.dim;
     console.log(
-      `  ${chalk3.cyan(skill.name)}  ${sourceColor(skill.sourceType)}  ${chalk3.dim(`used ${skill.usageCount}x`)}`
+      `  ${chalk2.cyan(skill.name)}  ${sourceColor(skill.sourceType)}  ${chalk2.dim(`used ${skill.usageCount}x`)}`
     );
     if (skill.triggerPhrase) {
-      console.log(`    ${chalk3.dim(skill.triggerPhrase)}`);
+      console.log(`    ${chalk2.dim(skill.triggerPhrase)}`);
     }
   });
   if (unregisteredSkills.length > 0) {
     logger_default.blank();
     logger_default.dim("  Unregistered skills (found in ~/.claude/skills/):");
     unregisteredSkills.forEach((name) => {
-      console.log(`    ${chalk3.yellow(name)}  ${chalk3.dim("filesystem only")}`);
+      console.log(`    ${chalk2.yellow(name)}  ${chalk2.dim("filesystem only")}`);
     });
   }
   logger_default.blank();
@@ -987,7 +713,7 @@ skillsCommand.command("list").description("List all skills").option("-s, --sourc
 });
 skillsCommand.command("show <name>").description("Show skill details").action(async (name) => {
   const dbPath = getDbPath();
-  if (!existsSync6(dbPath)) {
+  if (!existsSync5(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -997,7 +723,7 @@ skillsCommand.command("show <name>").description("Show skill details").action(as
   db.close();
   if (!skill) {
     const skillPath = join2(getSkillsDir(), name, "SKILL.md");
-    if (existsSync6(skillPath)) {
+    if (existsSync5(skillPath)) {
       logger_default.blank();
       logger_default.bold(name);
       logger_default.blank();
@@ -1028,984 +754,101 @@ skillsCommand.command("show <name>").description("Show skill details").action(as
 });
 skillsCommand.command("delete <name>").description("Delete a skill").option("-f, --force", "Skip confirmation").action(async (name, options) => {
   const dbPath = getDbPath();
-  if (!existsSync6(dbPath)) {
-    logger_default.error("Database not found.");
-    process.exit(1);
-  }
-  const db = new SkilloDatabase();
-  await db.initialize();
-  const skill = await db.getSkill(name);
-  const skillDir = skill?.path || join2(getSkillsDir(), name);
-  if (!skill && !existsSync6(skillDir)) {
-    db.close();
-    logger_default.error(`Skill not found: ${name}`);
-    process.exit(1);
-  }
-  if (!options.force) {
-    logger_default.warn(`This will delete skill '${name}'. This cannot be undone.`);
-    logger_default.dim("Use --force to confirm.");
-    db.close();
-    return;
-  }
-  if (existsSync6(skillDir)) {
-    rmSync(skillDir, { recursive: true, force: true });
-  }
-  if (skill) {
-    await db.deleteSkill(name);
-  }
-  db.close();
-  logger_default.success(`Skill deleted: ${name}`);
-});
-skillsCommand.command("path").description("Show skills directory path").action(async () => {
-  console.log(getSkillsDir());
-});
-skillsCommand.command("open").description("Open skills directory in file manager").action(async () => {
-  const skillsDir = getSkillsDir();
-  if (!existsSync6(skillsDir)) {
-    logger_default.error("Skills directory not found. Run 'skillo init' first.");
-    process.exit(1);
-  }
-  const { exec } = await import("child_process");
-  const command = process.platform === "win32" ? `explorer "${skillsDir}"` : process.platform === "darwin" ? `open "${skillsDir}"` : `xdg-open "${skillsDir}"`;
-  exec(command, (error) => {
-    if (error) {
-      logger_default.error(`Failed to open directory: ${error.message}`);
-      logger_default.dim(`Path: ${skillsDir}`);
-    }
-  });
-});
-
-// src/commands/shell.ts
-import { existsSync as existsSync7, writeFileSync as writeFileSync2, readFileSync as readFileSync4, appendFileSync } from "fs";
-import { spawn } from "child_process";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-import { Command as Command6 } from "commander";
-function normalizeCommand(cmd) {
-  const variables = {};
-  let normalized = cmd;
-  let varIndex = 0;
-  normalized = normalized.replace(/(?:^|\s)(\/[\w\-.\/]+)/g, (match, path2) => {
-    const key = `$PATH${varIndex++}`;
-    variables[key] = path2;
-    return match.replace(path2, key);
-  });
-  normalized = normalized.replace(
-    /https?:\/\/[^\s]+/g,
-    (match) => {
-      const key = `$URL${varIndex++}`;
-      variables[key] = match;
-      return key;
-    }
-  );
-  normalized = normalized.replace(/\b\d{4,}\b/g, (match) => {
-    const key = `$NUM${varIndex++}`;
-    variables[key] = match;
-    return key;
-  });
-  normalized = normalized.replace(/"[^"]+"/g, (match) => {
-    const key = `$STR${varIndex++}`;
-    variables[key] = match;
-    return key;
-  });
-  normalized = normalized.replace(/'[^']+'/g, (match) => {
-    const key = `$STR${varIndex++}`;
-    variables[key] = match;
-    return key;
-  });
-  return { normalized: normalized.trim(), variables };
-}
-var shellCommand = new Command6("shell").description("Start a tracked terminal session").option("-s, --shell <shell>", "Shell to use (default: $SHELL or cmd on Windows)").option("-p, --project <path>", "Project path to track").action(async (options) => {
-  if (!existsSync7(getConfigFile())) {
-    logger_default.error("Skillo not initialized. Run 'skillo init' first.");
-    process.exit(1);
-  }
-  const config = loadConfig();
-  let shell = options.shell || config.defaultShell;
-  if (!shell) {
-    if (process.platform === "win32") {
-      shell = process.env.COMSPEC || "cmd.exe";
-    } else {
-      shell = process.env.SHELL || "/bin/bash";
-    }
-  }
-  const projectPath = options.project || process.cwd();
-  logger_default.blank();
-  logger_default.info("Starting tracked shell session...");
-  logger_default.dim(`Shell: ${shell}`);
-  logger_default.dim(`Project: ${projectPath}`);
-  logger_default.blank();
-  logger_default.dim("All commands will be tracked. Type 'exit' to end the session.");
-  logger_default.blank();
-  const db = new SkilloDatabase();
-  await db.initialize();
-  const sessionId = await db.createSession(shell, projectPath);
-  let commandCount = 0;
-  let currentCommand = "";
-  let commandStartTime = null;
-  const shellArgs = process.platform === "win32" ? [] : ["-i"];
-  const child = spawn(shell, shellArgs, {
-    stdio: ["inherit", "inherit", "inherit"],
-    shell: false,
-    cwd: projectPath,
-    env: {
-      ...process.env,
-      SKILLO_SESSION: sessionId,
-      SKILLO_TRACKING: "1"
-    }
-  });
-  child.on("exit", async (code) => {
-    await db.endSession(sessionId);
-    db.close();
-    logger_default.blank();
-    logger_default.success(`Session ended. Tracked ${commandCount} command(s).`);
-    logger_default.dim(`Session ID: ${sessionId.slice(0, 8)}`);
-    logger_default.blank();
-    process.exit(code || 0);
-  });
-  child.on("error", async (error) => {
-    logger_default.error(`Failed to start shell: ${error.message}`);
-    await db.endSession(sessionId);
-    db.close();
-    process.exit(1);
-  });
-});
-var recordCommand = new Command6("record").description("Record a command (used by shell integration)").argument("<command>", "Command that was executed").option("--session <id>", "Session ID").option("--cwd <path>", "Working directory").option("--exit-code <code>", "Exit code").option("--duration <ms>", "Duration in milliseconds").option("--no-sync", "Don't sync to platform").action(
-  async (command, options) => {
-    const cwd = options.cwd || process.cwd();
-    const exitCode = options.exitCode ? parseInt(options.exitCode, 10) : null;
-    const durationMs = options.duration ? parseInt(options.duration, 10) : null;
-    const sessionId = options.session || process.env.SKILLO_SESSION || "default";
-    const { normalized, variables } = normalizeCommand(command);
-    const db = new SkilloDatabase();
-    await db.initialize();
-    await db.addCommand({
-      command,
-      normalized,
-      cwd,
-      sessionId,
-      exitCode,
-      durationMs,
-      variables: Object.keys(variables).length > 0 ? variables : null
-    });
-    db.close();
-    if (options.sync !== false) {
-      try {
-        const { getApiClient: getApiClient2 } = await import("./api-client-KUQW7FSC.js");
-        const client = getApiClient2();
-        if (client.hasApiKey()) {
-          await client.syncCommands([{
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            command,
-            normalized,
-            cwd,
-            exitCode,
-            durationMs,
-            sessionId: sessionId !== "default" ? sessionId : void 0,
-            variables: Object.keys(variables).length > 0 ? variables : null
-          }]);
-        }
-      } catch {
-      }
-    }
-  }
-);
-var setupShellCommand = new Command6("setup-shell").description("Set up shell integration for automatic command tracking").option("--bash", "Set up Bash integration").option("--zsh", "Set up Zsh integration").option("--powershell", "Set up PowerShell integration").option("--fish", "Set up Fish integration").option("--uninstall", "Remove shell integration").action(async (options) => {
-  logger_default.blank();
-  const home = homedir2();
-  const dataDir = getDataDir();
-  ensureDirectory(dataDir);
-  let shell = null;
-  if (options.bash) shell = "bash";
-  else if (options.zsh) shell = "zsh";
-  else if (options.powershell) shell = "powershell";
-  else if (options.fish) shell = "fish";
-  else {
-    if (process.platform === "win32") {
-      shell = "powershell";
-    } else {
-      const currentShell = process.env.SHELL || "";
-      if (currentShell.includes("zsh")) shell = "zsh";
-      else if (currentShell.includes("fish")) shell = "fish";
-      else shell = "bash";
-    }
-    logger_default.info(`Detected shell: ${shell}`);
-  }
-  if (options.uninstall) {
-    logger_default.info(`Removing ${shell} integration...`);
-    await uninstallShellIntegration(shell, home);
-    logger_default.success("Shell integration removed.");
-    logger_default.dim("Restart your terminal for changes to take effect.");
-    logger_default.blank();
-    return;
-  }
-  logger_default.info(`Setting up ${shell} integration...`);
-  logger_default.blank();
-  await installShellIntegration(shell, home, dataDir);
-  logger_default.blank();
-  logger_default.success("Shell integration installed!");
-  logger_default.blank();
-  logger_default.dim("Restart your terminal or run:");
-  if (shell === "powershell") {
-    logger_default.highlight("  . $PROFILE");
-  } else if (shell === "bash") {
-    logger_default.highlight("  source ~/.bashrc");
-  } else if (shell === "zsh") {
-    logger_default.highlight("  source ~/.zshrc");
-  } else if (shell === "fish") {
-    logger_default.highlight("  source ~/.config/fish/config.fish");
-  }
-  logger_default.blank();
-  logger_default.dim("All commands you run will now be tracked and synced to Skillo.");
-  logger_default.blank();
-});
-async function installShellIntegration(shell, home, dataDir) {
-  const scriptPath = join3(dataDir, "shell-integration");
-  ensureDirectory(scriptPath);
-  if (shell === "powershell") {
-    const psScript = `# Skillo CLI Integration
-# Records commands to Skillo platform
-# Works in two modes:
-# 1. Platform mode: Uses SKILLO_SESSION and SKILLO_USER_ID env vars (set by platform launch)
-# 2. Standalone mode: Uses skillo CLI which handles auth via API key
-
-$Global:SkilloLastHistoryId = 0
-$Global:SkilloStandaloneSessionId = $null
-$Global:SkilloSessionStartTime = $null
-
-# Check if launched from platform (has session/user env vars) or standalone
-$Global:SkilloPlatformMode = $false
-if ($env:SKILLO_SESSION -and $env:SKILLO_USER_ID) {
-    $Global:SkilloPlatformMode = $true
-    $Global:SkilloSessionId = $env:SKILLO_SESSION
-    $Global:SkilloUserId = $env:SKILLO_USER_ID
-    $Global:SkilloBaseUrl = if ($env:SKILLO_API_URL) { $env:SKILLO_API_URL } else { 'http://localhost:3000' }
-}
-
-function Send-SkilloCommandPlatform {
-    param($Command, $Duration, $ExitCode, $Cwd)
-
-    try {
-        $body = @{
-            type = 'commands'
-            data = @(@{
-                timestamp = (Get-Date).ToString('o')
-                command = $Command
-                normalized = $Command
-                cwd = $Cwd
-                exitCode = $ExitCode
-                durationMs = $Duration
-                sessionId = $Global:SkilloSessionId
-            })
-        } | ConvertTo-Json -Depth 3 -Compress
-
-        $uri = "$($Global:SkilloBaseUrl)/api/cli/sync"
-
-        $webRequest = [System.Net.HttpWebRequest]::Create($uri)
-        $webRequest.Method = 'POST'
-        $webRequest.ContentType = 'application/json'
-        $webRequest.Headers.Add('x-skillo-session', $Global:SkilloSessionId)
-        $webRequest.Headers.Add('x-skillo-user-id', $Global:SkilloUserId)
-        $webRequest.Timeout = 5000
-
-        $bytes = [System.Text.Encoding]::UTF8.GetBytes($body)
-        $webRequest.ContentLength = $bytes.Length
-        $stream = $webRequest.GetRequestStream()
-        $stream.Write($bytes, 0, $bytes.Length)
-        $stream.Close()
-
-        $response = $webRequest.GetResponse()
-        $response.Close()
-    } catch {
-        # Silently ignore errors
-    }
-}
-
-function Send-SkilloCommandCLI {
-    param($Command, $Duration, $ExitCode, $Cwd)
-
-    # Create session on first command if not exists
-    if (-not $Global:SkilloStandaloneSessionId) {
-        $Global:SkilloSessionStartTime = (Get-Date).ToString('o')
-        try {
-            $result = & skillo session start --shell "PowerShell" 2>$null
-            if ($result -match 'Session ID: ([a-f0-9-]+)') {
-                $Global:SkilloStandaloneSessionId = $Matches[1]
-            }
-        } catch {
-            # If session command doesn't exist, generate a local ID
-            $Global:SkilloStandaloneSessionId = [guid]::NewGuid().ToString()
-        }
-    }
-
-    # Run skillo record in background with session ID
-    Start-Job -ScriptBlock {
-        param($cmd, $cwd, $exit, $dur, $sessionId)
-        & skillo record $cmd --cwd $cwd --exit-code $exit --duration $dur --session $sessionId 2>$null
-    } -ArgumentList $Command, $Cwd, $ExitCode, $Duration, $Global:SkilloStandaloneSessionId | Out-Null
-}
-
-# Override prompt to capture commands after execution
-$Global:SkilloOriginalPrompt = $function:prompt
-function Global:prompt {
-    $lastCmd = Get-History -Count 1 -ErrorAction SilentlyContinue
-
-    if ($lastCmd -and $lastCmd.Id -gt $Global:SkilloLastHistoryId) {
-        $Global:SkilloLastHistoryId = $lastCmd.Id
-
-        $duration = 0
-        if ($lastCmd.EndExecutionTime -and $lastCmd.StartExecutionTime) {
-            $duration = [int]($lastCmd.EndExecutionTime - $lastCmd.StartExecutionTime).TotalMilliseconds
-        }
-        $exit = if ($null -eq $LASTEXITCODE) { 0 } else { $LASTEXITCODE }
-        $cwd = (Get-Location).Path
-
-        if ($Global:SkilloPlatformMode) {
-            Send-SkilloCommandPlatform -Command $lastCmd.CommandLine -Duration $duration -ExitCode $exit -Cwd $cwd
-        } else {
-            Send-SkilloCommandCLI -Command $lastCmd.CommandLine -Duration $duration -ExitCode $exit -Cwd $cwd
-        }
-    }
-
-    & $Global:SkilloOriginalPrompt
-}
-
-# Register exit handler to end session when terminal closes
-$null = Register-EngineEvent -SourceIdentifier PowerShell.Exiting -Action {
-    if ($Global:SkilloPlatformMode -and $Global:SkilloSessionId) {
-        # End platform session
-        try {
-            $body = @{ sessionId = $Global:SkilloSessionId } | ConvertTo-Json -Compress
-            $uri = "$($Global:SkilloBaseUrl)/api/sessions"
-
-            $webRequest = [System.Net.HttpWebRequest]::Create($uri)
-            $webRequest.Method = 'PATCH'
-            $webRequest.ContentType = 'application/json'
-            $webRequest.Headers.Add('x-skillo-session', $Global:SkilloSessionId)
-            $webRequest.Headers.Add('x-skillo-user-id', $Global:SkilloUserId)
-            $webRequest.Timeout = 3000
-
-            $bytes = [System.Text.Encoding]::UTF8.GetBytes($body)
-            $webRequest.ContentLength = $bytes.Length
-            $stream = $webRequest.GetRequestStream()
-            $stream.Write($bytes, 0, $bytes.Length)
-            $stream.Close()
-
-            $response = $webRequest.GetResponse()
-            $response.Close()
-        } catch {
-            # Ignore errors on exit
-        }
-    } elseif ($Global:SkilloStandaloneSessionId) {
-        # End standalone session via CLI
-        try {
-            & skillo session end --session $Global:SkilloStandaloneSessionId 2>$null
-        } catch {
-            # Ignore errors on exit
-        }
-    }
-}
-
-Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
-`;
-    const psScriptFile = join3(scriptPath, "skillo.ps1");
-    writeFileSync2(psScriptFile, psScript, "utf-8");
-    logger_default.success(`Created ${psScriptFile}`);
-    const profilePath = join3(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
-    const profileDir = join3(home, "Documents", "WindowsPowerShell");
-    ensureDirectory(profileDir);
-    const sourceLine = `
-# Skillo CLI Integration
-. "${psScriptFile}"
-`;
-    if (existsSync7(profilePath)) {
-      const content = readFileSync4(profilePath, "utf-8");
-      if (!content.includes("Skillo CLI Integration")) {
-        appendFileSync(profilePath, sourceLine);
-        logger_default.success("Added to PowerShell profile");
-      } else {
-        logger_default.dim("Already in PowerShell profile");
-      }
-    } else {
-      writeFileSync2(profilePath, sourceLine, "utf-8");
-      logger_default.success("Created PowerShell profile");
-    }
-  } else if (shell === "bash") {
-    const bashScript = [
-      "# Skillo CLI Integration",
-      "# Records commands and auto-detects tracked projects",
-      "",
-      '_skillo_session="${SKILLO_SESSION:-default}"',
-      "_skillo_last_cwd=",
-      "",
-      "_skillo_preexec() {",
-      '    _skillo_cmd="$1"',
-      "    _skillo_start_time=$(date +%s)",
-      "}",
-      "",
-      "_skillo_check_project() {",
-      "    # Fast path: skip if CWD unchanged",
-      '    if [ "$PWD" = "$_skillo_last_cwd" ]; then',
-      "        return",
-      "    fi",
-      '    _skillo_last_cwd="$PWD"',
-      "",
-      "    # Run session-auto in background (handles create/end via cache file)",
-      "    local result",
-      '    result=$(skillo session-auto "$PWD" --pid $$ --shell bash 2>/dev/null)',
-      '    if [ -n "$result" ]; then',
-      '        export SKILLO_SESSION="$result"',
-      '        _skillo_session="$result"',
-      "    fi",
-      "}",
-      "",
-      "_skillo_precmd() {",
-      "    local exit_code=$?",
-      "",
-      "    # Check for project change",
-      "    _skillo_check_project",
-      "",
-      '    if [ -n "$_skillo_cmd" ]; then',
-      "        local duration=0",
-      '        if [ -n "$_skillo_start_time" ]; then',
-      "            local end_time=$(date +%s)",
-      "            duration=$(( (end_time - _skillo_start_time) * 1000 ))",
-      "        fi",
-      '        (skillo record "$_skillo_cmd" --cwd "$PWD" --exit-code "$exit_code" --duration "$duration" --session "$_skillo_session" &>/dev/null &)',
-      '        _skillo_cmd=""',
-      "    fi",
-      "}",
-      "",
-      "# Clean up session on terminal exit",
-      "_skillo_cleanup() {",
-      '    if [ -n "$SKILLO_SESSION" ] && [ "$SKILLO_SESSION" != "default" ]; then',
-      '        skillo session end --session "$SKILLO_SESSION" &>/dev/null',
-      "    fi",
-      "}",
-      "trap _skillo_cleanup EXIT",
-      "",
-      "# Use DEBUG trap for preexec",
-      `trap '_skillo_preexec "$BASH_COMMAND"' DEBUG`,
-      "",
-      "# Add precmd to PROMPT_COMMAND",
-      'if [[ ! "$PROMPT_COMMAND" =~ _skillo_precmd ]]; then',
-      '    PROMPT_COMMAND="_skillo_precmd${PROMPT_COMMAND:+;$PROMPT_COMMAND}"',
-      "fi",
-      "",
-      "# Initial project check",
-      "_skillo_check_project",
-      "",
-      'echo -e "\\033[90mSkillo: Command tracking enabled\\033[0m"'
-    ].join("\n");
-    const bashScriptFile = join3(scriptPath, "skillo.bash");
-    writeFileSync2(bashScriptFile, bashScript, "utf-8");
-    logger_default.success(`Created ${bashScriptFile}`);
-    const bashrcPath = join3(home, ".bashrc");
-    const sourceLine = `
-# Skillo CLI Integration
-[ -f "${bashScriptFile}" ] && source "${bashScriptFile}"
-`;
-    if (existsSync7(bashrcPath)) {
-      const content = readFileSync4(bashrcPath, "utf-8");
-      if (!content.includes("Skillo CLI Integration")) {
-        appendFileSync(bashrcPath, sourceLine);
-        logger_default.success("Added to ~/.bashrc");
-      } else {
-        logger_default.dim("Already in ~/.bashrc");
-      }
-    } else {
-      writeFileSync2(bashrcPath, sourceLine, "utf-8");
-      logger_default.success("Created ~/.bashrc");
-    }
-  } else if (shell === "zsh") {
-    const zshScript = [
-      "# Skillo CLI Integration",
-      "# Records commands and auto-detects tracked projects",
-      "",
-      '_skillo_session="${SKILLO_SESSION:-default}"',
-      "_skillo_last_cwd=",
-      "",
-      "_skillo_preexec() {",
-      '    _skillo_cmd="$1"',
-      "    _skillo_start_time=$(date +%s)",
-      "}",
-      "",
-      "_skillo_check_project() {",
-      "    # Fast path: skip if CWD unchanged",
-      '    if [[ "$PWD" == "$_skillo_last_cwd" ]]; then',
-      "        return",
-      "    fi",
-      '    _skillo_last_cwd="$PWD"',
-      "",
-      "    # Run session-auto in background (handles create/end via cache file)",
-      "    local result",
-      '    result=$(skillo session-auto "$PWD" --pid $$ --shell zsh 2>/dev/null)',
-      '    if [[ -n "$result" ]]; then',
-      '        export SKILLO_SESSION="$result"',
-      '        _skillo_session="$result"',
-      "    fi",
-      "}",
-      "",
-      "_skillo_precmd() {",
-      "    local exit_code=$?",
-      "",
-      "    # Check for project change",
-      "    _skillo_check_project",
-      "",
-      '    if [[ -n "$_skillo_cmd" ]]; then',
-      "        local duration=0",
-      '        if [[ -n "$_skillo_start_time" ]]; then',
-      "            local end_time=$(date +%s)",
-      "            duration=$(( (end_time - _skillo_start_time) * 1000 ))",
-      "        fi",
-      '        (skillo record "$_skillo_cmd" --cwd "$PWD" --exit-code "$exit_code" --duration "$duration" --session "$_skillo_session" &>/dev/null &)',
-      '        _skillo_cmd=""',
-      "    fi",
-      "}",
-      "",
-      "# Clean up session on terminal exit",
-      "_skillo_cleanup() {",
-      '    if [[ -n "$SKILLO_SESSION" ]] && [[ "$SKILLO_SESSION" != "default" ]]; then',
-      '        skillo session end --session "$SKILLO_SESSION" &>/dev/null',
-      "    fi",
-      "}",
-      "trap _skillo_cleanup EXIT",
-      "",
-      "autoload -Uz add-zsh-hook",
-      "add-zsh-hook preexec _skillo_preexec",
-      "add-zsh-hook precmd _skillo_precmd",
-      "",
-      "# Initial project check",
-      "_skillo_check_project",
-      "",
-      'echo -e "\\033[90mSkillo: Command tracking enabled\\033[0m"'
-    ].join("\n");
-    const zshScriptFile = join3(scriptPath, "skillo.zsh");
-    writeFileSync2(zshScriptFile, zshScript, "utf-8");
-    logger_default.success(`Created ${zshScriptFile}`);
-    const zshrcPath = join3(home, ".zshrc");
-    const sourceLine = `
-# Skillo CLI Integration
-[ -f "${zshScriptFile}" ] && source "${zshScriptFile}"
-`;
-    if (existsSync7(zshrcPath)) {
-      const content = readFileSync4(zshrcPath, "utf-8");
-      if (!content.includes("Skillo CLI Integration")) {
-        appendFileSync(zshrcPath, sourceLine);
-        logger_default.success("Added to ~/.zshrc");
-      } else {
-        logger_default.dim("Already in ~/.zshrc");
-      }
-    } else {
-      writeFileSync2(zshrcPath, sourceLine, "utf-8");
-      logger_default.success("Created ~/.zshrc");
-    }
-  } else if (shell === "fish") {
-    const fishScript = [
-      "# Skillo CLI Integration",
-      "# Records commands to Skillo platform",
-      "",
-      'set -q SKILLO_SESSION; or set -g SKILLO_SESSION "default"',
-      "",
-      "function _skillo_postexec --on-event fish_postexec",
-      "    set -l cmd $argv[1]",
-      "    set -l exit_code $status",
-      '    skillo record "$cmd" --cwd (pwd) --exit-code $exit_code --session $SKILLO_SESSION &>/dev/null &',
-      "end",
-      "",
-      'echo -e "\\033[90mSkillo: Command tracking enabled\\033[0m"'
-    ].join("\n");
-    const fishScriptFile = join3(scriptPath, "skillo.fish");
-    writeFileSync2(fishScriptFile, fishScript, "utf-8");
-    logger_default.success(`Created ${fishScriptFile}`);
-    const fishConfigDir = join3(home, ".config", "fish");
-    ensureDirectory(fishConfigDir);
-    const fishConfigPath = join3(fishConfigDir, "config.fish");
-    const sourceLine = `
-# Skillo CLI Integration
-if test -f "${fishScriptFile}"
-    source "${fishScriptFile}"
-end
-`;
-    if (existsSync7(fishConfigPath)) {
-      const content = readFileSync4(fishConfigPath, "utf-8");
-      if (!content.includes("Skillo CLI Integration")) {
-        appendFileSync(fishConfigPath, sourceLine);
-        logger_default.success("Added to ~/.config/fish/config.fish");
-      } else {
-        logger_default.dim("Already in fish config");
-      }
-    } else {
-      writeFileSync2(fishConfigPath, sourceLine, "utf-8");
-      logger_default.success("Created fish config");
-    }
-  }
-}
-async function uninstallShellIntegration(shell, home) {
-  const removeFromFile = (filePath) => {
-    if (!existsSync7(filePath)) return;
-    let content = readFileSync4(filePath, "utf-8");
-    content = content.replace(/\n# Skillo CLI Integration\n[^\n]*\n/g, "\n");
-    writeFileSync2(filePath, content, "utf-8");
-  };
-  if (shell === "powershell") {
-    const profilePath = join3(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
-    removeFromFile(profilePath);
-  } else if (shell === "bash") {
-    removeFromFile(join3(home, ".bashrc"));
-  } else if (shell === "zsh") {
-    removeFromFile(join3(home, ".zshrc"));
-  } else if (shell === "fish") {
-    removeFromFile(join3(home, ".config", "fish", "config.fish"));
-  }
-}
-
-// src/commands/daemon.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
-import { fork } from "child_process";
-import { Command as Command7 } from "commander";
-function isDaemonRunning2() {
-  const pidFile = getPidFile();
-  if (!existsSync8(pidFile)) {
-    return { running: false, pid: null };
-  }
-  try {
-    const pidStr = readFileSync5(pidFile, "utf-8").trim();
-    const pid = parseInt(pidStr, 10);
-    if (isNaN(pid)) {
-      return { running: false, pid: null };
-    }
-    try {
-      process.kill(pid, 0);
-      return { running: true, pid };
-    } catch {
-      try {
-        unlinkSync2(pidFile);
-      } catch {
-      }
-      return { running: false, pid: null };
-    }
-  } catch {
-    return { running: false, pid: null };
-  }
-}
-function startDaemonProcess() {
-  const daemonScript = new URL("./daemon-runner.js", import.meta.url).pathname;
-  const child = fork(daemonScript, [], {
-    detached: true,
-    stdio: "ignore",
-    env: {
-      ...process.env,
-      SKILLO_DAEMON: "1"
-    }
-  });
-  child.unref();
-  if (child.pid) {
-    writeFileSync3(getPidFile(), String(child.pid));
-    return child.pid;
-  }
-  return null;
-}
-async function ensureInitialized() {
-  if (existsSync8(getConfigFile())) return;
-  const { getDefaultConfig: getDefaultConfig2, saveConfig: saveConfig2 } = await import("./config-P5EM5L7N.js");
-  const { SkilloDatabase: SkilloDatabase2 } = await import("./database-F3BFFZKG.js");
-  const { getConfigDir: getConfigDir2, getSkillsDir: getSkillsDir2 } = await import("./paths-INOKEM66.js");
-  ensureDirectory(getDataDir());
-  ensureDirectory(getConfigDir2());
-  ensureDirectory(getSkillsDir2());
-  saveConfig2(getDefaultConfig2());
-  const db = new SkilloDatabase2();
-  await db.initialize();
-  db.close();
-  logger_default.dim("Skillo initialized.");
-}
-async function ensureLoggedIn() {
-  const { getApiClient: getApiClient2 } = await import("./api-client-KUQW7FSC.js");
-  const client = getApiClient2();
-  if (client.hasApiKey()) {
-    const result = await client.authenticate();
-    if (result.success) return true;
-    client.clearApiKey();
-    logger_default.warn("Session expired. Logging in again...");
-  }
-  logger_default.blank();
-  logger_default.info("Login required. Opening browser...");
-  logger_default.blank();
-  const { hostname: hostname2 } = await import("os");
-  const deviceName = `CLI on ${hostname2()}`;
-  const deviceAuthResult = await client.startDeviceAuth(deviceName);
-  if (!deviceAuthResult.success || !deviceAuthResult.data) {
-    logger_default.error("Failed to start authentication: " + (deviceAuthResult.error || "Unknown error"));
-    logger_default.dim("You can also login manually: skillo login <api-key>");
-    return false;
-  }
-  const { code, verification_url, interval } = deviceAuthResult.data;
-  logger_default.highlight(`  ${verification_url}`);
-  logger_default.blank();
-  try {
-    const { exec: execCb } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(execCb);
-    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? 'start ""' : "xdg-open";
-    await execAsync(`${openCmd} "${verification_url}"`);
-    logger_default.dim("Browser opened. Waiting for authorization...");
-  } catch {
-    logger_default.dim("Open the URL above in your browser to authorize.");
-  }
-  logger_default.dim("(Press Ctrl+C to cancel)");
-  const maxAttempts = 120;
-  for (let i = 0; i < maxAttempts; i++) {
-    await new Promise((r) => setTimeout(r, interval * 1e3));
-    const statusResult = await client.checkTokenStatus(code);
-    if (!statusResult.success) continue;
-    const status = statusResult.data?.status;
-    if (status === "ready") {
-      const tokenResult = await client.exchangeToken(code, deviceName);
-      if (tokenResult.success && tokenResult.data) {
-        client.saveApiKey(tokenResult.data.api_key);
-        const authResult = await client.authenticate();
-        logger_default.blank();
-        logger_default.success("Login successful!");
-        if (authResult.success && authResult.data) {
-          logger_default.info(`Welcome, ${authResult.data.user.name}!`);
-        }
-        logger_default.blank();
-        return true;
-      }
-      logger_default.error("Failed to complete login: " + (tokenResult.error || "Unknown error"));
-      return false;
-    }
-    if (status === "expired" || status === "used" || status === "not_found") {
-      logger_default.error(`Authorization ${status}. Please try again.`);
-      return false;
-    }
-  }
-  logger_default.error("Authorization timed out.");
-  return false;
-}
-var startCommand = new Command7("start").description("Start the Skillo daemon").option("-f, --foreground", "Run in foreground (don't daemonize)").action(async (options) => {
-  await ensureInitialized();
-  if (!options.foreground) {
-    const loggedIn = await ensureLoggedIn();
-    if (!loggedIn) {
-      process.exit(1);
-    }
+  if (!existsSync5(dbPath)) {
+    logger_default.error("Database not found.");
+    process.exit(1);
   }
-  const { running, pid } = isDaemonRunning2();
-  if (running) {
-    logger_default.success(`Daemon is already running (PID: ${pid})`);
-    const serviceStatus = getServiceStatus();
-    if (!serviceStatus.daemon.installed) {
-      const serviceResult = await installService({ includeTray: true });
-      if (serviceResult.success) {
-        logger_default.dim("Auto-start service installed.");
-      }
-    }
+  const db = new SkilloDatabase();
+  await db.initialize();
+  const skill = await db.getSkill(name);
+  const skillDir = skill?.path || join2(getSkillsDir(), name);
+  if (!skill && !existsSync5(skillDir)) {
+    db.close();
+    logger_default.error(`Skill not found: ${name}`);
+    process.exit(1);
+  }
+  if (!options.force) {
+    logger_default.warn(`This will delete skill '${name}'. This cannot be undone.`);
+    logger_default.dim("Use --force to confirm.");
+    db.close();
     return;
   }
-  if (options.foreground) {
-    logger_default.info("Starting Skillo daemon in foreground...");
-    logger_default.dim("Press Ctrl+C to stop");
-    logger_default.blank();
-    await runDaemonForeground();
-  } else {
-    logger_default.info("Starting Skillo daemon...");
-    if (process.platform === "win32") {
-      logger_default.dim("Running in foreground mode on Windows...");
-      logger_default.blank();
-      const serviceResult = await installService({ includeTray: true });
-      if (serviceResult.success) {
-        logger_default.dim("Auto-start service installed. Daemon will run in background on next login.");
-      }
-      await runDaemonForeground();
-    } else {
-      const daemonPid = startDaemonProcess();
-      if (daemonPid) {
-        logger_default.success(`Daemon started (PID: ${daemonPid})`);
-        const serviceResult = await installService({ includeTray: true });
-        if (serviceResult.success) {
-          logger_default.dim("Auto-start & tray service installed. Daemon will survive reboots.");
-        }
-        logger_default.blank();
-        logger_default.dim("Use 'skillo status' to check daemon status");
-        logger_default.dim("Use 'skillo stop' to stop the daemon");
-      } else {
-        logger_default.error("Failed to start daemon");
-      }
-    }
+  if (existsSync5(skillDir)) {
+    rmSync(skillDir, { recursive: true, force: true });
   }
-});
-var stopCommand = new Command7("stop").description("Stop the Skillo daemon").action(async () => {
-  const { running, pid } = isDaemonRunning2();
-  if (!running) {
-    logger_default.dim("Daemon is not running.");
-    return;
+  if (skill) {
+    await db.deleteSkill(name);
   }
-  logger_default.info(`Stopping daemon (PID: ${pid})...`);
-  const serviceResult = await uninstallService();
-  if (serviceResult.success) {
-    logger_default.dim("Auto-start service removed.");
+  db.close();
+  logger_default.success(`Skill deleted: ${name}`);
+});
+skillsCommand.command("path").description("Show skills directory path").action(async () => {
+  console.log(getSkillsDir());
+});
+skillsCommand.command("open").description("Open skills directory in file manager").action(async () => {
+  const skillsDir = getSkillsDir();
+  if (!existsSync5(skillsDir)) {
+    logger_default.error("Skills directory not found. Run 'skillo init' first.");
+    process.exit(1);
   }
-  try {
-    process.kill(pid, "SIGTERM");
-    logger_default.success("Daemon stopped");
-  } catch (error) {
-    if (error.code === "ESRCH") {
-      logger_default.dim("Daemon already stopped");
-    } else if (error.code === "EPERM") {
-      logger_default.error("Permission denied. Try with sudo.");
-      process.exit(1);
-    } else {
-      throw error;
+  const { exec } = await import("child_process");
+  const command = process.platform === "win32" ? `explorer "${skillsDir}"` : process.platform === "darwin" ? `open "${skillsDir}"` : `xdg-open "${skillsDir}"`;
+  exec(command, (error) => {
+    if (error) {
+      logger_default.error(`Failed to open directory: ${error.message}`);
+      logger_default.dim(`Path: ${skillsDir}`);
     }
+  });
+});
+skillsCommand.command("install <slug>").description("Install a shared/team skill from the platform").action(async (slug) => {
+  const client = getApiClient();
+  if (!client.hasApiKey()) {
+    logger_default.error("Not authenticated. Run 'skillo login' first.");
+    process.exit(1);
   }
-  const pidFile = getPidFile();
-  if (existsSync8(pidFile)) {
-    try {
-      unlinkSync2(pidFile);
-    } catch {
-    }
+  logger_default.dim(`Installing skill: ${slug}...`);
+  const result = await client.installSkill(slug);
+  if (!result.success || !result.data) {
+    logger_default.error(result.error || "Failed to install skill");
+    process.exit(1);
   }
-});
-var logsCommand = new Command7("logs").description("Show daemon logs").option("-n, --lines <number>", "Number of lines to show", "50").option("-f, --follow", "Follow log output").action(async (options) => {
-  const logFile = getLogFile();
-  if (!existsSync8(logFile)) {
-    logger_default.dim("No logs found.");
-    return;
+  const { slug: skillSlug, name, content } = result.data;
+  const skillsDir = getSkillsDir();
+  const skillDir = join2(skillsDir, skillSlug);
+  if (!existsSync5(skillsDir)) {
+    mkdirSync(skillsDir, { recursive: true });
   }
-  const numLines = parseInt(options.lines, 10);
-  if (options.follow) {
-    const { spawn: spawn2 } = await import("child_process");
-    const tail = spawn2("tail", ["-f", "-n", String(numLines), logFile], {
-      stdio: "inherit"
-    });
-    tail.on("error", () => {
-      logger_default.warn("Follow mode not supported on this platform.");
-      showLogs(logFile, numLines);
-    });
-  } else {
-    showLogs(logFile, numLines);
+  if (!existsSync5(skillDir)) {
+    mkdirSync(skillDir, { recursive: true });
   }
+  writeFileSync(join2(skillDir, "SKILL.md"), content, "utf-8");
+  logger_default.success(`Installed skill: ${name} (${skillSlug})`);
+  logger_default.dim(`  Path: ${skillDir}`);
 });
-function showLogs(logFile, numLines) {
-  const content = readFileSync5(logFile, "utf-8");
-  const lines = content.split("\n").filter(Boolean);
-  const lastLines = lines.slice(-numLines);
-  lastLines.forEach((line) => console.log(line));
-}
-var serviceCommand = new Command7("service").description("Manage auto-start service").addCommand(
-  new Command7("install").description("Install auto-start service (LaunchAgent on macOS, systemd on Linux)").option("--no-tray", "Skip installing tray icon service").action(async (options) => {
-    logger_default.info("Installing auto-start service...");
-    const result = await installService({ includeTray: options.tray !== false });
-    if (result.success) {
-      logger_default.success("Auto-start service installed.");
-      logger_default.dim("Daemon will start automatically on login and restart on crash.");
-      if (options.tray !== false) {
-        logger_default.dim("Tray icon will appear in GUI sessions.");
-      }
-    } else {
-      logger_default.error(`Failed to install service: ${result.error}`);
-    }
-  })
-).addCommand(
-  new Command7("uninstall").description("Remove auto-start service").action(async () => {
-    logger_default.info("Removing auto-start service...");
-    const result = await uninstallService();
+skillsCommand.command("uninstall <slug>").description("Uninstall a shared/team skill").action(async (slug) => {
+  const skillsDir = getSkillsDir();
+  const skillDir = join2(skillsDir, slug);
+  if (existsSync5(skillDir)) {
+    rmSync(skillDir, { recursive: true, force: true });
+    logger_default.success(`Removed skill files: ${slug}`);
+  } else {
+    logger_default.warn(`Skill directory not found: ${slug}`);
+  }
+  const client = getApiClient();
+  if (client.hasApiKey()) {
+    const result = await client.uninstallSkill(slug);
     if (result.success) {
-      logger_default.success("Auto-start service removed.");
-    } else {
-      logger_default.error(`Failed to remove service: ${result.error}`);
-    }
-  })
-).addCommand(
-  new Command7("status").description("Show auto-start service status").action(async () => {
-    const status = getServiceStatus();
-    logger_default.blank();
-    logger_default.info(`Platform: ${status.platform}`);
-    logger_default.blank();
-    if (status.daemon.installed) {
-      logger_default.running(`Daemon service: installed${status.daemon.loaded ? " & loaded" : " (not loaded)"}`);
-    } else {
-      logger_default.stopped("Daemon service: not installed");
-    }
-    if (status.tray.installed) {
-      logger_default.running(`Tray service: installed${status.tray.loaded ? " & loaded" : " (not loaded)"}`);
+      logger_default.dim("  Platform subscription updated");
     } else {
-      logger_default.stopped("Tray service: not installed");
-    }
-    logger_default.blank();
-    if (!status.daemon.installed) {
-      logger_default.dim("Run 'skillo service install' to enable auto-start.");
-    }
-    logger_default.blank();
-  })
-);
-async function runDaemonForeground() {
-  const pidFile = getPidFile();
-  writeFileSync3(pidFile, String(process.pid));
-  logger_default.dim(`Daemon PID: ${process.pid}`);
-  logger_default.dim(`Log file: ${getLogFile()}`);
-  logger_default.blank();
-  const cleanup = () => {
-    logger_default.blank();
-    logger_default.info("Shutting down daemon...");
-    if (existsSync8(pidFile)) {
-      try {
-        unlinkSync2(pidFile);
-      } catch {
-      }
+      logger_default.dim(`  Platform notification failed: ${result.error}`);
     }
-    process.exit(0);
-  };
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
-  const config = loadConfig();
-  const { getApiClient: getApiClient2 } = await import("./api-client-KUQW7FSC.js");
-  const client = getApiClient2();
-  if (!client.hasApiKey()) {
-    logger_default.error("Not logged in. Run 'skillo login' first.");
-    process.exit(1);
   }
-  const { ClaudeWatcher } = await import("./claude-watcher-N6GN6WHJ.js");
-  ensureDirectory(getDataDir());
-  const watchInterval = (config.daemon?.conversationCheckInterval || 5) * 1e3;
-  const watcher = new ClaudeWatcher(client, {
-    intervalMs: watchInterval,
-    callbacks: {
-      onSync: (count) => logger_default.success(`Synced ${count} Claude prompt(s)`),
-      onError: (err) => logger_default.error(`Watcher error: ${err.message}`),
-      log: (level, msg) => {
-        if (level === "ERROR") logger_default.error(msg);
-        else if (level === "WARN") logger_default.warn(msg);
-        else logger_default.dim(msg);
-      }
-    }
-  });
-  await watcher.start();
-  const { SkillUsageDetector } = await import("./skill-usage-detector-EO26MRYV.js");
-  const skillDetector = new SkillUsageDetector(client, {
-    intervalMs: 3e4,
-    callbacks: {
-      onDetection: (count) => logger_default.success(`Detected ${count} skill usage(s)`),
-      onError: (err) => logger_default.error(`Skill detection error: ${err.message}`),
-      log: (level, msg) => {
-        if (level === "ERROR") logger_default.error(msg);
-        else if (level === "WARN") logger_default.warn(msg);
-        else logger_default.dim(msg);
-      }
-    }
-  });
-  await skillDetector.start();
-  logger_default.success("Daemon is running. Watching Claude conversations and skill usage...");
-  await new Promise(() => {
-  });
-}
+});
 
 // src/commands/session.ts
-import { Command as Command8 } from "commander";
-import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3 } from "fs";
-var sessionCommand = new Command8("session").description("Manage terminal sessions");
+import { Command as Command6 } from "commander";
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync2, unlinkSync } from "fs";
+var sessionCommand = new Command6("session").description("Manage terminal sessions");
 sessionCommand.command("start").description("Start a new terminal session (for standalone terminals)").option("--shell <shell>", "Shell type (powershell, bash, zsh, cmd)", "powershell").action(async (options) => {
   try {
     const client = getApiClient();
@@ -2051,32 +894,50 @@ sessionCommand.command("list").description("List active sessions").action(async
   }
   logger_default.info("Check your sessions at: https://www.skillo.one/terminal");
 });
-var sessionAutoCommand = new Command8("session-auto").description("Auto-detect project and manage session (used by shell hooks)").argument("<cwd>", "Current working directory").option("--pid <pid>", "Terminal PID").option("--shell <shell>", "Shell type").action(async (cwd, options) => {
+var sessionAutoCommand = new Command6("session-auto").description("Auto-detect project and manage session (used by shell hooks)").argument("<cwd>", "Current working directory").option("--pid <pid>", "Terminal PID").option("--shell <shell>", "Shell type").action(async (cwd, options) => {
   const terminalPid = options.pid || String(process.ppid || process.pid);
   const shell = options.shell || process.env.SHELL?.split("/").pop() || "unknown";
   const sessionsDir = getActiveSessionsDir();
   const sessionFile = `${sessionsDir}/${terminalPid}.json`;
   let currentSession = null;
-  if (existsSync9(sessionFile)) {
+  if (existsSync6(sessionFile)) {
     try {
-      currentSession = JSON.parse(readFileSync6(sessionFile, "utf-8"));
+      currentSession = JSON.parse(readFileSync4(sessionFile, "utf-8"));
     } catch {
       currentSession = null;
     }
   }
   const cacheFile = getTrackedProjectsCacheFile();
   let matchedProject = null;
-  if (existsSync9(cacheFile)) {
+  if (existsSync6(cacheFile)) {
     try {
-      const cache = JSON.parse(readFileSync6(cacheFile, "utf-8"));
-      const normalizedCwd = cwd.toLowerCase().replace(/\/+$/, "");
+      const cache = JSON.parse(readFileSync4(cacheFile, "utf-8"));
+      const normalizedCwd = cwd.replace(/\\/g, "/").toLowerCase().replace(/\/+$/, "");
       for (const project of cache.projects || []) {
-        const normalizedPath = project.path.toLowerCase().replace(/\/+$/, "");
+        const normalizedPath = project.path.replace(/\\/g, "/").toLowerCase().replace(/\/+$/, "");
         if (normalizedCwd === normalizedPath || normalizedCwd.startsWith(normalizedPath + "/")) {
           matchedProject = project;
           break;
         }
       }
+      if (!matchedProject) {
+        try {
+          const { getGitInfo } = await import("./git-OGUSYBJS.js");
+          const gitInfo = getGitInfo(cwd);
+          if (gitInfo.remoteNormalized) {
+            for (const project of cache.projects || []) {
+              if (project.gitRemoteNormalized === gitInfo.remoteNormalized) {
+                matchedProject = project;
+                break;
+              }
+            }
+          }
+        } catch (error) {
+          if (process.env.DEBUG) {
+            logger_default.dim(`[skillo] git detection failed: ${error}`);
+          }
+        }
+      }
     } catch {
     }
   }
@@ -2093,7 +954,7 @@ var sessionAutoCommand = new Command8("session-auto").description("Auto-detect p
     } catch {
     }
     try {
-      unlinkSync3(sessionFile);
+      unlinkSync(sessionFile);
     } catch {
     }
   }
@@ -2102,7 +963,7 @@ var sessionAutoCommand = new Command8("session-auto").description("Auto-detect p
       const result = await client.startSession(shell, matchedProject.path);
       if (result.success && result.data?.sessionId) {
         ensureDirectory(sessionsDir);
-        writeFileSync4(sessionFile, JSON.stringify({
+        writeFileSync2(sessionFile, JSON.stringify({
           sessionId: result.data.sessionId,
           projectPath: matchedProject.path,
           projectName: matchedProject.name,
@@ -2118,13 +979,14 @@ var sessionAutoCommand = new Command8("session-auto").description("Auto-detect p
 });
 
 // src/commands/claude.ts
-import { Command as Command9 } from "commander";
+import { Command as Command7 } from "commander";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import * as readline from "readline";
 var projectCache = {
   projects: /* @__PURE__ */ new Map(),
+  gitRemoteIndex: /* @__PURE__ */ new Map(),
   lastFetched: 0
 };
 var CACHE_TTL_MS = 6e4;
@@ -2154,12 +1016,17 @@ async function loadTrackedProjects() {
     const result = await client.listProjects(true);
     if (result.success && result.data?.projects) {
       projectCache.projects.clear();
+      projectCache.gitRemoteIndex.clear();
       for (const project of result.data.projects) {
         const normalizedPath = normalizePath(project.path);
-        projectCache.projects.set(normalizedPath, {
+        const info = {
           tracked: project.trackingEnabled,
           name: project.name
-        });
+        };
+        projectCache.projects.set(normalizedPath, info);
+        if (project.gitRemoteNormalized) {
+          projectCache.gitRemoteIndex.set(project.gitRemoteNormalized, info);
+        }
       }
       projectCache.lastFetched = now;
     }
@@ -2179,9 +1046,23 @@ async function isProjectTracked(projectPath) {
       return info;
     }
   }
+  if (projectCache.gitRemoteIndex.size > 0) {
+    try {
+      const { getGitInfo } = await import("./git-OGUSYBJS.js");
+      const gitInfo = getGitInfo(projectPath);
+      if (gitInfo.remoteNormalized) {
+        const remoteMatch = projectCache.gitRemoteIndex.get(gitInfo.remoteNormalized);
+        if (remoteMatch) return remoteMatch;
+      }
+    } catch (error) {
+      if (process.env.DEBUG) {
+        logger_default.dim(`[skillo] git detection failed: ${error}`);
+      }
+    }
+  }
   return { tracked: false };
 }
-var claudeCommand = new Command9("claude").description("Sync and monitor Claude Code activity");
+var claudeCommand = new Command7("claude").description("Sync and monitor Claude Code activity");
 claudeCommand.command("sync").description("Sync Claude Code history to the platform (only tracked projects)").option("--since <timestamp>", "Only sync entries after this timestamp (ms)").option("--all", "Sync all history (ignore last sync position)").option("--project-path <path>", "Only sync prompts for this project path").option("--session <id>", "Link prompts to this terminal session").option("--session-start <iso>", "Session start time (ISO 8601) for filtering").option("--ignore-tracking", "Sync all projects regardless of tracking status (not recommended)").action(async (options) => {
   const client = getApiClient();
   if (!client.hasApiKey()) {
@@ -2304,7 +1185,7 @@ claudeCommand.command("watch").description("Watch Claude Code history and sync i
     logger_default.error("Not logged in. Run 'skillo login' first.");
     process.exit(1);
   }
-  const { ClaudeWatcher } = await import("./claude-watcher-N6GN6WHJ.js");
+  const { ClaudeWatcher } = await import("./claude-watcher-WKGBJYKN.js");
   const interval = parseInt(options.interval, 10);
   const projectFilter = options.projectPath || process.env.SKILLO_PROJECT_PATH;
   if (projectFilter) {
@@ -2398,284 +1279,93 @@ Synced to platform: ${response.data.sessions.length} recent sessions`);
   }
 });
 
-// src/commands/project.ts
-import { Command as Command10 } from "commander";
-import { existsSync as existsSync11, writeFileSync as writeFileSync5 } from "fs";
-
-// src/utils/git.ts
-import { execSync as execSync2 } from "child_process";
-import { join as join5, dirname as dirname2, basename as basename2 } from "path";
-function getGitInfo(projectPath) {
-  const result = {
-    isGitRepo: false,
-    rootPath: null,
-    remote: null,
-    remoteNormalized: null,
-    branch: null,
-    projectName: null
-  };
+// src/commands/add.ts
+import { Command as Command8 } from "commander";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var DEFAULT_API_BASE = "https://www.skillo.one";
+var addCommand = new Command8("add").description("Install a public skill from the Skillo Marketplace (no login required)").argument("<slug>", "Skill slug (e.g., git-conventional-commits)").option("--api-url <url>", "Override API base URL").action(async (slug, options) => {
+  const config = loadConfig();
+  const baseUrl = options.apiUrl || config.api?.baseUrl?.replace(/\/api\/cli\/?$/, "") || DEFAULT_API_BASE;
+  const downloadUrl = `${baseUrl}/api/marketplace/${encodeURIComponent(slug)}/download`;
+  console.log(`
+Fetching skill "${slug}" from marketplace...`);
   try {
-    const rootPath = execSync2("git rev-parse --show-toplevel", {
-      cwd: projectPath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (!rootPath) return result;
-    result.isGitRepo = true;
-    result.rootPath = rootPath;
-    result.projectName = basename2(rootPath);
-    try {
-      result.branch = execSync2("git rev-parse --abbrev-ref HEAD", {
-        cwd: projectPath,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-    } catch {
-    }
-    try {
-      result.remote = execSync2("git remote get-url origin", {
-        cwd: projectPath,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-    } catch {
-      try {
-        const remotes = execSync2("git remote", {
-          cwd: projectPath,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        }).trim().split("\n");
-        if (remotes.length > 0 && remotes[0]) {
-          result.remote = execSync2(`git remote get-url ${remotes[0]}`, {
-            cwd: projectPath,
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"]
-          }).trim();
-        }
-      } catch {
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
+      if (response.status === 404) {
+        console.error(`
+  Error: Skill "${slug}" not found in the marketplace.`);
+        console.error(`  Check the slug and try again.
+`);
+        process.exit(1);
       }
-    }
-    if (result.remote) {
-      result.remoteNormalized = normalizeGitRemote(result.remote);
-    }
-  } catch {
-  }
-  return result;
-}
-function normalizeGitRemote(remoteUrl) {
-  let url = remoteUrl.trim();
-  url = url.replace(/\.git$/, "");
-  const sshMatch = url.match(/^git@([^:]+):(.+)$/);
-  if (sshMatch) {
-    return `${sshMatch[1]}/${sshMatch[2]}`;
-  }
-  try {
-    let normalized = url.replace(/^(https?|git|ssh):\/\//, "").replace(/^git@/, "");
-    normalized = normalized.replace(/^[^@]+@/, "");
-    normalized = normalized.replace(/:\d+\//, "/");
-    normalized = normalized.replace(/\/+/g, "/");
-    normalized = normalized.replace(/^\/|\/$/g, "");
-    return normalized.toLowerCase();
-  } catch {
-    return url.toLowerCase();
-  }
-}
-
-// src/commands/project.ts
-import { resolve } from "path";
-var projectCommand = new Command10("project").description("Manage project tracking settings");
-var trackCommand = new Command10("track").description("Enable tracking for the current project").argument("[path]", "Project path (defaults to current directory)").option("-n, --name <name>", "Custom project name").action(async (pathArg, options) => {
-  const client = getApiClient();
-  logger_default.blank();
-  if (!client.hasApiKey()) {
-    logger_default.error("Not logged in. Run 'skillo login' first.");
-    return;
-  }
-  const projectPath = resolve(pathArg || process.cwd());
-  logger_default.info(`Tracking project: ${projectPath}`);
-  logger_default.blank();
-  const gitInfo = getGitInfo(projectPath);
-  if (gitInfo.isGitRepo) {
-    logger_default.dim(`Git repository detected`);
-    if (gitInfo.remote) {
-      logger_default.dim(`Remote: ${gitInfo.remoteNormalized || gitInfo.remote}`);
-    }
-    if (gitInfo.branch) {
-      logger_default.dim(`Branch: ${gitInfo.branch}`);
-    }
-    logger_default.blank();
-  } else {
-    logger_default.warn("No git repository detected in this directory.");
-    logger_default.dim("Project will be tracked by path only (no team sharing).");
-    logger_default.blank();
-  }
-  const projectName = options?.name || gitInfo.projectName || projectPath.split("/").pop() || "Unknown";
-  try {
-    const result = await client.connectProject({
-      path: projectPath,
-      name: projectName,
-      gitRemote: gitInfo.remote || void 0,
-      gitRemoteNormalized: gitInfo.remoteNormalized || void 0
-    });
-    if (result.success) {
-      logger_default.success(`Project "${projectName}" is now being tracked!`);
-      logger_default.blank();
-      logger_default.dim("Your Claude Code prompts in this directory will now be synced.");
-      logger_default.dim("Run 'skillo untrack' to stop tracking.");
+      const text = await response.text();
+      let errorMsg = `Request failed with status ${response.status}`;
       try {
-        const listResult = await client.listProjects(true);
-        if (listResult.success && listResult.data?.projects) {
-          const cacheData = {
-            updatedAt: Date.now(),
-            projects: listResult.data.projects.filter((p) => p.trackingEnabled).map((p) => ({ path: p.path, name: p.name }))
-          };
-          ensureDirectory(getDataDir());
-          writeFileSync5(getTrackedProjectsCacheFile(), JSON.stringify(cacheData, null, 2));
-        }
+        const json2 = JSON.parse(text);
+        if (json2.error) errorMsg = json2.error;
       } catch {
       }
-      const { running } = isDaemonRunning2();
-      if (!running) {
-        logger_default.blank();
-        const pid = startDaemonProcess();
-        if (pid) {
-          logger_default.success(`Background sync daemon started (PID: ${pid})`);
-        } else {
-          logger_default.dim("Tip: Run 'skillo start' to enable background sync.");
-        }
-      }
-      const shellIntegrationDir = getShellIntegrationDir();
-      if (!existsSync11(shellIntegrationDir) || !existsSync11(resolve(shellIntegrationDir, "skillo.zsh"))) {
-        logger_default.blank();
-        logger_default.dim("Tip: Run 'skillo setup-shell' to enable terminal auto-detection.");
-      }
-    } else {
-      logger_default.error("Failed to track project: " + (result.error || "Unknown error"));
-    }
-  } catch (error) {
-    logger_default.error("Failed to track project: " + (error instanceof Error ? error.message : "Unknown error"));
-  }
-  logger_default.blank();
-});
-var untrackCommand = new Command10("untrack").description("Disable tracking for the current project").argument("[path]", "Project path (defaults to current directory)").action(async (pathArg) => {
-  const client = getApiClient();
-  logger_default.blank();
-  if (!client.hasApiKey()) {
-    logger_default.error("Not logged in. Run 'skillo login' first.");
-    return;
-  }
-  const projectPath = resolve(pathArg || process.cwd());
-  logger_default.info(`Untracking project: ${projectPath}`);
-  try {
-    const result = await client.disconnectProject(projectPath);
-    if (result.success) {
-      logger_default.blank();
-      logger_default.success("Project is no longer being tracked.");
-      logger_default.blank();
-      logger_default.dim("Your Claude Code prompts in this directory will no longer be synced.");
-      logger_default.dim("Existing data remains in your account.");
-    } else {
-      logger_default.blank();
-      logger_default.error("Failed to untrack project: " + (result.error || "Unknown error"));
+      console.error(`
+  Error: ${errorMsg}
+`);
+      process.exit(1);
     }
-  } catch (error) {
-    logger_default.blank();
-    logger_default.error("Failed to untrack project: " + (error instanceof Error ? error.message : "Unknown error"));
-  }
-  logger_default.blank();
-});
-projectCommand.command("status").description("Show tracking status for the current project").argument("[path]", "Project path (defaults to current directory)").action(async (pathArg) => {
-  const client = getApiClient();
-  logger_default.blank();
-  if (!client.hasApiKey()) {
-    logger_default.error("Not logged in. Run 'skillo login' first.");
-    return;
-  }
-  const projectPath = resolve(pathArg || process.cwd());
-  logger_default.info(`Project: ${projectPath}`);
-  logger_default.blank();
-  const gitInfo = getGitInfo(projectPath);
-  if (gitInfo.isGitRepo) {
-    logger_default.dim(`Git: ${gitInfo.remoteNormalized || gitInfo.remote || "no remote"}`);
-    if (gitInfo.branch) {
-      logger_default.dim(`Branch: ${gitInfo.branch}`);
+    const json = await response.json();
+    if (!json.success || !json.data) {
+      console.error("\n  Error: Unexpected response from server.\n");
+      process.exit(1);
     }
-  } else {
-    logger_default.dim("Git: not a repository");
-  }
-  logger_default.blank();
-  try {
-    const result = await client.getProjectStatus(projectPath);
-    if (result.success && result.data) {
-      const { connected, connectedAt } = result.data;
-      if (connected) {
-        logger_default.success("Tracking ENABLED");
-        if (connectedAt) {
-          logger_default.dim(`Since: ${new Date(connectedAt).toLocaleDateString()}`);
-        }
-      } else {
-        logger_default.warn("Tracking DISABLED");
-        logger_default.dim("Run 'skillo track' to enable tracking.");
-      }
-    } else {
-      logger_default.warn("Not tracked");
-      logger_default.dim("Run 'skillo track' to enable tracking for this project.");
+    const { name, content, version } = json.data;
+    if (!content) {
+      console.error(`
+  Error: Skill "${slug}" has no content.
+`);
+      process.exit(1);
     }
+    const skillsDir = getSkillsDir();
+    const skillDir = path2.join(skillsDir, slug);
+    ensureDirectory(skillsDir);
+    ensureDirectory(skillDir);
+    const skillPath = path2.join(skillDir, "SKILL.md");
+    fs2.writeFileSync(skillPath, content, "utf-8");
+    console.log(`
+  Installed: ${name} (v${version || "1.0.0"})`);
+    console.log(`  Location: ${skillPath}`);
+    console.log(`
+  The skill is now available in Claude Code.
+`);
   } catch (error) {
-    logger_default.error("Failed to get project status: " + (error instanceof Error ? error.message : "Unknown error"));
-  }
-  logger_default.blank();
-});
-projectCommand.command("list").alias("ls").description("List all projects (tracked and untracked)").option("-a, --all", "Include untracked projects").action(async (options) => {
-  const client = getApiClient();
-  logger_default.blank();
-  if (!client.hasApiKey()) {
-    logger_default.error("Not logged in. Run 'skillo login' first.");
-    return;
-  }
-  try {
-    const result = await client.listProjects(options?.all || false);
-    if (result.success && result.data) {
-      const { projects, totalTracked, totalProjects } = result.data;
-      logger_default.info(`Projects (${totalTracked} tracked / ${totalProjects} total)`);
-      logger_default.blank();
-      if (projects.length === 0) {
-        logger_default.dim("No projects found.");
-        logger_default.dim("Run 'skillo track' in a project directory to start tracking.");
-      } else {
-        for (const project of projects) {
-          const status = project.trackingEnabled ? "\u25CF" : "\u25CB";
-          const statusColor = project.trackingEnabled ? "\x1B[32m" : "\x1B[90m";
-          const resetColor = "\x1B[0m";
-          console.log(`  ${statusColor}${status}${resetColor} ${project.name}`);
-          logger_default.dim(`    ${project.path}`);
-          if (project.gitRemoteNormalized) {
-            logger_default.dim(`    ${project.gitRemoteNormalized}`);
-          }
-        }
+    if (error instanceof Error) {
+      if (error.message.includes("ECONNREFUSED") || error.message.includes("fetch failed")) {
+        console.error("\n  Error: Cannot connect to Skillo platform.");
+        console.error("  Check your network connection and try again.\n");
+        process.exit(1);
       }
+      console.error(`
+  Error: ${error.message}
+`);
     } else {
-      logger_default.error("Failed to list projects: " + (result.error || "Unknown error"));
+      console.error("\n  Error: An unknown error occurred.\n");
     }
-  } catch (error) {
-    logger_default.error("Failed to list projects: " + (error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
   }
-  logger_default.blank();
 });
 
 // src/commands/auth.ts
-import { Command as Command11 } from "commander";
+import { Command as Command9 } from "commander";
 import { hostname } from "os";
 async function openBrowser(url) {
   try {
     const { exec } = await import("child_process");
     const { promisify } = await import("util");
     const execAsync = promisify(exec);
-    const platform2 = process.platform;
+    const platform = process.platform;
     let command;
-    if (platform2 === "darwin") {
+    if (platform === "darwin") {
       command = `open "${url}"`;
-    } else if (platform2 === "win32") {
+    } else if (platform === "win32") {
       command = `start "" "${url}"`;
     } else {
       command = `xdg-open "${url}"`;
@@ -2687,11 +1377,11 @@ async function openBrowser(url) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function autoStartDaemon() {
   try {
-    const { running } = isDaemonRunning2();
+    const { running } = isDaemonRunning();
     if (!running) {
       const pid = startDaemonProcess();
       if (pid) {
@@ -2705,7 +1395,7 @@ async function autoStartDaemon() {
   } catch {
   }
 }
-var loginCommand = new Command11("login").description("Login to Skillo platform").argument("[api-key]", "Your Skillo API key (optional, will use browser auth if not provided)").option("-u, --url <url>", "Platform URL (default: https://www.skillo.one)").option("-n, --no-browser", "Don't open browser automatically").action(async (apiKey, options) => {
+var loginCommand = new Command9("login").description("Login to Skillo platform").argument("[api-key]", "Your Skillo API key (optional, will use browser auth if not provided)").option("-u, --url <url>", "Platform URL (default: https://www.skillo.one)").option("-n, --no-browser", "Don't open browser automatically").action(async (apiKey, options) => {
   const client = getApiClient();
   logger_default.blank();
   if (options?.url) {
@@ -2825,7 +1515,7 @@ var loginCommand = new Command11("login").description("Login to Skillo platform"
   logger_default.blank();
   logger_default.error("Authorization timed out. Please try again.");
 });
-var logoutCommand = new Command11("logout").description("Logout from Skillo platform").action(async () => {
+var logoutCommand = new Command9("logout").description("Logout from Skillo platform").action(async () => {
   const client = getApiClient();
   logger_default.blank();
   if (!client.hasApiKey()) {
@@ -2837,7 +1527,7 @@ var logoutCommand = new Command11("logout").description("Logout from Skillo plat
   logger_default.blank();
   logger_default.dim("Your local data remains intact. Use 'skillo login' to reconnect.");
 });
-var whoamiCommand = new Command11("whoami").description("Show current login status").action(async () => {
+var whoamiCommand = new Command9("whoami").description("Show current login status").action(async () => {
   const client = getApiClient();
   logger_default.blank();
   if (!client.hasApiKey()) {
@@ -2868,10 +1558,10 @@ var whoamiCommand = new Command11("whoami").description("Show current login stat
 });
 
 // src/commands/sync.ts
-import { existsSync as existsSync12, writeFileSync as writeFileSync6, mkdirSync as mkdirSync2 } from "fs";
-import { join as join6 } from "path";
-import { Command as Command12 } from "commander";
-var syncCommand = new Command12("sync").description("Sync data with Skillo platform").option("--push", "Push local data to platform").option("--pull", "Pull data from platform").option("--patterns", "Sync patterns only").option("--skills", "Sync skills only").option("--commands", "Sync commands only").action(
+import { existsSync as existsSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
+import { Command as Command10 } from "commander";
+var syncCommand = new Command10("sync").description("Sync data with Skillo platform").option("--push", "Push local data to platform").option("--pull", "Pull data from platform").option("--patterns", "Sync patterns only").option("--skills", "Sync skills only").option("--commands", "Sync commands only").action(
   async (options) => {
     const client = getApiClient();
     logger_default.blank();
@@ -2885,7 +1575,7 @@ var syncCommand = new Command12("sync").description("Sync data with Skillo platf
     const syncSkills = options.skills || !options.patterns && !options.skills && !options.commands;
     const syncCommands = options.commands || !options.patterns && !options.skills && !options.commands;
     const dbPath = getDbPath();
-    if (!existsSync12(dbPath)) {
+    if (!existsSync8(dbPath)) {
       logger_default.error("Database not found. Run 'skillo init' first.");
       return;
     }
@@ -2987,12 +1677,12 @@ async function pullSkills(skills) {
   let downloaded = 0;
   for (const skill of skills) {
     if (!skill.content) continue;
-    const skillDir = join6(skillsDir, skill.slug);
-    const skillFile = join6(skillDir, "SKILL.md");
-    if (!existsSync12(skillDir)) {
+    const skillDir = join5(skillsDir, skill.slug);
+    const skillFile = join5(skillDir, "SKILL.md");
+    if (!existsSync8(skillDir)) {
       mkdirSync2(skillDir, { recursive: true });
     }
-    writeFileSync6(skillFile, skill.content, "utf-8");
+    writeFileSync4(skillFile, skill.content, "utf-8");
     downloaded++;
     logger_default.dim(`  Downloaded: ${skill.name}`);
   }
@@ -3000,15 +1690,15 @@ async function pullSkills(skills) {
 }
 
 // src/commands/tray.ts
-import { Command as Command13 } from "commander";
-var trayCommand = new Command13("tray").description("Start the system tray icon").action(async () => {
+import { Command as Command11 } from "commander";
+var trayCommand = new Command11("tray").description("Start the system tray icon").action(async () => {
   try {
-    const { startTray } = await import("./tray-YOL4R2RH.js");
+    const { startTray } = await import("./tray-WKFGUUTO.js");
     await startTray();
   } catch (error) {
     if (error instanceof Error && error.message.includes("Cannot find module")) {
-      logger_default.error("System tray not available. The systray2 package may not be installed.");
-      logger_default.dim("Try: npm install -g skillo");
+      logger_default.error("System tray not available. Native tray helper could not be loaded.");
+      logger_default.dim("Try reinstalling: npm install -g skillo");
     } else {
       logger_default.error(`Tray error: ${error instanceof Error ? error.message : error}`);
     }
@@ -3017,8 +1707,8 @@ var trayCommand = new Command13("tray").description("Start the system tray icon"
 });
 
 // src/cli.ts
-var VERSION = "0.2.5";
-var program = new Command14();
+var VERSION = "0.2.7";
+var program = new Command12();
 program.name("skillo").description(
   `Skillo - Learn workflows by observation, not explanation.
 
@@ -3029,8 +1719,10 @@ Quick Start:
   $ skillo init          # Initialize Skillo
   $ skillo login <key>   # Connect to Skillo platform
   $ skillo shell         # Launch a tracked shell session
-  $ skillo sync          # Sync skills from platform`
+  $ skillo sync          # Sync skills from platform
+  $ skillo add <slug>    # Install a public skill from Marketplace`
 ).version(VERSION, "-v, --version", "Show version number").option("--debug", "Enable debug output");
+program.addCommand(addCommand);
 program.addCommand(initCommand);
 program.addCommand(statusCommand);
 program.addCommand(configCommand);