@devness/useai 0.4.3 → 0.4.5

package/dist/index.js

@@ -83,7 +83,7 @@ var init_types = __esm({
 // ../shared/dist/constants/paths.js
 import { join } from "path";
 import { homedir } from "os";
-var USEAI_DIR, DATA_DIR, ACTIVE_DIR, SEALED_DIR, KEYSTORE_FILE, CONFIG_FILE, SESSIONS_FILE, MILESTONES_FILE, DAEMON_PID_FILE, DAEMON_PORT, DAEMON_LOG_FILE, DAEMON_MCP_URL, DAEMON_HEALTH_URL, LAUNCHD_PLIST_PATH, SYSTEMD_SERVICE_PATH, WINDOWS_STARTUP_SCRIPT_PATH;
+var USEAI_DIR, DATA_DIR, ACTIVE_DIR, SEALED_DIR, KEYSTORE_FILE, CONFIG_FILE, SESSIONS_FILE, MILESTONES_FILE, DAEMON_PID_FILE, USEAI_HOOKS_DIR, DAEMON_PORT, DAEMON_LOG_FILE, DAEMON_MCP_URL, DAEMON_HEALTH_URL, LAUNCHD_PLIST_PATH, SYSTEMD_SERVICE_PATH, WINDOWS_STARTUP_SCRIPT_PATH;
 var init_paths = __esm({
   "../shared/dist/constants/paths.js"() {
     "use strict";
@@ -96,6 +96,7 @@ var init_paths = __esm({
     SESSIONS_FILE = join(DATA_DIR, "sessions.json");
     MILESTONES_FILE = join(DATA_DIR, "milestones.json");
     DAEMON_PID_FILE = join(USEAI_DIR, "daemon.pid");
+    USEAI_HOOKS_DIR = join(USEAI_DIR, "hooks");
     DAEMON_PORT = 19200;
     DAEMON_LOG_FILE = join(USEAI_DIR, "daemon.log");
     DAEMON_MCP_URL = `http://127.0.0.1:${DAEMON_PORT}/mcp`;
@@ -111,7 +112,7 @@ var VERSION;
 var init_version = __esm({
   "../shared/dist/constants/version.js"() {
     "use strict";
-    VERSION = "0.4.3";
+    VERSION = "0.4.5";
   }
 });
 
@@ -397,6 +398,10 @@ var init_format = __esm({
 });
 
 // ../shared/dist/utils/detect-client.js
+function normalizeMcpClientName(mcpName) {
+  const lower = mcpName.toLowerCase().trim();
+  return MCP_CLIENT_NAME_MAP[lower] ?? lower;
+}
 function detectClient() {
   const env = process.env;
   for (const [envVar, clientName] of Object.entries(AI_CLIENT_ENV_VARS)) {
@@ -407,10 +412,35 @@ function detectClient() {
     return env.MCP_CLIENT_NAME;
   return "unknown";
 }
+var MCP_CLIENT_NAME_MAP;
 var init_detect_client = __esm({
   "../shared/dist/utils/detect-client.js"() {
     "use strict";
     init_clients();
+    MCP_CLIENT_NAME_MAP = {
+      "claude-code": "claude-code",
+      "claude code": "claude-code",
+      "claude-desktop": "claude-desktop",
+      "claude desktop": "claude-desktop",
+      "cursor": "cursor",
+      "windsurf": "windsurf",
+      "codeium": "windsurf",
+      "vscode": "vscode",
+      "visual studio code": "vscode",
+      "vscode-insiders": "vscode-insiders",
+      "codex": "codex",
+      "codex-cli": "codex",
+      "gemini-cli": "gemini-cli",
+      "gemini cli": "gemini-cli",
+      "zed": "zed",
+      "cline": "cline",
+      "roo-code": "roo-code",
+      "roo-cline": "roo-code",
+      "amazon-q": "amazon-q",
+      "opencode": "opencode",
+      "goose": "goose",
+      "junie": "junie"
+    };
   }
 });
 
@@ -807,6 +837,136 @@ var init_daemon = __esm({
   }
 });
 
+// ../shared/dist/hooks/claude-code.js
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3, chmodSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+function readSettings() {
+  if (!existsSync5(CLAUDE_SETTINGS_PATH))
+    return {};
+  try {
+    return JSON.parse(readFileSync3(CLAUDE_SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(settings) {
+  mkdirSync3(join3(homedir3(), ".claude"), { recursive: true });
+  writeFileSync3(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+}
+function installClaudeCodeHooks() {
+  mkdirSync3(USEAI_HOOKS_DIR, { recursive: true });
+  writeFileSync3(STOP_GUARD_PATH, STOP_GUARD_SCRIPT);
+  try {
+    chmodSync(STOP_GUARD_PATH, "755");
+  } catch {
+  }
+  const settings = readSettings();
+  const hooks = settings["hooks"] ?? {};
+  const stopCmd = `node "${STOP_GUARD_PATH}"`;
+  const sealCmd = `curl -sf -X POST http://127.0.0.1:${DAEMON_PORT}/api/seal-active --max-time 3 2>/dev/null || true`;
+  let changed = false;
+  if (!hooks["Stop"])
+    hooks["Stop"] = [];
+  const stopArr = hooks["Stop"];
+  const hasStop = stopArr.some((g) => {
+    const inner = g["hooks"];
+    return inner?.some((h) => h["command"]?.includes("stop-guard"));
+  });
+  if (!hasStop) {
+    stopArr.push({ hooks: [{ type: "command", command: stopCmd, timeout: 10 }] });
+    changed = true;
+  }
+  if (!hooks["SessionEnd"])
+    hooks["SessionEnd"] = [];
+  const endArr = hooks["SessionEnd"];
+  const hasEnd = endArr.some((g) => {
+    const inner = g["hooks"];
+    return inner?.some((h) => h["command"]?.includes("seal-active"));
+  });
+  if (!hasEnd) {
+    endArr.push({ hooks: [{ type: "command", command: sealCmd, timeout: 5 }] });
+    changed = true;
+  }
+  settings["hooks"] = hooks;
+  writeSettings(settings);
+  return changed;
+}
+function removeClaudeCodeHooks() {
+  if (existsSync5(CLAUDE_SETTINGS_PATH)) {
+    try {
+      const settings = readSettings();
+      const hooks = settings["hooks"];
+      if (hooks) {
+        if (hooks["Stop"]) {
+          hooks["Stop"] = hooks["Stop"].filter((g) => {
+            const inner = g["hooks"];
+            return !inner?.some((h) => h["command"]?.includes("stop-guard"));
+          });
+          if (hooks["Stop"].length === 0)
+            delete hooks["Stop"];
+        }
+        if (hooks["SessionEnd"]) {
+          hooks["SessionEnd"] = hooks["SessionEnd"].filter((g) => {
+            const inner = g["hooks"];
+            return !inner?.some((h) => h["command"]?.includes("seal-active"));
+          });
+          if (hooks["SessionEnd"].length === 0)
+            delete hooks["SessionEnd"];
+        }
+        if (Object.keys(hooks).length === 0)
+          delete settings["hooks"];
+      }
+      writeSettings(settings);
+    } catch {
+    }
+  }
+  try {
+    if (existsSync5(STOP_GUARD_PATH))
+      unlinkSync3(STOP_GUARD_PATH);
+  } catch {
+  }
+}
+var STOP_GUARD_PATH, CLAUDE_SETTINGS_PATH, STOP_GUARD_SCRIPT;
+var init_claude_code = __esm({
+  "../shared/dist/hooks/claude-code.js"() {
+    "use strict";
+    init_paths();
+    STOP_GUARD_PATH = join3(USEAI_HOOKS_DIR, "stop-guard.js");
+    CLAUDE_SETTINGS_PATH = join3(homedir3(), ".claude", "settings.json");
+    STOP_GUARD_SCRIPT = `#!/usr/bin/env node
+'use strict';
+const { readFileSync } = require('node:fs');
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const hook = JSON.parse(input);
+    if (hook.stop_hook_active) process.exit(0);
+    if (!hook.transcript_path) process.exit(0);
+    let transcript;
+    try { transcript = readFileSync(hook.transcript_path, 'utf-8'); } catch { process.exit(0); }
+    if (!transcript.includes('useai_session_start')) process.exit(0);
+    if (transcript.includes('useai_session_end')) process.exit(0);
+    process.stdout.write(JSON.stringify({
+      decision: 'block',
+      reason: 'Before ending, call useai_session_end with milestones (generic descriptions of accomplishments), languages used, and files_touched_count.'
+    }));
+  } catch { process.exit(0); }
+});
+`;
+  }
+});
+
+// ../shared/dist/hooks/index.js
+var init_hooks = __esm({
+  "../shared/dist/hooks/index.js"() {
+    "use strict";
+    init_claude_code();
+  }
+});
+
 // ../shared/dist/index.js
 var init_dist = __esm({
   "../shared/dist/index.js"() {
@@ -817,12 +977,13 @@ var init_dist = __esm({
     init_validation();
     init_utils();
     init_daemon();
+    init_hooks();
   }
 });
 
 // src/session-state.ts
-import { appendFileSync, existsSync as existsSync5 } from "fs";
-import { join as join3 } from "path";
+import { appendFileSync, existsSync as existsSync6 } from "fs";
+import { join as join4 } from "path";
 var SessionState;
 var init_session_state = __esm({
   "src/session-state.ts"() {
@@ -872,7 +1033,7 @@ var init_session_state = __esm({
       }
       initializeKeystore() {
         ensureDir();
-        if (existsSync5(KEYSTORE_FILE)) {
+        if (existsSync6(KEYSTORE_FILE)) {
           const ks = readJson(KEYSTORE_FILE, null);
           if (ks) {
             try {
@@ -890,7 +1051,7 @@ var init_session_state = __esm({
       }
       /** Path to this session's chain file in the active directory */
       sessionChainPath() {
-        return join3(ACTIVE_DIR, `${this.sessionId}.jsonl`);
+        return join4(ACTIVE_DIR, `${this.sessionId}.jsonl`);
       }
       appendToChain(type, data) {
         const record = buildChainRecord(type, this.sessionId, data, this.chainTipHash, this.signingKey);
@@ -907,8 +1068,8 @@ var init_session_state = __esm({
 // src/register-tools.ts
 import { z as z2 } from "zod";
 import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync6, renameSync as renameSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync7, renameSync as renameSync2 } from "fs";
+import { join as join5 } from "path";
 function getConfig() {
   return readJson(CONFIG_FILE, {
     milestone_tracking: true,
@@ -1014,10 +1175,10 @@ Session: ${session2.sessionId.slice(0, 8)} \xB7 Chain: ${record.hash.slice(0, 12
         seal: sealData,
         seal_signature: sealSignature
       });
-      const activePath = join4(ACTIVE_DIR, `${session2.sessionId}.jsonl`);
-      const sealedPath = join4(SEALED_DIR, `${session2.sessionId}.jsonl`);
+      const activePath = join5(ACTIVE_DIR, `${session2.sessionId}.jsonl`);
+      const sealedPath = join5(SEALED_DIR, `${session2.sessionId}.jsonl`);
       try {
-        if (existsSync6(activePath)) {
+        if (existsSync7(activePath)) {
           renameSync2(activePath, sealedPath);
         }
       } catch {
@@ -1097,9 +1258,9 @@ var init_register_tools = __esm({
 
 // src/tools.ts
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3 } from "fs";
-import { dirname as dirname2, join as join5 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, unlinkSync as unlinkSync4 } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
+import { homedir as homedir4 } from "os";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 function installStandardHttp(configPath) {
@@ -1127,9 +1288,9 @@ function hasBinary(name) {
   }
 }
 function readJsonFile(path) {
-  if (!existsSync7(path)) return {};
+  if (!existsSync8(path)) return {};
   try {
-    const raw = readFileSync3(path, "utf-8").trim();
+    const raw = readFileSync4(path, "utf-8").trim();
     if (!raw) return {};
     return JSON.parse(raw);
   } catch {
@@ -1137,8 +1298,8 @@ function readJsonFile(path) {
   }
 }
 function writeJsonFile(path, data) {
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync3(path, JSON.stringify(data, null, 2) + "\n");
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync4(path, JSON.stringify(data, null, 2) + "\n");
 }
 function isConfiguredStandard(configPath) {
   const config = readJsonFile(configPath);
@@ -1219,9 +1380,9 @@ function removeZed(configPath) {
   }
 }
 function readTomlFile(path) {
-  if (!existsSync7(path)) return {};
+  if (!existsSync8(path)) return {};
   try {
-    const raw = readFileSync3(path, "utf-8").trim();
+    const raw = readFileSync4(path, "utf-8").trim();
     if (!raw) return {};
     return parseToml(raw);
   } catch {
@@ -1229,8 +1390,8 @@ function readTomlFile(path) {
   }
 }
 function writeTomlFile(path, data) {
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync3(path, stringifyToml(data) + "\n");
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync4(path, stringifyToml(data) + "\n");
 }
 function isConfiguredToml(configPath) {
   const config = readTomlFile(configPath);
@@ -1258,9 +1419,9 @@ function removeToml(configPath) {
   }
 }
 function readYamlFile(path) {
-  if (!existsSync7(path)) return {};
+  if (!existsSync8(path)) return {};
   try {
-    const raw = readFileSync3(path, "utf-8").trim();
+    const raw = readFileSync4(path, "utf-8").trim();
     if (!raw) return {};
     return parseYaml(raw) ?? {};
   } catch {
@@ -1268,8 +1429,8 @@ function readYamlFile(path) {
   }
 }
 function writeYamlFile(path, data) {
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync3(path, stringifyYaml(data));
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync4(path, stringifyYaml(data));
 }
 function isConfiguredYaml(configPath) {
   const config = readYamlFile(configPath);
@@ -1303,49 +1464,49 @@ function removeYaml(configPath) {
   }
 }
 function hasInstructionsBlock(filePath) {
-  if (!existsSync7(filePath)) return false;
+  if (!existsSync8(filePath)) return false;
   try {
-    return readFileSync3(filePath, "utf-8").includes(INSTRUCTIONS_START);
+    return readFileSync4(filePath, "utf-8").includes(INSTRUCTIONS_START);
   } catch {
     return false;
   }
 }
 function injectInstructions(config) {
-  mkdirSync3(dirname2(config.path), { recursive: true });
+  mkdirSync4(dirname2(config.path), { recursive: true });
   if (config.method === "create") {
-    writeFileSync3(config.path, USEAI_INSTRUCTIONS + "\n");
+    writeFileSync4(config.path, USEAI_INSTRUCTIONS + "\n");
     return;
   }
   if (hasInstructionsBlock(config.path)) return;
   let existing = "";
-  if (existsSync7(config.path)) {
-    existing = readFileSync3(config.path, "utf-8");
+  if (existsSync8(config.path)) {
+    existing = readFileSync4(config.path, "utf-8");
   }
   const separator = existing && !existing.endsWith("\n") ? "\n\n" : existing ? "\n" : "";
-  writeFileSync3(config.path, existing + separator + USEAI_INSTRUCTIONS_BLOCK + "\n");
+  writeFileSync4(config.path, existing + separator + USEAI_INSTRUCTIONS_BLOCK + "\n");
 }
 function removeInstructions(config) {
   if (config.method === "create") {
-    if (existsSync7(config.path)) {
+    if (existsSync8(config.path)) {
       try {
-        unlinkSync3(config.path);
+        unlinkSync4(config.path);
       } catch {
       }
     }
     return;
   }
-  if (!existsSync7(config.path)) return;
+  if (!existsSync8(config.path)) return;
   try {
-    const content = readFileSync3(config.path, "utf-8");
+    const content = readFileSync4(config.path, "utf-8");
     const escaped = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const regex = new RegExp(
       `\\n?${escaped(INSTRUCTIONS_START)}[\\s\\S]*?${escaped(INSTRUCTIONS_END)}\\n?`
     );
     const cleaned = content.replace(regex, "").trim();
     if (cleaned) {
-      writeFileSync3(config.path, cleaned + "\n");
+      writeFileSync4(config.path, cleaned + "\n");
     } else {
-      unlinkSync3(config.path);
+      unlinkSync4(config.path);
     }
   } catch {
   }
@@ -1421,7 +1582,7 @@ var init_tools = __esm({
     };
     MCP_HTTP_URL = DAEMON_MCP_URL;
     MCP_HTTP_ENTRY = { type: "http", url: MCP_HTTP_URL };
-    home = homedir3();
+    home = homedir4();
     INSTRUCTIONS_START = "<!-- useai:start -->";
     INSTRUCTIONS_END = "<!-- useai:end -->";
     USEAI_INSTRUCTIONS = [
@@ -1441,23 +1602,23 @@ ${INSTRUCTIONS_END}`;
       toml: { isConfigured: isConfiguredToml, install: installToml, remove: removeToml },
       yaml: { isConfigured: isConfiguredYaml, install: installYaml, remove: removeYaml }
     };
-    appSupport = join5(home, "Library", "Application Support");
+    appSupport = join6(home, "Library", "Application Support");
     AI_TOOLS = [
       createTool({
         id: "claude-code",
         name: "Claude Code",
         configFormat: "standard",
-        configPath: join5(home, ".claude.json"),
-        detect: () => hasBinary("claude") || existsSync7(join5(home, ".claude.json")),
-        instructions: { method: "append", path: join5(home, ".claude", "CLAUDE.md") },
+        configPath: join6(home, ".claude.json"),
+        detect: () => hasBinary("claude") || existsSync8(join6(home, ".claude.json")),
+        instructions: { method: "append", path: join6(home, ".claude", "CLAUDE.md") },
         supportsUrl: true
       }),
       createTool({
         id: "cursor",
         name: "Cursor",
         configFormat: "standard",
-        configPath: join5(home, ".cursor", "mcp.json"),
-        detect: () => existsSync7(join5(home, ".cursor")),
+        configPath: join6(home, ".cursor", "mcp.json"),
+        detect: () => existsSync8(join6(home, ".cursor")),
         manualHint: "Open Cursor Settings \u2192 Rules \u2192 User Rules and paste the instructions below.",
         supportsUrl: true
       }),
@@ -1465,51 +1626,51 @@ ${INSTRUCTIONS_END}`;
         id: "windsurf",
         name: "Windsurf",
         configFormat: "standard",
-        configPath: join5(home, ".codeium", "windsurf", "mcp_config.json"),
-        detect: () => existsSync7(join5(home, ".codeium", "windsurf")),
-        instructions: { method: "append", path: join5(home, ".codeium", "windsurf", "memories", "global_rules.md") },
+        configPath: join6(home, ".codeium", "windsurf", "mcp_config.json"),
+        detect: () => existsSync8(join6(home, ".codeium", "windsurf")),
+        instructions: { method: "append", path: join6(home, ".codeium", "windsurf", "memories", "global_rules.md") },
         supportsUrl: true
       }),
       createTool({
         id: "vscode",
         name: "VS Code",
         configFormat: "vscode",
-        configPath: join5(appSupport, "Code", "User", "mcp.json"),
-        detect: () => existsSync7(join5(appSupport, "Code")),
-        instructions: { method: "create", path: join5(appSupport, "Code", "User", "prompts", "useai.instructions.md") },
+        configPath: join6(appSupport, "Code", "User", "mcp.json"),
+        detect: () => existsSync8(join6(appSupport, "Code")),
+        instructions: { method: "create", path: join6(appSupport, "Code", "User", "prompts", "useai.instructions.md") },
         supportsUrl: true
       }),
       createTool({
         id: "vscode-insiders",
         name: "VS Code Insiders",
         configFormat: "vscode",
-        configPath: join5(appSupport, "Code - Insiders", "User", "mcp.json"),
-        detect: () => existsSync7(join5(appSupport, "Code - Insiders")),
-        instructions: { method: "create", path: join5(appSupport, "Code - Insiders", "User", "prompts", "useai.instructions.md") },
+        configPath: join6(appSupport, "Code - Insiders", "User", "mcp.json"),
+        detect: () => existsSync8(join6(appSupport, "Code - Insiders")),
+        instructions: { method: "create", path: join6(appSupport, "Code - Insiders", "User", "prompts", "useai.instructions.md") },
         supportsUrl: true
       }),
       createTool({
         id: "gemini-cli",
         name: "Gemini CLI",
         configFormat: "standard",
-        configPath: join5(home, ".gemini", "settings.json"),
+        configPath: join6(home, ".gemini", "settings.json"),
         detect: () => hasBinary("gemini"),
-        instructions: { method: "append", path: join5(home, ".gemini", "GEMINI.md") },
+        instructions: { method: "append", path: join6(home, ".gemini", "GEMINI.md") },
         supportsUrl: true
       }),
       createTool({
         id: "zed",
         name: "Zed",
         configFormat: "zed",
-        configPath: join5(appSupport, "Zed", "settings.json"),
-        detect: () => existsSync7(join5(appSupport, "Zed")),
+        configPath: join6(appSupport, "Zed", "settings.json"),
+        detect: () => existsSync8(join6(appSupport, "Zed")),
         manualHint: "Open Rules Library (\u2318\u2325L) \u2192 click + \u2192 paste the instructions below."
       }),
       createTool({
         id: "cline",
         name: "Cline",
         configFormat: "standard",
-        configPath: join5(
+        configPath: join6(
           appSupport,
           "Code",
           "User",
@@ -1518,17 +1679,17 @@ ${INSTRUCTIONS_END}`;
           "settings",
           "cline_mcp_settings.json"
         ),
-        detect: () => existsSync7(
-          join5(appSupport, "Code", "User", "globalStorage", "saoudrizwan.claude-dev")
+        detect: () => existsSync8(
+          join6(appSupport, "Code", "User", "globalStorage", "saoudrizwan.claude-dev")
         ),
-        instructions: { method: "create", path: join5(home, "Documents", "Cline", "Rules", "useai.md") },
+        instructions: { method: "create", path: join6(home, "Documents", "Cline", "Rules", "useai.md") },
         supportsUrl: true
       }),
       createTool({
         id: "roo-code",
         name: "Roo Code",
         configFormat: "standard",
-        configPath: join5(
+        configPath: join6(
           appSupport,
           "Code",
           "User",
@@ -1537,59 +1698,59 @@ ${INSTRUCTIONS_END}`;
           "settings",
           "cline_mcp_settings.json"
         ),
-        detect: () => existsSync7(
-          join5(appSupport, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline")
+        detect: () => existsSync8(
+          join6(appSupport, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline")
         ),
-        instructions: { method: "create", path: join5(home, ".roo", "rules", "useai.md") },
+        instructions: { method: "create", path: join6(home, ".roo", "rules", "useai.md") },
         supportsUrl: true
       }),
       createTool({
         id: "amazon-q-cli",
         name: "Amazon Q CLI",
         configFormat: "standard",
-        configPath: join5(home, ".aws", "amazonq", "mcp.json"),
-        detect: () => hasBinary("q") || existsSync7(join5(home, ".aws", "amazonq")),
+        configPath: join6(home, ".aws", "amazonq", "mcp.json"),
+        detect: () => hasBinary("q") || existsSync8(join6(home, ".aws", "amazonq")),
         manualHint: "Create .amazonq/rules/useai.md in your project root with the instructions below."
       }),
       createTool({
         id: "amazon-q-ide",
         name: "Amazon Q IDE",
         configFormat: "standard",
-        configPath: join5(home, ".aws", "amazonq", "default.json"),
-        detect: () => existsSync7(join5(home, ".amazonq")) || existsSync7(join5(home, ".aws", "amazonq")),
+        configPath: join6(home, ".aws", "amazonq", "default.json"),
+        detect: () => existsSync8(join6(home, ".amazonq")) || existsSync8(join6(home, ".aws", "amazonq")),
         manualHint: "Create .amazonq/rules/useai.md in your project root with the instructions below."
       }),
       createTool({
         id: "codex",
         name: "Codex",
         configFormat: "toml",
-        configPath: join5(home, ".codex", "config.toml"),
-        detect: () => hasBinary("codex") || existsSync7(join5(home, ".codex")) || existsSync7("/Applications/Codex.app"),
-        instructions: { method: "append", path: join5(home, ".codex", "AGENTS.md") }
+        configPath: join6(home, ".codex", "config.toml"),
+        detect: () => hasBinary("codex") || existsSync8(join6(home, ".codex")) || existsSync8("/Applications/Codex.app"),
+        instructions: { method: "append", path: join6(home, ".codex", "AGENTS.md") }
       }),
       createTool({
         id: "goose",
         name: "Goose",
         configFormat: "yaml",
-        configPath: join5(home, ".config", "goose", "config.yaml"),
-        detect: () => existsSync7(join5(home, ".config", "goose")),
-        instructions: { method: "append", path: join5(home, ".config", "goose", ".goosehints") }
+        configPath: join6(home, ".config", "goose", "config.yaml"),
+        detect: () => existsSync8(join6(home, ".config", "goose")),
+        instructions: { method: "append", path: join6(home, ".config", "goose", ".goosehints") }
       }),
       createTool({
         id: "opencode",
         name: "OpenCode",
         configFormat: "standard",
-        configPath: join5(home, ".config", "opencode", "opencode.json"),
-        detect: () => hasBinary("opencode") || existsSync7(join5(home, ".config", "opencode")),
-        instructions: { method: "append", path: join5(home, ".config", "opencode", "AGENTS.md") },
+        configPath: join6(home, ".config", "opencode", "opencode.json"),
+        detect: () => hasBinary("opencode") || existsSync8(join6(home, ".config", "opencode")),
+        instructions: { method: "append", path: join6(home, ".config", "opencode", "AGENTS.md") },
         supportsUrl: true
       }),
       createTool({
         id: "junie",
         name: "Junie",
         configFormat: "standard",
-        configPath: join5(home, ".junie", "mcp", "mcp.json"),
-        detect: () => existsSync7(join5(home, ".junie")),
+        configPath: join6(home, ".junie", "mcp", "mcp.json"),
+        detect: () => existsSync8(join6(home, ".junie")),
         manualHint: "Add the instructions below to .junie/guidelines.md in your project root."
       })
     ];
@@ -1705,6 +1866,14 @@ async function daemonInstallFlow(tools, explicit) {
       console.log(err(`\u2717 ${tool.name.padEnd(18)} \u2014 ${e.message}`));
     }
   }
+  try {
+    const hooksInstalled = installClaudeCodeHooks();
+    if (hooksInstalled) {
+      console.log(ok("\u2713 Claude Code hooks installed (Stop + SessionEnd)"));
+    }
+  } catch {
+    console.log(chalk.yellow("  \u26A0 Could not install Claude Code hooks"));
+  }
   showManualHints(targetTools);
   const mode = useDaemon ? "daemon mode" : "stdio mode";
   console.log(`
@@ -1879,6 +2048,11 @@ async function fullRemoveFlow(tools, autoYes, explicit) {
       }
     }
   }
+  try {
+    removeClaudeCodeHooks();
+    console.log(ok("\u2713 Claude Code hooks removed"));
+  } catch {
+  }
   console.log();
   try {
     await killDaemon();
@@ -1954,6 +2128,610 @@ var init_setup = __esm({
   }
 });
 
+// src/dashboard/html.ts
+function getDashboardHtml() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>UseAI \u2014 Local Dashboard</title>
+<style>
+  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+  :root {
+    --bg: #0f0e0c;
+    --surface: #1a1816;
+    --border: #2a2520;
+    --amber: #d4a04a;
+    --amber-dim: #b8892e;
+    --text: #e8e0d4;
+    --muted: #9a9082;
+    --green: #6abf69;
+    --red: #d45a5a;
+    --blue: #5a9fd4;
+    --purple: #a87fd4;
+    --radius: 8px;
+  }
+
+  body {
+    font-family: system-ui, -apple-system, sans-serif;
+    background: var(--bg);
+    color: var(--text);
+    line-height: 1.5;
+    min-height: 100vh;
+    padding: 24px 16px;
+  }
+
+  .container { max-width: 960px; margin: 0 auto; }
+
+  /* Header */
+  .header { margin-bottom: 32px; }
+  .header h1 {
+    font-family: 'SF Mono', 'Fira Code', 'Cascadia Code', monospace;
+    font-size: 1.5rem;
+    color: var(--amber);
+    font-weight: 700;
+    letter-spacing: -0.02em;
+  }
+  .header .subtitle {
+    color: var(--muted);
+    font-size: 0.85rem;
+    margin-top: 2px;
+  }
+
+  /* Stats row */
+  .stats-row {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+    gap: 12px;
+    margin-bottom: 28px;
+  }
+  .stat-card {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 16px;
+  }
+  .stat-card .label {
+    font-size: 0.75rem;
+    color: var(--muted);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: 4px;
+  }
+  .stat-card .value {
+    font-family: 'SF Mono', 'Fira Code', monospace;
+    font-size: 1.6rem;
+    font-weight: 700;
+    color: var(--amber);
+  }
+  .stat-card .unit {
+    font-size: 0.8rem;
+    color: var(--muted);
+    font-weight: 400;
+    margin-left: 4px;
+  }
+
+  /* Section */
+  .section {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 20px;
+    margin-bottom: 16px;
+  }
+  .section h2 {
+    font-size: 0.85rem;
+    color: var(--muted);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: 16px;
+    font-weight: 600;
+  }
+
+  /* Bar chart */
+  .bar-row { margin-bottom: 10px; }
+  .bar-row:last-child { margin-bottom: 0; }
+  .bar-label {
+    display: flex;
+    justify-content: space-between;
+    font-size: 0.82rem;
+    margin-bottom: 4px;
+  }
+  .bar-label .name {
+    font-family: 'SF Mono', 'Fira Code', monospace;
+    color: var(--text);
+  }
+  .bar-label .hours {
+    color: var(--muted);
+    font-family: 'SF Mono', 'Fira Code', monospace;
+  }
+  .bar-track {
+    height: 8px;
+    background: var(--bg);
+    border-radius: 4px;
+    overflow: hidden;
+  }
+  .bar-fill {
+    height: 100%;
+    background: var(--amber);
+    border-radius: 4px;
+    transition: width 0.6s ease;
+  }
+
+  /* Milestones */
+  .milestone-item {
+    display: flex;
+    align-items: flex-start;
+    gap: 10px;
+    padding: 10px 0;
+    border-bottom: 1px solid var(--border);
+  }
+  .milestone-item:last-child { border-bottom: none; }
+  .milestone-title {
+    flex: 1;
+    font-size: 0.88rem;
+    color: var(--text);
+  }
+  .milestone-meta {
+    display: flex;
+    gap: 8px;
+    align-items: center;
+    flex-shrink: 0;
+  }
+  .badge {
+    font-size: 0.7rem;
+    padding: 2px 8px;
+    border-radius: 4px;
+    font-family: 'SF Mono', 'Fira Code', monospace;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    font-weight: 600;
+  }
+  .badge-feature { background: #2a3520; color: var(--green); }
+  .badge-bugfix { background: #3a2020; color: var(--red); }
+  .badge-refactor { background: #202a3a; color: var(--blue); }
+  .badge-test { background: #2a2035; color: var(--purple); }
+  .badge-docs { background: #2a2820; color: #c4a854; }
+  .badge-setup { background: #252520; color: #b0a070; }
+  .badge-deployment { background: #202525; color: #70b0a0; }
+  .badge-other { background: #252525; color: var(--muted); }
+  .complexity {
+    font-size: 0.7rem;
+    color: var(--muted);
+    font-family: 'SF Mono', 'Fira Code', monospace;
+  }
+  .milestone-date {
+    font-size: 0.72rem;
+    color: var(--muted);
+    font-family: 'SF Mono', 'Fira Code', monospace;
+    white-space: nowrap;
+  }
+
+  /* Sync section */
+  .sync-section { text-align: center; padding: 24px; }
+  .sync-btn {
+    background: var(--amber);
+    color: var(--bg);
+    border: none;
+    padding: 10px 28px;
+    border-radius: var(--radius);
+    font-weight: 600;
+    font-size: 0.9rem;
+    cursor: pointer;
+    font-family: system-ui, sans-serif;
+    transition: opacity 0.15s;
+  }
+  .sync-btn:hover { opacity: 0.85; }
+  .sync-btn:disabled { opacity: 0.5; cursor: not-allowed; }
+  .sync-status {
+    margin-top: 10px;
+    font-size: 0.82rem;
+    color: var(--muted);
+  }
+  .sync-result {
+    margin-top: 8px;
+    font-size: 0.82rem;
+  }
+  .sync-result.success { color: var(--green); }
+  .sync-result.error { color: var(--red); }
+
+  .setup-msg {
+    text-align: center;
+    padding: 20px;
+    color: var(--muted);
+    font-size: 0.88rem;
+  }
+  .setup-msg a {
+    color: var(--amber);
+    text-decoration: underline;
+  }
+
+  .empty {
+    text-align: center;
+    color: var(--muted);
+    padding: 20px;
+    font-size: 0.85rem;
+  }
+
+  @media (max-width: 500px) {
+    body { padding: 16px 10px; }
+    .stats-row { grid-template-columns: repeat(2, 1fr); }
+    .milestone-meta { flex-direction: column; gap: 4px; align-items: flex-end; }
+  }
+</style>
+</head>
+<body>
+<div class="container">
+  <div class="header">
+    <h1>UseAI</h1>
+    <div class="subtitle">Local Dashboard</div>
+  </div>
+
+  <div class="stats-row" id="stats-row">
+    <div class="stat-card"><div class="label">Total Hours</div><div class="value" id="stat-hours">-</div></div>
+    <div class="stat-card"><div class="label">Sessions</div><div class="value" id="stat-sessions">-</div></div>
+    <div class="stat-card"><div class="label">Current Streak</div><div class="value" id="stat-streak">-<span class="unit">days</span></div></div>
+    <div class="stat-card"><div class="label">Files Touched</div><div class="value" id="stat-files">-</div></div>
+  </div>
+
+  <div class="section" id="clients-section" style="display:none">
+    <h2>Tools / Clients</h2>
+    <div id="clients-bars"></div>
+  </div>
+
+  <div class="section" id="languages-section" style="display:none">
+    <h2>Languages</h2>
+    <div id="languages-bars"></div>
+  </div>
+
+  <div class="section" id="tasks-section" style="display:none">
+    <h2>Task Types</h2>
+    <div id="tasks-bars"></div>
+  </div>
+
+  <div class="section" id="milestones-section" style="display:none">
+    <h2>Recent Milestones</h2>
+    <div id="milestones-list"></div>
+  </div>
+
+  <div class="section" id="sync-section" style="display:none"></div>
+</div>
+
+<script>
+(function() {
+  const API = '';
+
+  function animateCounter(el, target, decimals) {
+    if (decimals === undefined) decimals = 0;
+    var start = 0;
+    var duration = 600;
+    var startTime = null;
+    function step(ts) {
+      if (!startTime) startTime = ts;
+      var progress = Math.min((ts - startTime) / duration, 1);
+      var eased = 1 - Math.pow(1 - progress, 3);
+      var current = start + (target - start) * eased;
+      el.textContent = decimals > 0 ? current.toFixed(decimals) : Math.round(current);
+      if (progress < 1) requestAnimationFrame(step);
+    }
+    requestAnimationFrame(step);
+  }
+
+  function formatHours(seconds) {
+    var h = seconds / 3600;
+    return h < 0.1 ? h.toFixed(2) : h.toFixed(1);
+  }
+
+  function renderBars(containerId, data) {
+    var container = document.getElementById(containerId);
+    if (!container) return;
+    var entries = Object.entries(data).sort(function(a, b) { return b[1] - a[1]; });
+    if (entries.length === 0) { container.innerHTML = '<div class="empty">No data yet</div>'; return; }
+    var max = entries[0][1];
+    container.innerHTML = entries.map(function(e) {
+      var pct = max > 0 ? (e[1] / max * 100) : 0;
+      return '<div class="bar-row">' +
+        '<div class="bar-label"><span class="name">' + escapeHtml(e[0]) + '</span><span class="hours">' + formatHours(e[1]) + 'h</span></div>' +
+        '<div class="bar-track"><div class="bar-fill" style="width:' + pct + '%"></div></div>' +
+        '</div>';
+    }).join('');
+  }
+
+  function badgeClass(cat) {
+    var map = { feature: 'feature', bugfix: 'bugfix', refactor: 'refactor', test: 'test', docs: 'docs', setup: 'setup', deployment: 'deployment' };
+    return 'badge badge-' + (map[cat] || 'other');
+  }
+
+  function escapeHtml(s) {
+    var d = document.createElement('div');
+    d.textContent = s;
+    return d.innerHTML;
+  }
+
+  function renderMilestones(milestones) {
+    var section = document.getElementById('milestones-section');
+    var list = document.getElementById('milestones-list');
+    if (!milestones || milestones.length === 0) {
+      section.style.display = 'block';
+      list.innerHTML = '<div class="empty">No milestones recorded yet</div>';
+      return;
+    }
+    section.style.display = 'block';
+    var recent = milestones.slice(-20).reverse();
+    list.innerHTML = recent.map(function(m) {
+      var date = m.created_at ? m.created_at.slice(0, 10) : '';
+      return '<div class="milestone-item">' +
+        '<div class="milestone-title">' + escapeHtml(m.title) + '</div>' +
+        '<div class="milestone-meta">' +
+          '<span class="' + badgeClass(m.category) + '">' + escapeHtml(m.category) + '</span>' +
+          (m.complexity ? '<span class="complexity">' + escapeHtml(m.complexity) + '</span>' : '') +
+          '<span class="milestone-date">' + escapeHtml(date) + '</span>' +
+        '</div>' +
+      '</div>';
+    }).join('');
+  }
+
+  function renderSync(config) {
+    var section = document.getElementById('sync-section');
+    if (!config) { section.style.display = 'none'; return; }
+    section.style.display = 'block';
+
+    if (config.authenticated) {
+      var lastSync = config.last_sync_at ? 'Last sync: ' + config.last_sync_at : 'Never synced';
+      section.innerHTML = '<div class="sync-section">' +
+        '<h2 style="font-size:0.85rem;color:var(--muted);text-transform:uppercase;letter-spacing:0.05em;margin-bottom:12px;font-weight:600;">Sync</h2>' +
+        '<button class="sync-btn" id="sync-btn">Sync to useai.dev</button>' +
+        '<div class="sync-status" id="sync-status">' + escapeHtml(lastSync) + '</div>' +
+        '<div class="sync-result" id="sync-result"></div>' +
+      '</div>';
+      document.getElementById('sync-btn').addEventListener('click', doSync);
+    } else {
+      section.innerHTML = '<div class="setup-msg">Login at <a href="https://useai.dev" target="_blank">useai.dev</a> to sync your data across devices</div>';
+    }
+  }
+
+  function doSync() {
+    var btn = document.getElementById('sync-btn');
+    var result = document.getElementById('sync-result');
+    var status = document.getElementById('sync-status');
+    btn.disabled = true;
+    btn.textContent = 'Syncing...';
+    result.textContent = '';
+    result.className = 'sync-result';
+
+    fetch(API + '/api/local/sync', { method: 'POST' })
+      .then(function(r) { return r.json(); })
+      .then(function(data) {
+        btn.disabled = false;
+        btn.textContent = 'Sync to useai.dev';
+        if (data.success) {
+          result.textContent = 'Synced successfully';
+          result.className = 'sync-result success';
+          if (data.last_sync_at) status.textContent = 'Last sync: ' + data.last_sync_at;
+        } else {
+          result.textContent = 'Sync failed: ' + (data.error || 'Unknown error');
+          result.className = 'sync-result error';
+        }
+      })
+      .catch(function(err) {
+        btn.disabled = false;
+        btn.textContent = 'Sync to useai.dev';
+        result.textContent = 'Sync failed: ' + err.message;
+        result.className = 'sync-result error';
+      });
+  }
+
+  function loadAll() {
+    fetch(API + '/api/local/stats')
+      .then(function(r) { return r.json(); })
+      .then(function(stats) {
+        animateCounter(document.getElementById('stat-hours'), stats.totalHours, 1);
+        animateCounter(document.getElementById('stat-sessions'), stats.totalSessions);
+        var streakEl = document.getElementById('stat-streak');
+        streakEl.innerHTML = '';
+        var numSpan = document.createElement('span');
+        streakEl.appendChild(numSpan);
+        animateCounter(numSpan, stats.currentStreak);
+        var unitSpan = document.createElement('span');
+        unitSpan.className = 'unit';
+        unitSpan.textContent = ' days';
+        streakEl.appendChild(unitSpan);
+        animateCounter(document.getElementById('stat-files'), stats.filesTouched || 0);
+
+        if (Object.keys(stats.byClient || {}).length > 0) {
+          document.getElementById('clients-section').style.display = 'block';
+          renderBars('clients-bars', stats.byClient);
+        }
+        if (Object.keys(stats.byLanguage || {}).length > 0) {
+          document.getElementById('languages-section').style.display = 'block';
+          renderBars('languages-bars', stats.byLanguage);
+        }
+        if (Object.keys(stats.byTaskType || {}).length > 0) {
+          document.getElementById('tasks-section').style.display = 'block';
+          renderBars('tasks-bars', stats.byTaskType);
+        }
+      })
+      .catch(function() {});
+
+    fetch(API + '/api/local/milestones')
+      .then(function(r) { return r.json(); })
+      .then(function(data) { renderMilestones(data); })
+      .catch(function() {});
+
+    fetch(API + '/api/local/config')
+      .then(function(r) { return r.json(); })
+      .then(function(data) { renderSync(data); })
+      .catch(function() {});
+  }
+
+  loadAll();
+  setInterval(loadAll, 30000);
+})();
+</script>
+</body>
+</html>`;
+}
+var init_html = __esm({
+  "src/dashboard/html.ts"() {
+    "use strict";
+  }
+});
+
+// src/dashboard/local-api.ts
+function json(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type"
+  });
+  res.end(body);
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+function calculateStreak(sessions2) {
+  if (sessions2.length === 0) return 0;
+  const days = /* @__PURE__ */ new Set();
+  for (const s of sessions2) {
+    days.add(s.started_at.slice(0, 10));
+  }
+  const sorted = [...days].sort().reverse();
+  if (sorted.length === 0) return 0;
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const yesterday = new Date(Date.now() - 864e5).toISOString().slice(0, 10);
+  if (sorted[0] !== today && sorted[0] !== yesterday) return 0;
+  let streak = 1;
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = new Date(sorted[i - 1]);
+    const curr = new Date(sorted[i]);
+    const diffDays = (prev.getTime() - curr.getTime()) / 864e5;
+    if (diffDays === 1) {
+      streak++;
+    } else {
+      break;
+    }
+  }
+  return streak;
+}
+function handleLocalStats(_req, res) {
+  try {
+    const sessions2 = readJson(SESSIONS_FILE, []);
+    let totalSeconds = 0;
+    let filesTouched = 0;
+    const byClient = {};
+    const byLanguage = {};
+    const byTaskType = {};
+    for (const s of sessions2) {
+      totalSeconds += s.duration_seconds;
+      filesTouched += s.files_touched;
+      byClient[s.client] = (byClient[s.client] ?? 0) + s.duration_seconds;
+      for (const lang of s.languages) {
+        byLanguage[lang] = (byLanguage[lang] ?? 0) + s.duration_seconds;
+      }
+      byTaskType[s.task_type] = (byTaskType[s.task_type] ?? 0) + s.duration_seconds;
+    }
+    json(res, 200, {
+      totalHours: totalSeconds / 3600,
+      totalSessions: sessions2.length,
+      currentStreak: calculateStreak(sessions2),
+      filesTouched,
+      byClient,
+      byLanguage,
+      byTaskType
+    });
+  } catch (err2) {
+    json(res, 500, { error: err2.message });
+  }
+}
+function handleLocalMilestones(_req, res) {
+  try {
+    const milestones = readJson(MILESTONES_FILE, []);
+    json(res, 200, milestones);
+  } catch (err2) {
+    json(res, 500, { error: err2.message });
+  }
+}
+function handleLocalConfig(_req, res) {
+  try {
+    const config = readJson(CONFIG_FILE, {
+      milestone_tracking: true,
+      auto_sync: false,
+      sync_interval_hours: 24
+    });
+    json(res, 200, {
+      authenticated: !!config.auth?.token,
+      email: config.auth?.user?.email ?? null,
+      username: config.auth?.user?.username ?? null,
+      last_sync_at: config.last_sync_at ?? null,
+      auto_sync: config.auto_sync
+    });
+  } catch (err2) {
+    json(res, 500, { error: err2.message });
+  }
+}
+async function handleLocalSync(req, res) {
+  try {
+    await readBody(req);
+    const config = readJson(CONFIG_FILE, {
+      milestone_tracking: true,
+      auto_sync: false,
+      sync_interval_hours: 24
+    });
+    if (!config.auth?.token) {
+      json(res, 401, { success: false, error: "Not authenticated. Login at useai.dev first." });
+      return;
+    }
+    const token = config.auth.token;
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token}`
+    };
+    const sessions2 = readJson(SESSIONS_FILE, []);
+    const sessionsRes = await fetch("https://api.useai.dev/api/sync", {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ sessions: sessions2 })
+    });
+    if (!sessionsRes.ok) {
+      const errBody = await sessionsRes.text();
+      json(res, 502, { success: false, error: `Sessions sync failed: ${sessionsRes.status} ${errBody}` });
+      return;
+    }
+    const milestones = readJson(MILESTONES_FILE, []);
+    const milestonesRes = await fetch("https://api.useai.dev/api/publish", {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ milestones })
+    });
+    if (!milestonesRes.ok) {
+      const errBody = await milestonesRes.text();
+      json(res, 502, { success: false, error: `Milestones publish failed: ${milestonesRes.status} ${errBody}` });
+      return;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    config.last_sync_at = now;
+    writeJson(CONFIG_FILE, config);
+    json(res, 200, { success: true, last_sync_at: now });
+  } catch (err2) {
+    json(res, 500, { success: false, error: err2.message });
+  }
+}
+var init_local_api = __esm({
+  "src/dashboard/local-api.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
+
 // src/daemon.ts
 var daemon_exports = {};
 __export(daemon_exports, {
@@ -1961,11 +2739,125 @@ __export(daemon_exports, {
 });
 import { createServer } from "http";
 import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync8, renameSync as renameSync3, writeFileSync as writeFileSync4, unlinkSync as unlinkSync4 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync5, appendFileSync as appendFileSync2, renameSync as renameSync3, writeFileSync as writeFileSync5, unlinkSync as unlinkSync5 } from "fs";
+import { join as join7 } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+function getActiveUseaiSessionIds() {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [, active] of sessions) {
+    ids.add(active.session.sessionId);
+  }
+  return ids;
+}
+function sealOrphanFile(sessionId) {
+  const filePath = join7(ACTIVE_DIR, `${sessionId}.jsonl`);
+  if (!existsSync9(filePath)) return;
+  try {
+    const content = readFileSync5(filePath, "utf-8").trim();
+    if (!content) return;
+    const lines = content.split("\n").filter(Boolean);
+    if (lines.length === 0) return;
+    const firstRecord = JSON.parse(lines[0]);
+    const lastRecord = JSON.parse(lines[lines.length - 1]);
+    if (lastRecord.type === "session_end" || lastRecord.type === "session_seal") {
+      try {
+        renameSync3(filePath, join7(SEALED_DIR, `${sessionId}.jsonl`));
+      } catch {
+      }
+      return;
+    }
+    const startData = firstRecord.data;
+    const client = startData["client"] ?? "unknown";
+    const taskType = startData["task_type"] ?? "coding";
+    const startTime = firstRecord.timestamp;
+    let heartbeatCount = 0;
+    for (const line of lines) {
+      try {
+        if (JSON.parse(line).type === "heartbeat") heartbeatCount++;
+      } catch {
+      }
+    }
+    const chainTip = lastRecord.hash;
+    const duration = Math.round((Date.now() - new Date(startTime).getTime()) / 1e3);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const endRecord = buildChainRecord("session_end", sessionId, {
+      duration_seconds: duration,
+      task_type: taskType,
+      languages: [],
+      files_touched: 0,
+      heartbeat_count: heartbeatCount,
+      auto_sealed: true
+    }, chainTip, daemonSigningKey);
+    appendFileSync2(filePath, JSON.stringify(endRecord) + "\n");
+    const sealData = JSON.stringify({
+      session_id: sessionId,
+      client,
+      task_type: taskType,
+      languages: [],
+      files_touched: 0,
+      started_at: startTime,
+      ended_at: now,
+      duration_seconds: duration,
+      heartbeat_count: heartbeatCount,
+      record_count: lines.length + 2,
+      chain_end_hash: endRecord.hash
+    });
+    const sealSignature = signHash(
+      createHash4("sha256").update(sealData).digest("hex"),
+      daemonSigningKey
+    );
+    appendFileSync2(filePath, JSON.stringify(
+      buildChainRecord("session_seal", sessionId, {
+        seal: sealData,
+        seal_signature: sealSignature,
+        auto_sealed: true
+      }, endRecord.hash, daemonSigningKey)
+    ) + "\n");
+    try {
+      renameSync3(filePath, join7(SEALED_DIR, `${sessionId}.jsonl`));
+    } catch {
+    }
+    const seal = {
+      session_id: sessionId,
+      client,
+      task_type: taskType,
+      languages: [],
+      files_touched: 0,
+      started_at: startTime,
+      ended_at: now,
+      duration_seconds: duration,
+      heartbeat_count: heartbeatCount,
+      record_count: lines.length + 2,
+      chain_start_hash: firstRecord.prev_hash,
+      chain_end_hash: endRecord.hash,
+      seal_signature: sealSignature
+    };
+    const allSessions = readJson(SESSIONS_FILE, []);
+    allSessions.push(seal);
+    writeJson(SESSIONS_FILE, allSessions);
+  } catch {
+  }
+}
+function sealOrphanedSessions() {
+  if (!existsSync9(ACTIVE_DIR)) return;
+  const activeIds = getActiveUseaiSessionIds();
+  let sealed = 0;
+  try {
+    const files = readdirSync(ACTIVE_DIR).filter((f) => f.endsWith(".jsonl"));
+    for (const file of files) {
+      const sessionId = file.replace(".jsonl", "");
+      if (activeIds.has(sessionId)) continue;
+      sealOrphanFile(sessionId);
+      sealed++;
+    }
+  } catch {
+  }
+  if (sealed > 0) {
+    console.log(`Sealed ${sealed} orphaned session${sealed === 1 ? "" : "s"}`);
+  }
+}
 function autoSealSession(active) {
   const { session: session2 } = active;
   if (session2.sessionRecordCount === 0) return;
@@ -2001,10 +2893,10 @@ function autoSealSession(active) {
     seal_signature: sealSignature,
     auto_sealed: true
   });
-  const activePath = join6(ACTIVE_DIR, `${session2.sessionId}.jsonl`);
-  const sealedPath = join6(SEALED_DIR, `${session2.sessionId}.jsonl`);
+  const activePath = join7(ACTIVE_DIR, `${session2.sessionId}.jsonl`);
+  const sealedPath = join7(SEALED_DIR, `${session2.sessionId}.jsonl`);
   try {
-    if (existsSync8(activePath)) {
+    if (existsSync9(activePath)) {
       renameSync3(activePath, sealedPath);
     }
   } catch {
@@ -2081,12 +2973,71 @@ function parseBody(req) {
 async function startDaemon(port) {
   const listenPort = port ?? DAEMON_PORT;
   ensureDir();
+  try {
+    if (existsSync9(KEYSTORE_FILE)) {
+      const ks = readJson(KEYSTORE_FILE, null);
+      if (ks) daemonSigningKey = decryptKeystore(ks);
+    }
+    if (!daemonSigningKey) {
+      const result = generateKeystore();
+      writeJson(KEYSTORE_FILE, result.keystore);
+      daemonSigningKey = result.signingKey;
+    }
+  } catch {
+  }
+  sealOrphanedSessions();
+  const sweepInterval = setInterval(sealOrphanedSessions, ORPHAN_SWEEP_INTERVAL_MS);
+  sweepInterval.unref();
   const server2 = createServer(async (req, res) => {
     const url = new URL(req.url, `http://${req.headers.host}`);
     if (url.pathname === "/health" && req.method === "GET") {
       handleHealth(res);
       return;
     }
+    if ((url.pathname === "/" || url.pathname === "/dashboard") && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(getDashboardHtml());
+      return;
+    }
+    if (url.pathname.startsWith("/api/local/") && req.method === "GET") {
+      if (url.pathname === "/api/local/stats") {
+        handleLocalStats(req, res);
+        return;
+      }
+      if (url.pathname === "/api/local/milestones") {
+        handleLocalMilestones(req, res);
+        return;
+      }
+      if (url.pathname === "/api/local/config") {
+        handleLocalConfig(req, res);
+        return;
+      }
+    }
+    if (url.pathname === "/api/local/sync" && req.method === "POST") {
+      await handleLocalSync(req, res);
+      return;
+    }
+    if (url.pathname === "/api/seal-active" && req.method === "POST") {
+      const sids = [...sessions.keys()];
+      for (const sid of sids) {
+        await cleanupSession(sid);
+      }
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*"
+      });
+      res.end(JSON.stringify({ sealed: sids.length }));
+      return;
+    }
+    if ((url.pathname.startsWith("/api/local/") || url.pathname === "/api/seal-active") && req.method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type"
+      });
+      res.end();
+      return;
+    }
     if (url.pathname !== "/mcp") {
       res.writeHead(404, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Not found" }));
@@ -2120,6 +3071,10 @@ async function startDaemon(port) {
           const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => randomUUID4(),
             onsessioninitialized: (newSid) => {
+              const clientInfo = mcpServer.server.getClientVersion();
+              if (clientInfo?.name) {
+                sessionState.setClient(normalizeMcpClientName(clientInfo.name));
+              }
               const idleTimer = setTimeout(async () => {
                 await cleanupSession(newSid);
               }, IDLE_TIMEOUT_MS);
@@ -2187,14 +3142,14 @@ async function startDaemon(port) {
     port: listenPort,
     started_at: (/* @__PURE__ */ new Date()).toISOString()
   });
-  writeFileSync4(DAEMON_PID_FILE, pidData + "\n");
+  writeFileSync5(DAEMON_PID_FILE, pidData + "\n");
   const shutdown = async (signal) => {
     for (const [sid] of sessions) {
       await cleanupSession(sid);
     }
     try {
-      if (existsSync8(DAEMON_PID_FILE)) {
-        unlinkSync4(DAEMON_PID_FILE);
+      if (existsSync9(DAEMON_PID_FILE)) {
+        unlinkSync5(DAEMON_PID_FILE);
       }
     } catch {
     }
@@ -2210,15 +3165,19 @@ async function startDaemon(port) {
     console.log(`PID: ${process.pid}`);
   });
 }
-var IDLE_TIMEOUT_MS, sessions, startedAt;
+var IDLE_TIMEOUT_MS, sessions, daemonSigningKey, ORPHAN_SWEEP_INTERVAL_MS, startedAt;
 var init_daemon2 = __esm({
   "src/daemon.ts"() {
     "use strict";
     init_dist();
     init_session_state();
     init_register_tools();
+    init_html();
+    init_local_api();
     IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
     sessions = /* @__PURE__ */ new Map();
+    daemonSigningKey = null;
+    ORPHAN_SWEEP_INTERVAL_MS = 15 * 60 * 1e3;
     startedAt = Date.now();
   }
 });