@askexenow/exe-os 0.9.8 → 0.9.9

package/dist/hooks/ingest.js

@@ -1,11 +1,47 @@
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+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) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/secure-files.ts
+import { chmodSync, existsSync, mkdirSync } from "fs";
+import { chmod, mkdir } from "fs/promises";
+function ensurePrivateDirSync(dirPath) {
+  mkdirSync(dirPath, { recursive: true, mode: PRIVATE_DIR_MODE });
+  try {
+    chmodSync(dirPath, PRIVATE_DIR_MODE);
+  } catch {
+  }
+}
+function enforcePrivateFileSync(filePath) {
+  try {
+    if (existsSync(filePath)) chmodSync(filePath, PRIVATE_FILE_MODE);
+  } catch {
+  }
+}
+var PRIVATE_DIR_MODE, PRIVATE_FILE_MODE;
+var init_secure_files = __esm({
+  "src/lib/secure-files.ts"() {
+    "use strict";
+    PRIVATE_DIR_MODE = 448;
+    PRIVATE_FILE_MODE = 384;
+  }
+});
 
 // src/lib/config.ts
-import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { readFileSync, existsSync, renameSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { readFileSync, existsSync as existsSync2, renameSync } from "fs";
 import path from "path";
 import os from "os";
 function resolveDataDir() {
@@ -13,7 +49,7 @@ function resolveDataDir() {
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
   const newDir = path.join(os.homedir(), ".exe-os");
   const legacyDir = path.join(os.homedir(), ".exe-mem");
-  if (!existsSync(newDir) && existsSync(legacyDir)) {
+  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
     try {
       renameSync(legacyDir, newDir);
       process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
@@ -77,7 +113,7 @@ function normalizeAutoUpdate(raw) {
 function loadConfigSync() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   const configPath = path.join(dir, "config.json");
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
   try {
@@ -97,6 +133,7 @@ var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CON
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
+    init_secure_files();
     EXE_AI_DIR = resolveDataDir();
     DB_PATH = path.join(EXE_AI_DIR, "memories.db");
     MODELS_DIR = path.join(EXE_AI_DIR, "models");
@@ -173,19 +210,703 @@ var init_config = __esm({
   }
 });
 
+// src/lib/runtime-table.ts
+var RUNTIME_TABLE, DEFAULT_RUNTIME;
+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.4"
+      },
+      opencode: {
+        binary: "opencode",
+        launchMode: "exec",
+        autoApproveFlag: "--dangerously-skip-permissions",
+        inlineFlag: "",
+        apiKeyEnv: "ANTHROPIC_API_KEY",
+        defaultModel: "anthropic/claude-sonnet-4-6"
+      }
+    };
+    DEFAULT_RUNTIME = "claude";
+  }
+});
+
+// src/lib/agent-config.ts
+var agent_config_exports = {};
+__export(agent_config_exports, {
+  AGENT_CONFIG_PATH: () => AGENT_CONFIG_PATH,
+  DEFAULT_MODELS: () => DEFAULT_MODELS,
+  KNOWN_RUNTIMES: () => KNOWN_RUNTIMES,
+  RUNTIME_LABELS: () => RUNTIME_LABELS,
+  clearAgentRuntime: () => clearAgentRuntime,
+  getAgentRuntime: () => getAgentRuntime,
+  loadAgentConfig: () => loadAgentConfig,
+  saveAgentConfig: () => saveAgentConfig,
+  setAgentRuntime: () => setAgentRuntime
+});
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3 } from "fs";
+import path2 from "path";
+function loadAgentConfig() {
+  if (!existsSync3(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync2(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveAgentConfig(config) {
+  const dir = path2.dirname(AGENT_CONFIG_PATH);
+  ensurePrivateDirSync(dir);
+  writeFileSync(AGENT_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  enforcePrivateFileSync(AGENT_CONFIG_PATH);
+}
+function getAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  const entry = config[agentId];
+  if (entry) return entry;
+  const orgDefault = config["default"];
+  if (orgDefault) return orgDefault;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+function setAgentRuntime(agentId, runtime, model) {
+  const knownModels = KNOWN_RUNTIMES[runtime];
+  if (!knownModels) {
+    return {
+      ok: false,
+      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
+    };
+  }
+  if (!knownModels.includes(model)) {
+    return {
+      ok: false,
+      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${knownModels.join(", ")}`
+    };
+  }
+  const config = loadAgentConfig();
+  config[agentId] = { runtime, model };
+  saveAgentConfig(config);
+  return { ok: true };
+}
+function clearAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  delete config[agentId];
+  saveAgentConfig(config);
+}
+var AGENT_CONFIG_PATH, KNOWN_RUNTIMES, RUNTIME_LABELS, 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 = path2.join(EXE_AI_DIR, "agent-config.json");
+    KNOWN_RUNTIMES = {
+      claude: ["claude-opus-4", "claude-sonnet-4", "claude-haiku-4.5"],
+      codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
+      opencode: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
+    };
+    RUNTIME_LABELS = {
+      claude: "Claude Code (Anthropic)",
+      codex: "Codex (OpenAI)",
+      opencode: "OpenCode (open source)"
+    };
+    DEFAULT_MODELS = {
+      claude: "claude-opus-4",
+      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+      opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
+    };
+  }
+});
+
+// src/lib/employees.ts
+var employees_exports = {};
+__export(employees_exports, {
+  COORDINATOR_ROLE: () => COORDINATOR_ROLE,
+  DEFAULT_COORDINATOR_TEMPLATE_NAME: () => DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  EMPLOYEES_PATH: () => EMPLOYEES_PATH,
+  addEmployee: () => addEmployee,
+  baseAgentName: () => baseAgentName,
+  canCoordinate: () => canCoordinate,
+  getCoordinatorEmployee: () => getCoordinatorEmployee,
+  getCoordinatorName: () => getCoordinatorName,
+  getEmployee: () => getEmployee,
+  getEmployeeByRole: () => getEmployeeByRole,
+  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
+  hasRole: () => hasRole,
+  hireEmployee: () => hireEmployee,
+  isCoordinatorName: () => isCoordinatorName,
+  isCoordinatorRole: () => isCoordinatorRole,
+  isMultiInstance: () => isMultiInstance,
+  loadEmployees: () => loadEmployees,
+  loadEmployeesSync: () => loadEmployeesSync,
+  normalizeRole: () => normalizeRole,
+  normalizeRosterCase: () => normalizeRosterCase,
+  registerBinSymlinks: () => registerBinSymlinks,
+  saveEmployees: () => saveEmployees,
+  validateEmployeeName: () => validateEmployeeName
+});
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync4, symlinkSync, readlinkSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import path3 from "path";
+import os2 from "os";
+function normalizeRole(role) {
+  return (role ?? "").trim().toLowerCase();
+}
+function isCoordinatorRole(role) {
+  return normalizeRole(role) === normalizeRole(COORDINATOR_ROLE);
+}
+function getCoordinatorEmployee(employees) {
+  return employees.find((e) => isCoordinatorRole(e.role));
+}
+function getCoordinatorName(employees = loadEmployeesSync()) {
+  return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+}
+function isCoordinatorName(agentName, employees = loadEmployeesSync()) {
+  if (!agentName) return false;
+  return agentName.toLowerCase() === getCoordinatorName(employees).toLowerCase();
+}
+function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
+  return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
+}
+function validateEmployeeName(name) {
+  if (!name) {
+    return { valid: false, error: "Name is required" };
+  }
+  if (name.length > 32) {
+    return { valid: false, error: "Name must be 32 characters or fewer" };
+  }
+  if (!/^[a-z][a-z0-9]*$/.test(name)) {
+    return {
+      valid: false,
+      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
+    };
+  }
+  return { valid: true };
+}
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync4(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile2(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
+  await mkdir2(path3.dirname(employeesPath), { recursive: true });
+  await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
+}
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync4(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync3(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+function getEmployeeByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.find((e) => e.role.toLowerCase() === lower);
+}
+function getEmployeeNamesByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.filter((e) => e.role.toLowerCase() === lower).map((e) => e.name);
+}
+function hasRole(agentName, role) {
+  const employees = loadEmployeesSync();
+  const emp = getEmployee(employees, agentName);
+  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
+}
+function baseAgentName(name, employees) {
+  const match = name.match(/^([a-zA-Z]+)\d+$/);
+  if (!match) return name;
+  const base = match[1];
+  const roster = employees ?? loadEmployeesSync();
+  if (getEmployee(roster, base)) return base;
+  return name;
+}
+function isMultiInstance(agentName, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
+function addEmployee(employees, employee) {
+  const normalized = { ...employee, name: employee.name.toLowerCase() };
+  if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
+    throw new Error(`Employee '${normalized.name}' already exists`);
+  }
+  return [...employees, normalized];
+}
+function appendToCoordinatorTeam(employee) {
+  const coordinator = getCoordinatorEmployee(loadEmployeesSync());
+  if (!coordinator) return;
+  const idPath = path3.join(IDENTITY_DIR, `${coordinator.name}.md`);
+  if (!existsSync4(idPath)) return;
+  const content = readFileSync3(idPath, "utf-8");
+  if (content.includes(`**${capitalize(employee.name)}`)) return;
+  const teamMatch = content.match(TEAM_SECTION_RE);
+  if (!teamMatch || teamMatch.index === void 0) return;
+  const afterTeam = content.slice(teamMatch.index + teamMatch[0].length);
+  const nextHeading = afterTeam.match(/\n## /);
+  const entry = `
+**${capitalize(employee.name)} (${employee.role}):** Newly hired. Update this description as the role develops.
+`;
+  let updated;
+  if (nextHeading && nextHeading.index !== void 0) {
+    const insertAt = teamMatch.index + teamMatch[0].length + nextHeading.index;
+    updated = content.slice(0, insertAt) + entry + content.slice(insertAt);
+  } else {
+    updated = content.trimEnd() + "\n" + entry;
+  }
+  writeFileSync2(idPath, updated, "utf-8");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+async function hireEmployee(employee) {
+  const employees = await loadEmployees();
+  const updated = addEmployee(employees, employee);
+  await saveEmployees(updated);
+  try {
+    appendToCoordinatorTeam(employee);
+  } catch {
+  }
+  try {
+    const { loadAgentConfig: loadAgentConfig2, saveAgentConfig: saveAgentConfig2 } = await Promise.resolve().then(() => (init_agent_config(), agent_config_exports));
+    const config = loadAgentConfig2();
+    const name = employee.name.toLowerCase();
+    if (!config[name] && config["default"]) {
+      config[name] = { ...config["default"] };
+      saveAgentConfig2(config);
+    }
+  } catch {
+  }
+  return updated;
+}
+async function normalizeRosterCase(rosterPath) {
+  const employees = await loadEmployees(rosterPath);
+  let changed = false;
+  for (const emp of employees) {
+    if (emp.name !== emp.name.toLowerCase()) {
+      const oldName = emp.name;
+      emp.name = emp.name.toLowerCase();
+      changed = true;
+      try {
+        const identityDir = path3.join(os2.homedir(), ".exe-os", "identity");
+        const oldPath = path3.join(identityDir, `${oldName}.md`);
+        const newPath = path3.join(identityDir, `${emp.name}.md`);
+        if (existsSync4(oldPath) && !existsSync4(newPath)) {
+          renameSync2(oldPath, newPath);
+        } else if (existsSync4(oldPath) && oldPath !== newPath) {
+          const content = readFileSync3(oldPath, "utf-8");
+          writeFileSync2(newPath, content, "utf-8");
+          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
+            unlinkSync(oldPath);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (changed) {
+    await saveEmployees(employees, rosterPath);
+  }
+  return changed;
+}
+function findExeBin() {
+  try {
+    return execSync2(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  const exeBinPath = findExeBin();
+  if (!exeBinPath) {
+    errors.push("Could not find 'exe-os' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path3.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path3.join(binDir, linkName);
+    if (existsSync4(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES, IDENTITY_DIR, TEAM_SECTION_RE;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
+    "use strict";
+    init_config();
+    EMPLOYEES_PATH = path3.join(EXE_AI_DIR, "exe-employees.json");
+    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
+    COORDINATOR_ROLE = "COO";
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+    IDENTITY_DIR = path3.join(EXE_AI_DIR, "identity");
+    TEAM_SECTION_RE = /^## Team\b.*$/m;
+  }
+});
+
+// src/lib/mcp-prefix.ts
+function isExeMcpTool(toolName) {
+  if (!toolName) return false;
+  return MCP_TOOL_PREFIXES.some((p) => toolName.startsWith(p));
+}
+function stripExeMcpPrefix(toolName) {
+  for (const p of MCP_TOOL_PREFIXES) {
+    if (toolName.startsWith(p)) return toolName.slice(p.length);
+  }
+  return toolName;
+}
+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/content-extractor.ts
+var content_extractor_exports = {};
+__export(content_extractor_exports, {
+  extractSemanticText: () => extractSemanticText
+});
+function extractSemanticText(toolName, toolInput, toolResponse) {
+  switch (toolName) {
+    case "Write":
+      return extractWrite(toolInput);
+    case "Edit":
+      return extractEdit(toolInput);
+    case "Read":
+      return extractRead(toolInput, toolResponse);
+    case "Bash":
+      return extractBash(toolInput, toolResponse);
+    case "Grep":
+      return extractGrep(toolInput, toolResponse);
+    case "Glob":
+      return extractGlob(toolInput, toolResponse);
+    default:
+      if (isExeMcpTool(toolName)) {
+        return extractExeMemMcp(toolName, toolInput, toolResponse);
+      }
+      if (toolName.startsWith("mcp__")) {
+        return extractGenericMcp(toolName, toolInput, toolResponse);
+      }
+      return extractDefault(toolName, toolInput, toolResponse);
+  }
+}
+function findContainingChunk(filePath, snippet) {
+  try {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
+    const { readFileSync: readFileSync7 } = __require("fs");
+    const source = readFileSync7(filePath, "utf8");
+    const lines = source.split("\n");
+    const lowerSnippet = snippet.toLowerCase().slice(0, 80);
+    let matchLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].toLowerCase().includes(lowerSnippet)) {
+        matchLine = i;
+        break;
+      }
+    }
+    if (matchLine === -1) return "";
+    for (let i = matchLine; i >= 0; i--) {
+      const line = lines[i];
+      const fnMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+      if (fnMatch) return `Function ${fnMatch[1]} in ${filePath}:${i + 1}`;
+      const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+      if (classMatch) return `Class ${classMatch[1]} in ${filePath}:${i + 1}`;
+      const arrowMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+      if (arrowMatch) return `Function ${arrowMatch[1]} in ${filePath}:${i + 1}`;
+    }
+  } catch {
+  }
+  return "";
+}
+function extractWrite(input2) {
+  const filePath = String(input2.file_path ?? "");
+  const content = String(input2.content ?? "");
+  const chunkContext = findContainingChunk(filePath, content.slice(0, 200));
+  const prefix = chunkContext ? `Wrote ${filePath} (${chunkContext})` : `Wrote ${filePath}`;
+  return `${prefix}
+${content.slice(0, MAX_CONTENT)}`;
+}
+function extractEdit(input2) {
+  const filePath = String(input2.file_path ?? "");
+  const oldStr = String(input2.old_string ?? "");
+  const newStr = String(input2.new_string ?? "");
+  const chunkContext = findContainingChunk(filePath, oldStr.slice(0, 200));
+  const prefix = chunkContext ? `Edited ${filePath} (${chunkContext})` : `Edited ${filePath}`;
+  return `${prefix}
+Removed: ${oldStr.slice(0, MAX_CONTENT / 2)}
+Added: ${newStr.slice(0, MAX_CONTENT / 2)}`;
+}
+function extractRead(input2, response) {
+  const filePath = String(input2.file_path ?? "");
+  const file = response.file;
+  const content = file ? String(file.content ?? "") : "";
+  if (!content) {
+    const text = String(response.text ?? response.content ?? "");
+    return `Read ${filePath}
+${text.slice(0, MAX_CONTENT)}`;
+  }
+  return `Read ${filePath}
+${content.slice(0, MAX_CONTENT)}`;
+}
+function extractBash(input2, response) {
+  const command = String(input2.command ?? "");
+  const description = input2.description ? String(input2.description) : "";
+  const stdout = String(response.stdout ?? response.text ?? "");
+  const stderr = String(response.stderr ?? "");
+  const parts = [description ? `${description}: ${command}` : `Ran: ${command}`];
+  if (stdout) parts.push(`Output: ${stdout.slice(0, MAX_OUTPUT)}`);
+  if (stderr && !stdout) parts.push(`Error: ${stderr.slice(0, MAX_OUTPUT)}`);
+  return parts.join("\n");
+}
+function extractGrep(input2, response) {
+  const pattern = String(input2.pattern ?? "");
+  const path9 = input2.path ? String(input2.path) : "";
+  const output = String(response.text ?? response.content ?? JSON.stringify(response).slice(0, MAX_OUTPUT));
+  return `Searched for "${pattern}"${path9 ? ` in ${path9}` : ""}
+${output.slice(0, MAX_OUTPUT)}`;
+}
+function extractGlob(input2, response) {
+  const pattern = String(input2.pattern ?? "");
+  const output = String(response.text ?? response.content ?? JSON.stringify(response).slice(0, MAX_OUTPUT));
+  return `Found files matching "${pattern}"
+${output.slice(0, MAX_OUTPUT)}`;
+}
+function extractExeMemMcp(toolName, input2, response) {
+  const shortName = stripExeMcpPrefix(toolName);
+  switch (shortName) {
+    case "store_memory": {
+      const text = String(input2.text ?? input2.query ?? "");
+      return `Stored memory: ${text.slice(0, MAX_CONTENT)}`;
+    }
+    case "recall_my_memory":
+    case "ask_team_memory": {
+      const query = String(input2.query ?? "");
+      const member = input2.team_member ? ` (from ${input2.team_member})` : "";
+      const resultText = extractResponseText(response);
+      return `Memory search${member}: "${query}"
+${resultText.slice(0, MAX_OUTPUT)}`;
+    }
+    case "create_task": {
+      const title = String(input2.title ?? "");
+      const assignedTo = String(input2.assigned_to ?? "");
+      const priority = String(input2.priority ?? "p1");
+      const context = String(input2.context ?? "");
+      return `Task created: "${title}" assigned to ${assignedTo} [${priority}]
+${context.slice(0, MAX_CONTENT)}`;
+    }
+    case "update_task": {
+      const taskId = String(input2.task_id ?? "");
+      const status = String(input2.status ?? "");
+      const result = input2.result ? String(input2.result) : "";
+      return `Task updated: ${taskId} \u2192 ${status}${result ? `
+Result: ${result.slice(0, MAX_CONTENT)}` : ""}`;
+    }
+    case "list_tasks": {
+      const resultText = extractResponseText(response);
+      return `Listed tasks
+${resultText.slice(0, MAX_OUTPUT)}`;
+    }
+    default: {
+      return extractGenericMcp(toolName, input2, response);
+    }
+  }
+}
+function extractGenericMcp(toolName, input2, response) {
+  const shortName = toolName.replace(/^mcp__[^_]+__/, "");
+  const inputParts = Object.entries(input2).filter(([, v]) => v != null && String(v).length > 0).map(([k, v]) => `${k}: ${String(v).slice(0, 200)}`).join(", ");
+  const resultText = extractResponseText(response);
+  return `${shortName}(${inputParts})
+${resultText.slice(0, MAX_OUTPUT)}`;
+}
+function extractDefault(toolName, input2, response) {
+  const inputStr = JSON.stringify(input2);
+  const resultText = extractResponseText(response);
+  return `Tool: ${toolName}
+${inputStr.slice(0, MAX_CONTENT / 2)}
+${resultText.slice(0, MAX_OUTPUT)}`;
+}
+function extractResponseText(response) {
+  if (typeof response.text === "string") return response.text;
+  if (typeof response.content === "string") return response.content;
+  if (Array.isArray(response.content)) {
+    return response.content.map((block) => {
+      if (typeof block === "object" && block !== null && "text" in block) {
+        return String(block.text);
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  if (Array.isArray(response)) {
+    return response.map((item) => {
+      if (typeof item === "object" && item !== null && "text" in item) {
+        return String(item.text);
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  return JSON.stringify(response).slice(0, MAX_OUTPUT);
+}
+var MAX_CONTENT, MAX_OUTPUT;
+var init_content_extractor = __esm({
+  "src/lib/content-extractor.ts"() {
+    "use strict";
+    init_mcp_prefix();
+    MAX_CONTENT = 2e3;
+    MAX_OUTPUT = 1e3;
+  }
+});
+
+// src/lib/project-name.ts
+var project_name_exports = {};
+__export(project_name_exports, {
+  _resetCache: () => _resetCache,
+  getProjectName: () => getProjectName
+});
+import { execSync as execSync4 } from "child_process";
+import path6 from "path";
+function getProjectName(cwd) {
+  const dir = cwd ?? process.cwd();
+  if (_cached2 && _cachedCwd === dir) return _cached2;
+  try {
+    let repoRoot;
+    try {
+      const gitCommonDir = execSync4("git rev-parse --path-format=absolute --git-common-dir", {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      repoRoot = path6.dirname(gitCommonDir);
+    } catch {
+      repoRoot = execSync4("git rev-parse --show-toplevel", {
+        cwd: dir,
+        encoding: "utf8",
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    }
+    _cached2 = path6.basename(repoRoot);
+    _cachedCwd = dir;
+    return _cached2;
+  } catch {
+    _cached2 = path6.basename(dir);
+    _cachedCwd = dir;
+    return _cached2;
+  }
+}
+function _resetCache() {
+  _cached2 = null;
+  _cachedCwd = null;
+}
+var _cached2, _cachedCwd;
+var init_project_name = __esm({
+  "src/lib/project-name.ts"() {
+    "use strict";
+    _cached2 = null;
+    _cachedCwd = null;
+  }
+});
+
+// src/lib/daemon-auth.ts
+var daemon_auth_exports = {};
+__export(daemon_auth_exports, {
+  DAEMON_TOKEN_PATH: () => DAEMON_TOKEN_PATH,
+  ensureDaemonToken: () => ensureDaemonToken,
+  readDaemonToken: () => readDaemonToken
+});
+import crypto2 from "crypto";
+import path7 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+function normalizeToken(token) {
+  if (!token) return null;
+  const trimmed = token.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readDaemonToken() {
+  try {
+    if (!existsSync6(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync5(DAEMON_TOKEN_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ensureDaemonToken(seed) {
+  const existing = readDaemonToken();
+  if (existing) return existing;
+  const token = normalizeToken(seed) ?? crypto2.randomBytes(32).toString("hex");
+  ensurePrivateDirSync(EXE_AI_DIR);
+  writeFileSync5(DAEMON_TOKEN_PATH, `${token}
+`, "utf8");
+  enforcePrivateFileSync(DAEMON_TOKEN_PATH);
+  return token;
+}
+var DAEMON_TOKEN_PATH;
+var init_daemon_auth = __esm({
+  "src/lib/daemon-auth.ts"() {
+    "use strict";
+    init_config();
+    init_secure_files();
+    DAEMON_TOKEN_PATH = path7.join(EXE_AI_DIR, "exed.token");
+  }
+});
+
 // src/adapters/claude/hooks/ingest.ts
 init_config();
 init_config();
 import { spawn } from "child_process";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, existsSync as existsSync4, openSync, closeSync } from "fs";
-import path5 from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync4, existsSync as existsSync7, openSync, closeSync } from "fs";
+import path8 from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/active-agent.ts
 init_config();
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync, unlinkSync as unlinkSync2, readdirSync } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2, readdirSync } from "fs";
 import { execSync as execSync3 } from "child_process";
-import path3 from "path";
+import path4 from "path";
 
 // src/lib/session-key.ts
 import { execSync } from "child_process";
@@ -249,43 +970,9 @@ function getSessionKey() {
   return _cached;
 }
 
-// src/lib/employees.ts
-init_config();
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
-import { execSync as execSync2 } from "child_process";
-import path2 from "path";
-import os2 from "os";
-var EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
-var DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
-var COORDINATOR_ROLE = "COO";
-function normalizeRole(role) {
-  return (role ?? "").trim().toLowerCase();
-}
-function isCoordinatorRole(role) {
-  return normalizeRole(role) === normalizeRole(COORDINATOR_ROLE);
-}
-function getCoordinatorEmployee(employees) {
-  return employees.find((e) => isCoordinatorRole(e.role));
-}
-function getCoordinatorName(employees = loadEmployeesSync()) {
-  return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
-}
-function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) return [];
-  try {
-    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function getEmployee(employees, name) {
-  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
-}
-var IDENTITY_DIR = path2.join(EXE_AI_DIR, "identity");
-
 // src/lib/active-agent.ts
-var CACHE_DIR = path3.join(EXE_AI_DIR, "session-cache");
+init_employees();
+var CACHE_DIR = path4.join(EXE_AI_DIR, "session-cache");
 var STALE_MS = 24 * 60 * 60 * 1e3;
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
@@ -330,12 +1017,12 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path3.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path4.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function getActiveAgent() {
   try {
     const markerPath = getMarkerPath();
-    const raw = readFileSync3(markerPath, "utf8");
+    const raw = readFileSync4(markerPath, "utf8");
     const data = JSON.parse(raw);
     if (data.agentId) {
       if (data.startedAt) {
@@ -376,21 +1063,8 @@ function getActiveAgent() {
 }
 
 // src/lib/error-detector.ts
+init_mcp_prefix();
 import crypto from "crypto";
-
-// src/lib/mcp-prefix.ts
-var MCP_PRIMARY_KEY = "exe-os";
-var MCP_LEGACY_KEY = "exe-mem";
-var MCP_TOOL_PREFIXES = [
-  `mcp__${MCP_PRIMARY_KEY}__`,
-  `mcp__${MCP_LEGACY_KEY}__`
-];
-function isExeMcpTool(toolName) {
-  if (!toolName) return false;
-  return MCP_TOOL_PREFIXES.some((p) => toolName.startsWith(p));
-}
-
-// src/lib/error-detector.ts
 var ERROR_PATTERNS = [
   /\bError\b/i,
   /\bERR!\b/,
@@ -527,16 +1201,16 @@ function errorFingerprint(toolName, errorText) {
 
 // src/lib/worker-gate.ts
 init_config();
-import { readdirSync as readdirSync2, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
-import path4 from "path";
-var WORKER_PID_DIR = path4.join(EXE_AI_DIR, "worker-pids");
+import { readdirSync as readdirSync2, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
+import path5 from "path";
+var WORKER_PID_DIR = path5.join(EXE_AI_DIR, "worker-pids");
 var MAX_CONCURRENT_WORKERS = 3;
 function tryAcquireWorkerSlot() {
   try {
-    mkdirSync2(WORKER_PID_DIR, { recursive: true });
+    mkdirSync3(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path4.join(WORKER_PID_DIR, `${reservationId}.pid`);
-    writeFileSync3(reservationPath, String(process.pid));
+    const reservationPath = path5.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync4(reservationPath, String(process.pid));
     const files = readdirSync2(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
@@ -553,7 +1227,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync3(path4.join(WORKER_PID_DIR, f));
+          unlinkSync3(path5.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -576,14 +1250,15 @@ function tryAcquireWorkerSlot() {
 }
 function registerWorkerPid(pid) {
   try {
-    mkdirSync2(WORKER_PID_DIR, { recursive: true });
-    writeFileSync3(path4.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    mkdirSync3(WORKER_PID_DIR, { recursive: true });
+    writeFileSync4(path5.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
-var BACKFILL_LOCK = path4.join(WORKER_PID_DIR, "backfill.lock");
+var BACKFILL_LOCK = path5.join(WORKER_PID_DIR, "backfill.lock");
 
 // src/adapters/claude/hooks/ingest.ts
+init_employees();
 if (!process.env.AGENT_ID) {
   process.env.AGENT_ID = "default";
   process.env.AGENT_ROLE = "employee";
@@ -594,7 +1269,7 @@ if (!loadConfigSync().autoIngestion) {
 if (!process.env.EXE_OS_DIR) {
   process.env.EXE_OS_DIR = EXE_AI_DIR;
 }
-var WORKER_LOG_PATH = path5.join(EXE_AI_DIR, "workers.log");
+var WORKER_LOG_PATH = path8.join(EXE_AI_DIR, "workers.log");
 function openWorkerLog() {
   try {
     return openSync(WORKER_LOG_PATH, "a");
@@ -606,13 +1281,13 @@ var ALLOWED_TOOL_RE = /^(Bash|Edit|Write|Read|Glob|Grep|Agent|apply_patch|mcp__.
 var WRITE_TOOL_RE = /^(Bash|Edit|Write|apply_patch)$/;
 var SUMMARY_INTERVAL = 25;
 var MIN_WRITES_FOR_SUMMARY = 3;
-var COUNTER_DIR = path5.join(EXE_AI_DIR, "session-cache");
+var COUNTER_DIR = path8.join(EXE_AI_DIR, "session-cache");
 function getCounterPath(sessionId) {
-  return path5.join(COUNTER_DIR, `counter-${sessionId}.json`);
+  return path8.join(COUNTER_DIR, `counter-${sessionId}.json`);
 }
 function loadCounter(sessionId) {
   try {
-    const raw = readFileSync4(getCounterPath(sessionId), "utf8");
+    const raw = readFileSync6(getCounterPath(sessionId), "utf8");
     return JSON.parse(raw);
   } catch {
     return { total: 0, writes: 0, pipelineWrites: 0, lastSummaryAt: 0, pipelineDetected: false };
@@ -620,8 +1295,8 @@ function loadCounter(sessionId) {
 }
 function saveCounter(sessionId, counter) {
   try {
-    mkdirSync3(COUNTER_DIR, { recursive: true });
-    writeFileSync4(getCounterPath(sessionId), JSON.stringify(counter));
+    mkdirSync4(COUNTER_DIR, { recursive: true });
+    writeFileSync6(getCounterPath(sessionId), JSON.stringify(counter));
   } catch {
   }
 }
@@ -633,15 +1308,15 @@ process.stdin.on("data", (chunk) => {
     input += chunk;
   }
 });
-process.stdin.on("end", () => {
+process.stdin.on("end", async () => {
   try {
     if (process.env.EXE_DEBUG_HOOKS) {
       try {
-        const debugPath = path5.join(EXE_AI_DIR, "logs", "hook-stdin-ingest.log");
-        mkdirSync3(path5.dirname(debugPath), { recursive: true });
+        const debugPath = path8.join(EXE_AI_DIR, "logs", "hook-stdin-ingest.log");
+        mkdirSync4(path8.dirname(debugPath), { recursive: true });
         const ts = (/* @__PURE__ */ new Date()).toISOString();
         const snippet = input.length > 2e3 ? input.slice(0, 2e3) + "...[truncated]" : input;
-        writeFileSync4(debugPath, `[${ts}] ${snippet}
+        writeFileSync6(debugPath, `[${ts}] ${snippet}
 `, { flag: "a" });
       } catch {
       }
@@ -708,14 +1383,14 @@ Your output files must start with: exe/output/${agent.agentId}-`
       const classification = classifyError(errorText);
       if (classification === "system" && data.session_id) {
         const fp = errorFingerprint(data.tool_name, errorText);
-        const fpFilePath = path5.join(COUNTER_DIR, `bug-fingerprints-${data.session_id}.json`);
+        const fpFilePath = path8.join(COUNTER_DIR, `bug-fingerprints-${data.session_id}.json`);
         let fpData = {
           seen: {},
           taskCount: 0,
           lastTaskAt: ""
         };
         try {
-          fpData = JSON.parse(readFileSync4(fpFilePath, "utf8"));
+          fpData = JSON.parse(readFileSync6(fpFilePath, "utf8"));
         } catch {
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -733,13 +1408,13 @@ Your output files must start with: exe/output/${agent.agentId}-`
           fpData.seen[fp] = { count: 1, firstAt: now, lastAt: now };
           fpData.taskCount++;
           fpData.lastTaskAt = now;
-          const bugWorkerPath = path5.resolve(
-            path5.dirname(fileURLToPath(import.meta.url)),
+          const bugWorkerPath = path8.resolve(
+            path8.dirname(fileURLToPath(import.meta.url)),
             "bug-report-worker.js"
           );
-          if (existsSync4(bugWorkerPath) && tryAcquireWorkerSlot()) {
+          if (existsSync7(bugWorkerPath) && tryAcquireWorkerSlot()) {
             const stderrFd2 = openWorkerLog();
-            const projectName = process.cwd().split(path5.sep).pop() ?? "unknown";
+            const projectName = process.cwd().split(path8.sep).pop() ?? "unknown";
             const bugToolInput = data.tool_input ?? {};
             const bugWorker = spawn(process.execPath, [bugWorkerPath], {
               detached: true,
@@ -767,8 +1442,8 @@ Your output files must start with: exe/output/${agent.agentId}-`
           }
         }
         try {
-          mkdirSync3(COUNTER_DIR, { recursive: true });
-          writeFileSync4(fpFilePath, JSON.stringify(fpData));
+          mkdirSync4(COUNTER_DIR, { recursive: true });
+          writeFileSync6(fpFilePath, JSON.stringify(fpData));
         } catch {
         }
       }
@@ -785,11 +1460,11 @@ Your output files must start with: exe/output/${agent.agentId}-`
       }
       const callsSinceLastSummary = counter.total - counter.lastSummaryAt;
       if (callsSinceLastSummary >= SUMMARY_INTERVAL && counter.writes >= MIN_WRITES_FOR_SUMMARY) {
-        const summaryWorkerPath = path5.resolve(
-          path5.dirname(fileURLToPath(import.meta.url)),
+        const summaryWorkerPath = path8.resolve(
+          path8.dirname(fileURLToPath(import.meta.url)),
           "summary-worker.js"
         );
-        if (existsSync4(summaryWorkerPath) && tryAcquireWorkerSlot()) {
+        if (existsSync7(summaryWorkerPath) && tryAcquireWorkerSlot()) {
           const stderrFd2 = openWorkerLog();
           const summaryWorker = spawn(process.execPath, [summaryWorkerPath], {
             detached: true,
@@ -835,13 +1510,13 @@ WARNING: You are writing code without running the build pipeline. If this task a
       const bashOutput = typeof data.tool_response === "string" ? data.tool_response : JSON.stringify(data.tool_response ?? "");
       const commitMatch = bashOutput.match(/\[(\S+)\s+([a-f0-9]{7,40})\]\s+(.+)/);
       if (commitMatch) {
-        const commitWorkerPath = path5.resolve(
-          path5.dirname(fileURLToPath(import.meta.url)),
+        const commitWorkerPath = path8.resolve(
+          path8.dirname(fileURLToPath(import.meta.url)),
           "commit-complete.js"
         );
-        if (existsSync4(commitWorkerPath) && tryAcquireWorkerSlot()) {
+        if (existsSync7(commitWorkerPath) && tryAcquireWorkerSlot()) {
           const stderrFd2 = openWorkerLog();
-          const projectName = process.cwd().split(path5.sep).pop() ?? "unknown";
+          const projectName = process.cwd().split(path8.sep).pop() ?? "unknown";
           const commitWorker = spawn(process.execPath, [commitWorkerPath], {
             detached: true,
             stdio: ["ignore", "ignore", stderrFd2],
@@ -865,8 +1540,68 @@ WARNING: You are writing code without running the build pipeline. If this task a
     if (!ALLOWED_TOOL_RE.test(data.tool_name)) {
       process.exit(0);
     }
-    const workerPath = path5.resolve(
-      path5.dirname(fileURLToPath(import.meta.url)),
+    let sentViaDaemon = false;
+    try {
+      const socketPath = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path8.join(EXE_AI_DIR, "exed.sock");
+      if (existsSync7(socketPath)) {
+        const { extractSemanticText: extractSemanticText2 } = await Promise.resolve().then(() => (init_content_extractor(), content_extractor_exports));
+        const { getProjectName: getProjectName2 } = await Promise.resolve().then(() => (init_project_name(), project_name_exports));
+        const { canCoordinate: canCoordinate2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
+        const { readDaemonToken: readDaemonToken2 } = await Promise.resolve().then(() => (init_daemon_auth(), daemon_auth_exports));
+        const rawText = extractSemanticText2(data.tool_name, data.tool_input ?? {}, data.tool_response ?? {});
+        if (rawText.length >= 50) {
+          let taskId = null;
+          try {
+            const cachePath = path8.join(EXE_AI_DIR, "session-cache", `current-task-${agent.agentId}.json`);
+            if (existsSync7(cachePath)) {
+              const cached = JSON.parse(readFileSync6(cachePath, "utf8"));
+              taskId = cached.taskId ?? null;
+            }
+          } catch {
+          }
+          const detectData2 = { tool_name: data.tool_name, tool_response: data.tool_response };
+          const hasError = detectError(detectData2);
+          const isDraft = taskId !== null && !canCoordinate2(agent.agentId, agent.agentRole);
+          const toolInputStr = JSON.stringify(data.tool_input ?? "").slice(0, 200);
+          const toolOutputStr = JSON.stringify(data.tool_response ?? "").slice(0, 200);
+          const token = process.env.EXE_DAEMON_TOKEN ?? readDaemonToken2();
+          const projectName = getProjectName2(data.cwd ?? process.cwd());
+          const payload = JSON.stringify({
+            id: `ingest-${Date.now()}`,
+            token,
+            type: "ingest",
+            rawText,
+            agentId: agent.agentId,
+            agentRole: agent.agentRole,
+            sessionId: data.session_id ?? "",
+            toolName: data.tool_name,
+            projectName,
+            hasError,
+            taskId,
+            confidence: agent.agentId === "default" ? 0.9 : 0.7,
+            draft: isDraft,
+            trajectory: { input: toolInputStr, tool: data.tool_name, output: toolOutputStr, result_type: hasError ? "error" : "success" }
+          }) + "\n";
+          const net = await import("net");
+          const sock = net.connect(socketPath);
+          sock.on("error", () => {
+          });
+          sock.write(payload, () => {
+            sock.destroy();
+          });
+          sentViaDaemon = true;
+        } else {
+          sentViaDaemon = true;
+        }
+      }
+    } catch {
+    }
+    if (sentViaDaemon) {
+      setTimeout(() => process.exit(0), 10);
+      return;
+    }
+    const workerPath = path8.resolve(
+      path8.dirname(fileURLToPath(import.meta.url)),
       "ingest-worker.js"
     );
     if (!tryAcquireWorkerSlot()) {