@askexenow/exe-os 0.8.1 → 0.8.3

package/dist/mcp/tools/create-task.js

@@ -1,1903 +0,0 @@
-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/database.ts
-import { createClient } from "@libsql/client";
-function getClient() {
-  if (!_client) {
-    throw new Error("Database client not initialized. Call initDatabase() first.");
-  }
-  return _client;
-}
-var _client;
-var init_database = __esm({
-  "src/lib/database.ts"() {
-    "use strict";
-    _client = null;
-  }
-});
-
-// src/lib/config.ts
-var config_exports = {};
-__export(config_exports, {
-  CONFIG_MIGRATIONS: () => CONFIG_MIGRATIONS,
-  CONFIG_PATH: () => CONFIG_PATH,
-  CURRENT_CONFIG_VERSION: () => CURRENT_CONFIG_VERSION,
-  DB_PATH: () => DB_PATH,
-  EXE_AI_DIR: () => EXE_AI_DIR,
-  LEGACY_LANCE_PATH: () => LEGACY_LANCE_PATH,
-  MODELS_DIR: () => MODELS_DIR,
-  loadConfig: () => loadConfig,
-  loadConfigFrom: () => loadConfigFrom,
-  loadConfigSync: () => loadConfigSync,
-  migrateConfig: () => migrateConfig,
-  saveConfig: () => saveConfig
-});
-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;
-}
-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;
-}
-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 normalizeAutoUpdate(raw) {
-  const defaultAU = DEFAULT_CONFIG.autoUpdate;
-  const userAU = raw.autoUpdate ?? {};
-  raw.autoUpdate = { ...defaultAU, ...userAU };
-}
-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 = path.join(dir, "config.json");
-  if (!existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
-  }
-  const raw = await readFile(configPath, "utf-8");
-  try {
-    let parsed = JSON.parse(raw);
-    parsed = migrateLegacyConfig(parsed);
-    const { config: migratedCfg, migrated, fromVersion } = migrateConfig(parsed);
-    if (migrated) {
-      process.stderr.write(`[exe-os] Config migrated from v${fromVersion} to v${migratedCfg.config_version}
-`);
-      try {
-        await writeFile(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
-      } catch {
-      }
-    }
-    normalizeScalingRoadmap(migratedCfg);
-    normalizeSessionLifecycle(migratedCfg);
-    normalizeAutoUpdate(migratedCfg);
-    const config = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
-    if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os.homedir());
-    }
-    return config;
-  } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
-  }
-}
-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);
-    normalizeAutoUpdate(migratedCfg);
-    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
-  } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path.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 = path.join(dir, "config.json");
-  await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
-}
-async function loadConfigFrom(configPath) {
-  const raw = await readFile(configPath, "utf-8");
-  try {
-    let parsed = JSON.parse(raw);
-    parsed = migrateLegacyConfig(parsed);
-    const { config: migratedCfg } = migrateConfig(parsed);
-    normalizeScalingRoadmap(migratedCfg);
-    normalizeSessionLifecycle(migratedCfg);
-    normalizeAutoUpdate(migratedCfg);
-    return { ...DEFAULT_CONFIG, ...migratedCfg };
-  } catch {
-    return { ...DEFAULT_CONFIG };
-  }
-}
-var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
-var init_config = __esm({
-  "src/lib/config.ts"() {
-    "use strict";
-    EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path.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
-      },
-      autoUpdate: {
-        checkOnBoot: true,
-        autoInstall: false,
-        checkIntervalMs: 24 * 60 * 60 * 1e3
-      }
-    };
-    CONFIG_MIGRATIONS = [
-      {
-        from: 0,
-        to: 1,
-        migrate: (cfg) => {
-          cfg.config_version = 1;
-          return cfg;
-        }
-      }
-    ];
-  }
-});
-
-// src/lib/notifications.ts
-import crypto from "crypto";
-import path2 from "path";
-import os2 from "os";
-import {
-  readFileSync as readFileSync2,
-  readdirSync,
-  unlinkSync,
-  existsSync as existsSync2,
-  rmdirSync
-} from "fs";
-var init_notifications = __esm({
-  "src/lib/notifications.ts"() {
-    "use strict";
-    init_database();
-  }
-});
-
-// src/lib/tasks-crud.ts
-import crypto2 from "crypto";
-import path3 from "path";
-import { execSync } from "child_process";
-import { mkdir as mkdir2, writeFile as writeFile2, appendFile } from "fs/promises";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-function extractParentFromContext(contextBody) {
-  if (!contextBody) return null;
-  const match = contextBody.match(
-    /Parent task:\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i
-  );
-  return match ? match[1].toLowerCase() : null;
-}
-function slugify(title) {
-  return title.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-async function resolveTask(client, identifier) {
-  let result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE id = ?",
-    args: [identifier]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE task_file LIKE ?",
-    args: [`%${identifier}%`]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const exact = result.rows.filter(
-      (r) => String(r.task_file).endsWith(`/${identifier}.md`)
-    );
-    if (exact.length === 1) return exact[0];
-    const candidates = exact.length > 1 ? exact : result.rows;
-    const active = candidates.filter(
-      (r) => !["done", "cancelled"].includes(String(r.status))
-    );
-    if (active.length === 1) return active[0];
-    const matches = (active.length > 1 ? active : candidates).map((r) => `${String(r.task_file)} (${String(r.status)}, ${String(r.id)})`).join(", ");
-    throw new Error(
-      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
-    );
-  }
-  result = await client.execute({
-    sql: "SELECT * FROM tasks WHERE title LIKE ?",
-    args: [`%${identifier}%`]
-  });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const active = result.rows.filter(
-      (r) => !["done", "cancelled"].includes(String(r.status))
-    );
-    if (active.length === 1) return active[0];
-    const matches = (active.length > 1 ? active : result.rows).map((r) => `"${String(r.title)}" (${String(r.status)}, ${String(r.id)})`).join(", ");
-    throw new Error(
-      `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
-    );
-  }
-  throw new Error(`Task not found: ${identifier}`);
-}
-async function createTaskCore(input) {
-  const client = getClient();
-  const id = crypto2.randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const slug = slugify(input.title);
-  const taskFile = input.taskFile ?? `exe/${input.assignedTo}/${slug}.md`;
-  let blockedById = null;
-  const initialStatus = input.blockedBy ? "blocked" : "open";
-  if (input.blockedBy) {
-    const blocker = await resolveTask(client, input.blockedBy);
-    blockedById = String(blocker.id);
-  }
-  let parentTaskId = null;
-  let parentRef = input.parentTaskId;
-  if (!parentRef) {
-    const extracted = extractParentFromContext(input.context);
-    if (extracted) {
-      parentRef = extracted;
-      process.stderr.write(
-        "[create_task] auto-populated parent_task_id from context body \u2014 dispatchers should pass parent_task_id explicitly\n"
-      );
-    }
-  }
-  if (parentRef) {
-    try {
-      const parent = await resolveTask(client, parentRef);
-      parentTaskId = String(parent.id);
-    } catch (err) {
-      if (!input.parentTaskId) {
-        throw new Error(
-          `create_task: parent reference "${parentRef}" in context body does not resolve to an existing task`
-        );
-      }
-      throw err;
-    }
-  }
-  let warning;
-  const dupCheck = await client.execute({
-    sql: "SELECT id FROM tasks WHERE title = ? AND assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')",
-    args: [input.title, input.assignedTo]
-  });
-  if (dupCheck.rows.length > 0) {
-    warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
-  }
-  if (input.baseDir) {
-    try {
-      await mkdir2(path3.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir2(path3.join(input.baseDir, "exe", "research"), { recursive: true });
-      await ensureArchitectureDoc(input.baseDir, input.projectName);
-      await ensureGitignoreExe(input.baseDir);
-    } catch {
-    }
-  }
-  const complexity = input.complexity ?? "standard";
-  await client.execute({
-    sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    args: [
-      id,
-      input.title,
-      input.assignedTo,
-      input.assignedBy,
-      input.projectName,
-      input.priority,
-      initialStatus,
-      taskFile,
-      blockedById,
-      parentTaskId,
-      input.reviewer ?? null,
-      input.context,
-      input.budgetTokens ?? null,
-      input.budgetFallbackModel ?? null,
-      0,
-      null,
-      complexity,
-      now,
-      now
-    ]
-  });
-  return {
-    id,
-    title: input.title,
-    assignedTo: input.assignedTo,
-    assignedBy: input.assignedBy,
-    projectName: input.projectName,
-    priority: input.priority,
-    status: initialStatus,
-    taskFile,
-    createdAt: now,
-    updatedAt: now,
-    warning,
-    budgetTokens: input.budgetTokens ?? null,
-    budgetFallbackModel: input.budgetFallbackModel ?? null,
-    tokensUsed: 0,
-    tokensWarnedAt: null
-  };
-}
-async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path3.join(baseDir, "exe", "ARCHITECTURE.md");
-  try {
-    if (existsSync3(archPath)) return;
-    const template = [
-      `# ${projectName} \u2014 System Architecture`,
-      "",
-      "> Employees: read this before every task. Update it when you change system structure.",
-      `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
-      "",
-      "## Overview",
-      "",
-      "<!-- Describe what this system does, its main components, and how they connect. -->",
-      "",
-      "## Key Components",
-      "",
-      "<!-- List the major modules, services, or subsystems. -->",
-      "",
-      "## Data Flow",
-      "",
-      "<!-- How does data move through the system? What writes where? -->",
-      "",
-      "## Invariants",
-      "",
-      "<!-- Rules that must never be violated. What breaks if these are wrong? -->",
-      "",
-      "## Dependencies",
-      "",
-      "<!-- What depends on what? If I change X, what else is affected? -->",
-      ""
-    ].join("\n");
-    await writeFile2(archPath, template, "utf-8");
-  } catch {
-  }
-}
-async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path3.join(baseDir, ".gitignore");
-  try {
-    if (existsSync3(gitignorePath)) {
-      const content = readFileSync3(gitignorePath, "utf-8");
-      if (/^\/?exe\/?$/m.test(content)) return;
-      await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
-    } else {
-      await writeFile2(gitignorePath, "# Employee task assignments (private)\n/exe/\n", "utf-8");
-    }
-  } catch {
-  }
-}
-var init_tasks_crud = __esm({
-  "src/lib/tasks-crud.ts"() {
-    "use strict";
-    init_database();
-  }
-});
-
-// src/lib/employees.ts
-import { readFile as readFile2, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync4, symlinkSync, readlinkSync } from "fs";
-import { execSync as execSync2 } 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/session-registry.ts
-import { readFileSync as readFileSync4, writeFileSync, mkdirSync, existsSync as existsSync5 } from "fs";
-import path5 from "path";
-import os3 from "os";
-function registerSession(entry) {
-  const dir = path5.dirname(REGISTRY_PATH);
-  if (!existsSync5(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 = readFileSync4(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 = path5.join(os3.homedir(), ".exe-os", "session-registry.json");
-  }
-});
-
-// src/lib/session-key.ts
-import { execSync as execSync3 } from "child_process";
-function getSessionKey() {
-  if (_cached) return _cached;
-  let pid = process.ppid;
-  for (let i = 0; i < 10; i++) {
-    try {
-      const info = execSync3(`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 result = execFileSync(
-            "tmux",
-            ["display-message", "-p", "-t", target, "#{pane_in_mode}"],
-            { ...QUIET, timeout: 3e3 }
-          ).trim();
-          return result === "1";
-        } catch {
-          return false;
-        }
-      }
-      spawn(name, config) {
-        try {
-          const args = ["new-session", "-d", "-s", name];
-          if (config.cwd) args.push("-c", config.cwd);
-          args.push(config.command);
-          execFileSync("tmux", args);
-          return { sessionName: name };
-        } catch (e) {
-          return { sessionName: name, error: `spawn failed: ${e}` };
-        }
-      }
-      kill(target) {
-        try {
-          execFileSync("tmux", ["kill-session", "-t", target], QUIET);
-        } catch {
-        }
-      }
-      pipeLog(target, logFile) {
-        try {
-          const safePath = logFile.replace(/'/g, "'\\''");
-          execFileSync("tmux", ["pipe-pane", "-t", target, `cat >> '${safePath}'`], QUIET);
-        } catch {
-        }
-      }
-    };
-  }
-});
-
-// src/lib/transport.ts
-function getTransport() {
-  if (!_transport) {
-    const { TmuxTransport: TmuxTransport2 } = (init_tmux_transport(), __toCommonJS(tmux_transport_exports));
-    _transport = new TmuxTransport2();
-  }
-  return _transport;
-}
-var _transport;
-var init_transport = __esm({
-  "src/lib/transport.ts"() {
-    "use strict";
-    _transport = null;
-  }
-});
-
-// src/lib/cc-agent-support.ts
-import { execSync as execSync4 } from "child_process";
-function _resetCcAgentSupportCache() {
-  _cachedSupport = null;
-}
-function claudeSupportsAgentFlag() {
-  if (_cachedSupport !== null) return _cachedSupport;
-  try {
-    const helpOutput = execSync4("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 readFileSync5, writeFileSync as writeFileSync2, renameSync as renameSync2, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
-import path6 from "path";
-import os4 from "os";
-function ensureDir() {
-  const dir = path6.dirname(QUEUE_PATH);
-  if (!existsSync6(dir)) mkdirSync2(dir, { recursive: true });
-}
-function readQueue() {
-  try {
-    if (!existsSync6(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync5(QUEUE_PATH, "utf8"));
-  } catch {
-    return [];
-  }
-}
-function writeQueue(queue) {
-  ensureDir();
-  const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(queue, null, 2));
-  renameSync2(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, TTL_MS, INTERCOM_LOG;
-var init_intercom_queue = __esm({
-  "src/lib/intercom-queue.ts"() {
-    "use strict";
-    QUEUE_PATH = path6.join(os4.homedir(), ".exe-os", "intercom-queue.json");
-    TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path6.join(os4.homedir(), ".exe-os", "intercom.log");
-  }
-});
-
-// src/lib/license.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
-import { randomUUID } from "crypto";
-import path7 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 = path7.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path7.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path7.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 readFileSync7, existsSync as existsSync8 } from "fs";
-import path8 from "path";
-function getLicenseSync() {
-  try {
-    if (!existsSync8(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync7(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 (existsSync8(filePath)) {
-      const raw = readFileSync7(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 = path8.join(EXE_AI_DIR, "license-cache.json");
-  }
-});
-
-// src/lib/worktree.ts
-import { execSync as execSync5 } from "child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync8, appendFileSync, mkdirSync as mkdirSync4, realpathSync } from "fs";
-import path9 from "path";
-function getGitRoot(dir) {
-  try {
-    const root = execSync5("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 getMainRepoRoot(dir) {
-  try {
-    const commonDir = execSync5(
-      "git rev-parse --path-format=absolute --git-common-dir",
-      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-    return realpath(path9.dirname(commonDir));
-  } catch {
-    return null;
-  }
-}
-function worktreePath(repoRoot, employeeName, instance) {
-  const label = instanceLabel(employeeName, instance);
-  return path9.join(repoRoot, ".worktrees", label);
-}
-function worktreeBranch(employeeName, instance) {
-  return `${instanceLabel(employeeName, instance)}-work`;
-}
-function instanceLabel(name, instance) {
-  return instance != null && instance > 0 ? `${name}${instance}` : name;
-}
-function ensureWorktree(projectDir, employeeName, instance) {
-  const repoRoot = getGitRoot(projectDir);
-  if (!repoRoot) return null;
-  const wtPath = worktreePath(repoRoot, employeeName, instance);
-  const branch = worktreeBranch(employeeName, instance);
-  if (existsSync9(path9.join(wtPath, ".git"))) {
-    return wtPath;
-  }
-  const worktreesDir = path9.join(repoRoot, ".worktrees");
-  mkdirSync4(worktreesDir, { recursive: true });
-  ensureGitignoreEntry(repoRoot, "/.worktrees/");
-  try {
-    execSync5("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) {
-      execSync5(`git worktree add "${wtPath}" "${branch}"`, {
-        cwd: repoRoot,
-        encoding: "utf-8",
-        timeout: GIT_TIMEOUT_MS,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    } else {
-      execSync5(`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 ${employeeName}: ${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return null;
-  }
-}
-function branchExistsLocally(repoRoot, branch) {
-  try {
-    execSync5(`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 = path9.join(repoRoot, ".gitignore");
-    if (existsSync9(gitignorePath)) {
-      const content = readFileSync8(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 execSync6 } from "child_process";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync10, appendFileSync as appendFileSync2 } from "fs";
-import path10 from "path";
-import os5 from "os";
-import { fileURLToPath } from "url";
-function resolveBehaviorsExporterScript() {
-  try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const scriptPath = path10.join(
-      path10.dirname(thisFile),
-      "..",
-      "bin",
-      "exe-export-behaviors.js"
-    );
-    return existsSync10(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, exeSession, instance) {
-  const suffix = instance != null && instance > 0 ? String(instance) : "";
-  return `${employee}${suffix}-${exeSession}`;
-}
-function extractRootExe(name) {
-  const match = name.match(/(exe\d+)$/);
-  return match?.[1] ?? null;
-}
-function getParentExe(sessionKey) {
-  try {
-    const data = JSON.parse(readFileSync9(path10.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(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
-  const base = employeeSessionName(employeeName, exeSession);
-  if (!isAlive(base)) return 0;
-  for (let i = 2; i <= maxInstances; i++) {
-    const candidate = employeeSessionName(employeeName, exeSession, i);
-    if (!isAlive(candidate)) return i;
-  }
-  return null;
-}
-function readDebounceState() {
-  try {
-    if (!existsSync10(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync9(DEBOUNCE_FILE, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function writeDebounceState(state) {
-  try {
-    if (!existsSync10(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 (!pane.includes("\u276F") && !pane.includes("Claude Code") && !BUSY_PATTERN.test(pane) && !/Running…/.test(pane)) {
-      if (/\$\s*$/.test(pane) || /% $/.test(pane.trimEnd())) {
-        return "no_claude";
-      }
-    }
-    if (/Running…/.test(pane)) return "tool";
-    if (BUSY_PATTERN.test(pane)) return "thinking";
-    return "idle";
-  } catch {
-    return "offline";
-  }
-}
-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";
-    }
-    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)`);
-      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)`);
-      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);
-    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
-    return "delivered";
-  } catch {
-    logIntercom(`FAIL \u2192 ${targetSession}`);
-    return "failed";
-  }
-}
-function ensureEmployee(employeeName, exeSession, projectDir, opts) {
-  if (employeeName === "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(employeeName)) {
-    const bare = employeeName.replace(/-exe\d*$/, "").replace(/\d+$/, "");
-    return {
-      status: "failed",
-      sessionName: "",
-      error: `Error: pass employee name ('${bare}'), not session name ('${employeeName}')`
-    };
-  }
-  let effectiveInstance = opts?.instance;
-  if (effectiveInstance === void 0 && opts?.autoInstance) {
-    const free = findFreeInstance(
-      employeeName,
-      exeSession,
-      opts.maxAutoInstances ?? 10
-    );
-    if (free === null) {
-      return {
-        status: "failed",
-        sessionName: employeeSessionName(employeeName, exeSession),
-        error: `All ${opts.maxAutoInstances ?? 10} instances of ${employeeName} are alive \u2014 cap reached`
-      };
-    }
-    effectiveInstance = free === 0 ? void 0 : free;
-  }
-  const sessionName = employeeSessionName(employeeName, exeSession, effectiveInstance);
-  if (isEmployeeAlive(sessionName)) {
-    const result2 = sendIntercom(sessionName);
-    if (result2 === "acknowledged" || result2 === "skipped_exe" || result2 === "debounced" || result2 === "queued") {
-      return { status: "intercom_sent", sessionName };
-    }
-    if (result2 === "delivered") {
-      return { status: "intercom_unprocessed", sessionName };
-    }
-    return { status: "failed", sessionName, error: "intercom delivery failed" };
-  }
-  const spawnOpts = { ...opts, instance: effectiveInstance };
-  const mainRoot = getMainRepoRoot(projectDir) ?? projectDir;
-  const wtPath = ensureWorktree(mainRoot, employeeName, effectiveInstance);
-  if (wtPath) {
-    spawnOpts.cwd = wtPath;
-  }
-  const result = spawnEmployee(employeeName, exeSession, projectDir, spawnOpts);
-  if (result.error) {
-    return { status: "failed", sessionName, error: result.error };
-  }
-  return { status: "spawned", sessionName };
-}
-function spawnEmployee(employeeName, exeSession, projectDir, opts) {
-  const transport = getTransport();
-  const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
-  const instanceLabel2 = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path10.join(os5.homedir(), ".exe-os", "session-logs");
-  const logFile = path10.join(logDir, `${instanceLabel2}-${Date.now()}.log`);
-  if (!existsSync10(logDir)) {
-    mkdirSync5(logDir, { recursive: true });
-  }
-  transport.kill(sessionName);
-  let cleanupSuffix = "";
-  try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const cleanupScript = path10.join(path10.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync10(cleanupScript)) {
-      cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
-    }
-  } catch {
-  }
-  try {
-    const claudeJsonPath = path10.join(os5.homedir(), ".claude.json");
-    let claudeJson = {};
-    try {
-      claudeJson = JSON.parse(readFileSync9(claudeJsonPath, "utf8"));
-    } catch {
-    }
-    if (!claudeJson.projects) claudeJson.projects = {};
-    const projects = claudeJson.projects;
-    const trustDir = opts?.cwd ?? projectDir;
-    if (!projects[trustDir]) projects[trustDir] = {};
-    projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync4(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
-  } catch {
-  }
-  try {
-    const settingsDir = path10.join(os5.homedir(), ".claude", "projects");
-    const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path10.join(settingsDir, normalizedKey);
-    const settingsPath = path10.join(projSettingsDir, "settings.json");
-    let settings = {};
-    try {
-      settings = JSON.parse(readFileSync9(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 ?? projectDir;
-  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 = path10.join(
-      os5.homedir(),
-      ".exe-os",
-      "identity",
-      `${employeeName}.md`
-    );
-    _resetCcAgentSupportCache();
-    const hasAgentFlag = claudeSupportsAgentFlag();
-    if (hasAgentFlag) {
-      identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync10(identityPath)) {
-      identityFlag = ` --append-system-prompt-file ${identityPath}`;
-      legacyFallbackWarned = true;
-    }
-    const behaviorsFile = exportBehaviorsSync(
-      employeeName,
-      path10.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 ${employeeName}. Upgrade Claude Code to enable native --agent launch.
-`
-    );
-  }
-  let sessionContextFlag = "";
-  try {
-    const ctxDir = path10.join(os5.homedir(), ".exe-os", "session-cache");
-    mkdirSync5(ctxDir, { recursive: true });
-    const ctxFile = path10.join(ctxDir, `session-context-${sessionName}.md`);
-    const ctxContent = [
-      `## Session Context`,
-      `You are running in tmux session: ${sessionName}.`,
-      `Your parent exe session is ${exeSession}.`,
-      `Your employees (if any) use the -${exeSession} suffix (e.g., tom-${exeSession}).`
-    ].join("\n");
-    writeFileSync4(ctxFile, ctxContent);
-    sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
-  } catch {
-  }
-  let envPrefix = `EXE_SESSION=${exeSession} 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 ${employeeName} --model ${opts.model} --provider ${opts.provider}${cleanupSuffix}`;
-  } else if (useBinSymlink) {
-    const binName = `${employeeName}-${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 = path10.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync4(dispatchInfo, JSON.stringify({
-      dispatchedBy: mySession,
-      rootExe: exeSession,
-      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    }));
-  } catch {
-  }
-  let booted = false;
-  for (let i = 0; i < 30; i++) {
-    try {
-      execSync6("sleep 0.5");
-    } 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 15s` };
-  }
-  if (!useExeAgent) {
-    try {
-      transport.sendKeys(sessionName, `/exe-call ${employeeName}`);
-    } catch {
-    }
-  }
-  registerSession({
-    windowName: sessionName,
-    agentId: employeeName,
-    projectDir: spawnCwd,
-    parentExe: exeSession,
-    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;
-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 = path10.join(os5.homedir(), ".exe-os", "session-cache");
-    BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
-    INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path10.join(os5.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path10.join(SESSION_CACHE, "intercom-debounce.json");
-    DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
-    BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
-  }
-});
-
-// src/lib/tasks-review.ts
-import path11 from "path";
-import { existsSync as existsSync11, readdirSync as readdirSync2, unlinkSync as unlinkSync2 } from "fs";
-var init_tasks_review = __esm({
-  "src/lib/tasks-review.ts"() {
-    "use strict";
-    init_database();
-    init_config();
-    init_employees();
-    init_notifications();
-    init_tasks_crud();
-    init_tmux_routing();
-    init_session_key();
-  }
-});
-
-// src/lib/tasks-chain.ts
-import path12 from "path";
-import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
-var init_tasks_chain = __esm({
-  "src/lib/tasks-chain.ts"() {
-    "use strict";
-    init_database();
-    init_notifications();
-  }
-});
-
-// src/lib/project-name.ts
-import { execSync as execSync7 } from "child_process";
-import path13 from "path";
-function getProjectName(cwd) {
-  const dir = cwd ?? process.cwd();
-  if (_cached2 && _cachedCwd === dir) return _cached2;
-  try {
-    let repoRoot;
-    try {
-      const gitCommonDir = execSync7("git rev-parse --path-format=absolute --git-common-dir", {
-        cwd: dir,
-        encoding: "utf8",
-        timeout: 2e3,
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      repoRoot = path13.dirname(gitCommonDir);
-    } catch {
-      repoRoot = execSync7("git rev-parse --show-toplevel", {
-        cwd: dir,
-        encoding: "utf8",
-        timeout: 2e3,
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-    }
-    _cached2 = path13.basename(repoRoot);
-    _cachedCwd = dir;
-    return _cached2;
-  } catch {
-    _cached2 = path13.basename(dir);
-    _cachedCwd = dir;
-    return _cached2;
-  }
-}
-var _cached2, _cachedCwd;
-var init_project_name = __esm({
-  "src/lib/project-name.ts"() {
-    "use strict";
-    _cached2 = null;
-    _cachedCwd = null;
-  }
-});
-
-// src/lib/session-scope.ts
-var session_scope_exports = {};
-__export(session_scope_exports, {
-  assertSessionScope: () => assertSessionScope,
-  findSessionForProject: () => findSessionForProject,
-  getSessionProject: () => getSessionProject
-});
-function getSessionProject(sessionName) {
-  const sessions = listSessions();
-  const entry = sessions.find((s) => s.windowName === sessionName);
-  if (!entry) return null;
-  const parts = entry.projectDir.split("/").filter(Boolean);
-  return parts[parts.length - 1] ?? null;
-}
-function findSessionForProject(projectName) {
-  const sessions = listSessions();
-  for (const s of sessions) {
-    const proj = s.projectDir.split("/").filter(Boolean).pop();
-    if (proj === projectName && s.agentId === "exe") return s;
-  }
-  return null;
-}
-function assertSessionScope(actionType, targetProject) {
-  try {
-    const currentProject = getProjectName();
-    const exeSession = resolveExeSession();
-    if (!exeSession) {
-      return { allowed: true, reason: "no_session" };
-    }
-    if (currentProject === targetProject) {
-      return {
-        allowed: true,
-        reason: "same_session",
-        currentProject,
-        targetProject
-      };
-    }
-    process.stderr.write(
-      `[session-scope] Cross-project ${actionType}: session project="${currentProject}" \u2260 target project="${targetProject}"
-`
-    );
-    return {
-      allowed: true,
-      // v1: warn-only, don't block
-      reason: "cross_session_granted",
-      currentProject,
-      targetProject,
-      targetSession: findSessionForProject(targetProject)?.windowName
-    };
-  } catch {
-    return { allowed: true, reason: "no_session" };
-  }
-}
-var init_session_scope = __esm({
-  "src/lib/session-scope.ts"() {
-    "use strict";
-    init_session_registry();
-    init_project_name();
-    init_tmux_routing();
-  }
-});
-
-// src/lib/tasks-notify.ts
-async function dispatchTaskToEmployee(input) {
-  if (input.assignedTo === "exe") return { dispatched: "skipped" };
-  let crossProject = false;
-  if (input.projectName) {
-    try {
-      const { assertSessionScope: assertSessionScope2 } = (init_session_scope(), __toCommonJS(session_scope_exports));
-      const check = assertSessionScope2("dispatch_task", input.projectName);
-      if (check.reason === "cross_session_granted") {
-        crossProject = true;
-      }
-    } catch {
-    }
-  }
-  try {
-    const transport = getTransport();
-    const exeSession = resolveExeSession();
-    if (!exeSession) return { dispatched: "session_missing" };
-    const sessionName = employeeSessionName(input.assignedTo, exeSession);
-    if (transport.isAlive(sessionName)) {
-      const result = sendIntercom(sessionName);
-      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
-      return { dispatched, session: sessionName, crossProject };
-    } else {
-      const projectDir = input.projectDir ?? process.cwd();
-      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
-        autoInstance: input.assignedTo === "tom" || input.assignedTo === "sasha"
-      });
-      if (result.status === "failed") {
-        process.stderr.write(
-          `[dispatch] Failed to spawn ${input.assignedTo}: ${result.error}
-`
-        );
-        return { dispatched: "session_missing" };
-      }
-      return { dispatched: "spawned", session: result.sessionName, crossProject };
-    }
-  } catch {
-    return { dispatched: "session_missing" };
-  }
-}
-var init_tasks_notify = __esm({
-  "src/lib/tasks-notify.ts"() {
-    "use strict";
-    init_tmux_routing();
-    init_session_key();
-    init_notifications();
-    init_transport();
-  }
-});
-
-// src/lib/tasks.ts
-import path14 from "path";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, unlinkSync as unlinkSync3 } from "fs";
-async function createTask(input) {
-  const result = await createTaskCore(input);
-  if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
-    dispatchTaskToEmployee({
-      assignedTo: input.assignedTo,
-      title: input.title,
-      priority: input.priority,
-      taskFile: result.taskFile,
-      initialStatus: result.status,
-      projectName: input.projectName
-    });
-  }
-  return result;
-}
-var init_tasks = __esm({
-  "src/lib/tasks.ts"() {
-    "use strict";
-    init_database();
-    init_config();
-    init_notifications();
-    init_tasks_crud();
-    init_tasks_review();
-    init_tasks_crud();
-    init_tasks_chain();
-    init_tasks_review();
-    init_tasks_notify();
-  }
-});
-
-// src/mcp/tools/create-task.ts
-init_tasks();
-import { z } from "zod";
-
-// src/adapters/claude/active-agent.ts
-init_config();
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, unlinkSync as unlinkSync4, readdirSync as readdirSync3 } from "fs";
-import { execSync as execSync8 } from "child_process";
-import path15 from "path";
-
-// src/adapters/claude/session-key.ts
-init_session_key();
-
-// src/adapters/claude/active-agent.ts
-var CACHE_DIR = path15.join(EXE_AI_DIR, "session-cache");
-var STALE_MS = 24 * 60 * 60 * 1e3;
-function getMarkerPath() {
-  return path15.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
-}
-function getActiveAgent() {
-  try {
-    const markerPath = getMarkerPath();
-    const raw = readFileSync10(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 {
-            unlinkSync4(markerPath);
-          } catch {
-          }
-        } else {
-          return {
-            agentId: data.agentId,
-            agentRole: data.agentRole || "employee"
-          };
-        }
-      } else {
-        return {
-          agentId: data.agentId,
-          agentRole: data.agentRole || "employee"
-        };
-      }
-    }
-  } catch {
-  }
-  try {
-    const sessionName = execSync8(
-      "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/mcp/tools/create-task.ts
-init_tmux_routing();
-function registerCreateTask(server) {
-  server.registerTool(
-    "create_task",
-    {
-      title: "Create Task",
-      description: "Create and assign a task to an employee. Writes a .md task file and DB row.",
-      inputSchema: {
-        title: z.string().describe("Task title"),
-        assigned_to: z.string().describe("Employee name to assign to"),
-        project_name: z.string().describe("Project name"),
-        priority: z.enum(["p0", "p1", "p2"]).default("p1").describe("Priority level"),
-        complexity: z.enum(["routine", "standard", "complex", "critical"]).default("standard").describe("Bloom taxonomy complexity level. Affects routing tier and review requirements."),
-        context: z.string().describe("Full task description and context"),
-        blocked_by: z.string().optional().describe("Task ID or slug of the blocking task. If set, task starts as 'blocked'."),
-        parent_task_id: z.string().optional().describe("Parent task ID or slug. Links this task as a subtask."),
-        reviewer: z.string().optional().describe("Who should review this task when done. Defaults to assigner."),
-        budget_tokens: z.number().optional().describe("Max tokens allowed for this task (null = unlimited)"),
-        budget_fallback_model: z.string().optional().describe("Model to route to when budget is exhausted")
-      }
-    },
-    async ({ title, assigned_to, project_name, priority, complexity, context, blocked_by, parent_task_id, reviewer, budget_tokens, budget_fallback_model }) => {
-      const { agentId: assignedBy } = getActiveAgent();
-      const task = await createTask({
-        title,
-        assignedTo: assigned_to,
-        assignedBy,
-        projectName: project_name,
-        priority,
-        complexity,
-        context,
-        baseDir: process.cwd(),
-        blockedBy: blocked_by,
-        parentTaskId: parent_task_id,
-        reviewer,
-        budgetTokens: budget_tokens,
-        budgetFallbackModel: budget_fallback_model,
-        // Skip internal dispatch — we handle it below with autoInstance
-        // support. Without this, createTask fires dispatchTaskToEmployee
-        // (no autoInstance) in parallel, racing with our ensureEmployee
-        // (autoInstance: true) and spawning duplicate sessions.
-        skipDispatch: true
-      });
-      let dispatchStatus = "";
-      if (task.status !== "blocked" && !process.env.VITEST) {
-        try {
-          const exeSession = resolveExeSession();
-          if (exeSession) {
-            const MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["tom", "sasha"]);
-            const useAutoInstance = MULTI_INSTANCE_ROLES.has(assigned_to);
-            const { loadConfigSync: loadConfigSync2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-            const cfg = loadConfigSync2();
-            const result = ensureEmployee(assigned_to, exeSession, process.cwd(), {
-              autoInstance: useAutoInstance,
-              maxAutoInstances: useAutoInstance ? cfg.sessionLifecycle.maxAutoInstances : void 0
-            });
-            switch (result.status) {
-              case "intercom_sent":
-                dispatchStatus = `
-Dispatched: intercom sent to ${result.sessionName}`;
-                break;
-              case "spawned":
-                dispatchStatus = `
-Dispatched: spawned ${result.sessionName}`;
-                break;
-              case "failed":
-                dispatchStatus = `
-Dispatch failed: ${result.error ?? "unknown"}`;
-                break;
-            }
-          }
-        } catch {
-        }
-      }
-      let text = `Task created: ${task.id}
-File: ${task.taskFile}
-Assigned to: ${task.assignedTo} [${task.priority.toUpperCase()}]${dispatchStatus}`;
-      if (task.status === "blocked") {
-        text += `
-Status: blocked (waiting on ${blocked_by})`;
-      }
-      if (task.warning) {
-        text += `
-Warning: ${task.warning}`;
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text
-          }
-        ]
-      };
-    }
-  );
-}
-export {
-  registerCreateTask
-};