@askexenow/exe-os 0.9.70 → 0.9.71

package/dist/hooks/post-tool-combined.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/lib/secure-files.ts
 import { chmodSync, existsSync, mkdirSync } from "fs";
@@ -1218,6 +1229,17 @@ var init_daemon_auth = __esm({
 });
 
 // src/lib/exe-daemon-client.ts
+var exe_daemon_client_exports = {};
+__export(exe_daemon_client_exports, {
+  connectEmbedDaemon: () => connectEmbedDaemon,
+  disconnectClient: () => disconnectClient,
+  embedBatchViaClient: () => embedBatchViaClient,
+  embedViaClient: () => embedViaClient,
+  isClientConnected: () => isClientConnected,
+  pingDaemon: () => pingDaemon,
+  sendDaemonRequest: () => sendDaemonRequest,
+  sendIngestRequest: () => sendIngestRequest
+});
 import net from "net";
 import os4 from "os";
 import { spawn } from "child_process";
@@ -1285,8 +1307,8 @@ function findPackageRoot() {
 function getAvailableMemoryGB() {
   if (process.platform === "darwin") {
     try {
-      const { execSync: execSync7 } = __require("child_process");
-      const vmstat = execSync7("vm_stat", { encoding: "utf8" });
+      const { execSync: execSync8 } = __require("child_process");
+      const vmstat = execSync8("vm_stat", { encoding: "utf8" });
       const pageSize = 16384;
       const pageSizeMatch = vmstat.match(/page size of (\d+) bytes/);
       const actualPageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : pageSize;
@@ -1606,6 +1628,15 @@ async function embedViaClient(text, priority = "high") {
   );
   return !result.error && result.vectors?.[0] ? result.vectors[0] : null;
 }
+async function embedBatchViaClient(texts, priority = "high") {
+  if (!_connected && !await connectEmbedDaemon()) return null;
+  _requestCount++;
+  const result = await retryThenRestart(
+    () => sendRequest(texts, priority),
+    "Batch embed"
+  );
+  return !result.error && result.vectors ? result.vectors : null;
+}
 function disconnectClient() {
   if (_socket) {
     _socket.destroy();
@@ -1622,6 +1653,17 @@ function disconnectClient() {
 function isClientConnected() {
   return _connected;
 }
+function sendIngestRequest(payload) {
+  if (!_socket || !_connected) return false;
+  try {
+    const id = randomUUID();
+    const token = process.env[DAEMON_TOKEN_ENV] ?? readDaemonToken();
+    _socket.write(JSON.stringify({ id, token, type: "ingest", ...payload }) + "\n");
+    return true;
+  } catch {
+    return false;
+  }
+}
 var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, DAEMON_TOKEN_ENV, _socket, _connected, _buffer, _requestCount, _consecutiveFailures, HEALTH_CHECK_INTERVAL, MAX_RETRIES_BEFORE_RESTART, RETRY_DELAYS_MS, MIN_DAEMON_AGE_MS, _pending, MAX_BUFFER;
 var init_exe_daemon_client = __esm({
   "src/lib/exe-daemon-client.ts"() {
@@ -1650,6 +1692,15 @@ var init_exe_daemon_client = __esm({
 });
 
 // src/lib/daemon-protocol.ts
+var daemon_protocol_exports = {};
+__export(daemon_protocol_exports, {
+  deserializeArgs: () => deserializeArgs,
+  deserializeResultSet: () => deserializeResultSet,
+  deserializeValue: () => deserializeValue,
+  serializeArgs: () => serializeArgs,
+  serializeResultSet: () => serializeResultSet,
+  serializeValue: () => serializeValue
+});
 function serializeValue(v) {
   if (v === null || v === void 0) return null;
   if (typeof v === "bigint") return Number(v);
@@ -1674,6 +1725,32 @@ function deserializeValue(v) {
   }
   return v;
 }
+function serializeArgs(args) {
+  return args.map(serializeValue);
+}
+function deserializeArgs(args) {
+  return args.map(deserializeValue);
+}
+function serializeResultSet(rs) {
+  const rows = [];
+  for (const row of rs.rows) {
+    const obj = {};
+    for (let i = 0; i < rs.columns.length; i++) {
+      const col = rs.columns[i];
+      if (col !== void 0) {
+        obj[col] = serializeValue(row[i]);
+      }
+    }
+    rows.push(obj);
+  }
+  return {
+    columns: [...rs.columns],
+    columnTypes: [...rs.columnTypes ?? []],
+    rows,
+    rowsAffected: typeof rs.rowsAffected === "bigint" ? Number(rs.rowsAffected) : rs.rowsAffected ?? 0,
+    lastInsertRowid: rs.lastInsertRowid != null ? typeof rs.lastInsertRowid === "bigint" ? Number(rs.lastInsertRowid) : rs.lastInsertRowid : null
+  };
+}
 function deserializeResultSet(srs) {
   const rows = srs.rows.map((obj) => {
     const values = srs.columns.map(
@@ -2613,6 +2690,33 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_chat_history_session
       ON chat_history(session_id, id);
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_events (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      session_scope TEXT,
+      project_name  TEXT NOT NULL,
+      event_index   INTEGER NOT NULL,
+      event_type    TEXT NOT NULL,
+      tool_name     TEXT,
+      tool_use_id   TEXT,
+      content       TEXT NOT NULL,
+      payload_json  TEXT,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_agent_time
+      ON session_events(agent_id, created_at DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_session_index
+      ON session_events(session_id, event_index);
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_scope_agent_time
+      ON session_events(session_scope, agent_id, created_at DESC);
+  `);
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS workspaces (
       id              TEXT PRIMARY KEY,
@@ -3380,8 +3484,8 @@ function deriveMachineKey() {
 }
 function readMachineId() {
   try {
-    const { readFileSync: readFileSync8 } = __require("fs");
-    return readFileSync8("/etc/machine-id", "utf-8").trim();
+    const { readFileSync: readFileSync13 } = __require("fs");
+    return readFileSync13("/etc/machine-id", "utf-8").trim();
   } catch {
     return "";
   }
@@ -5776,10 +5880,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 path13 = await import("path");
-  const modelPath = path13.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync11(modelPath)) {
+  const { existsSync: existsSync17 } = await import("fs");
+  const path20 = await import("path");
+  const modelPath = path20.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync17(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -6870,10 +6974,10 @@ async function hybridSearch(queryText, agentId, options) {
     };
     try {
       const fs = await import("fs");
-      const path13 = await import("path");
-      const os6 = await import("os");
-      const logPath = path13.join(os6.homedir(), ".exe-os", "search-quality.jsonl");
-      fs.mkdirSync(path13.dirname(logPath), { recursive: true });
+      const path20 = await import("path");
+      const os11 = await import("os");
+      const logPath = path20.join(os11.homedir(), ".exe-os", "search-quality.jsonl");
+      fs.mkdirSync(path20.dirname(logPath), { recursive: true });
       fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
     } catch {
     }
@@ -7407,8 +7511,8 @@ function findContainingChunk(filePath, snippet) {
   try {
     const ext = filePath.split(".").pop()?.toLowerCase();
     if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
-    const { readFileSync: readFileSync8 } = __require("fs");
-    const source = readFileSync8(filePath, "utf8");
+    const { readFileSync: readFileSync13 } = __require("fs");
+    const source = readFileSync13(filePath, "utf8");
     const lines = source.split("\n");
     const lowerSnippet = snippet.toLowerCase().slice(0, 80);
     let matchLine = -1;
@@ -7474,9 +7578,9 @@ function extractBash(input2, response) {
 }
 function extractGrep(input2, response) {
   const pattern = String(input2.pattern ?? "");
-  const path13 = input2.path ? String(input2.path) : "";
+  const path20 = input2.path ? String(input2.path) : "";
   const output = String(response.text ?? response.content ?? JSON.stringify(response).slice(0, MAX_OUTPUT));
-  return `Searched for "${pattern}"${path13 ? ` in ${path13}` : ""}
+  return `Searched for "${pattern}"${path20 ? ` in ${path20}` : ""}
 ${output.slice(0, MAX_OUTPUT)}`;
 }
 function extractGlob(input2, response) {
@@ -7881,6 +7985,551 @@ var init_active_agent2 = __esm({
   }
 });
 
+// src/bin/fast-db-init.ts
+var fast_db_init_exports = {};
+__export(fast_db_init_exports, {
+  fastDbInit: () => fastDbInit
+});
+async function fastDbInit() {
+  const { isInitialized: isInitialized2, getClient: getClient2, setExternalClient: setExternalClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+  if (isInitialized2()) {
+    return getClient2();
+  }
+  try {
+    const { connectEmbedDaemon: connectEmbedDaemon2, sendDaemonRequest: sendDaemonRequest2, isClientConnected: isClientConnected2 } = await Promise.resolve().then(() => (init_exe_daemon_client(), exe_daemon_client_exports));
+    const { deserializeResultSet: deserializeResultSet2 } = await Promise.resolve().then(() => (init_daemon_protocol(), daemon_protocol_exports));
+    await connectEmbedDaemon2();
+    if (isClientConnected2()) {
+      const daemonClient = {
+        async execute(stmt) {
+          const sql = typeof stmt === "string" ? stmt : stmt.sql;
+          const args = typeof stmt === "string" ? [] : Array.isArray(stmt.args) ? stmt.args : [];
+          const resp = await sendDaemonRequest2({ type: "db-execute", sql, args });
+          if (resp.error) throw new Error(String(resp.error));
+          if (resp.db) return deserializeResultSet2(resp.db);
+          throw new Error("Unexpected daemon response");
+        },
+        async batch(stmts, mode) {
+          const statements = stmts.map((s) => {
+            const sql = typeof s === "string" ? s : s.sql;
+            const args = typeof s === "string" ? [] : Array.isArray(s.args) ? s.args : [];
+            return { sql, args };
+          });
+          const resp = await sendDaemonRequest2({ type: "db-batch", statements, mode: mode ?? "deferred" });
+          if (resp.error) throw new Error(String(resp.error));
+          const batchResults = resp["db-batch"];
+          if (batchResults) return batchResults.map(deserializeResultSet2);
+          throw new Error("Unexpected daemon batch response");
+        },
+        async transaction(_mode) {
+          throw new Error("Transactions not supported via daemon socket");
+        },
+        async executeMultiple(_sql) {
+          throw new Error("executeMultiple not supported via daemon socket");
+        },
+        async migrate(_stmts) {
+          throw new Error("migrate not supported via daemon socket");
+        },
+        sync() {
+          return Promise.resolve(void 0);
+        },
+        close() {
+        },
+        get closed() {
+          return false;
+        },
+        get protocol() {
+          return "file";
+        }
+      };
+      setExternalClient2(daemonClient);
+      return daemonClient;
+    }
+  } catch {
+  }
+  const { initStore: initStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
+  await initStore2({ lightweight: true });
+  return getClient2();
+}
+var init_fast_db_init = __esm({
+  "src/bin/fast-db-init.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/session-registry.ts
+import path13 from "path";
+import os6 from "os";
+var REGISTRY_PATH;
+var init_session_registry = __esm({
+  "src/lib/session-registry.ts"() {
+    "use strict";
+    REGISTRY_PATH = path13.join(os6.homedir(), ".exe-os", "session-registry.json");
+  }
+});
+
+// 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);
+      }
+      /**
+       * Send text as literal characters, then submit with Enter as a separate call.
+       * Fixes Codex intercom bug: long text + Enter in one send-keys blast causes
+       * Codex to drop the Enter. Splitting them ensures the text renders before
+       * the submit keystroke arrives.
+       */
+      sendKeysLiteral(target, text) {
+        execFileSync("tmux", ["send-keys", "-t", target, "-l", text], QUIET);
+        execFileSync("tmux", ["send-keys", "-t", target, "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 execSync7 } from "child_process";
+var init_cc_agent_support = __esm({
+  "src/lib/cc-agent-support.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/provider-table.ts
+var init_provider_table = __esm({
+  "src/lib/provider-table.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/runtime-table.ts
+var RUNTIME_TABLE;
+var init_runtime_table = __esm({
+  "src/lib/runtime-table.ts"() {
+    "use strict";
+    RUNTIME_TABLE = {
+      codex: {
+        binary: "codex",
+        launchMode: "interactive",
+        autoApproveFlag: "--dangerously-bypass-approvals-and-sandbox",
+        inlineFlag: "--no-alt-screen",
+        apiKeyEnv: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.5"
+      },
+      opencode: {
+        binary: "opencode",
+        launchMode: "exec",
+        autoApproveFlag: "--dangerously-skip-permissions",
+        inlineFlag: "",
+        apiKeyEnv: "ANTHROPIC_API_KEY",
+        defaultModel: "anthropic/claude-sonnet-4-6"
+      }
+    };
+  }
+});
+
+// src/lib/agent-config.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync11 } from "fs";
+import path14 from "path";
+var AGENT_CONFIG_PATH, DEFAULT_MODELS;
+var init_agent_config = __esm({
+  "src/lib/agent-config.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_table();
+    init_secure_files();
+    AGENT_CONFIG_PATH = path14.join(EXE_AI_DIR, "agent-config.json");
+    DEFAULT_MODELS = {
+      claude: "claude-opus-4.6",
+      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+      opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
+    };
+  }
+});
+
+// src/lib/intercom-queue.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, renameSync as renameSync5, existsSync as existsSync12, mkdirSync as mkdirSync4 } from "fs";
+import path15 from "path";
+import os7 from "os";
+var QUEUE_PATH2, TTL_MS2, INTERCOM_LOG;
+var init_intercom_queue = __esm({
+  "src/lib/intercom-queue.ts"() {
+    "use strict";
+    QUEUE_PATH2 = path15.join(os7.homedir(), ".exe-os", "intercom-queue.json");
+    TTL_MS2 = 60 * 60 * 1e3;
+    INTERCOM_LOG = path15.join(os7.homedir(), ".exe-os", "intercom.log");
+  }
+});
+
+// src/lib/license.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync13, mkdirSync as mkdirSync5 } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import os8 from "os";
+import path16 from "path";
+import { jwtVerify, importSPKI } from "jose";
+var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH;
+var init_license = __esm({
+  "src/lib/license.ts"() {
+    "use strict";
+    init_config();
+    LICENSE_PATH = path16.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path16.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path16.join(EXE_AI_DIR, "device-id");
+  }
+});
+
+// src/lib/plan-limits.ts
+import { readFileSync as readFileSync11, existsSync as existsSync14 } from "fs";
+import path17 from "path";
+var CACHE_PATH2;
+var init_plan_limits = __esm({
+  "src/lib/plan-limits.ts"() {
+    "use strict";
+    init_database();
+    init_employees();
+    init_license();
+    init_config();
+    CACHE_PATH2 = path17.join(EXE_AI_DIR, "license-cache.json");
+  }
+});
+
+// src/lib/agent-symlinks.ts
+import os9 from "os";
+import path18 from "path";
+import {
+  existsSync as existsSync15,
+  lstatSync,
+  mkdirSync as mkdirSync6,
+  readlinkSync as readlinkSync2,
+  symlinkSync as symlinkSync2
+} from "fs";
+var init_agent_symlinks = __esm({
+  "src/lib/agent-symlinks.ts"() {
+    "use strict";
+    init_employees();
+  }
+});
+
+// src/lib/tmux-routing.ts
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync16, appendFileSync as appendFileSync2, readdirSync as readdirSync4 } from "fs";
+import path19 from "path";
+import os10 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getMySession() {
+  return getTransport().getMySession();
+}
+function extractRootExe(name) {
+  if (!name) return null;
+  if (!name.includes("-")) return name;
+  const parts = name.split("-").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : null;
+}
+function getParentExe(sessionKey) {
+  try {
+    const data = JSON.parse(readFileSync12(path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    return data.parentExe || null;
+  } catch {
+    return null;
+  }
+}
+function resolveExeSession() {
+  const mySession = getMySession();
+  if (!mySession) return null;
+  const fromSessionName = extractRootExe(mySession);
+  try {
+    const key = getSessionKey();
+    const parentExe = getParentExe(key);
+    if (parentExe) {
+      const fromCache = extractRootExe(parentExe) ?? parentExe;
+      if (fromSessionName && fromCache !== fromSessionName) {
+        process.stderr.write(
+          `[tmux-routing] WARN: cache says "${fromCache}" but session name says "${fromSessionName}". Trusting session name.
+`
+        );
+        return fromSessionName;
+      }
+      return fromCache;
+    }
+  } catch {
+  }
+  return fromSessionName ?? 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_agent_config();
+    init_runtime_table();
+    init_intercom_queue();
+    init_plan_limits();
+    init_employees();
+    init_agent_symlinks();
+    SPAWN_LOCK_DIR = path19.join(os10.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path19.join(os10.homedir(), ".exe-os", "session-cache");
+    INTERCOM_LOG2 = path19.join(os10.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path19.join(SESSION_CACHE, "intercom-debounce.json");
+    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
+  }
+});
+
+// src/lib/task-scope.ts
+function getCurrentSessionScope() {
+  try {
+    return resolveExeSession();
+  } catch {
+    return null;
+  }
+}
+function strictSessionScopeFilter(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} = ?`,
+    args: [scope]
+  };
+}
+var init_task_scope = __esm({
+  "src/lib/task-scope.ts"() {
+    "use strict";
+    init_tmux_routing();
+  }
+});
+
+// src/lib/session-events.ts
+var session_events_exports = {};
+__export(session_events_exports, {
+  ensureSessionEventsTable: () => ensureSessionEventsTable,
+  listRecentSessionEvents: () => listRecentSessionEvents,
+  recordSessionEvent: () => recordSessionEvent
+});
+import { randomUUID as randomUUID4 } from "crypto";
+async function ensureSessionEventsTable(client) {
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS session_events (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      session_scope TEXT,
+      project_name  TEXT NOT NULL,
+      event_index   INTEGER NOT NULL,
+      event_type    TEXT NOT NULL,
+      tool_name     TEXT,
+      tool_use_id   TEXT,
+      content       TEXT NOT NULL,
+      payload_json  TEXT,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    )
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_agent_time
+      ON session_events(agent_id, created_at DESC)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_session_index
+      ON session_events(session_id, event_index)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_scope_agent_time
+      ON session_events(session_scope, agent_id, created_at DESC)
+  `);
+}
+async function recordSessionEvent(client, input2) {
+  if (!input2.content || input2.content.trim().length === 0) return;
+  await ensureSessionEventsTable(client);
+  const maxResult = await client.execute({
+    sql: "SELECT COALESCE(MAX(event_index), 0) AS max_index FROM session_events WHERE session_id = ?",
+    args: [input2.sessionId]
+  });
+  const currentMax = Number(maxResult.rows[0]?.max_index ?? 0);
+  const eventIndex = Number.isFinite(currentMax) ? currentMax + 1 : 1;
+  await client.execute({
+    sql: `INSERT INTO session_events (
+            id, agent_id, agent_role, session_id, session_scope, project_name,
+            event_index, event_type, tool_name, tool_use_id, content,
+            payload_json, has_error, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      randomUUID4(),
+      input2.agentId,
+      input2.agentRole,
+      input2.sessionId,
+      input2.sessionScope ?? getCurrentSessionScope(),
+      input2.projectName ?? getProjectName(input2.cwd),
+      eventIndex,
+      input2.eventType,
+      input2.toolName ?? null,
+      input2.toolUseId ?? null,
+      input2.content,
+      input2.payloadJson ?? null,
+      input2.hasError ? 1 : 0,
+      input2.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    ]
+  });
+}
+async function listRecentSessionEvents(client, options) {
+  await ensureSessionEventsTable(client);
+  const conditions = ["agent_id = ?"];
+  const args = [options.agentId];
+  if (options.sessionId) {
+    conditions.push("session_id = ?");
+    args.push(options.sessionId);
+  }
+  if (options.eventType) {
+    conditions.push("event_type = ?");
+    args.push(options.eventType);
+  }
+  if (options.projectName && options.projectName !== "all") {
+    conditions.push("project_name = ?");
+    args.push(options.projectName);
+  }
+  const scope = strictSessionScopeFilter(options.sessionScope);
+  const where = `WHERE ${conditions.join(" AND ")}${scope.sql}`;
+  args.push(...scope.args);
+  args.push(Math.min(Math.max(options.limit ?? 20, 1), 100));
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, agent_role, session_id, session_scope,
+                 project_name, event_index, event_type, tool_name, tool_use_id,
+                 content, payload_json, has_error, created_at
+          FROM session_events
+          ${where}
+          ORDER BY created_at DESC, event_index DESC
+          LIMIT ?`,
+    args
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    agentId: String(row.agent_id),
+    agentRole: String(row.agent_role),
+    sessionId: String(row.session_id),
+    sessionScope: row.session_scope == null ? null : String(row.session_scope),
+    projectName: String(row.project_name),
+    eventIndex: Number(row.event_index),
+    eventType: String(row.event_type),
+    toolName: row.tool_name == null ? null : String(row.tool_name),
+    toolUseId: row.tool_use_id == null ? null : String(row.tool_use_id),
+    content: String(row.content),
+    payloadJson: row.payload_json == null ? null : String(row.payload_json),
+    hasError: Number(row.has_error) === 1,
+    createdAt: String(row.created_at)
+  }));
+}
+var init_session_events = __esm({
+  "src/lib/session-events.ts"() {
+    "use strict";
+    init_task_scope();
+    init_project_name();
+  }
+});
+
 // src/adapters/claude/hooks/post-tool-combined.ts
 if (!process.env.AGENT_ID) {
   process.env.AGENT_ID = "default";
@@ -7930,7 +8579,33 @@ ${context}`
     const { writeMemoryViaDaemon: writeMemoryViaDaemon2 } = await Promise.resolve().then(() => (init_memory_queue_client(), memory_queue_client_exports));
     const { buildPostToolMemoryEntry: buildPostToolMemoryEntry2 } = await Promise.resolve().then(() => (init_post_tool_memory(), post_tool_memory_exports));
     const { getActiveAgent: getActiveAgent2 } = await Promise.resolve().then(() => (init_active_agent2(), active_agent_exports));
-    const entry = buildPostToolMemoryEntry2(data, getActiveAgent2());
+    const { detectError: detectError2 } = await Promise.resolve().then(() => (init_error_detector(), error_detector_exports));
+    const agent = getActiveAgent2();
+    try {
+      const { fastDbInit: fastDbInit2 } = await Promise.resolve().then(() => (init_fast_db_init(), fast_db_init_exports));
+      const { recordSessionEvent: recordSessionEvent2 } = await Promise.resolve().then(() => (init_session_events(), session_events_exports));
+      const client = await fastDbInit2();
+      const toolName = String(data.tool_name ?? "unknown");
+      const toolInput = JSON.stringify(data.tool_input ?? {});
+      const toolResponse = JSON.stringify(data.tool_response ?? data.tool_result ?? {});
+      await recordSessionEvent2(client, {
+        agentId: agent.agentId,
+        agentRole: agent.agentRole,
+        sessionId: String(data.session_id ?? "unknown"),
+        eventType: "tool_call",
+        toolName,
+        toolUseId: data.tool_use_id ? String(data.tool_use_id) : null,
+        content: `${toolName}
+input: ${toolInput.slice(0, 8e3)}
+result: ${toolResponse.slice(0, 8e3)}`,
+        payloadJson: JSON.stringify(data).slice(0, 3e4),
+        hasError: detectError2(data),
+        cwd: typeof data.cwd === "string" ? data.cwd : process.cwd(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch {
+    }
+    const entry = buildPostToolMemoryEntry2(data, agent);
     if (entry) await writeMemoryViaDaemon2(entry);
   } catch {
   }