@askexenow/exe-os 0.9.276 → 0.9.277

package/dist/chunk-TPSLW46F.js

@@ -0,0 +1,1068 @@
+import {
+  loadPreferences
+} from "./chunk-GNHN5HRQ.js";
+import {
+  EXE_HOOKS,
+  isLegacyHomeDirHookCommand,
+  isLegacySplitPostToolCommand
+} from "./chunk-L3TB7CC3.js";
+import {
+  buildClaudeHttpMcpEntry
+} from "./chunk-V75SLGIH.js";
+import {
+  ensureAllAgentSymlinks
+} from "./chunk-4H4HKOE4.js";
+import {
+  MCP_LEGACY_KEY,
+  MCP_PRIMARY_KEY
+} from "./chunk-HYZV25LY.js";
+
+// src/adapters/claude/installer.ts
+import { readFile, writeFile, mkdir, readdir, rm } from "fs/promises";
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync } from "fs";
+import { createHash } from "crypto";
+import path from "path";
+import os from "os";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+function resolvePackageRoot() {
+  const thisFile = fileURLToPath(import.meta.url);
+  let dir = path.dirname(thisFile);
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
+      } catch {
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return path.resolve(path.dirname(thisFile), "..", "..", "..");
+}
+async function copySlashCommands(packageRoot, homeDir = os.homedir()) {
+  let copied = 0;
+  let skipped = 0;
+  const skillsBase = path.join(homeDir, ".claude", "skills");
+  const deprecatedExeLink = path.join(skillsBase, "exe-link");
+  if (existsSync(deprecatedExeLink)) {
+    await rm(deprecatedExeLink, { recursive: true, force: true });
+  }
+  const exeDir = path.join(packageRoot, "src", "commands", "exe");
+  if (existsSync(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 = path.join(skillsBase, `exe-${name}`);
+      await mkdir(destDir, { recursive: true });
+      const srcPath = path.join(exeDir, file);
+      const destPath = path.join(destDir, "SKILL.md");
+      const result = await copyAsSkill(srcPath, destPath, `exe-${name}`);
+      if (result) copied++;
+      else skipped++;
+    }
+  }
+  const topLevelSrc = path.join(packageRoot, "src", "commands", "exe.md");
+  if (existsSync(topLevelSrc)) {
+    const destDir = path.join(skillsBase, "exe");
+    await mkdir(destDir, { recursive: true });
+    const destPath = path.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 readFile(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 (existsSync(destPath)) {
+    const existing = await readFile(destPath, "utf-8");
+    if (existing === content) return false;
+  }
+  await writeFile(destPath, content);
+  return true;
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function findAncestorMcpJsons(startDir, homeDir) {
+  const files = [];
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+  const stop = path.resolve(homeDir);
+  while (dir !== root) {
+    const candidate = path.join(dir, ".mcp.json");
+    if (existsSync(candidate)) files.push(candidate);
+    if (dir === stop) break;
+    dir = path.dirname(dir);
+  }
+  return files;
+}
+function pathApplies(projectPath, cwd) {
+  const project = path.resolve(projectPath);
+  const current = path.resolve(cwd);
+  return current === project || current.startsWith(project + path.sep);
+}
+function detectMcpNameCollisions(homeDir = os.homedir(), cwd = process.cwd()) {
+  const claudeJsonPath = path.join(homeDir, ".claude.json");
+  if (!existsSync(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: [path.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 = os.totalmem() / (1024 * 1024 * 1024);
+  if (totalGB <= 8) return "stdio";
+  return "http";
+}
+async function registerMcpServer(packageRoot, homeDir = os.homedir()) {
+  const claudeJsonPath = path.join(homeDir, ".claude.json");
+  let claudeJson = {};
+  if (existsSync(claudeJsonPath)) {
+    try {
+      claudeJson = JSON.parse(await readFile(claudeJsonPath, "utf-8"));
+    } catch {
+      claudeJson = {};
+    }
+  }
+  if (!claudeJson.mcpServers) {
+    claudeJson.mcpServers = {};
+  }
+  const newEntry = mcpTransportMode() === "stdio" ? buildStdioMcpEntry(packageRoot) : buildClaudeHttpMcpEntry(homeDir);
+  if (newEntry && typeof newEntry === "object" && "headers" in newEntry) {
+    const headers = newEntry.headers;
+    if (headers["X-Exe-Session"]) {
+      delete headers["X-Exe-Session"];
+    }
+  }
+  for (const key of [MCP_PRIMARY_KEY, MCP_LEGACY_KEY]) {
+    const existing = claudeJson.mcpServers?.[key];
+    if (existing?.headers) {
+      const h = existing.headers;
+      if (h["X-Exe-Session"]) {
+        delete h["X-Exe-Session"];
+        process.stderr.write(`exe-os: stripped stale X-Exe-Session from global ${key} config
+`);
+      }
+    }
+  }
+  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(path.join(homeDir, ".claude", "settings.json"));
+    await migratePermissionsToExeOs(path.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 writeFile(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+  await cleanSettingsJsonMcp(path.join(homeDir, ".claude", "settings.json"));
+  await migratePermissionsToExeOs(path.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 = path.join(homeDir, ".exe");
+  const exeMcpPath = path.join(exeDir, "mcp.json");
+  await mkdir(exeDir, { recursive: true });
+  let config = { servers: {} };
+  if (existsSync(exeMcpPath)) {
+    try {
+      config = JSON.parse(await readFile(exeMcpPath, "utf-8"));
+      if (!config.servers) config.servers = {};
+    } catch {
+      config = { servers: {} };
+    }
+  }
+  const stdioEntry = {
+    command: "node",
+    args: [path.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 writeFile(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 (!existsSync(settingsPath)) return;
+  try {
+    const settings = JSON.parse(await readFile(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 writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    }
+  } catch {
+  }
+}
+async function migratePermissionsToExeOs(settingsPath) {
+  if (!existsSync(settingsPath)) return;
+  try {
+    const settings = JSON.parse(await readFile(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 writeFile(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 = os.homedir()) {
+  const settingsPath = path.join(homeDir, ".claude", "settings.json");
+  const logsDir = path.join(homeDir, ".exe-os", "logs");
+  const hookLogPath = path.join(logsDir, "hooks.log");
+  const logSuffix = ` 2>> "${hookLogPath}"`;
+  await mkdir(logsDir, { recursive: true });
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(await readFile(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 "${path.join(packageRoot, "dist", "hooks", "post-tool-combined.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: EXE_HOOKS.postToolCombined
+    },
+    {
+      event: "SessionStart",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
+            timeout: 1e4
+          }
+        ]
+      },
+      marker: EXE_HOOKS.sessionStart
+    },
+    {
+      event: "UserPromptSubmit",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: EXE_HOOKS.promptSubmit
+    },
+    {
+      event: "UserPromptSubmit",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
+            timeout: 5e3
+          }
+        ]
+      },
+      marker: EXE_HOOKS.heartbeat
+    },
+    {
+      event: "Stop",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: EXE_HOOKS.stop
+    },
+    {
+      event: "PreToolUse",
+      group: {
+        matcher: "Write|Edit|Read|Bash",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: EXE_HOOKS.preToolUse
+    },
+    {
+      event: "SubagentStop",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "subagent-stop.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: EXE_HOOKS.subagentStop
+    },
+    {
+      event: "PreCompact",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "pre-compact.js")}"${logSuffix}`,
+            timeout: 1e4
+          }
+        ]
+      },
+      marker: EXE_HOOKS.preCompact
+    },
+    {
+      event: "SessionEnd",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "session-end.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: EXE_HOOKS.sessionEnd
+    },
+    {
+      event: "Notification",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "notification.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: EXE_HOOKS.notification
+    },
+    {
+      event: "PostCompact",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.join(packageRoot, "dist", "hooks", "post-compact.js")}"${logSuffix}`,
+            timeout: 1e4
+          }
+        ]
+      },
+      marker: EXE_HOOKS.postCompact
+    },
+    {
+      event: "InstructionsLoaded",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path.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 mkdir(path.dirname(settingsPath), { recursive: true });
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  return { added, skipped };
+}
+async function cleanOldShellFunctions(homeDir = os.homedir()) {
+  const rosterPath = path.join(homeDir, ".exe-os", "exe-employees.json");
+  if (!existsSync(rosterPath)) return 0;
+  let employees;
+  try {
+    employees = JSON.parse(await readFile(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 = [
+    path.join(homeDir, ".zshrc"),
+    path.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 (!existsSync(rcPath)) continue;
+    let content;
+    try {
+      content = await readFile(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) {
+      const backupPath = `${rcPath}.exe-os-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+      await writeFile(backupPath, content);
+      await writeFile(rcPath, lines.join("\n"));
+    }
+  }
+  return totalRemoved;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var EXE_SECTION_START = "<!-- exe-os:orchestration-start -->";
+var EXE_SECTION_END = "<!-- exe-os:orchestration-end -->";
+var 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}`;
+async function injectOrchestrationRules(homeDir) {
+  const claudeDir = path.join(homeDir, ".claude");
+  const claudeMdPath = path.join(claudeDir, "CLAUDE.md");
+  await mkdir(claudeDir, { recursive: true });
+  let existing = "";
+  try {
+    existing = await readFile(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 writeFile(claudeMdPath, updated, "utf-8");
+    return "updated";
+  }
+  const separator = existing.length > 0 && !existing.endsWith("\n\n") ? "\n\n" : "";
+  await writeFile(claudeMdPath, existing + separator + ORCHESTRATION_RULES + "\n", "utf-8");
+  return "injected";
+}
+async function installStatusLine(packageRoot, homeDir = os.homedir()) {
+  const prefs = loadPreferences(homeDir);
+  if (prefs.ccStatusLine === false) return "opted-out";
+  const claudeDir = path.join(homeDir, ".claude");
+  await mkdir(claudeDir, { recursive: true });
+  const assetPath = path.join(packageRoot, "dist", "assets", "statusline-command.sh");
+  if (!existsSync(assetPath)) return "asset-missing";
+  const destScript = path.join(claudeDir, "statusline-command.sh");
+  const assetContent = await readFile(assetPath, "utf-8");
+  await writeFile(destScript, assetContent, { mode: 493 });
+  const settingsPath = path.join(claudeDir, "settings.json");
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(await readFile(settingsPath, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+  if (settings.statusLine) return "already-configured";
+  settings.statusLine = {
+    type: "command",
+    command: `bash ${destScript}`
+  };
+  await writeFile(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 ?? os.homedir();
+  const exeWorkspace = path.join(resolvedHome, "exe");
+  if (!existsSync(exeWorkspace)) {
+    try {
+      await mkdir(path.join(exeWorkspace, "content"), { recursive: true });
+      await mkdir(path.join(exeWorkspace, "operations"), { recursive: true });
+      await mkdir(path.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 ?? os.homedir();
+  const prefs = loadPreferences(homeDir);
+  if (prefs.tmux === false) {
+    process.stderr.write("exe-os: tmux config skipped (user preference)\n");
+    return;
+  }
+  const exeDir = path.join(homeDir, ".exe-os");
+  const exeTmuxConf = path.join(exeDir, "tmux.conf");
+  const userTmuxConf = path.join(homeDir, ".tmux.conf");
+  const sourceLine = "source-file ~/.exe-os/tmux.conf";
+  const shellQuote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
+  const pkgRoot = resolvePackageRoot();
+  const assetPath = path.join(pkgRoot, "dist", "assets", "tmux.conf");
+  if (!existsSync(assetPath)) {
+    process.stderr.write(`exe-os: tmux.conf asset not found at ${assetPath} \u2014 skipping tmux setup
+`);
+    return;
+  }
+  mkdirSync(exeDir, { recursive: true });
+  if (existsSync(exeTmuxConf)) {
+    const currentContent = readFileSync(exeTmuxConf, "utf8");
+    const newContent = readFileSync(assetPath, "utf8");
+    const currentHash = createHash("sha256").update(currentContent).digest("hex");
+    const newHash = createHash("sha256").update(newContent).digest("hex");
+    if (currentHash !== newHash) {
+      const shippedPath = path.join(exeDir, ".tmux.conf.shipped-hash");
+      const lastShippedHash = existsSync(shippedPath) ? readFileSync(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");
+      }
+      writeFileSync(shippedPath, newHash, "utf8");
+    } else {
+      process.stderr.write("exe-os: tmux config already up to date\n");
+    }
+  } else {
+    copyFileSync(assetPath, exeTmuxConf);
+    const newContent = readFileSync(assetPath, "utf8");
+    const newHash = createHash("sha256").update(newContent).digest("hex");
+    writeFileSync(path.join(exeDir, ".tmux.conf.shipped-hash"), newHash, "utf8");
+  }
+  if (existsSync(userTmuxConf)) {
+    const existing = readFileSync(userTmuxConf, "utf8");
+    if (!existing.includes(sourceLine)) {
+      const backupPath = path.join(homeDir, ".tmux.conf.backup");
+      if (!existsSync(backupPath)) {
+        copyFileSync(userTmuxConf, backupPath);
+        process.stderr.write(`exe-os: backed up existing tmux config to ${backupPath}
+`);
+      }
+      writeFileSync(userTmuxConf, `${sourceLine}
+${existing}`);
+    }
+  } else {
+    writeFileSync(userTmuxConf, `# Exe OS tmux defaults \u2014 remove this line to use your own config
+${sourceLine}
+`);
+  }
+  try {
+    execSync(`tmux source-file ${shellQuote(userTmuxConf)} 2>/dev/null`);
+  } catch {
+  }
+  process.stderr.write("exe-os: tmux config installed\n");
+}
+function setupGhostty(home) {
+  const homeDir = home ?? os.homedir();
+  const prefs = loadPreferences(homeDir);
+  if (prefs.ghostty === false) {
+    process.stderr.write("exe-os: Ghostty config skipped (user preference)\n");
+    return;
+  }
+  const xdgConfig = path.join(homeDir, ".config", "ghostty");
+  const macConfig = path.join(homeDir, "Library", "Application Support", "com.mitchellh.ghostty");
+  const ghosttyInstalled = existsSync(xdgConfig) || existsSync(macConfig) || (() => {
+    try {
+      execSync("which ghostty 2>/dev/null");
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  if (!ghosttyInstalled) {
+    return;
+  }
+  const pkgRoot = resolvePackageRoot();
+  const assetPath = path.join(pkgRoot, "dist", "assets", "ghostty.conf");
+  if (!existsSync(assetPath)) {
+    process.stderr.write("exe-os: ghostty.conf asset not found \u2014 skipping Ghostty setup\n");
+    return;
+  }
+  const configDir = xdgConfig;
+  const configPath = path.join(configDir, "config");
+  const backupPath = path.join(configDir, "config.backup");
+  mkdirSync(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 = readFileSync(assetPath, "utf8").trim();
+  const markedSection = `${START_MARKER}
+${assetContent}
+${END_MARKER}`;
+  if (existsSync(configPath)) {
+    const existing = readFileSync(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 (!existsSync(backupPath)) {
+        copyFileSync(configPath, backupPath);
+        process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
+`);
+      }
+      writeFileSync(configPath, `${START_MARKER}
+${existing.trim()}
+${END_MARKER}
+`);
+    } else {
+      if (!existsSync(backupPath)) {
+        copyFileSync(configPath, backupPath);
+        process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
+`);
+      }
+      writeFileSync(configPath, `${markedSection}
+
+${existing}`);
+    }
+  } else {
+    writeFileSync(configPath, `${markedSection}
+`);
+  }
+  process.stderr.write("exe-os: Ghostty config installed\n");
+}
+function setupWezterm(home) {
+  const homeDir = home ?? os.homedir();
+  const prefs = loadPreferences(homeDir);
+  if (prefs.wezterm === false) {
+    process.stderr.write("exe-os: WezTerm config skipped (user preference)\n");
+    return;
+  }
+  const weztermLua = path.join(homeDir, ".wezterm.lua");
+  const weztermDir = path.join(homeDir, ".config", "wezterm");
+  const weztermInstalled = existsSync(weztermLua) || existsSync(weztermDir) || (() => {
+    try {
+      execSync("which wezterm 2>/dev/null", { encoding: "utf8", timeout: 5e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  if (!weztermInstalled) {
+    return;
+  }
+  const pkgRoot = resolvePackageRoot();
+  const assetPath = path.join(pkgRoot, "dist", "assets", "wezterm.lua");
+  if (!existsSync(assetPath)) {
+    process.stderr.write("exe-os: wezterm.lua asset not found \u2014 skipping WezTerm setup\n");
+    return;
+  }
+  const configPath = weztermLua;
+  const START_MARKER = "-- \u2500\u2500 exe-os:wezterm-start \u2500\u2500";
+  const END_MARKER = "-- \u2500\u2500 exe-os:wezterm-end \u2500\u2500";
+  const assetContent = readFileSync(assetPath, "utf8").trim();
+  if (existsSync(configPath)) {
+    const existing = readFileSync(configPath, "utf8");
+    if (existing.includes(START_MARKER) && existing.includes(END_MARKER)) {
+      process.stderr.write("exe-os: WezTerm config already installed \u2014 preserving local settings\n");
+      return;
+    }
+    process.stderr.write(
+      "exe-os: existing WezTerm config found at ~/.wezterm.lua \u2014 skipping (manual integration needed)\nexe-os: see ~/.exe-os/assets/wezterm.lua for exe-os defaults you can merge\n"
+    );
+    const refDir = path.join(homeDir, ".exe-os", "assets");
+    mkdirSync(refDir, { recursive: true });
+    copyFileSync(assetPath, path.join(refDir, "wezterm.lua"));
+    return;
+  }
+  writeFileSync(configPath, assetContent + "\n");
+  process.stderr.write("exe-os: WezTerm 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;
+}
+
+export {
+  resolvePackageRoot,
+  copySlashCommands,
+  detectMcpNameCollisions,
+  registerMcpServer,
+  mergeHooks,
+  cleanOldShellFunctions,
+  installStatusLine,
+  runInstaller,
+  setupTmux,
+  setupGhostty,
+  setupWezterm
+};