@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/bin/install.js

@@ -1,2311 +1,36 @@
 #!/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/secure-files.ts
-import { chmodSync, existsSync, mkdirSync } from "fs";
-import { chmod, mkdir } from "fs/promises";
-function ensurePrivateDirSync(dirPath) {
-  mkdirSync(dirPath, { recursive: true, mode: PRIVATE_DIR_MODE });
-  try {
-    chmodSync(dirPath, PRIVATE_DIR_MODE);
-  } catch {
-  }
-}
-function enforcePrivateFileSync(filePath) {
-  try {
-    if (existsSync(filePath)) chmodSync(filePath, PRIVATE_FILE_MODE);
-  } catch {
-  }
-}
-var PRIVATE_DIR_MODE, PRIVATE_FILE_MODE;
-var init_secure_files = __esm({
-  "src/lib/secure-files.ts"() {
-    "use strict";
-    PRIVATE_DIR_MODE = 448;
-    PRIVATE_FILE_MODE = 384;
-  }
-});
-
-// src/lib/config.ts
-import { readFile, writeFile } from "fs/promises";
-import { readFileSync, existsSync as existsSync2, 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 (!existsSync2(newDir) && existsSync2(legacyDir)) {
-    try {
-      renameSync(legacyDir, newDir);
-      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
-`);
-    } catch {
-      return legacyDir;
-    }
-  }
-  return newDir;
-}
-var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG;
-var init_config = __esm({
-  "src/lib/config.ts"() {
-    "use strict";
-    init_secure_files();
-    EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path.join(EXE_AI_DIR, "models");
-    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: {},
-      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
-      },
-      support: {
-        bugReportEndpoint: "https://askexe.com/v1/support/bug-reports"
-      },
-      orchestration: {
-        phase: "phase_1_coo",
-        phaseSetBy: "default"
-      }
-    };
-  }
-});
-
-// src/lib/runtime-table.ts
-var RUNTIME_TABLE, DEFAULT_RUNTIME;
-var init_runtime_table = __esm({
-  "src/lib/runtime-table.ts"() {
-    "use strict";
-    RUNTIME_TABLE = {
-      codex: {
-        binary: "codex",
-        launchMode: "interactive",
-        autoApproveFlag: "--dangerously-bypass-approvals-and-sandbox",
-        inlineFlag: "--no-alt-screen",
-        apiKeyEnv: "OPENAI_API_KEY",
-        defaultModel: "gpt-5.5"
-      },
-      opencode: {
-        binary: "opencode",
-        launchMode: "exec",
-        autoApproveFlag: "--dangerously-skip-permissions",
-        inlineFlag: "",
-        apiKeyEnv: "ANTHROPIC_API_KEY",
-        defaultModel: "anthropic/claude-sonnet-4-6"
-      }
-    };
-    DEFAULT_RUNTIME = "claude";
-  }
-});
-
-// src/lib/agent-config.ts
-var agent_config_exports = {};
-__export(agent_config_exports, {
-  AGENT_CONFIG_PATH: () => AGENT_CONFIG_PATH,
-  DEFAULT_MODELS: () => DEFAULT_MODELS,
-  KNOWN_RUNTIMES: () => KNOWN_RUNTIMES,
-  RUNTIME_LABELS: () => RUNTIME_LABELS,
-  clearAgentRuntime: () => clearAgentRuntime,
-  getAgentRuntime: () => getAgentRuntime,
-  loadAgentConfig: () => loadAgentConfig,
-  normalizeCcModelName: () => normalizeCcModelName,
-  saveAgentConfig: () => saveAgentConfig,
-  setAgentMcps: () => setAgentMcps,
-  setAgentRuntime: () => setAgentRuntime
-});
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3 } from "fs";
-import path2 from "path";
-function loadAgentConfig() {
-  if (!existsSync3(AGENT_CONFIG_PATH)) return {};
-  try {
-    return JSON.parse(readFileSync2(AGENT_CONFIG_PATH, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function saveAgentConfig(config) {
-  const dir = path2.dirname(AGENT_CONFIG_PATH);
-  ensurePrivateDirSync(dir);
-  writeFileSync(AGENT_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  enforcePrivateFileSync(AGENT_CONFIG_PATH);
-}
-function getAgentRuntime(agentId) {
-  const config = loadAgentConfig();
-  const entry = config[agentId];
-  if (entry) return entry;
-  const orgDefault = config["default"];
-  if (orgDefault) return orgDefault;
-  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
-}
-function normalizeCcModelName(model) {
-  let ccModel = model.replace(/(\d+)\.(\d+)/g, "$1-$2");
-  if (/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) && !ccModel.includes("[1m]")) {
-    ccModel += "[1m]";
-  }
-  return ccModel;
-}
-function setAgentRuntime(agentId, runtime, model, reasoning_effort, mcps) {
-  const knownModels = KNOWN_RUNTIMES[runtime];
-  if (!knownModels) {
-    return {
-      ok: false,
-      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
-    };
-  }
-  if (!knownModels.includes(model)) {
-    return {
-      ok: false,
-      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${knownModels.join(", ")}`
-    };
-  }
-  const config = loadAgentConfig();
-  const existing = config[agentId];
-  const entry = { runtime, model };
-  if (reasoning_effort) entry.reasoning_effort = reasoning_effort;
-  if (mcps !== void 0) {
-    entry.mcps = mcps.includes("exe-os") ? mcps : ["exe-os", ...mcps];
-  } else if (existing?.mcps) {
-    entry.mcps = existing.mcps;
-  }
-  config[agentId] = entry;
-  saveAgentConfig(config);
-  return { ok: true };
-}
-function setAgentMcps(agentId, mcps) {
-  const config = loadAgentConfig();
-  const existing = config[agentId] ?? getAgentRuntime(agentId);
-  existing.mcps = mcps.includes("exe-os") ? mcps : ["exe-os", ...mcps];
-  config[agentId] = existing;
-  saveAgentConfig(config);
-  return { ok: true };
-}
-function clearAgentRuntime(agentId) {
-  const config = loadAgentConfig();
-  delete config[agentId];
-  saveAgentConfig(config);
-}
-var AGENT_CONFIG_PATH, KNOWN_RUNTIMES, RUNTIME_LABELS, DEFAULT_MODELS;
-var init_agent_config = __esm({
-  "src/lib/agent-config.ts"() {
-    "use strict";
-    init_config();
-    init_runtime_table();
-    init_secure_files();
-    AGENT_CONFIG_PATH = path2.join(EXE_AI_DIR, "agent-config.json");
-    KNOWN_RUNTIMES = {
-      claude: ["claude-opus-4.6", "claude-opus-4", "claude-sonnet-4.6", "claude-sonnet-4", "claude-haiku-4.5"],
-      codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
-      opencode: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
-    };
-    RUNTIME_LABELS = {
-      claude: "Claude Code (Anthropic)",
-      codex: "Codex (OpenAI)",
-      opencode: "OpenCode (open source)"
-    };
-    DEFAULT_MODELS = {
-      claude: "claude-opus-4.6",
-      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
-      opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
-    };
-  }
-});
-
-// src/lib/employees.ts
-var employees_exports = {};
-__export(employees_exports, {
-  COORDINATOR_ROLE: () => COORDINATOR_ROLE,
-  DEFAULT_COORDINATOR_TEMPLATE_NAME: () => DEFAULT_COORDINATOR_TEMPLATE_NAME,
-  EMPLOYEES_PATH: () => EMPLOYEES_PATH,
-  addEmployee: () => addEmployee,
-  baseAgentName: () => baseAgentName,
-  canCoordinate: () => canCoordinate,
-  getCoordinatorEmployee: () => getCoordinatorEmployee,
-  getCoordinatorName: () => getCoordinatorName,
-  getEmployee: () => getEmployee,
-  getEmployeeByRole: () => getEmployeeByRole,
-  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
-  hasRole: () => hasRole,
-  hireEmployee: () => hireEmployee,
-  isCoordinatorName: () => isCoordinatorName,
-  isCoordinatorRole: () => isCoordinatorRole,
-  isMultiInstance: () => isMultiInstance,
-  loadEmployees: () => loadEmployees,
-  loadEmployeesSync: () => loadEmployeesSync,
-  normalizeRole: () => normalizeRole,
-  normalizeRosterCase: () => normalizeRosterCase,
-  registerBinSymlinks: () => registerBinSymlinks,
-  saveEmployees: () => saveEmployees,
-  validateEmployeeName: () => validateEmployeeName
-});
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync4, symlinkSync, readlinkSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { execSync } from "child_process";
-import path3 from "path";
-import os2 from "os";
-function normalizeRole(role) {
-  return (role ?? "").trim().toLowerCase();
-}
-function isCoordinatorRole(role) {
-  return normalizeRole(role) === normalizeRole(COORDINATOR_ROLE);
-}
-function getCoordinatorEmployee(employees) {
-  return employees.find((e) => isCoordinatorRole(e.role));
-}
-function getCoordinatorName(employees = loadEmployeesSync()) {
-  return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
-}
-function isCoordinatorName(agentName, employees = loadEmployeesSync()) {
-  if (!agentName) return false;
-  return agentName.toLowerCase() === getCoordinatorName(employees).toLowerCase();
-}
-function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
-  return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
-}
-function validateEmployeeName(name) {
-  if (!name) {
-    return { valid: false, error: "Name is required" };
-  }
-  if (name.length > 32) {
-    return { valid: false, error: "Name must be 32 characters or fewer" };
-  }
-  if (!/^[a-z][a-z0-9]*$/.test(name)) {
-    return {
-      valid: false,
-      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
-    };
-  }
-  return { valid: true };
-}
-async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync4(employeesPath)) {
-    return [];
-  }
-  const raw = await readFile2(employeesPath, "utf-8");
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return [];
-  }
-}
-async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir2(path3.dirname(employeesPath), { recursive: true });
-  await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
-}
-function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync4(employeesPath)) return [];
-  try {
-    return JSON.parse(readFileSync3(employeesPath, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function getEmployee(employees, name) {
-  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
-}
-function getEmployeeByRole(employees, role) {
-  const lower = role.toLowerCase();
-  return employees.find((e) => e.role.toLowerCase() === lower);
-}
-function getEmployeeNamesByRole(employees, role) {
-  const lower = role.toLowerCase();
-  return employees.filter((e) => e.role.toLowerCase() === lower).map((e) => e.name);
-}
-function hasRole(agentName, role) {
-  const employees = loadEmployeesSync();
-  const emp = getEmployee(employees, agentName);
-  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
-}
-function baseAgentName(name, employees) {
-  const match = name.match(/^([a-zA-Z]+)\d+$/);
-  if (!match) return name;
-  const base = match[1];
-  const roster = employees ?? loadEmployeesSync();
-  if (getEmployee(roster, base)) return base;
-  return name;
-}
-function isMultiInstance(agentName, employees) {
-  const roster = employees ?? loadEmployeesSync();
-  const emp = getEmployee(roster, agentName);
-  if (!emp) return false;
-  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
-}
-function addEmployee(employees, employee) {
-  const { systemPrompt: _legacyPrompt, ...rest } = employee;
-  const normalized = { ...rest, name: employee.name.toLowerCase() };
-  if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
-    throw new Error(`Employee '${normalized.name}' already exists`);
-  }
-  return [...employees, normalized];
-}
-function appendToCoordinatorTeam(employee) {
-  const coordinator = getCoordinatorEmployee(loadEmployeesSync());
-  if (!coordinator) return;
-  const idPath = path3.join(IDENTITY_DIR, `${coordinator.name}.md`);
-  if (!existsSync4(idPath)) return;
-  const content = readFileSync3(idPath, "utf-8");
-  if (content.includes(`**${capitalize(employee.name)}`)) return;
-  const teamMatch = content.match(TEAM_SECTION_RE);
-  if (!teamMatch || teamMatch.index === void 0) return;
-  const afterTeam = content.slice(teamMatch.index + teamMatch[0].length);
-  const nextHeading = afterTeam.match(/\n## /);
-  const entry = `
-**${capitalize(employee.name)} (${employee.role}):** Newly hired. Update this description as the role develops.
-`;
-  let updated;
-  if (nextHeading && nextHeading.index !== void 0) {
-    const insertAt = teamMatch.index + teamMatch[0].length + nextHeading.index;
-    updated = content.slice(0, insertAt) + entry + content.slice(insertAt);
-  } else {
-    updated = content.trimEnd() + "\n" + entry;
-  }
-  writeFileSync2(idPath, updated, "utf-8");
-}
-function capitalize(s) {
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}
-async function hireEmployee(employee) {
-  const employees = await loadEmployees();
-  const updated = addEmployee(employees, employee);
-  await saveEmployees(updated);
-  try {
-    appendToCoordinatorTeam(employee);
-  } catch {
-  }
-  try {
-    const { loadAgentConfig: loadAgentConfig2, saveAgentConfig: saveAgentConfig2 } = await Promise.resolve().then(() => (init_agent_config(), agent_config_exports));
-    const config = loadAgentConfig2();
-    const name = employee.name.toLowerCase();
-    if (!config[name] && config["default"]) {
-      config[name] = { ...config["default"] };
-      saveAgentConfig2(config);
-    }
-  } catch {
-  }
-  return updated;
-}
-async function normalizeRosterCase(rosterPath) {
-  const employees = await loadEmployees(rosterPath);
-  let changed = false;
-  for (const emp of employees) {
-    if (emp.name !== emp.name.toLowerCase()) {
-      const oldName = emp.name;
-      emp.name = emp.name.toLowerCase();
-      changed = true;
-      try {
-        const identityDir = path3.join(os2.homedir(), ".exe-os", "identity");
-        const oldPath = path3.join(identityDir, `${oldName}.md`);
-        const newPath = path3.join(identityDir, `${emp.name}.md`);
-        if (existsSync4(oldPath) && !existsSync4(newPath)) {
-          renameSync2(oldPath, newPath);
-        } else if (existsSync4(oldPath) && oldPath !== newPath) {
-          const content = readFileSync3(oldPath, "utf-8");
-          writeFileSync2(newPath, content, "utf-8");
-          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
-            unlinkSync(oldPath);
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  if (changed) {
-    await saveEmployees(employees, rosterPath);
-  }
-  return changed;
-}
-function findExeBin() {
-  try {
-    return execSync(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
-  } catch {
-    return null;
-  }
-}
-function registerBinSymlinks(name) {
-  const created = [];
-  const skipped = [];
-  const errors = [];
-  const exeBinPath = findExeBin();
-  if (!exeBinPath) {
-    errors.push("Could not find 'exe-os' in PATH");
-    return { created, skipped, errors };
-  }
-  const binDir = path3.dirname(exeBinPath);
-  let target;
-  try {
-    target = readlinkSync(exeBinPath);
-  } catch {
-    errors.push("Could not read 'exe' symlink");
-    return { created, skipped, errors };
-  }
-  for (const suffix of ["", "-opencode"]) {
-    const linkName = `${name}${suffix}`;
-    const linkPath = path3.join(binDir, linkName);
-    if (existsSync4(linkPath)) {
-      skipped.push(linkName);
-      continue;
-    }
-    try {
-      symlinkSync(target, linkPath);
-      created.push(linkName);
-    } catch (err) {
-      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  return { created, skipped, errors };
-}
-var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES, IDENTITY_DIR, TEAM_SECTION_RE;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
-    "use strict";
-    init_config();
-    EMPLOYEES_PATH = path3.join(EXE_AI_DIR, "exe-employees.json");
-    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
-    COORDINATOR_ROLE = "COO";
-    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
-    IDENTITY_DIR = path3.join(EXE_AI_DIR, "identity");
-    TEAM_SECTION_RE = /^## Team\b.*$/m;
-  }
-});
-
-// src/lib/agent-symlinks.ts
-import os3 from "os";
-import path4 from "path";
 import {
-  existsSync as existsSync5,
-  lstatSync,
-  mkdirSync as mkdirSync2,
-  readlinkSync as readlinkSync2,
-  symlinkSync as symlinkSync2
-} from "fs";
-function claudeAgentsDir(homeDir) {
-  return path4.join(homeDir, ".claude", "agents");
-}
-function identitySourcePath(homeDir, agentId) {
-  return path4.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
-}
-function claudeAgentLinkPath(homeDir, agentId) {
-  return path4.join(claudeAgentsDir(homeDir), `${agentId}.md`);
-}
-function ensureAgentSymlink(agentId, homeDir = os3.homedir()) {
-  const target = identitySourcePath(homeDir, agentId);
-  const link = claudeAgentLinkPath(homeDir, agentId);
-  mkdirSync2(claudeAgentsDir(homeDir), { recursive: true });
-  if (existsSync5(link)) {
-    let stat;
-    try {
-      stat = lstatSync(link);
-    } catch {
-      return { agentId, action: "conflict", target, link, conflict: "stat_failed" };
-    }
-    if (!stat.isSymbolicLink()) {
-      return { agentId, action: "conflict", target, link, conflict: "regular_file" };
-    }
-    let currentTarget;
-    try {
-      currentTarget = readlinkSync2(link);
-    } catch {
-      return { agentId, action: "conflict", target, link, conflict: "readlink_failed" };
-    }
-    if (currentTarget === target) {
-      return { agentId, action: "already_correct", target, link };
-    }
-    return { agentId, action: "conflict", target, link, conflict: `points_to:${currentTarget}` };
-  }
-  try {
-    symlinkSync2(target, link);
-  } catch (err) {
-    return {
-      agentId,
-      action: "conflict",
-      target,
-      link,
-      conflict: err instanceof Error ? err.message : String(err)
-    };
-  }
-  return { agentId, action: "created", target, link };
-}
-async function ensureAllAgentSymlinks(homeDir = os3.homedir()) {
-  const employees = await loadEmployees();
-  return employees.map((emp) => ensureAgentSymlink(emp.name, homeDir));
-}
-var init_agent_symlinks = __esm({
-  "src/lib/agent-symlinks.ts"() {
-    "use strict";
-    init_employees();
-  }
-});
-
-// src/lib/mcp-prefix.ts
-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/preferences.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import path5 from "path";
-import os4 from "os";
-function loadPreferences(homeDir = os4.homedir()) {
-  const configPath = path5.join(homeDir, ".exe-os", "config.json");
-  if (!existsSync6(configPath)) return {};
-  try {
-    const config = JSON.parse(readFileSync4(configPath, "utf-8"));
-    return config.preferences ?? {};
-  } catch {
-    return {};
-  }
-}
-var init_preferences = __esm({
-  "src/lib/preferences.ts"() {
-    "use strict";
-    init_secure_files();
-  }
-});
-
-// src/adapters/mcp-http-config.ts
-import { chmodSync as chmodSync2, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { randomBytes } from "crypto";
-import path6 from "path";
-import os5 from "os";
-function resolveDefaultAgentId() {
-  if (process.env.AGENT_ID && process.env.AGENT_ID !== "default") return process.env.AGENT_ID;
-  try {
-    const { loadEmployeesSync: loadEmployeesSync2 } = (init_employees(), __toCommonJS(employees_exports));
-    const coo = loadEmployeesSync2().find((e) => e.role === "COO");
-    if (coo) return coo.name;
-  } catch {
-  }
-  return "exe";
-}
-function mcpHttpPort() {
-  return process.env.EXE_MCP_PORT || DEFAULT_MCP_HTTP_PORT;
-}
-function mcpHttpUrl() {
-  return `http://127.0.0.1:${mcpHttpPort()}/mcp`;
-}
-function readOrCreateDaemonToken(homeDir = os5.homedir()) {
-  const exeDir = path6.join(homeDir, ".exe-os");
-  const tokenPath = path6.join(exeDir, "exed.token");
-  if (existsSync7(tokenPath)) {
-    try {
-      const token2 = readFileSync5(tokenPath, "utf-8").trim();
-      if (/^[a-f0-9]{64}$/i.test(token2)) return token2;
-    } catch {
-    }
-  }
-  const token = randomBytes(32).toString("hex");
-  mkdirSync3(exeDir, { recursive: true });
-  writeFileSync4(tokenPath, `${token}
-`, "utf-8");
-  try {
-    chmodSync2(tokenPath, 384);
-  } catch {
-  }
-  return token;
-}
-function buildMcpHttpHeaders(homeDir = os5.homedir(), opts = {}) {
-  const agentId = opts.useShellPlaceholders ? "${AGENT_ID:-exe}" : opts.agentId ?? DEFAULT_MCP_HTTP_AGENT_ID;
-  const agentRole = opts.useShellPlaceholders ? "${AGENT_ROLE:-COO}" : opts.agentRole ?? DEFAULT_MCP_HTTP_AGENT_ROLE;
-  const sessionName = opts.useShellPlaceholders ? "" : process.env.EXE_SESSION_NAME ?? "";
-  const headers = {
-    Authorization: `Bearer ${readOrCreateDaemonToken(homeDir)}`,
-    "X-Agent-Id": agentId,
-    "X-Agent-Role": agentRole
-  };
-  if (sessionName) headers["X-Exe-Session"] = sessionName;
-  return headers;
-}
-function buildClaudeHttpMcpEntry(homeDir = os5.homedir()) {
-  return {
-    type: "http",
-    url: mcpHttpUrl(),
-    headers: buildMcpHttpHeaders(homeDir, { useShellPlaceholders: true })
-  };
-}
-var DEFAULT_MCP_HTTP_PORT, DEFAULT_MCP_HTTP_AGENT_ID, DEFAULT_MCP_HTTP_AGENT_ROLE;
-var init_mcp_http_config = __esm({
-  "src/adapters/mcp-http-config.ts"() {
-    "use strict";
-    DEFAULT_MCP_HTTP_PORT = "48739";
-    DEFAULT_MCP_HTTP_AGENT_ID = resolveDefaultAgentId();
-    DEFAULT_MCP_HTTP_AGENT_ROLE = "COO";
-  }
-});
-
-// src/adapters/runtime-hook-manifest.ts
-function isLegacyHomeDirHookCommand(command) {
-  return LEGACY_HOME_DIR_HOOK_PATTERNS.some((pattern) => command.includes(pattern));
-}
-function commandHasAnyMarker(command, markers) {
-  return markers.some((marker) => command.includes(marker));
-}
-function isLegacySplitPostToolCommand(command) {
-  return commandHasAnyMarker(command, LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS);
-}
-var EXE_HOOKS, EXE_HOOK_MANIFEST, LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS, LEGACY_HOME_DIR_HOOK_PATTERNS;
-var init_runtime_hook_manifest = __esm({
-  "src/adapters/runtime-hook-manifest.ts"() {
-    "use strict";
-    EXE_HOOKS = {
-      postToolCombined: "dist/hooks/post-tool-combined.js",
-      sessionStart: "dist/hooks/session-start.js",
-      promptSubmit: "dist/hooks/prompt-submit.js",
-      heartbeat: "dist/hooks/exe-heartbeat-hook.js",
-      stop: "dist/hooks/stop.js",
-      preToolUse: "dist/hooks/pre-tool-use.js",
-      subagentStop: "dist/hooks/subagent-stop.js",
-      preCompact: "dist/hooks/pre-compact.js",
-      postCompact: "dist/hooks/post-compact.js",
-      sessionEnd: "dist/hooks/session-end.js",
-      notification: "dist/hooks/notification.js",
-      instructionsLoaded: "dist/hooks/instructions-loaded.js"
-    };
-    EXE_HOOK_MANIFEST = [
-      {
-        key: "postToolCombined",
-        event: "PostToolUse",
-        commandMarker: EXE_HOOKS.postToolCombined,
-        owner: "exe-os",
-        purpose: "Single PostToolUse entrypoint for ingestion, error recall, summaries, and bug detection.",
-        runtimes: ["claude", "codex", "opencode"],
-        checkpointRole: "none"
-      },
-      {
-        key: "sessionStart",
-        event: "SessionStart",
-        commandMarker: EXE_HOOKS.sessionStart,
-        owner: "exe-os",
-        purpose: "Loads agent identity, procedures, and boot context.",
-        runtimes: ["claude", "codex", "opencode"],
-        checkpointRole: "none"
-      },
-      {
-        key: "promptSubmit",
-        event: "UserPromptSubmit",
-        commandMarker: EXE_HOOKS.promptSubmit,
-        owner: "exe-os",
-        purpose: "Injects current tasks, pending reviews, and local context before each prompt.",
-        runtimes: ["claude", "codex", "opencode"],
-        checkpointRole: "none"
-      },
-      {
-        key: "heartbeat",
-        event: "UserPromptSubmit",
-        commandMarker: EXE_HOOKS.heartbeat,
-        owner: "exe-os",
-        purpose: "Lightweight heartbeat/status sidecar for Claude Code sessions.",
-        runtimes: ["claude"],
-        checkpointRole: "none"
-      },
-      {
-        key: "stop",
-        event: "Stop",
-        commandMarker: EXE_HOOKS.stop,
-        owner: "exe-os",
-        purpose: "Finalizes task state, capacity signals, and emergency checkpointing.",
-        runtimes: ["claude", "codex", "opencode"],
-        checkpointRole: "capacity_checkpoint"
-      },
-      {
-        key: "preToolUse",
-        event: "PreToolUse",
-        commandMarker: EXE_HOOKS.preToolUse,
-        owner: "exe-os",
-        purpose: "Preflight guardrails before shell/tool execution.",
-        runtimes: ["claude", "codex", "opencode"],
-        checkpointRole: "none"
-      },
-      {
-        key: "subagentStop",
-        event: "SubagentStop",
-        commandMarker: EXE_HOOKS.subagentStop,
-        owner: "exe-os",
-        purpose: "Captures subagent completion context.",
-        runtimes: ["claude"],
-        checkpointRole: "none"
-      },
-      {
-        key: "preCompact",
-        event: "PreCompact",
-        commandMarker: EXE_HOOKS.preCompact,
-        owner: "exe-os",
-        purpose: "Writes active-task snapshot and compaction recovery context.",
-        runtimes: ["claude"],
-        checkpointRole: "recovery_context"
-      },
-      {
-        key: "postCompact",
-        event: "PostCompact",
-        commandMarker: EXE_HOOKS.postCompact,
-        owner: "exe-os",
-        purpose: "Rehydrates recovery context after compaction.",
-        runtimes: ["claude"],
-        checkpointRole: "recovery_context"
-      },
-      {
-        key: "sessionEnd",
-        event: "SessionEnd",
-        commandMarker: EXE_HOOKS.sessionEnd,
-        owner: "exe-os",
-        purpose: "Stores session-end checkpoint and triages orphaned in-progress tasks.",
-        runtimes: ["claude"],
-        checkpointRole: "session_summary"
-      },
-      {
-        key: "notification",
-        event: "Notification",
-        commandMarker: EXE_HOOKS.notification,
-        owner: "exe-os",
-        purpose: "Captures runtime notifications and nudges.",
-        runtimes: ["claude"],
-        checkpointRole: "none"
-      },
-      {
-        key: "instructionsLoaded",
-        event: "InstructionsLoaded",
-        commandMarker: EXE_HOOKS.instructionsLoaded,
-        owner: "exe-os",
-        purpose: "Applies runtime instruction post-processing.",
-        runtimes: ["claude"],
-        checkpointRole: "none"
-      }
-    ];
-    LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS = [
-      "dist/hooks/ingest.js",
-      "dist/hooks/error-recall.js",
-      "dist/hooks/ingest-worker.js"
-    ];
-    LEGACY_HOME_DIR_HOOK_PATTERNS = [
-      ".exe-os/hooks/",
-      // Old hook storage path (pre-npm-package era)
-      "log-prefix.js",
-      // Removed hook from early versions
-      "approval-bridge.log"
-      // Removed log redirect from early versions
-    ];
-  }
-});
-
-// src/adapters/claude/installer.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir, rm } from "fs/promises";
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync5, copyFileSync, mkdirSync as mkdirSync4 } from "fs";
-import { createHash } from "crypto";
-import path7 from "path";
-import os6 from "os";
-import { execSync as execSync2 } from "child_process";
-import { fileURLToPath } from "url";
-function resolvePackageRoot() {
-  const thisFile = fileURLToPath(import.meta.url);
-  let dir = path7.dirname(thisFile);
-  const root = path7.parse(dir).root;
-  while (dir !== root) {
-    const pkgPath = path7.join(dir, "package.json");
-    if (existsSync8(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
-        if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
-      } catch {
-      }
-    }
-    dir = path7.dirname(dir);
-  }
-  return path7.resolve(path7.dirname(thisFile), "..", "..", "..");
-}
-async function copySlashCommands(packageRoot, homeDir = os6.homedir()) {
-  let copied = 0;
-  let skipped = 0;
-  const skillsBase = path7.join(homeDir, ".claude", "skills");
-  const deprecatedExeLink = path7.join(skillsBase, "exe-link");
-  if (existsSync8(deprecatedExeLink)) {
-    await rm(deprecatedExeLink, { recursive: true, force: true });
-  }
-  const exeDir = path7.join(packageRoot, "src", "commands", "exe");
-  if (existsSync8(exeDir)) {
-    const entries = await readdir(exeDir);
-    const mdFiles = entries.filter((f) => f.endsWith(".md"));
-    for (const file of mdFiles) {
-      const name = file.replace(".md", "");
-      const destDir = path7.join(skillsBase, `exe-${name}`);
-      await mkdir3(destDir, { recursive: true });
-      const srcPath = path7.join(exeDir, file);
-      const destPath = path7.join(destDir, "SKILL.md");
-      const result = await copyAsSkill(srcPath, destPath, `exe-${name}`);
-      if (result) copied++;
-      else skipped++;
-    }
-  }
-  const topLevelSrc = path7.join(packageRoot, "src", "commands", "exe.md");
-  if (existsSync8(topLevelSrc)) {
-    const destDir = path7.join(skillsBase, "exe");
-    await mkdir3(destDir, { recursive: true });
-    const destPath = path7.join(destDir, "SKILL.md");
-    const result = await copyAsSkill(topLevelSrc, destPath, "exe");
-    if (result) copied++;
-    else skipped++;
-  }
-  return { copied, skipped };
-}
-async function copyAsSkill(srcPath, destPath, skillName) {
-  let content = await readFile3(srcPath, "utf-8");
-  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (fmMatch?.[1]) {
-    const fm = fmMatch[1];
-    if (fm.includes("name:")) {
-      content = content.replace(
-        /^(---\n[\s\S]*?)name:\s*[^\n]+/,
-        `$1name: ${skillName}`
-      );
-    } else {
-      content = content.replace(/^---\n/, `---
-name: ${skillName}
-`);
-    }
-  }
-  if (existsSync8(destPath)) {
-    const existing = await readFile3(destPath, "utf-8");
-    if (existing === content) return false;
-  }
-  await writeFile3(destPath, content);
-  return true;
-}
-function readJsonFile(filePath) {
-  try {
-    return JSON.parse(readFileSync6(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function findAncestorMcpJsons(startDir, homeDir) {
-  const files = [];
-  let dir = path7.resolve(startDir);
-  const root = path7.parse(dir).root;
-  const stop = path7.resolve(homeDir);
-  while (dir !== root) {
-    const candidate = path7.join(dir, ".mcp.json");
-    if (existsSync8(candidate)) files.push(candidate);
-    if (dir === stop) break;
-    dir = path7.dirname(dir);
-  }
-  return files;
-}
-function pathApplies(projectPath, cwd) {
-  const project = path7.resolve(projectPath);
-  const current = path7.resolve(cwd);
-  return current === project || current.startsWith(project + path7.sep);
-}
-function detectMcpNameCollisions(homeDir = os6.homedir(), cwd = process.cwd()) {
-  const claudeJsonPath = path7.join(homeDir, ".claude.json");
-  if (!existsSync8(claudeJsonPath)) return [];
-  const claudeJson = readJsonFile(claudeJsonPath);
-  if (!claudeJson?.projects) return [];
-  const collisions = [];
-  const mcpJsons = findAncestorMcpJsons(cwd, homeDir);
-  if (mcpJsons.length === 0) return [];
-  for (const [projectPath, projectConfig] of Object.entries(claudeJson.projects)) {
-    if (!pathApplies(projectPath, cwd)) continue;
-    const projectServerNames = new Set(Object.keys(projectConfig.mcpServers ?? {}));
-    if (projectServerNames.size === 0) continue;
-    const enabled = new Set(projectConfig.enabledMcpjsonServers ?? []);
-    for (const mcpJsonPath of mcpJsons) {
-      const mcpJson = readJsonFile(mcpJsonPath);
-      const mcpServerNames = Object.keys(mcpJson?.mcpServers ?? {});
-      for (const serverName of mcpServerNames) {
-        if (!projectServerNames.has(serverName)) continue;
-        collisions.push({
-          mcpJsonPath,
-          projectPath,
-          serverName,
-          disabledInMcpJson: !enabled.has(serverName)
-        });
-      }
-    }
-  }
-  return collisions;
-}
-function buildStdioMcpEntry(packageRoot) {
-  return {
-    type: "stdio",
-    command: "node",
-    args: [path7.join(packageRoot, "dist", "mcp", "server.js")],
-    env: {}
-  };
-}
-function mcpTransportMode() {
-  const value = process.env.EXE_OS_MCP_TRANSPORT?.trim().toLowerCase();
-  if (value === "stdio") return "stdio";
-  if (value === "http") return "http";
-  const totalGB = os6.totalmem() / (1024 * 1024 * 1024);
-  if (totalGB <= 8) return "stdio";
-  return "http";
-}
-async function registerMcpServer(packageRoot, homeDir = os6.homedir()) {
-  const claudeJsonPath = path7.join(homeDir, ".claude.json");
-  let claudeJson = {};
-  if (existsSync8(claudeJsonPath)) {
-    try {
-      claudeJson = JSON.parse(await readFile3(claudeJsonPath, "utf-8"));
-    } catch {
-      claudeJson = {};
-    }
-  }
-  if (!claudeJson.mcpServers) {
-    claudeJson.mcpServers = {};
-  }
-  const newEntry = mcpTransportMode() === "stdio" ? buildStdioMcpEntry(packageRoot) : buildClaudeHttpMcpEntry(homeDir);
-  if (claudeJson.mcpServers[MCP_LEGACY_KEY]) {
-    delete claudeJson.mcpServers[MCP_LEGACY_KEY];
-    process.stderr.write("exe-os: migrated MCP server key exe-mem \u2192 exe-os\n");
-  }
-  if (claudeJson.projects) {
-    for (const [projectPath, projectConfig] of Object.entries(claudeJson.projects)) {
-      if (projectConfig.mcpServers?.[MCP_LEGACY_KEY]) {
-        delete projectConfig.mcpServers[MCP_LEGACY_KEY];
-        process.stderr.write(`exe-os: removed stale project-level exe-mem from ${projectPath}
-`);
-      }
-    }
-  }
-  const currentOs = claudeJson.mcpServers[MCP_PRIMARY_KEY];
-  const osMatches = currentOs && JSON.stringify(currentOs) === JSON.stringify(newEntry);
-  if (osMatches) {
-    await cleanSettingsJsonMcp(path7.join(homeDir, ".claude", "settings.json"));
-    await migratePermissionsToExeOs(path7.join(homeDir, ".claude", "settings.json"));
-    const collisions2 = detectMcpNameCollisions(homeDir, packageRoot).filter((c) => c.serverName === MCP_PRIMARY_KEY || c.serverName === MCP_LEGACY_KEY);
-    for (const c of collisions2) {
-      process.stderr.write(
-        `exe-os: WARNING Claude Code MCP name collision: ${c.serverName} exists in ${c.mcpJsonPath} and ~/.claude.json project ${c.projectPath}. Remove or rename the .mcp.json entry if tools do not surface.
-`
-      );
-    }
-    await registerExeRustMcpConfig(packageRoot, homeDir);
-    return false;
-  }
-  claudeJson.mcpServers[MCP_PRIMARY_KEY] = newEntry;
-  await writeFile3(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
-  await cleanSettingsJsonMcp(path7.join(homeDir, ".claude", "settings.json"));
-  await migratePermissionsToExeOs(path7.join(homeDir, ".claude", "settings.json"));
-  const collisions = detectMcpNameCollisions(homeDir, packageRoot).filter((c) => c.serverName === MCP_PRIMARY_KEY || c.serverName === MCP_LEGACY_KEY);
-  for (const c of collisions) {
-    process.stderr.write(
-      `exe-os: WARNING Claude Code MCP name collision: ${c.serverName} exists in ${c.mcpJsonPath} and ~/.claude.json project ${c.projectPath}. Remove or rename the .mcp.json entry if tools do not surface.
-`
-    );
-  }
-  await registerExeRustMcpConfig(packageRoot, homeDir);
-  return true;
-}
-async function registerExeRustMcpConfig(packageRoot, homeDir) {
-  const exeDir = path7.join(homeDir, ".exe");
-  const exeMcpPath = path7.join(exeDir, "mcp.json");
-  await mkdir3(exeDir, { recursive: true });
-  let config = { servers: {} };
-  if (existsSync8(exeMcpPath)) {
-    try {
-      config = JSON.parse(await readFile3(exeMcpPath, "utf-8"));
-      if (!config.servers) config.servers = {};
-    } catch {
-      config = { servers: {} };
-    }
-  }
-  const stdioEntry = {
-    command: "node",
-    args: [path7.join(packageRoot, "dist", "mcp", "server.js")],
-    env: {},
-    shared: true
-  };
-  const existing = config.servers[MCP_PRIMARY_KEY];
-  if (existing && JSON.stringify(existing) === JSON.stringify(stdioEntry)) {
-    return;
-  }
-  if (config.servers[MCP_LEGACY_KEY]) {
-    delete config.servers[MCP_LEGACY_KEY];
-  }
-  config.servers[MCP_PRIMARY_KEY] = stdioEntry;
-  await writeFile3(exeMcpPath, JSON.stringify(config, null, 2) + "\n");
-  process.stderr.write("exe-os: registered MCP server in ~/.exe/mcp.json (Rust runtime)\n");
-}
-async function cleanSettingsJsonMcp(settingsPath) {
-  if (!existsSync8(settingsPath)) return;
-  try {
-    const settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
-    const servers = settings.mcpServers;
-    if (!servers) return;
-    let changed = false;
-    if (servers[MCP_PRIMARY_KEY]) {
-      delete servers[MCP_PRIMARY_KEY];
-      changed = true;
-    }
-    if (servers[MCP_LEGACY_KEY]) {
-      delete servers[MCP_LEGACY_KEY];
-      changed = true;
-    }
-    if (changed) {
-      await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-    }
-  } catch {
-  }
-}
-async function migratePermissionsToExeOs(settingsPath) {
-  if (!existsSync8(settingsPath)) return;
-  try {
-    const settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
-    const permissions = settings.permissions;
-    if (!permissions || !Array.isArray(permissions.allow)) return;
-    const allow = permissions.allow;
-    let migrated = 0;
-    for (let i = 0; i < allow.length; i++) {
-      if (allow[i].startsWith("mcp__exe-mem__")) {
-        const newName = allow[i].replace("mcp__exe-mem__", "mcp__exe-os__");
-        if (!allow.includes(newName)) {
-          allow[i] = newName;
-        } else {
-          allow[i] = "__REMOVE__";
-        }
-        migrated++;
-      }
-    }
-    if (migrated > 0) {
-      permissions.allow = allow.filter((e) => e !== "__REMOVE__");
-      permissions.allow = [...new Set(permissions.allow)];
-      await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-      process.stderr.write(`exe-os: migrated ${migrated} permission(s) from exe-mem \u2192 exe-os
-`);
-    }
-  } catch {
-  }
-}
-async function mergeHooks(packageRoot, homeDir = os6.homedir()) {
-  const settingsPath = path7.join(homeDir, ".claude", "settings.json");
-  const logsDir = path7.join(homeDir, ".exe-os", "logs");
-  const hookLogPath = path7.join(logsDir, "hooks.log");
-  const logSuffix = ` 2>> "${hookLogPath}"`;
-  await mkdir3(logsDir, { recursive: true });
-  let settings = {};
-  if (existsSync8(settingsPath)) {
-    try {
-      settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
-    } catch {
-      settings = {};
-    }
-  }
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (settings.hooks && typeof settings.hooks !== "object") {
-    console.warn("[exe-os] Unexpected hooks schema in settings.json \u2014 skipping hook installation");
-    return { added: 0, skipped: 0 };
-  }
-  const hooksToRegister = [
-    {
-      event: "PostToolUse",
-      group: {
-        matcher: "Bash|Edit|Write|Read|Glob|Grep|Agent|mcp__.*",
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "post-tool-combined.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.postToolCombined
-    },
-    {
-      event: "SessionStart",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
-            timeout: 1e4
-          }
-        ]
-      },
-      marker: EXE_HOOKS.sessionStart
-    },
-    {
-      event: "UserPromptSubmit",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.promptSubmit
-    },
-    {
-      event: "UserPromptSubmit",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
-            timeout: 5e3
-          }
-        ]
-      },
-      marker: EXE_HOOKS.heartbeat
-    },
-    {
-      event: "Stop",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.stop
-    },
-    {
-      event: "PreToolUse",
-      group: {
-        matcher: "Write|Edit|Read|Bash",
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.preToolUse
-    },
-    {
-      event: "SubagentStop",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "subagent-stop.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.subagentStop
-    },
-    {
-      event: "PreCompact",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "pre-compact.js")}"${logSuffix}`,
-            timeout: 1e4
-          }
-        ]
-      },
-      marker: EXE_HOOKS.preCompact
-    },
-    {
-      event: "SessionEnd",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "session-end.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.sessionEnd
-    },
-    {
-      event: "Notification",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "notification.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.notification
-    },
-    {
-      event: "PostCompact",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "post-compact.js")}"${logSuffix}`,
-            timeout: 1e4
-          }
-        ]
-      },
-      marker: EXE_HOOKS.postCompact
-    },
-    {
-      event: "InstructionsLoaded",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path7.join(packageRoot, "dist", "hooks", "instructions-loaded.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.instructionsLoaded
-    }
-  ];
-  let added = 0;
-  let skipped = 0;
-  for (const eventKey of Object.keys(settings.hooks)) {
-    const groups = settings.hooks[eventKey];
-    if (!Array.isArray(groups)) continue;
-    settings.hooks[eventKey] = groups.map((g) => ({
-      ...g,
-      hooks: g.hooks.filter((h) => !isLegacyHomeDirHookCommand(h.command))
-    })).filter((g) => g.hooks.length > 0);
-  }
-  const postToolGroups = settings.hooks["PostToolUse"];
-  if (Array.isArray(postToolGroups)) {
-    settings.hooks["PostToolUse"] = postToolGroups.map((g) => ({
-      ...g,
-      hooks: g.hooks.filter((h) => !isLegacySplitPostToolCommand(h.command))
-    })).filter((g) => g.hooks.length > 0);
-  }
-  for (const { event, group, marker } of hooksToRegister) {
-    if (!settings.hooks[event]) {
-      settings.hooks[event] = [];
-    }
-    if (!Array.isArray(settings.hooks[event])) {
-      console.warn(`[exe-os] Hook event "${event}" has unexpected structure \u2014 skipping`);
-      skipped++;
-      continue;
-    }
-    const existing = settings.hooks[event];
-    const correctCommand = group.hooks[0]?.command ?? "";
-    const alreadyCorrect = existing.some(
-      (g) => g.hooks.some((h) => h.command === correctCommand)
-    );
-    if (alreadyCorrect) {
-      skipped++;
-    } else {
-      settings.hooks[event] = existing.filter(
-        (g) => !g.hooks.some((h) => h.command.includes(marker))
-      );
-      settings.hooks[event].push(group);
-      added++;
-    }
-  }
-  const perms = settings.permissions;
-  if (!perms) {
-    settings.permissions = {};
-  }
-  const permissions = settings.permissions;
-  if (!Array.isArray(permissions.allow)) {
-    permissions.allow = [];
-  }
-  const toolNames = [
-    // Core memory
-    "store_memory",
-    "recall_my_memory",
-    "commit_to_long_term_memory",
-    "consolidate_memories",
-    "ask_team_memory",
-    "get_session_context",
-    // Tasks
-    "create_task",
-    "list_tasks",
-    "get_task",
-    "update_task",
-    "close_task",
-    "checkpoint_task",
-    // Behaviors
-    "store_behavior",
-    "deactivate_behavior",
-    "list_behaviors",
-    // Identity
-    "get_identity",
-    "update_identity",
-    // Messaging
-    "send_message",
-    "acknowledge_messages",
-    "send_whatsapp",
-    "query_conversations",
-    // Reminders + triggers
-    "create_reminder",
-    "complete_reminder",
-    "list_reminders",
-    "create_trigger",
-    "list_triggers",
-    // GraphRAG
-    "query_relationships",
-    "merge_entities",
-    // Documents + wiki
-    "ingest_document",
-    "list_documents",
-    "purge_document",
-    "rerank_documents",
-    "set_document_importance",
-    "get_wiki_page",
-    "list_wiki_pages",
-    // System
-    "load_skill",
-    "apply_starter_pack",
-    "resume_employee",
-    "deploy_client"
-  ];
-  const allowList = permissions.allow;
-  for (const name of toolNames) {
-    const fullName = `mcp__${MCP_PRIMARY_KEY}__${name}`;
-    if (!allowList.includes(fullName)) {
-      allowList.push(fullName);
-    }
-  }
-  await mkdir3(path7.dirname(settingsPath), { recursive: true });
-  await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-  return { added, skipped };
-}
-async function cleanOldShellFunctions(homeDir = os6.homedir()) {
-  const rosterPath = path7.join(homeDir, ".exe-os", "exe-employees.json");
-  if (!existsSync8(rosterPath)) return 0;
-  let employees;
-  try {
-    employees = JSON.parse(await readFile3(rosterPath, "utf-8"));
-  } catch {
-    return 0;
-  }
-  if (employees.length === 0) return 0;
-  const names = employees.map((e) => e.name);
-  const funcPatterns = names.map((n) => {
-    const funcDef = new RegExp(`^\\s*(function\\s+)?${escapeRegExp(n)}\\d+\\s*\\(\\)`, "m");
-    const forLoop = new RegExp(`${escapeRegExp(n)}\\$\\{?[a-zA-Z_][a-zA-Z0-9_]*\\}?`, "m");
-    return { name: n, funcDef, forLoop };
-  });
-  const rcFiles = [
-    path7.join(homeDir, ".zshrc"),
-    path7.join(homeDir, ".bashrc")
-  ];
-  const REMOVED_MARKER = "# Removed by exe-os \u2014 wrappers now at ~/.exe-os/bin/";
-  let totalRemoved = 0;
-  for (const rcPath of rcFiles) {
-    if (!existsSync8(rcPath)) continue;
-    let content;
-    try {
-      content = await readFile3(rcPath, "utf-8");
-    } catch {
-      continue;
-    }
-    if (content.includes(REMOVED_MARKER)) continue;
-    const lines = content.split("\n");
-    let changed = false;
-    let inForLoop = false;
-    let forLoopMatchesEmployee = false;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-      if (trimmed.startsWith("#")) continue;
-      if (/^\s*for\s+/.test(trimmed)) {
-        inForLoop = true;
-        forLoopMatchesEmployee = false;
-        for (const { forLoop } of funcPatterns) {
-          if (forLoop.test(trimmed)) {
-            forLoopMatchesEmployee = true;
-            break;
-          }
-        }
-        if (forLoopMatchesEmployee) {
-          lines[i] = `${REMOVED_MARKER}
-# ${line}`;
-          changed = true;
-          totalRemoved++;
-          continue;
-        }
-      }
-      if (inForLoop) {
-        if (!forLoopMatchesEmployee) {
-          for (const { forLoop } of funcPatterns) {
-            if (forLoop.test(trimmed)) {
-              forLoopMatchesEmployee = true;
-              for (let j = i - 1; j >= 0; j--) {
-                if (/^\s*for\s+/.test(lines[j].replace(/^#\s*/, ""))) {
-                  if (!lines[j].startsWith("#")) {
-                    lines[j] = `${REMOVED_MARKER}
-# ${lines[j]}`;
-                    totalRemoved++;
-                  }
-                  break;
-                }
-              }
-              break;
-            }
-          }
-        }
-        if (forLoopMatchesEmployee && !trimmed.startsWith("#")) {
-          lines[i] = `# ${line}`;
-          changed = true;
-          totalRemoved++;
-        }
-        if (trimmed === "done" || trimmed.startsWith("done;") || trimmed.startsWith("done ")) {
-          inForLoop = false;
-          forLoopMatchesEmployee = false;
-        }
-        continue;
-      }
-      for (const { funcDef } of funcPatterns) {
-        if (funcDef.test(trimmed)) {
-          lines[i] = `${REMOVED_MARKER}
-# ${line}`;
-          changed = true;
-          totalRemoved++;
-          let braceDepth = 0;
-          const hasBrace = trimmed.includes("{");
-          if (hasBrace) braceDepth = 1;
-          for (let j = i + 1; j < lines.length; j++) {
-            const bodyLine = lines[j].trim();
-            if (!hasBrace && braceDepth === 0) {
-              if (bodyLine === "{") {
-                braceDepth = 1;
-                lines[j] = `# ${lines[j]}`;
-                totalRemoved++;
-                continue;
-              }
-            }
-            if (braceDepth > 0) {
-              braceDepth += (bodyLine.match(/{/g) ?? []).length;
-              braceDepth -= (bodyLine.match(/}/g) ?? []).length;
-              lines[j] = `# ${lines[j]}`;
-              totalRemoved++;
-              if (braceDepth <= 0) break;
-            }
-          }
-          break;
-        }
-      }
-    }
-    if (changed) {
-      await writeFile3(rcPath, lines.join("\n"));
-    }
-  }
-  return totalRemoved;
-}
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-async function injectOrchestrationRules(homeDir) {
-  const claudeDir = path7.join(homeDir, ".claude");
-  const claudeMdPath = path7.join(claudeDir, "CLAUDE.md");
-  await mkdir3(claudeDir, { recursive: true });
-  let existing = "";
-  try {
-    existing = await readFile3(claudeMdPath, "utf-8");
-  } catch {
-  }
-  const startIdx = existing.indexOf(EXE_SECTION_START);
-  const endIdx = existing.indexOf(EXE_SECTION_END);
-  if (startIdx !== -1 && endIdx !== -1) {
-    const currentSection = existing.slice(startIdx, endIdx + EXE_SECTION_END.length);
-    if (currentSection === ORCHESTRATION_RULES) {
-      return "unchanged";
-    }
-    const updated = existing.slice(0, startIdx) + ORCHESTRATION_RULES + existing.slice(endIdx + EXE_SECTION_END.length);
-    await writeFile3(claudeMdPath, updated, "utf-8");
-    return "updated";
-  }
-  const separator = existing.length > 0 && !existing.endsWith("\n\n") ? "\n\n" : "";
-  await writeFile3(claudeMdPath, existing + separator + ORCHESTRATION_RULES + "\n", "utf-8");
-  return "injected";
-}
-async function installStatusLine(packageRoot, homeDir = os6.homedir()) {
-  const prefs = loadPreferences(homeDir);
-  if (prefs.ccStatusLine === false) return "opted-out";
-  const claudeDir = path7.join(homeDir, ".claude");
-  await mkdir3(claudeDir, { recursive: true });
-  const assetPath = path7.join(packageRoot, "dist", "assets", "statusline-command.sh");
-  if (!existsSync8(assetPath)) return "asset-missing";
-  const destScript = path7.join(claudeDir, "statusline-command.sh");
-  const assetContent = await readFile3(assetPath, "utf-8");
-  await writeFile3(destScript, assetContent, { mode: 493 });
-  const settingsPath = path7.join(claudeDir, "settings.json");
-  let settings = {};
-  if (existsSync8(settingsPath)) {
-    try {
-      settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
-    } catch {
-      settings = {};
-    }
-  }
-  if (settings.statusLine) return "already-configured";
-  settings.statusLine = {
-    type: "command",
-    command: `bash ${destScript}`
-  };
-  await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-  return "installed";
-}
-async function runInstaller(homeDir) {
-  const packageRoot = resolvePackageRoot();
-  process.stderr.write(`exe-os installer v1.3.0
-`);
-  process.stderr.write(`Package root: ${packageRoot}
-
-`);
-  const cmdResult = await copySlashCommands(packageRoot, homeDir);
-  process.stderr.write(
-    `Slash commands: ${cmdResult.copied} copied, ${cmdResult.skipped} unchanged
-`
-  );
-  const mcpChanged = await registerMcpServer(packageRoot, homeDir);
-  process.stderr.write(
-    `MCP server: ${mcpChanged ? "registered" : "already registered"}
-`
-  );
-  const hookResult = await mergeHooks(packageRoot, homeDir);
-  process.stderr.write(
-    `Hooks: ${hookResult.added} added, ${hookResult.skipped} unchanged
-`
-  );
-  const resolvedHome = homeDir ?? os6.homedir();
-  const exeWorkspace = path7.join(resolvedHome, "exe");
-  if (!existsSync8(exeWorkspace)) {
-    try {
-      await mkdir3(path7.join(exeWorkspace, "content"), { recursive: true });
-      await mkdir3(path7.join(exeWorkspace, "operations"), { recursive: true });
-      await mkdir3(path7.join(exeWorkspace, "output"), { recursive: true });
-      process.stderr.write(
-        `Created ~/exe/ \u2014 your automation workspace for non-code projects
-`
-      );
-    } catch {
-    }
-  }
-  const claudeMdResult = await injectOrchestrationRules(resolvedHome);
-  process.stderr.write(
-    `CLAUDE.md orchestration: ${claudeMdResult}
-`
-  );
-  const symlinkResults = await ensureAllAgentSymlinks(resolvedHome);
-  process.stderr.write(
-    `Agent symlinks: ${summarizeSymlinkResults(symlinkResults)}
-`
-  );
-  const statusLineResult = await installStatusLine(packageRoot, resolvedHome);
-  process.stderr.write(
-    `Status line: ${statusLineResult}
-`
-  );
-  const shellFuncsCleaned = await cleanOldShellFunctions(resolvedHome);
-  if (shellFuncsCleaned > 0) {
-    process.stderr.write(
-      `Shell cleanup: removed ${shellFuncsCleaned} old shell function(s) that were shadowing exe-os wrappers
-`
-    );
-  }
-  process.stderr.write(`
-exe-os installed successfully.
-`);
-}
-function setupTmux(home) {
-  const homeDir = home ?? os6.homedir();
-  const exeDir = path7.join(homeDir, ".exe-os");
-  const exeTmuxConf = path7.join(exeDir, "tmux.conf");
-  const userTmuxConf = path7.join(homeDir, ".tmux.conf");
-  const backupPath = path7.join(homeDir, ".tmux.conf.backup");
-  const sourceLine = "source-file ~/.exe-os/tmux.conf";
-  const pkgRoot = resolvePackageRoot();
-  const assetPath = path7.join(pkgRoot, "dist", "assets", "tmux.conf");
-  if (!existsSync8(assetPath)) {
-    process.stderr.write(`exe-os: tmux.conf asset not found at ${assetPath} \u2014 skipping tmux setup
-`);
-    return;
-  }
-  mkdirSync4(exeDir, { recursive: true });
-  if (existsSync8(exeTmuxConf)) {
-    const currentContent = readFileSync6(exeTmuxConf, "utf8");
-    const newContent = readFileSync6(assetPath, "utf8");
-    const currentHash = createHash("sha256").update(currentContent).digest("hex");
-    const newHash = createHash("sha256").update(newContent).digest("hex");
-    if (currentHash !== newHash) {
-      const shippedPath = path7.join(exeDir, ".tmux.conf.shipped-hash");
-      const lastShippedHash = existsSync8(shippedPath) ? readFileSync6(shippedPath, "utf8").trim() : "";
-      if (lastShippedHash && currentHash !== lastShippedHash) {
-        process.stderr.write("exe-os: tmux config has user customizations \u2014 skipping overwrite\n");
-      } else {
-        copyFileSync(assetPath, exeTmuxConf);
-        process.stderr.write("exe-os: tmux config updated\n");
-      }
-      writeFileSync5(shippedPath, newHash, "utf8");
-    } else {
-      process.stderr.write("exe-os: tmux config already up to date\n");
-    }
-  } else {
-    copyFileSync(assetPath, exeTmuxConf);
-    const newContent = readFileSync6(assetPath, "utf8");
-    const newHash = createHash("sha256").update(newContent).digest("hex");
-    writeFileSync5(path7.join(exeDir, ".tmux.conf.shipped-hash"), newHash, "utf8");
-  }
-  if (existsSync8(userTmuxConf)) {
-    const existing = readFileSync6(userTmuxConf, "utf8");
-    if (!existing.includes(sourceLine)) {
-      if (!existsSync8(backupPath)) {
-        copyFileSync(userTmuxConf, backupPath);
-        process.stderr.write(`exe-os: backed up existing tmux config to ${backupPath}
-`);
-      }
-      writeFileSync5(userTmuxConf, `${sourceLine}
-${existing}`);
-    }
-  } else {
-    writeFileSync5(userTmuxConf, `# Exe OS tmux defaults \u2014 remove this line to use your own config
-${sourceLine}
-`);
-  }
-  try {
-    execSync2(`tmux source-file ${exeTmuxConf} 2>/dev/null`);
-  } catch {
-  }
-  process.stderr.write("exe-os: tmux config installed\n");
-}
-function setupGhostty(home) {
-  const homeDir = home ?? os6.homedir();
-  const xdgConfig = path7.join(homeDir, ".config", "ghostty");
-  const macConfig = path7.join(homeDir, "Library", "Application Support", "com.mitchellh.ghostty");
-  const ghosttyInstalled = existsSync8(xdgConfig) || existsSync8(macConfig) || (() => {
-    try {
-      execSync2("which ghostty 2>/dev/null");
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  if (!ghosttyInstalled) {
-    return;
-  }
-  const pkgRoot = resolvePackageRoot();
-  const assetPath = path7.join(pkgRoot, "dist", "assets", "ghostty.conf");
-  if (!existsSync8(assetPath)) {
-    process.stderr.write("exe-os: ghostty.conf asset not found \u2014 skipping Ghostty setup\n");
-    return;
-  }
-  const configDir = xdgConfig;
-  const configPath = path7.join(configDir, "config");
-  const backupPath = path7.join(configDir, "config.backup");
-  mkdirSync4(configDir, { recursive: true });
-  const START_MARKER = "# \u2500\u2500 exe-os:ghostty-start \u2500\u2500";
-  const END_MARKER = "# \u2500\u2500 exe-os:ghostty-end \u2500\u2500";
-  const assetContent = readFileSync6(assetPath, "utf8").trim();
-  const markedSection = `${START_MARKER}
-${assetContent}
-${END_MARKER}`;
-  if (existsSync8(configPath)) {
-    const existing = readFileSync6(configPath, "utf8");
-    if (existing.includes(START_MARKER) && existing.includes(END_MARKER)) {
-      process.stderr.write("exe-os: Ghostty config already installed \u2014 preserving local settings\n");
-      return;
-    } else if (existing.includes("Exe OS")) {
-      if (!existsSync8(backupPath)) {
-        copyFileSync(configPath, backupPath);
-        process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
-`);
-      }
-      writeFileSync5(configPath, `${START_MARKER}
-${existing.trim()}
-${END_MARKER}
-`);
-    } else {
-      if (!existsSync8(backupPath)) {
-        copyFileSync(configPath, backupPath);
-        process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
-`);
-      }
-      writeFileSync5(configPath, `${markedSection}
-
-${existing}`);
-    }
-  } else {
-    writeFileSync5(configPath, `${markedSection}
-`);
-  }
-  process.stderr.write("exe-os: Ghostty config installed\n");
-}
-function summarizeSymlinkResults(results) {
-  if (results.length === 0) return "no employees in roster";
-  const created = results.filter((r) => r.action === "created").length;
-  const already = results.filter((r) => r.action === "already_correct").length;
-  const conflicts = results.filter((r) => r.action === "conflict");
-  let summary = `${created} created, ${already} already linked`;
-  if (conflicts.length > 0) {
-    const details = conflicts.map((r) => `${r.agentId} (${r.conflict ?? "unknown"})`).join(", ");
-    summary += `, ${conflicts.length} conflict(s): ${details}`;
-  }
-  return summary;
-}
-var EXE_SECTION_START, EXE_SECTION_END, ORCHESTRATION_RULES;
-var init_installer = __esm({
-  "src/adapters/claude/installer.ts"() {
-    "use strict";
-    init_agent_symlinks();
-    init_mcp_prefix();
-    init_preferences();
-    init_mcp_http_config();
-    init_runtime_hook_manifest();
-    EXE_SECTION_START = "<!-- exe-os:orchestration-start -->";
-    EXE_SECTION_END = "<!-- exe-os:orchestration-end -->";
-    ORCHESTRATION_RULES = `${EXE_SECTION_START}
-## exe-os Multi-Agent Orchestration (auto-managed \u2014 do not edit)
-
-These rules are injected by exe-os and override default behavior for multi-agent coordination.
-
-- **Session routing is deterministic.** When working in a coordinator session, ALL employee sessions use that same coordinator-session suffix. NEVER reference, consider, or dispatch to employee sessions from other project sessions. This is not a choice \u2014 it is a hard constraint.
-- **Always use create_task to assign work.** Never use messages, tmux send-keys, or ad-hoc instructions as a substitute for tasks.
-- **Never modify another agent's in-progress task.** Create a new task instead. Modifying active tasks causes race conditions.
-- **Chain of command:** founder -> coordinator/executive agent (internal routing slot may be "COO") -> managers -> specialists. The coordinator does not bypass managers for specialist work. Internal role labels are plumbing, not user-facing titles.
-- **Verify dispatch.** After every create_task, confirm the employee received and started the task via tmux capture-pane.
-${EXE_SECTION_END}`;
-  }
-});
-
-// src/adapters/codex/installer.ts
-var installer_exports = {};
-__export(installer_exports, {
-  ensureCodexHooksFeature: () => ensureCodexHooksFeature,
-  installCodexStatusLine: () => installCodexStatusLine,
-  mergeCodexHooks: () => mergeCodexHooks,
-  registerCodexMcpServer: () => registerCodexMcpServer,
-  runCodexInstaller: () => runCodexInstaller,
-  verifyCodexHooks: () => verifyCodexHooks
-});
-import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import path9 from "path";
-import os7 from "os";
-async function mergeCodexHooks(packageRoot, homeDir = os7.homedir()) {
-  const codexDir = path9.join(homeDir, ".codex");
-  const hooksPath = path9.join(codexDir, "hooks.json");
-  const logsDir = path9.join(homeDir, ".exe-os", "logs");
-  const hookLogPath = path9.join(logsDir, "hooks.log");
-  const logSuffix = ` 2>> "${hookLogPath}"`;
-  await mkdir4(codexDir, { recursive: true });
-  await mkdir4(logsDir, { recursive: true });
-  let hooksJson = {};
-  if (existsSync10(hooksPath)) {
-    try {
-      hooksJson = JSON.parse(await readFile4(hooksPath, "utf-8"));
-    } catch {
-      hooksJson = {};
-    }
-  }
-  if (!hooksJson.hooks) {
-    hooksJson.hooks = {};
-  }
-  const hooksToRegister = [
-    {
-      event: "PostToolUse",
-      group: {
-        matcher: "Bash|apply_patch|Edit|Write|Read|Glob|Grep|mcp__.*",
-        hooks: [
-          {
-            // Combined hook: runs ingest + error-recall in one Node process.
-            // Eliminates a cold-start cycle per tool call (~3-6s savings on Codex).
-            type: "command",
-            command: `node "${path9.join(packageRoot, "dist", "hooks", "post-tool-combined.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.postToolCombined
-    },
-    {
-      event: "UserPromptSubmit",
-      group: {
-        hooks: [
-          {
-            // Single hook: prompt-submit handles memory retrieval + entity boost.
-            // exe-heartbeat-hook is CC-specific (intercom) — omitted on Codex.
-            type: "command",
-            command: `node "${path9.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.promptSubmit
-    },
-    {
-      event: "Stop",
-      group: {
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path9.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.stop
-    },
-    {
-      event: "PreToolUse",
-      group: {
-        matcher: "Bash|apply_patch",
-        hooks: [
-          {
-            type: "command",
-            command: `node "${path9.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
-          }
-        ]
-      },
-      marker: EXE_HOOKS.preToolUse
-    }
-  ];
-  let added = 0;
-  let skipped = 0;
-  const sessionStartGroups = hooksJson.hooks["SessionStart"];
-  if (Array.isArray(sessionStartGroups)) {
-    hooksJson.hooks["SessionStart"] = sessionStartGroups.map((g) => ({
-      ...g,
-      hooks: g.hooks.filter((h) => !h.command.includes(EXE_HOOKS.sessionStart))
-    })).filter((g) => g.hooks.length > 0);
-    if (hooksJson.hooks["SessionStart"].length === 0) {
-      delete hooksJson.hooks["SessionStart"];
-    }
-  }
-  const postToolGroups = hooksJson.hooks["PostToolUse"];
-  if (Array.isArray(postToolGroups)) {
-    hooksJson.hooks["PostToolUse"] = postToolGroups.map((g) => ({
-      ...g,
-      hooks: g.hooks.filter((h) => !isLegacySplitPostToolCommand(h.command))
-    })).filter((g) => g.hooks.length > 0);
-  }
-  for (const { event, group, marker } of hooksToRegister) {
-    if (!hooksJson.hooks[event]) {
-      hooksJson.hooks[event] = [];
-    }
-    const existing = hooksJson.hooks[event];
-    const correctCommand = group.hooks[0]?.command ?? "";
-    const alreadyCorrect = existing.some(
-      (g) => g.hooks.some((h) => h.command === correctCommand)
-    );
-    if (alreadyCorrect) {
-      skipped++;
-    } else {
-      hooksJson.hooks[event] = existing.filter(
-        (g) => !g.hooks.some((h) => h.command.includes(marker))
-      );
-      hooksJson.hooks[event].push(group);
-      added++;
-    }
-  }
-  await writeFile4(hooksPath, JSON.stringify(hooksJson, null, 2) + "\n");
-  return { added, skipped };
-}
-function verifyCodexHooks(homeDir = os7.homedir()) {
-  const hooksPath = path9.join(homeDir, ".codex", "hooks.json");
-  if (!existsSync10(hooksPath)) return false;
-  try {
-    const hooksJson = JSON.parse(readFileSync8(hooksPath, "utf-8"));
-    if (!hooksJson.hooks) return false;
-    const required = ["PostToolUse", "UserPromptSubmit", "Stop", "PreToolUse"];
-    for (const event of required) {
-      const groups = hooksJson.hooks[event];
-      if (!groups || !groups.some(
-        (g) => g.hooks.some((h) => h.command.includes("dist/hooks/"))
-      )) {
-        return false;
-      }
-    }
-    const postToolCommands = (hooksJson.hooks.PostToolUse ?? []).flatMap((g) => g.hooks.map((h) => h.command));
-    if (!postToolCommands.some((cmd) => cmd.includes(EXE_HOOKS.postToolCombined))) {
-      return false;
-    }
-    if (postToolCommands.some(
-      (cmd) => isLegacySplitPostToolCommand(cmd)
-    )) {
-      return false;
-    }
-    const sessionStartCommands = (hooksJson.hooks.SessionStart ?? []).flatMap((g) => g.hooks.map((h) => h.command));
-    if (sessionStartCommands.some((cmd) => cmd.includes(EXE_HOOKS.sessionStart))) {
-      return false;
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function installCodexStatusLine(homeDir = os7.homedir()) {
-  const prefs = loadPreferences(homeDir);
-  if (prefs.codexStatusLine === false) return "opted-out";
-  const codexDir = path9.join(homeDir, ".codex");
-  const configPath = path9.join(codexDir, "config.toml");
-  await mkdir4(codexDir, { recursive: true });
-  let content = "";
-  if (existsSync10(configPath)) {
-    content = await readFile4(configPath, "utf-8");
-    if (/\[tui\][\s\S]*?status_line\s*=/.test(content)) {
-      return "already-configured";
-    }
-  }
-  const statusLineToml = `[tui]
-status_line = [${DEFAULT_CODEX_STATUS_LINE.map((s) => `"${s}"`).join(", ")}]`;
-  if (content.includes("[tui]")) {
-    content = content.replace(/\[tui\]/, `${statusLineToml}`);
-  } else {
-    const separator = content.length > 0 && !content.endsWith("\n") ? "\n\n" : content.length > 0 ? "\n" : "";
-    content = content + separator + statusLineToml + "\n";
-  }
-  await writeFile4(configPath, content);
-  return "installed";
-}
-function tomlString(value) {
-  return JSON.stringify(value);
-}
-function codexHttpHeadersToml(homeDir) {
-  const headers = buildMcpHttpHeaders(homeDir);
-  return `{ ${Object.entries(headers).map(([key, value]) => `${tomlString(key)} = ${tomlString(value)}`).join(", ")} }`;
-}
-function desiredCodexMcpSection(homeDir) {
-  return [
-    "[mcp_servers.exe-os]",
-    `url = ${tomlString(mcpHttpUrl())}`,
-    `http_headers = ${codexHttpHeadersToml(homeDir)}`,
-    `startup_timeout_sec = ${CODEX_EXE_MCP_STARTUP_TIMEOUT_SEC}`,
-    `tool_timeout_sec = ${CODEX_EXE_MCP_TOOL_TIMEOUT_SEC}`,
-    ""
-  ].join("\n");
-}
-function reconcileCodexMcpSection(sectionContent, homeDir) {
-  const desiredLines = {
-    url: `url = ${tomlString(mcpHttpUrl())}`,
-    headers: `http_headers = ${codexHttpHeadersToml(homeDir)}`,
-    startup: `startup_timeout_sec = ${CODEX_EXE_MCP_STARTUP_TIMEOUT_SEC}`,
-    tool: `tool_timeout_sec = ${CODEX_EXE_MCP_TOOL_TIMEOUT_SEC}`
-  };
-  let next = sectionContent;
-  next = next.split("\n").filter((line) => !/^(command|args|env|type|url|http_headers|startup_timeout_sec|tool_timeout_sec)\s*=/.test(line.trim())).join("\n").replace(/\n{3,}/g, "\n\n");
-  for (const line of [desiredLines.url, desiredLines.headers, desiredLines.startup, desiredLines.tool]) {
-    next = next.endsWith("\n") ? `${next}${line}
-` : `${next}
-${line}
-`;
-  }
-  return { content: next, changed: next !== sectionContent };
-}
-async function registerCodexMcpServer(packageRoot, homeDir = os7.homedir()) {
-  const codexDir = path9.join(homeDir, ".codex");
-  const configPath = path9.join(codexDir, "config.toml");
-  void packageRoot;
-  await mkdir4(codexDir, { recursive: true });
-  let content = "";
-  if (existsSync10(configPath)) {
-    content = await readFile4(configPath, "utf-8");
-  }
-  const sectionHeader = "[mcp_servers.exe-os]";
-  const headerIndex = content.indexOf(sectionHeader);
-  if (headerIndex !== -1) {
-    const afterHeader = content.slice(headerIndex + sectionHeader.length);
-    const nextSectionMatch = afterHeader.match(/\n\[(?!mcp_servers\.exe-os)/);
-    const sectionEnd = nextSectionMatch ? headerIndex + sectionHeader.length + nextSectionMatch.index : content.length;
-    const sectionContent = content.slice(headerIndex, sectionEnd);
-    const reconciled = reconcileCodexMcpSection(sectionContent, homeDir);
-    if (!reconciled.changed) {
-      return "already-registered";
-    }
-    content = content.slice(0, headerIndex) + reconciled.content + content.slice(sectionEnd);
-    await writeFile4(configPath, content);
-    return "updated";
-  }
-  const newSection = desiredCodexMcpSection(homeDir);
-  const separator = content.length > 0 && !content.endsWith("\n") ? "\n\n" : content.length > 0 ? "\n" : "";
-  content = content + separator + newSection;
-  await writeFile4(configPath, content);
-  return "registered";
-}
-async function ensureCodexHooksFeature(homeDir = os7.homedir()) {
-  const configPath = path9.join(homeDir, ".codex", "config.toml");
-  await mkdir4(path9.join(homeDir, ".codex"), { recursive: true });
-  let content = "";
-  if (existsSync10(configPath)) {
-    content = await readFile4(configPath, "utf-8");
-  }
-  if (/\[features\][\s\S]*?codex_hooks\s*=\s*true/.test(content)) {
-    return "already-enabled";
-  }
-  if (content.includes("[features]")) {
-    if (/codex_hooks\s*=\s*false/.test(content)) {
-      content = content.replace(/codex_hooks\s*=\s*false/, "codex_hooks = true");
-    } else {
-      content = content.replace(/\[features\]/, "[features]\ncodex_hooks = true");
-    }
-  } else {
-    const firstSectionMatch = content.match(/\n\[(?!features\])/);
-    if (firstSectionMatch && firstSectionMatch.index != null) {
-      const insertAt = firstSectionMatch.index;
-      content = content.slice(0, insertAt) + "\n\n[features]\ncodex_hooks = true" + content.slice(insertAt);
-    } else {
-      const separator = content.length > 0 && !content.endsWith("\n") ? "\n\n" : "\n";
-      content = content + separator + "[features]\ncodex_hooks = true\n";
-    }
-  }
-  await writeFile4(configPath, content);
-  return "enabled";
-}
-async function runCodexInstaller(homeDir) {
-  const packageRoot = resolvePackageRoot();
-  const result = await mergeCodexHooks(packageRoot, homeDir);
-  process.stderr.write(
-    `[exe-os] Codex hooks: ${result.added} added, ${result.skipped} unchanged
-`
-  );
-  const featureResult = await ensureCodexHooksFeature(homeDir);
-  process.stderr.write(
-    `[exe-os] Codex hooks feature: ${featureResult}
-`
-  );
-  const mcpResult = await registerCodexMcpServer(packageRoot, homeDir);
-  process.stderr.write(
-    `[exe-os] Codex MCP server: ${mcpResult}
-`
-  );
-  const statusResult = await installCodexStatusLine(homeDir);
-  process.stderr.write(
-    `[exe-os] Codex status line: ${statusResult}
-`
-  );
-}
-var DEFAULT_CODEX_STATUS_LINE, CODEX_EXE_MCP_STARTUP_TIMEOUT_SEC, CODEX_EXE_MCP_TOOL_TIMEOUT_SEC;
-var init_installer2 = __esm({
-  "src/adapters/codex/installer.ts"() {
-    "use strict";
-    init_installer();
-    init_preferences();
-    init_runtime_hook_manifest();
-    init_mcp_http_config();
-    DEFAULT_CODEX_STATUS_LINE = [
-      "model-with-reasoning",
-      "current-dir",
-      "project-name",
-      "git-branch",
-      "run-state",
-      "context-used"
-    ];
-    CODEX_EXE_MCP_STARTUP_TIMEOUT_SEC = 30;
-    CODEX_EXE_MCP_TOOL_TIMEOUT_SEC = 120;
-  }
-});
-
-// src/bin/install.ts
-init_installer();
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, readdirSync as readdirSync2, openSync, closeSync } from "fs";
-import { spawn, execSync as execSync4 } from "child_process";
-import path10 from "path";
-import os8 from "os";
-
-// src/lib/session-wrappers.ts
+  copySlashCommands,
+  resolvePackageRoot,
+  runInstaller,
+  setupGhostty,
+  setupTmux
+} from "../chunk-BCMOO4OQ.js";
+import "../chunk-SPKE5ANC.js";
 import {
-  existsSync as existsSync9,
-  readFileSync as readFileSync7,
-  writeFileSync as writeFileSync6,
-  mkdirSync as mkdirSync5,
-  chmodSync as chmodSync3,
-  readdirSync,
-  unlinkSync as unlinkSync2
-} from "fs";
-import { execSync as execSync3 } from "child_process";
-import path8 from "path";
-import { homedir } from "os";
-var MAX_N = 9;
-function generateSessionWrappers(packageRoot, homeDir) {
-  const home = homeDir ?? homedir();
-  const binDir = path8.join(home, ".exe-os", "bin");
-  const rosterPath = path8.join(home, ".exe-os", "exe-employees.json");
-  const shouldMirrorToGlobalBin = homeDir === void 0;
-  mkdirSync5(binDir, { recursive: true });
-  const exeStartDst = path8.join(binDir, "exe-start");
-  const candidates = [
-    path8.join(packageRoot, "dist", "bin", "exe-start.sh"),
-    path8.join(packageRoot, "src", "bin", "exe-start.sh")
-  ];
-  for (const src of candidates) {
-    if (existsSync9(src)) {
-      writeFileSync6(exeStartDst, readFileSync7(src));
-      chmodSync3(exeStartDst, 493);
-      break;
-    }
-  }
-  let employees = [];
-  try {
-    employees = JSON.parse(readFileSync7(rosterPath, "utf8"));
-  } catch {
-    return { created: 0, pathConfigured: false };
-  }
-  if (employees.length === 0) {
-    return { created: 0, pathConfigured: false };
-  }
-  try {
-    for (const f of readdirSync(binDir)) {
-      if (f === "exe-start") continue;
-      const fPath = path8.join(binDir, f);
-      try {
-        const content = readFileSync7(fPath, "utf8");
-        if (content.includes("exe-start")) {
-          unlinkSync2(fPath);
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  let created = 0;
-  const wrapperContent = `#!/bin/bash
-exec "${exeStartDst}" "$0" "$@"
-`;
-  const globalBinDir = shouldMirrorToGlobalBin ? resolveGlobalBinDir() : null;
-  for (const emp of employees) {
-    for (let n = 1; n <= MAX_N; n++) {
-      writeWrapper(path8.join(binDir, `${emp.name}${n}`), wrapperContent);
-      if (globalBinDir) {
-        writeWrapper(path8.join(globalBinDir, `${emp.name}${n}`), wrapperContent);
-      }
-      created++;
-    }
-  }
-  const pathConfigured = ensurePath(home, binDir);
-  return { created, pathConfigured };
-}
-function writeWrapper(wrapperPath, content) {
-  try {
-    writeFileSync6(wrapperPath, content);
-    chmodSync3(wrapperPath, 493);
-  } catch {
-  }
-}
-function resolveGlobalBinDir() {
-  try {
-    const exeOsPath = execSync3("command -v exe-os", { encoding: "utf8", timeout: 3e3 }).trim().split("\n")[0];
-    if (exeOsPath) return path8.dirname(exeOsPath);
-  } catch {
-  }
-  try {
-    const prefix = execSync3("npm prefix -g", { encoding: "utf8", timeout: 3e3 }).trim();
-    if (prefix) return path8.join(prefix, "bin");
-  } catch {
-  }
-  return null;
-}
-function ensurePath(home, binDir) {
-  if (process.env.PATH?.split(":").includes(binDir)) {
-    return false;
-  }
-  const exportLine = `
-# exe-os session commands
-export PATH="${binDir}:$PATH"
-`;
-  const shell = process.env.SHELL ?? "/bin/bash";
-  const profilePaths = [];
-  if (shell.includes("zsh")) {
-    profilePaths.push(path8.join(home, ".zshrc"));
-  } else if (shell.includes("bash")) {
-    profilePaths.push(path8.join(home, ".bashrc"));
-    profilePaths.push(path8.join(home, ".bash_profile"));
-  } else {
-    profilePaths.push(path8.join(home, ".profile"));
-  }
-  for (const profilePath of profilePaths) {
-    try {
-      let content = "";
-      try {
-        content = readFileSync7(profilePath, "utf8");
-      } catch {
-      }
-      if (content.includes(".exe-os/bin")) {
-        return false;
-      }
-      writeFileSync6(profilePath, content + exportLine);
-      return true;
-    } catch {
-      continue;
-    }
-  }
-  return false;
-}
+  generateSessionWrappers
+} from "../chunk-MLCUPTP7.js";
+import "../chunk-L3TB7CC3.js";
+import "../chunk-OFK72LTZ.js";
+import "../chunk-6BFIFI5F.js";
+import "../chunk-RUG3N6P4.js";
+import "../chunk-KVPG5UT6.js";
+import "../chunk-X2IMCCM5.js";
+import "../chunk-KFQGP6VL.js";
 
 // src/bin/install.ts
-var homedir2 = os8.homedir;
-var EXE_DIR = path10.join(homedir2(), ".exe-os");
+import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, openSync, closeSync } from "fs";
+import { spawn, execSync } from "child_process";
+import path from "path";
+import os from "os";
+var homedir = os.homedir;
+var EXE_DIR = path.join(homedir(), ".exe-os");
 function restartDaemon() {
-  const pidPath = path10.join(EXE_DIR, "exed.pid");
-  const sockPath = path10.join(EXE_DIR, "exed.sock");
+  const pidPath = path.join(EXE_DIR, "exed.pid");
+  const sockPath = path.join(EXE_DIR, "exed.sock");
   try {
-    if (existsSync11(pidPath)) {
-      const pid = parseInt(readFileSync9(pidPath, "utf8").trim(), 10);
+    if (existsSync(pidPath)) {
+      const pid = parseInt(readFileSync(pidPath, "utf8").trim(), 10);
       if (!isNaN(pid) && pid > 0) {
         try {
           process.kill(pid, "SIGKILL");
@@ -2313,16 +38,16 @@ function restartDaemon() {
         }
       }
       try {
-        unlinkSync3(pidPath);
+        unlinkSync(pidPath);
       } catch {
       }
       try {
-        unlinkSync3(pidPath + ".lock");
+        unlinkSync(pidPath + ".lock");
       } catch {
       }
     }
     try {
-      const pids = execSync4("pgrep -f 'exe-daemon.js' 2>/dev/null || true", { encoding: "utf8" }).trim().split("\n").filter(Boolean).map(Number).filter((n) => !isNaN(n) && n !== process.pid);
+      const pids = execSync("pgrep -f 'exe-daemon.js' 2>/dev/null || true", { encoding: "utf8" }).trim().split("\n").filter(Boolean).map(Number).filter((n) => !isNaN(n) && n !== process.pid);
       for (const pid of pids) {
         try {
           process.kill(pid, "SIGKILL");
@@ -2336,7 +61,7 @@ function restartDaemon() {
     } catch {
     }
     try {
-      const pids = execSync4("pgrep -f 'backfill-vectors.js' 2>/dev/null || true", { encoding: "utf8" }).trim().split("\n").filter(Boolean).map(Number).filter((n) => !isNaN(n) && n !== process.pid);
+      const pids = execSync("pgrep -f 'backfill-vectors.js' 2>/dev/null || true", { encoding: "utf8" }).trim().split("\n").filter(Boolean).map(Number).filter((n) => !isNaN(n) && n !== process.pid);
       for (const pid of pids) {
         try {
           process.kill(pid, "SIGKILL");
@@ -2350,18 +75,18 @@ function restartDaemon() {
     } catch {
     }
     try {
-      const versionPath = path10.join(EXE_DIR, "mcp-version");
-      writeFileSync7(versionPath, `deploy-${Date.now()}`);
+      const versionPath = path.join(EXE_DIR, "mcp-version");
+      writeFileSync(versionPath, `deploy-${Date.now()}`);
       process.stderr.write(`exe-os: MCP version marker updated \u2014 servers will hot-reload within 10s
 `);
     } catch {
     }
     try {
-      const wpDir = path10.join(EXE_DIR, "worker-pids");
-      if (existsSync11(wpDir)) {
-        for (const f of readdirSync2(wpDir)) {
+      const wpDir = path.join(EXE_DIR, "worker-pids");
+      if (existsSync(wpDir)) {
+        for (const f of readdirSync(wpDir)) {
           try {
-            unlinkSync3(path10.join(wpDir, f));
+            unlinkSync(path.join(wpDir, f));
           } catch {
           }
         }
@@ -2369,16 +94,16 @@ function restartDaemon() {
     } catch {
     }
     try {
-      unlinkSync3(sockPath);
+      unlinkSync(sockPath);
     } catch {
     }
     try {
-      execSync4("sleep 0.5");
+      execSync("sleep 0.5");
     } catch {
     }
   } catch {
   }
-  const totalGB = os8.totalmem() / (1024 * 1024 * 1024);
+  const totalGB = os.totalmem() / (1024 * 1024 * 1024);
   if (totalGB <= 8) {
     process.stderr.write(
       `exe-os: ${totalGB.toFixed(0)}GB system \u2014 skipping daemon spawn (keyword search mode)
@@ -2388,13 +113,13 @@ function restartDaemon() {
   }
   try {
     const pkgRoot = resolvePackageRoot();
-    const daemonPath = path10.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-    if (!existsSync11(daemonPath)) {
+    const daemonPath = path.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+    if (!existsSync(daemonPath)) {
       process.stderr.write(`exe-os: daemon not found at ${daemonPath} \u2014 skipping respawn
 `);
       return;
     }
-    const logPath = path10.join(EXE_DIR, "exed.log");
+    const logPath = path.join(EXE_DIR, "exed.log");
     let stderrFd = "ignore";
     try {
       stderrFd = openSync(logPath, "a");
@@ -2444,8 +169,8 @@ if (args.includes("--commands-only")) {
     setupTmux();
     setupGhostty();
     try {
-      const { normalizeRosterCase: normalizeRosterCase2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
-      const changed = await normalizeRosterCase2();
+      const { normalizeRosterCase } = await import("../lib/employees.js");
+      const changed = await normalizeRosterCase();
       if (changed) {
         process.stderr.write("exe-os: normalized employee names to lowercase\n");
       }
@@ -2467,9 +192,9 @@ if (args.includes("--commands-only")) {
 `);
     }
     try {
-      execSync4("which codex", { encoding: "utf8", timeout: 5e3 });
-      const { runCodexInstaller: runCodexInstaller2 } = await Promise.resolve().then(() => (init_installer2(), installer_exports));
-      await runCodexInstaller2();
+      execSync("which codex", { encoding: "utf8", timeout: 5e3 });
+      const { runCodexInstaller } = await import("../installer-ZPQUKHU5.js");
+      await runCodexInstaller();
     } catch {
     }
     restartDaemon();