@askexenow/exe-os 0.8.0 → 0.8.1

package/dist/hooks/summary-worker.js

@@ -38,6 +38,9 @@ async function initDatabase(config) {
   }
   _client = createClient(opts);
 }
+function isInitialized() {
+  return _client !== null;
+}
 function getClient() {
   if (!_client) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
@@ -231,6 +234,27 @@ async function ensureSchema() {
     });
   } catch {
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN complexity TEXT NOT NULL DEFAULT 'standard'`,
+      args: []
+    });
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
@@ -641,6 +665,15 @@ async function ensureSchema() {
     } catch {
     }
   }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN source_path TEXT",
+    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
   await client.executeMultiple(`
     CREATE INDEX IF NOT EXISTS idx_memories_workspace
       ON memories(workspace_id);
@@ -705,6 +738,34 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_conversations_channel
       ON conversations(channel_id);
   `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN budget_fallback_model TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN tokens_used INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN tokens_warned_at INTEGER`,
+      args: []
+    });
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE VIRTUAL TABLE IF NOT EXISTS conversations_fts USING fts5(
       content_text,
@@ -731,6 +792,52 @@ async function ensureSchema() {
       VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
     END;
   `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `UPDATE memories SET tier = 1 WHERE tool_name = 'commit_to_long_term_memory' AND importance >= 8 AND tier = 3`,
+      args: []
+    });
+    await client.execute({
+      sql: `UPDATE memories SET tier = 2 WHERE tool_name IN ('store_memory', 'manual') AND importance >= 5 AND tier = 3`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN supersedes_id TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL`
+    );
+  } catch {
+  }
+  for (const col of [
+    "ALTER TABLE tasks ADD COLUMN checkpoint TEXT",
+    "ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER DEFAULT 0"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
 }
 var _client, initTurso;
 var init_database = __esm({
@@ -968,6 +1075,11 @@ function normalizeSessionLifecycle(raw) {
   const userSL = raw.sessionLifecycle ?? {};
   raw.sessionLifecycle = { ...defaultSL, ...userSL };
 }
+function normalizeAutoUpdate(raw) {
+  const defaultAU = DEFAULT_CONFIG.autoUpdate;
+  const userAU = raw.autoUpdate ?? {};
+  raw.autoUpdate = { ...defaultAU, ...userAU };
+}
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir2(dir, { recursive: true });
@@ -990,6 +1102,7 @@ async function loadConfig() {
     }
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
     const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
       config.dbPath = config.dbPath.replace(/^~/, os.homedir());
@@ -1012,6 +1125,7 @@ function loadConfigSync() {
     const { config: migratedCfg } = migrateConfig(parsed);
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
     return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
   } catch {
     return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
@@ -1031,6 +1145,7 @@ async function loadConfigFrom(configPath) {
     const { config: migratedCfg } = migrateConfig(parsed);
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
     return { ...DEFAULT_CONFIG, ...migratedCfg };
   } catch {
     return { ...DEFAULT_CONFIG };
@@ -1102,6 +1217,11 @@ var init_config = __esm({
         idleKillTicksRequired: 3,
         idleKillIntercomAckWindowMs: 1e4,
         maxAutoInstances: 10
+      },
+      autoUpdate: {
+        checkOnBoot: true,
+        autoInstall: false,
+        checkIntervalMs: 24 * 60 * 60 * 1e3
       }
     };
     CONFIG_MIGRATIONS = [
@@ -1235,13 +1355,27 @@ async function ensureShardSchema(client) {
     "ALTER TABLE memories ADD COLUMN document_id TEXT",
     "ALTER TABLE memories ADD COLUMN user_id TEXT",
     "ALTER TABLE memories ADD COLUMN char_offset INTEGER",
-    "ALTER TABLE memories ADD COLUMN page_number INTEGER"
+    "ALTER TABLE memories ADD COLUMN page_number INTEGER",
+    // Source provenance columns (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN source_path TEXT",
+    "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'",
+    "ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3",
+    "ALTER TABLE memories ADD COLUMN supersedes_id TEXT"
   ]) {
     try {
       await client.execute(col);
     } catch {
     }
   }
+  for (const idx of [
+    "CREATE INDEX IF NOT EXISTS idx_memories_tier ON memories(tier)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes_id) WHERE supersedes_id IS NOT NULL"
+  ]) {
+    try {
+      await client.execute(idx);
+    } catch {
+    }
+  }
   try {
     await client.execute("CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)");
   } catch {
@@ -1345,139 +1479,453 @@ var init_shard_manager = __esm({
   }
 });
 
-// src/lib/exe-daemon-client.ts
-import net from "net";
-import { spawn } from "child_process";
-import { randomUUID } from "crypto";
-import { existsSync as existsSync5, unlinkSync as unlinkSync2, readFileSync as readFileSync3, openSync, closeSync, statSync } from "fs";
+// src/lib/employees.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync5, symlinkSync, readlinkSync } from "fs";
+import { execSync } from "child_process";
 import path5 from "path";
-import { fileURLToPath } from "url";
-function handleData(chunk) {
-  _buffer += chunk.toString();
-  let newlineIdx;
-  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
-    const line = _buffer.slice(0, newlineIdx).trim();
-    _buffer = _buffer.slice(newlineIdx + 1);
-    if (!line) continue;
-    try {
-      const response = JSON.parse(line);
-      const entry = _pending.get(response.id);
-      if (entry) {
-        clearTimeout(entry.timer);
-        _pending.delete(response.id);
-        entry.resolve(response);
-      }
-    } catch {
-    }
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync5(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile3(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
   }
 }
-function cleanupStaleFiles() {
-  if (existsSync5(PID_PATH)) {
-    try {
-      const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(pid, 0);
-          return;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    try {
-      unlinkSync2(PID_PATH);
-    } catch {
+var EMPLOYEES_PATH;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
+    "use strict";
+    init_config();
+    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
+  }
+});
+
+// src/lib/license.ts
+import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
+import { randomUUID } from "crypto";
+import path6 from "path";
+import { jwtVerify, importSPKI } from "jose";
+function loadDeviceId() {
+  const deviceJsonPath = path6.join(EXE_AI_DIR, "device.json");
+  try {
+    if (existsSync6(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync3(deviceJsonPath, "utf8"));
+      if (data.deviceId) return data.deviceId;
     }
-    try {
-      unlinkSync2(SOCKET_PATH);
-    } catch {
+  } catch {
+  }
+  try {
+    if (existsSync6(DEVICE_ID_PATH)) {
+      const id2 = readFileSync3(DEVICE_ID_PATH, "utf8").trim();
+      if (id2) return id2;
     }
+  } catch {
   }
+  const id = randomUUID();
+  mkdirSync2(EXE_AI_DIR, { recursive: true });
+  writeFileSync(DEVICE_ID_PATH, id, "utf8");
+  return id;
 }
-function findPackageRoot() {
-  let dir = path5.dirname(fileURLToPath(import.meta.url));
-  const { root } = path5.parse(dir);
-  while (dir !== root) {
-    if (existsSync5(path5.join(dir, "package.json"))) return dir;
-    dir = path5.dirname(dir);
+function loadLicense() {
+  try {
+    if (!existsSync6(LICENSE_PATH)) return null;
+    return readFileSync3(LICENSE_PATH, "utf8").trim();
+  } catch {
+    return null;
   }
-  return null;
 }
-function spawnDaemon() {
-  const pkgRoot = findPackageRoot();
-  if (!pkgRoot) {
-    process.stderr.write("[exed-client] WARN: cannot find package root\n");
-    return;
-  }
-  const daemonPath = path5.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync5(daemonPath)) {
-    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
-`);
-    return;
-  }
-  const resolvedPath = daemonPath;
-  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
-`);
-  const logPath = path5.join(path5.dirname(SOCKET_PATH), "exed.log");
-  let stderrFd = "ignore";
+async function verifyLicenseJwt(token) {
   try {
-    stderrFd = openSync(logPath, "a");
+    const key = await importSPKI(LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG);
+    const { payload } = await jwtVerify(token, key, {
+      algorithms: [LICENSE_JWT_ALG]
+    });
+    const plan = payload.plan ?? "free";
+    const email = payload.sub ?? "";
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan,
+      email,
+      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
   } catch {
-  }
-  const child = spawn(process.execPath, [resolvedPath], {
-    detached: true,
-    stdio: ["ignore", "ignore", stderrFd],
-    env: {
-      ...process.env,
-      EXE_DAEMON_SOCK: SOCKET_PATH,
-      EXE_DAEMON_PID: PID_PATH
-    }
-  });
-  child.unref();
-  if (typeof stderrFd === "number") {
-    try {
-      closeSync(stderrFd);
-    } catch {
-    }
+    return null;
   }
 }
-function acquireSpawnLock() {
+async function getCachedLicense() {
   try {
-    const fd = openSync(SPAWN_LOCK_PATH, "wx");
-    closeSync(fd);
-    return true;
+    if (!existsSync6(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync3(CACHE_PATH, "utf8"));
+    if (!raw.token || typeof raw.token !== "string") return null;
+    return await verifyLicenseJwt(raw.token);
   } catch {
-    try {
-      const stat = statSync(SPAWN_LOCK_PATH);
-      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
-        try {
-          unlinkSync2(SPAWN_LOCK_PATH);
-        } catch {
-        }
-        try {
-          const fd = openSync(SPAWN_LOCK_PATH, "wx");
-          closeSync(fd);
-          return true;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    return false;
+    return null;
   }
 }
-function releaseSpawnLock() {
+function cacheResponse(token) {
   try {
-    unlinkSync2(SPAWN_LOCK_PATH);
+    writeFileSync(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
-function connectToSocket() {
-  return new Promise((resolve) => {
-    if (_socket && _connected) {
-      resolve(true);
-      return;
-    }
+async function validateLicense(apiKey, deviceId) {
+  const did = deviceId ?? loadDeviceId();
+  try {
+    const res = await fetch(`${API_BASE}/auth/activate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ apiKey, deviceId: did }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.ok) {
+      const data = await res.json();
+      if (data.error === "device_limit_exceeded") {
+        const cached2 = await getCachedLicense();
+        if (cached2) return cached2;
+        return { ...FREE_LICENSE, valid: false, plan: "free" };
+      }
+      if (data.token) {
+        cacheResponse(data.token);
+        const verified = await verifyLicenseJwt(data.token);
+        if (verified) return verified;
+      }
+      const limits = PLAN_LIMITS[data.plan] ?? PLAN_LIMITS.free;
+      return {
+        valid: data.valid,
+        plan: data.plan,
+        email: data.email,
+        expiresAt: data.expiresAt,
+        deviceLimit: limits.devices,
+        employeeLimit: limits.employees,
+        memoryLimit: limits.memories
+      };
+    }
+    const cached = await getCachedLicense();
+    if (cached) return cached;
+    return { ...FREE_LICENSE, valid: false, plan: "free" };
+  } catch {
+    const cached = await getCachedLicense();
+    if (cached) return cached;
+    return FREE_LICENSE;
+  }
+}
+async function checkLicense() {
+  const key = loadLicense();
+  if (!key) return FREE_LICENSE;
+  const cached = await getCachedLicense();
+  if (cached) return cached;
+  const deviceId = loadDeviceId();
+  return validateLicense(key, deviceId);
+}
+function isFeatureAllowed(license, feature) {
+  switch (feature) {
+    case "cloud_sync":
+    case "external_agents":
+    case "wiki":
+      return license.plan !== "free";
+    case "unlimited_employees":
+      return license.plan === "team" || license.plan === "agency" || license.plan === "enterprise";
+  }
+}
+var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE;
+var init_license = __esm({
+  "src/lib/license.ts"() {
+    "use strict";
+    init_config();
+    LICENSE_PATH = path6.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path6.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path6.join(EXE_AI_DIR, "device-id");
+    API_BASE = "https://askexe.com/cloud";
+    LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
+4uj+UqeKCcvtgNHKmOK278HJaJcANe9xAeji8AFYu27q3WtzCi04pHudow==
+-----END PUBLIC KEY-----`;
+    LICENSE_JWT_ALG = "ES256";
+    PLAN_LIMITS = {
+      free: { devices: 1, employees: 1, memories: 5e3 },
+      pro: { devices: 2, employees: 5, memories: 1e5 },
+      team: { devices: 10, employees: 20, memories: 1e6 },
+      agency: { devices: 50, employees: 100, memories: 1e7 },
+      enterprise: { devices: -1, employees: -1, memories: -1 }
+    };
+    FREE_LICENSE = {
+      valid: true,
+      plan: "free",
+      email: "",
+      expiresAt: null,
+      deviceLimit: 1,
+      employeeLimit: 1,
+      memoryLimit: 5e3
+    };
+  }
+});
+
+// src/lib/plan-limits.ts
+var plan_limits_exports = {};
+__export(plan_limits_exports, {
+  PlanLimitError: () => PlanLimitError,
+  assertEmployeeLimit: () => assertEmployeeLimit,
+  assertEmployeeLimitSync: () => assertEmployeeLimitSync,
+  assertFeature: () => assertFeature,
+  assertMemoryLimit: () => assertMemoryLimit,
+  countActiveMemories: () => countActiveMemories,
+  getLicenseSync: () => getLicenseSync
+});
+import { readFileSync as readFileSync4, existsSync as existsSync7 } from "fs";
+import path7 from "path";
+function getLicenseSync() {
+  try {
+    if (!existsSync7(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync4(CACHE_PATH2, "utf8"));
+    if (!raw.token || typeof raw.token !== "string") return freeLicense();
+    const parts = raw.token.split(".");
+    if (parts.length !== 3) return freeLicense();
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    const plan = payload.plan ?? "free";
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan,
+      email: payload.sub ?? "",
+      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  } catch {
+    return freeLicense();
+  }
+}
+function freeLicense() {
+  const limits = PLAN_LIMITS.free;
+  return {
+    valid: true,
+    plan: "free",
+    email: "",
+    expiresAt: null,
+    deviceLimit: limits.devices,
+    employeeLimit: limits.employees,
+    memoryLimit: limits.memories
+  };
+}
+async function countActiveMemories() {
+  if (!isInitialized()) return 0;
+  const client = getClient();
+  const result = await client.execute(
+    "SELECT COUNT(*) as cnt FROM memories WHERE status = 'active' OR status IS NULL"
+  );
+  const row = result.rows[0];
+  return Number(row?.cnt ?? 0);
+}
+async function assertMemoryLimit() {
+  const license = await checkLicense();
+  if (license.memoryLimit < 0) return;
+  const count = await countActiveMemories();
+  if (count >= license.memoryLimit) {
+    throw new PlanLimitError(
+      `Memory limit reached: ${count}/${license.memoryLimit} active memories on the ${license.plan} plan. Upgrade at https://askexe.com to store more.`
+    );
+  }
+}
+async function assertEmployeeLimit(license, rosterPath) {
+  const lic = license ?? await checkLicense();
+  if (lic.employeeLimit < 0) return;
+  const employees = await loadEmployees(rosterPath ?? EMPLOYEES_PATH);
+  if (employees.length >= lic.employeeLimit) {
+    throw new PlanLimitError(
+      `Employee limit reached: ${employees.length}/${lic.employeeLimit} employees on the ${lic.plan} plan. Upgrade at https://askexe.com to add more.`
+    );
+  }
+}
+function assertEmployeeLimitSync(rosterPath) {
+  const license = getLicenseSync();
+  if (license.employeeLimit < 0) return;
+  const filePath = rosterPath ?? EMPLOYEES_PATH;
+  let count = 0;
+  try {
+    if (existsSync7(filePath)) {
+      const raw = readFileSync4(filePath, "utf8");
+      const employees = JSON.parse(raw);
+      count = Array.isArray(employees) ? employees.length : 0;
+    }
+  } catch {
+    throw new PlanLimitError(
+      `Cannot verify employee count: roster unreadable at ${filePath}. Refusing to proceed. Check file permissions or upgrade plan.`
+    );
+  }
+  if (count >= license.employeeLimit) {
+    throw new PlanLimitError(
+      `Employee limit reached: ${count}/${license.employeeLimit} employees on the ${license.plan} plan. Upgrade at https://askexe.com to add more.`
+    );
+  }
+}
+async function assertFeature(feature) {
+  const license = await checkLicense();
+  if (!isFeatureAllowed(license, feature)) {
+    throw new PlanLimitError(
+      `Feature "${feature}" requires a paid plan. Current plan: ${license.plan}. Upgrade at https://askexe.com.`
+    );
+  }
+}
+var PlanLimitError, CACHE_PATH2;
+var init_plan_limits = __esm({
+  "src/lib/plan-limits.ts"() {
+    "use strict";
+    init_database();
+    init_employees();
+    init_license();
+    init_config();
+    PlanLimitError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "PlanLimitError";
+      }
+    };
+    CACHE_PATH2 = path7.join(EXE_AI_DIR, "license-cache.json");
+  }
+});
+
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import { spawn } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync8, unlinkSync as unlinkSync2, readFileSync as readFileSync5, openSync, closeSync, statSync } from "fs";
+import path8 from "path";
+import { fileURLToPath } from "url";
+function handleData(chunk) {
+  _buffer += chunk.toString();
+  let newlineIdx;
+  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
+    const line = _buffer.slice(0, newlineIdx).trim();
+    _buffer = _buffer.slice(newlineIdx + 1);
+    if (!line) continue;
+    try {
+      const response = JSON.parse(line);
+      const entry = _pending.get(response.id);
+      if (entry) {
+        clearTimeout(entry.timer);
+        _pending.delete(response.id);
+        entry.resolve(response);
+      }
+    } catch {
+    }
+  }
+}
+function cleanupStaleFiles() {
+  if (existsSync8(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync5(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync2(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync2(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function findPackageRoot() {
+  let dir = path8.dirname(fileURLToPath(import.meta.url));
+  const { root } = path8.parse(dir);
+  while (dir !== root) {
+    if (existsSync8(path8.join(dir, "package.json"))) return dir;
+    dir = path8.dirname(dir);
+  }
+  return null;
+}
+function spawnDaemon() {
+  const pkgRoot = findPackageRoot();
+  if (!pkgRoot) {
+    process.stderr.write("[exed-client] WARN: cannot find package root\n");
+    return;
+  }
+  const daemonPath = path8.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync8(daemonPath)) {
+    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
+`);
+    return;
+  }
+  const resolvedPath = daemonPath;
+  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
+`);
+  const logPath = path8.join(path8.dirname(SOCKET_PATH), "exed.log");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const child = spawn(process.execPath, [resolvedPath], {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd],
+    env: {
+      ...process.env,
+      EXE_DAEMON_SOCK: SOCKET_PATH,
+      EXE_DAEMON_PID: PID_PATH
+    }
+  });
+  child.unref();
+  if (typeof stderrFd === "number") {
+    try {
+      closeSync(stderrFd);
+    } catch {
+    }
+  }
+}
+function acquireSpawnLock() {
+  try {
+    const fd = openSync(SPAWN_LOCK_PATH, "wx");
+    closeSync(fd);
+    return true;
+  } catch {
+    try {
+      const stat = statSync(SPAWN_LOCK_PATH);
+      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
+        try {
+          unlinkSync2(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync2(SPAWN_LOCK_PATH);
+  } catch {
+  }
+}
+function connectToSocket() {
+  return new Promise((resolve) => {
+    if (_socket && _connected) {
+      resolve(true);
+      return;
+    }
     const socket = net.createConnection({ path: SOCKET_PATH });
     const connectTimeout = setTimeout(() => {
       socket.destroy();
@@ -1536,7 +1984,7 @@ function sendRequest(texts, priority) {
       resolve({ error: "Not connected" });
       return;
     }
-    const id = randomUUID();
+    const id = randomUUID2();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve({ error: "Request timeout" });
@@ -1554,7 +2002,7 @@ function sendRequest(texts, priority) {
 async function pingDaemon() {
   if (!_socket || !_connected) return null;
   return new Promise((resolve) => {
-    const id = randomUUID();
+    const id = randomUUID2();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve(null);
@@ -1580,9 +2028,9 @@ async function pingDaemon() {
 }
 function killAndRespawnDaemon() {
   process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync5(PID_PATH)) {
+  if (existsSync8(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync5(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, "SIGKILL");
@@ -1666,9 +2114,9 @@ var init_exe_daemon_client = __esm({
   "src/lib/exe-daemon-client.ts"() {
     "use strict";
     init_config();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path5.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path5.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path5.join(EXE_AI_DIR, "exed-spawn.lock");
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path8.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path8.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path8.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
@@ -1828,213 +2276,6 @@ var init_compress = __esm({
   }
 });
 
-// src/lib/employees.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync6, symlinkSync, readlinkSync } from "fs";
-import { execSync } from "child_process";
-import path6 from "path";
-var EMPLOYEES_PATH;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
-    "use strict";
-    init_config();
-    EMPLOYEES_PATH = path6.join(EXE_AI_DIR, "exe-employees.json");
-  }
-});
-
-// src/lib/license.ts
-import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
-import path7 from "path";
-import { jwtVerify, importSPKI } from "jose";
-function loadDeviceId() {
-  const deviceJsonPath = path7.join(EXE_AI_DIR, "device.json");
-  try {
-    if (existsSync7(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync4(deviceJsonPath, "utf8"));
-      if (data.deviceId) return data.deviceId;
-    }
-  } catch {
-  }
-  try {
-    if (existsSync7(DEVICE_ID_PATH)) {
-      const id2 = readFileSync4(DEVICE_ID_PATH, "utf8").trim();
-      if (id2) return id2;
-    }
-  } catch {
-  }
-  const id = randomUUID2();
-  mkdirSync2(EXE_AI_DIR, { recursive: true });
-  writeFileSync(DEVICE_ID_PATH, id, "utf8");
-  return id;
-}
-function loadLicense() {
-  try {
-    if (!existsSync7(LICENSE_PATH)) return null;
-    return readFileSync4(LICENSE_PATH, "utf8").trim();
-  } catch {
-    return null;
-  }
-}
-async function verifyLicenseJwt(token) {
-  try {
-    const key = await importSPKI(LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG);
-    const { payload } = await jwtVerify(token, key, {
-      algorithms: [LICENSE_JWT_ALG]
-    });
-    const plan = payload.plan ?? "free";
-    const email = payload.sub ?? "";
-    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
-    return {
-      valid: true,
-      plan,
-      email,
-      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
-      deviceLimit: limits.devices,
-      employeeLimit: limits.employees,
-      memoryLimit: limits.memories
-    };
-  } catch {
-    return null;
-  }
-}
-async function getCachedLicense() {
-  try {
-    if (!existsSync7(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync4(CACHE_PATH, "utf8"));
-    if (!raw.token || typeof raw.token !== "string") return null;
-    return await verifyLicenseJwt(raw.token);
-  } catch {
-    return null;
-  }
-}
-function cacheResponse(token) {
-  try {
-    writeFileSync(CACHE_PATH, JSON.stringify({ token }), "utf8");
-  } catch {
-  }
-}
-async function validateLicense(apiKey, deviceId) {
-  const did = deviceId ?? loadDeviceId();
-  try {
-    const res = await fetch(`${API_BASE}/auth/activate`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ apiKey, deviceId: did }),
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (res.ok) {
-      const data = await res.json();
-      if (data.error === "device_limit_exceeded") {
-        const cached2 = await getCachedLicense();
-        if (cached2) return cached2;
-        return { ...FREE_LICENSE, valid: false, plan: "free" };
-      }
-      if (data.token) {
-        cacheResponse(data.token);
-        const verified = await verifyLicenseJwt(data.token);
-        if (verified) return verified;
-      }
-      const limits = PLAN_LIMITS[data.plan] ?? PLAN_LIMITS.free;
-      return {
-        valid: data.valid,
-        plan: data.plan,
-        email: data.email,
-        expiresAt: data.expiresAt,
-        deviceLimit: limits.devices,
-        employeeLimit: limits.employees,
-        memoryLimit: limits.memories
-      };
-    }
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    return { ...FREE_LICENSE, valid: false, plan: "free" };
-  } catch {
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    return FREE_LICENSE;
-  }
-}
-async function checkLicense() {
-  const key = loadLicense();
-  if (!key) return FREE_LICENSE;
-  const cached = await getCachedLicense();
-  if (cached) return cached;
-  const deviceId = loadDeviceId();
-  return validateLicense(key, deviceId);
-}
-function isFeatureAllowed(license, feature) {
-  switch (feature) {
-    case "cloud_sync":
-    case "external_agents":
-    case "wiki":
-      return license.plan !== "free";
-    case "unlimited_employees":
-      return license.plan === "team" || license.plan === "agency" || license.plan === "enterprise";
-  }
-}
-var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE;
-var init_license = __esm({
-  "src/lib/license.ts"() {
-    "use strict";
-    init_config();
-    LICENSE_PATH = path7.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path7.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path7.join(EXE_AI_DIR, "device-id");
-    API_BASE = "https://askexe.com/cloud";
-    LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
-MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
-4uj+UqeKCcvtgNHKmOK278HJaJcANe9xAeji8AFYu27q3WtzCi04pHudow==
------END PUBLIC KEY-----`;
-    LICENSE_JWT_ALG = "ES256";
-    PLAN_LIMITS = {
-      free: { devices: 1, employees: 1, memories: 5e3 },
-      pro: { devices: 2, employees: 5, memories: 1e5 },
-      team: { devices: 10, employees: 20, memories: 1e6 },
-      agency: { devices: 50, employees: 100, memories: 1e7 },
-      enterprise: { devices: -1, employees: -1, memories: -1 }
-    };
-    FREE_LICENSE = {
-      valid: true,
-      plan: "free",
-      email: "",
-      expiresAt: null,
-      deviceLimit: 1,
-      employeeLimit: 1,
-      memoryLimit: 5e3
-    };
-  }
-});
-
-// src/lib/plan-limits.ts
-import { readFileSync as readFileSync5, existsSync as existsSync8 } from "fs";
-import path8 from "path";
-async function assertFeature(feature) {
-  const license = await checkLicense();
-  if (!isFeatureAllowed(license, feature)) {
-    throw new PlanLimitError(
-      `Feature "${feature}" requires a paid plan. Current plan: ${license.plan}. Upgrade at https://askexe.com.`
-    );
-  }
-}
-var PlanLimitError, CACHE_PATH2;
-var init_plan_limits = __esm({
-  "src/lib/plan-limits.ts"() {
-    "use strict";
-    init_database();
-    init_employees();
-    init_license();
-    init_config();
-    PlanLimitError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "PlanLimitError";
-      }
-    };
-    CACHE_PATH2 = path8.join(EXE_AI_DIR, "license-cache.json");
-  }
-});
-
 // src/lib/cloud-sync.ts
 var cloud_sync_exports = {};
 __export(cloud_sync_exports, {
@@ -2260,6 +2501,11 @@ async function initStore(options) {
   const vResult = await client.execute("SELECT MAX(version) as max_v FROM memories");
   _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
 }
+function classifyTier(record) {
+  if (record.tool_name === "commit_to_long_term_memory" && (record.importance ?? 0) >= 8) return 1;
+  if (["store_memory", "manual"].includes(record.tool_name ?? "") && (record.importance ?? 0) >= 5) return 2;
+  return 3;
+}
 async function writeMemory(record) {
   if (record.vector !== null && record.vector.length !== EMBEDDING_DIM) {
     throw new Error(
@@ -2287,7 +2533,11 @@ async function writeMemory(record) {
     document_id: record.document_id ?? null,
     user_id: record.user_id ?? null,
     char_offset: record.char_offset ?? null,
-    page_number: record.page_number ?? null
+    page_number: record.page_number ?? null,
+    source_path: record.source_path ?? null,
+    source_type: record.source_type ?? null,
+    tier: record.tier ?? classifyTier(record),
+    supersedes_id: record.supersedes_id ?? null
   };
   _pendingRecords.push(dbRow);
   if (_flushTimer === null) {
@@ -2319,20 +2569,26 @@ async function flushBatch() {
       const userId = row.user_id ?? null;
       const charOffset = row.char_offset ?? null;
       const pageNumber = row.page_number ?? null;
+      const sourcePath = row.source_path ?? null;
+      const sourceType = row.source_type ?? null;
+      const tier = row.tier ?? 3;
+      const supersedesId = row.supersedes_id ?? null;
       return {
         sql: hasVector ? `INSERT OR IGNORE INTO memories
               (id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
-               workspace_id, document_id, user_id, char_offset, page_number)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
+               workspace_id, document_id, user_id, char_offset, page_number,
+               source_path, source_type, tier, supersedes_id)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
               (id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
-               workspace_id, document_id, user_id, char_offset, page_number)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+               workspace_id, document_id, user_id, char_offset, page_number,
+               source_path, source_type, tier, supersedes_id)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         args: hasVector ? [
           row.id,
           row.agent_id,
@@ -2354,7 +2610,11 @@ async function flushBatch() {
           documentId,
           userId,
           charOffset,
-          pageNumber
+          pageNumber,
+          sourcePath,
+          sourceType,
+          tier,
+          supersedesId
         ] : [
           row.id,
           row.agent_id,
@@ -2375,7 +2635,11 @@ async function flushBatch() {
           documentId,
           userId,
           charOffset,
-          pageNumber
+          pageNumber,
+          sourcePath,
+          sourceType,
+          tier,
+          supersedesId
         ]
       };
     };
@@ -2523,6 +2787,12 @@ async function main() {
       primaryProject = p;
     }
   }
+  try {
+    const { assertMemoryLimit: assertMemoryLimit2 } = await Promise.resolve().then(() => (init_plan_limits(), plan_limits_exports));
+    await assertMemoryLimit2();
+  } catch {
+    process.exit(0);
+  }
   await writeMemory({
     id: crypto4.randomUUID(),
     agent_id: agentId,