skillo 0.1.4 → 0.2.1

package/dist/cli.js

@@ -6,20 +6,23 @@ import {
   loadConfig,
   saveConfig,
   setConfigValue
-} from "./chunk-QNRWQL6M.js";
+} from "./chunk-SYULMYPN.js";
 import {
   ensureDirectory,
+  getActiveSessionsDir,
   getConfigDir,
   getConfigFile,
   getDataDir,
   getDbPath,
   getLogFile,
   getPidFile,
-  getSkillsDir
-} from "./chunk-SWPZL2RI.js";
+  getShellIntegrationDir,
+  getSkillsDir,
+  getTrackedProjectsCacheFile
+} from "./chunk-WJKZWKER.js";
 
 // src/cli.ts
-import { Command as Command13 } from "commander";
+import { Command as Command14 } from "commander";
 
 // src/commands/init.ts
 import { existsSync as existsSync2 } from "fs";
@@ -590,15 +593,444 @@ var initCommand = new Command("init").description("Initialize Skillo configurati
 });
 
 // src/commands/status.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import { Command as Command2 } from "commander";
+
+// src/utils/os-service.ts
+import { existsSync as existsSync3, writeFileSync as writeFileSync2, 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");
+}
+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 {
+  }
+  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 (existsSync3(c)) return c;
+    }
+  } else {
+    const candidates = [
+      "/usr/local/bin/skillo",
+      "/usr/bin/skillo"
+    ];
+    for (const c of candidates) {
+      if (existsSync3(c)) return c;
+    }
+  }
+  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 (existsSync3(fnmDir)) paths.add(fnmDir);
+  } else {
+    const nvmDir = process.env.NVM_DIR || join(home, ".nvm");
+    if (existsSync3(nvmDir)) {
+      try {
+        const defaultAlias = join(nvmDir, "alias", "default");
+        if (existsSync3(defaultAlias)) {
+          const versionsDir = join(nvmDir, "versions", "node");
+          if (existsSync3(versionsDir)) {
+            const versions = readdirSync(versionsDir);
+            for (const v of versions) {
+              paths.add(join(versionsDir, v, "bin"));
+            }
+          }
+        }
+      } 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 {
+  }
+}
+function winRegExists(valueName) {
+  try {
+    execSync(`reg query "${WIN_REG_KEY}" /v "${valueName}"`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installService(options) {
+  const os2 = platform();
+  const skilloBin = findSkilloBin();
+  const envPath = buildPath();
+  const includeTray = options?.includeTray ?? true;
+  try {
+    if (os2 === "darwin") {
+      const agentsDir = getLaunchAgentsDir();
+      if (!existsSync3(agentsDir)) mkdirSync(agentsDir, { recursive: true });
+      const daemonPlist = getDaemonPlistPath();
+      writeFileSync2(daemonPlist, generateDaemonPlist(skilloBin, envPath), "utf-8");
+      try {
+        execSync(`launchctl unload "${daemonPlist}" 2>/dev/null`);
+      } catch {
+      }
+      execSync(`launchctl load "${daemonPlist}"`);
+      if (includeTray) {
+        const trayPlist = getTrayPlistPath();
+        writeFileSync2(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 (!existsSync3(systemdDir)) mkdirSync(systemdDir, { recursive: true });
+      writeFileSync2(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) {
+        writeFileSync2(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 (!existsSync3(dataDir)) mkdirSync(dataDir, { recursive: true });
+      const vbsPath = getWinDaemonVbsPath();
+      writeFileSync2(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.` };
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function uninstallService() {
+  const os2 = platform();
+  try {
+    if (os2 === "darwin") {
+      const daemonPlist = getDaemonPlistPath();
+      if (existsSync3(daemonPlist)) {
+        try {
+          execSync(`launchctl unload "${daemonPlist}" 2>/dev/null`);
+        } catch {
+        }
+        unlinkSync(daemonPlist);
+      }
+      const trayPlist = getTrayPlistPath();
+      if (existsSync3(trayPlist)) {
+        try {
+          execSync(`launchctl unload "${trayPlist}" 2>/dev/null`);
+        } catch {
+        }
+        unlinkSync(trayPlist);
+      }
+      return { success: true };
+    } else if (os2 === "linux") {
+      const daemonService = getDaemonServicePath();
+      if (existsSync3(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 (existsSync3(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 (existsSync3(vbsPath)) {
+        try {
+          unlinkSync(vbsPath);
+        } catch {
+        }
+      }
+      return { success: true };
+    } else {
+      return { success: false, error: `Unsupported platform: ${os2}` };
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function getServiceStatus() {
+  const os2 = platform();
+  if (os2 === "darwin") {
+    const daemonInstalled = existsSync3(getDaemonPlistPath());
+    const trayInstalled = existsSync3(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 = existsSync3(getDaemonServicePath());
+    const trayInstalled = existsSync3(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 {
+    }
+    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 }
+  };
+}
+
+// src/commands/status.ts
 function isDaemonRunning() {
   const pidFile = getPidFile();
-  if (!existsSync3(pidFile)) {
+  if (!existsSync4(pidFile)) {
     return { running: false, pid: null };
   }
   try {
-    const pidStr = readFileSync2(pidFile, "utf-8").trim();
+    const pidStr = readFileSync3(pidFile, "utf-8").trim();
     const pid = parseInt(pidStr, 10);
     if (isNaN(pid)) {
       return { running: false, pid: null };
@@ -622,11 +1054,18 @@ var statusCommand = new Command2("status").description("Show daemon status and s
     logger_default.stopped("Daemon is not running");
     logger_default.blank();
     logger_default.dim("Start with: skillo start");
-    return;
   }
+  const serviceStatus = getServiceStatus();
+  if (serviceStatus.daemon.installed) {
+    logger_default.running("Auto-start: enabled");
+  } else {
+    logger_default.stopped("Auto-start: disabled");
+    logger_default.dim("  Enable with: skillo service install");
+  }
+  if (!running) return;
   logger_default.blank();
   const dbPath = getDbPath();
-  if (!existsSync3(dbPath)) {
+  if (!existsSync4(dbPath)) {
     logger_default.warn("Database not found. Run 'skillo init' first.");
     return;
   }
@@ -643,10 +1082,10 @@ var statusCommand = new Command2("status").description("Show daemon status and s
   ]);
   logger_default.blank();
   const logFile = getLogFile();
-  if (existsSync3(logFile)) {
+  if (existsSync4(logFile)) {
     logger_default.dim("Recent log entries:");
     try {
-      const content = readFileSync2(logFile, "utf-8");
+      const content = readFileSync3(logFile, "utf-8");
       const lines = content.split("\n").filter(Boolean).slice(-5);
       lines.forEach((line) => {
         logger_default.dim(`  ${line}`);
@@ -658,7 +1097,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 existsSync5, readFileSync as readFileSync4 } from "fs";
 import { Command as Command3 } from "commander";
 import YAML from "yaml";
 var configCommand = new Command3("config").description(
@@ -666,12 +1105,12 @@ var configCommand = new Command3("config").description(
 );
 configCommand.command("show").description("Show current configuration").action(async () => {
   const configFile = getConfigFile();
-  if (!existsSync4(configFile)) {
+  if (!existsSync5(configFile)) {
     logger_default.error("Configuration not found.");
     logger_default.dim("Run 'skillo init' first.");
     process.exit(1);
   }
-  const content = readFileSync3(configFile, "utf-8");
+  const content = readFileSync4(configFile, "utf-8");
   logger_default.blank();
   logger_default.bold(`Configuration file: ${configFile}`);
   logger_default.blank();
@@ -679,7 +1118,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 (!existsSync5(configFile)) {
     logger_default.error("Configuration not found.");
     process.exit(1);
   }
@@ -697,7 +1136,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 (!existsSync5(configFile)) {
     logger_default.error("Configuration not found.");
     process.exit(1);
   }
@@ -739,7 +1178,7 @@ configCommand.command("path").description("Show configuration file path").action
 });
 
 // src/commands/patterns.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { Command as Command4 } from "commander";
 import chalk2 from "chalk";
 var patternsCommand = new Command4("patterns").description(
@@ -747,7 +1186,7 @@ var patternsCommand = new Command4("patterns").description(
 );
 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 (!existsSync6(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -784,7 +1223,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 (!existsSync6(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -827,7 +1266,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 (!existsSync6(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -848,12 +1287,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-HTWGTHC2.js");
-  const { writeFileSync: writeFileSync5, mkdirSync: mkdirSync2 } = await import("fs");
-  const { join: join6 } = await import("path");
-  const { getSkillsDir: getSkillsDir2, ensureDirectory: ensureDirectory2 } = await import("./paths-YODCFIEO.js");
+  const { getApiClient: getApiClient2 } = await import("./api-client-WO6NUCIJ.js");
+  const { writeFileSync: writeFileSync8, mkdirSync: mkdirSync3 } = await import("fs");
+  const { join: join7 } = await import("path");
+  const { getSkillsDir: getSkillsDir2, ensureDirectory: ensureDirectory2 } = await import("./paths-INOKEM66.js");
   const dbPath = getDbPath();
-  if (!existsSync5(dbPath)) {
+  if (!existsSync6(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -904,10 +1343,10 @@ patternsCommand.command("generate <id>").description("Generate a skill from a pa
   } else {
     const skillsDir = getSkillsDir2();
     ensureDirectory2(skillsDir);
-    const skillDir = join6(skillsDir, skill.slug);
-    const skillFile = join6(skillDir, "SKILL.md");
-    mkdirSync2(skillDir, { recursive: true });
-    writeFileSync5(skillFile, skill.content, "utf-8");
+    const skillDir = join7(skillsDir, skill.slug);
+    const skillFile = join7(skillDir, "SKILL.md");
+    mkdirSync3(skillDir, { recursive: true });
+    writeFileSync8(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();
@@ -922,7 +1361,7 @@ patternsCommand.command("clear").description("Clear all patterns").option("-f, -
     return;
   }
   const dbPath = getDbPath();
-  if (!existsSync5(dbPath)) {
+  if (!existsSync6(dbPath)) {
     logger_default.error("Database not found.");
     process.exit(1);
   }
@@ -930,8 +1369,8 @@ patternsCommand.command("clear").description("Clear all patterns").option("-f, -
 });
 
 // src/commands/skills.ts
-import { existsSync as existsSync6, readdirSync, rmSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, rmSync } from "fs";
+import { join as join2 } from "path";
 import { Command as Command5 } from "commander";
 import chalk3 from "chalk";
 var skillsCommand = new Command5("skills").description(
@@ -939,7 +1378,7 @@ var skillsCommand = new Command5("skills").description(
 );
 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 (!existsSync7(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -952,11 +1391,11 @@ skillsCommand.command("list").description("List all skills").option("-s, --sourc
   db.close();
   const skillsDir = getSkillsDir();
   const fsSkills = [];
-  if (existsSync6(skillsDir)) {
-    const entries = readdirSync(skillsDir, { withFileTypes: true });
+  if (existsSync7(skillsDir)) {
+    const entries = readdirSync2(skillsDir, { withFileTypes: true });
     entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).forEach((e) => {
-      const skillMd = join(skillsDir, e.name, "SKILL.md");
-      if (existsSync6(skillMd)) {
+      const skillMd = join2(skillsDir, e.name, "SKILL.md");
+      if (existsSync7(skillMd)) {
         fsSkills.push(e.name);
       }
     });
@@ -996,7 +1435,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 (!existsSync7(dbPath)) {
     logger_default.error("Database not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -1005,12 +1444,12 @@ skillsCommand.command("show <name>").description("Show skill details").action(as
   const skill = await db.getSkill(name);
   db.close();
   if (!skill) {
-    const skillPath = join(getSkillsDir(), name, "SKILL.md");
-    if (existsSync6(skillPath)) {
+    const skillPath = join2(getSkillsDir(), name, "SKILL.md");
+    if (existsSync7(skillPath)) {
       logger_default.blank();
       logger_default.bold(name);
       logger_default.blank();
-      logger_default.dim(`  Path: ${join(getSkillsDir(), name)}`);
+      logger_default.dim(`  Path: ${join2(getSkillsDir(), name)}`);
       logger_default.dim(`  Status: Not registered in database`);
       logger_default.blank();
       return;
@@ -1037,15 +1476,15 @@ 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)) {
+  if (!existsSync7(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 || join(getSkillsDir(), name);
-  if (!skill && !existsSync6(skillDir)) {
+  const skillDir = skill?.path || join2(getSkillsDir(), name);
+  if (!skill && !existsSync7(skillDir)) {
     db.close();
     logger_default.error(`Skill not found: ${name}`);
     process.exit(1);
@@ -1056,7 +1495,7 @@ skillsCommand.command("delete <name>").description("Delete a skill").option("-f,
     db.close();
     return;
   }
-  if (existsSync6(skillDir)) {
+  if (existsSync7(skillDir)) {
     rmSync(skillDir, { recursive: true, force: true });
   }
   if (skill) {
@@ -1070,7 +1509,7 @@ skillsCommand.command("path").description("Show skills directory path").action(a
 });
 skillsCommand.command("open").description("Open skills directory in file manager").action(async () => {
   const skillsDir = getSkillsDir();
-  if (!existsSync6(skillsDir)) {
+  if (!existsSync7(skillsDir)) {
     logger_default.error("Skills directory not found. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -1085,10 +1524,10 @@ skillsCommand.command("open").description("Open skills directory in file manager
 });
 
 // src/commands/shell.ts
-import { existsSync as existsSync7, writeFileSync as writeFileSync2, readFileSync as readFileSync4, appendFileSync } from "fs";
+import { existsSync as existsSync8, writeFileSync as writeFileSync3, readFileSync as readFileSync5, appendFileSync } from "fs";
 import { spawn } from "child_process";
-import { homedir } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
 import { Command as Command6 } from "commander";
 function normalizeCommand(cmd) {
   const variables = {};
@@ -1125,7 +1564,7 @@ function normalizeCommand(cmd) {
   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())) {
+  if (!existsSync8(getConfigFile())) {
     logger_default.error("Skillo not initialized. Run 'skillo init' first.");
     process.exit(1);
   }
@@ -1200,7 +1639,7 @@ var recordCommand = new Command6("record").description("Record a command (used b
     db.close();
     if (options.sync !== false) {
       try {
-        const { getApiClient: getApiClient2 } = await import("./api-client-HTWGTHC2.js");
+        const { getApiClient: getApiClient2 } = await import("./api-client-WO6NUCIJ.js");
         const client = getApiClient2();
         if (client.hasApiKey()) {
           await client.syncCommands([{
@@ -1221,7 +1660,7 @@ var recordCommand = new Command6("record").description("Record a command (used b
 );
 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 = homedir();
+  const home = homedir2();
   const dataDir = getDataDir();
   ensureDirectory(dataDir);
   let shell = null;
@@ -1269,7 +1708,7 @@ var setupShellCommand = new Command6("setup-shell").description("Set up shell in
   logger_default.blank();
 });
 async function installShellIntegration(shell, home, dataDir) {
-  const scriptPath = join2(dataDir, "shell-integration");
+  const scriptPath = join3(dataDir, "shell-integration");
   ensureDirectory(scriptPath);
   if (shell === "powershell") {
     const psScript = `# Skillo CLI Integration
@@ -1417,18 +1856,18 @@ $null = Register-EngineEvent -SourceIdentifier PowerShell.Exiting -Action {
 
 Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
 `;
-    const psScriptFile = join2(scriptPath, "skillo.ps1");
-    writeFileSync2(psScriptFile, psScript, "utf-8");
+    const psScriptFile = join3(scriptPath, "skillo.ps1");
+    writeFileSync3(psScriptFile, psScript, "utf-8");
     logger_default.success(`Created ${psScriptFile}`);
-    const profilePath = join2(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
-    const profileDir = join2(home, "Documents", "WindowsPowerShell");
+    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 (existsSync8(profilePath)) {
+      const content = readFileSync5(profilePath, "utf-8");
       if (!content.includes("Skillo CLI Integration")) {
         appendFileSync(profilePath, sourceLine);
         logger_default.success("Added to PowerShell profile");
@@ -1436,34 +1875,63 @@ Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
         logger_default.dim("Already in PowerShell profile");
       }
     } else {
-      writeFileSync2(profilePath, sourceLine, "utf-8");
+      writeFileSync3(profilePath, sourceLine, "utf-8");
       logger_default.success("Created PowerShell profile");
     }
   } else if (shell === "bash") {
     const bashScript = [
       "# Skillo CLI Integration",
-      "# Records commands to Skillo platform",
+      "# 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%3N 2>/dev/null || date +%s)",
+      "    _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%3N 2>/dev/null || date +%s)",
-      "            duration=$((end_time - _skillo_start_time))",
+      "            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`,
       "",
@@ -1472,18 +1940,21 @@ Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
       '    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 = join2(scriptPath, "skillo.bash");
-    writeFileSync2(bashScriptFile, bashScript, "utf-8");
+    const bashScriptFile = join3(scriptPath, "skillo.bash");
+    writeFileSync3(bashScriptFile, bashScript, "utf-8");
     logger_default.success(`Created ${bashScriptFile}`);
-    const bashrcPath = join2(home, ".bashrc");
+    const bashrcPath = join3(home, ".bashrc");
     const sourceLine = `
 # Skillo CLI Integration
 [ -f "${bashScriptFile}" ] && source "${bashScriptFile}"
 `;
-    if (existsSync7(bashrcPath)) {
-      const content = readFileSync4(bashrcPath, "utf-8");
+    if (existsSync8(bashrcPath)) {
+      const content = readFileSync5(bashrcPath, "utf-8");
       if (!content.includes("Skillo CLI Integration")) {
         appendFileSync(bashrcPath, sourceLine);
         logger_default.success("Added to ~/.bashrc");
@@ -1491,50 +1962,82 @@ Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
         logger_default.dim("Already in ~/.bashrc");
       }
     } else {
-      writeFileSync2(bashrcPath, sourceLine, "utf-8");
+      writeFileSync3(bashrcPath, sourceLine, "utf-8");
       logger_default.success("Created ~/.bashrc");
     }
   } else if (shell === "zsh") {
     const zshScript = [
       "# Skillo CLI Integration",
-      "# Records commands to Skillo platform",
+      "# 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%N)/1000000))",
+      "    _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%N)/1000000))",
-      "            duration=$((end_time - _skillo_start_time))",
+      "            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 = join2(scriptPath, "skillo.zsh");
-    writeFileSync2(zshScriptFile, zshScript, "utf-8");
+    const zshScriptFile = join3(scriptPath, "skillo.zsh");
+    writeFileSync3(zshScriptFile, zshScript, "utf-8");
     logger_default.success(`Created ${zshScriptFile}`);
-    const zshrcPath = join2(home, ".zshrc");
+    const zshrcPath = join3(home, ".zshrc");
     const sourceLine = `
 # Skillo CLI Integration
 [ -f "${zshScriptFile}" ] && source "${zshScriptFile}"
 `;
-    if (existsSync7(zshrcPath)) {
-      const content = readFileSync4(zshrcPath, "utf-8");
+    if (existsSync8(zshrcPath)) {
+      const content = readFileSync5(zshrcPath, "utf-8");
       if (!content.includes("Skillo CLI Integration")) {
         appendFileSync(zshrcPath, sourceLine);
         logger_default.success("Added to ~/.zshrc");
@@ -1542,7 +2045,7 @@ Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
         logger_default.dim("Already in ~/.zshrc");
       }
     } else {
-      writeFileSync2(zshrcPath, sourceLine, "utf-8");
+      writeFileSync3(zshrcPath, sourceLine, "utf-8");
       logger_default.success("Created ~/.zshrc");
     }
   } else if (shell === "fish") {
@@ -1560,20 +2063,20 @@ Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
       "",
       'echo -e "\\033[90mSkillo: Command tracking enabled\\033[0m"'
     ].join("\n");
-    const fishScriptFile = join2(scriptPath, "skillo.fish");
-    writeFileSync2(fishScriptFile, fishScript, "utf-8");
+    const fishScriptFile = join3(scriptPath, "skillo.fish");
+    writeFileSync3(fishScriptFile, fishScript, "utf-8");
     logger_default.success(`Created ${fishScriptFile}`);
-    const fishConfigDir = join2(home, ".config", "fish");
+    const fishConfigDir = join3(home, ".config", "fish");
     ensureDirectory(fishConfigDir);
-    const fishConfigPath = join2(fishConfigDir, "config.fish");
+    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 (existsSync8(fishConfigPath)) {
+      const content = readFileSync5(fishConfigPath, "utf-8");
       if (!content.includes("Skillo CLI Integration")) {
         appendFileSync(fishConfigPath, sourceLine);
         logger_default.success("Added to ~/.config/fish/config.fish");
@@ -1581,41 +2084,41 @@ end
         logger_default.dim("Already in fish config");
       }
     } else {
-      writeFileSync2(fishConfigPath, sourceLine, "utf-8");
+      writeFileSync3(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");
+    if (!existsSync8(filePath)) return;
+    let content = readFileSync5(filePath, "utf-8");
     content = content.replace(/\n# Skillo CLI Integration\n[^\n]*\n/g, "\n");
-    writeFileSync2(filePath, content, "utf-8");
+    writeFileSync3(filePath, content, "utf-8");
   };
   if (shell === "powershell") {
-    const profilePath = join2(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+    const profilePath = join3(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
     removeFromFile(profilePath);
   } else if (shell === "bash") {
-    removeFromFile(join2(home, ".bashrc"));
+    removeFromFile(join3(home, ".bashrc"));
   } else if (shell === "zsh") {
-    removeFromFile(join2(home, ".zshrc"));
+    removeFromFile(join3(home, ".zshrc"));
   } else if (shell === "fish") {
-    removeFromFile(join2(home, ".config", "fish", "config.fish"));
+    removeFromFile(join3(home, ".config", "fish", "config.fish"));
   }
 }
 
 // src/commands/daemon.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync3, unlinkSync } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2 } from "fs";
 import { fork } from "child_process";
 import { Command as Command7 } from "commander";
 function isDaemonRunning2() {
   const pidFile = getPidFile();
-  if (!existsSync8(pidFile)) {
+  if (!existsSync9(pidFile)) {
     return { running: false, pid: null };
   }
   try {
-    const pidStr = readFileSync5(pidFile, "utf-8").trim();
+    const pidStr = readFileSync6(pidFile, "utf-8").trim();
     const pid = parseInt(pidStr, 10);
     if (isNaN(pid)) {
       return { running: false, pid: null };
@@ -1625,7 +2128,7 @@ function isDaemonRunning2() {
       return { running: true, pid };
     } catch {
       try {
-        unlinkSync(pidFile);
+        unlinkSync2(pidFile);
       } catch {
       }
       return { running: false, pid: null };
@@ -1634,8 +2137,25 @@ function isDaemonRunning2() {
     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) {
+    writeFileSync4(getPidFile(), String(child.pid));
+    return child.pid;
+  }
+  return null;
+}
 var startCommand = new Command7("start").description("Start the Skillo daemon").option("-f, --foreground", "Run in foreground (don't daemonize)").action(async (options) => {
-  if (!existsSync8(getConfigFile())) {
+  if (!existsSync9(getConfigFile())) {
     logger_default.error("Skillo not initialized.");
     logger_default.dim("Run 'skillo init' first.");
     process.exit(1);
@@ -1645,36 +2165,31 @@ var startCommand = new Command7("start").description("Start the Skillo daemon").
     logger_default.warn(`Daemon is already running (PID: ${pid})`);
     return;
   }
-  const config = loadConfig();
   if (options.foreground) {
     logger_default.info("Starting Skillo daemon in foreground...");
     logger_default.dim("Press Ctrl+C to stop");
     logger_default.blank();
-    await runDaemon(config);
+    await runDaemonForeground();
   } else {
     logger_default.info("Starting Skillo daemon...");
     if (process.platform === "win32") {
       logger_default.warn("Background daemon not fully supported on Windows.");
       logger_default.dim("Running in foreground mode...");
       logger_default.blank();
-      await runDaemon(config);
+      await runDaemonForeground();
     } else {
-      const daemonScript = new URL("../daemon.js", import.meta.url).pathname;
-      const child = fork(daemonScript, [], {
-        detached: true,
-        stdio: "ignore",
-        env: {
-          ...process.env,
-          SKILLO_DAEMON: "1"
+      const daemonPid = startDaemonProcess();
+      if (daemonPid) {
+        logger_default.success(`Daemon started (PID: ${daemonPid})`);
+        const serviceResult = await installService({ includeTray: false });
+        if (serviceResult.success) {
+          logger_default.dim("Auto-start service installed. Daemon will survive reboots.");
         }
-      });
-      child.unref();
-      if (child.pid) {
-        writeFileSync3(getPidFile(), String(child.pid));
-        logger_default.success(`Daemon started (PID: ${child.pid})`);
         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");
       }
     }
   }
@@ -1686,6 +2201,10 @@ var stopCommand = new Command7("stop").description("Stop the Skillo daemon").act
     return;
   }
   logger_default.info(`Stopping daemon (PID: ${pid})...`);
+  const serviceResult = await uninstallService();
+  if (serviceResult.success) {
+    logger_default.dim("Auto-start service removed.");
+  }
   try {
     process.kill(pid, "SIGTERM");
     logger_default.success("Daemon stopped");
@@ -1700,16 +2219,16 @@ var stopCommand = new Command7("stop").description("Stop the Skillo daemon").act
     }
   }
   const pidFile = getPidFile();
-  if (existsSync8(pidFile)) {
+  if (existsSync9(pidFile)) {
     try {
-      unlinkSync(pidFile);
+      unlinkSync2(pidFile);
     } catch {
     }
   }
 });
 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)) {
+  if (!existsSync9(logFile)) {
     logger_default.dim("No logs found.");
     return;
   }
@@ -1728,23 +2247,70 @@ var logsCommand = new Command7("logs").description("Show daemon logs").option("-
   }
 });
 function showLogs(logFile, numLines) {
-  const content = readFileSync5(logFile, "utf-8");
+  const content = readFileSync6(logFile, "utf-8");
   const lines = content.split("\n").filter(Boolean);
   const lastLines = lines.slice(-numLines);
   lastLines.forEach((line) => console.log(line));
 }
-async function runDaemon(_config) {
+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();
+    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)"}`);
+    } 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));
+  writeFileSync4(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)) {
+    if (existsSync9(pidFile)) {
       try {
-        unlinkSync(pidFile);
+        unlinkSync2(pidFile);
       } catch {
       }
     }
@@ -1752,17 +2318,51 @@ async function runDaemon(_config) {
   };
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
-  const heartbeat = () => {
-  };
-  setInterval(heartbeat, 6e4);
-  heartbeat();
-  logger_default.success("Daemon is running. Watching for patterns...");
+  const config = loadConfig();
+  const { getApiClient: getApiClient2 } = await import("./api-client-WO6NUCIJ.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 existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync5, unlinkSync as unlinkSync3 } from "fs";
 var sessionCommand = new Command8("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 {
@@ -1809,6 +2409,71 @@ 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) => {
+  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 (existsSync10(sessionFile)) {
+    try {
+      currentSession = JSON.parse(readFileSync7(sessionFile, "utf-8"));
+    } catch {
+      currentSession = null;
+    }
+  }
+  const cacheFile = getTrackedProjectsCacheFile();
+  let matchedProject = null;
+  if (existsSync10(cacheFile)) {
+    try {
+      const cache = JSON.parse(readFileSync7(cacheFile, "utf-8"));
+      const normalizedCwd = cwd.toLowerCase().replace(/\/+$/, "");
+      for (const project of cache.projects || []) {
+        const normalizedPath = project.path.toLowerCase().replace(/\/+$/, "");
+        if (normalizedCwd === normalizedPath || normalizedCwd.startsWith(normalizedPath + "/")) {
+          matchedProject = project;
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  if (currentSession && matchedProject && currentSession.projectPath === matchedProject.path) {
+    process.exit(0);
+  }
+  const client = getApiClient();
+  if (!client.hasApiKey()) {
+    process.exit(0);
+  }
+  if (currentSession) {
+    try {
+      await client.endSession(currentSession.sessionId);
+    } catch {
+    }
+    try {
+      unlinkSync3(sessionFile);
+    } catch {
+    }
+  }
+  if (matchedProject) {
+    try {
+      const result = await client.startSession(shell, matchedProject.path);
+      if (result.success && result.data?.sessionId) {
+        ensureDirectory(sessionsDir);
+        writeFileSync5(sessionFile, JSON.stringify({
+          sessionId: result.data.sessionId,
+          projectPath: matchedProject.path,
+          projectName: matchedProject.name,
+          pid: terminalPid,
+          startedAt: Date.now()
+        }));
+        console.log(result.data.sessionId);
+      }
+    } catch {
+    }
+  }
+  process.exit(0);
+});
 
 // src/commands/claude.ts
 import { Command as Command9 } from "commander";
@@ -1991,112 +2656,38 @@ claudeCommand.command("sync").description("Sync Claude Code history to the platf
     process.exit(1);
   }
 });
-claudeCommand.command("watch").description("Watch Claude Code history and sync in real-time (only tracked projects)").option("--interval <ms>", "Check interval in milliseconds", "5000").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").action(async (options) => {
+claudeCommand.command("watch").description("Watch Claude Code history and sync in real-time (only tracked projects)").option("--interval <ms>", "Check interval in milliseconds", "5000").option("--project-path <path>", "Only sync prompts for this project path").option("--session <id>", "Link prompts to this terminal session").action(async (options) => {
   const client = getApiClient();
   if (!client.hasApiKey()) {
     logger_default.error("Not logged in. Run 'skillo login' first.");
     process.exit(1);
   }
-  const historyPath = getClaudeHistoryPath();
+  const { ClaudeWatcher } = await import("./claude-watcher-N6GN6WHJ.js");
   const interval = parseInt(options.interval, 10);
   const projectFilter = options.projectPath || process.env.SKILLO_PROJECT_PATH;
-  const ignoreTracking = options.ignoreTracking || false;
-  if (!fs.existsSync(historyPath)) {
-    logger_default.warn(`Claude Code history file not found at: ${historyPath}`);
-    logger_default.info("Waiting for file to be created...");
-  }
-  if (!ignoreTracking) {
-    logger_default.info("Loading tracked projects...");
-    await loadTrackedProjects();
-    const trackedCount = Array.from(projectCache.projects.values()).filter((p) => p.tracked).length;
-    if (trackedCount === 0) {
-      logger_default.warn("No projects are connected for tracking.");
-      logger_default.info("Run 'skillo connect' in your project directories first.");
-      process.exit(0);
-    }
-    logger_default.dim(`Watching ${trackedCount} tracked project(s)`);
-  } else {
-    logger_default.warn("Privacy filter disabled - watching all projects");
-  }
-  let lastSize = 0;
-  let lastMtime = 0;
-  try {
-    const stats = fs.statSync(historyPath);
-    lastSize = stats.size;
-    lastMtime = stats.mtimeMs;
-  } catch {
-  }
   if (projectFilter) {
     logger_default.info(`Watching for project: ${projectFilter}`);
   }
   logger_default.info(`Checking every ${interval}ms`);
   logger_default.info("Press Ctrl+C to stop");
-  const checkAndSync = async () => {
-    try {
-      if (!fs.existsSync(historyPath)) return;
-      const stats = fs.statSync(historyPath);
-      if (stats.size === lastSize && stats.mtimeMs === lastMtime) {
-        return;
-      }
-      if (!ignoreTracking) {
-        await loadTrackedProjects();
+  const watcher = new ClaudeWatcher(client, {
+    intervalMs: interval,
+    projectFilter,
+    sessionFilter: options.session,
+    callbacks: {
+      onSync: (count) => logger_default.success(`Synced ${count} prompt(s)`),
+      onError: (err) => logger_default.error(`Watch 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);
       }
-      const newPrompts = [];
-      if (stats.size > lastSize) {
-        const stream = fs.createReadStream(historyPath, {
-          start: lastSize,
-          encoding: "utf-8"
-        });
-        const rl = readline.createInterface({
-          input: stream,
-          crlfDelay: Infinity
-        });
-        for await (const line of rl) {
-          if (!line.trim()) continue;
-          try {
-            const entry = JSON.parse(line);
-            if (!entry.display || !entry.timestamp || !entry.project || !entry.sessionId) {
-              continue;
-            }
-            if (projectFilter && !matchesProjectPath(entry.project, projectFilter)) {
-              continue;
-            }
-            if (!isWithinSession(entry.timestamp, options.sessionStart)) {
-              continue;
-            }
-            if (!ignoreTracking) {
-              const trackingStatus = await isProjectTracked(entry.project);
-              if (!trackingStatus.tracked) {
-                continue;
-              }
-            }
-            newPrompts.push(entry);
-          } catch {
-          }
-        }
-      }
-      lastSize = stats.size;
-      lastMtime = stats.mtimeMs;
-      if (newPrompts.length > 0) {
-        logger_default.info(`Detected ${newPrompts.length} new prompt(s), syncing...`);
-        const response = await client.syncClaudePrompts(newPrompts, {
-          terminalSessionId: options.session,
-          projectPath: projectFilter
-        });
-        if (response.success && response.data) {
-          logger_default.success(`Synced ${response.data.promptsCreated} prompt(s)`);
-        } else {
-          logger_default.error(`Sync failed: ${response.error}`);
-        }
-      }
-    } catch (error) {
-      logger_default.error(`Watch error: ${error}`);
     }
-  };
-  await checkAndSync();
-  setInterval(checkAndSync, interval);
+  });
+  await watcher.start();
   process.on("SIGINT", () => {
     logger_default.info("\nStopping watcher...");
+    watcher.stop();
     process.exit(0);
   });
 });
@@ -2167,10 +2758,11 @@ Synced to platform: ${response.data.sessions.length} recent sessions`);
 
 // src/commands/project.ts
 import { Command as Command10 } from "commander";
+import { existsSync as existsSync12, writeFileSync as writeFileSync6 } from "fs";
 
 // src/utils/git.ts
-import { execSync } from "child_process";
-import { join as join4, dirname as dirname2, basename as basename2 } from "path";
+import { execSync as execSync2 } from "child_process";
+import { join as join5, dirname as dirname3, basename as basename2 } from "path";
 function getGitInfo(projectPath) {
   const result = {
     isGitRepo: false,
@@ -2181,7 +2773,7 @@ function getGitInfo(projectPath) {
     projectName: null
   };
   try {
-    const rootPath = execSync("git rev-parse --show-toplevel", {
+    const rootPath = execSync2("git rev-parse --show-toplevel", {
       cwd: projectPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -2191,7 +2783,7 @@ function getGitInfo(projectPath) {
     result.rootPath = rootPath;
     result.projectName = basename2(rootPath);
     try {
-      result.branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      result.branch = execSync2("git rev-parse --abbrev-ref HEAD", {
         cwd: projectPath,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -2199,20 +2791,20 @@ function getGitInfo(projectPath) {
     } catch {
     }
     try {
-      result.remote = execSync("git remote get-url origin", {
+      result.remote = execSync2("git remote get-url origin", {
         cwd: projectPath,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     } catch {
       try {
-        const remotes = execSync("git remote", {
+        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 = execSync(`git remote get-url ${remotes[0]}`, {
+          result.remote = execSync2(`git remote get-url ${remotes[0]}`, {
             cwd: projectPath,
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"]
@@ -2288,6 +2880,33 @@ var trackCommand = new Command10("track").description("Enable tracking for the c
       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.");
+      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());
+          writeFileSync6(getTrackedProjectsCacheFile(), JSON.stringify(cacheData, null, 2));
+        }
+      } 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 (!existsSync12(shellIntegrationDir) || !existsSync12(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"));
     }
@@ -2410,11 +3029,11 @@ async function openBrowser(url) {
     const { exec } = await import("child_process");
     const { promisify } = await import("util");
     const execAsync = promisify(exec);
-    const platform = process.platform;
+    const platform2 = process.platform;
     let command;
-    if (platform === "darwin") {
+    if (platform2 === "darwin") {
       command = `open "${url}"`;
-    } else if (platform === "win32") {
+    } else if (platform2 === "win32") {
       command = `start "" "${url}"`;
     } else {
       command = `xdg-open "${url}"`;
@@ -2428,6 +3047,22 @@ async function openBrowser(url) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+async function autoStartDaemon() {
+  try {
+    const { running } = isDaemonRunning2();
+    if (!running) {
+      const pid = startDaemonProcess();
+      if (pid) {
+        logger_default.dim(`Background daemon started (PID: ${pid}).`);
+      }
+    }
+    const result = await installService();
+    if (result.success) {
+      logger_default.dim("Auto-start installed. Daemon will survive reboots.");
+    }
+  } 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) => {
   const client = getApiClient();
   logger_default.blank();
@@ -2450,6 +3085,7 @@ var loginCommand = new Command11("login").description("Login to Skillo platform"
       logger_default.info(`Welcome, ${result.data.user.name}!`);
       logger_default.dim(`Email: ${result.data.user.email}`);
       logger_default.blank();
+      await autoStartDaemon();
       logger_default.dim("Your patterns and skills will now sync with the Skillo platform.");
     } else {
       client.clearApiKey();
@@ -2522,6 +3158,7 @@ var loginCommand = new Command11("login").description("Login to Skillo platform"
           logger_default.dim(`Email: ${authResult.data.user.email}`);
         }
         logger_default.blank();
+        await autoStartDaemon();
         logger_default.dim("Your patterns and skills will now sync with the Skillo platform.");
         return;
       } else {
@@ -2589,8 +3226,8 @@ var whoamiCommand = new Command11("whoami").description("Show current login stat
 });
 
 // src/commands/sync.ts
-import { existsSync as existsSync10, writeFileSync as writeFileSync4, mkdirSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync13, writeFileSync as writeFileSync7, 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(
   async (options) => {
@@ -2606,7 +3243,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 (!existsSync10(dbPath)) {
+    if (!existsSync13(dbPath)) {
       logger_default.error("Database not found. Run 'skillo init' first.");
       return;
     }
@@ -2708,21 +3345,38 @@ async function pullSkills(skills) {
   let downloaded = 0;
   for (const skill of skills) {
     if (!skill.content) continue;
-    const skillDir = join5(skillsDir, skill.slug);
-    const skillFile = join5(skillDir, "SKILL.md");
-    if (!existsSync10(skillDir)) {
-      mkdirSync(skillDir, { recursive: true });
+    const skillDir = join6(skillsDir, skill.slug);
+    const skillFile = join6(skillDir, "SKILL.md");
+    if (!existsSync13(skillDir)) {
+      mkdirSync2(skillDir, { recursive: true });
     }
-    writeFileSync4(skillFile, skill.content, "utf-8");
+    writeFileSync7(skillFile, skill.content, "utf-8");
     downloaded++;
     logger_default.dim(`  Downloaded: ${skill.name}`);
   }
   logger_default.success(`Downloaded ${downloaded} skills to ~/.claude/skills/`);
 }
 
+// src/commands/tray.ts
+import { Command as Command13 } from "commander";
+var trayCommand = new Command13("tray").description("Start the system tray icon").action(async () => {
+  try {
+    const { startTray } = await import("./tray-62I5KIFE.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");
+    } else {
+      logger_default.error(`Tray error: ${error instanceof Error ? error.message : error}`);
+    }
+    process.exit(1);
+  }
+});
+
 // src/cli.ts
-var VERSION = "0.1.0";
-var program = new Command13();
+var VERSION = "0.2.1";
+var program = new Command14();
 program.name("skillo").description(
   `Skillo - Learn workflows by observation, not explanation.
 
@@ -2751,10 +3405,13 @@ program.addCommand(logoutCommand);
 program.addCommand(whoamiCommand);
 program.addCommand(syncCommand);
 program.addCommand(sessionCommand);
+program.addCommand(sessionAutoCommand);
 program.addCommand(claudeCommand);
 program.addCommand(projectCommand);
 program.addCommand(trackCommand);
 program.addCommand(untrackCommand);
+program.addCommand(serviceCommand);
+program.addCommand(trayCommand);
 program.command("version").description("Show version information").action(() => {
   console.log(`Skillo v${VERSION}`);
   console.log("Autonomous workflow learning & skill generation system");