@devness/useai 0.3.7 → 0.4.0

package/dist/index.js

@@ -9,25 +9,1127 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/tools.ts
+// ../shared/dist/types/chain.js
+var init_chain = __esm({
+  "../shared/dist/types/chain.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/types/config.js
+var init_config = __esm({
+  "../shared/dist/types/config.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/types/keystore.js
+var init_keystore = __esm({
+  "../shared/dist/types/keystore.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/types/milestone.js
+var init_milestone = __esm({
+  "../shared/dist/types/milestone.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/types/session.js
+var init_session = __esm({
+  "../shared/dist/types/session.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/types/api.js
+var init_api = __esm({
+  "../shared/dist/types/api.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/types/user.js
+var init_user = __esm({
+  "../shared/dist/types/user.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/types/leaderboard.js
+var init_leaderboard = __esm({
+  "../shared/dist/types/leaderboard.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/types/index.js
+var init_types = __esm({
+  "../shared/dist/types/index.js"() {
+    "use strict";
+    init_chain();
+    init_config();
+    init_keystore();
+    init_milestone();
+    init_session();
+    init_api();
+    init_user();
+    init_leaderboard();
+  }
+});
+
+// ../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 init_paths = __esm({
+  "../shared/dist/constants/paths.js"() {
+    "use strict";
+    USEAI_DIR = join(homedir(), ".useai");
+    DATA_DIR = join(USEAI_DIR, "data");
+    ACTIVE_DIR = join(DATA_DIR, "active");
+    SEALED_DIR = join(DATA_DIR, "sealed");
+    KEYSTORE_FILE = join(USEAI_DIR, "keystore.json");
+    CONFIG_FILE = join(USEAI_DIR, "config.json");
+    SESSIONS_FILE = join(DATA_DIR, "sessions.json");
+    MILESTONES_FILE = join(DATA_DIR, "milestones.json");
+    DAEMON_PID_FILE = join(USEAI_DIR, "daemon.pid");
+    DAEMON_PORT = 19200;
+    DAEMON_LOG_FILE = join(USEAI_DIR, "daemon.log");
+    DAEMON_MCP_URL = `http://127.0.0.1:${DAEMON_PORT}/mcp`;
+    DAEMON_HEALTH_URL = `http://127.0.0.1:${DAEMON_PORT}/health`;
+    LAUNCHD_PLIST_PATH = join(homedir(), "Library", "LaunchAgents", "dev.useai.daemon.plist");
+    SYSTEMD_SERVICE_PATH = join(homedir(), ".config", "systemd", "user", "useai-daemon.service");
+    WINDOWS_STARTUP_SCRIPT_PATH = join(process.env["APPDATA"] ?? join(homedir(), "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "useai-daemon.vbs");
+  }
+});
+
+// ../shared/dist/constants/version.js
+var VERSION;
+var init_version = __esm({
+  "../shared/dist/constants/version.js"() {
+    "use strict";
+    VERSION = "0.3.0";
+  }
+});
+
+// ../shared/dist/constants/clients.js
+var AI_CLIENT_ENV_VARS;
+var init_clients = __esm({
+  "../shared/dist/constants/clients.js"() {
+    "use strict";
+    AI_CLIENT_ENV_VARS = {
+      CURSOR_EDITOR: "cursor",
+      WINDSURF_EDITOR: "windsurf",
+      CLAUDE_CODE: "claude-code",
+      VSCODE_PID: "vscode",
+      CODEX_CLI: "codex",
+      GEMINI_CLI: "gemini-cli",
+      JETBRAINS_IDE: "jetbrains",
+      ZED_EDITOR: "zed"
+    };
+  }
+});
+
+// ../shared/dist/constants/defaults.js
+var GENESIS_HASH;
+var init_defaults = __esm({
+  "../shared/dist/constants/defaults.js"() {
+    "use strict";
+    GENESIS_HASH = "GENESIS";
+  }
+});
+
+// ../shared/dist/constants/index.js
+var init_constants = __esm({
+  "../shared/dist/constants/index.js"() {
+    "use strict";
+    init_paths();
+    init_version();
+    init_clients();
+    init_defaults();
+  }
+});
+
+// ../shared/dist/crypto/derive.js
+import { pbkdf2Sync } from "crypto";
+import { hostname, userInfo } from "os";
+function deriveEncryptionKey(salt) {
+  const machineData = `${hostname()}:${userInfo().username}:useai-keystore`;
+  return pbkdf2Sync(machineData, salt, 1e5, 32, "sha256");
+}
+var init_derive = __esm({
+  "../shared/dist/crypto/derive.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/crypto/keystore.js
+import { generateKeyPairSync, randomBytes, createCipheriv, createDecipheriv, createPrivateKey } from "crypto";
+function decryptKeystore(ks) {
+  const salt = Buffer.from(ks.salt, "hex");
+  const iv = Buffer.from(ks.iv, "hex");
+  const tag = Buffer.from(ks.tag, "hex");
+  const encrypted = Buffer.from(ks.encrypted_private_key, "hex");
+  const encKey = deriveEncryptionKey(salt);
+  const decipher = createDecipheriv("aes-256-gcm", encKey, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+  return createPrivateKey(decrypted.toString("utf-8"));
+}
+function generateKeystore() {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" });
+  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" });
+  const salt = randomBytes(32);
+  const encKey = deriveEncryptionKey(salt);
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", encKey, iv);
+  const encrypted = Buffer.concat([cipher.update(privateKeyPem, "utf-8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const keystore = {
+    public_key_pem: publicKeyPem,
+    encrypted_private_key: encrypted.toString("hex"),
+    iv: iv.toString("hex"),
+    tag: tag.toString("hex"),
+    salt: salt.toString("hex"),
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return { keystore, signingKey: privateKey };
+}
+var init_keystore2 = __esm({
+  "../shared/dist/crypto/keystore.js"() {
+    "use strict";
+    init_derive();
+  }
+});
+
+// ../shared/dist/crypto/chain.js
+import { createHash, sign as cryptoSign, randomUUID } from "crypto";
+function computeHash(recordJson, prevHash) {
+  return createHash("sha256").update(recordJson + prevHash).digest("hex");
+}
+function signHash(hash, signingKey) {
+  if (!signingKey)
+    return "unsigned";
+  try {
+    return cryptoSign(null, Buffer.from(hash), signingKey).toString("hex");
+  } catch {
+    return "unsigned";
+  }
+}
+function buildChainRecord(type, sessionId, data, prevHash, signingKey) {
+  const id = `r_${randomUUID().slice(0, 12)}`;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const recordCore = JSON.stringify({ id, type, session_id: sessionId, timestamp, data });
+  const hash = computeHash(recordCore, prevHash);
+  const signature = signHash(hash, signingKey);
+  return {
+    id,
+    type,
+    session_id: sessionId,
+    timestamp,
+    data,
+    prev_hash: prevHash,
+    hash,
+    signature
+  };
+}
+var init_chain2 = __esm({
+  "../shared/dist/crypto/chain.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/crypto/verify.js
+import { createHash as createHash2, createPublicKey, verify as cryptoVerify } from "crypto";
+var init_verify = __esm({
+  "../shared/dist/crypto/verify.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/crypto/index.js
+var init_crypto = __esm({
+  "../shared/dist/crypto/index.js"() {
+    "use strict";
+    init_keystore2();
+    init_chain2();
+    init_verify();
+    init_derive();
+  }
+});
+
+// ../shared/dist/validation/schemas.js
+import { z } from "zod";
+var taskTypeSchema, milestoneCategorySchema, complexitySchema, milestoneInputSchema, syncPayloadSchema, publishPayloadSchema;
+var init_schemas = __esm({
+  "../shared/dist/validation/schemas.js"() {
+    "use strict";
+    taskTypeSchema = z.enum([
+      "coding",
+      "debugging",
+      "testing",
+      "planning",
+      "reviewing",
+      "documenting",
+      "learning",
+      "other"
+    ]);
+    milestoneCategorySchema = z.enum([
+      "feature",
+      "bugfix",
+      "refactor",
+      "test",
+      "docs",
+      "setup",
+      "deployment",
+      "other"
+    ]);
+    complexitySchema = z.enum(["simple", "medium", "complex"]);
+    milestoneInputSchema = z.object({
+      title: z.string().min(1).max(500),
+      category: milestoneCategorySchema,
+      complexity: complexitySchema.optional()
+    });
+    syncPayloadSchema = z.object({
+      date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+      total_seconds: z.number().int().nonnegative(),
+      clients: z.record(z.string(), z.number().int().nonnegative()),
+      task_types: z.record(z.string(), z.number().int().nonnegative()),
+      languages: z.record(z.string(), z.number().int().nonnegative()),
+      sessions: z.array(z.object({
+        session_id: z.string(),
+        client: z.string(),
+        task_type: z.string(),
+        languages: z.array(z.string()),
+        files_touched: z.number().int().nonnegative(),
+        started_at: z.string(),
+        ended_at: z.string(),
+        duration_seconds: z.number().int().nonnegative(),
+        heartbeat_count: z.number().int().nonnegative(),
+        record_count: z.number().int().nonnegative(),
+        chain_start_hash: z.string(),
+        chain_end_hash: z.string(),
+        seal_signature: z.string()
+      })),
+      sync_signature: z.string()
+    });
+    publishPayloadSchema = z.object({
+      milestones: z.array(z.object({
+        id: z.string(),
+        title: z.string().min(1).max(500),
+        category: milestoneCategorySchema,
+        complexity: complexitySchema,
+        duration_minutes: z.number().int().nonnegative(),
+        languages: z.array(z.string()),
+        client: z.string(),
+        chain_hash: z.string()
+      }))
+    });
+  }
+});
+
+// ../shared/dist/validation/guards.js
+var init_guards = __esm({
+  "../shared/dist/validation/guards.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/validation/index.js
+var init_validation = __esm({
+  "../shared/dist/validation/index.js"() {
+    "use strict";
+    init_schemas();
+    init_guards();
+  }
+});
+
+// ../shared/dist/utils/fs.js
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
+function ensureDir() {
+  for (const dir of [USEAI_DIR, DATA_DIR, ACTIVE_DIR, SEALED_DIR]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+function readJson(path, fallback) {
+  try {
+    if (!existsSync(path))
+      return fallback;
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(path, data) {
+  ensureDir();
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+  renameSync(tmp, path);
+}
+var init_fs = __esm({
+  "../shared/dist/utils/fs.js"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// ../shared/dist/utils/format.js
+function formatDuration(seconds) {
+  if (seconds < 60)
+    return `${seconds}s`;
+  const mins = Math.round(seconds / 60);
+  if (mins < 60)
+    return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  const remainMins = mins % 60;
+  return `${hrs}h ${remainMins}m`;
+}
+var init_format = __esm({
+  "../shared/dist/utils/format.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/utils/detect-client.js
+function detectClient() {
+  const env = process.env;
+  for (const [envVar, clientName] of Object.entries(AI_CLIENT_ENV_VARS)) {
+    if (env[envVar])
+      return clientName;
+  }
+  if (env.MCP_CLIENT_NAME)
+    return env.MCP_CLIENT_NAME;
+  return "unknown";
+}
+var init_detect_client = __esm({
+  "../shared/dist/utils/detect-client.js"() {
+    "use strict";
+    init_clients();
+  }
+});
+
+// ../shared/dist/utils/id.js
+import { randomUUID as randomUUID2 } from "crypto";
+function generateSessionId() {
+  return randomUUID2();
+}
+var init_id = __esm({
+  "../shared/dist/utils/id.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/utils/index.js
+var init_utils = __esm({
+  "../shared/dist/utils/index.js"() {
+    "use strict";
+    init_fs();
+    init_format();
+    init_detect_client();
+    init_id();
+  }
+});
+
+// ../shared/dist/daemon/resolve-npx.js
 import { execSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, unlinkSync } from "fs";
-import { dirname, join as join3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
+function resolveNpxPath() {
+  const whichCmd = isWindows ? "where npx" : "which npx";
+  try {
+    const result = execSync(whichCmd, { stdio: ["pipe", "pipe", "ignore"], encoding: "utf-8" }).trim();
+    if (result)
+      return result.split("\n")[0].trim();
+  } catch {
+  }
+  if (!isWindows && process.env["SHELL"]) {
+    try {
+      const result = execSync(`${process.env["SHELL"]} -lc "which npx"`, {
+        stdio: ["pipe", "pipe", "ignore"],
+        encoding: "utf-8"
+      }).trim();
+      if (result)
+        return result;
+    } catch {
+    }
+  }
+  for (const p of KNOWN_PATHS) {
+    if (existsSync2(p))
+      return p;
+  }
+  throw new Error("Could not find npx. Ensure Node.js is installed and npx is in your PATH.");
+}
+function buildNodePath() {
+  const home2 = homedir2();
+  const dirs = [
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    "/usr/bin",
+    "/bin",
+    join2(home2, ".nvm", "current", "bin"),
+    join2(home2, ".volta", "bin"),
+    join2(home2, ".bun", "bin")
+  ];
+  try {
+    const npx = resolveNpxPath();
+    const npxDir = npx.substring(0, npx.lastIndexOf("/"));
+    if (npxDir && !dirs.includes(npxDir)) {
+      dirs.unshift(npxDir);
+    }
+  } catch {
+  }
+  return dirs.filter((d) => existsSync2(d)).join(":");
+}
+var isWindows, KNOWN_PATHS;
+var init_resolve_npx = __esm({
+  "../shared/dist/daemon/resolve-npx.js"() {
+    "use strict";
+    isWindows = process.platform === "win32";
+    KNOWN_PATHS = isWindows ? [] : [
+      "/usr/local/bin/npx",
+      "/opt/homebrew/bin/npx",
+      join2(homedir2(), ".nvm", "current", "bin", "npx"),
+      join2(homedir2(), ".volta", "bin", "npx"),
+      join2(homedir2(), ".bun", "bin", "npx")
+    ];
+  }
+});
+
+// ../shared/dist/daemon/ensure.js
+import { existsSync as existsSync3, readFileSync as readFileSync2, unlinkSync } from "fs";
+import { spawn } from "child_process";
+function readPidFile() {
+  if (!existsSync3(DAEMON_PID_FILE))
+    return null;
+  try {
+    const raw = readFileSync2(DAEMON_PID_FILE, "utf-8").trim();
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkDaemonHealth() {
+  try {
+    const res = await fetch(DAEMON_HEALTH_URL, { signal: AbortSignal.timeout(3e3) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function killDaemon() {
+  const pid = readPidFile();
+  if (!pid)
+    return;
+  if (!isProcessRunning(pid.pid)) {
+    try {
+      unlinkSync(DAEMON_PID_FILE);
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(pid.pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  const start = Date.now();
+  while (Date.now() - start < 5e3) {
+    if (!isProcessRunning(pid.pid)) {
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  try {
+    process.kill(pid.pid, "SIGKILL");
+  } catch {
+  }
+  try {
+    if (existsSync3(DAEMON_PID_FILE))
+      unlinkSync(DAEMON_PID_FILE);
+  } catch {
+  }
+}
+async function ensureDaemon() {
+  if (await checkDaemonHealth())
+    return true;
+  const pid = readPidFile();
+  if (pid && isProcessRunning(pid.pid)) {
+    await killDaemon();
+  } else if (pid) {
+    try {
+      unlinkSync(DAEMON_PID_FILE);
+    } catch {
+    }
+  }
+  let npxPath;
+  try {
+    npxPath = resolveNpxPath();
+  } catch {
+    npxPath = "npx";
+  }
+  const child = spawn(npxPath, ["-y", "@devness/useai", "daemon", "--port", String(DAEMON_PORT)], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  const start = Date.now();
+  while (Date.now() - start < 8e3) {
+    await new Promise((r) => setTimeout(r, 300));
+    if (await checkDaemonHealth())
+      return true;
+  }
+  return false;
+}
+var init_ensure = __esm({
+  "../shared/dist/daemon/ensure.js"() {
+    "use strict";
+    init_paths();
+    init_resolve_npx();
+  }
+});
+
+// ../shared/dist/daemon/autostart.js
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { dirname } from "path";
+function detectPlatform() {
+  switch (process.platform) {
+    case "darwin":
+      return "macos";
+    case "linux":
+      return "linux";
+    case "win32":
+      return "windows";
+    default:
+      return "unsupported";
+  }
+}
+function buildPlist(npxPath, nodePath) {
+  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>dev.useai.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${npxPath}</string>
+    <string>-y</string>
+    <string>@devness/useai</string>
+    <string>daemon</string>
+    <string>--port</string>
+    <string>${DAEMON_PORT}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${DAEMON_LOG_FILE}</string>
+  <key>StandardErrorPath</key>
+  <string>${DAEMON_LOG_FILE}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${nodePath}</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+function installMacos() {
+  const npxPath = resolveNpxPath();
+  const nodePath = buildNodePath();
+  mkdirSync2(dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+  writeFileSync2(LAUNCHD_PLIST_PATH, buildPlist(npxPath, nodePath));
+  try {
+    execSync2(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: "ignore" });
+  } catch {
+  }
+  execSync2(`launchctl load "${LAUNCHD_PLIST_PATH}"`, { stdio: "ignore" });
+}
+function removeMacos() {
+  try {
+    execSync2(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: "ignore" });
+  } catch {
+  }
+  try {
+    if (existsSync4(LAUNCHD_PLIST_PATH))
+      unlinkSync2(LAUNCHD_PLIST_PATH);
+  } catch {
+  }
+}
+function isMacosInstalled() {
+  return existsSync4(LAUNCHD_PLIST_PATH);
+}
+function buildSystemdUnit(npxPath, nodePath) {
+  return `[Unit]
+Description=UseAI Daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${npxPath} -y @devness/useai daemon --port ${DAEMON_PORT}
+Restart=on-failure
+RestartSec=10
+Environment=PATH=${nodePath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function installLinux() {
+  const npxPath = resolveNpxPath();
+  const nodePath = buildNodePath();
+  mkdirSync2(dirname(SYSTEMD_SERVICE_PATH), { recursive: true });
+  writeFileSync2(SYSTEMD_SERVICE_PATH, buildSystemdUnit(npxPath, nodePath));
+  execSync2("systemctl --user daemon-reload", { stdio: "ignore" });
+  execSync2("systemctl --user enable --now useai-daemon.service", { stdio: "ignore" });
+}
+function removeLinux() {
+  try {
+    execSync2("systemctl --user disable --now useai-daemon.service", { stdio: "ignore" });
+  } catch {
+  }
+  try {
+    if (existsSync4(SYSTEMD_SERVICE_PATH))
+      unlinkSync2(SYSTEMD_SERVICE_PATH);
+  } catch {
+  }
+  try {
+    execSync2("systemctl --user daemon-reload", { stdio: "ignore" });
+  } catch {
+  }
+}
+function isLinuxInstalled() {
+  return existsSync4(SYSTEMD_SERVICE_PATH);
+}
+function buildVbsScript(npxPath) {
+  return `Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run """${npxPath}"" -y @devness/useai daemon --port ${DAEMON_PORT}", 0, False
+`;
+}
+function installWindows() {
+  const npxPath = resolveNpxPath();
+  mkdirSync2(dirname(WINDOWS_STARTUP_SCRIPT_PATH), { recursive: true });
+  writeFileSync2(WINDOWS_STARTUP_SCRIPT_PATH, buildVbsScript(npxPath));
+}
+function removeWindows() {
+  try {
+    if (existsSync4(WINDOWS_STARTUP_SCRIPT_PATH))
+      unlinkSync2(WINDOWS_STARTUP_SCRIPT_PATH);
+  } catch {
+  }
+}
+function isWindowsInstalled() {
+  return existsSync4(WINDOWS_STARTUP_SCRIPT_PATH);
+}
+function installAutostart() {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos":
+      installMacos();
+      break;
+    case "linux":
+      installLinux();
+      break;
+    case "windows":
+      installWindows();
+      break;
+    case "unsupported":
+      throw new Error(`Auto-start is not supported on ${process.platform}`);
+  }
+}
+function removeAutostart() {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos":
+      removeMacos();
+      break;
+    case "linux":
+      removeLinux();
+      break;
+    case "windows":
+      removeWindows();
+      break;
+    case "unsupported":
+      break;
+  }
+}
+function isAutostartInstalled() {
+  const platform = detectPlatform();
+  switch (platform) {
+    case "macos":
+      return isMacosInstalled();
+    case "linux":
+      return isLinuxInstalled();
+    case "windows":
+      return isWindowsInstalled();
+    default:
+      return false;
+  }
+}
+var init_autostart = __esm({
+  "../shared/dist/daemon/autostart.js"() {
+    "use strict";
+    init_paths();
+    init_resolve_npx();
+  }
+});
+
+// ../shared/dist/daemon/index.js
+var init_daemon = __esm({
+  "../shared/dist/daemon/index.js"() {
+    "use strict";
+    init_resolve_npx();
+    init_ensure();
+    init_autostart();
+  }
+});
+
+// ../shared/dist/index.js
+var init_dist = __esm({
+  "../shared/dist/index.js"() {
+    "use strict";
+    init_types();
+    init_constants();
+    init_crypto();
+    init_validation();
+    init_utils();
+    init_daemon();
+  }
+});
+
+// src/session-state.ts
+import { appendFileSync, existsSync as existsSync5 } from "fs";
+import { join as join3 } from "path";
+var SessionState;
+var init_session_state = __esm({
+  "src/session-state.ts"() {
+    "use strict";
+    init_dist();
+    SessionState = class {
+      sessionId;
+      sessionStartTime;
+      heartbeatCount;
+      sessionRecordCount;
+      clientName;
+      sessionTaskType;
+      chainTipHash;
+      signingKey;
+      signingAvailable;
+      constructor() {
+        this.sessionId = generateSessionId();
+        this.sessionStartTime = Date.now();
+        this.heartbeatCount = 0;
+        this.sessionRecordCount = 0;
+        this.clientName = "unknown";
+        this.sessionTaskType = "coding";
+        this.chainTipHash = GENESIS_HASH;
+        this.signingKey = null;
+        this.signingAvailable = false;
+      }
+      reset() {
+        this.sessionStartTime = Date.now();
+        this.sessionId = generateSessionId();
+        this.heartbeatCount = 0;
+        this.sessionRecordCount = 0;
+        this.chainTipHash = GENESIS_HASH;
+        this.clientName = "unknown";
+        this.sessionTaskType = "coding";
+      }
+      setClient(name) {
+        this.clientName = name;
+      }
+      setTaskType(type) {
+        this.sessionTaskType = type;
+      }
+      incrementHeartbeat() {
+        this.heartbeatCount++;
+      }
+      getSessionDuration() {
+        return Math.round((Date.now() - this.sessionStartTime) / 1e3);
+      }
+      initializeKeystore() {
+        ensureDir();
+        if (existsSync5(KEYSTORE_FILE)) {
+          const ks = readJson(KEYSTORE_FILE, null);
+          if (ks) {
+            try {
+              this.signingKey = decryptKeystore(ks);
+              this.signingAvailable = true;
+              return;
+            } catch {
+            }
+          }
+        }
+        const result = generateKeystore();
+        writeJson(KEYSTORE_FILE, result.keystore);
+        this.signingKey = result.signingKey;
+        this.signingAvailable = true;
+      }
+      /** Path to this session's chain file in the active directory */
+      sessionChainPath() {
+        return join3(ACTIVE_DIR, `${this.sessionId}.jsonl`);
+      }
+      appendToChain(type, data) {
+        const record = buildChainRecord(type, this.sessionId, data, this.chainTipHash, this.signingKey);
+        ensureDir();
+        appendFileSync(this.sessionChainPath(), JSON.stringify(record) + "\n", "utf-8");
+        this.chainTipHash = record.hash;
+        this.sessionRecordCount++;
+        return record;
+      }
+    };
+  }
+});
+
+// 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";
+function getConfig() {
+  return readJson(CONFIG_FILE, {
+    milestone_tracking: true,
+    auto_sync: true
+  });
+}
+function getSessions() {
+  return readJson(SESSIONS_FILE, []);
+}
+function getMilestones() {
+  return readJson(MILESTONES_FILE, []);
+}
+function registerTools(server2, session2) {
+  server2.tool(
+    "useai_session_start",
+    "Start tracking an AI coding session. Call this at the beginning of a conversation.",
+    {
+      task_type: z2.enum(["coding", "debugging", "testing", "planning", "reviewing", "documenting", "learning", "other"]).optional().describe("What kind of task is the developer working on?")
+    },
+    async ({ task_type }) => {
+      session2.reset();
+      session2.setClient(detectClient());
+      session2.setTaskType(task_type ?? "coding");
+      const record = session2.appendToChain("session_start", {
+        client: session2.clientName,
+        task_type: session2.sessionTaskType,
+        version: VERSION
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `useai session started \u2014 tracking ${session2.sessionTaskType} session on ${session2.clientName}.
+Session: ${session2.sessionId.slice(0, 8)} \xB7 Chain: ${record.hash.slice(0, 12)} (${session2.signingAvailable ? "signed" : "unsigned"})`
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "useai_heartbeat",
+    "Record a heartbeat for the current AI coding session. Call this periodically during long conversations (every 10-15 minutes).",
+    {},
+    async () => {
+      session2.incrementHeartbeat();
+      session2.appendToChain("heartbeat", {
+        heartbeat_number: session2.heartbeatCount,
+        cumulative_seconds: session2.getSessionDuration()
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Heartbeat recorded. Session active for ${formatDuration(session2.getSessionDuration())}.`
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "useai_session_end",
+    "End the current AI coding session and record milestones. IMPORTANT: Milestone descriptions must be GENERIC \u2014 no project names, file names, file paths, or company names. Use general terms like 'authentication system', 'data validation layer', 'responsive dashboard'.",
+    {
+      task_type: z2.enum(["coding", "debugging", "testing", "planning", "reviewing", "documenting", "learning", "other"]).optional().describe("What kind of task was the developer working on?"),
+      languages: z2.array(z2.string()).optional().describe("Programming languages used (e.g. ['typescript', 'python'])"),
+      files_touched_count: z2.number().optional().describe("Approximate number of files created or modified (count only, no names)"),
+      milestones: z2.array(z2.object({
+        title: z2.string().describe("Generic description of what was accomplished. PRIVACY RULES: Do NOT include project names, repository names, file names, file paths, API endpoints, database names, company names, or any project-specific details. Use generic terms only. GOOD examples: 'Implemented user authentication', 'Fixed race condition in background worker', 'Added unit tests for data validation', 'Refactored state management layer', 'Built responsive dashboard layout'. BAD examples: 'Fixed bug in /api/stripe/webhooks', 'Added auth to acme-corp project', 'Updated UserService.ts in src/services/'"),
+        category: z2.enum(["feature", "bugfix", "refactor", "test", "docs", "setup", "deployment", "other"]).describe("Type of work completed"),
+        complexity: z2.enum(["simple", "medium", "complex"]).optional().describe("How complex was this task?")
+      })).optional().describe("What was accomplished this session? List each distinct piece of work completed. Describe generically \u2014 no project names, file names, or proprietary details.")
+    },
+    async ({ task_type, languages, files_touched_count, milestones: milestonesInput }) => {
+      const duration = session2.getSessionDuration();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const finalTaskType = task_type ?? session2.sessionTaskType;
+      const chainStartHash = session2.chainTipHash === "GENESIS" ? "GENESIS" : session2.chainTipHash;
+      const endRecord = session2.appendToChain("session_end", {
+        duration_seconds: duration,
+        task_type: finalTaskType,
+        languages: languages ?? [],
+        files_touched: files_touched_count ?? 0,
+        heartbeat_count: session2.heartbeatCount
+      });
+      const sealData = JSON.stringify({
+        session_id: session2.sessionId,
+        client: session2.clientName,
+        task_type: finalTaskType,
+        languages: languages ?? [],
+        files_touched: files_touched_count ?? 0,
+        started_at: new Date(session2.sessionStartTime).toISOString(),
+        ended_at: now,
+        duration_seconds: duration,
+        heartbeat_count: session2.heartbeatCount,
+        record_count: session2.sessionRecordCount,
+        chain_end_hash: endRecord.hash
+      });
+      const sealSignature = signHash(
+        createHash3("sha256").update(sealData).digest("hex"),
+        session2.signingKey
+      );
+      session2.appendToChain("session_seal", {
+        seal: sealData,
+        seal_signature: sealSignature
+      });
+      const activePath = join4(ACTIVE_DIR, `${session2.sessionId}.jsonl`);
+      const sealedPath = join4(SEALED_DIR, `${session2.sessionId}.jsonl`);
+      try {
+        if (existsSync6(activePath)) {
+          renameSync2(activePath, sealedPath);
+        }
+      } catch {
+      }
+      const seal = {
+        session_id: session2.sessionId,
+        client: session2.clientName,
+        task_type: finalTaskType,
+        languages: languages ?? [],
+        files_touched: files_touched_count ?? 0,
+        started_at: new Date(session2.sessionStartTime).toISOString(),
+        ended_at: now,
+        duration_seconds: duration,
+        heartbeat_count: session2.heartbeatCount,
+        record_count: session2.sessionRecordCount,
+        chain_start_hash: chainStartHash,
+        chain_end_hash: endRecord.hash,
+        seal_signature: sealSignature
+      };
+      const sessions2 = getSessions();
+      sessions2.push(seal);
+      writeJson(SESSIONS_FILE, sessions2);
+      let milestoneCount = 0;
+      if (milestonesInput && milestonesInput.length > 0) {
+        const config = getConfig();
+        if (config.milestone_tracking) {
+          const durationMinutes = Math.round(duration / 60);
+          const allMilestones = getMilestones();
+          for (const m of milestonesInput) {
+            const record = session2.appendToChain("milestone", {
+              title: m.title,
+              category: m.category,
+              complexity: m.complexity ?? "medium",
+              duration_minutes: durationMinutes,
+              languages: languages ?? []
+            });
+            const milestone = {
+              id: `m_${randomUUID3().slice(0, 8)}`,
+              session_id: session2.sessionId,
+              title: m.title,
+              category: m.category,
+              complexity: m.complexity ?? "medium",
+              duration_minutes: durationMinutes,
+              languages: languages ?? [],
+              client: session2.clientName,
+              created_at: (/* @__PURE__ */ new Date()).toISOString(),
+              published: false,
+              published_at: null,
+              chain_hash: record.hash
+            };
+            allMilestones.push(milestone);
+            milestoneCount++;
+          }
+          writeJson(MILESTONES_FILE, allMilestones);
+        }
+      }
+      const durationStr = formatDuration(duration);
+      const langStr = languages && languages.length > 0 ? ` using ${languages.join(", ")}` : "";
+      const milestoneStr = milestoneCount > 0 ? ` \xB7 ${milestoneCount} milestone${milestoneCount > 1 ? "s" : ""} recorded` : "";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Session ended: ${durationStr} ${finalTaskType}${langStr}${milestoneStr}`
+          }
+        ]
+      };
+    }
+  );
+}
+var init_register_tools = __esm({
+  "src/register-tools.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// 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 { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function installStandardHttp(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["mcpServers"] ?? {};
+  delete servers["useai"];
+  servers["UseAI"] = { ...MCP_HTTP_ENTRY };
+  config["mcpServers"] = servers;
+  writeJsonFile(configPath, config);
+}
+function installVscodeHttp(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["servers"] ?? {};
+  delete servers["useai"];
+  servers["UseAI"] = { type: "http", url: MCP_HTTP_URL };
+  config["servers"] = servers;
+  writeJsonFile(configPath, config);
+}
 function hasBinary(name) {
   try {
-    execSync(`which ${name}`, { stdio: "ignore" });
+    execSync3(`which ${name}`, { stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
 function readJsonFile(path) {
-  if (!existsSync3(path)) return {};
+  if (!existsSync7(path)) return {};
   try {
-    const raw = readFileSync2(path, "utf-8").trim();
+    const raw = readFileSync3(path, "utf-8").trim();
     if (!raw) return {};
     return JSON.parse(raw);
   } catch {
@@ -35,8 +1137,8 @@ function readJsonFile(path) {
   }
 }
 function writeJsonFile(path, data) {
-  mkdirSync2(dirname(path), { recursive: true });
-  writeFileSync2(path, JSON.stringify(data, null, 2) + "\n");
+  mkdirSync3(dirname2(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify(data, null, 2) + "\n");
 }
 function isConfiguredStandard(configPath) {
   const config = readJsonFile(configPath);
@@ -117,9 +1219,9 @@ function removeZed(configPath) {
   }
 }
 function readTomlFile(path) {
-  if (!existsSync3(path)) return {};
+  if (!existsSync7(path)) return {};
   try {
-    const raw = readFileSync2(path, "utf-8").trim();
+    const raw = readFileSync3(path, "utf-8").trim();
     if (!raw) return {};
     return parseToml(raw);
   } catch {
@@ -127,8 +1229,8 @@ function readTomlFile(path) {
   }
 }
 function writeTomlFile(path, data) {
-  mkdirSync2(dirname(path), { recursive: true });
-  writeFileSync2(path, stringifyToml(data) + "\n");
+  mkdirSync3(dirname2(path), { recursive: true });
+  writeFileSync3(path, stringifyToml(data) + "\n");
 }
 function isConfiguredToml(configPath) {
   const config = readTomlFile(configPath);
@@ -156,9 +1258,9 @@ function removeToml(configPath) {
   }
 }
 function readYamlFile(path) {
-  if (!existsSync3(path)) return {};
+  if (!existsSync7(path)) return {};
   try {
-    const raw = readFileSync2(path, "utf-8").trim();
+    const raw = readFileSync3(path, "utf-8").trim();
     if (!raw) return {};
     return parseYaml(raw) ?? {};
   } catch {
@@ -166,8 +1268,8 @@ function readYamlFile(path) {
   }
 }
 function writeYamlFile(path, data) {
-  mkdirSync2(dirname(path), { recursive: true });
-  writeFileSync2(path, stringifyYaml(data));
+  mkdirSync3(dirname2(path), { recursive: true });
+  writeFileSync3(path, stringifyYaml(data));
 }
 function isConfiguredYaml(configPath) {
   const config = readYamlFile(configPath);
@@ -201,59 +1303,61 @@ function removeYaml(configPath) {
   }
 }
 function hasInstructionsBlock(filePath) {
-  if (!existsSync3(filePath)) return false;
+  if (!existsSync7(filePath)) return false;
   try {
-    return readFileSync2(filePath, "utf-8").includes(INSTRUCTIONS_START);
+    return readFileSync3(filePath, "utf-8").includes(INSTRUCTIONS_START);
   } catch {
     return false;
   }
 }
 function injectInstructions(config) {
-  mkdirSync2(dirname(config.path), { recursive: true });
+  mkdirSync3(dirname2(config.path), { recursive: true });
   if (config.method === "create") {
-    writeFileSync2(config.path, USEAI_INSTRUCTIONS + "\n");
+    writeFileSync3(config.path, USEAI_INSTRUCTIONS + "\n");
     return;
   }
   if (hasInstructionsBlock(config.path)) return;
   let existing = "";
-  if (existsSync3(config.path)) {
-    existing = readFileSync2(config.path, "utf-8");
+  if (existsSync7(config.path)) {
+    existing = readFileSync3(config.path, "utf-8");
   }
   const separator = existing && !existing.endsWith("\n") ? "\n\n" : existing ? "\n" : "";
-  writeFileSync2(config.path, existing + separator + USEAI_INSTRUCTIONS_BLOCK + "\n");
+  writeFileSync3(config.path, existing + separator + USEAI_INSTRUCTIONS_BLOCK + "\n");
 }
 function removeInstructions(config) {
   if (config.method === "create") {
-    if (existsSync3(config.path)) {
+    if (existsSync7(config.path)) {
       try {
-        unlinkSync(config.path);
+        unlinkSync3(config.path);
       } catch {
       }
     }
     return;
   }
-  if (!existsSync3(config.path)) return;
+  if (!existsSync7(config.path)) return;
   try {
-    const content = readFileSync2(config.path, "utf-8");
+    const content = readFileSync3(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) {
-      writeFileSync2(config.path, cleaned + "\n");
+      writeFileSync3(config.path, cleaned + "\n");
     } else {
-      unlinkSync(config.path);
+      unlinkSync3(config.path);
     }
   } catch {
   }
 }
 function createTool(def) {
   const handler = formatHandlers[def.configFormat];
+  const urlSupported = def.supportsUrl ?? false;
   return {
     id: def.id,
     name: def.name,
     configFormat: def.configFormat,
+    supportsUrl: urlSupported,
     getConfigPath: () => def.configPath,
     detect: def.detect,
     isConfigured: () => handler.isConfigured(def.configPath),
@@ -261,6 +1365,16 @@ function createTool(def) {
       handler.install(def.configPath);
       if (def.instructions) injectInstructions(def.instructions);
     },
+    installHttp: () => {
+      if (def.configFormat === "vscode") {
+        installVscodeHttp(def.configPath);
+      } else if (def.configFormat === "standard") {
+        installStandardHttp(def.configPath);
+      } else {
+        handler.install(def.configPath);
+      }
+      if (def.instructions) injectInstructions(def.instructions);
+    },
     remove: () => {
       handler.remove(def.configPath);
       if (def.instructions) removeInstructions(def.instructions);
@@ -289,10 +1403,11 @@ function resolveTools(names) {
   }
   return { matched, unmatched };
 }
-var USEAI_INSTRUCTIONS_TEXT, MCP_ENTRY, home, INSTRUCTIONS_START, INSTRUCTIONS_END, USEAI_INSTRUCTIONS, USEAI_INSTRUCTIONS_BLOCK, formatHandlers, appSupport, AI_TOOLS;
+var USEAI_INSTRUCTIONS_TEXT, MCP_ENTRY, MCP_HTTP_URL, MCP_HTTP_ENTRY, home, INSTRUCTIONS_START, INSTRUCTIONS_END, USEAI_INSTRUCTIONS, USEAI_INSTRUCTIONS_BLOCK, formatHandlers, appSupport, AI_TOOLS;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
+    init_dist();
     USEAI_INSTRUCTIONS_TEXT = [
       "## UseAI Session Tracking",
       "- At the START of every conversation, call `useai_session_start` with the appropriate task_type.",
@@ -303,7 +1418,9 @@ var init_tools = __esm({
       command: "npx",
       args: ["-y", "@devness/useai"]
     };
-    home = homedir2();
+    MCP_HTTP_URL = DAEMON_MCP_URL;
+    MCP_HTTP_ENTRY = { url: MCP_HTTP_URL };
+    home = homedir3();
     INSTRUCTIONS_START = "<!-- useai:start -->";
     INSTRUCTIONS_END = "<!-- useai:end -->";
     USEAI_INSTRUCTIONS = [
@@ -322,69 +1439,75 @@ ${INSTRUCTIONS_END}`;
       toml: { isConfigured: isConfiguredToml, install: installToml, remove: removeToml },
       yaml: { isConfigured: isConfiguredYaml, install: installYaml, remove: removeYaml }
     };
-    appSupport = join3(home, "Library", "Application Support");
+    appSupport = join5(home, "Library", "Application Support");
     AI_TOOLS = [
       createTool({
         id: "claude-code",
         name: "Claude Code",
         configFormat: "standard",
-        configPath: join3(home, ".claude.json"),
-        detect: () => hasBinary("claude") || existsSync3(join3(home, ".claude.json")),
-        instructions: { method: "append", path: join3(home, ".claude", "CLAUDE.md") }
+        configPath: join5(home, ".claude.json"),
+        detect: () => hasBinary("claude") || existsSync7(join5(home, ".claude.json")),
+        instructions: { method: "append", path: join5(home, ".claude", "CLAUDE.md") },
+        supportsUrl: true
       }),
       createTool({
         id: "cursor",
         name: "Cursor",
         configFormat: "standard",
-        configPath: join3(home, ".cursor", "mcp.json"),
-        detect: () => existsSync3(join3(home, ".cursor")),
-        manualHint: "Open Cursor Settings \u2192 Rules \u2192 User Rules and paste the instructions below."
+        configPath: join5(home, ".cursor", "mcp.json"),
+        detect: () => existsSync7(join5(home, ".cursor")),
+        manualHint: "Open Cursor Settings \u2192 Rules \u2192 User Rules and paste the instructions below.",
+        supportsUrl: true
       }),
       createTool({
         id: "windsurf",
         name: "Windsurf",
         configFormat: "standard",
-        configPath: join3(home, ".codeium", "windsurf", "mcp_config.json"),
-        detect: () => existsSync3(join3(home, ".codeium", "windsurf")),
-        instructions: { method: "append", path: join3(home, ".codeium", "windsurf", "memories", "global_rules.md") }
+        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") },
+        supportsUrl: true
       }),
       createTool({
         id: "vscode",
         name: "VS Code",
         configFormat: "vscode",
-        configPath: join3(appSupport, "Code", "User", "mcp.json"),
-        detect: () => existsSync3(join3(appSupport, "Code")),
-        instructions: { method: "create", path: join3(appSupport, "Code", "User", "prompts", "useai.instructions.md") }
+        configPath: join5(appSupport, "Code", "User", "mcp.json"),
+        detect: () => existsSync7(join5(appSupport, "Code")),
+        instructions: { method: "create", path: join5(appSupport, "Code", "User", "prompts", "useai.instructions.md") },
+        supportsUrl: true
       }),
       createTool({
         id: "vscode-insiders",
         name: "VS Code Insiders",
         configFormat: "vscode",
-        configPath: join3(appSupport, "Code - Insiders", "User", "mcp.json"),
-        detect: () => existsSync3(join3(appSupport, "Code - Insiders")),
-        instructions: { method: "create", path: join3(appSupport, "Code - Insiders", "User", "prompts", "useai.instructions.md") }
+        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") },
+        supportsUrl: true
       }),
       createTool({
         id: "gemini-cli",
         name: "Gemini CLI",
         configFormat: "standard",
-        configPath: join3(home, ".gemini", "settings.json"),
+        configPath: join5(home, ".gemini", "settings.json"),
         detect: () => hasBinary("gemini"),
-        instructions: { method: "append", path: join3(home, ".gemini", "GEMINI.md") }
+        instructions: { method: "append", path: join5(home, ".gemini", "GEMINI.md") },
+        supportsUrl: true
       }),
       createTool({
         id: "zed",
         name: "Zed",
         configFormat: "zed",
-        configPath: join3(appSupport, "Zed", "settings.json"),
-        detect: () => existsSync3(join3(appSupport, "Zed")),
+        configPath: join5(appSupport, "Zed", "settings.json"),
+        detect: () => existsSync7(join5(appSupport, "Zed")),
         manualHint: "Open Rules Library (\u2318\u2325L) \u2192 click + \u2192 paste the instructions below."
       }),
       createTool({
         id: "cline",
         name: "Cline",
         configFormat: "standard",
-        configPath: join3(
+        configPath: join5(
           appSupport,
           "Code",
           "User",
@@ -393,16 +1516,17 @@ ${INSTRUCTIONS_END}`;
           "settings",
           "cline_mcp_settings.json"
         ),
-        detect: () => existsSync3(
-          join3(appSupport, "Code", "User", "globalStorage", "saoudrizwan.claude-dev")
+        detect: () => existsSync7(
+          join5(appSupport, "Code", "User", "globalStorage", "saoudrizwan.claude-dev")
         ),
-        instructions: { method: "create", path: join3(home, "Documents", "Cline", "Rules", "useai.md") }
+        instructions: { method: "create", path: join5(home, "Documents", "Cline", "Rules", "useai.md") },
+        supportsUrl: true
       }),
       createTool({
         id: "roo-code",
         name: "Roo Code",
         configFormat: "standard",
-        configPath: join3(
+        configPath: join5(
           appSupport,
           "Code",
           "User",
@@ -411,57 +1535,59 @@ ${INSTRUCTIONS_END}`;
           "settings",
           "cline_mcp_settings.json"
         ),
-        detect: () => existsSync3(
-          join3(appSupport, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline")
+        detect: () => existsSync7(
+          join5(appSupport, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline")
         ),
-        instructions: { method: "create", path: join3(home, ".roo", "rules", "useai.md") }
+        instructions: { method: "create", path: join5(home, ".roo", "rules", "useai.md") },
+        supportsUrl: true
       }),
       createTool({
         id: "amazon-q-cli",
         name: "Amazon Q CLI",
         configFormat: "standard",
-        configPath: join3(home, ".aws", "amazonq", "mcp.json"),
-        detect: () => hasBinary("q") || existsSync3(join3(home, ".aws", "amazonq")),
+        configPath: join5(home, ".aws", "amazonq", "mcp.json"),
+        detect: () => hasBinary("q") || existsSync7(join5(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: join3(home, ".aws", "amazonq", "default.json"),
-        detect: () => existsSync3(join3(home, ".amazonq")) || existsSync3(join3(home, ".aws", "amazonq")),
+        configPath: join5(home, ".aws", "amazonq", "default.json"),
+        detect: () => existsSync7(join5(home, ".amazonq")) || existsSync7(join5(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: join3(home, ".codex", "config.toml"),
-        detect: () => hasBinary("codex") || existsSync3(join3(home, ".codex")) || existsSync3("/Applications/Codex.app"),
-        instructions: { method: "append", path: join3(home, ".codex", "AGENTS.md") }
+        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") }
       }),
       createTool({
         id: "goose",
         name: "Goose",
         configFormat: "yaml",
-        configPath: join3(home, ".config", "goose", "config.yaml"),
-        detect: () => existsSync3(join3(home, ".config", "goose")),
-        instructions: { method: "append", path: join3(home, ".config", "goose", ".goosehints") }
+        configPath: join5(home, ".config", "goose", "config.yaml"),
+        detect: () => existsSync7(join5(home, ".config", "goose")),
+        instructions: { method: "append", path: join5(home, ".config", "goose", ".goosehints") }
       }),
       createTool({
         id: "opencode",
         name: "OpenCode",
         configFormat: "standard",
-        configPath: join3(home, ".config", "opencode", "opencode.json"),
-        detect: () => hasBinary("opencode") || existsSync3(join3(home, ".config", "opencode")),
-        instructions: { method: "append", path: join3(home, ".config", "opencode", "AGENTS.md") }
+        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") },
+        supportsUrl: true
       }),
       createTool({
         id: "junie",
         name: "Junie",
         configFormat: "standard",
-        configPath: join3(home, ".junie", "mcp", "mcp.json"),
-        detect: () => existsSync3(join3(home, ".junie")),
+        configPath: join5(home, ".junie", "mcp", "mcp.json"),
+        detect: () => existsSync7(join5(home, ".junie")),
         manualHint: "Add the instructions below to .junie/guidelines.md in your project root."
       })
     ];
@@ -531,7 +1657,59 @@ function showStatus(tools) {
   console.log(rows.join("\n"));
   console.log();
 }
-async function installFlow(tools, autoYes, explicit) {
+async function daemonInstallFlow(tools, explicit) {
+  console.log(dim("Ensuring UseAI daemon is running..."));
+  const daemonOk = await ensureDaemon();
+  let useDaemon = true;
+  if (daemonOk) {
+    console.log(ok(`\u2713 Daemon running on port ${DAEMON_PORT}`));
+  } else {
+    useDaemon = false;
+    console.log(err("\u2717 Could not start daemon \u2014 falling back to stdio config"));
+    console.log(dim(`(Run with --foreground to debug: npx @devness/useai daemon --port ${DAEMON_PORT})`));
+  }
+  if (useDaemon) {
+    const platform = detectPlatform();
+    if (platform !== "unsupported") {
+      try {
+        installAutostart();
+        console.log(ok(`\u2713 Auto-start service installed (${platform})`));
+      } catch {
+        console.log(chalk.yellow(`  \u26A0 Could not install auto-start service`));
+      }
+    }
+  }
+  const targetTools = explicit ? tools : tools.filter((t) => t.detect());
+  if (targetTools.length === 0) {
+    console.log(err("\n  No AI tools detected on this machine."));
+    return;
+  }
+  let configuredCount = 0;
+  console.log();
+  for (const tool of targetTools) {
+    try {
+      if (useDaemon && tool.supportsUrl) {
+        tool.installHttp();
+        console.log(ok(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk.dim("HTTP (daemon)")}`));
+      } else if (useDaemon && !tool.supportsUrl) {
+        tool.install();
+        console.log(ok(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk.dim("stdio (no URL support)")}`));
+      } else {
+        tool.install();
+        console.log(ok(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk.dim("stdio")}`));
+      }
+      configuredCount++;
+    } catch (e) {
+      console.log(err(`\u2717 ${tool.name.padEnd(18)} \u2014 ${e.message}`));
+    }
+  }
+  showManualHints(targetTools);
+  const mode = useDaemon ? "daemon mode" : "stdio mode";
+  console.log(`
+  Done! UseAI configured in ${chalk.bold(String(configuredCount))} tool${configuredCount === 1 ? "" : "s"} (${mode}).
+`);
+}
+async function stdioInstallFlow(tools, autoYes, explicit) {
   if (explicit) {
     console.log();
     for (const tool of tools) {
@@ -618,9 +1796,9 @@ async function installFlow(tools, autoYes, explicit) {
   Done! UseAI MCP server configured in ${chalk.bold(String(toInstall.length))} tool${toInstall.length === 1 ? "" : "s"}.
 `);
 }
-async function removeFlow(tools, autoYes, explicit) {
+async function fullRemoveFlow(tools, autoYes, explicit) {
   if (explicit) {
-    const toRemove2 = tools.filter((t) => {
+    const toRemove = tools.filter((t) => {
       try {
         return t.isConfigured();
       } catch {
@@ -637,83 +1815,98 @@ async function removeFlow(tools, autoYes, explicit) {
     for (const tool of notConfigured) {
       console.log(dim(`${tool.name} is not configured \u2014 skipping.`));
     }
-    if (toRemove2.length === 0) return;
-    console.log();
-    for (const tool of toRemove2) {
-      try {
-        tool.remove();
-        console.log(ok(`\u2713 Removed from ${tool.name}`));
-      } catch (e) {
-        console.log(err(`\u2717 ${tool.name} \u2014 ${e.message}`));
+    if (toRemove.length > 0) {
+      console.log();
+      for (const tool of toRemove) {
+        try {
+          tool.remove();
+          console.log(ok(`\u2713 Removed from ${tool.name}`));
+        } catch (e) {
+          console.log(err(`\u2717 ${tool.name} \u2014 ${e.message}`));
+        }
       }
     }
-    console.log();
-    return;
-  }
-  const configured = tools.filter((t) => {
-    try {
-      return t.isConfigured();
-    } catch {
-      return false;
-    }
-  });
-  if (configured.length === 0) {
-    console.log(dim("UseAI is not configured in any AI tools."));
-    return;
-  }
-  console.log(`
+  } else {
+    const configured = tools.filter((t) => {
+      try {
+        return t.isConfigured();
+      } catch {
+        return false;
+      }
+    });
+    if (configured.length === 0) {
+      console.log(dim("UseAI is not configured in any AI tools."));
+    } else {
+      console.log(`
   Found UseAI configured in ${chalk.bold(String(configured.length))} tool${configured.length === 1 ? "" : "s"}:
 `);
-  let toRemove;
-  if (autoYes) {
-    toRemove = configured;
-  } else {
-    let selected;
-    try {
-      selected = await checkbox({
-        message: "Select tools to remove UseAI from:",
-        choices: configured.map((t) => ({
-          name: t.name,
-          value: t.id,
-          checked: true
-        }))
-      });
-    } catch {
-      console.log("\n");
-      return;
+      let toRemove;
+      if (autoYes) {
+        toRemove = configured;
+      } else {
+        let selected;
+        try {
+          selected = await checkbox({
+            message: "Select tools to remove UseAI from:",
+            choices: configured.map((t) => ({
+              name: t.name,
+              value: t.id,
+              checked: true
+            }))
+          });
+        } catch {
+          console.log("\n");
+          return;
+        }
+        toRemove = configured.filter((t) => selected.includes(t.id));
+      }
+      if (toRemove.length === 0) {
+        console.log(dim("No tools selected."));
+      } else {
+        console.log(`
+  Removing from ${toRemove.length} tool${toRemove.length === 1 ? "" : "s"}...
+`);
+        for (const tool of toRemove) {
+          try {
+            tool.remove();
+            console.log(ok(`\u2713 Removed from ${tool.name}`));
+          } catch (e) {
+            console.log(err(`\u2717 ${tool.name} \u2014 ${e.message}`));
+          }
+        }
+      }
     }
-    toRemove = configured.filter((t) => selected.includes(t.id));
   }
-  if (toRemove.length === 0) {
-    console.log(dim("No tools selected."));
-    return;
+  console.log();
+  try {
+    await killDaemon();
+    console.log(ok("\u2713 Daemon stopped"));
+  } catch {
+    console.log(dim("Daemon was not running"));
   }
-  console.log(`
-  Removing from ${toRemove.length} tool${toRemove.length === 1 ? "" : "s"}...
-`);
-  for (const tool of toRemove) {
+  if (isAutostartInstalled()) {
     try {
-      tool.remove();
-      console.log(ok(`\u2713 Removed from ${tool.name}`));
-    } catch (e) {
-      console.log(err(`\u2717 ${tool.name} \u2014 ${e.message}`));
+      removeAutostart();
+      console.log(ok("\u2713 Auto-start service removed"));
+    } catch {
+      console.log(err("\u2717 Failed to remove auto-start service"));
     }
   }
-  console.log(`
-  Done! UseAI removed from ${chalk.bold(String(toRemove.length))} tool${toRemove.length === 1 ? "" : "s"}.
-`);
+  console.log(dim("\nDone! UseAI fully removed.\n"));
 }
 function showHelp() {
   console.log(`
   ${chalk.bold("Usage:")} npx @devness/useai mcp [tools...] [options]
 
   Configure UseAI MCP server in your AI tools.
+  Default: starts daemon, installs auto-start, configures tools with HTTP.
 
   ${chalk.bold("Arguments:")}
     tools       Specific tool names (e.g. codex cursor vscode)
 
   ${chalk.bold("Options:")}
-    --remove    Remove UseAI from configured tools
+    --stdio     Use stdio config (legacy mode for containers/CI)
+    --remove    Remove UseAI from configured tools, stop daemon, remove auto-start
     --status    Show configuration status without modifying
     -y, --yes   Skip confirmation, auto-select all detected tools
     -h, --help  Show this help message
@@ -728,6 +1921,7 @@ async function runSetup(args) {
   }
   const isRemove = flags.has("--remove");
   const isStatus = flags.has("--status");
+  const isStdio = flags.has("--stdio");
   const autoYes = flags.has("-y") || flags.has("--yes");
   const explicit = toolNames.length > 0;
   let tools = AI_TOOLS;
@@ -743,513 +1937,312 @@ async function runSetup(args) {
   if (isStatus) {
     showStatus(tools);
   } else if (isRemove) {
-    await removeFlow(tools, autoYes, explicit);
+    await fullRemoveFlow(tools, autoYes, explicit);
+  } else if (isStdio) {
+    await stdioInstallFlow(tools, autoYes, explicit);
   } else {
-    await installFlow(tools, autoYes, explicit);
+    await daemonInstallFlow(tools, explicit);
   }
 }
 var init_setup = __esm({
   "src/setup.ts"() {
     "use strict";
+    init_dist();
     init_tools();
   }
 });
 
-// src/index.ts
+// src/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  startDaemon: () => startDaemon
+});
+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 { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z2 } from "zod";
-import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync4, renameSync as renameSync2 } from "fs";
-import { join as join4 } from "path";
-
-// ../shared/dist/constants/paths.js
-import { join } from "path";
-import { homedir } from "os";
-var USEAI_DIR = join(homedir(), ".useai");
-var DATA_DIR = join(USEAI_DIR, "data");
-var ACTIVE_DIR = join(DATA_DIR, "active");
-var SEALED_DIR = join(DATA_DIR, "sealed");
-var KEYSTORE_FILE = join(USEAI_DIR, "keystore.json");
-var CONFIG_FILE = join(USEAI_DIR, "config.json");
-var SESSIONS_FILE = join(DATA_DIR, "sessions.json");
-var MILESTONES_FILE = join(DATA_DIR, "milestones.json");
-
-// ../shared/dist/constants/version.js
-var VERSION = "0.3.0";
-
-// ../shared/dist/constants/clients.js
-var AI_CLIENT_ENV_VARS = {
-  CURSOR_EDITOR: "cursor",
-  WINDSURF_EDITOR: "windsurf",
-  CLAUDE_CODE: "claude-code",
-  VSCODE_PID: "vscode",
-  CODEX_CLI: "codex",
-  GEMINI_CLI: "gemini-cli",
-  JETBRAINS_IDE: "jetbrains",
-  ZED_EDITOR: "zed"
-};
-
-// ../shared/dist/constants/defaults.js
-var GENESIS_HASH = "GENESIS";
-
-// ../shared/dist/crypto/keystore.js
-import { generateKeyPairSync, randomBytes, createCipheriv, createDecipheriv, createPrivateKey } from "crypto";
-
-// ../shared/dist/crypto/derive.js
-import { pbkdf2Sync } from "crypto";
-import { hostname, userInfo } from "os";
-function deriveEncryptionKey(salt) {
-  const machineData = `${hostname()}:${userInfo().username}:useai-keystore`;
-  return pbkdf2Sync(machineData, salt, 1e5, 32, "sha256");
-}
-
-// ../shared/dist/crypto/keystore.js
-function decryptKeystore(ks) {
-  const salt = Buffer.from(ks.salt, "hex");
-  const iv = Buffer.from(ks.iv, "hex");
-  const tag = Buffer.from(ks.tag, "hex");
-  const encrypted = Buffer.from(ks.encrypted_private_key, "hex");
-  const encKey = deriveEncryptionKey(salt);
-  const decipher = createDecipheriv("aes-256-gcm", encKey, iv);
-  decipher.setAuthTag(tag);
-  const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
-  return createPrivateKey(decrypted.toString("utf-8"));
-}
-function generateKeystore() {
-  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
-  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" });
-  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" });
-  const salt = randomBytes(32);
-  const encKey = deriveEncryptionKey(salt);
-  const iv = randomBytes(12);
-  const cipher = createCipheriv("aes-256-gcm", encKey, iv);
-  const encrypted = Buffer.concat([cipher.update(privateKeyPem, "utf-8"), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  const keystore = {
-    public_key_pem: publicKeyPem,
-    encrypted_private_key: encrypted.toString("hex"),
-    iv: iv.toString("hex"),
-    tag: tag.toString("hex"),
-    salt: salt.toString("hex"),
-    created_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  return { keystore, signingKey: privateKey };
-}
-
-// ../shared/dist/crypto/chain.js
-import { createHash, sign as cryptoSign, randomUUID } from "crypto";
-function computeHash(recordJson, prevHash) {
-  return createHash("sha256").update(recordJson + prevHash).digest("hex");
-}
-function signHash(hash, signingKey2) {
-  if (!signingKey2)
-    return "unsigned";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+function autoSealSession(active) {
+  const { session: session2 } = active;
+  if (session2.sessionRecordCount === 0) return;
+  const duration = session2.getSessionDuration();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const endRecord = session2.appendToChain("session_end", {
+    duration_seconds: duration,
+    task_type: session2.sessionTaskType,
+    languages: [],
+    files_touched: 0,
+    heartbeat_count: session2.heartbeatCount,
+    auto_sealed: true
+  });
+  const sealData = JSON.stringify({
+    session_id: session2.sessionId,
+    client: session2.clientName,
+    task_type: session2.sessionTaskType,
+    languages: [],
+    files_touched: 0,
+    started_at: new Date(session2.sessionStartTime).toISOString(),
+    ended_at: now,
+    duration_seconds: duration,
+    heartbeat_count: session2.heartbeatCount,
+    record_count: session2.sessionRecordCount,
+    chain_end_hash: endRecord.hash
+  });
+  const sealSignature = signHash(
+    createHash4("sha256").update(sealData).digest("hex"),
+    session2.signingKey
+  );
+  session2.appendToChain("session_seal", {
+    seal: sealData,
+    seal_signature: sealSignature,
+    auto_sealed: true
+  });
+  const activePath = join6(ACTIVE_DIR, `${session2.sessionId}.jsonl`);
+  const sealedPath = join6(SEALED_DIR, `${session2.sessionId}.jsonl`);
   try {
-    return cryptoSign(null, Buffer.from(hash), signingKey2).toString("hex");
+    if (existsSync8(activePath)) {
+      renameSync3(activePath, sealedPath);
+    }
   } catch {
-    return "unsigned";
   }
-}
-function buildChainRecord(type, sessionId2, data, prevHash, signingKey2) {
-  const id = `r_${randomUUID().slice(0, 12)}`;
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const recordCore = JSON.stringify({ id, type, session_id: sessionId2, timestamp, data });
-  const hash = computeHash(recordCore, prevHash);
-  const signature = signHash(hash, signingKey2);
-  return {
-    id,
-    type,
-    session_id: sessionId2,
-    timestamp,
-    data,
-    prev_hash: prevHash,
-    hash,
-    signature
+  const chainStartHash = session2.chainTipHash === "GENESIS" ? "GENESIS" : session2.chainTipHash;
+  const seal = {
+    session_id: session2.sessionId,
+    client: session2.clientName,
+    task_type: session2.sessionTaskType,
+    languages: [],
+    files_touched: 0,
+    started_at: new Date(session2.sessionStartTime).toISOString(),
+    ended_at: now,
+    duration_seconds: duration,
+    heartbeat_count: session2.heartbeatCount,
+    record_count: session2.sessionRecordCount,
+    chain_start_hash: chainStartHash,
+    chain_end_hash: endRecord.hash,
+    seal_signature: sealSignature
   };
-}
-
-// ../shared/dist/crypto/verify.js
-import { createHash as createHash2, createPublicKey, verify as cryptoVerify } from "crypto";
-
-// ../shared/dist/validation/schemas.js
-import { z } from "zod";
-var taskTypeSchema = z.enum([
-  "coding",
-  "debugging",
-  "testing",
-  "planning",
-  "reviewing",
-  "documenting",
-  "learning",
-  "other"
-]);
-var milestoneCategorySchema = z.enum([
-  "feature",
-  "bugfix",
-  "refactor",
-  "test",
-  "docs",
-  "setup",
-  "deployment",
-  "other"
-]);
-var complexitySchema = z.enum(["simple", "medium", "complex"]);
-var milestoneInputSchema = z.object({
-  title: z.string().min(1).max(500),
-  category: milestoneCategorySchema,
-  complexity: complexitySchema.optional()
-});
-var syncPayloadSchema = z.object({
-  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
-  total_seconds: z.number().int().nonnegative(),
-  clients: z.record(z.string(), z.number().int().nonnegative()),
-  task_types: z.record(z.string(), z.number().int().nonnegative()),
-  languages: z.record(z.string(), z.number().int().nonnegative()),
-  sessions: z.array(z.object({
-    session_id: z.string(),
-    client: z.string(),
-    task_type: z.string(),
-    languages: z.array(z.string()),
-    files_touched: z.number().int().nonnegative(),
-    started_at: z.string(),
-    ended_at: z.string(),
-    duration_seconds: z.number().int().nonnegative(),
-    heartbeat_count: z.number().int().nonnegative(),
-    record_count: z.number().int().nonnegative(),
-    chain_start_hash: z.string(),
-    chain_end_hash: z.string(),
-    seal_signature: z.string()
-  })),
-  sync_signature: z.string()
-});
-var publishPayloadSchema = z.object({
-  milestones: z.array(z.object({
-    id: z.string(),
-    title: z.string().min(1).max(500),
-    category: milestoneCategorySchema,
-    complexity: complexitySchema,
-    duration_minutes: z.number().int().nonnegative(),
-    languages: z.array(z.string()),
-    client: z.string(),
-    chain_hash: z.string()
-  }))
-});
-
-// ../shared/dist/utils/fs.js
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
-function ensureDir() {
-  for (const dir of [USEAI_DIR, DATA_DIR, ACTIVE_DIR, SEALED_DIR]) {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
+  const allSessions = readJson(SESSIONS_FILE, []);
+  allSessions.push(seal);
+  writeJson(SESSIONS_FILE, allSessions);
+}
+function resetIdleTimer(sessionId) {
+  const active = sessions.get(sessionId);
+  if (!active) return;
+  clearTimeout(active.idleTimer);
+  active.idleTimer = setTimeout(async () => {
+    autoSealSession(active);
+    try {
+      await active.transport.close();
+    } catch {
     }
-  }
-}
-function readJson(path, fallback) {
+    sessions.delete(sessionId);
+  }, IDLE_TIMEOUT_MS);
+}
+async function cleanupSession(sessionId) {
+  const active = sessions.get(sessionId);
+  if (!active) return;
+  clearTimeout(active.idleTimer);
+  autoSealSession(active);
   try {
-    if (!existsSync(path))
-      return fallback;
-    return JSON.parse(readFileSync(path, "utf-8"));
+    await active.transport.close();
   } catch {
-    return fallback;
-  }
-}
-function writeJson(path, data) {
-  ensureDir();
-  const tmp = `${path}.${process.pid}.tmp`;
-  writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
-  renameSync(tmp, path);
-}
-
-// ../shared/dist/utils/format.js
-function formatDuration(seconds) {
-  if (seconds < 60)
-    return `${seconds}s`;
-  const mins = Math.round(seconds / 60);
-  if (mins < 60)
-    return `${mins}m`;
-  const hrs = Math.floor(mins / 60);
-  const remainMins = mins % 60;
-  return `${hrs}h ${remainMins}m`;
-}
-
-// ../shared/dist/utils/detect-client.js
-function detectClient() {
-  const env = process.env;
-  for (const [envVar, clientName2] of Object.entries(AI_CLIENT_ENV_VARS)) {
-    if (env[envVar])
-      return clientName2;
   }
-  if (env.MCP_CLIENT_NAME)
-    return env.MCP_CLIENT_NAME;
-  return "unknown";
-}
-
-// ../shared/dist/utils/id.js
-import { randomUUID as randomUUID2 } from "crypto";
-function generateSessionId() {
-  return randomUUID2();
-}
-
-// src/session.ts
-import { appendFileSync, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-var sessionStartTime = Date.now();
-var sessionId = generateSessionId();
-var heartbeatCount = 0;
-var sessionRecordCount = 0;
-var clientName = "unknown";
-var sessionTaskType = "coding";
-var chainTipHash = GENESIS_HASH;
-var signingKey = null;
-var signingAvailable = false;
-function resetSession() {
-  sessionStartTime = Date.now();
-  sessionId = generateSessionId();
-  heartbeatCount = 0;
-  sessionRecordCount = 0;
-  chainTipHash = GENESIS_HASH;
-  clientName = "unknown";
-  sessionTaskType = "coding";
-}
-function setClient(name) {
-  clientName = name;
-}
-function setTaskType(type) {
-  sessionTaskType = type;
-}
-function incrementHeartbeat() {
-  heartbeatCount++;
-}
-function getSessionDuration() {
-  return Math.round((Date.now() - sessionStartTime) / 1e3);
-}
-function initializeKeystore() {
-  ensureDir();
-  if (existsSync2(KEYSTORE_FILE)) {
-    const ks = readJson(KEYSTORE_FILE, null);
-    if (ks) {
+  sessions.delete(sessionId);
+}
+function handleHealth(res) {
+  const body = JSON.stringify({
+    status: "ok",
+    version: VERSION,
+    active_sessions: sessions.size,
+    uptime_seconds: Math.round((Date.now() - startedAt) / 1e3)
+  });
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(body);
+}
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
       try {
-        signingKey = decryptKeystore(ks);
-        signingAvailable = true;
-        return;
-      } catch {
+        const raw = Buffer.concat(chunks).toString();
+        resolve(raw ? JSON.parse(raw) : void 0);
+      } catch (e) {
+        reject(e);
       }
-    }
-  }
-  const result = generateKeystore();
-  writeJson(KEYSTORE_FILE, result.keystore);
-  signingKey = result.signingKey;
-  signingAvailable = true;
-}
-function sessionChainPath() {
-  return join2(ACTIVE_DIR, `${sessionId}.jsonl`);
+    });
+    req.on("error", reject);
+  });
 }
-function appendToChain(type, data) {
-  const record = buildChainRecord(type, sessionId, data, chainTipHash, signingKey);
+async function startDaemon(port) {
+  const listenPort = port ?? DAEMON_PORT;
   ensureDir();
-  appendFileSync(sessionChainPath(), JSON.stringify(record) + "\n", "utf-8");
-  chainTipHash = record.hash;
-  sessionRecordCount++;
-  return record;
+  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 !== "/mcp") {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+      return;
+    }
+    try {
+      if (req.method === "POST") {
+        const body = await parseBody(req);
+        const sid = req.headers["mcp-session-id"];
+        if (sid && sessions.has(sid)) {
+          resetIdleTimer(sid);
+          await sessions.get(sid).transport.handleRequest(req, res, body);
+        } else if (!sid && isInitializeRequest(body)) {
+          const sessionState = new SessionState();
+          try {
+            sessionState.initializeKeystore();
+          } catch {
+          }
+          const mcpServer = new McpServer({
+            name: "UseAI",
+            version: VERSION
+          });
+          registerTools(mcpServer, sessionState);
+          const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID4(),
+            onsessioninitialized: (newSid) => {
+              const idleTimer = setTimeout(async () => {
+                await cleanupSession(newSid);
+              }, IDLE_TIMEOUT_MS);
+              sessions.set(newSid, {
+                transport,
+                server: mcpServer,
+                session: sessionState,
+                idleTimer
+              });
+            }
+          });
+          transport.onclose = () => {
+            const closedSid = transport.sessionId;
+            if (closedSid && sessions.has(closedSid)) {
+              const active = sessions.get(closedSid);
+              clearTimeout(active.idleTimer);
+              autoSealSession(active);
+              sessions.delete(closedSid);
+            }
+          };
+          await mcpServer.connect(transport);
+          await transport.handleRequest(req, res, body);
+        } else {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32e3, message: "Bad Request: No valid session ID provided" },
+            id: null
+          }));
+        }
+      } else if (req.method === "GET") {
+        const sid = req.headers["mcp-session-id"];
+        if (!sid || !sessions.has(sid)) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid or missing session ID" }));
+          return;
+        }
+        resetIdleTimer(sid);
+        await sessions.get(sid).transport.handleRequest(req, res);
+      } else if (req.method === "DELETE") {
+        const sid = req.headers["mcp-session-id"];
+        if (!sid || !sessions.has(sid)) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid or missing session ID" }));
+          return;
+        }
+        await sessions.get(sid).transport.handleRequest(req, res);
+      } else {
+        res.writeHead(405, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Method not allowed" }));
+      }
+    } catch (error) {
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32603, message: "Internal server error" },
+          id: null
+        }));
+      }
+    }
+  });
+  const pidData = JSON.stringify({
+    pid: process.pid,
+    port: listenPort,
+    started_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeFileSync4(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);
+      }
+    } catch {
+    }
+    server2.close(() => {
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(0), 5e3).unref();
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  server2.listen(listenPort, "127.0.0.1", () => {
+    console.log(`UseAI daemon listening on http://127.0.0.1:${listenPort}`);
+    console.log(`PID: ${process.pid}`);
+  });
 }
+var IDLE_TIMEOUT_MS, sessions, startedAt;
+var init_daemon2 = __esm({
+  "src/daemon.ts"() {
+    "use strict";
+    init_dist();
+    init_session_state();
+    init_register_tools();
+    IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
+    sessions = /* @__PURE__ */ new Map();
+    startedAt = Date.now();
+  }
+});
 
 // src/index.ts
+init_dist();
+init_session_state();
+init_register_tools();
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 if (process.argv[2] === "mcp") {
   const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
   await runSetup2(process.argv.slice(3));
   process.exit(0);
 }
-function getConfig() {
-  return readJson(CONFIG_FILE, {
-    milestone_tracking: true,
-    auto_sync: true
+if (process.argv[2] === "daemon") {
+  const { startDaemon: startDaemon2 } = await Promise.resolve().then(() => (init_daemon2(), daemon_exports));
+  const portArg = process.argv.indexOf("--port");
+  const port = portArg !== -1 ? parseInt(process.argv[portArg + 1], 10) : void 0;
+  await startDaemon2(port);
+  await new Promise(() => {
   });
 }
-function getSessions() {
-  return readJson(SESSIONS_FILE, []);
-}
-function getMilestones() {
-  return readJson(MILESTONES_FILE, []);
-}
-var server = new McpServer({
+var session = new SessionState();
+var server = new McpServer2({
   name: "UseAI",
   version: VERSION
 });
-server.tool(
-  "useai_session_start",
-  "Start tracking an AI coding session. Call this at the beginning of a conversation. Records which AI tool and task type \u2014 stored LOCALLY at ~/.useai/. No data is sent anywhere. No code, prompts, or private data is captured.",
-  {
-    task_type: z2.enum(["coding", "debugging", "testing", "planning", "reviewing", "documenting", "learning", "other"]).optional().describe("What kind of task is the developer working on?")
-  },
-  async ({ task_type }) => {
-    resetSession();
-    setClient(detectClient());
-    setTaskType(task_type ?? "coding");
-    const record = appendToChain("session_start", {
-      client: clientName,
-      task_type: sessionTaskType,
-      version: VERSION
-    });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `useai session started \u2014 tracking ${sessionTaskType} session on ${clientName}.
-Session: ${sessionId.slice(0, 8)} \xB7 Chain: ${record.hash.slice(0, 12)} (${signingAvailable ? "signed" : "unsigned"})
-All data stored locally at ${USEAI_DIR}. No network calls made.`
-        }
-      ]
-    };
-  }
-);
-server.tool(
-  "useai_heartbeat",
-  "Record a heartbeat for the current AI coding session. Call this periodically during long conversations (every 10-15 minutes). Only records a timestamp \u2014 stored locally, never sent anywhere.",
-  {},
-  async () => {
-    incrementHeartbeat();
-    appendToChain("heartbeat", {
-      heartbeat_number: heartbeatCount,
-      cumulative_seconds: getSessionDuration()
-    });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Heartbeat recorded locally. Session active for ${formatDuration(getSessionDuration())}.`
-        }
-      ]
-    };
-  }
-);
-server.tool(
-  "useai_session_end",
-  "End the current AI coding session. Creates a cryptographically sealed session record and optionally records milestones \u2014 what was accomplished. Stats auto-sync to useai.dev daily. To publish milestones: run `useai publish` from the CLI. IMPORTANT: Milestone descriptions must be GENERIC. Do not include project names, file names, file paths, API endpoints, database names, company names, or any project-specific information. Use general terms like 'authentication system', 'data validation layer', 'responsive dashboard'. Think: would this description reveal what company or project this is for? If yes, make it more generic.",
-  {
-    task_type: z2.enum(["coding", "debugging", "testing", "planning", "reviewing", "documenting", "learning", "other"]).optional().describe("What kind of task was the developer working on?"),
-    languages: z2.array(z2.string()).optional().describe("Programming languages used (e.g. ['typescript', 'python'])"),
-    files_touched_count: z2.number().optional().describe("Approximate number of files created or modified (count only, no names)"),
-    milestones: z2.array(z2.object({
-      title: z2.string().describe("Generic description of what was accomplished. PRIVACY RULES: Do NOT include project names, repository names, file names, file paths, API endpoints, database names, company names, or any project-specific details. Use generic terms only. GOOD examples: 'Implemented user authentication', 'Fixed race condition in background worker', 'Added unit tests for data validation', 'Refactored state management layer', 'Built responsive dashboard layout'. BAD examples: 'Fixed bug in /api/stripe/webhooks', 'Added auth to acme-corp project', 'Updated UserService.ts in src/services/'"),
-      category: z2.enum(["feature", "bugfix", "refactor", "test", "docs", "setup", "deployment", "other"]).describe("Type of work completed"),
-      complexity: z2.enum(["simple", "medium", "complex"]).optional().describe("How complex was this task?")
-    })).optional().describe("What was accomplished this session? List each distinct piece of work completed. Describe generically \u2014 no project names, file names, or proprietary details.")
-  },
-  async ({ task_type, languages, files_touched_count, milestones: milestonesInput }) => {
-    const duration = getSessionDuration();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const finalTaskType = task_type ?? sessionTaskType;
-    const chainStartHash = chainTipHash === "GENESIS" ? "GENESIS" : chainTipHash;
-    const endRecord = appendToChain("session_end", {
-      duration_seconds: duration,
-      task_type: finalTaskType,
-      languages: languages ?? [],
-      files_touched: files_touched_count ?? 0,
-      heartbeat_count: heartbeatCount
-    });
-    const sealData = JSON.stringify({
-      session_id: sessionId,
-      client: clientName,
-      task_type: finalTaskType,
-      languages: languages ?? [],
-      files_touched: files_touched_count ?? 0,
-      started_at: new Date(sessionStartTime).toISOString(),
-      ended_at: now,
-      duration_seconds: duration,
-      heartbeat_count: heartbeatCount,
-      record_count: sessionRecordCount,
-      chain_end_hash: endRecord.hash
-    });
-    const sealSignature = signHash(
-      createHash3("sha256").update(sealData).digest("hex"),
-      signingKey
-    );
-    appendToChain("session_seal", {
-      seal: sealData,
-      seal_signature: sealSignature
-    });
-    const activePath = join4(ACTIVE_DIR, `${sessionId}.jsonl`);
-    const sealedPath = join4(SEALED_DIR, `${sessionId}.jsonl`);
-    try {
-      if (existsSync4(activePath)) {
-        renameSync2(activePath, sealedPath);
-      }
-    } catch {
-    }
-    const seal = {
-      session_id: sessionId,
-      client: clientName,
-      task_type: finalTaskType,
-      languages: languages ?? [],
-      files_touched: files_touched_count ?? 0,
-      started_at: new Date(sessionStartTime).toISOString(),
-      ended_at: now,
-      duration_seconds: duration,
-      heartbeat_count: heartbeatCount,
-      record_count: sessionRecordCount,
-      chain_start_hash: chainStartHash,
-      chain_end_hash: endRecord.hash,
-      seal_signature: sealSignature
-    };
-    const sessions = getSessions();
-    sessions.push(seal);
-    writeJson(SESSIONS_FILE, sessions);
-    let milestoneCount = 0;
-    if (milestonesInput && milestonesInput.length > 0) {
-      const config = getConfig();
-      if (config.milestone_tracking) {
-        const durationMinutes = Math.round(duration / 60);
-        const allMilestones = getMilestones();
-        for (const m of milestonesInput) {
-          const record = appendToChain("milestone", {
-            title: m.title,
-            category: m.category,
-            complexity: m.complexity ?? "medium",
-            duration_minutes: durationMinutes,
-            languages: languages ?? []
-          });
-          const milestone = {
-            id: `m_${randomUUID3().slice(0, 8)}`,
-            session_id: sessionId,
-            title: m.title,
-            category: m.category,
-            complexity: m.complexity ?? "medium",
-            duration_minutes: durationMinutes,
-            languages: languages ?? [],
-            client: clientName,
-            created_at: (/* @__PURE__ */ new Date()).toISOString(),
-            published: false,
-            published_at: null,
-            chain_hash: record.hash
-          };
-          allMilestones.push(milestone);
-          milestoneCount++;
-        }
-        writeJson(MILESTONES_FILE, allMilestones);
-      }
-    }
-    const durationStr = formatDuration(duration);
-    const langStr = languages && languages.length > 0 ? ` using ${languages.join(", ")}` : "";
-    const milestoneStr = milestoneCount > 0 ? ` \xB7 ${milestoneCount} milestone${milestoneCount > 1 ? "s" : ""} recorded` : "";
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Session sealed: ${durationStr} ${finalTaskType} on ${clientName}${langStr}
-${sessionRecordCount} chain records \xB7 ${signingAvailable ? "Ed25519 signed" : "unsigned"}${milestoneStr}
-Stored at: ${sealedPath}
-
-To publish: run \`useai sync\` from your terminal.`
-        }
-      ]
-    };
-  }
-);
+registerTools(server, session);
 async function main() {
   ensureDir();
   try {
-    initializeKeystore();
+    session.initializeKeystore();
   } catch {
   }
   const transport = new StdioServerTransport();