@devness/useai 0.3.8 → 0.4.1

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.4.1";
+  }
+});
+
+// ../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@latest", "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. CRITICAL PRIVACY REQUIREMENT: Milestone titles must be COMPLETELY GENERIC. NEVER include project names, repository names, product names, package names, file names, file paths, class names, API endpoints, database names, or company names. Write as if describing the work to a stranger with zero knowledge of the codebase. GOOD: "Implemented user authentication", "Fixed race condition in background worker", "Added unit tests for data validation". BAD: "Fixed bug in Acme auth service", "Updated UserService.ts", "Investigated ProjectX pipeline".',
+    {
+      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("PRIVACY-CRITICAL: Generic description of what was accomplished. NEVER include project names, repo names, product names, package names, file names, file paths, class names, API endpoints, database names, company names, or ANY identifier that could reveal which codebase this work was done in. Write as if describing the work to a stranger. GOOD: 'Implemented user authentication', 'Fixed race condition in background worker', 'Added unit tests for data validation', 'Refactored state management layer'. BAD: 'Fixed bug in Acme auth', 'Investigated ProjectX pipeline', 'Updated UserService.ts in src/services/', 'Added tests for coverit MCP tool'"),
+        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,28 +1403,33 @@ 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.",
       "- For LONG sessions (15+ min), call `useai_heartbeat` periodically.",
-      "- At the END of every conversation, call `useai_session_end` with languages used, files_touched_count, and milestones (generic descriptions only \u2014 no project names, file paths, or company names)."
+      "- At the END of every conversation, call `useai_session_end` with languages used, files_touched_count, and milestones.",
+      '- MILESTONES PRIVACY: Milestone titles must be COMPLETELY GENERIC. NEVER mention project names, repository names, product names, file names, file paths, class names, or company names. Write as if describing the work to a stranger who knows nothing about the codebase. GOOD: "Fixed race condition in background worker". BAD: "Fixed bug in ProjectX worker service".'
     ].join("\n");
     MCP_ENTRY = {
       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 = [
       "## UseAI Session Tracking",
       "- At the START of every conversation, call `useai_session_start` with the appropriate task_type.",
       "- For LONG sessions (15+ min), call `useai_heartbeat` periodically.",
-      "- At the END of every conversation, call `useai_session_end` with languages used, files_touched_count, and milestones (generic descriptions only \u2014 no project names, file paths, or company names)."
+      "- At the END of every conversation, call `useai_session_end` with languages used, files_touched_count, and milestones.",
+      '- MILESTONES PRIVACY: Milestone titles must be COMPLETELY GENERIC. NEVER mention project names, repository names, product names, file names, file paths, class names, or company names. Write as if describing the work to a stranger who knows nothing about the codebase. GOOD: "Fixed race condition in background worker". BAD: "Fixed bug in ProjectX worker service".'
     ].join("\n");
     USEAI_INSTRUCTIONS_BLOCK = `${INSTRUCTIONS_START}
 ${USEAI_INSTRUCTIONS}
@@ -322,69 +1441,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 +1518,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 +1537,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 +1659,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 +1798,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 +1817,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 +1923,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,508 +1939,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.",
-  {
-    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"})`
-        }
-      ]
-    };
-  }
-);
-server.tool(
-  "useai_heartbeat",
-  "Record a heartbeat for the current AI coding session. Call this periodically during long conversations (every 10-15 minutes).",
-  {},
-  async () => {
-    incrementHeartbeat();
-    appendToChain("heartbeat", {
-      heartbeat_number: heartbeatCount,
-      cumulative_seconds: getSessionDuration()
-    });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Heartbeat recorded. Session active for ${formatDuration(getSessionDuration())}.`
-        }
-      ]
-    };
-  }
-);
-server.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 = 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 ended: ${durationStr} ${finalTaskType}${langStr}${milestoneStr}`
-        }
-      ]
-    };
-  }
-);
+registerTools(server, session);
 async function main() {
   ensureDir();
   try {
-    initializeKeystore();
+    session.initializeKeystore();
   } catch {
   }
   const transport = new StdioServerTransport();