skillo 0.1.5 → 0.2.2

package/dist/cli.js

@@ -1,12 +1,17 @@
 #!/usr/bin/env node
 import {
-  getApiClient,
+  SkilloDatabase
+} from "./chunk-2CVEPT6U.js";
+import {
+  getApiClient
+} from "./chunk-ODOZM4QV.js";
+import {
   getConfigValue,
   getDefaultConfig,
   loadConfig,
   saveConfig,
   setConfigValue
-} from "./chunk-SYULMYPN.js";
+} from "./chunk-CPL3P2OF.js";
 import {
   ensureDirectory,
   getActiveSessionsDir,
@@ -22,465 +27,12 @@ import {
 } 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";
+import { existsSync } from "fs";
 import { Command } from "commander";
 
-// src/core/database.ts
-import initSqlJs from "sql.js";
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { randomUUID } from "crypto";
-import { dirname } from "path";
-var SQL = null;
-async function getSqlJs() {
-  if (!SQL) {
-    SQL = await initSqlJs();
-  }
-  return SQL;
-}
-var SkilloDatabase = class {
-  db = null;
-  dbPath;
-  initialized = false;
-  constructor(dbPath) {
-    this.dbPath = dbPath || getDbPath();
-    ensureDirectory(dirname(this.dbPath));
-  }
-  async getDb() {
-    if (!this.db) {
-      const SQL2 = await getSqlJs();
-      if (existsSync(this.dbPath)) {
-        const buffer = readFileSync(this.dbPath);
-        this.db = new SQL2.Database(buffer);
-      } else {
-        this.db = new SQL2.Database();
-      }
-    }
-    return this.db;
-  }
-  save() {
-    if (this.db) {
-      const data = this.db.export();
-      const buffer = Buffer.from(data);
-      writeFileSync(this.dbPath, buffer);
-    }
-  }
-  async initialize() {
-    if (this.initialized) return;
-    const db = await this.getDb();
-    const schema = `
-      -- Command history
-      CREATE TABLE IF NOT EXISTS commands (
-        id TEXT PRIMARY KEY,
-        timestamp DATETIME NOT NULL,
-        command TEXT NOT NULL,
-        normalized TEXT NOT NULL,
-        variables TEXT,
-        cwd TEXT NOT NULL,
-        exit_code INTEGER,
-        duration_ms INTEGER,
-        session_id TEXT NOT NULL,
-        project_id TEXT,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_commands_session ON commands(session_id);
-      CREATE INDEX IF NOT EXISTS idx_commands_timestamp ON commands(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_commands_normalized ON commands(normalized);
-
-      -- Terminal sessions
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        started_at DATETIME NOT NULL,
-        ended_at DATETIME,
-        shell TEXT NOT NULL,
-        project_path TEXT,
-        command_count INTEGER DEFAULT 0,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      );
-
-      -- Conversations (Claude Code)
-      CREATE TABLE IF NOT EXISTS conversations (
-        id TEXT PRIMARY KEY,
-        project_path TEXT,
-        started_at DATETIME,
-        updated_at DATETIME,
-        message_count INTEGER DEFAULT 0,
-        tool_calls TEXT,
-        files_touched TEXT,
-        intent_summary TEXT,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_conversations_project ON conversations(project_path);
-
-      -- Detected patterns
-      CREATE TABLE IF NOT EXISTS patterns (
-        id TEXT PRIMARY KEY,
-        source_type TEXT NOT NULL,
-        description TEXT NOT NULL,
-        count INTEGER DEFAULT 1,
-        first_seen DATETIME NOT NULL,
-        last_seen DATETIME NOT NULL,
-        data TEXT NOT NULL,
-        status TEXT DEFAULT 'active',
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_patterns_status ON patterns(status);
-      CREATE INDEX IF NOT EXISTS idx_patterns_count ON patterns(count);
-
-      -- Generated skills
-      CREATE TABLE IF NOT EXISTS skills (
-        id TEXT PRIMARY KEY,
-        name TEXT UNIQUE NOT NULL,
-        path TEXT NOT NULL,
-        source_patterns TEXT,
-        source_type TEXT NOT NULL,
-        trigger_phrase TEXT,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        usage_count INTEGER DEFAULT 0,
-        last_used_at DATETIME
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_skills_name ON skills(name);
-
-      -- Configuration
-      CREATE TABLE IF NOT EXISTS config (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      );
-
-      -- Ignored patterns
-      CREATE TABLE IF NOT EXISTS ignored_patterns (
-        pattern_hash TEXT PRIMARY KEY,
-        reason TEXT,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      );
-
-      -- Notifications
-      CREATE TABLE IF NOT EXISTS notifications (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        title TEXT NOT NULL,
-        message TEXT,
-        data TEXT,
-        is_read INTEGER DEFAULT 0,
-        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-      );
-    `;
-    db.run(schema);
-    this.save();
-    this.initialized = true;
-  }
-  close() {
-    if (this.db) {
-      this.save();
-      this.db.close();
-      this.db = null;
-    }
-  }
-  // Command operations
-  async addCommand(params) {
-    const db = await this.getDb();
-    const id = randomUUID();
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    db.run(
-      `INSERT INTO commands (id, timestamp, command, normalized, variables, cwd, exit_code, duration_ms, session_id, project_id)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [
-        id,
-        timestamp,
-        params.command,
-        params.normalized,
-        params.variables ? JSON.stringify(params.variables) : null,
-        params.cwd,
-        params.exitCode ?? null,
-        params.durationMs ?? null,
-        params.sessionId,
-        params.projectId ?? null
-      ]
-    );
-    this.save();
-    return id;
-  }
-  async getRecentCommands(options) {
-    const db = await this.getDb();
-    const limit = options?.limit ?? 100;
-    let query = "SELECT * FROM commands";
-    const params = [];
-    const conditions = [];
-    if (options?.sessionId) {
-      conditions.push("session_id = ?");
-      params.push(options.sessionId);
-    }
-    if (options?.days) {
-      const cutoff = /* @__PURE__ */ new Date();
-      cutoff.setDate(cutoff.getDate() - options.days);
-      conditions.push("timestamp >= ?");
-      params.push(cutoff.toISOString());
-    }
-    if (conditions.length > 0) {
-      query += " WHERE " + conditions.join(" AND ");
-    }
-    query += " ORDER BY timestamp DESC LIMIT ?";
-    params.push(limit);
-    const results = db.exec(query, params);
-    if (results.length === 0) return [];
-    return results[0].values.map((row) => this.mapCommand(results[0].columns, row));
-  }
-  // Session operations
-  async createSession(shell, projectPath) {
-    const db = await this.getDb();
-    const id = randomUUID();
-    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    db.run(
-      `INSERT INTO sessions (id, started_at, shell, project_path) VALUES (?, ?, ?, ?)`,
-      [id, startedAt, shell, projectPath ?? null]
-    );
-    this.save();
-    return id;
-  }
-  async endSession(sessionId) {
-    const db = await this.getDb();
-    const endedAt = (/* @__PURE__ */ new Date()).toISOString();
-    db.run(
-      `UPDATE sessions
-       SET ended_at = ?, command_count = (SELECT COUNT(*) FROM commands WHERE session_id = ?)
-       WHERE id = ?`,
-      [endedAt, sessionId, sessionId]
-    );
-    this.save();
-  }
-  async getSession(sessionId) {
-    const db = await this.getDb();
-    const results = db.exec("SELECT * FROM sessions WHERE id = ?", [sessionId]);
-    if (results.length === 0 || results[0].values.length === 0) return null;
-    return this.mapSession(results[0].columns, results[0].values[0]);
-  }
-  // Pattern operations
-  async addPattern(params) {
-    const db = await this.getDb();
-    const patternId = params.patternHash || randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = db.exec("SELECT id, count FROM patterns WHERE id = ?", [patternId]);
-    if (existing.length > 0 && existing[0].values.length > 0) {
-      db.run(`UPDATE patterns SET count = count + 1, last_seen = ?, updated_at = ? WHERE id = ?`, [
-        now,
-        now,
-        patternId
-      ]);
-    } else {
-      db.run(
-        `INSERT INTO patterns (id, source_type, description, data, first_seen, last_seen)
-         VALUES (?, ?, ?, ?, ?, ?)`,
-        [patternId, params.sourceType, params.description, JSON.stringify(params.data), now, now]
-      );
-    }
-    this.save();
-    return patternId;
-  }
-  async getPatterns(options) {
-    const db = await this.getDb();
-    const minCount = options?.minCount ?? 1;
-    const limit = options?.limit ?? 50;
-    let query = "SELECT * FROM patterns WHERE count >= ?";
-    const params = [minCount];
-    if (options?.type) {
-      query += " AND source_type = ?";
-      params.push(options.type);
-    }
-    if (options?.status) {
-      query += " AND status = ?";
-      params.push(options.status);
-    }
-    query += " ORDER BY count DESC, last_seen DESC LIMIT ?";
-    params.push(limit);
-    const results = db.exec(query, params);
-    if (results.length === 0) return [];
-    return results[0].values.map((row) => this.mapPattern(results[0].columns, row));
-  }
-  async getPattern(patternId) {
-    const db = await this.getDb();
-    let results = db.exec("SELECT * FROM patterns WHERE id = ?", [patternId]);
-    if (results.length === 0 || results[0].values.length === 0) {
-      results = db.exec("SELECT * FROM patterns WHERE id LIKE ?", [`${patternId}%`]);
-    }
-    if (results.length === 0 || results[0].values.length === 0) return null;
-    return this.mapPattern(results[0].columns, results[0].values[0]);
-  }
-  async updatePatternStatus(patternId, status) {
-    const db = await this.getDb();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    db.run(`UPDATE patterns SET status = ?, updated_at = ? WHERE id = ? OR id LIKE ?`, [
-      status,
-      now,
-      patternId,
-      `${patternId}%`
-    ]);
-    this.save();
-  }
-  async addIgnoredPattern(patternHash, reason) {
-    const db = await this.getDb();
-    db.run(`INSERT OR REPLACE INTO ignored_patterns (pattern_hash, reason) VALUES (?, ?)`, [
-      patternHash,
-      reason ?? null
-    ]);
-    this.save();
-  }
-  async isPatternIgnored(patternHash) {
-    const db = await this.getDb();
-    const results = db.exec("SELECT 1 FROM ignored_patterns WHERE pattern_hash = ?", [patternHash]);
-    return results.length > 0 && results[0].values.length > 0;
-  }
-  // Skill operations
-  async registerSkill(params) {
-    const db = await this.getDb();
-    const id = randomUUID();
-    db.run(
-      `INSERT INTO skills (id, name, path, source_patterns, source_type, trigger_phrase)
-       VALUES (?, ?, ?, ?, ?, ?)`,
-      [
-        id,
-        params.name,
-        params.path,
-        params.sourcePatterns ? JSON.stringify(params.sourcePatterns) : null,
-        params.sourceType,
-        params.triggerPhrase ?? null
-      ]
-    );
-    this.save();
-    return id;
-  }
-  async getSkills(options) {
-    const db = await this.getDb();
-    const sortMap = {
-      name: "name",
-      created: "created_at",
-      usage: "usage_count DESC"
-    };
-    const order = sortMap[options?.sortBy ?? "name"];
-    let query = "SELECT * FROM skills";
-    const params = [];
-    if (options?.source) {
-      query += " WHERE source_type = ?";
-      params.push(options.source);
-    }
-    query += ` ORDER BY ${order}`;
-    const results = db.exec(query, params);
-    if (results.length === 0) return [];
-    return results[0].values.map((row) => this.mapSkill(results[0].columns, row));
-  }
-  async getSkill(name) {
-    const db = await this.getDb();
-    const results = db.exec("SELECT * FROM skills WHERE name = ?", [name]);
-    if (results.length === 0 || results[0].values.length === 0) return null;
-    return this.mapSkill(results[0].columns, results[0].values[0]);
-  }
-  async deleteSkill(name) {
-    const db = await this.getDb();
-    db.run("DELETE FROM skills WHERE name = ?", [name]);
-    this.save();
-  }
-  async recordSkillUsage(name) {
-    const db = await this.getDb();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    db.run(`UPDATE skills SET usage_count = usage_count + 1, last_used_at = ? WHERE name = ?`, [
-      now,
-      name
-    ]);
-    this.save();
-  }
-  // Statistics
-  async getStats() {
-    const db = await this.getDb();
-    const today = /* @__PURE__ */ new Date();
-    today.setHours(0, 0, 0, 0);
-    const todayIso = today.toISOString();
-    const getCount = (query, params = []) => {
-      const results = db.exec(query, params);
-      if (results.length === 0 || results[0].values.length === 0) return 0;
-      return results[0].values[0][0];
-    };
-    return {
-      commandsToday: getCount("SELECT COUNT(*) FROM commands WHERE timestamp >= ?", [todayIso]),
-      commandsTotal: getCount("SELECT COUNT(*) FROM commands"),
-      patternsActive: getCount("SELECT COUNT(*) FROM patterns WHERE status = 'active'"),
-      skillsTotal: getCount("SELECT COUNT(*) FROM skills"),
-      conversationsTotal: getCount("SELECT COUNT(*) FROM conversations")
-    };
-  }
-  // Mapping helpers
-  mapCommand(columns, values) {
-    const row = this.toObject(columns, values);
-    return {
-      id: row.id,
-      timestamp: row.timestamp,
-      command: row.command,
-      normalized: row.normalized,
-      variables: row.variables,
-      cwd: row.cwd,
-      exitCode: row.exit_code,
-      durationMs: row.duration_ms,
-      sessionId: row.session_id,
-      projectId: row.project_id,
-      createdAt: row.created_at
-    };
-  }
-  mapSession(columns, values) {
-    const row = this.toObject(columns, values);
-    return {
-      id: row.id,
-      startedAt: row.started_at,
-      endedAt: row.ended_at,
-      shell: row.shell,
-      projectPath: row.project_path,
-      commandCount: row.command_count,
-      createdAt: row.created_at
-    };
-  }
-  mapPattern(columns, values) {
-    const row = this.toObject(columns, values);
-    return {
-      id: row.id,
-      sourceType: row.source_type,
-      description: row.description,
-      count: row.count,
-      firstSeen: row.first_seen,
-      lastSeen: row.last_seen,
-      data: JSON.parse(row.data),
-      status: row.status,
-      createdAt: row.created_at,
-      updatedAt: row.updated_at
-    };
-  }
-  mapSkill(columns, values) {
-    const row = this.toObject(columns, values);
-    return {
-      id: row.id,
-      name: row.name,
-      path: row.path,
-      sourcePatterns: row.source_patterns,
-      sourceType: row.source_type,
-      triggerPhrase: row.trigger_phrase,
-      createdAt: row.created_at,
-      usageCount: row.usage_count,
-      lastUsedAt: row.last_used_at
-    };
-  }
-  toObject(columns, values) {
-    const obj = {};
-    columns.forEach((col, i) => {
-      obj[col] = values[i];
-    });
-    return obj;
-  }
-};
-
 // src/utils/logger.ts
 import chalk from "chalk";
 var logger = {
@@ -552,7 +104,7 @@ var initCommand = new Command("init").description("Initialize Skillo configurati
   const configDir = getConfigDir();
   const skillsDir = getSkillsDir();
   const configFile = getConfigFile();
-  if (existsSync2(configFile) && !options.force) {
+  if (existsSync(configFile) && !options.force) {
     logger_default.warn("Skillo is already initialized.");
     logger_default.dim("Use --force to reinitialize and overwrite configuration.");
     return;
@@ -595,6 +147,435 @@ var initCommand = new Command("init").description("Initialize Skillo configurati
 // 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");
+}
+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 (existsSync2(c)) return c;
+    }
+  } else {
+    const candidates = [
+      "/usr/local/bin/skillo",
+      "/usr/bin/skillo"
+    ];
+    for (const c of candidates) {
+      if (existsSync2(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 (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"));
+            }
+          }
+        }
+      } 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 (!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.` };
+    }
+  } 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 (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}` };
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+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 {
+    }
+    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)) {
@@ -625,8 +606,15 @@ 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)) {
@@ -851,9 +839,9 @@ 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-WO6NUCIJ.js");
-  const { writeFileSync: writeFileSync7, mkdirSync: mkdirSync2 } = await import("fs");
-  const { join: join6 } = await import("path");
+  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 dbPath = getDbPath();
   if (!existsSync5(dbPath)) {
@@ -907,9 +895,9 @@ 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 });
+    const skillDir = join7(skillsDir, skill.slug);
+    const skillFile = join7(skillDir, "SKILL.md");
+    mkdirSync3(skillDir, { recursive: true });
     writeFileSync7(skillFile, skill.content, "utf-8");
     await db.updatePatternStatus(id, "converted");
     logger_default.success(`Skill saved to: ~/.claude/skills/${skill.slug}/SKILL.md`);
@@ -933,8 +921,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 existsSync6, 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(
@@ -956,9 +944,9 @@ skillsCommand.command("list").description("List all skills").option("-s, --sourc
   const skillsDir = getSkillsDir();
   const fsSkills = [];
   if (existsSync6(skillsDir)) {
-    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    const entries = readdirSync2(skillsDir, { withFileTypes: true });
     entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).forEach((e) => {
-      const skillMd = join(skillsDir, e.name, "SKILL.md");
+      const skillMd = join2(skillsDir, e.name, "SKILL.md");
       if (existsSync6(skillMd)) {
         fsSkills.push(e.name);
       }
@@ -1008,12 +996,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");
+    const skillPath = join2(getSkillsDir(), name, "SKILL.md");
     if (existsSync6(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;
@@ -1047,7 +1035,7 @@ skillsCommand.command("delete <name>").description("Delete a skill").option("-f,
   const db = new SkilloDatabase();
   await db.initialize();
   const skill = await db.getSkill(name);
-  const skillDir = skill?.path || join(getSkillsDir(), name);
+  const skillDir = skill?.path || join2(getSkillsDir(), name);
   if (!skill && !existsSync6(skillDir)) {
     db.close();
     logger_default.error(`Skill not found: ${name}`);
@@ -1090,8 +1078,8 @@ 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 { 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 = {};
@@ -1203,7 +1191,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-WO6NUCIJ.js");
+        const { getApiClient: getApiClient2 } = await import("./api-client-KUQW7FSC.js");
         const client = getApiClient2();
         if (client.hasApiKey()) {
           await client.syncCommands([{
@@ -1224,7 +1212,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;
@@ -1272,7 +1260,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
@@ -1420,11 +1408,11 @@ $null = Register-EngineEvent -SourceIdentifier PowerShell.Exiting -Action {
 
 Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
 `;
-    const psScriptFile = join2(scriptPath, "skillo.ps1");
+    const psScriptFile = join3(scriptPath, "skillo.ps1");
     writeFileSync2(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
@@ -1509,10 +1497,10 @@ Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
       "",
       'echo -e "\\033[90mSkillo: Command tracking enabled\\033[0m"'
     ].join("\n");
-    const bashScriptFile = join2(scriptPath, "skillo.bash");
+    const bashScriptFile = join3(scriptPath, "skillo.bash");
     writeFileSync2(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}"
@@ -1592,10 +1580,10 @@ Write-Host "Skillo: Command tracking enabled" -ForegroundColor DarkGray
       "",
       'echo -e "\\033[90mSkillo: Command tracking enabled\\033[0m"'
     ].join("\n");
-    const zshScriptFile = join2(scriptPath, "skillo.zsh");
+    const zshScriptFile = join3(scriptPath, "skillo.zsh");
     writeFileSync2(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}"
@@ -1627,12 +1615,12 @@ 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");
+    const fishScriptFile = join3(scriptPath, "skillo.fish");
     writeFileSync2(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}"
@@ -1661,19 +1649,19 @@ async function uninstallShellIntegration(shell, home) {
     writeFileSync2(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 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() {
@@ -1692,7 +1680,7 @@ function isDaemonRunning2() {
       return { running: true, pid };
     } catch {
       try {
-        unlinkSync(pidFile);
+        unlinkSync2(pidFile);
       } catch {
       }
       return { running: false, pid: null };
@@ -1718,15 +1706,102 @@ function startDaemonProcess() {
   }
   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) => {
-  if (!existsSync8(getConfigFile())) {
-    logger_default.error("Skillo not initialized.");
-    logger_default.dim("Run 'skillo init' first.");
-    process.exit(1);
+  await ensureInitialized();
+  if (!options.foreground) {
+    const loggedIn = await ensureLoggedIn();
+    if (!loggedIn) {
+      process.exit(1);
+    }
   }
   const { running, pid } = isDaemonRunning2();
   if (running) {
-    logger_default.warn(`Daemon is already running (PID: ${pid})`);
+    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.");
+      }
+    }
     return;
   }
   if (options.foreground) {
@@ -1737,14 +1812,21 @@ var startCommand = new Command7("start").description("Start the Skillo daemon").
   } 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.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");
@@ -1761,6 +1843,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");
@@ -1777,7 +1863,7 @@ var stopCommand = new Command7("stop").description("Stop the Skillo daemon").act
   const pidFile = getPidFile();
   if (existsSync8(pidFile)) {
     try {
-      unlinkSync(pidFile);
+      unlinkSync2(pidFile);
     } catch {
     }
   }
@@ -1808,6 +1894,53 @@ function showLogs(logFile, numLines) {
   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();
+    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));
@@ -1819,7 +1952,7 @@ async function runDaemonForeground() {
     logger_default.info("Shutting down daemon...");
     if (existsSync8(pidFile)) {
       try {
-        unlinkSync(pidFile);
+        unlinkSync2(pidFile);
       } catch {
       }
     }
@@ -1828,7 +1961,7 @@ async function runDaemonForeground() {
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   const config = loadConfig();
-  const { getApiClient: getApiClient2 } = await import("./api-client-WO6NUCIJ.js");
+  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.");
@@ -1871,7 +2004,7 @@ async function runDaemonForeground() {
 
 // src/commands/session.ts
 import { Command as Command8 } from "commander";
-import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync4, 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 {
@@ -1960,7 +2093,7 @@ var sessionAutoCommand = new Command8("session-auto").description("Auto-detect p
     } catch {
     }
     try {
-      unlinkSync2(sessionFile);
+      unlinkSync3(sessionFile);
     } catch {
     }
   }
@@ -2270,8 +2403,8 @@ import { Command as Command10 } from "commander";
 import { existsSync as existsSync11, writeFileSync as writeFileSync5 } 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 dirname2, basename as basename2 } from "path";
 function getGitInfo(projectPath) {
   const result = {
     isGitRepo: false,
@@ -2282,7 +2415,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"]
@@ -2292,7 +2425,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"]
@@ -2300,20 +2433,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"]
@@ -2538,11 +2671,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}"`;
@@ -2556,6 +2689,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();
@@ -2578,6 +2727,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();
@@ -2650,6 +2800,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 {
@@ -2717,8 +2868,8 @@ var whoamiCommand = new Command11("whoami").description("Show current login stat
 });
 
 // src/commands/sync.ts
-import { existsSync as existsSync12, writeFileSync as writeFileSync6, mkdirSync } from "fs";
-import { join as join5 } from "path";
+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(
   async (options) => {
@@ -2836,10 +2987,10 @@ 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");
+    const skillDir = join6(skillsDir, skill.slug);
+    const skillFile = join6(skillDir, "SKILL.md");
     if (!existsSync12(skillDir)) {
-      mkdirSync(skillDir, { recursive: true });
+      mkdirSync2(skillDir, { recursive: true });
     }
     writeFileSync6(skillFile, skill.content, "utf-8");
     downloaded++;
@@ -2848,9 +2999,26 @@ async function pullSkills(skills) {
   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.2";
+var program = new Command14();
 program.name("skillo").description(
   `Skillo - Learn workflows by observation, not explanation.
 
@@ -2884,6 +3052,8 @@ 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");