@askexenow/exe-os 0.8.0 → 0.8.2

package/dist/bin/exe-dispatch.js

@@ -1,1146 +0,0 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/lib/session-registry.ts
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import path from "path";
-import os from "os";
-function registerSession(entry) {
-  const dir = path.dirname(REGISTRY_PATH);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  const sessions = listSessions();
-  const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
-  if (idx >= 0) {
-    sessions[idx] = entry;
-  } else {
-    sessions.push(entry);
-  }
-  writeFileSync(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
-}
-function listSessions() {
-  try {
-    const raw = readFileSync(REGISTRY_PATH, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return [];
-  }
-}
-var REGISTRY_PATH;
-var init_session_registry = __esm({
-  "src/lib/session-registry.ts"() {
-    "use strict";
-    REGISTRY_PATH = path.join(os.homedir(), ".exe-os", "session-registry.json");
-  }
-});
-
-// src/lib/session-key.ts
-import { execSync } from "child_process";
-function getSessionKey() {
-  if (_cached) return _cached;
-  let pid = process.ppid;
-  for (let i = 0; i < 10; i++) {
-    try {
-      const info = execSync(`ps -p ${pid} -o ppid=,comm=`, {
-        encoding: "utf8",
-        timeout: 2e3
-      }).trim();
-      const match = info.match(/^\s*(\d+)\s+(.+)$/);
-      if (!match) break;
-      const [, ppid, cmd] = match;
-      if (cmd === "claude" || cmd.endsWith("/claude")) {
-        _cached = String(pid);
-        return _cached;
-      }
-      pid = parseInt(ppid, 10);
-      if (pid <= 1) break;
-    } catch {
-      break;
-    }
-  }
-  _cached = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
-  return _cached;
-}
-var _cached;
-var init_session_key = __esm({
-  "src/lib/session-key.ts"() {
-    "use strict";
-    _cached = null;
-  }
-});
-
-// src/lib/tmux-transport.ts
-var tmux_transport_exports = {};
-__export(tmux_transport_exports, {
-  TmuxTransport: () => TmuxTransport
-});
-import { execFileSync } from "child_process";
-var QUIET, TmuxTransport;
-var init_tmux_transport = __esm({
-  "src/lib/tmux-transport.ts"() {
-    "use strict";
-    QUIET = {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    };
-    TmuxTransport = class {
-      getMySession() {
-        try {
-          return execFileSync("tmux", ["display-message", "-p", "#{session_name}"], QUIET).trim() || null;
-        } catch {
-          return null;
-        }
-      }
-      listSessions() {
-        try {
-          return execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], QUIET).trim().split("\n").filter(Boolean);
-        } catch {
-          return [];
-        }
-      }
-      isAlive(target) {
-        try {
-          const sessions = this.listSessions();
-          if (!sessions.includes(target)) return false;
-          const paneStatus = execFileSync(
-            "tmux",
-            ["list-panes", "-t", target, "-F", "#{pane_dead}"],
-            QUIET
-          ).trim();
-          return paneStatus !== "1";
-        } catch {
-          return false;
-        }
-      }
-      sendKeys(target, keys) {
-        execFileSync("tmux", ["send-keys", "-t", target, keys, "Enter"], QUIET);
-      }
-      capturePane(target, lines) {
-        const args = ["capture-pane", "-t", target, "-p"];
-        if (lines) args.push("-S", `-${lines}`);
-        return execFileSync("tmux", args, { ...QUIET, timeout: 3e3 });
-      }
-      isPaneInCopyMode(target) {
-        try {
-          const result2 = execFileSync(
-            "tmux",
-            ["display-message", "-p", "-t", target, "#{pane_in_mode}"],
-            { ...QUIET, timeout: 3e3 }
-          ).trim();
-          return result2 === "1";
-        } catch {
-          return false;
-        }
-      }
-      spawn(name, config) {
-        try {
-          const args = ["new-session", "-d", "-s", name];
-          if (config.cwd) args.push("-c", config.cwd);
-          args.push(config.command);
-          execFileSync("tmux", args);
-          return { sessionName: name };
-        } catch (e) {
-          return { sessionName: name, error: `spawn failed: ${e}` };
-        }
-      }
-      kill(target) {
-        try {
-          execFileSync("tmux", ["kill-session", "-t", target], QUIET);
-        } catch {
-        }
-      }
-      pipeLog(target, logFile) {
-        try {
-          const safePath = logFile.replace(/'/g, "'\\''");
-          execFileSync("tmux", ["pipe-pane", "-t", target, `cat >> '${safePath}'`], QUIET);
-        } catch {
-        }
-      }
-    };
-  }
-});
-
-// src/lib/transport.ts
-function getTransport() {
-  if (!_transport) {
-    const { TmuxTransport: TmuxTransport2 } = (init_tmux_transport(), __toCommonJS(tmux_transport_exports));
-    _transport = new TmuxTransport2();
-  }
-  return _transport;
-}
-var _transport;
-var init_transport = __esm({
-  "src/lib/transport.ts"() {
-    "use strict";
-    _transport = null;
-  }
-});
-
-// src/lib/cc-agent-support.ts
-import { execSync as execSync2 } from "child_process";
-function _resetCcAgentSupportCache() {
-  _cachedSupport = null;
-}
-function claudeSupportsAgentFlag() {
-  if (_cachedSupport !== null) return _cachedSupport;
-  try {
-    const helpOutput = execSync2("claude --help 2>&1", {
-      encoding: "utf-8",
-      timeout: 5e3
-    });
-    _cachedSupport = /(^|\s)--agent(\b|=)/.test(helpOutput);
-  } catch {
-    _cachedSupport = false;
-  }
-  return _cachedSupport;
-}
-var _cachedSupport;
-var init_cc_agent_support = __esm({
-  "src/lib/cc-agent-support.ts"() {
-    "use strict";
-    _cachedSupport = null;
-  }
-});
-
-// src/lib/mcp-prefix.ts
-function expandDualPrefixTools(shortNames) {
-  const out = [];
-  for (const name of shortNames) {
-    for (const prefix of MCP_TOOL_PREFIXES) {
-      out.push(prefix + name);
-    }
-  }
-  return out;
-}
-var MCP_PRIMARY_KEY, MCP_LEGACY_KEY, MCP_TOOL_PREFIXES;
-var init_mcp_prefix = __esm({
-  "src/lib/mcp-prefix.ts"() {
-    "use strict";
-    MCP_PRIMARY_KEY = "exe-os";
-    MCP_LEGACY_KEY = "exe-mem";
-    MCP_TOOL_PREFIXES = [
-      `mcp__${MCP_PRIMARY_KEY}__`,
-      `mcp__${MCP_LEGACY_KEY}__`
-    ];
-  }
-});
-
-// src/lib/provider-table.ts
-function detectActiveProvider(env = process.env) {
-  const baseUrl = env.ANTHROPIC_BASE_URL;
-  if (!baseUrl) return DEFAULT_PROVIDER;
-  for (const [name, cfg] of Object.entries(PROVIDER_TABLE)) {
-    if (cfg.baseUrl === baseUrl) return name;
-  }
-  return DEFAULT_PROVIDER;
-}
-var PROVIDER_TABLE, DEFAULT_PROVIDER;
-var init_provider_table = __esm({
-  "src/lib/provider-table.ts"() {
-    "use strict";
-    PROVIDER_TABLE = {
-      opencode: {
-        baseUrl: "https://opencode.ai/zen/go",
-        apiKeyEnv: "OPENCODE_API_KEY",
-        defaultModel: "minimax-m2.7"
-      }
-    };
-    DEFAULT_PROVIDER = "default";
-  }
-});
-
-// src/lib/intercom-queue.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import path2 from "path";
-import os2 from "os";
-function ensureDir() {
-  const dir = path2.dirname(QUEUE_PATH);
-  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
-}
-function readQueue() {
-  try {
-    if (!existsSync2(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync2(QUEUE_PATH, "utf8"));
-  } catch {
-    return [];
-  }
-}
-function writeQueue(queue) {
-  ensureDir();
-  const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(queue, null, 2));
-  renameSync(tmp, QUEUE_PATH);
-}
-function queueIntercom(targetSession, reason) {
-  const queue = readQueue();
-  const existing = queue.find((q) => q.targetSession === targetSession);
-  if (existing) {
-    existing.attempts++;
-    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
-    existing.reason = reason;
-  } else {
-    queue.push({
-      targetSession,
-      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      attempts: 0,
-      reason
-    });
-  }
-  writeQueue(queue);
-}
-var QUEUE_PATH, INTERCOM_LOG;
-var init_intercom_queue = __esm({
-  "src/lib/intercom-queue.ts"() {
-    "use strict";
-    QUEUE_PATH = path2.join(os2.homedir(), ".exe-os", "intercom-queue.json");
-    INTERCOM_LOG = path2.join(os2.homedir(), ".exe-os", "intercom.log");
-  }
-});
-
-// src/lib/database.ts
-import { createClient } from "@libsql/client";
-var init_database = __esm({
-  "src/lib/database.ts"() {
-    "use strict";
-  }
-});
-
-// src/lib/config.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { readFileSync as readFileSync3, existsSync as existsSync3, renameSync as renameSync2 } from "fs";
-import path3 from "path";
-import os3 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(os3.homedir(), ".exe-os");
-  const legacyDir = path3.join(os3.homedir(), ".exe-mem");
-  if (!existsSync3(newDir) && existsSync3(legacyDir)) {
-    try {
-      renameSync2(legacyDir, newDir);
-      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
-`);
-    } catch {
-      return legacyDir;
-    }
-  }
-  return newDir;
-}
-var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG;
-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");
-    CURRENT_CONFIG_VERSION = 1;
-    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
-      }
-    };
-  }
-});
-
-// src/lib/employees.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync4, symlinkSync, readlinkSync } from "fs";
-import { execSync as execSync3 } from "child_process";
-import path4 from "path";
-var EMPLOYEES_PATH;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
-    "use strict";
-    init_config();
-    EMPLOYEES_PATH = path4.join(EXE_AI_DIR, "exe-employees.json");
-  }
-});
-
-// src/lib/license.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
-import { randomUUID } from "crypto";
-import path5 from "path";
-import { jwtVerify, importSPKI } from "jose";
-var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, PLAN_LIMITS;
-var init_license = __esm({
-  "src/lib/license.ts"() {
-    "use strict";
-    init_config();
-    LICENSE_PATH = path5.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path5.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path5.join(EXE_AI_DIR, "device-id");
-    PLAN_LIMITS = {
-      free: { devices: 1, employees: 1, memories: 5e3 },
-      pro: { devices: 2, employees: 5, memories: 1e5 },
-      team: { devices: 10, employees: 20, memories: 1e6 },
-      agency: { devices: 50, employees: 100, memories: 1e7 },
-      enterprise: { devices: -1, employees: -1, memories: -1 }
-    };
-  }
-});
-
-// src/lib/plan-limits.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
-import path6 from "path";
-function getLicenseSync() {
-  try {
-    if (!existsSync6(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync5(CACHE_PATH2, "utf8"));
-    if (!raw.token || typeof raw.token !== "string") return freeLicense();
-    const parts = raw.token.split(".");
-    if (parts.length !== 3) return freeLicense();
-    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
-    const plan = payload.plan ?? "free";
-    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
-    return {
-      valid: true,
-      plan,
-      email: payload.sub ?? "",
-      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
-      deviceLimit: limits.devices,
-      employeeLimit: limits.employees,
-      memoryLimit: limits.memories
-    };
-  } catch {
-    return freeLicense();
-  }
-}
-function freeLicense() {
-  const limits = PLAN_LIMITS.free;
-  return {
-    valid: true,
-    plan: "free",
-    email: "",
-    expiresAt: null,
-    deviceLimit: limits.devices,
-    employeeLimit: limits.employees,
-    memoryLimit: limits.memories
-  };
-}
-function assertEmployeeLimitSync(rosterPath) {
-  const license = getLicenseSync();
-  if (license.employeeLimit < 0) return;
-  const filePath = rosterPath ?? EMPLOYEES_PATH;
-  let count = 0;
-  try {
-    if (existsSync6(filePath)) {
-      const raw = readFileSync5(filePath, "utf8");
-      const employees = JSON.parse(raw);
-      count = Array.isArray(employees) ? employees.length : 0;
-    }
-  } catch {
-    throw new PlanLimitError(
-      `Cannot verify employee count: roster unreadable at ${filePath}. Refusing to proceed. Check file permissions or upgrade plan.`
-    );
-  }
-  if (count >= license.employeeLimit) {
-    throw new PlanLimitError(
-      `Employee limit reached: ${count}/${license.employeeLimit} employees on the ${license.plan} plan. Upgrade at https://askexe.com to add more.`
-    );
-  }
-}
-var PlanLimitError, CACHE_PATH2;
-var init_plan_limits = __esm({
-  "src/lib/plan-limits.ts"() {
-    "use strict";
-    init_database();
-    init_employees();
-    init_license();
-    init_config();
-    PlanLimitError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "PlanLimitError";
-      }
-    };
-    CACHE_PATH2 = path6.join(EXE_AI_DIR, "license-cache.json");
-  }
-});
-
-// src/lib/worktree.ts
-import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync6, appendFileSync, mkdirSync as mkdirSync4, realpathSync } from "fs";
-import path7 from "path";
-function getGitRoot(dir) {
-  try {
-    const root = execSync4("git rev-parse --show-toplevel", {
-      cwd: dir,
-      encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return realpath(root);
-  } catch {
-    return null;
-  }
-}
-function worktreePath(repoRoot, employeeName2, instance) {
-  const label = instanceLabel(employeeName2, instance);
-  return path7.join(repoRoot, ".worktrees", label);
-}
-function worktreeBranch(employeeName2, instance) {
-  return `${instanceLabel(employeeName2, instance)}-work`;
-}
-function instanceLabel(name, instance) {
-  return instance != null && instance > 0 ? `${name}${instance}` : name;
-}
-function ensureWorktree(projectDir2, employeeName2, instance) {
-  const repoRoot = getGitRoot(projectDir2);
-  if (!repoRoot) return null;
-  const wtPath = worktreePath(repoRoot, employeeName2, instance);
-  const branch = worktreeBranch(employeeName2, instance);
-  if (existsSync7(path7.join(wtPath, ".git"))) {
-    return wtPath;
-  }
-  const worktreesDir = path7.join(repoRoot, ".worktrees");
-  mkdirSync4(worktreesDir, { recursive: true });
-  ensureGitignoreEntry(repoRoot, "/.worktrees/");
-  try {
-    execSync4("git worktree prune", {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-  }
-  const branchExists = branchExistsLocally(repoRoot, branch);
-  try {
-    if (branchExists) {
-      execSync4(`git worktree add "${wtPath}" "${branch}"`, {
-        cwd: repoRoot,
-        encoding: "utf-8",
-        timeout: GIT_TIMEOUT_MS,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    } else {
-      execSync4(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
-        cwd: repoRoot,
-        encoding: "utf-8",
-        timeout: GIT_TIMEOUT_MS,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    }
-    return wtPath;
-  } catch (err) {
-    process.stderr.write(
-      `[worktree] Failed to create worktree for ${employeeName2}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return null;
-  }
-}
-function branchExistsLocally(repoRoot, branch) {
-  try {
-    execSync4(`git rev-parse --verify "refs/heads/${branch}"`, {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      timeout: GIT_TIMEOUT_MS,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function realpath(p) {
-  try {
-    return realpathSync(p);
-  } catch {
-    return p;
-  }
-}
-function ensureGitignoreEntry(repoRoot, entry) {
-  try {
-    const gitignorePath = path7.join(repoRoot, ".gitignore");
-    if (existsSync7(gitignorePath)) {
-      const content = readFileSync6(gitignorePath, "utf-8");
-      if (content.includes(entry)) return;
-      appendFileSync(gitignorePath, `
-# Agent worktrees (exe-os)
-${entry}
-`);
-    } else {
-    }
-  } catch {
-  }
-}
-var GIT_TIMEOUT_MS;
-var init_worktree = __esm({
-  "src/lib/worktree.ts"() {
-    "use strict";
-    GIT_TIMEOUT_MS = 1e4;
-  }
-});
-
-// src/lib/tmux-routing.ts
-import { execFileSync as execFileSync2, execSync as execSync5 } from "child_process";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync8, appendFileSync as appendFileSync2 } from "fs";
-import path8 from "path";
-import os4 from "os";
-import { fileURLToPath } from "url";
-function resolveBehaviorsExporterScript() {
-  try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const scriptPath = path8.join(
-      path8.dirname(thisFile),
-      "..",
-      "bin",
-      "exe-export-behaviors.js"
-    );
-    return existsSync8(scriptPath) ? scriptPath : null;
-  } catch {
-    return null;
-  }
-}
-function exportBehaviorsSync(agentId, projectName, sessionKey) {
-  const script = resolveBehaviorsExporterScript();
-  if (!script) return null;
-  try {
-    const output = execFileSync2(
-      process.execPath,
-      [script, agentId, projectName, sessionKey],
-      { encoding: "utf-8", timeout: BEHAVIORS_EXPORT_TIMEOUT_MS }
-    ).trim();
-    return output.length > 0 ? output : null;
-  } catch (err) {
-    process.stderr.write(
-      `[tmux-routing] behaviors export failed for ${agentId}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return null;
-  }
-}
-function getMySession() {
-  return getTransport().getMySession();
-}
-function employeeSessionName(employee, exeSession2, instance) {
-  const suffix = instance != null && instance > 0 ? String(instance) : "";
-  return `${employee}${suffix}-${exeSession2}`;
-}
-function extractRootExe(name) {
-  const match = name.match(/(exe\d+)$/);
-  return match?.[1] ?? null;
-}
-function getParentExe(sessionKey) {
-  try {
-    const data = JSON.parse(readFileSync7(path8.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
-    return data.parentExe || null;
-  } catch {
-    return null;
-  }
-}
-function resolveExeSession() {
-  const mySession = getMySession();
-  if (!mySession) return null;
-  try {
-    const key = getSessionKey();
-    const parentExe = getParentExe(key);
-    if (parentExe) {
-      return extractRootExe(parentExe) ?? parentExe;
-    }
-  } catch {
-  }
-  return extractRootExe(mySession) ?? mySession;
-}
-function isEmployeeAlive(sessionName) {
-  return getTransport().isAlive(sessionName);
-}
-function findFreeInstance(employeeName2, exeSession2, maxInstances = 10, isAlive = isEmployeeAlive) {
-  const base = employeeSessionName(employeeName2, exeSession2);
-  if (!isAlive(base)) return 0;
-  for (let i = 2; i <= maxInstances; i++) {
-    const candidate = employeeSessionName(employeeName2, exeSession2, i);
-    if (!isAlive(candidate)) return i;
-  }
-  return null;
-}
-function readDebounceState() {
-  try {
-    if (!existsSync8(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync7(DEBOUNCE_FILE, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function writeDebounceState(state) {
-  try {
-    if (!existsSync8(SESSION_CACHE)) mkdirSync5(SESSION_CACHE, { recursive: true });
-    writeFileSync4(DEBOUNCE_FILE, JSON.stringify(state));
-  } catch {
-  }
-}
-function isDebounced(targetSession) {
-  const state = readDebounceState();
-  const lastSent = state[targetSession] ?? 0;
-  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
-}
-function recordDebounce(targetSession) {
-  const state = readDebounceState();
-  state[targetSession] = Date.now();
-  const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
-  for (const key of Object.keys(state)) {
-    if ((state[key] ?? 0) < cutoff) delete state[key];
-  }
-  writeDebounceState(state);
-}
-function logIntercom(msg) {
-  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
-`;
-  process.stderr.write(`[intercom] ${msg}
-`);
-  try {
-    appendFileSync2(INTERCOM_LOG2, line);
-  } catch {
-  }
-}
-function getSessionState(sessionName) {
-  const transport = getTransport();
-  if (!transport.isAlive(sessionName)) return "offline";
-  try {
-    const pane = transport.capturePane(sessionName, 5);
-    if (/Running…/.test(pane)) return "tool";
-    if (BUSY_PATTERN.test(pane)) return "thinking";
-    return "idle";
-  } catch {
-    return "offline";
-  }
-}
-function isSessionBusy(sessionName) {
-  const state = getSessionState(sessionName);
-  return state === "thinking" || state === "tool";
-}
-function isExeSession(sessionName) {
-  return /^exe\d*$/.test(sessionName);
-}
-function sendIntercom(targetSession) {
-  const transport = getTransport();
-  if (isExeSession(targetSession)) {
-    logIntercom(`SKIP_EXE \u2192 ${targetSession} (exe sessions use prompt-submit hook)`);
-    return "skipped_exe";
-  }
-  if (isDebounced(targetSession)) {
-    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
-    return "debounced";
-  }
-  try {
-    const sessions = transport.listSessions();
-    if (!sessions.includes(targetSession)) {
-      logIntercom(`SKIP \u2192 ${targetSession} (session not found)`);
-      return "failed";
-    }
-    if (isSessionBusy(targetSession)) {
-      queueIntercom(targetSession, "session busy at send time");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
-      return "queued";
-    }
-    if (transport.isPaneInCopyMode(targetSession)) {
-      logIntercom(`COPY_MODE \u2192 ${targetSession} (exiting copy mode first)`);
-      transport.sendKeys(targetSession, "q");
-    }
-    transport.sendKeys(targetSession, "/exe-intercom");
-    recordDebounce(targetSession);
-    for (let i = 0; i < INTERCOM_POLL_MAX_ATTEMPTS; i++) {
-      try {
-        execSync5(`sleep ${INTERCOM_POLL_INTERVAL_S}`);
-      } catch {
-      }
-      const state = getSessionState(targetSession);
-      if (state === "thinking" || state === "tool") {
-        logIntercom(`ACKNOWLEDGED \u2192 ${targetSession} (state=${state}, poll=${i + 1})`);
-        return "acknowledged";
-      }
-    }
-    logIntercom(`DELIVERED \u2192 ${targetSession} (no state transition after ${INTERCOM_POLL_MAX_ATTEMPTS}s)`);
-    return "delivered";
-  } catch {
-    logIntercom(`FAIL \u2192 ${targetSession}`);
-    return "failed";
-  }
-}
-function ensureEmployee(employeeName2, exeSession2, projectDir2, opts) {
-  if (employeeName2 === "exe") {
-    return { status: "failed", sessionName: "", error: "exe is the COO, not a dispatchable employee" };
-  }
-  try {
-    assertEmployeeLimitSync();
-  } catch (err) {
-    if (err instanceof PlanLimitError) {
-      return { status: "failed", sessionName: "", error: err.message };
-    }
-  }
-  if (/-exe\d*$/.test(employeeName2)) {
-    const bare = employeeName2.replace(/-exe\d*$/, "").replace(/\d+$/, "");
-    return {
-      status: "failed",
-      sessionName: "",
-      error: `Error: pass employee name ('${bare}'), not session name ('${employeeName2}')`
-    };
-  }
-  let effectiveInstance = opts?.instance;
-  if (effectiveInstance === void 0 && opts?.autoInstance) {
-    const free = findFreeInstance(
-      employeeName2,
-      exeSession2,
-      opts.maxAutoInstances ?? 10
-    );
-    if (free === null) {
-      return {
-        status: "failed",
-        sessionName: employeeSessionName(employeeName2, exeSession2),
-        error: `All ${opts.maxAutoInstances ?? 10} instances of ${employeeName2} are alive \u2014 cap reached`
-      };
-    }
-    effectiveInstance = free === 0 ? void 0 : free;
-  }
-  const sessionName = employeeSessionName(employeeName2, exeSession2, effectiveInstance);
-  if (isEmployeeAlive(sessionName)) {
-    const result3 = sendIntercom(sessionName);
-    if (result3 === "acknowledged" || result3 === "skipped_exe" || result3 === "debounced" || result3 === "queued") {
-      return { status: "intercom_sent", sessionName };
-    }
-    if (result3 === "delivered") {
-      return { status: "intercom_unprocessed", sessionName };
-    }
-    return { status: "failed", sessionName, error: "intercom delivery failed" };
-  }
-  const spawnOpts = { ...opts, instance: effectiveInstance };
-  const wtPath = ensureWorktree(projectDir2, employeeName2, effectiveInstance);
-  if (wtPath) {
-    spawnOpts.cwd = wtPath;
-  }
-  const result2 = spawnEmployee(employeeName2, exeSession2, projectDir2, spawnOpts);
-  if (result2.error) {
-    return { status: "failed", sessionName, error: result2.error };
-  }
-  return { status: "spawned", sessionName };
-}
-function spawnEmployee(employeeName2, exeSession2, projectDir2, opts) {
-  const transport = getTransport();
-  const sessionName = employeeSessionName(employeeName2, exeSession2, opts?.instance);
-  const instanceLabel2 = opts?.instance != null && opts.instance > 0 ? `${employeeName2}${opts.instance}` : employeeName2;
-  const logDir = path8.join(os4.homedir(), ".exe-os", "session-logs");
-  const logFile = path8.join(logDir, `${instanceLabel2}-${Date.now()}.log`);
-  if (!existsSync8(logDir)) {
-    mkdirSync5(logDir, { recursive: true });
-  }
-  transport.kill(sessionName);
-  let cleanupSuffix = "";
-  try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const cleanupScript = path8.join(path8.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync8(cleanupScript)) {
-      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName2}" "${exeSession2}"`;
-    }
-  } catch {
-  }
-  try {
-    const claudeJsonPath = path8.join(os4.homedir(), ".claude.json");
-    let claudeJson = {};
-    try {
-      claudeJson = JSON.parse(readFileSync7(claudeJsonPath, "utf8"));
-    } catch {
-    }
-    if (!claudeJson.projects) claudeJson.projects = {};
-    const projects = claudeJson.projects;
-    const trustDir = opts?.cwd ?? projectDir2;
-    if (!projects[trustDir]) projects[trustDir] = {};
-    projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync4(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
-  } catch {
-  }
-  try {
-    const settingsDir = path8.join(os4.homedir(), ".claude", "projects");
-    const normalizedKey = (opts?.cwd ?? projectDir2).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path8.join(settingsDir, normalizedKey);
-    const settingsPath = path8.join(projSettingsDir, "settings.json");
-    let settings = {};
-    try {
-      settings = JSON.parse(readFileSync7(settingsPath, "utf8"));
-    } catch {
-    }
-    const perms = settings.permissions ?? {};
-    const allow = perms.allow ?? [];
-    const toolNames = [
-      "recall_my_memory",
-      "store_memory",
-      "create_task",
-      "update_task",
-      "list_tasks",
-      "get_task",
-      "ask_team_memory",
-      "store_behavior",
-      "get_identity",
-      "send_message"
-    ];
-    const requiredTools = expandDualPrefixTools(toolNames);
-    let changed = false;
-    for (const tool of requiredTools) {
-      if (!allow.includes(tool)) {
-        allow.push(tool);
-        changed = true;
-      }
-    }
-    if (changed) {
-      perms.allow = allow;
-      settings.permissions = perms;
-      mkdirSync5(projSettingsDir, { recursive: true });
-      writeFileSync4(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-    }
-  } catch {
-  }
-  const spawnCwd = opts?.cwd ?? projectDir2;
-  const useExeAgent = !!(opts?.model && opts?.provider);
-  const ccProvider = useExeAgent ? DEFAULT_PROVIDER : detectActiveProvider();
-  const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
-  let identityFlag = "";
-  let behaviorsFlag = "";
-  let legacyFallbackWarned = false;
-  if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path8.join(
-      os4.homedir(),
-      ".exe-os",
-      "identity",
-      `${employeeName2}.md`
-    );
-    _resetCcAgentSupportCache();
-    const hasAgentFlag = claudeSupportsAgentFlag();
-    if (hasAgentFlag) {
-      identityFlag = ` --agent ${employeeName2}`;
-    } else if (existsSync8(identityPath)) {
-      identityFlag = ` --append-system-prompt-file ${identityPath}`;
-      legacyFallbackWarned = true;
-    }
-    const behaviorsFile = exportBehaviorsSync(
-      employeeName2,
-      path8.basename(spawnCwd),
-      sessionName
-    );
-    if (behaviorsFile) {
-      behaviorsFlag = ` --append-system-prompt-file ${behaviorsFile}`;
-    }
-  }
-  if (legacyFallbackWarned) {
-    process.stderr.write(
-      `[tmux-routing] claude --agent not supported by installed CC. Falling back to --append-system-prompt-file for ${employeeName2}. Upgrade Claude Code to enable native --agent launch.
-`
-    );
-  }
-  let sessionContextFlag = "";
-  try {
-    const ctxDir = path8.join(os4.homedir(), ".exe-os", "session-cache");
-    mkdirSync5(ctxDir, { recursive: true });
-    const ctxFile = path8.join(ctxDir, `session-context-${sessionName}.md`);
-    const ctxContent = [
-      `## Session Context`,
-      `You are running in tmux session: ${sessionName}.`,
-      `Your parent exe session is ${exeSession2}.`,
-      `Your employees (if any) use the -${exeSession2} suffix (e.g., tom-${exeSession2}).`
-    ].join("\n");
-    writeFileSync4(ctxFile, ctxContent);
-    sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
-  } catch {
-  }
-  let envPrefix = `EXE_SESSION=${exeSession2} EXE_SESSION_NAME=${sessionName}`;
-  if (ccProvider !== DEFAULT_PROVIDER) {
-    const cfg = PROVIDER_TABLE[ccProvider];
-    if (cfg?.apiKeyEnv) {
-      const keyVal = process.env[cfg.apiKeyEnv];
-      if (keyVal) {
-        envPrefix = `${envPrefix} ${cfg.apiKeyEnv}=${keyVal}`;
-      }
-    }
-  }
-  let spawnCommand;
-  if (useExeAgent) {
-    spawnCommand = `${envPrefix} exe-agent --employee ${employeeName2} --model ${opts.model} --provider ${opts.provider}${cleanupSuffix}`;
-  } else if (useBinSymlink) {
-    const binName = `${employeeName2}-${ccProvider}`;
-    process.stderr.write(
-      `[tmux-routing] provider cascade: ${ccProvider} \u2192 spawning ${binName}
-`
-    );
-    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
-  } else {
-    spawnCommand = `${envPrefix} claude --dangerously-skip-permissions${identityFlag}${behaviorsFlag}${sessionContextFlag}${cleanupSuffix}`;
-  }
-  const spawnResult = transport.spawn(sessionName, {
-    cwd: spawnCwd,
-    command: spawnCommand
-  });
-  if (spawnResult.error) {
-    return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
-  }
-  transport.pipeLog(sessionName, logFile);
-  try {
-    const mySession = getMySession();
-    const dispatchInfo = path8.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync4(dispatchInfo, JSON.stringify({
-      dispatchedBy: mySession,
-      rootExe: exeSession2,
-      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    }));
-  } catch {
-  }
-  let booted = false;
-  for (let i = 0; i < 30; i++) {
-    try {
-      execSync5("sleep 1");
-    } catch {
-    }
-    try {
-      const pane = transport.capturePane(sessionName);
-      if (useExeAgent) {
-        if (pane.includes("[exe-agent]") || pane.includes("online")) {
-          booted = true;
-          break;
-        }
-      } else {
-        if (pane.includes("Claude Code") || pane.includes("\u276F")) {
-          booted = true;
-          break;
-        }
-      }
-    } catch {
-    }
-  }
-  if (!booted) {
-    return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 30s` };
-  }
-  if (!useExeAgent) {
-    try {
-      transport.sendKeys(sessionName, `/exe-call ${employeeName2}`);
-    } catch {
-    }
-  }
-  registerSession({
-    windowName: sessionName,
-    agentId: employeeName2,
-    projectDir: spawnCwd,
-    parentExe: exeSession2,
-    pid: 0,
-    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  return { sessionName };
-}
-var SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN, INTERCOM_POLL_INTERVAL_S, INTERCOM_POLL_MAX_ATTEMPTS;
-var init_tmux_routing = __esm({
-  "src/lib/tmux-routing.ts"() {
-    "use strict";
-    init_session_registry();
-    init_session_key();
-    init_transport();
-    init_cc_agent_support();
-    init_mcp_prefix();
-    init_provider_table();
-    init_intercom_queue();
-    init_plan_limits();
-    init_worktree();
-    SESSION_CACHE = path8.join(os4.homedir(), ".exe-os", "session-cache");
-    BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
-    INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path8.join(os4.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path8.join(SESSION_CACHE, "intercom-debounce.json");
-    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
-    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
-    INTERCOM_POLL_INTERVAL_S = 1;
-    INTERCOM_POLL_MAX_ATTEMPTS = 8;
-  }
-});
-
-// src/bin/exe-dispatch.ts
-init_tmux_routing();
-var employeeName = process.argv[2];
-if (!employeeName) {
-  console.error("Usage: exe-dispatch <employeeName> [projectDir]");
-  process.exit(1);
-}
-var projectDir = process.argv[3] || process.cwd();
-var exeSession = resolveExeSession();
-if (!exeSession) {
-  console.log(JSON.stringify({
-    status: "failed",
-    sessionName: "",
-    error: "Not in tmux \u2014 cannot resolve exe session"
-  }));
-  process.exit(1);
-}
-var result = ensureEmployee(employeeName, exeSession, projectDir);
-console.log(JSON.stringify(result));