@askexenow/exe-os 0.8.85 → 0.8.87

package/dist/hooks/ingest-worker.js

@@ -59,34 +59,34 @@ var init_mcp_prefix = __esm({
 });
 
 // src/lib/project-name.ts
-import { execSync as execSync2 } from "child_process";
-import path2 from "path";
+import { execSync } from "child_process";
+import path from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached && _cachedCwd === dir) return _cached;
   try {
     let repoRoot;
     try {
-      const gitCommonDir = execSync2("git rev-parse --path-format=absolute --git-common-dir", {
+      const gitCommonDir = execSync("git rev-parse --path-format=absolute --git-common-dir", {
         cwd: dir,
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path2.dirname(gitCommonDir);
+      repoRoot = path.dirname(gitCommonDir);
     } catch {
-      repoRoot = execSync2("git rev-parse --show-toplevel", {
+      repoRoot = execSync("git rev-parse --show-toplevel", {
         cwd: dir,
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached = path2.basename(repoRoot);
+    _cached = path.basename(repoRoot);
     _cachedCwd = dir;
     return _cached;
   } catch {
-    _cached = path2.basename(dir);
+    _cached = path.basename(dir);
     _cachedCwd = dir;
     return _cached;
   }
@@ -181,15 +181,15 @@ __export(config_exports, {
   saveConfig: () => saveConfig
 });
 import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { readFileSync as readFileSync2, existsSync as existsSync2, renameSync } from "fs";
-import path3 from "path";
-import os2 from "os";
+import { readFileSync, existsSync, renameSync } from "fs";
+import path2 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 = path3.join(os2.homedir(), ".exe-os");
-  const legacyDir = path3.join(os2.homedir(), ".exe-mem");
-  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
+  const newDir = path2.join(os.homedir(), ".exe-os");
+  const legacyDir = path2.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
@@ -253,9 +253,9 @@ function normalizeAutoUpdate(raw) {
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir(dir, { recursive: true });
-  const configPath = path3.join(dir, "config.json");
-  if (!existsSync2(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
   const raw = await readFile(configPath, "utf-8");
   try {
@@ -273,38 +273,38 @@ async function loadConfig() {
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
-    const config = { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db"), ...migratedCfg };
+    const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os2.homedir());
+      config.dbPath = config.dbPath.replace(/^~/, os.homedir());
     }
     return config;
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
 }
 function loadConfigSync() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  const configPath = path3.join(dir, "config.json");
-  if (!existsSync2(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
   try {
-    const raw = readFileSync2(configPath, "utf-8");
+    const raw = readFileSync(configPath, "utf-8");
     let parsed = JSON.parse(raw);
     parsed = migrateLegacyConfig(parsed);
     const { config: migratedCfg } = migrateConfig(parsed);
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db"), ...migratedCfg };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
 }
 async function saveConfig(config) {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir(dir, { recursive: true });
-  const configPath = path3.join(dir, "config.json");
+  const configPath = path2.join(dir, "config.json");
   await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
   if (config.cloud?.apiKey) {
     await chmod(configPath, 384);
@@ -329,10 +329,10 @@ var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
     EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path3.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path3.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path3.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path3.join(EXE_AI_DIR, "local.lance");
+    DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
+    MODELS_DIR = path2.join(EXE_AI_DIR, "models");
+    CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
+    LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
     CURRENT_CONFIG_VERSION = 1;
     DEFAULT_CONFIG = {
       config_version: CURRENT_CONFIG_VERSION,
@@ -406,10 +406,10 @@ var init_config = __esm({
 
 // src/lib/employees.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync3, symlinkSync, readlinkSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
-import { execSync as execSync3 } from "child_process";
-import path4 from "path";
-import os3 from "os";
+import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
+import { execSync as execSync2 } from "child_process";
+import path3 from "path";
+import os2 from "os";
 function normalizeRole(role) {
   return (role ?? "").trim().toLowerCase();
 }
@@ -430,9 +430,9 @@ function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
   return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync3(employeesPath)) return [];
+  if (!existsSync2(employeesPath)) return [];
   try {
-    return JSON.parse(readFileSync3(employeesPath, "utf-8"));
+    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
   } catch {
     return [];
   }
@@ -451,7 +451,7 @@ var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
-    EMPLOYEES_PATH = path4.join(EXE_AI_DIR, "exe-employees.json");
+    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"]);
@@ -462,8 +462,8 @@ var init_employees = __esm({
 import net from "net";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync4, unlinkSync as unlinkSync2, readFileSync as readFileSync4, openSync, closeSync, statSync as statSync2 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync3, unlinkSync as unlinkSync2, readFileSync as readFileSync3, openSync, closeSync, statSync } from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -491,9 +491,9 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync4(PID_PATH)) {
+  if (existsSync3(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync4(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -514,11 +514,11 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path5.dirname(fileURLToPath(import.meta.url));
-  const { root } = path5.parse(dir);
+  let dir = path4.dirname(fileURLToPath(import.meta.url));
+  const { root } = path4.parse(dir);
   while (dir !== root) {
-    if (existsSync4(path5.join(dir, "package.json"))) return dir;
-    dir = path5.dirname(dir);
+    if (existsSync3(path4.join(dir, "package.json"))) return dir;
+    dir = path4.dirname(dir);
   }
   return null;
 }
@@ -528,8 +528,8 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path5.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync4(daemonPath)) {
+  const daemonPath = path4.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync3(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
     return;
@@ -537,7 +537,7 @@ function spawnDaemon() {
   const resolvedPath = daemonPath;
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path5.join(path5.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path4.join(path4.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -571,7 +571,7 @@ function acquireSpawnLock() {
     return true;
   } catch {
     try {
-      const stat = statSync2(SPAWN_LOCK_PATH);
+      const stat = statSync(SPAWN_LOCK_PATH);
       if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
         try {
           unlinkSync2(SPAWN_LOCK_PATH);
@@ -687,9 +687,9 @@ async function pingDaemon() {
 }
 function killAndRespawnDaemon() {
   process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync4(PID_PATH)) {
+  if (existsSync3(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync4(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, "SIGKILL");
@@ -776,9 +776,9 @@ var init_exe_daemon_client = __esm({
   "src/lib/exe-daemon-client.ts"() {
     "use strict";
     init_config();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path5.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path5.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path5.join(EXE_AI_DIR, "exed-spawn.lock");
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path4.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path4.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path4.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
@@ -2072,12 +2072,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path7 from "path";
-import { existsSync as existsSync6, mkdirSync, readdirSync as readdirSync2 } from "fs";
+import path6 from "path";
+import { existsSync as existsSync5, mkdirSync, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync6(SHARDS_DIR)) {
+  if (!existsSync5(SHARDS_DIR)) {
     mkdirSync(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -2098,7 +2098,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path7.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path6.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -2108,11 +2108,11 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync6(path7.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync5(path6.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync6(SHARDS_DIR)) return [];
-  return readdirSync2(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+  if (!existsSync5(SHARDS_DIR)) return [];
+  return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
   await client.execute("PRAGMA journal_mode = WAL");
@@ -2297,7 +2297,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path7.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path6.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -2487,13 +2487,13 @@ ${p.content}`).join("\n\n");
 
 // src/lib/notifications.ts
 import crypto2 from "crypto";
-import path8 from "path";
-import os5 from "os";
+import path7 from "path";
+import os4 from "os";
 import {
-  readFileSync as readFileSync5,
-  readdirSync as readdirSync3,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync2,
   unlinkSync as unlinkSync3,
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -2538,9 +2538,9 @@ var init_notifications = __esm({
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
-import path9 from "path";
+import path8 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -2551,17 +2551,17 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path9.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path8.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync8(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync6(deviceJsonPath, "utf8"));
+    if (existsSync7(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync5(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync8(DEVICE_ID_PATH)) {
-      const id2 = readFileSync6(DEVICE_ID_PATH, "utf8").trim();
+    if (existsSync7(DEVICE_ID_PATH)) {
+      const id2 = readFileSync5(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
@@ -2573,8 +2573,8 @@ function loadDeviceId() {
 }
 function loadLicense() {
   try {
-    if (!existsSync8(LICENSE_PATH)) return null;
-    return readFileSync6(LICENSE_PATH, "utf8").trim();
+    if (!existsSync7(LICENSE_PATH)) return null;
+    return readFileSync5(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
@@ -2607,8 +2607,8 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    if (!existsSync7(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync5(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -2617,8 +2617,8 @@ async function getCachedLicense() {
 }
 function readCachedToken() {
   try {
-    if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    if (!existsSync7(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync5(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
     return null;
@@ -2705,8 +2705,8 @@ async function validateLicense(apiKey, deviceId) {
 }
 function getCacheAgeMs() {
   try {
-    const { statSync: statSync3 } = __require("fs");
-    const s = statSync3(CACHE_PATH);
+    const { statSync: statSync2 } = __require("fs");
+    const s = statSync2(CACHE_PATH);
     return Date.now() - s.mtimeMs;
   } catch {
     return Infinity;
@@ -2716,9 +2716,9 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path9.join(EXE_AI_DIR, "config.json");
-      if (existsSync8(configPath)) {
-        const raw = JSON.parse(readFileSync6(configPath, "utf8"));
+      const configPath = path8.join(EXE_AI_DIR, "config.json");
+      if (existsSync7(configPath)) {
+        const raw = JSON.parse(readFileSync5(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
           key = cloud.apiKey;
@@ -2739,9 +2739,9 @@ var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path9.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path9.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path9.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path8.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path8.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path8.join(EXE_AI_DIR, "device-id");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -2770,12 +2770,12 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
-import path10 from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import path9 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync9(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync7(CACHE_PATH2, "utf8"));
+    if (!existsSync8(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync6(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -2832,8 +2832,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync9(filePath)) {
-      const raw = readFileSync7(filePath, "utf8");
+    if (existsSync8(filePath)) {
+      const raw = readFileSync6(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -2862,7 +2862,7 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path10.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path9.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
@@ -2935,12 +2935,12 @@ var init_embedder = __esm({
 });
 
 // src/lib/session-registry.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync10 } from "fs";
-import path11 from "path";
-import os6 from "os";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync9 } from "fs";
+import path10 from "path";
+import os5 from "os";
 function registerSession(entry) {
-  const dir = path11.dirname(REGISTRY_PATH);
-  if (!existsSync10(dir)) {
+  const dir = path10.dirname(REGISTRY_PATH);
+  if (!existsSync9(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
   const sessions = listSessions();
@@ -2954,7 +2954,7 @@ function registerSession(entry) {
 }
 function listSessions() {
   try {
-    const raw = readFileSync8(REGISTRY_PATH, "utf8");
+    const raw = readFileSync7(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -2964,18 +2964,18 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path11.join(os6.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path10.join(os5.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
 // src/lib/session-key.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function getSessionKey() {
   if (_cached2) return _cached2;
   let pid = process.ppid;
   for (let i = 0; i < 10; i++) {
     try {
-      const info = execSync4(`ps -p ${pid} -o ppid=,comm=`, {
+      const info = execSync3(`ps -p ${pid} -o ppid=,comm=`, {
         encoding: "utf8",
         timeout: 2e3
       }).trim();
@@ -3111,14 +3111,14 @@ var init_transport = __esm({
 });
 
 // src/lib/cc-agent-support.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function _resetCcAgentSupportCache() {
   _cachedSupport = null;
 }
 function claudeSupportsAgentFlag() {
   if (_cachedSupport !== null) return _cachedSupport;
   try {
-    const helpOutput = execSync5("claude --help 2>&1", {
+    const helpOutput = execSync4("claude --help 2>&1", {
       encoding: "utf-8",
       timeout: 5e3
     });
@@ -3160,13 +3160,64 @@ var init_provider_table = __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: "exec",
+        autoApproveFlag: "--full-auto",
+        inlineFlag: "--no-alt-screen",
+        apiKeyEnv: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.4"
+      }
+    };
+    DEFAULT_RUNTIME = "claude";
+  }
+});
+
+// src/lib/agent-config.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync10, mkdirSync as mkdirSync4 } from "fs";
+import path11 from "path";
+function loadAgentConfig() {
+  if (!existsSync10(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync8(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  const entry = config[agentId];
+  if (entry) return entry;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+var AGENT_CONFIG_PATH, DEFAULT_MODELS;
+var init_agent_config = __esm({
+  "src/lib/agent-config.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_table();
+    AGENT_CONFIG_PATH = path11.join(EXE_AI_DIR, "agent-config.json");
+    DEFAULT_MODELS = {
+      claude: "claude-opus-4",
+      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+      opencode: "minimax-m2.7"
+    };
+  }
+});
+
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, renameSync as renameSync3, existsSync as existsSync11, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, renameSync as renameSync3, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "fs";
 import path12 from "path";
-import os7 from "os";
+import os6 from "os";
 function ensureDir() {
   const dir = path12.dirname(QUEUE_PATH);
-  if (!existsSync11(dir)) mkdirSync4(dir, { recursive: true });
+  if (!existsSync11(dir)) mkdirSync5(dir, { recursive: true });
 }
 function readQueue() {
   try {
@@ -3179,7 +3230,7 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync5(tmp, JSON.stringify(queue, null, 2));
   renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -3203,9 +3254,9 @@ var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path12.join(os7.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path12.join(os6.homedir(), ".exe-os", "intercom-queue.json");
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path12.join(os7.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path12.join(os6.homedir(), ".exe-os", "intercom.log");
   }
 });
 
@@ -3552,10 +3603,10 @@ __export(tmux_routing_exports, {
   spawnEmployee: () => spawnEmployee,
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
-import { execFileSync as execFileSync2, execSync as execSync6 } from "child_process";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync12, appendFileSync } from "fs";
+import { execFileSync as execFileSync2, execSync as execSync5 } from "child_process";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync12, appendFileSync } from "fs";
 import path13 from "path";
-import os8 from "os";
+import os7 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { unlinkSync as unlinkSync4 } from "fs";
 function spawnLockPath(sessionName) {
@@ -3571,7 +3622,7 @@ function isProcessAlive(pid) {
 }
 function acquireSpawnLock2(sessionName) {
   if (!existsSync12(SPAWN_LOCK_DIR)) {
-    mkdirSync5(SPAWN_LOCK_DIR, { recursive: true });
+    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
   if (existsSync12(lockFile)) {
@@ -3584,7 +3635,7 @@ function acquireSpawnLock2(sessionName) {
     } catch {
     }
   }
-  writeFileSync5(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync6(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
 function releaseSpawnLock2(sessionName) {
@@ -3669,11 +3720,11 @@ function extractRootExe(name) {
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
   if (!existsSync12(SESSION_CACHE)) {
-    mkdirSync5(SESSION_CACHE, { recursive: true });
+    mkdirSync6(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
   const filePath = path13.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync5(filePath, JSON.stringify({
+  writeFileSync6(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3752,31 +3803,49 @@ async function verifyPaneAtCapacity(sessionName) {
 function readDebounceState() {
   try {
     if (!existsSync12(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync10(DEBOUNCE_FILE, "utf8"));
+    const raw = JSON.parse(readFileSync10(DEBOUNCE_FILE, "utf8"));
+    const state = {};
+    for (const [key, val] of Object.entries(raw)) {
+      if (typeof val === "number") {
+        state[key] = { lastSent: val, pending: 0 };
+      } else if (val && typeof val === "object" && "lastSent" in val) {
+        state[key] = val;
+      }
+    }
+    return state;
   } catch {
     return {};
   }
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync12(SESSION_CACHE)) mkdirSync5(SESSION_CACHE, { recursive: true });
-    writeFileSync5(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync12(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
+    writeFileSync6(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
 function isDebounced(targetSession) {
   const state = readDebounceState();
-  const lastSent = state[targetSession] ?? 0;
-  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
+  const entry = state[targetSession];
+  const lastSent = entry?.lastSent ?? 0;
+  if (Date.now() - lastSent < INTERCOM_DEBOUNCE_MS) {
+    if (!state[targetSession]) state[targetSession] = { lastSent, pending: 0 };
+    state[targetSession].pending++;
+    writeDebounceState(state);
+    return true;
+  }
+  return false;
 }
 function recordDebounce(targetSession) {
   const state = readDebounceState();
-  state[targetSession] = Date.now();
+  const batched = state[targetSession]?.pending ?? 0;
+  state[targetSession] = { lastSent: Date.now(), pending: 0 };
   const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
   for (const key of Object.keys(state)) {
-    if ((state[key] ?? 0) < cutoff) delete state[key];
+    if ((state[key]?.lastSent ?? 0) < cutoff) delete state[key];
   }
   writeDebounceState(state);
+  return batched;
 }
 function logIntercom(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
@@ -3821,7 +3890,7 @@ function sendIntercom(targetSession) {
     return "skipped_exe";
   }
   if (isDebounced(targetSession)) {
-    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
+    logIntercom(`DEBOUNCE \u2192 ${targetSession} (nudge batched, task safe in DB)`);
     return "debounced";
   }
   try {
@@ -3833,14 +3902,14 @@ function sendIntercom(targetSession) {
     const sessionState = getSessionState(targetSession);
     if (sessionState === "no_claude") {
       queueIntercom(targetSession, "claude not running in session");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process \u2014 raw shell detected)`);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
       return "queued";
     }
     if (sessionState === "thinking" || sessionState === "tool") {
       queueIntercom(targetSession, "session busy at send time");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (session busy)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
       return "queued";
     }
     if (transport.isPaneInCopyMode(targetSession)) {
@@ -3848,8 +3917,8 @@ function sendIntercom(targetSession) {
       transport.sendKeys(targetSession, "q");
     }
     transport.sendKeys(targetSession, "/exe-intercom");
-    recordDebounce(targetSession);
-    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
+    const batched = recordDebounce(targetSession);
+    logIntercom(`DELIVERED \u2192 ${targetSession}${batched > 0 ? ` [${batched} nudges batched during debounce]` : ""} (fire-and-forget)`);
     return "delivered";
   } catch {
     logIntercom(`FAIL \u2192 ${targetSession}`);
@@ -3951,10 +4020,10 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const transport = getTransport();
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path13.join(os8.homedir(), ".exe-os", "session-logs");
+  const logDir = path13.join(os7.homedir(), ".exe-os", "session-logs");
   const logFile = path13.join(logDir, `${instanceLabel}-${Date.now()}.log`);
   if (!existsSync12(logDir)) {
-    mkdirSync5(logDir, { recursive: true });
+    mkdirSync6(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
@@ -3967,7 +4036,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   } catch {
   }
   try {
-    const claudeJsonPath = path13.join(os8.homedir(), ".claude.json");
+    const claudeJsonPath = path13.join(os7.homedir(), ".claude.json");
     let claudeJson = {};
     try {
       claudeJson = JSON.parse(readFileSync10(claudeJsonPath, "utf8"));
@@ -3978,11 +4047,11 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync5(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync6(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path13.join(os8.homedir(), ".claude", "projects");
+    const settingsDir = path13.join(os7.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
     const projSettingsDir = path13.join(settingsDir, normalizedKey);
     const settingsPath = path13.join(projSettingsDir, "settings.json");
@@ -4016,21 +4085,24 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync5(projSettingsDir, { recursive: true });
-      writeFileSync5(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync6(projSettingsDir, { recursive: true });
+      writeFileSync6(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
   }
   const spawnCwd = opts?.cwd ?? projectDir;
   const useExeAgent = !!(opts?.model && opts?.provider);
-  const ccProvider = useExeAgent ? DEFAULT_PROVIDER : detectActiveProvider();
+  const agentRtConfig = getAgentRuntime(employeeName);
+  const useCodex = !useExeAgent && agentRtConfig.runtime === "codex";
+  const useOpencode = !useExeAgent && !useCodex && agentRtConfig.runtime === "opencode";
+  const ccProvider = useExeAgent || useCodex || useOpencode ? DEFAULT_PROVIDER : detectActiveProvider();
   const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
   let identityFlag = "";
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
     const identityPath = path13.join(
-      os8.homedir(),
+      os7.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -4060,8 +4132,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path13.join(os8.homedir(), ".exe-os", "session-cache");
-    mkdirSync5(ctxDir, { recursive: true });
+    const ctxDir = path13.join(os7.homedir(), ".exe-os", "session-cache");
+    mkdirSync6(ctxDir, { recursive: true });
     const ctxFile = path13.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
@@ -4069,7 +4141,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `Your parent coordinator session is ${exeSession}.`,
       `Your employees (if any) use the -${exeSession} suffix.`
     ].join("\n");
-    writeFileSync5(ctxFile, ctxContent);
+    writeFileSync6(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -4083,9 +4155,48 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       }
     }
   }
+  if (useCodex) {
+    const codexCfg = RUNTIME_TABLE.codex;
+    if (codexCfg?.apiKeyEnv) {
+      const keyVal = process.env[codexCfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${codexCfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
+    envPrefix = `${envPrefix} EXE_AGENT_MODEL=${agentRtConfig.model}`;
+  }
+  if (useOpencode) {
+    const ocCfg = PROVIDER_TABLE.opencode;
+    if (ocCfg?.apiKeyEnv) {
+      const keyVal = process.env[ocCfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${ocCfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
+    envPrefix = `${envPrefix} ANTHROPIC_MODEL=${agentRtConfig.model}`;
+  }
+  if (!useExeAgent && !useCodex && !useOpencode && !useBinSymlink) {
+    const defaultClaudeModel = DEFAULT_MODELS.claude;
+    if (agentRtConfig.runtime === "claude" && agentRtConfig.model !== defaultClaudeModel) {
+      envPrefix = `${envPrefix} ANTHROPIC_MODEL=${agentRtConfig.model}`;
+    }
+  }
   let spawnCommand;
   if (useExeAgent) {
     spawnCommand = `${envPrefix} exe-agent --employee ${employeeName} --model ${opts.model} --provider ${opts.provider}${cleanupSuffix}`;
+  } else if (useCodex) {
+    process.stderr.write(
+      `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
+`
+    );
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+  } else if (useOpencode) {
+    const binName = `${employeeName}-opencode`;
+    process.stderr.write(
+      `[tmux-routing] agent-config: ${employeeName} \u2192 opencode (${agentRtConfig.model})
+`
+    );
+    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
   } else if (useBinSymlink) {
     const binName = `${employeeName}-${ccProvider}`;
     process.stderr.write(
@@ -4108,10 +4219,12 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   try {
     const mySession = getMySession();
     const dispatchInfo = path13.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync5(dispatchInfo, JSON.stringify({
+    writeFileSync6(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
-      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
+      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
+      runtime: useCodex ? "codex" : useOpencode ? "opencode" : useExeAgent ? "exe-agent" : "claude",
+      model: useCodex ? agentRtConfig.model : useOpencode ? agentRtConfig.model : void 0,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }));
   } catch {
@@ -4119,7 +4232,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let booted = false;
   for (let i = 0; i < 30; i++) {
     try {
-      execSync6("sleep 0.5");
+      execSync5("sleep 0.5");
     } catch {
     }
     try {
@@ -4129,6 +4242,11 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
           booted = true;
           break;
         }
+      } else if (useCodex) {
+        if (pane.includes("codex") || pane.includes("Codex") || pane.includes("exe-start-codex")) {
+          booted = true;
+          break;
+        }
       } else {
         if (pane.includes("Claude Code") || pane.includes("\u276F")) {
           booted = true;
@@ -4140,9 +4258,10 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   if (!booted) {
     releaseSpawnLock2(sessionName);
-    return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 15s` };
+    const runtimeLabel = useExeAgent ? "exe-agent" : useCodex ? "codex" : "claude";
+    return { sessionName, error: `${runtimeLabel} did not boot within 15s` };
   }
-  if (!useExeAgent) {
+  if (!useExeAgent && !useCodex) {
     try {
       transport.sendKeys(sessionName, `/exe-call ${employeeName}`);
     } catch {
@@ -4169,16 +4288,18 @@ var init_tmux_routing = __esm({
     init_cc_agent_support();
     init_mcp_prefix();
     init_provider_table();
+    init_agent_config();
+    init_runtime_table();
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path13.join(os8.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path13.join(os8.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path13.join(os7.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path13.join(os7.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path13.join(os8.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG2 = path13.join(os7.homedir(), ".exe-os", "intercom.log");
     DEBOUNCE_FILE = path13.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
@@ -4212,8 +4333,8 @@ var init_task_scope = __esm({
 // src/lib/tasks-crud.ts
 import crypto4 from "crypto";
 import path14 from "path";
-import os9 from "os";
-import { execSync as execSync7 } from "child_process";
+import os8 from "os";
+import { execSync as execSync6 } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
 import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
 async function writeCheckpoint(input2) {
@@ -4427,7 +4548,7 @@ ${laneWarning}` : laneWarning;
   });
   if (input2.baseDir) {
     try {
-      const EXE_OS_DIR = path14.join(os9.homedir(), ".exe-os");
+      const EXE_OS_DIR = path14.join(os8.homedir(), ".exe-os");
       const mdPath = path14.join(EXE_OS_DIR, taskFile);
       const mdDir = path14.dirname(mdPath);
       if (!existsSync13(mdDir)) await mkdir4(mdDir, { recursive: true });
@@ -4455,7 +4576,11 @@ If you skip this, your reviewer will not know you're done and your work won't be
 Do NOT let a failed commit or any error prevent you from calling update_task(done).
 `;
       await writeFile4(mdPath, mdContent, "utf-8");
-    } catch {
+    } catch (err) {
+      process.stderr.write(
+        `[create-task] WARNING: .md file write failed for ${taskFile}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
     }
   }
   return {
@@ -4530,14 +4655,14 @@ function isTmuxSessionAlive(identifier) {
   if (!identifier || identifier === "unknown") return true;
   try {
     if (identifier.startsWith("%")) {
-      const output = execSync7("tmux list-panes -a -F '#{pane_id}'", {
+      const output = execSync6("tmux list-panes -a -F '#{pane_id}'", {
         timeout: 2e3,
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       });
       return output.split("\n").some((l) => l.trim() === identifier);
     } else {
-      execSync7(`tmux has-session -t ${JSON.stringify(identifier)}`, {
+      execSync6(`tmux has-session -t ${JSON.stringify(identifier)}`, {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -4546,7 +4671,7 @@ function isTmuxSessionAlive(identifier) {
   } catch {
     if (identifier.startsWith("%")) return true;
     try {
-      execSync7("tmux list-sessions", {
+      execSync6("tmux list-sessions", {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -4561,12 +4686,12 @@ function checkStaleCompletion(taskContext, taskCreatedAt) {
   if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
   try {
     const since = new Date(taskCreatedAt).toISOString();
-    const branch = execSync7(
+    const branch = execSync6(
       "git rev-parse --abbrev-ref HEAD 2>/dev/null",
       { encoding: "utf8", timeout: 3e3 }
     ).trim();
     const branchArg = branch && branch !== "HEAD" ? branch : "";
-    const commitCount = execSync7(
+    const commitCount = execSync6(
       `git log --oneline --since="${since}" ${branchArg} 2>/dev/null | wc -l`,
       { encoding: "utf8", timeout: 5e3 }
     ).trim();
@@ -4785,7 +4910,7 @@ var init_tasks_crud = __esm({
 
 // src/lib/tasks-review.ts
 import path15 from "path";
-import { existsSync as existsSync14, readdirSync as readdirSync4, unlinkSync as unlinkSync5 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync3, unlinkSync as unlinkSync5 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
@@ -4968,7 +5093,7 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
   try {
     const cacheDir = path15.join(EXE_AI_DIR, "session-cache");
     if (existsSync14(cacheDir)) {
-      for (const f of readdirSync4(cacheDir)) {
+      for (const f of readdirSync3(cacheDir)) {
         if (f.startsWith("review-notified-")) {
           unlinkSync5(path15.join(cacheDir, f));
         }
@@ -5535,7 +5660,7 @@ __export(tasks_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import path17 from "path";
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, unlinkSync as unlinkSync6 } from "fs";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, unlinkSync as unlinkSync6 } from "fs";
 async function createTask(input2) {
   const result = await createTaskCore(input2);
   if (!input2.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -5557,8 +5682,8 @@ async function updateTask(input2) {
     const cacheDir = path17.join(EXE_AI_DIR, "session-cache");
     const cachePath = path17.join(cacheDir, `current-task-${agent}.json`);
     if (input2.status === "in_progress") {
-      mkdirSync6(cacheDir, { recursive: true });
-      writeFileSync6(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync7(cacheDir, { recursive: true });
+      writeFileSync7(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input2.status === "done" || input2.status === "blocked" || input2.status === "cancelled") {
       try {
         unlinkSync6(cachePath);
@@ -5725,15 +5850,15 @@ __export(worker_gate_exports, {
   tryAcquireBackfillLock: () => tryAcquireBackfillLock,
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
-import { readdirSync as readdirSync5, writeFileSync as writeFileSync7, unlinkSync as unlinkSync7, mkdirSync as mkdirSync7, existsSync as existsSync15 } from "fs";
+import { readdirSync as readdirSync4, writeFileSync as writeFileSync8, unlinkSync as unlinkSync7, mkdirSync as mkdirSync8, existsSync as existsSync15 } from "fs";
 import path18 from "path";
 function tryAcquireWorkerSlot() {
   try {
-    mkdirSync7(WORKER_PID_DIR, { recursive: true });
+    mkdirSync8(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
     const reservationPath = path18.join(WORKER_PID_DIR, `${reservationId}.pid`);
-    writeFileSync7(reservationPath, String(process.pid));
-    const files = readdirSync5(WORKER_PID_DIR);
+    writeFileSync8(reservationPath, String(process.pid));
+    const files = readdirSync4(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
       if (!f.endsWith(".pid")) continue;
@@ -5772,8 +5897,8 @@ function tryAcquireWorkerSlot() {
 }
 function registerWorkerPid(pid) {
   try {
-    mkdirSync7(WORKER_PID_DIR, { recursive: true });
-    writeFileSync7(path18.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    mkdirSync8(WORKER_PID_DIR, { recursive: true });
+    writeFileSync8(path18.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
@@ -5785,7 +5910,7 @@ function cleanupWorkerPid() {
 }
 function tryAcquireBackfillLock() {
   try {
-    mkdirSync7(WORKER_PID_DIR, { recursive: true });
+    mkdirSync8(WORKER_PID_DIR, { recursive: true });
     if (existsSync15(BACKFILL_LOCK)) {
       try {
         const pid = parseInt(
@@ -5802,7 +5927,7 @@ function tryAcquireBackfillLock() {
       } catch {
       }
     }
-    writeFileSync7(BACKFILL_LOCK, String(process.pid));
+    writeFileSync8(BACKFILL_LOCK, String(process.pid));
     return true;
   } catch {
     return true;
@@ -5827,8 +5952,8 @@ var init_worker_gate = __esm({
 
 // src/adapters/claude/hooks/ingest-worker.ts
 import crypto7 from "crypto";
-import { execSync as execSync8 } from "child_process";
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "fs";
+import { execSync as execSync7 } from "child_process";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import path19 from "path";
 
 // src/lib/error-detector.ts
@@ -5926,10 +6051,6 @@ function detectError(data) {
 }
 
 // src/lib/task-scanner.ts
-import { readdirSync, readFileSync, existsSync, statSync } from "fs";
-import { execSync } from "child_process";
-import path from "path";
-import os from "os";
 var STATUS_RE = /^\*\*Status:\*\*\s*(\w+)/m;
 var TITLE_RE = /^# (.+)/m;
 
@@ -5943,16 +6064,16 @@ import { createHash } from "crypto";
 
 // src/lib/keychain.ts
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import path6 from "path";
-import os4 from "os";
+import { existsSync as existsSync4 } from "fs";
+import path5 from "path";
+import os3 from "os";
 var SERVICE = "exe-mem";
 var ACCOUNT = "master-key";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path6.join(os4.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path5.join(os3.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path6.join(getKeyDir(), "master.key");
+  return path5.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -5973,9 +6094,9 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync5(keyPath)) {
+  if (!existsSync4(keyPath)) {
     process.stderr.write(
-      `[keychain] Key not found at ${keyPath} (HOME=${os4.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+      `[keychain] Key not found at ${keyPath} (HOME=${os3.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
     );
     return null;
@@ -6631,7 +6752,7 @@ process.stdin.on("end", async () => {
       try {
         const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
         const flagPath = path19.join(exeDir, "session-cache", "needs-backfill");
-        writeFileSync8(flagPath, "1");
+        writeFileSync9(flagPath, "1");
       } catch (err) {
         process.stderr.write(`[ingest-worker] backfill flag write failed: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -6659,9 +6780,9 @@ process.stdin.on("end", async () => {
           if (status === "done") {
             const cwd = data.cwd ?? process.cwd();
             try {
-              execSync8("git add -u", { cwd, timeout: 1e4, stdio: "ignore" });
+              execSync7("git add -u", { cwd, timeout: 1e4, stdio: "ignore" });
               const msg = `task(${agentId}): ${title}`;
-              execSync8(`git commit --no-verify -m ${JSON.stringify(msg)}`, { cwd, timeout: 3e4, stdio: "ignore" });
+              execSync7(`git commit --no-verify -m ${JSON.stringify(msg)}`, { cwd, timeout: 3e4, stdio: "ignore" });
             } catch (err) {
               process.stderr.write(`[ingest-worker] auto-commit failed: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -6742,8 +6863,8 @@ process.stdin.on("end", async () => {
           }
           const cwd = data.cwd ?? process.cwd();
           try {
-            mkdirSync8(path19.join(cwd, "exe/output"), { recursive: true });
-            mkdirSync8(path19.join(cwd, "exe/research"), { recursive: true });
+            mkdirSync9(path19.join(cwd, "exe/output"), { recursive: true });
+            mkdirSync9(path19.join(cwd, "exe/research"), { recursive: true });
             const { ensureGitignoreExe: ensureGitignoreExe2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
             await ensureGitignoreExe2(cwd);
           } catch (err) {