@askexenow/exe-os 0.8.55 → 0.8.56

package/dist/hooks/summary-worker.js

@@ -1,5 +1,7 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -13,6 +15,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/types/memory.ts
 var EMBEDDING_DIM;
@@ -1347,6 +1358,61 @@ var init_config = __esm({
   }
 });
 
+// src/lib/state-bus.ts
+var StateBus, orgBus;
+var init_state_bus = __esm({
+  "src/lib/state-bus.ts"() {
+    "use strict";
+    StateBus = class {
+      handlers = /* @__PURE__ */ new Map();
+      globalHandlers = /* @__PURE__ */ new Set();
+      /** Emit an event to all subscribers */
+      emit(event) {
+        const typeHandlers = this.handlers.get(event.type);
+        if (typeHandlers) {
+          for (const handler of typeHandlers) {
+            try {
+              handler(event);
+            } catch {
+            }
+          }
+        }
+        for (const handler of this.globalHandlers) {
+          try {
+            handler(event);
+          } catch {
+          }
+        }
+      }
+      /** Subscribe to a specific event type */
+      on(type, handler) {
+        if (!this.handlers.has(type)) {
+          this.handlers.set(type, /* @__PURE__ */ new Set());
+        }
+        this.handlers.get(type).add(handler);
+      }
+      /** Subscribe to ALL events */
+      onAny(handler) {
+        this.globalHandlers.add(handler);
+      }
+      /** Unsubscribe from a specific event type */
+      off(type, handler) {
+        this.handlers.get(type)?.delete(handler);
+      }
+      /** Unsubscribe from ALL events */
+      offAny(handler) {
+        this.globalHandlers.delete(handler);
+      }
+      /** Remove all listeners */
+      clear() {
+        this.handlers.clear();
+        this.globalHandlers.clear();
+      }
+    };
+    orgBus = new StateBus();
+  }
+});
+
 // src/lib/shard-manager.ts
 var shard_manager_exports = {};
 __export(shard_manager_exports, {
@@ -1756,13 +1822,251 @@ ${p.content}`).join("\n\n");
   }
 });
 
+// src/lib/notifications.ts
+import crypto2 from "crypto";
+import path4 from "path";
+import os3 from "os";
+import {
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  unlinkSync,
+  existsSync as existsSync4,
+  rmdirSync
+} from "fs";
+async function writeNotification(notification) {
+  try {
+    const client = getClient();
+    const id = crypto2.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await client.execute({
+      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`,
+      args: [
+        id,
+        notification.agentId,
+        notification.agentRole,
+        notification.event,
+        notification.project,
+        notification.summary,
+        notification.taskFile ?? null,
+        now
+      ]
+    });
+  } catch (err) {
+    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+var init_notifications = __esm({
+  "src/lib/notifications.ts"() {
+    "use strict";
+    init_database();
+  }
+});
+
+// src/lib/session-registry.ts
+import path5 from "path";
+import os4 from "os";
+var REGISTRY_PATH;
+var init_session_registry = __esm({
+  "src/lib/session-registry.ts"() {
+    "use strict";
+    REGISTRY_PATH = path5.join(os4.homedir(), ".exe-os", "session-registry.json");
+  }
+});
+
+// src/lib/session-key.ts
+import { execSync } from "child_process";
+function getSessionKey() {
+  if (_cached) return _cached;
+  let pid = process.ppid;
+  for (let i = 0; i < 10; i++) {
+    try {
+      const info = execSync(`ps -p ${pid} -o ppid=,comm=`, {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      const match = info.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) break;
+      const [, ppid, cmd] = match;
+      if (cmd === "claude" || cmd.endsWith("/claude")) {
+        _cached = String(pid);
+        return _cached;
+      }
+      pid = parseInt(ppid, 10);
+      if (pid <= 1) break;
+    } catch {
+      break;
+    }
+  }
+  _cached = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
+  return _cached;
+}
+var _cached;
+var init_session_key = __esm({
+  "src/lib/session-key.ts"() {
+    "use strict";
+    _cached = null;
+  }
+});
+
+// src/lib/tmux-transport.ts
+var tmux_transport_exports = {};
+__export(tmux_transport_exports, {
+  TmuxTransport: () => TmuxTransport
+});
+import { execFileSync } from "child_process";
+var QUIET, TmuxTransport;
+var init_tmux_transport = __esm({
+  "src/lib/tmux-transport.ts"() {
+    "use strict";
+    QUIET = {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    };
+    TmuxTransport = class {
+      getMySession() {
+        try {
+          return execFileSync("tmux", ["display-message", "-p", "#{session_name}"], QUIET).trim() || null;
+        } catch {
+          return null;
+        }
+      }
+      listSessions() {
+        try {
+          return execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], QUIET).trim().split("\n").filter(Boolean);
+        } catch {
+          return [];
+        }
+      }
+      isAlive(target) {
+        try {
+          const sessions = this.listSessions();
+          if (!sessions.includes(target)) return false;
+          const paneStatus = execFileSync(
+            "tmux",
+            ["list-panes", "-t", target, "-F", "#{pane_dead}"],
+            QUIET
+          ).trim();
+          return paneStatus !== "1";
+        } catch {
+          return false;
+        }
+      }
+      sendKeys(target, keys) {
+        execFileSync("tmux", ["send-keys", "-t", target, keys, "Enter"], QUIET);
+      }
+      capturePane(target, lines) {
+        const args = ["capture-pane", "-t", target, "-p"];
+        if (lines) args.push("-S", `-${lines}`);
+        return execFileSync("tmux", args, { ...QUIET, timeout: 3e3 });
+      }
+      isPaneInCopyMode(target) {
+        try {
+          const result = execFileSync(
+            "tmux",
+            ["display-message", "-p", "-t", target, "#{pane_in_mode}"],
+            { ...QUIET, timeout: 3e3 }
+          ).trim();
+          return result === "1";
+        } catch {
+          return false;
+        }
+      }
+      spawn(name, config) {
+        try {
+          const args = ["new-session", "-d", "-s", name];
+          if (config.cwd) args.push("-c", config.cwd);
+          args.push(config.command);
+          execFileSync("tmux", args);
+          return { sessionName: name };
+        } catch (e) {
+          return { sessionName: name, error: `spawn failed: ${e}` };
+        }
+      }
+      kill(target) {
+        try {
+          execFileSync("tmux", ["kill-session", "-t", target], QUIET);
+        } catch {
+        }
+      }
+      pipeLog(target, logFile) {
+        try {
+          const safePath = logFile.replace(/'/g, "'\\''");
+          execFileSync("tmux", ["pipe-pane", "-t", target, `cat >> '${safePath}'`], QUIET);
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// src/lib/transport.ts
+function getTransport() {
+  if (!_transport) {
+    const { TmuxTransport: TmuxTransport2 } = (init_tmux_transport(), __toCommonJS(tmux_transport_exports));
+    _transport = new TmuxTransport2();
+  }
+  return _transport;
+}
+var _transport;
+var init_transport = __esm({
+  "src/lib/transport.ts"() {
+    "use strict";
+    _transport = null;
+  }
+});
+
+// src/lib/cc-agent-support.ts
+import { execSync as execSync2 } from "child_process";
+var init_cc_agent_support = __esm({
+  "src/lib/cc-agent-support.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/mcp-prefix.ts
+var MCP_PRIMARY_KEY, MCP_LEGACY_KEY, MCP_TOOL_PREFIXES;
+var init_mcp_prefix = __esm({
+  "src/lib/mcp-prefix.ts"() {
+    "use strict";
+    MCP_PRIMARY_KEY = "exe-os";
+    MCP_LEGACY_KEY = "exe-mem";
+    MCP_TOOL_PREFIXES = [
+      `mcp__${MCP_PRIMARY_KEY}__`,
+      `mcp__${MCP_LEGACY_KEY}__`
+    ];
+  }
+});
+
+// src/lib/provider-table.ts
+var init_provider_table = __esm({
+  "src/lib/provider-table.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/intercom-queue.ts
+import { readFileSync as readFileSync3, writeFileSync, renameSync as renameSync2, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import path6 from "path";
+import os5 from "os";
+var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
+var init_intercom_queue = __esm({
+  "src/lib/intercom-queue.ts"() {
+    "use strict";
+    QUEUE_PATH = path6.join(os5.homedir(), ".exe-os", "intercom-queue.json");
+    TTL_MS = 60 * 60 * 1e3;
+    INTERCOM_LOG = path6.join(os5.homedir(), ".exe-os", "intercom.log");
+  }
+});
+
 // src/lib/employees.ts
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync5, symlinkSync, readlinkSync, readFileSync as readFileSync3 } from "fs";
-import { execSync } from "child_process";
-import path5 from "path";
+import { existsSync as existsSync6, symlinkSync, readlinkSync, readFileSync as readFileSync4 } from "fs";
+import { execSync as execSync3 } from "child_process";
+import path7 from "path";
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync5(employeesPath)) {
+  if (!existsSync6(employeesPath)) {
     return [];
   }
   const raw = await readFile3(employeesPath, "utf-8");
@@ -1773,12 +2077,12 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
   }
 }
 async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir3(path5.dirname(employeesPath), { recursive: true });
+  await mkdir3(path7.dirname(employeesPath), { recursive: true });
   await writeFile3(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
 function findExeBin() {
   try {
-    return execSync(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+    return execSync3(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
   } catch {
     return null;
   }
@@ -1792,7 +2096,7 @@ function registerBinSymlinks(name) {
     errors.push("Could not find 'exe-os' in PATH");
     return { created, skipped, errors };
   }
-  const binDir = path5.dirname(exeBinPath);
+  const binDir = path7.dirname(exeBinPath);
   let target;
   try {
     target = readlinkSync(exeBinPath);
@@ -1802,8 +2106,8 @@ function registerBinSymlinks(name) {
   }
   for (const suffix of ["", "-opencode"]) {
     const linkName = `${name}${suffix}`;
-    const linkPath = path5.join(binDir, linkName);
-    if (existsSync5(linkPath)) {
+    const linkPath = path7.join(binDir, linkName);
+    if (existsSync6(linkPath)) {
       skipped.push(linkName);
       continue;
     }
@@ -1821,14 +2125,30 @@ var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
-    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
+    EMPLOYEES_PATH = path7.join(EXE_AI_DIR, "exe-employees.json");
   }
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
+var license_exports = {};
+__export(license_exports, {
+  LICENSE_PUBLIC_KEY_PEM: () => LICENSE_PUBLIC_KEY_PEM,
+  PLAN_LIMITS: () => PLAN_LIMITS,
+  assertVpsLicense: () => assertVpsLicense,
+  checkLicense: () => checkLicense,
+  getCachedLicense: () => getCachedLicense,
+  isFeatureAllowed: () => isFeatureAllowed,
+  loadDeviceId: () => loadDeviceId,
+  loadLicense: () => loadLicense,
+  mirrorLicenseKey: () => mirrorLicenseKey,
+  saveLicense: () => saveLicense,
+  startLicenseRevalidation: () => startLicenseRevalidation,
+  stopLicenseRevalidation: () => stopLicenseRevalidation,
+  validateLicense: () => validateLicense
+});
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import path6 from "path";
+import path8 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -1839,37 +2159,37 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path6.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path8.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync6(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync4(deviceJsonPath, "utf8"));
+    if (existsSync7(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync5(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync6(DEVICE_ID_PATH)) {
-      const id2 = readFileSync4(DEVICE_ID_PATH, "utf8").trim();
+    if (existsSync7(DEVICE_ID_PATH)) {
+      const id2 = readFileSync5(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");
+  mkdirSync3(EXE_AI_DIR, { recursive: true });
+  writeFileSync2(DEVICE_ID_PATH, id, "utf8");
   return id;
 }
 function loadLicense() {
   try {
-    if (!existsSync6(LICENSE_PATH)) return null;
-    return readFileSync4(LICENSE_PATH, "utf8").trim();
+    if (!existsSync7(LICENSE_PATH)) return null;
+    return readFileSync5(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
 }
 function saveLicense(apiKey) {
-  mkdirSync2(EXE_AI_DIR, { recursive: true });
-  writeFileSync(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+  mkdirSync3(EXE_AI_DIR, { recursive: true });
+  writeFileSync2(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
 }
 async function verifyLicenseJwt(token) {
   try {
@@ -1895,17 +2215,26 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync6(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync4(CACHE_PATH, "utf8"));
+    if (!existsSync7(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync5(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
     return null;
   }
 }
+function readCachedToken() {
+  try {
+    if (!existsSync7(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync5(CACHE_PATH, "utf8"));
+    return typeof raw.token === "string" ? raw.token : null;
+  } catch {
+    return null;
+  }
+}
 function cacheResponse(token) {
   try {
-    writeFileSync(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    writeFileSync2(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
@@ -1963,9 +2292,9 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path6.join(EXE_AI_DIR, "config.json");
-      if (existsSync6(configPath)) {
-        const raw = JSON.parse(readFileSync4(configPath, "utf8"));
+      const configPath = path8.join(EXE_AI_DIR, "config.json");
+      if (existsSync7(configPath)) {
+        const raw = JSON.parse(readFileSync5(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
           key = cloud.apiKey;
@@ -1991,14 +2320,142 @@ function isFeatureAllowed(license, feature) {
       return license.plan === "team" || license.plan === "agency" || license.plan === "enterprise";
   }
 }
-var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, RETRY_DELAY_MS, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE, CACHE_MAX_AGE_MS;
+function mirrorLicenseKey(apiKey) {
+  const trimmed = apiKey.trim();
+  if (!trimmed) return;
+  saveLicense(trimmed);
+}
+async function assertVpsLicense(opts) {
+  const env = opts?.env ?? process.env;
+  const inProduction = env.NODE_ENV === "production";
+  if (!opts?.force && !inProduction) {
+    return { ...FREE_LICENSE, plan: "free" };
+  }
+  const envKey = env.EXE_LICENSE_KEY?.trim();
+  if (envKey) {
+    saveLicense(envKey);
+  }
+  const apiKey = envKey ?? loadLicense();
+  if (!apiKey) {
+    throw new Error(
+      "License required: set EXE_LICENSE_KEY env var with your exe_sk_* key. Purchase at https://askexe.com. This VPS image refuses to boot without a valid license."
+    );
+  }
+  const deviceId = loadDeviceId();
+  let backendResponse = null;
+  let explicitRejection = false;
+  let transientFailure = false;
+  try {
+    const res = await fetchRetry(`${API_BASE}/auth/activate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ apiKey, deviceId }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.ok) {
+      backendResponse = await res.json();
+      if (!backendResponse.valid) explicitRejection = true;
+    } else if (res.status === 401 || res.status === 403) {
+      explicitRejection = true;
+    } else {
+      transientFailure = true;
+    }
+  } catch {
+    transientFailure = true;
+  }
+  if (backendResponse?.valid) {
+    if (backendResponse.token) {
+      cacheResponse(backendResponse.token);
+      const verified = await verifyLicenseJwt(backendResponse.token);
+      if (verified) return verified;
+    }
+    const limits = PLAN_LIMITS[backendResponse.plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan: backendResponse.plan,
+      email: backendResponse.email,
+      expiresAt: backendResponse.expiresAt,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  }
+  if (explicitRejection) {
+    throw new Error(
+      `License invalid or expired. Renew at https://askexe.com, then restart. Backend rejected key ending in ...${apiKey.slice(-4)}.`
+    );
+  }
+  if (!transientFailure) {
+    throw new Error(
+      "License validation failed: unknown backend state. Restore network connectivity to https://askexe.com/cloud and retry."
+    );
+  }
+  const fresh = await getCachedLicense();
+  if (fresh && fresh.valid) return fresh;
+  const graceDays = opts?.offlineGraceDays ?? 7;
+  const graceMs = graceDays * 24 * 60 * 60 * 1e3;
+  try {
+    const token = readCachedToken();
+    if (token) {
+      const payloadB64 = token.split(".")[1];
+      if (payloadB64) {
+        const payload = JSON.parse(Buffer.from(payloadB64, "base64url").toString());
+        const expMs = (payload.exp ?? 0) * 1e3;
+        if (Date.now() < expMs + graceMs) {
+          const key = await importSPKI(LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG);
+          const { payload: verified } = await jwtVerify(token, key, {
+            algorithms: [LICENSE_JWT_ALG],
+            clockTolerance: graceDays * 24 * 60 * 60
+          });
+          const plan = verified.plan ?? "free";
+          const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+          return {
+            valid: true,
+            plan,
+            email: verified.sub ?? "",
+            expiresAt: verified.exp ? new Date(verified.exp * 1e3).toISOString() : null,
+            deviceLimit: limits.devices,
+            employeeLimit: limits.employees,
+            memoryLimit: limits.memories
+          };
+        }
+      }
+    }
+  } catch {
+  }
+  throw new Error(
+    `License validation unreachable for more than ${graceDays} days. Restore network connectivity to https://askexe.com/cloud and retry. This VPS image refuses to boot after the offline grace window.`
+  );
+}
+function startLicenseRevalidation(intervalMs = 36e5) {
+  if (_revalTimer) return;
+  _revalTimer = setInterval(async () => {
+    try {
+      const license = await checkLicense();
+      if (!license.valid) {
+        process.stderr.write("[exe-os] License expired or invalid \u2014 features may be restricted\n");
+      }
+    } catch {
+    }
+  }, intervalMs);
+  if (_revalTimer && typeof _revalTimer === "object" && "unref" in _revalTimer) {
+    _revalTimer.unref();
+  }
+}
+function stopLicenseRevalidation() {
+  if (_revalTimer) {
+    clearInterval(_revalTimer);
+    _revalTimer = null;
+  }
+}
+var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, RETRY_DELAY_MS, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE, CACHE_MAX_AGE_MS, _revalTimer;
 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");
+    LICENSE_PATH = path8.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path8.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path8.join(EXE_AI_DIR, "device-id");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -2023,6 +2480,7 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
       memoryLimit: 5e3
     };
     CACHE_MAX_AGE_MS = 36e5;
+    _revalTimer = null;
   }
 });
 
@@ -2037,12 +2495,12 @@ __export(plan_limits_exports, {
   countActiveMemories: () => countActiveMemories,
   getLicenseSync: () => getLicenseSync
 });
-import { readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
-import path7 from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import path9 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync7(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync5(CACHE_PATH2, "utf8"));
+    if (!existsSync8(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync6(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -2109,8 +2567,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync7(filePath)) {
-      const raw = readFileSync5(filePath, "utf8");
+    if (existsSync8(filePath)) {
+      const raw = readFileSync6(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -2147,7 +2605,60 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path7.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path9.join(EXE_AI_DIR, "license-cache.json");
+  }
+});
+
+// src/lib/tmux-routing.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync9, appendFileSync } from "fs";
+import path10 from "path";
+import os6 from "os";
+import { fileURLToPath } from "url";
+function getMySession() {
+  return getTransport().getMySession();
+}
+function extractRootExe(name) {
+  const match = name.match(/(exe\d+)$/);
+  return match?.[1] ?? null;
+}
+function getParentExe(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync7(path10.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    return data.parentExe || null;
+  } catch {
+    return null;
+  }
+}
+function resolveExeSession() {
+  const mySession = getMySession();
+  if (!mySession) return null;
+  try {
+    const key = getSessionKey();
+    const parentExe = getParentExe(key);
+    if (parentExe) {
+      return extractRootExe(parentExe) ?? parentExe;
+    }
+  } catch {
+  }
+  return extractRootExe(mySession) ?? mySession;
+}
+var SPAWN_LOCK_DIR, SESSION_CACHE, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS;
+var init_tmux_routing = __esm({
+  "src/lib/tmux-routing.ts"() {
+    "use strict";
+    init_session_registry();
+    init_session_key();
+    init_transport();
+    init_cc_agent_support();
+    init_mcp_prefix();
+    init_provider_table();
+    init_intercom_queue();
+    init_plan_limits();
+    SPAWN_LOCK_DIR = path10.join(os6.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path10.join(os6.homedir(), ".exe-os", "session-cache");
+    INTERCOM_LOG2 = path10.join(os6.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path10.join(SESSION_CACHE, "intercom-debounce.json");
+    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
   }
 });
 
@@ -2155,9 +2666,9 @@ var init_plan_limits = __esm({
 import net from "net";
 import { spawn } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync8, unlinkSync as unlinkSync2, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
-import path8 from "path";
-import { fileURLToPath } from "url";
+import { existsSync as existsSync10, unlinkSync as unlinkSync2, readFileSync as readFileSync8, openSync, closeSync, statSync } from "fs";
+import path11 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
   if (_buffer.length > MAX_BUFFER) {
@@ -2182,9 +2693,9 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync8(PID_PATH)) {
+  if (existsSync10(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync8(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -2205,11 +2716,11 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path8.dirname(fileURLToPath(import.meta.url));
-  const { root } = path8.parse(dir);
+  let dir = path11.dirname(fileURLToPath2(import.meta.url));
+  const { root } = path11.parse(dir);
   while (dir !== root) {
-    if (existsSync8(path8.join(dir, "package.json"))) return dir;
-    dir = path8.dirname(dir);
+    if (existsSync10(path11.join(dir, "package.json"))) return dir;
+    dir = path11.dirname(dir);
   }
   return null;
 }
@@ -2219,8 +2730,8 @@ function spawnDaemon() {
     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)) {
+  const daemonPath = path11.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync10(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
     return;
@@ -2228,7 +2739,7 @@ function spawnDaemon() {
   const resolvedPath = daemonPath;
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path8.join(path8.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path11.join(path11.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -2390,9 +2901,9 @@ async function pingDaemon() {
 }
 function killAndRespawnDaemon() {
   process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync8(PID_PATH)) {
+  if (existsSync10(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync8(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, "SIGKILL");
@@ -2476,9 +2987,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 ?? 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");
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path11.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path11.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path11.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
@@ -2529,10 +3040,10 @@ async function disposeEmbedder() {
 async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync11 } = await import("fs");
-  const path12 = await import("path");
-  const modelPath = path12.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync11(modelPath)) {
+  const { existsSync: existsSync13 } = await import("fs");
+  const path15 = await import("path");
+  const modelPath = path15.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync13(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -2568,11 +3079,11 @@ __export(worker_gate_exports, {
   registerWorkerPid: () => registerWorkerPid,
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
-import { readdirSync as readdirSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync3, mkdirSync as mkdirSync3 } from "fs";
-import path9 from "path";
+import { readdirSync as readdirSync3, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, mkdirSync as mkdirSync5 } from "fs";
+import path12 from "path";
 function tryAcquireWorkerSlot() {
   try {
-    mkdirSync3(WORKER_PID_DIR, { recursive: true });
+    mkdirSync5(WORKER_PID_DIR, { recursive: true });
     const files = readdirSync3(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
@@ -2585,7 +3096,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync3(path9.join(WORKER_PID_DIR, f));
+          unlinkSync3(path12.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -2597,14 +3108,14 @@ function tryAcquireWorkerSlot() {
 }
 function registerWorkerPid(pid) {
   try {
-    mkdirSync3(WORKER_PID_DIR, { recursive: true });
-    writeFileSync2(path9.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    mkdirSync5(WORKER_PID_DIR, { recursive: true });
+    writeFileSync4(path12.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync3(path9.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync3(path12.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
@@ -2613,7 +3124,7 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path9.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path12.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
   }
 });
@@ -2725,14 +3236,14 @@ __export(cloud_sync_exports, {
   mergeRosterFromRemote: () => mergeRosterFromRemote,
   recordRosterDeletion: () => recordRosterDeletion
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync9, readdirSync as readdirSync4, mkdirSync as mkdirSync4, appendFileSync, unlinkSync as unlinkSync4, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync11, readdirSync as readdirSync4, mkdirSync as mkdirSync6, appendFileSync as appendFileSync2, unlinkSync as unlinkSync4, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto4 from "crypto";
-import path10 from "path";
+import path13 from "path";
 import { homedir } from "os";
 function logError(msg) {
   try {
-    const logPath = path10.join(homedir(), ".exe-os", "workers.log");
-    appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+    const logPath = path13.join(homedir(), ".exe-os", "workers.log");
+    appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
   }
@@ -2741,18 +3252,18 @@ async function withRosterLock(fn) {
   try {
     const fd = openSync2(ROSTER_LOCK_PATH, "wx");
     closeSync2(fd);
-    writeFileSync3(ROSTER_LOCK_PATH, String(Date.now()));
+    writeFileSync5(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts = parseInt(readFileSync7(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts = parseInt(readFileSync9(ROSTER_LOCK_PATH, "utf-8"), 10);
         if (Date.now() - ts < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
         unlinkSync4(ROSTER_LOCK_PATH);
         const fd = openSync2(ROSTER_LOCK_PATH, "wx");
         closeSync2(fd);
-        writeFileSync3(ROSTER_LOCK_PATH, String(Date.now()));
+        writeFileSync5(ROSTER_LOCK_PATH, String(Date.now()));
       } catch (retryErr) {
         if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
@@ -3059,48 +3570,48 @@ async function cloudSync(config) {
 function recordRosterDeletion(name) {
   let deletions = [];
   try {
-    if (existsSync9(ROSTER_DELETIONS_PATH)) {
-      deletions = JSON.parse(readFileSync7(ROSTER_DELETIONS_PATH, "utf-8"));
+    if (existsSync11(ROSTER_DELETIONS_PATH)) {
+      deletions = JSON.parse(readFileSync9(ROSTER_DELETIONS_PATH, "utf-8"));
     }
   } catch {
   }
   if (!deletions.includes(name)) deletions.push(name);
-  writeFileSync3(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
+  writeFileSync5(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
 }
 function consumeRosterDeletions() {
   try {
-    if (!existsSync9(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync7(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync3(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync11(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync9(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync5(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
     return [];
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path10.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path10.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path10.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path13.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path13.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path13.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync9(rosterPath)) {
+  if (existsSync11(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync7(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync9(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync9(identityDir)) {
+  if (existsSync11(identityDir)) {
     for (const file of readdirSync4(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync7(path10.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync9(path13.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config;
-  if (existsSync9(configPath)) {
+  if (existsSync11(configPath)) {
     try {
-      config = JSON.parse(readFileSync7(configPath, "utf-8"));
+      config = JSON.parse(readFileSync9(configPath, "utf-8"));
     } catch {
     }
   }
@@ -3176,23 +3687,23 @@ async function cloudPullRoster(config) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path10.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path13.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync9(cfgPath)) {
+  if (existsSync11(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync7(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync9(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path10.dirname(cfgPath);
-  if (!existsSync9(dir)) mkdirSync4(dir, { recursive: true });
-  writeFileSync3(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  const dir = path13.dirname(cfgPath);
+  if (!existsSync11(dir)) mkdirSync6(dir, { recursive: true });
+  writeFileSync5(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path10.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path13.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -3202,10 +3713,10 @@ async function mergeRosterFromRemote(remote, paths) {
       localNames.add(remoteEmp.name);
       added++;
       if (remote.identities[`${remoteEmp.name}.md`]) {
-        if (!existsSync9(identityDir)) mkdirSync4(identityDir, { recursive: true });
-        const idPath = path10.join(identityDir, `${remoteEmp.name}.md`);
-        if (!existsSync9(idPath)) {
-          writeFileSync3(idPath, remote.identities[`${remoteEmp.name}.md`], "utf-8");
+        if (!existsSync11(identityDir)) mkdirSync6(identityDir, { recursive: true });
+        const idPath = path13.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync11(idPath)) {
+          writeFileSync5(idPath, remote.identities[`${remoteEmp.name}.md`], "utf-8");
         }
       }
       try {
@@ -3665,9 +4176,9 @@ var init_cloud_sync = __esm({
     LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
     FETCH_TIMEOUT_MS = 3e4;
     PUSH_BATCH_SIZE = 5e3;
-    ROSTER_LOCK_PATH = path10.join(EXE_AI_DIR, "roster-merge.lock");
+    ROSTER_LOCK_PATH = path13.join(EXE_AI_DIR, "roster-merge.lock");
     LOCK_STALE_MS = 3e4;
-    ROSTER_DELETIONS_PATH = path10.join(EXE_AI_DIR, "roster-deletions.json");
+    ROSTER_DELETIONS_PATH = path13.join(EXE_AI_DIR, "roster-deletions.json");
   }
 });
 
@@ -3676,57 +4187,7 @@ init_memory();
 init_database();
 init_keychain();
 init_config();
-
-// src/lib/state-bus.ts
-var StateBus = class {
-  handlers = /* @__PURE__ */ new Map();
-  globalHandlers = /* @__PURE__ */ new Set();
-  /** Emit an event to all subscribers */
-  emit(event) {
-    const typeHandlers = this.handlers.get(event.type);
-    if (typeHandlers) {
-      for (const handler of typeHandlers) {
-        try {
-          handler(event);
-        } catch {
-        }
-      }
-    }
-    for (const handler of this.globalHandlers) {
-      try {
-        handler(event);
-      } catch {
-      }
-    }
-  }
-  /** Subscribe to a specific event type */
-  on(type, handler) {
-    if (!this.handlers.has(type)) {
-      this.handlers.set(type, /* @__PURE__ */ new Set());
-    }
-    this.handlers.get(type).add(handler);
-  }
-  /** Subscribe to ALL events */
-  onAny(handler) {
-    this.globalHandlers.add(handler);
-  }
-  /** Unsubscribe from a specific event type */
-  off(type, handler) {
-    this.handlers.get(type)?.delete(handler);
-  }
-  /** Unsubscribe from ALL events */
-  offAny(handler) {
-    this.globalHandlers.delete(handler);
-  }
-  /** Remove all listeners */
-  clear() {
-    this.handlers.clear();
-    this.globalHandlers.clear();
-  }
-};
-var orgBus = new StateBus();
-
-// src/lib/store.ts
+init_state_bus();
 var INIT_MAX_RETRIES = 3;
 var INIT_RETRY_DELAY_MS = 1e3;
 function isBusyError2(err) {
@@ -4005,49 +4466,32 @@ function vectorToBlob(vector) {
 
 // src/adapters/claude/hooks/summary-worker.ts
 init_database();
+init_notifications();
 import crypto5 from "crypto";
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, openSync as openSync3, closeSync as closeSync3 } from "fs";
+import path14 from "path";
 
-// src/lib/notifications.ts
-init_database();
-import crypto2 from "crypto";
-import path4 from "path";
-import os3 from "os";
-import {
-  readFileSync as readFileSync2,
-  readdirSync as readdirSync2,
-  unlinkSync,
-  existsSync as existsSync4,
-  rmdirSync
-} from "fs";
-async function writeNotification(notification) {
+// src/lib/task-scope.ts
+init_tmux_routing();
+function getCurrentSessionScope() {
   try {
-    const client = getClient();
-    const id = crypto2.randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await client.execute({
-      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`,
-      args: [
-        id,
-        notification.agentId,
-        notification.agentRole,
-        notification.event,
-        notification.project,
-        notification.summary,
-        notification.taskFile ?? null,
-        now
-      ]
-    });
-  } catch (err) {
-    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
+    return resolveExeSession();
+  } catch {
+    return null;
   }
 }
+function sessionScopeFilter(sessionScope, tableAlias) {
+  const scope = sessionScope !== void 0 ? sessionScope : getCurrentSessionScope();
+  if (!scope) return { sql: "", args: [] };
+  const col = tableAlias ? `${tableAlias}.session_scope` : "session_scope";
+  return {
+    sql: ` AND (${col} IS NULL OR ${col} = ?)`,
+    args: [scope]
+  };
+}
 
 // src/adapters/claude/hooks/summary-worker.ts
-import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, openSync as openSync3, closeSync as closeSync3 } from "fs";
-import path11 from "path";
 async function main() {
   const agentId = process.env.AGENT_ID ?? "default";
   const agentRole = process.env.AGENT_ROLE ?? "employee";
@@ -4171,20 +4615,20 @@ async function main() {
   }
   try {
     const { EXE_AI_DIR: EXE_AI_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const flagPath = path11.join(EXE_AI_DIR2, "session-cache", "needs-backfill");
-    if (existsSync10(flagPath)) {
+    const flagPath = path14.join(EXE_AI_DIR2, "session-cache", "needs-backfill");
+    if (existsSync12(flagPath)) {
       const { tryAcquireWorkerSlot: tryAcquireWorkerSlot2, registerWorkerPid: registerWorkerPid2 } = await Promise.resolve().then(() => (init_worker_gate(), worker_gate_exports));
       if (!tryAcquireWorkerSlot2()) {
         process.stderr.write("[summary-worker] Backfill needed but worker gate full \u2014 skipping\n");
       } else {
         const { spawn: spawn2 } = await import("child_process");
-        const { fileURLToPath: fileURLToPath2 } = await import("url");
-        const thisFile = fileURLToPath2(import.meta.url);
-        const backfillPath = path11.resolve(path11.dirname(thisFile), "backfill-vectors.js");
-        if (existsSync10(backfillPath)) {
+        const { fileURLToPath: fileURLToPath3 } = await import("url");
+        const thisFile = fileURLToPath3(import.meta.url);
+        const backfillPath = path14.resolve(path14.dirname(thisFile), "backfill-vectors.js");
+        if (existsSync12(backfillPath)) {
           const { EXE_AI_DIR: exeDir2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-          const bLogPath = path11.join(exeDir2, "workers.log");
-          mkdirSync5(path11.dirname(bLogPath), { recursive: true });
+          const bLogPath = path14.join(exeDir2, "workers.log");
+          mkdirSync7(path14.dirname(bLogPath), { recursive: true });
           const bLogFd = openSync3(bLogPath, "a");
           const child = spawn2(process.execPath, [backfillPath], {
             detached: true,
@@ -4210,26 +4654,33 @@ async function main() {
     const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
     const cfg = await loadConfig2();
     if (cfg.cloud?.apiKey) {
-      const { initSyncCrypto: initSyncCrypto2, isSyncCryptoInitialized: isSyncCryptoInitialized2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
-      if (!isSyncCryptoInitialized2()) {
-        const { getMasterKey: getMasterKey2 } = await Promise.resolve().then(() => (init_keychain(), keychain_exports));
-        const mk = await getMasterKey2();
-        if (mk) initSyncCrypto2(mk);
+      const { checkLicense: checkLicense2, isFeatureAllowed: isFeatureAllowed2 } = await Promise.resolve().then(() => (init_license(), license_exports));
+      const license = await checkLicense2();
+      if (!isFeatureAllowed2(license, "cloud_sync")) {
+      } else {
+        const { initSyncCrypto: initSyncCrypto2, isSyncCryptoInitialized: isSyncCryptoInitialized2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+        if (!isSyncCryptoInitialized2()) {
+          const { getMasterKey: getMasterKey2 } = await Promise.resolve().then(() => (init_keychain(), keychain_exports));
+          const mk = await getMasterKey2();
+          if (mk) initSyncCrypto2(mk);
+        }
+        const { cloudSync: cloudSync2 } = await Promise.resolve().then(() => (init_cloud_sync(), cloud_sync_exports));
+        await cloudSync2({ apiKey: cfg.cloud.apiKey, endpoint: cfg.cloud.endpoint });
       }
-      const { cloudSync: cloudSync2 } = await Promise.resolve().then(() => (init_cloud_sync(), cloud_sync_exports));
-      await cloudSync2({ apiKey: cfg.cloud.apiKey, endpoint: cfg.cloud.endpoint });
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    const stack = err instanceof Error && err.stack ? "\n  " + err.stack.split("\n").slice(1, 4).join("\n  ") : "";
-    process.stderr.write(`[summary-worker] cloud sync failed: ${msg}${stack}
+    if (!msg.includes("requires a paid plan")) {
+      process.stderr.write(`[summary-worker] cloud sync failed: ${msg}
 `);
+    }
   }
   if (agentId !== "exe" && agentId !== "default") {
     try {
+      const swScope = sessionScopeFilter();
       const inProgressResult = await client.execute({
-        sql: "SELECT id, title, task_file FROM tasks WHERE assigned_to = ? AND status = 'in_progress'",
-        args: [agentId]
+        sql: `SELECT id, title, task_file FROM tasks WHERE assigned_to = ? AND status = 'in_progress'${swScope.sql}`,
+        args: [agentId, ...swScope.args]
       });
       for (const taskRow of inProgressResult.rows) {
         const taskFile = String(taskRow.task_file);
@@ -4237,7 +4688,7 @@ async function main() {
         const taskTitle = String(taskRow.title);
         let lastCommit = "";
         try {
-          lastCommit = execSync2("git log --oneline -1 --since='30 minutes ago'", {
+          lastCommit = execSync4("git log --oneline -1 --since='30 minutes ago'", {
             encoding: "utf8",
             timeout: 5e3
           }).trim();