skillo 0.2.5 → 0.2.8

package/dist/{config-P5EM5L7N.js → config-ZOKAP2LJ.js}

@@ -5,8 +5,8 @@ import {
   loadConfig,
   saveConfig,
   setConfigValue
-} from "./chunk-CPL3P2OF.js";
-import "./chunk-WJKZWKER.js";
+} from "./chunk-QUXHHRRK.js";
+import "./chunk-63FVALWX.js";
 export {
   getConfigValue,
   getDefaultConfig,
@@ -14,4 +14,4 @@ export {
   saveConfig,
   setConfigValue
 };
-//# sourceMappingURL=config-P5EM5L7N.js.map
+//# sourceMappingURL=config-ZOKAP2LJ.js.map

package/dist/daemon-6DTCMOJB.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import {
+  ensureLoggedIn,
+  isDaemonRunning,
+  isTrayRunning,
+  logsCommand,
+  serviceCommand,
+  startCommand,
+  startDaemonProcess,
+  startTrayProcess,
+  stopCommand
+} from "./chunk-XLJGCOVT.js";
+import "./chunk-VAQ73XPE.js";
+import "./chunk-6UGTWBUW.js";
+import "./chunk-QUXHHRRK.js";
+import "./chunk-63FVALWX.js";
+export {
+  ensureLoggedIn,
+  isDaemonRunning,
+  isTrayRunning,
+  logsCommand,
+  serviceCommand,
+  startCommand,
+  startDaemonProcess,
+  startTrayProcess,
+  stopCommand
+};
+//# sourceMappingURL=daemon-6DTCMOJB.js.map

package/dist/daemon-runner.js

@@ -1,5 +1,5 @@
 // src/daemon-runner.ts
-import { existsSync as existsSync6, writeFileSync as writeFileSync4, unlinkSync, readFileSync as readFileSync4, readdirSync as readdirSync2, appendFileSync } from "fs";
+import { existsSync as existsSync8, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, appendFileSync } from "fs";
 
 // src/core/config.ts
 import { readFileSync, writeFileSync, existsSync as existsSync2 } from "fs";
@@ -33,11 +33,11 @@ function getSkillsDir() {
 function getClaudeDir() {
   return join(getHomeDir(), ".claude");
 }
-function ensureDirectory(path3) {
-  if (existsSync(path3)) {
+function ensureDirectory(path4) {
+  if (existsSync(path4)) {
     return false;
   }
-  mkdirSync(path3, { recursive: true });
+  mkdirSync(path4, { recursive: true });
   return true;
 }
 function getLogFile() {
@@ -138,8 +138,8 @@ function deepMerge(base, override) {
   }
   return result;
 }
-function loadConfig(path3) {
-  const configPath = path3 || getConfigFile();
+function loadConfig(path4) {
+  const configPath = path4 || getConfigFile();
   if (!existsSync2(configPath)) {
     return getDefaultConfig();
   }
@@ -153,8 +153,8 @@ function loadConfig(path3) {
     return getDefaultConfig();
   }
 }
-function saveConfig(config, path3) {
-  const configPath = path3 || getConfigFile();
+function saveConfig(config, path4) {
+  const configPath = path4 || getConfigFile();
   ensureDirectory(dirname(configPath));
   const converted = convertKeysToSnakeCase(config);
   const content = YAML.stringify(converted, {
@@ -257,6 +257,20 @@ var ApiClient = class {
     saveConfig(config);
     this.baseUrl = url;
   }
+  /**
+   * Safely parse JSON from a fetch response, returning an error ApiResponse on failure.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async parseJsonResponse(response) {
+    try {
+      return { data: await response.json() };
+    } catch {
+      return {
+        success: false,
+        error: `Server returned non-JSON response (status ${response.status})`
+      };
+    }
+  }
   /**
    * Make an authenticated API request
    */
@@ -275,7 +289,9 @@ var ApiClient = class {
         ...options,
         headers
       });
-      const data = await response.json();
+      const parsed = await this.parseJsonResponse(response);
+      if ("success" in parsed) return parsed;
+      const { data } = parsed;
       if (process.env.SKILLO_DEBUG) {
         console.log("[DEBUG] Request:", url);
         console.log("[DEBUG] Status:", response.status);
@@ -396,7 +412,9 @@ var ApiClient = class {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ device_name: deviceName })
       });
-      const data = await response.json();
+      const parsed = await this.parseJsonResponse(response);
+      if ("success" in parsed) return parsed;
+      const { data } = parsed;
       if (!response.ok) {
         return {
           success: false,
@@ -424,7 +442,9 @@ var ApiClient = class {
     const url = `${this.baseUrl}/token?code=${encodeURIComponent(code)}`;
     try {
       const response = await fetch(url, { method: "GET" });
-      const data = await response.json();
+      const parsed = await this.parseJsonResponse(response);
+      if ("success" in parsed) return parsed;
+      const { data } = parsed;
       if (!response.ok) {
         return {
           success: false,
@@ -450,7 +470,9 @@ var ApiClient = class {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ code, device_name: deviceName })
       });
-      const data = await response.json();
+      const parsed = await this.parseJsonResponse(response);
+      if ("success" in parsed) return parsed;
+      const { data } = parsed;
       if (!response.ok) {
         return {
           success: false,
@@ -494,6 +516,42 @@ var ApiClient = class {
     });
   }
   // ============================================================================
+  // SKILL INSTALLATION
+  // ============================================================================
+  /**
+   * Get pending skill installs/uninstalls (daemon polling)
+   */
+  async getPendingInstalls() {
+    return this.request("/skills/pending-installs", { method: "GET" });
+  }
+  /**
+   * Report install/uninstall completion (daemon)
+   */
+  async reportInstallComplete(subscriptionId, action) {
+    return this.request("/skills/install-complete", {
+      method: "POST",
+      body: JSON.stringify({ subscriptionId, action })
+    });
+  }
+  /**
+   * Install a skill by slug (CLI direct install)
+   */
+  async installSkill(slug) {
+    return this.request("/skills/install", {
+      method: "POST",
+      body: JSON.stringify({ slug })
+    });
+  }
+  /**
+   * Uninstall a skill by slug (CLI)
+   */
+  async uninstallSkill(slug) {
+    return this.request("/skills/uninstall", {
+      method: "POST",
+      body: JSON.stringify({ slug })
+    });
+  }
+  // ============================================================================
   // PROJECT TRACKING
   // ============================================================================
   /**
@@ -508,16 +566,20 @@ var ApiClient = class {
   /**
    * Disconnect a project from tracking
    */
-  async disconnectProject(path3) {
-    return this.request(`/projects/connect?path=${encodeURIComponent(path3)}`, {
+  async disconnectProject(path4, gitRemoteNormalized) {
+    const params = new URLSearchParams({ path: path4 });
+    if (gitRemoteNormalized) params.set("gitRemoteNormalized", gitRemoteNormalized);
+    return this.request(`/projects/connect?${params.toString()}`, {
       method: "DELETE"
     });
   }
   /**
    * Get tracking status for a project
    */
-  async getProjectStatus(path3) {
-    return this.request(`/projects/connect?path=${encodeURIComponent(path3)}`, {
+  async getProjectStatus(path4, gitRemoteNormalized) {
+    const params = new URLSearchParams({ path: path4 });
+    if (gitRemoteNormalized) params.set("gitRemoteNormalized", gitRemoteNormalized);
+    return this.request(`/projects/connect?${params.toString()}`, {
       method: "GET"
     });
   }
@@ -533,8 +595,8 @@ var ApiClient = class {
    * Check if a path is in a tracked project
    * Returns the project if tracked, null if not
    */
-  async isProjectTracked(path3) {
-    const result = await this.getProjectStatus(path3);
+  async isProjectTracked(path4) {
+    const result = await this.getProjectStatus(path4);
     if (result.success && result.data?.connected) {
       return {
         tracked: true,
@@ -574,6 +636,7 @@ function matchesProjectPath(claudeProjectPath, filterPath) {
 }
 var projectCache = {
   projects: /* @__PURE__ */ new Map(),
+  gitRemoteIndex: /* @__PURE__ */ new Map(),
   lastFetched: 0
 };
 var CACHE_TTL_MS = 6e4;
@@ -586,12 +649,17 @@ async function loadTrackedProjects(client) {
     const result = await client.listProjects(true);
     if (result.success && result.data?.projects) {
       projectCache.projects.clear();
+      projectCache.gitRemoteIndex.clear();
       for (const project of result.data.projects) {
         const normalizedPath = normalizePath(project.path);
-        projectCache.projects.set(normalizedPath, {
+        const info = {
           tracked: project.trackingEnabled,
           name: project.name
-        });
+        };
+        projectCache.projects.set(normalizedPath, info);
+        if (project.gitRemoteNormalized) {
+          projectCache.gitRemoteIndex.set(project.gitRemoteNormalized, info);
+        }
       }
       projectCache.lastFetched = now;
     }
@@ -612,6 +680,20 @@ async function isProjectTracked(projectPath) {
       return info;
     }
   }
+  if (projectCache.gitRemoteIndex.size > 0) {
+    try {
+      const { getGitInfo } = await import("./git-OUAHIOY2.js");
+      const gitInfo = getGitInfo(projectPath);
+      if (gitInfo.remoteNormalized) {
+        const remoteMatch = projectCache.gitRemoteIndex.get(gitInfo.remoteNormalized);
+        if (remoteMatch) return remoteMatch;
+      }
+    } catch (error) {
+      if (process.env.DEBUG) {
+        console.error("[skillo] git detection failed:", error);
+      }
+    }
+  }
   return { tracked: false };
 }
 var ClaudeWatcher = class {
@@ -697,6 +779,8 @@ var ClaudeWatcher = class {
             if (!trackingStatus.tracked) {
               continue;
             }
+            entry.toolsUsed = extractToolsUsed(entry.display);
+            entry.filesReferenced = extractFilesReferenced(entry.display);
             newPrompts.push(entry);
           } catch {
           }
@@ -724,6 +808,46 @@ var ClaudeWatcher = class {
     }
   }
 };
+var TOOL_PATTERNS = [
+  /\b(grep|rg|ripgrep)\b/i,
+  /\b(git)\s+(commit|push|pull|merge|rebase|checkout|branch|stash|log|diff|add|reset)\b/i,
+  /\b(npm|yarn|pnpm|bun)\s+(install|run|build|test|dev|start|publish)\b/i,
+  /\b(docker|docker-compose|podman)\s+\w+/i,
+  /\b(curl|wget|fetch)\b/i,
+  /\b(vim|nvim|nano|code|emacs)\b/i,
+  /\b(make|cmake|cargo|go\s+build|rustc|gcc|clang)\b/i,
+  /\b(pytest|jest|vitest|mocha|cypress|playwright)\b/i,
+  /\b(prisma|drizzle|sequelize|typeorm)\s+\w+/i,
+  /\b(kubectl|helm|terraform|ansible)\s+\w+/i
+];
+function extractToolsUsed(text) {
+  const tools = /* @__PURE__ */ new Set();
+  for (const pattern of TOOL_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) {
+      tools.add(match[0].trim().toLowerCase());
+    }
+  }
+  return Array.from(tools);
+}
+var FILE_PATTERN = /(?:^|\s|['"`])((?:\.{0,2}\/)?[\w-]+\/[\w./-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|yaml|yml|toml|md|css|scss|html|sql|py|rs|go|java|rb|sh|prisma|graphql))\b/gi;
+var CONFIG_FILE_PATTERN = /(?:^|\s|['"`])((?:package\.json|tsconfig\.json|\.env|Dockerfile|Makefile|docker-compose\.ya?ml|\.gitignore|prisma\/schema\.prisma))\b/gi;
+function extractFilesReferenced(text) {
+  const files = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = FILE_PATTERN.exec(text)) !== null) {
+    const filePath = match[1];
+    if (filePath.length < 200 && !filePath.includes("..")) {
+      files.add(filePath);
+    }
+  }
+  FILE_PATTERN.lastIndex = 0;
+  while ((match = CONFIG_FILE_PATTERN.exec(text)) !== null) {
+    files.add(match[1]);
+  }
+  CONFIG_FILE_PATTERN.lastIndex = 0;
+  return Array.from(files);
+}
 
 // src/core/skill-usage-detector.ts
 import * as fs2 from "fs";
@@ -931,9 +1055,122 @@ var SkillUsageDetector = class {
   }
 };
 
+// src/core/skill-installer.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var SkillInstaller = class {
+  intervalId = null;
+  intervalMs;
+  callbacks;
+  client;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.intervalMs = options.intervalMs || 3e4;
+    this.callbacks = options.callbacks || {};
+  }
+  log(level, msg) {
+    this.callbacks.log?.(level, msg);
+  }
+  async start() {
+    this.log("INFO", "Skill installer started");
+    await this.poll();
+    this.intervalId = setInterval(() => this.poll(), this.intervalMs);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+  async poll() {
+    try {
+      const response = await this.client.getPendingInstalls();
+      if (!response.success || !response.data) {
+        if (response.error) {
+          this.log("WARN", `Failed to fetch pending installs: ${response.error}`);
+        }
+        return;
+      }
+      const { pendingInstalls, pendingUninstalls, personalSkills } = response.data;
+      if (personalSkills?.length) {
+        for (const skill of personalSkills) {
+          try {
+            const existing = this.readSkill(skill.slug);
+            if (existing === skill.content) continue;
+            this.writeSkill(skill.slug, skill.content);
+            this.log("INFO", `Installed personal skill: ${skill.slug}`);
+            this.callbacks.onInstall?.(skill.slug);
+          } catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            this.log("ERROR", `Failed to install personal skill ${skill.slug}: ${error.message}`);
+            this.callbacks.onError?.(error);
+            if (error.message.includes("ENOSPC") || error.message.includes("EACCES")) {
+              this.log("ERROR", "Filesystem error detected, stopping personal skill installation");
+              break;
+            }
+          }
+        }
+      }
+      for (const install of pendingInstalls) {
+        try {
+          this.writeSkill(install.slug, install.content);
+          this.log("INFO", `Installed skill: ${install.slug}`);
+          this.callbacks.onInstall?.(install.slug);
+          await this.client.reportInstallComplete(install.subscriptionId, "installed");
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          this.log("ERROR", `Failed to install skill ${install.slug}: ${error.message}`);
+          this.callbacks.onError?.(error);
+        }
+      }
+      for (const uninstall of pendingUninstalls) {
+        try {
+          this.removeSkill(uninstall.slug);
+          this.log("INFO", `Uninstalled skill: ${uninstall.slug}`);
+          this.callbacks.onUninstall?.(uninstall.slug);
+          await this.client.reportInstallComplete(uninstall.subscriptionId, "uninstalled");
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          this.log("ERROR", `Failed to uninstall skill ${uninstall.slug}: ${error.message}`);
+          this.callbacks.onError?.(error);
+        }
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log("ERROR", `Skill installer poll error: ${err.message}`);
+      this.callbacks.onError?.(err);
+    }
+  }
+  writeSkill(slug, content) {
+    const skillsDir = getSkillsDir();
+    const skillDir = path3.join(skillsDir, slug);
+    if (!fs3.existsSync(skillsDir)) {
+      fs3.mkdirSync(skillsDir, { recursive: true });
+    }
+    if (!fs3.existsSync(skillDir)) {
+      fs3.mkdirSync(skillDir, { recursive: true });
+    }
+    fs3.writeFileSync(path3.join(skillDir, "SKILL.md"), content, "utf-8");
+  }
+  readSkill(slug) {
+    const skillFile = path3.join(getSkillsDir(), slug, "SKILL.md");
+    try {
+      return fs3.existsSync(skillFile) ? fs3.readFileSync(skillFile, "utf-8") : null;
+    } catch {
+      return null;
+    }
+  }
+  removeSkill(slug) {
+    const skillDir = path3.join(getSkillsDir(), slug);
+    if (fs3.existsSync(skillDir)) {
+      fs3.rmSync(skillDir, { recursive: true, force: true });
+    }
+  }
+};
+
 // src/utils/status-writer.ts
-import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, existsSync as existsSync5 } from "fs";
-import { join as join4 } from "path";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
+import { join as join5 } from "path";
 var STATUS_FILE = "daemon-status.json";
 var WRITE_INTERVAL_MS = 1e4;
 var StatusWriter = class _StatusWriter {
@@ -941,7 +1178,7 @@ var StatusWriter = class _StatusWriter {
   status;
   filePath;
   constructor() {
-    this.filePath = join4(getDataDir(), STATUS_FILE);
+    this.filePath = join5(getDataDir(), STATUS_FILE);
     this.status = {
       running: true,
       pid: process.pid,
@@ -980,18 +1217,22 @@ var StatusWriter = class _StatusWriter {
       this.status.skillDetector = { ...this.status.skillDetector, ...partial.skillDetector };
       delete partial.skillDetector;
     }
+    if (partial.skillInstaller) {
+      this.status.skillInstaller = { ...this.status.skillInstaller, ...partial.skillInstaller };
+      delete partial.skillInstaller;
+    }
     Object.assign(this.status, partial);
   }
   /** Get the status file path */
   static getStatusFilePath() {
-    return join4(getDataDir(), STATUS_FILE);
+    return join5(getDataDir(), STATUS_FILE);
   }
   /** Read current status from disk (static, for tray/status commands) */
   static read() {
     const filePath = _StatusWriter.getStatusFilePath();
     try {
-      if (existsSync5(filePath)) {
-        return JSON.parse(readFileSync3(filePath, "utf-8"));
+      if (existsSync6(filePath)) {
+        return JSON.parse(readFileSync4(filePath, "utf-8"));
       }
     } catch {
     }
@@ -1000,39 +1241,32 @@ var StatusWriter = class _StatusWriter {
   write() {
     this.status.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     try {
-      writeFileSync3(this.filePath, JSON.stringify(this.status, null, 2), "utf-8");
+      writeFileSync4(this.filePath, JSON.stringify(this.status, null, 2), "utf-8");
     } catch {
     }
   }
 };
 
-// src/daemon-runner.ts
-function log(level, msg) {
-  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${msg}
-`;
-  try {
-    appendFileSync(getLogFile(), line);
-  } catch {
-  }
-}
-async function updateTrackedProjectsCache(client) {
+// src/utils/daemon-tasks.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, unlinkSync, readdirSync as readdirSync2 } from "fs";
+async function updateTrackedProjectsCache(client, log2) {
   try {
     const result = await client.listProjects(true);
     if (result.success && result.data?.projects) {
-      const cacheData = {
-        updatedAt: Date.now(),
-        projects: result.data.projects.filter((p) => p.trackingEnabled).map((p) => ({ path: p.path, name: p.name }))
-      };
-      writeFileSync4(getTrackedProjectsCacheFile(), JSON.stringify(cacheData, null, 2));
-      log("DEBUG", `Updated tracked projects cache: ${cacheData.projects.length} project(s)`);
+      const projects = result.data.projects.filter((p) => p.trackingEnabled).map((p) => ({ path: p.path, name: p.name, gitRemoteNormalized: p.gitRemoteNormalized }));
+      const cacheData = { updatedAt: Date.now(), projects };
+      writeFileSync5(getTrackedProjectsCacheFile(), JSON.stringify(cacheData, null, 2));
+      log2("DEBUG", `Updated tracked projects cache: ${projects.length} project(s)`);
+      return projects;
     }
   } catch (error) {
-    log("ERROR", `Failed to update tracked projects cache: ${error}`);
+    log2("ERROR", `Failed to update tracked projects cache: ${error}`);
   }
+  return null;
 }
-async function cleanupStaleSessions(client) {
+async function cleanupStaleSessions(client, log2) {
   const sessionsDir = getActiveSessionsDir();
-  if (!existsSync6(sessionsDir)) return;
+  if (!existsSync7(sessionsDir)) return;
   try {
     const files = readdirSync2(sessionsDir);
     for (const file of files) {
@@ -1047,10 +1281,10 @@ async function cleanupStaleSessions(client) {
       }
       if (!isRunning) {
         try {
-          const sessionData = JSON.parse(readFileSync4(`${sessionsDir}/${file}`, "utf-8"));
+          const sessionData = JSON.parse(readFileSync5(`${sessionsDir}/${file}`, "utf-8"));
           if (sessionData.sessionId) {
             await client.endSession(sessionData.sessionId);
-            log("INFO", `Ended stale session ${sessionData.sessionId.slice(0, 8)} (PID ${pid} dead)`);
+            log2("INFO", `Ended stale session ${sessionData.sessionId.slice(0, 8)} (PID ${pid} dead)`);
           }
           unlinkSync(`${sessionsDir}/${file}`);
         } catch {
@@ -1062,20 +1296,38 @@ async function cleanupStaleSessions(client) {
       }
     }
   } catch (error) {
-    log("ERROR", `Stale session cleanup error: ${error}`);
+    log2("ERROR", `Stale session cleanup error: ${error}`);
+  }
+}
+function readTrackedProjectsFromCache() {
+  try {
+    const cacheData = JSON.parse(readFileSync5(getTrackedProjectsCacheFile(), "utf-8"));
+    return cacheData.projects || [];
+  } catch {
+    return null;
+  }
+}
+
+// src/daemon-runner.ts
+function log(level, msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] ${msg}
+`;
+  try {
+    appendFileSync(getLogFile(), line);
+  } catch {
   }
 }
 async function main() {
   const pidFile = getPidFile();
-  writeFileSync4(pidFile, String(process.pid));
+  writeFileSync6(pidFile, String(process.pid));
   log("INFO", `Daemon starting (PID: ${process.pid})`);
   const statusWriter = new StatusWriter();
   const cleanup = () => {
     log("INFO", "Daemon shutting down");
     statusWriter.stop();
-    if (existsSync6(pidFile)) {
+    if (existsSync8(pidFile)) {
       try {
-        unlinkSync(pidFile);
+        unlinkSync2(pidFile);
       } catch {
       }
     }
@@ -1096,15 +1348,37 @@ async function main() {
     cleanup();
     return;
   }
+  try {
+    const authResult = await client.authenticate();
+    const user = authResult.data?.user || authResult.user;
+    if (authResult.success && user) {
+      statusWriter.update({ user: user.name });
+      log("INFO", `Authenticated as: ${user.name}`);
+    }
+  } catch (err) {
+    log("WARN", `Could not fetch user info: ${err}`);
+  }
   ensureDirectory(getActiveSessionsDir());
-  await updateTrackedProjectsCache(client);
-  await cleanupStaleSessions(client);
+  const projects = await updateTrackedProjectsCache(client, log);
+  if (projects) {
+    statusWriter.update({ trackedProjects: projects });
+  } else {
+    const cached = readTrackedProjectsFromCache();
+    if (cached) statusWriter.update({ trackedProjects: cached });
+  }
+  await cleanupStaleSessions(client, log);
   const watchInterval = (config.daemon?.conversationCheckInterval || 5) * 1e3;
   const watcher = new ClaudeWatcher(client, {
     intervalMs: watchInterval,
     callbacks: {
-      onSync: (count) => log("INFO", `Synced ${count} Claude prompt(s)`),
-      onError: (err) => log("ERROR", `Watcher error: ${err.message}`),
+      onSync: (count) => {
+        log("INFO", `Synced ${count} Claude prompt(s)`);
+        statusWriter.update({ claudeWatcher: { promptsSynced: count, lastSync: (/* @__PURE__ */ new Date()).toISOString(), lastError: null } });
+      },
+      onError: (err) => {
+        log("ERROR", `Watcher error: ${err.message}`);
+        statusWriter.update({ claudeWatcher: { lastError: err.message } });
+      },
       log: (level, msg) => log(level, msg)
     }
   });
@@ -1124,18 +1398,31 @@ async function main() {
     }
   });
   await skillDetector.start();
+  const skillInstaller = new SkillInstaller(client, {
+    intervalMs: 3e4,
+    callbacks: {
+      onInstall: (slug) => {
+        log("INFO", `Installed skill: ${slug}`);
+        statusWriter.update({ skillInstaller: { lastInstall: slug, lastAction: (/* @__PURE__ */ new Date()).toISOString(), lastError: null } });
+      },
+      onUninstall: (slug) => {
+        log("INFO", `Uninstalled skill: ${slug}`);
+        statusWriter.update({ skillInstaller: { lastUninstall: slug, lastAction: (/* @__PURE__ */ new Date()).toISOString(), lastError: null } });
+      },
+      onError: (err) => {
+        log("ERROR", `Skill installer error: ${err.message}`);
+        statusWriter.update({ skillInstaller: { lastError: err.message } });
+      },
+      log: (level, msg) => log(level, msg)
+    }
+  });
+  await skillInstaller.start();
   statusWriter.start();
   setInterval(async () => {
-    await updateTrackedProjectsCache(client);
-    try {
-      const cacheData = JSON.parse(readFileSync4(getTrackedProjectsCacheFile(), "utf-8"));
-      statusWriter.update({
-        trackedProjects: cacheData.projects || []
-      });
-    } catch {
-    }
+    const updated = await updateTrackedProjectsCache(client, log);
+    if (updated) statusWriter.update({ trackedProjects: updated });
   }, 6e4);
-  setInterval(() => cleanupStaleSessions(client), 3e5);
+  setInterval(() => cleanupStaleSessions(client, log), 3e5);
   log("INFO", "Daemon started successfully \u2014 watching Claude conversations & skill usage");
   await new Promise(() => {
   });