@askexenow/exe-os 0.8.60 → 0.8.61

package/dist/bin/exe-new-employee.js

@@ -17,15 +17,15 @@ var __export = (target, all) => {
 
 // src/lib/config.ts
 import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { readFileSync, existsSync, renameSync } from "fs";
-import path from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2, renameSync } from "fs";
+import path2 from "path";
 import os from "os";
 function resolveDataDir() {
   if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  const newDir = path.join(os.homedir(), ".exe-os");
-  const legacyDir = path.join(os.homedir(), ".exe-mem");
-  if (!existsSync(newDir) && existsSync(legacyDir)) {
+  const newDir = path2.join(os.homedir(), ".exe-os");
+  const legacyDir = path2.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
@@ -41,10 +41,10 @@ var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
     EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
+    DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
+    MODELS_DIR = path2.join(EXE_AI_DIR, "models");
+    CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
+    LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
     CURRENT_CONFIG_VERSION = 1;
     DEFAULT_CONFIG = {
       config_version: CURRENT_CONFIG_VERSION,
@@ -112,6 +112,97 @@ var init_config = __esm({
   }
 });
 
+// src/lib/employees.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3, symlinkSync, readlinkSync, readFileSync as readFileSync3 } from "fs";
+import { execSync } from "child_process";
+import path3 from "path";
+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 (!existsSync3(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 addEmployee(employees, employee) {
+  const normalized = { ...employee, 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 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 (existsSync3(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;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
+    "use strict";
+    init_config();
+    EMPLOYEES_PATH = path3.join(EXE_AI_DIR, "exe-employees.json");
+  }
+});
+
 // src/lib/db-retry.ts
 var init_db_retry = __esm({
   "src/lib/db-retry.ts"() {
@@ -675,17 +766,17 @@ __export(identity_exports, {
   listIdentities: () => listIdentities,
   updateIdentity: () => updateIdentity
 });
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { readdirSync } from "fs";
-import path5 from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
+import { readdirSync as readdirSync2 } from "fs";
+import path6 from "path";
 import { createHash } from "crypto";
 function ensureDir() {
-  if (!existsSync5(IDENTITY_DIR)) {
-    mkdirSync2(IDENTITY_DIR, { recursive: true });
+  if (!existsSync6(IDENTITY_DIR)) {
+    mkdirSync3(IDENTITY_DIR, { recursive: true });
   }
 }
 function identityPath(agentId) {
-  return path5.join(IDENTITY_DIR, `${agentId}.md`);
+  return path6.join(IDENTITY_DIR, `${agentId}.md`);
 }
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -726,8 +817,8 @@ function contentHash(content) {
 }
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
-  if (!existsSync5(filePath)) return null;
-  const raw = readFileSync5(filePath, "utf-8");
+  if (!existsSync6(filePath)) return null;
+  const raw = readFileSync6(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
   return {
     agentId,
@@ -741,7 +832,7 @@ async function updateIdentity(agentId, content, updatedBy) {
   ensureDir();
   const filePath = identityPath(agentId);
   const hash = contentHash(content);
-  writeFileSync2(filePath, content, "utf-8");
+  writeFileSync3(filePath, content, "utf-8");
   try {
     const client = getClient();
     await client.execute({
@@ -758,7 +849,7 @@ async function updateIdentity(agentId, content, updatedBy) {
 }
 function listIdentities() {
   ensureDir();
-  const files = readdirSync(IDENTITY_DIR).filter((f) => f.endsWith(".md"));
+  const files = readdirSync2(IDENTITY_DIR).filter((f) => f.endsWith(".md"));
   const results = [];
   for (const file of files) {
     const agentId = file.replace(".md", "");
@@ -797,99 +888,746 @@ var init_identity = __esm({
     "use strict";
     init_config();
     init_database();
-    IDENTITY_DIR = path5.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR = path6.join(EXE_AI_DIR, "identity");
   }
 });
 
-// src/bin/exe-new-employee.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import path6 from "path";
-
-// src/lib/employees.ts
-init_config();
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2 } from "fs";
-import { execSync } from "child_process";
-import path2 from "path";
-var EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
-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" };
+// src/lib/agent-symlinks.ts
+import os2 from "os";
+import path7 from "path";
+import {
+  existsSync as existsSync7,
+  lstatSync,
+  mkdirSync as mkdirSync4,
+  readlinkSync as readlinkSync2,
+  symlinkSync as symlinkSync2
+} from "fs";
+function claudeAgentsDir(homeDir) {
+  return path7.join(homeDir, ".claude", "agents");
+}
+function identitySourcePath(homeDir, agentId) {
+  return path7.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
+}
+function claudeAgentLinkPath(homeDir, agentId) {
+  return path7.join(claudeAgentsDir(homeDir), `${agentId}.md`);
+}
+function ensureAgentSymlink(agentId, homeDir = os2.homedir()) {
+  const target = identitySourcePath(homeDir, agentId);
+  const link = claudeAgentLinkPath(homeDir, agentId);
+  mkdirSync4(claudeAgentsDir(homeDir), { recursive: true });
+  if (existsSync7(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}` };
   }
-  if (!/^[a-z][a-z0-9]*$/.test(name)) {
+  try {
+    symlinkSync2(target, link);
+  } catch (err) {
     return {
-      valid: false,
-      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
+      agentId,
+      action: "conflict",
+      target,
+      link,
+      conflict: err instanceof Error ? err.message : String(err)
     };
   }
-  return { valid: true };
+  return { agentId, action: "created", target, link };
 }
-async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) {
-    return [];
+async function ensureAllAgentSymlinks(homeDir = os2.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();
   }
-  const raw = await readFile2(employeesPath, "utf-8");
+});
+
+// src/lib/mcp-prefix.ts
+function expandDualPrefixTools(shortNames) {
+  const out = [];
+  for (const name of shortNames) {
+    for (const prefix of MCP_TOOL_PREFIXES) {
+      out.push(prefix + name);
+    }
+  }
+  return out;
+}
+var MCP_PRIMARY_KEY, MCP_LEGACY_KEY, MCP_TOOL_PREFIXES;
+var init_mcp_prefix = __esm({
+  "src/lib/mcp-prefix.ts"() {
+    "use strict";
+    MCP_PRIMARY_KEY = "exe-os";
+    MCP_LEGACY_KEY = "exe-mem";
+    MCP_TOOL_PREFIXES = [
+      `mcp__${MCP_PRIMARY_KEY}__`,
+      `mcp__${MCP_LEGACY_KEY}__`
+    ];
+  }
+});
+
+// src/adapters/claude/installer.ts
+var installer_exports = {};
+__export(installer_exports, {
+  copySlashCommands: () => copySlashCommands,
+  mergeHooks: () => mergeHooks,
+  registerMcpServer: () => registerMcpServer,
+  resolvePackageRoot: () => resolvePackageRoot,
+  runInstaller: () => runInstaller,
+  setupTmux: () => setupTmux
+});
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir } from "fs/promises";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4, copyFileSync, mkdirSync as mkdirSync5 } from "fs";
+import path8 from "path";
+import os3 from "os";
+import { execSync as execSync2 } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function resolvePackageRoot() {
+  const thisFile = fileURLToPath2(import.meta.url);
+  let dir = path8.dirname(thisFile);
+  const root = path8.parse(dir).root;
+  while (dir !== root) {
+    const pkgPath = path8.join(dir, "package.json");
+    if (existsSync8(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+        if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
+      } catch {
+      }
+    }
+    dir = path8.dirname(dir);
+  }
+  return path8.resolve(path8.dirname(thisFile), "..", "..", "..");
+}
+async function copySlashCommands(packageRoot, homeDir = os3.homedir()) {
+  let copied = 0;
+  let skipped = 0;
+  const skillsBase = path8.join(homeDir, ".claude", "skills");
+  const exeDir = path8.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 = path8.join(skillsBase, `exe-${name}`);
+      await mkdir3(destDir, { recursive: true });
+      const srcPath = path8.join(exeDir, file);
+      const destPath = path8.join(destDir, "SKILL.md");
+      const result = await copyAsSkill(srcPath, destPath, `exe-${name}`);
+      if (result) copied++;
+      else skipped++;
+    }
+  }
+  const topLevelSrc = path8.join(packageRoot, "src", "commands", "exe.md");
+  if (existsSync8(topLevelSrc)) {
+    const destDir = path8.join(skillsBase, "exe");
+    await mkdir3(destDir, { recursive: true });
+    const destPath = path8.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;
+}
+async function registerMcpServer(packageRoot, homeDir = os3.homedir()) {
+  const claudeJsonPath = path8.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 = {
+    type: "stdio",
+    command: "node",
+    args: [path8.join(packageRoot, "dist", "mcp", "server.js")],
+    env: {}
+  };
+  const legacy = claudeJson.mcpServers[MCP_LEGACY_KEY];
+  const current = claudeJson.mcpServers[MCP_PRIMARY_KEY];
+  const currentMatches = current && JSON.stringify(current) === JSON.stringify(newEntry);
+  if (currentMatches && !legacy) {
+    return false;
+  }
+  claudeJson.mcpServers[MCP_PRIMARY_KEY] = newEntry;
+  if (legacy) {
+    delete claudeJson.mcpServers[MCP_LEGACY_KEY];
+  }
+  await writeFile3(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+  return true;
+}
+async function mergeHooks(packageRoot, homeDir = os3.homedir()) {
+  const settingsPath = path8.join(homeDir, ".claude", "settings.json");
+  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 "${path8.join(packageRoot, "dist", "hooks", "ingest.js")}"`
+          },
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "error-recall.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/ingest.js"
+    },
+    {
+      event: "SessionStart",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "session-start.js")}"`,
+            timeout: 1e4
+          }
+        ]
+      },
+      marker: "dist/hooks/session-start.js"
+    },
+    {
+      event: "UserPromptSubmit",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/prompt-submit.js"
+    },
+    {
+      event: "UserPromptSubmit",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"`,
+            timeout: 5e3
+          }
+        ]
+      },
+      marker: "dist/hooks/exe-heartbeat-hook.js"
+    },
+    {
+      event: "Stop",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "stop.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/stop.js"
+    },
+    {
+      event: "PreToolUse",
+      group: {
+        matcher: "Write|Edit|Read|Bash",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/pre-tool-use.js"
+    },
+    {
+      event: "SubagentStop",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "subagent-stop.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/subagent-stop.js"
+    },
+    {
+      event: "PreCompact",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "pre-compact.js")}"`,
+            timeout: 1e4
+          }
+        ]
+      },
+      marker: "dist/hooks/pre-compact.js"
+    },
+    {
+      event: "SessionEnd",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "session-end.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/session-end.js"
+    },
+    {
+      event: "Notification",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "notification.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/notification.js"
+    },
+    {
+      event: "PostCompact",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "post-compact.js")}"`,
+            timeout: 1e4
+          }
+        ]
+      },
+      marker: "dist/hooks/post-compact.js"
+    },
+    {
+      event: "InstructionsLoaded",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "instructions-loaded.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/instructions-loaded.js"
+    }
+  ];
+  let added = 0;
+  let skipped = 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",
+    "create_wiki_page",
+    "update_wiki_page",
+    "get_wiki_page",
+    "list_wiki_pages",
+    // System
+    "load_skill",
+    "apply_starter_pack",
+    "resume_employee",
+    "deploy_client"
+  ];
+  const allowList = permissions.allow;
+  for (const tool of expandDualPrefixTools(toolNames)) {
+    if (!allowList.includes(tool)) {
+      allowList.push(tool);
+    }
+  }
+  await mkdir3(path8.dirname(settingsPath), { recursive: true });
+  await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  return { added, skipped };
+}
+async function injectOrchestrationRules(homeDir) {
+  const claudeDir = path8.join(homeDir, ".claude");
+  const claudeMdPath = path8.join(claudeDir, "CLAUDE.md");
+  await mkdir3(claudeDir, { recursive: true });
+  let existing = "";
   try {
-    return JSON.parse(raw);
+    existing = await readFile3(claudeMdPath, "utf-8");
   } catch {
-    return [];
   }
+  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 saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir2(path2.dirname(employeesPath), { recursive: true });
-  await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
-}
-function addEmployee(employees, employee) {
-  const normalized = { ...employee, name: employee.name.toLowerCase() };
-  if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
-    throw new Error(`Employee '${normalized.name}' already exists`);
+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 ?? os3.homedir();
+  const exeWorkspace = path8.join(resolvedHome, "exe");
+  if (!existsSync8(exeWorkspace)) {
+    try {
+      await mkdir3(path8.join(exeWorkspace, "content"), { recursive: true });
+      await mkdir3(path8.join(exeWorkspace, "operations"), { recursive: true });
+      await mkdir3(path8.join(exeWorkspace, "output"), { recursive: true });
+      process.stderr.write(
+        `Created ~/exe/ \u2014 your automation workspace for non-code projects
+`
+      );
+    } catch {
+    }
   }
-  return [...employees, normalized];
+  const claudeMdResult = await injectOrchestrationRules(resolvedHome);
+  process.stderr.write(
+    `CLAUDE.md orchestration: ${claudeMdResult}
+`
+  );
+  const symlinkResults = await ensureAllAgentSymlinks(resolvedHome);
+  process.stderr.write(
+    `Agent symlinks: ${summarizeSymlinkResults(symlinkResults)}
+`
+  );
+  process.stderr.write(`
+exe-os installed successfully.
+`);
 }
-function findExeBin() {
+function setupTmux(home) {
+  const homeDir = home ?? os3.homedir();
+  const exeDir = path8.join(homeDir, ".exe-os");
+  const exeTmuxConf = path8.join(exeDir, "tmux.conf");
+  const userTmuxConf = path8.join(homeDir, ".tmux.conf");
+  const backupPath = path8.join(homeDir, ".tmux.conf.backup");
+  const sourceLine = "source-file ~/.exe-os/tmux.conf";
+  const pkgRoot = resolvePackageRoot();
+  const assetPath = path8.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;
+  }
+  mkdirSync5(exeDir, { recursive: true });
+  copyFileSync(assetPath, exeTmuxConf);
+  if (existsSync8(userTmuxConf)) {
+    const existing = readFileSync7(userTmuxConf, "utf8");
+    if (!existing.includes(sourceLine)) {
+      if (!existsSync8(backupPath)) {
+        copyFileSync(userTmuxConf, backupPath);
+        process.stderr.write(`exe-os: backed up existing tmux config to ${backupPath}
+`);
+      }
+      writeFileSync4(userTmuxConf, `${sourceLine}
+${existing}`);
+    }
+  } else {
+    writeFileSync4(userTmuxConf, `# Exe OS tmux defaults \u2014 remove this line to use your own config
+${sourceLine}
+`);
+  }
   try {
-    return execSync(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+    execSync2(`tmux source-file ${exeTmuxConf} 2>/dev/null`);
   } catch {
-    return null;
   }
+  process.stderr.write("exe-os: tmux config installed\n");
 }
-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 };
+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}`;
   }
-  const binDir = path2.dirname(exeBinPath);
-  let target;
+  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();
+    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 exeN (e.g. exe1), ALL employee sessions use the same number: yoshi-exe1, tom-exe1, mari-exe1. NEVER reference, consider, or dispatch to employee sessions from other project numbers. 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 \u2192 exe \u2192 yoshi \u2192 engineers. Exe does not assign directly to tom or other engineers below yoshi.
+- **Verify dispatch.** After every create_task, confirm the employee received and started the task via tmux capture-pane.
+${EXE_SECTION_END}`;
+  }
+});
+
+// src/bin/exe-new-employee.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import path9 from "path";
+
+// src/lib/session-wrappers.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  chmodSync,
+  readdirSync,
+  unlinkSync
+} from "fs";
+import path from "path";
+import { homedir } from "os";
+var MAX_N = 9;
+function generateSessionWrappers(packageRoot, homeDir) {
+  const home = homeDir ?? homedir();
+  const binDir = path.join(home, ".exe-os", "bin");
+  const rosterPath = path.join(home, ".exe-os", "exe-employees.json");
+  mkdirSync(binDir, { recursive: true });
+  const exeStartDst = path.join(binDir, "exe-start");
+  const candidates = [
+    path.join(packageRoot, "dist", "bin", "exe-start.sh"),
+    path.join(packageRoot, "src", "bin", "exe-start.sh")
+  ];
+  for (const src of candidates) {
+    if (existsSync(src)) {
+      writeFileSync(exeStartDst, readFileSync(src));
+      chmodSync(exeStartDst, 493);
+      break;
+    }
+  }
+  let employees = [];
   try {
-    target = readlinkSync(exeBinPath);
+    employees = JSON.parse(readFileSync(rosterPath, "utf8"));
   } catch {
-    errors.push("Could not read 'exe' symlink");
-    return { created, skipped, errors };
+    return { created: 0, pathConfigured: false };
   }
-  for (const suffix of ["", "-opencode"]) {
-    const linkName = `${name}${suffix}`;
-    const linkPath = path2.join(binDir, linkName);
-    if (existsSync2(linkPath)) {
-      skipped.push(linkName);
-      continue;
+  if (employees.length === 0) {
+    return { created: 0, pathConfigured: false };
+  }
+  try {
+    for (const f of readdirSync(binDir)) {
+      if (f === "exe-start") continue;
+      const fPath = path.join(binDir, f);
+      try {
+        const content = readFileSync(fPath, "utf8");
+        if (content.includes("exe-start")) {
+          unlinkSync(fPath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  let created = 0;
+  const wrapperContent = `#!/bin/bash
+exec "${exeStartDst}" "$0" "$@"
+`;
+  for (const emp of employees) {
+    for (let n = 1; n <= MAX_N; n++) {
+      const wrapperPath = path.join(binDir, `${emp.name}${n}`);
+      writeFileSync(wrapperPath, wrapperContent);
+      chmodSync(wrapperPath, 493);
+      created++;
     }
+  }
+  const pathConfigured = ensurePath(home, binDir);
+  return { created, pathConfigured };
+}
+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(path.join(home, ".zshrc"));
+  } else if (shell.includes("bash")) {
+    profilePaths.push(path.join(home, ".bashrc"));
+    profilePaths.push(path.join(home, ".bash_profile"));
+  } else {
+    profilePaths.push(path.join(home, ".profile"));
+  }
+  for (const profilePath of profilePaths) {
     try {
-      symlinkSync(target, linkPath);
-      created.push(linkName);
-    } catch (err) {
-      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+      let content = "";
+      try {
+        content = readFileSync(profilePath, "utf8");
+      } catch {
+      }
+      if (content.includes(".exe-os/bin")) {
+        return false;
+      }
+      writeFileSync(profilePath, content + exportLine);
+      return true;
+    } catch {
+      continue;
     }
   }
-  return { created, skipped, errors };
+  return false;
 }
 
+// src/bin/exe-new-employee.ts
+init_employees();
+
 // src/lib/global-procedures.ts
 init_database();
 import { randomUUID } from "crypto";
@@ -1342,18 +2080,19 @@ function isMainModule(importMetaUrl) {
 
 // src/lib/plan-limits.ts
 init_database();
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
-import path4 from "path";
+init_employees();
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
+import path5 from "path";
 
 // src/lib/license.ts
 init_config();
-import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import path3 from "path";
+import path4 from "path";
 import { jwtVerify, importSPKI } from "jose";
-var LICENSE_PATH = path3.join(EXE_AI_DIR, "license.key");
-var CACHE_PATH = path3.join(EXE_AI_DIR, "license-cache.json");
-var DEVICE_ID_PATH = path3.join(EXE_AI_DIR, "device-id");
+var LICENSE_PATH = path4.join(EXE_AI_DIR, "license.key");
+var CACHE_PATH = path4.join(EXE_AI_DIR, "license-cache.json");
+var DEVICE_ID_PATH = path4.join(EXE_AI_DIR, "device-id");
 var API_BASE = "https://askexe.com/cloud";
 var RETRY_DELAY_MS = 500;
 async function fetchRetry(url, init) {
@@ -1386,37 +2125,37 @@ var FREE_LICENSE = {
   memoryLimit: 5e4
 };
 function loadDeviceId() {
-  const deviceJsonPath = path3.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path4.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync3(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync3(deviceJsonPath, "utf8"));
+    if (existsSync4(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync4(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync3(DEVICE_ID_PATH)) {
-      const id2 = readFileSync3(DEVICE_ID_PATH, "utf8").trim();
+    if (existsSync4(DEVICE_ID_PATH)) {
+      const id2 = readFileSync4(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
   }
   const id = randomUUID2();
-  mkdirSync(EXE_AI_DIR, { recursive: true });
-  writeFileSync(DEVICE_ID_PATH, id, "utf8");
+  mkdirSync2(EXE_AI_DIR, { recursive: true });
+  writeFileSync2(DEVICE_ID_PATH, id, "utf8");
   return id;
 }
 function loadLicense() {
   try {
-    if (!existsSync3(LICENSE_PATH)) return null;
-    return readFileSync3(LICENSE_PATH, "utf8").trim();
+    if (!existsSync4(LICENSE_PATH)) return null;
+    return readFileSync4(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
 }
 function saveLicense(apiKey) {
-  mkdirSync(EXE_AI_DIR, { recursive: true });
-  writeFileSync(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+  mkdirSync2(EXE_AI_DIR, { recursive: true });
+  writeFileSync2(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
 }
 async function verifyLicenseJwt(token) {
   try {
@@ -1442,8 +2181,8 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync3(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync3(CACHE_PATH, "utf8"));
+    if (!existsSync4(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync4(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -1452,8 +2191,8 @@ async function getCachedLicense() {
 }
 function readCachedToken() {
   try {
-    if (!existsSync3(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync3(CACHE_PATH, "utf8"));
+    if (!existsSync4(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync4(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
     return null;
@@ -1487,7 +2226,7 @@ function getRawCachedPlan() {
 }
 function cacheResponse(token) {
   try {
-    writeFileSync(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    writeFileSync2(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
@@ -1552,9 +2291,9 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path3.join(EXE_AI_DIR, "config.json");
-      if (existsSync3(configPath)) {
-        const raw = JSON.parse(readFileSync3(configPath, "utf8"));
+      const configPath = path4.join(EXE_AI_DIR, "config.json");
+      if (existsSync4(configPath)) {
+        const raw = JSON.parse(readFileSync4(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
           key = cloud.apiKey;
@@ -1579,7 +2318,7 @@ var PlanLimitError = class extends Error {
     this.name = "PlanLimitError";
   }
 };
-var CACHE_PATH2 = path4.join(EXE_AI_DIR, "license-cache.json");
+var CACHE_PATH2 = path5.join(EXE_AI_DIR, "license-cache.json");
 async function assertEmployeeLimit(license, rosterPath) {
   const lic = license ?? await checkLicense();
   if (lic.employeeLimit < 0) return;
@@ -1675,7 +2414,7 @@ async function main() {
     const identityTemplate = templateKey ? getIdentityTemplate(templateKey) : null;
     if (identityTemplate) {
       const idPath = identityPath2(name);
-      const dir = path6.dirname(idPath);
+      const dir = path9.dirname(idPath);
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
       const content = identityTemplate.replace(/^agent_id: \w+/m, `agent_id: ${name}`);
       fs.writeFileSync(idPath, content, "utf-8");
@@ -1683,9 +2422,9 @@ async function main() {
     }
   } catch {
   }
-  const taskDir = path6.join(process.cwd(), "exe", name);
-  if (!existsSync6(taskDir)) {
-    mkdirSync3(taskDir, { recursive: true });
+  const taskDir = path9.join(process.cwd(), "exe", name);
+  if (!existsSync9(taskDir)) {
+    mkdirSync6(taskDir, { recursive: true });
   }
   const bins = registerBinSymlinks(newEmployee.name);
   if (bins.created.length > 0) {
@@ -1694,6 +2433,15 @@ async function main() {
   if (bins.errors.length > 0) {
     console.error(`Warning: some launchers failed: ${bins.errors.join("; ")}`);
   }
+  try {
+    const { resolvePackageRoot: resolvePackageRoot2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
+    const pkgRoot = resolvePackageRoot2();
+    const wrapResult = generateSessionWrappers(pkgRoot);
+    if (wrapResult.created > 0) {
+      console.log(`Session wrappers: ${wrapResult.created} generated (${newEmployee.name}1-9 added)`);
+    }
+  } catch {
+  }
   console.log(`Created employee: ${newEmployee.name} (${newEmployee.role})`);
 }
 if (isMainModule(import.meta.url)) {