@askexenow/exe-os 0.8.0

package/dist/hooks/ingest.js

@@ -0,0 +1,684 @@
+// src/lib/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { readFileSync, existsSync, renameSync } from "fs";
+import path from "path";
+import os from "os";
+function resolveDataDir() {
+  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
+  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)) {
+    try {
+      renameSync(legacyDir, newDir);
+      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
+`);
+    } catch {
+      return legacyDir;
+    }
+  }
+  return newDir;
+}
+var EXE_AI_DIR = resolveDataDir();
+var DB_PATH = path.join(EXE_AI_DIR, "memories.db");
+var MODELS_DIR = path.join(EXE_AI_DIR, "models");
+var CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
+var LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
+var CURRENT_CONFIG_VERSION = 1;
+var DEFAULT_CONFIG = {
+  config_version: CURRENT_CONFIG_VERSION,
+  dbPath: DB_PATH,
+  modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
+  embeddingDim: 1024,
+  batchSize: 20,
+  flushIntervalMs: 1e4,
+  autoIngestion: true,
+  autoRetrieval: true,
+  searchMode: "hybrid",
+  hookSearchMode: "hybrid",
+  fileGrepEnabled: true,
+  splashEffect: true,
+  consolidationEnabled: true,
+  consolidationIntervalMs: 6 * 60 * 60 * 1e3,
+  consolidationModel: "claude-haiku-4-5-20251001",
+  consolidationMaxCallsPerRun: 20,
+  selfQueryRouter: true,
+  selfQueryModel: "claude-haiku-4-5-20251001",
+  rerankerEnabled: true,
+  scalingRoadmap: {
+    rerankerAutoTrigger: {
+      enabled: true,
+      broadQueryMinCardinality: 5e4,
+      fetchTopK: 150,
+      returnTopK: 5
+    }
+  },
+  graphRagEnabled: true,
+  wikiEnabled: false,
+  wikiUrl: "",
+  wikiApiKey: "",
+  wikiSyncIntervalMs: 30 * 60 * 1e3,
+  wikiWorkspaceMapping: {
+    exe: "Executive",
+    yoshi: "Engineering",
+    mari: "Marketing",
+    tom: "Engineering",
+    sasha: "Production"
+  },
+  wikiAutoUpdate: true,
+  wikiAutoUpdateThreshold: 0.5,
+  wikiAutoUpdateCreateNew: true,
+  skillLearning: true,
+  skillThreshold: 3,
+  skillModel: "claude-haiku-4-5-20251001",
+  exeHeartbeat: {
+    enabled: true,
+    intervalSeconds: 60,
+    staleInProgressThresholdHours: 2
+  },
+  sessionLifecycle: {
+    idleKillEnabled: true,
+    idleKillTicksRequired: 3,
+    idleKillIntercomAckWindowMs: 1e4,
+    maxAutoInstances: 10
+  }
+};
+function migrateLegacyConfig(raw) {
+  if ("r2" in raw) {
+    process.stderr.write(
+      "[exe-os] Warning: config.json contains deprecated 'r2' field from v1.0. R2 sync has been replaced in v1.1. The 'r2' field will be ignored.\n"
+    );
+    delete raw.r2;
+  }
+  if ("syncIntervalMs" in raw) {
+    delete raw.syncIntervalMs;
+  }
+  return raw;
+}
+var CONFIG_MIGRATIONS = [
+  {
+    from: 0,
+    to: 1,
+    migrate: (cfg) => {
+      cfg.config_version = 1;
+      return cfg;
+    }
+  }
+];
+function migrateConfig(raw) {
+  const fromVersion = typeof raw.config_version === "number" ? raw.config_version : 0;
+  let currentVersion = fromVersion;
+  let migrated = false;
+  if (currentVersion > CURRENT_CONFIG_VERSION) {
+    return { config: raw, migrated: false, fromVersion };
+  }
+  for (const migration of CONFIG_MIGRATIONS) {
+    if (currentVersion === migration.from && migration.to <= CURRENT_CONFIG_VERSION) {
+      raw = migration.migrate(raw);
+      currentVersion = migration.to;
+      migrated = true;
+    }
+  }
+  return { config: raw, migrated, fromVersion };
+}
+function normalizeScalingRoadmap(raw) {
+  const defaultAuto = DEFAULT_CONFIG.scalingRoadmap.rerankerAutoTrigger;
+  const userRoadmap = raw.scalingRoadmap ?? {};
+  const userAuto = userRoadmap.rerankerAutoTrigger ?? {};
+  if (userAuto.enabled === void 0 && raw.rerankerEnabled !== void 0) {
+    userAuto.enabled = raw.rerankerEnabled;
+  }
+  raw.scalingRoadmap = {
+    ...userRoadmap,
+    rerankerAutoTrigger: { ...defaultAuto, ...userAuto }
+  };
+}
+function normalizeSessionLifecycle(raw) {
+  const defaultSL = DEFAULT_CONFIG.sessionLifecycle;
+  const userSL = raw.sessionLifecycle ?? {};
+  raw.sessionLifecycle = { ...defaultSL, ...userSL };
+}
+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)) {
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    let parsed = JSON.parse(raw);
+    parsed = migrateLegacyConfig(parsed);
+    const { config: migratedCfg } = migrateConfig(parsed);
+    normalizeScalingRoadmap(migratedCfg);
+    normalizeSessionLifecycle(migratedCfg);
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
+  } catch {
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
+  }
+}
+
+// src/adapters/claude/hooks/ingest.ts
+import { spawn } from "child_process";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2, openSync, closeSync } from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+
+// src/adapters/claude/active-agent.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, unlinkSync, readdirSync } from "fs";
+import { execSync as execSync2 } from "child_process";
+import path2 from "path";
+
+// src/lib/session-key.ts
+import { execSync } from "child_process";
+var _cached = null;
+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;
+}
+
+// src/adapters/claude/active-agent.ts
+var CACHE_DIR = path2.join(EXE_AI_DIR, "session-cache");
+var STALE_MS = 24 * 60 * 60 * 1e3;
+function getMarkerPath() {
+  return path2.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+}
+function getActiveAgent() {
+  try {
+    const markerPath = getMarkerPath();
+    const raw = readFileSync2(markerPath, "utf8");
+    const data = JSON.parse(raw);
+    if (data.agentId) {
+      if (data.startedAt) {
+        const age = Date.now() - new Date(data.startedAt).getTime();
+        if (age > STALE_MS) {
+          try {
+            unlinkSync(markerPath);
+          } catch {
+          }
+        } else {
+          return {
+            agentId: data.agentId,
+            agentRole: data.agentRole || "employee"
+          };
+        }
+      } else {
+        return {
+          agentId: data.agentId,
+          agentRole: data.agentRole || "employee"
+        };
+      }
+    }
+  } catch {
+  }
+  try {
+    const sessionName = execSync2(
+      "tmux display-message -p '#{session_name}' 2>/dev/null",
+      { encoding: "utf8", timeout: 2e3 }
+    ).trim();
+    const empMatch = sessionName.match(/^(\w+)-exe\d+$/);
+    if (empMatch && empMatch[1] !== "exe") {
+      return { agentId: empMatch[1], agentRole: "employee" };
+    }
+    if (/^exe\d+$/.test(sessionName)) {
+      return { agentId: "exe", agentRole: "COO" };
+    }
+  } catch {
+  }
+  return {
+    agentId: process.env.AGENT_ID || "default",
+    agentRole: process.env.AGENT_ROLE || "employee"
+  };
+}
+
+// src/lib/error-detector.ts
+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/,
+  /\bFAIL(ED|URE)?\b/i,
+  /\bException\b/i,
+  /\bTraceback\b/,
+  /\bpanic\b/,
+  /\bSIGSEGV\b/,
+  /\bSIGABRT\b/,
+  /exit code [1-9]/i,
+  /non-zero (exit|status)/i,
+  /command not found/i,
+  /permission denied/i,
+  /ENOENT/,
+  /EACCES/,
+  /ENOMEM/
+];
+var FILE_CONTENT_TOOLS = /* @__PURE__ */ new Set([
+  "Read",
+  "Write",
+  "Edit",
+  "Glob",
+  "Grep",
+  "NotebookEdit"
+]);
+var STDERR_IGNORE_PATTERNS = [
+  /^warning\b/i,
+  /\bDeprecationWarning\b/,
+  /^hint:/i,
+  /^npm warn\b/i,
+  /^npm notice\b/i,
+  /^\(node:\d+\) \w*Warning:/,
+  /^Cloning into/,
+  /^Already on/,
+  /^Switched to/,
+  /^Your branch is/,
+  /^Auto-merging/,
+  /^\s*$/
+];
+function isRealStderr(stderr) {
+  const lines = stderr.trim().split("\n");
+  const meaningful = lines.filter(
+    (line) => line.trim().length > 0 && !STDERR_IGNORE_PATTERNS.some((p) => p.test(line))
+  );
+  return meaningful.length > 0;
+}
+function logSuppression(exitCode, stderr, stdout) {
+  process.stderr.write(
+    `[error-detector] suppressed bash non-zero exit: code=${exitCode} stderr_len=${stderr.length} stdout_len=${stdout.length}
+`
+  );
+}
+function detectError(data) {
+  const response = data.tool_response;
+  if (!response) return false;
+  const toolName = data.tool_name ?? "";
+  if (FILE_CONTENT_TOOLS.has(toolName)) {
+    return response.type === "error" || response.error != null;
+  }
+  if (toolName === "Bash") {
+    const exitCode = typeof response.exitCode === "number" ? response.exitCode : 0;
+    const stderr = typeof response.stderr === "string" ? response.stderr : "";
+    const stdout = typeof response.stdout === "string" ? response.stdout : "";
+    if (exitCode === 141) {
+      logSuppression(exitCode, stderr, stdout);
+      return false;
+    }
+    if (stderr.trim().length > 0 && isRealStderr(stderr)) return true;
+    if (exitCode !== 0 && !isRealStderr(stderr) && stdout.trim().length > 0) {
+      logSuppression(exitCode, stderr, stdout);
+      return false;
+    }
+    if (exitCode !== 0) return true;
+    return false;
+  }
+  if (response.type === "error" || response.error != null || response.isError === true) {
+    return true;
+  }
+  if (typeof response.stderr === "string" && response.stderr.trim().length > 0) {
+    if (isRealStderr(response.stderr)) return true;
+  }
+  const textParts = [];
+  if (typeof response.stdout === "string") textParts.push(response.stdout);
+  if (typeof response.output === "string") textParts.push(response.output);
+  if (typeof response.text === "string") textParts.push(response.text);
+  if (typeof response.message === "string") textParts.push(response.message);
+  if (textParts.length === 0) return false;
+  const text = textParts.join("\n");
+  return ERROR_PATTERNS.some((pattern) => pattern.test(text));
+}
+function isExeOsError(data) {
+  const toolName = data.tool_name ?? "";
+  if (isExeMcpTool(toolName)) return true;
+  if (toolName === "Bash") {
+    const cmd = String(data.tool_input?.command ?? "");
+    if (/\bexe-os\b|exe-boot|exe-healthcheck|scan-tasks|exe-call/.test(cmd)) return true;
+    if (/node.*dist\/(bin|hooks|lib)\//.test(cmd)) return true;
+  }
+  return false;
+}
+var USER_ERROR_PATTERNS = [
+  /not found:?\s/i,
+  /expected \d+ words/i,
+  /provide either/i,
+  /invalid.*parameter/i,
+  /already exists/i,
+  /Multiple tasks match/i,
+  /Use a more specific identifier/i
+];
+var SYSTEM_BUG_PATTERNS = [
+  /SQLITE_ERROR/,
+  /Cannot find module/,
+  /ERR_MODULE_NOT_FOUND/,
+  /TypeError:/,
+  /ReferenceError:/,
+  /Cannot read propert/,
+  /is not a function/,
+  /ENOENT.*dist\//,
+  /dimension mismatch/i,
+  /unhealthy.*model/i,
+  /constraint.*violat/i
+];
+function classifyError(errorText) {
+  if (USER_ERROR_PATTERNS.some((p) => p.test(errorText))) return "user";
+  if (SYSTEM_BUG_PATTERNS.some((p) => p.test(errorText))) return "system";
+  if (/at\s+\S+\s+\(.*exe-os.*\)/m.test(errorText)) return "system";
+  if (/at\s+\S+\s+\(.*dist\/(lib|bin|hooks|mcp)\//m.test(errorText)) return "system";
+  return "unknown";
+}
+function errorFingerprint(toolName, errorText) {
+  const normalized = errorText.replace(/\d{4}-\d{2}-\d{2}T[\d:.]+Z/g, "TIMESTAMP").replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, "UUID").replace(/\/Users\/[^\s]+/g, "PATH").replace(/:\d+:\d+/g, ":LINE:COL").slice(0, 200);
+  return crypto.createHash("sha256").update(`${toolName}:${normalized}`).digest("hex").slice(0, 16);
+}
+
+// src/adapters/claude/hooks/ingest.ts
+if (!process.env.AGENT_ID) {
+  process.env.AGENT_ID = "default";
+  process.env.AGENT_ROLE = "employee";
+}
+if (!loadConfigSync().autoIngestion) {
+  process.exit(0);
+}
+var WORKER_LOG_PATH = path3.join(EXE_AI_DIR, "workers.log");
+function openWorkerLog() {
+  try {
+    return openSync(WORKER_LOG_PATH, "a");
+  } catch {
+    return "ignore";
+  }
+}
+var ALLOWED_TOOL_RE = /^(Bash|Edit|Write|Read|Glob|Grep|Agent|mcp__.*)$/;
+var WRITE_TOOL_RE = /^(Bash|Edit|Write)$/;
+var SUMMARY_INTERVAL = 25;
+var MIN_WRITES_FOR_SUMMARY = 3;
+var COUNTER_DIR = path3.join(EXE_AI_DIR, "session-cache");
+function getCounterPath(sessionId) {
+  return path3.join(COUNTER_DIR, `counter-${sessionId}.json`);
+}
+function loadCounter(sessionId) {
+  try {
+    const raw = readFileSync3(getCounterPath(sessionId), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return { total: 0, writes: 0, pipelineWrites: 0, lastSummaryAt: 0, pipelineDetected: false };
+  }
+}
+function saveCounter(sessionId, counter) {
+  try {
+    mkdirSync2(COUNTER_DIR, { recursive: true });
+    writeFileSync2(getCounterPath(sessionId), JSON.stringify(counter));
+  } catch {
+  }
+}
+var MAX_INPUT_SIZE = 1e6;
+var input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  if (input.length < MAX_INPUT_SIZE) {
+    input += chunk;
+  }
+});
+process.stdin.on("end", () => {
+  try {
+    const data = JSON.parse(input);
+    if (!data.tool_name) {
+      process.exit(0);
+    }
+    const agent = getActiveAgent();
+    if (/^(Read|Write|Edit)$/.test(data.tool_name) && agent.agentId !== "exe" && agent.agentId !== "default") {
+      const filePath = data.tool_input?.file_path ?? "";
+      const exeMatch = filePath.match(/exe\/([^/]+)\//);
+      if (exeMatch && exeMatch[1] !== agent.agentId) {
+        const target = exeMatch[1];
+        const warning = JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            additionalContext: `## Boundary Violation
+BOUNDARY VIOLATION: You accessed exe/${target}/ \u2014 that is ${target}'s workspace, not yours.
+Your workspace is exe/${agent.agentId}/. Use ask_team_memory("${target}") if you need context from their work.
+Do NOT read, write, or modify files in another employee's folder.`
+          }
+        });
+        process.stdout.write(warning);
+      }
+    }
+    if (/^(Read|Glob|Grep|Bash)$/.test(data.tool_name) && agent.agentId === "exe") {
+      const target = data.tool_input?.file_path ?? data.tool_input?.path ?? data.tool_input?.pattern ?? String(data.tool_input?.command ?? "");
+      if (/exe\/exe\//.test(target)) {
+        const warning = JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            additionalContext: `## Review Count Warning
+WARNING: exe/exe/ may contain stale done review files. NEVER count files here to determine review counts.
+The boot brief has the correct open review count from the DB. Use that number, not filesystem counts.
+Open reviews are tracked in the tasks table: SELECT COUNT(*) FROM tasks WHERE assigned_to = 'exe' AND status IN ('open','in_progress') AND task_file LIKE '%review-%'`
+          }
+        });
+        process.stdout.write(warning);
+      }
+    }
+    if (/^(Write|Bash)$/.test(data.tool_name) && agent.agentId !== "exe" && agent.agentId !== "default") {
+      const filePath = data.tool_input?.file_path ?? String(data.tool_input?.command ?? "");
+      const outputMatch = filePath.match(/exe\/output\/([^/\-]+)-([^/]+)/);
+      if (outputMatch) {
+        const outputAgent = outputMatch[1];
+        if (outputAgent !== agent.agentId) {
+          const warning = JSON.stringify({
+            hookSpecificOutput: {
+              hookEventName: "PostToolUse",
+              additionalContext: `## Boundary Violation
+You wrote to exe/output/${outputAgent}-* \u2014 only ${outputAgent} can write files with that prefix.
+Your output files must start with: exe/output/${agent.agentId}-`
+            }
+          });
+          process.stdout.write(warning);
+        }
+      }
+    }
+    const detectData = { tool_name: data.tool_name, tool_response: data.tool_response };
+    if (detectError(detectData) && isExeOsError(data) && agent.agentId !== "default") {
+      const errorText = JSON.stringify(data.tool_response).slice(0, 1e3);
+      const classification = classifyError(errorText);
+      if (classification === "system" && data.session_id) {
+        const fp = errorFingerprint(data.tool_name, errorText);
+        const fpFilePath = path3.join(COUNTER_DIR, `bug-fingerprints-${data.session_id}.json`);
+        let fpData = {
+          seen: {},
+          taskCount: 0,
+          lastTaskAt: ""
+        };
+        try {
+          fpData = JSON.parse(readFileSync3(fpFilePath, "utf8"));
+        } catch {
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const alreadySeen = fp in fpData.seen;
+        const rateLimited = fpData.taskCount >= 5 || fpData.lastTaskAt && Date.now() - new Date(fpData.lastTaskAt).getTime() < 6e4;
+        if (alreadySeen) {
+          fpData.seen[fp].count++;
+          fpData.seen[fp].lastAt = now;
+        } else if (rateLimited) {
+          fpData.seen[fp] = { count: 1, firstAt: now, lastAt: now };
+          if (fpData.taskCount >= 5) {
+            process.stderr.write("[ingest] Auto-bug rate limit reached (5 tasks this session). Suppressing.\n");
+          }
+        } else {
+          fpData.seen[fp] = { count: 1, firstAt: now, lastAt: now };
+          fpData.taskCount++;
+          fpData.lastTaskAt = now;
+          const bugWorkerPath = path3.resolve(
+            path3.dirname(fileURLToPath(import.meta.url)),
+            "bug-report-worker.js"
+          );
+          if (existsSync2(bugWorkerPath)) {
+            const stderrFd2 = openWorkerLog();
+            const projectName = process.cwd().split(path3.sep).pop() ?? "unknown";
+            const bugToolInput = data.tool_input ?? {};
+            const bugWorker = spawn(process.execPath, [bugWorkerPath], {
+              detached: true,
+              stdio: ["ignore", "ignore", stderrFd2],
+              env: {
+                ...process.env,
+                BUG_TOOL_NAME: data.tool_name,
+                BUG_ERROR_TEXT: errorText,
+                BUG_TOOL_INPUT: JSON.stringify(bugToolInput).slice(0, 500),
+                BUG_FINGERPRINT: fp,
+                BUG_AGENT_ID: agent.agentId,
+                BUG_AGENT_ROLE: agent.agentRole,
+                BUG_PROJECT_NAME: projectName
+              }
+            });
+            bugWorker.unref();
+            if (typeof stderrFd2 === "number") try {
+              closeSync(stderrFd2);
+            } catch {
+            }
+          } else {
+            process.stderr.write(`[ingest] WARN: bug-report-worker not found at ${bugWorkerPath}
+`);
+          }
+        }
+        try {
+          mkdirSync2(COUNTER_DIR, { recursive: true });
+          writeFileSync2(fpFilePath, JSON.stringify(fpData));
+        } catch {
+        }
+      }
+    }
+    if (data.session_id && agent.agentId !== "exe" && agent.agentId !== "default") {
+      const counter = loadCounter(data.session_id);
+      counter.total++;
+      if (WRITE_TOOL_RE.test(data.tool_name)) {
+        counter.writes++;
+        counter.pipelineWrites++;
+      }
+      if (data.tool_name === "Skill" && data.tool_input?.skill === "exe-build-e2e") {
+        counter.pipelineDetected = true;
+      }
+      const callsSinceLastSummary = counter.total - counter.lastSummaryAt;
+      if (callsSinceLastSummary >= SUMMARY_INTERVAL && counter.writes >= MIN_WRITES_FOR_SUMMARY) {
+        const summaryWorkerPath = path3.resolve(
+          path3.dirname(fileURLToPath(import.meta.url)),
+          "summary-worker.js"
+        );
+        if (existsSync2(summaryWorkerPath)) {
+          const stderrFd2 = openWorkerLog();
+          const summaryWorker = spawn(process.execPath, [summaryWorkerPath], {
+            detached: true,
+            stdio: ["ignore", "ignore", stderrFd2],
+            env: {
+              ...process.env,
+              AGENT_ID: agent.agentId,
+              AGENT_ROLE: agent.agentRole,
+              EXE_SUMMARY_SINCE: String(counter.lastSummaryAt),
+              EXE_SUMMARY_TOTAL: String(callsSinceLastSummary),
+              EXE_SUMMARY_WRITES: String(counter.writes)
+            }
+          });
+          summaryWorker.unref();
+          if (typeof stderrFd2 === "number") try {
+            closeSync(stderrFd2);
+          } catch {
+          }
+        } else {
+          process.stderr.write(`[ingest] WARN: summary-worker not found at ${summaryWorkerPath}
+`);
+        }
+        counter.lastSummaryAt = counter.total;
+        counter.writes = 0;
+      }
+      saveCounter(data.session_id, counter);
+      if (WRITE_TOOL_RE.test(data.tool_name) && counter.pipelineWrites >= 3 && !counter.pipelineDetected) {
+        const warning = JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            additionalContext: "## Pipeline Warning\nWARNING: You are writing code without running the exe-build-e2e pipeline.\nIf this task adds capability or changes behavior, run /exe-build-e2e first.\nIf this is a minor fix (typo, config, one-liner), you can ignore this warning."
+          }
+        });
+        process.stdout.write(warning);
+      }
+    }
+    if (data.tool_name === "Bash" && agent.agentId !== "default") {
+      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 = path3.resolve(
+          path3.dirname(fileURLToPath(import.meta.url)),
+          "commit-complete.js"
+        );
+        if (existsSync2(commitWorkerPath)) {
+          const stderrFd2 = openWorkerLog();
+          const projectName = process.cwd().split(path3.sep).pop() ?? "unknown";
+          const commitWorker = spawn(process.execPath, [commitWorkerPath], {
+            detached: true,
+            stdio: ["ignore", "ignore", stderrFd2],
+            env: {
+              ...process.env,
+              COMMIT_HASH: commitMatch[2],
+              COMMIT_MESSAGE: commitMatch[3].trim(),
+              AGENT_ID: agent.agentId,
+              PROJECT_NAME: projectName
+            }
+          });
+          commitWorker.unref();
+          if (typeof stderrFd2 === "number") try {
+            closeSync(stderrFd2);
+          } catch {
+          }
+        }
+      }
+    }
+    if (!ALLOWED_TOOL_RE.test(data.tool_name)) {
+      process.exit(0);
+    }
+    const workerPath = path3.resolve(
+      path3.dirname(fileURLToPath(import.meta.url)),
+      "ingest-worker.js"
+    );
+    const stderrFd = openWorkerLog();
+    const worker = spawn(process.execPath, [workerPath], {
+      detached: true,
+      stdio: ["pipe", "ignore", stderrFd],
+      env: { ...process.env, AGENT_ID: agent.agentId, AGENT_ROLE: agent.agentRole }
+    });
+    worker.stdin.write(input);
+    worker.stdin.end();
+    worker.unref();
+    if (typeof stderrFd === "number") try {
+      closeSync(stderrFd);
+    } catch {
+    }
+  } catch {
+  }
+  process.exit(0);
+});