@askexenow/exe-os 0.9.7 → 0.9.8

package/dist/bin/install.js

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -100,6 +106,118 @@ var init_config = __esm({
   }
 });
 
+// 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.4"
+      },
+      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,
+  saveAgentConfig: () => saveAgentConfig,
+  setAgentRuntime: () => setAgentRuntime
+});
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import path2 from "path";
+function loadAgentConfig() {
+  if (!existsSync2(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);
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(AGENT_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+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 setAgentRuntime(agentId, runtime, model) {
+  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();
+  config[agentId] = { runtime, model };
+  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();
+    AGENT_CONFIG_PATH = path2.join(EXE_AI_DIR, "agent-config.json");
+    KNOWN_RUNTIMES = {
+      claude: ["claude-opus-4", "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",
+      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, {
@@ -115,6 +233,7 @@ __export(employees_exports, {
   getEmployeeByRole: () => getEmployeeByRole,
   getEmployeeNamesByRole: () => getEmployeeNamesByRole,
   hasRole: () => hasRole,
+  hireEmployee: () => hireEmployee,
   isCoordinatorName: () => isCoordinatorName,
   isCoordinatorRole: () => isCoordinatorRole,
   isMultiInstance: () => isMultiInstance,
@@ -127,9 +246,9 @@ __export(employees_exports, {
   validateEmployeeName: () => validateEmployeeName
 });
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, symlinkSync, readlinkSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { execSync } from "child_process";
-import path2 from "path";
+import path3 from "path";
 import os2 from "os";
 function normalizeRole(role) {
   return (role ?? "").trim().toLowerCase();
@@ -166,7 +285,7 @@ function validateEmployeeName(name) {
   return { valid: true };
 }
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) {
+  if (!existsSync3(employeesPath)) {
     return [];
   }
   const raw = await readFile2(employeesPath, "utf-8");
@@ -177,13 +296,13 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
   }
 }
 async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir2(path2.dirname(employeesPath), { recursive: true });
+  await mkdir2(path3.dirname(employeesPath), { recursive: true });
   await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) return [];
+  if (!existsSync3(employeesPath)) return [];
   try {
-    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
+    return JSON.parse(readFileSync3(employeesPath, "utf-8"));
   } catch {
     return [];
   }
@@ -225,6 +344,52 @@ function addEmployee(employees, employee) {
   }
   return [...employees, normalized];
 }
+function appendToCoordinatorTeam(employee) {
+  const coordinator = getCoordinatorEmployee(loadEmployeesSync());
+  if (!coordinator) return;
+  const idPath = path3.join(IDENTITY_DIR, `${coordinator.name}.md`);
+  if (!existsSync3(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;
@@ -234,14 +399,14 @@ async function normalizeRosterCase(rosterPath) {
       emp.name = emp.name.toLowerCase();
       changed = true;
       try {
-        const identityDir = path2.join(os2.homedir(), ".exe-os", "identity");
-        const oldPath = path2.join(identityDir, `${oldName}.md`);
-        const newPath = path2.join(identityDir, `${emp.name}.md`);
-        if (existsSync2(oldPath) && !existsSync2(newPath)) {
+        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 (existsSync3(oldPath) && !existsSync3(newPath)) {
           renameSync2(oldPath, newPath);
-        } else if (existsSync2(oldPath) && oldPath !== newPath) {
-          const content = readFileSync2(oldPath, "utf-8");
-          writeFileSync(newPath, content, "utf-8");
+        } else if (existsSync3(oldPath) && oldPath !== newPath) {
+          const content = readFileSync3(oldPath, "utf-8");
+          writeFileSync2(newPath, content, "utf-8");
           if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
             unlinkSync(oldPath);
           }
@@ -271,7 +436,7 @@ function registerBinSymlinks(name) {
     errors.push("Could not find 'exe-os' in PATH");
     return { created, skipped, errors };
   }
-  const binDir = path2.dirname(exeBinPath);
+  const binDir = path3.dirname(exeBinPath);
   let target;
   try {
     target = readlinkSync(exeBinPath);
@@ -281,8 +446,8 @@ function registerBinSymlinks(name) {
   }
   for (const suffix of ["", "-opencode"]) {
     const linkName = `${name}${suffix}`;
-    const linkPath = path2.join(binDir, linkName);
-    if (existsSync2(linkPath)) {
+    const linkPath = path3.join(binDir, linkName);
+    if (existsSync3(linkPath)) {
       skipped.push(linkName);
       continue;
     }
@@ -295,51 +460,44 @@ function registerBinSymlinks(name) {
   }
   return { created, skipped, errors };
 }
-var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES;
+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 = path2.join(EXE_AI_DIR, "exe-employees.json");
+    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/adapters/claude/installer.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir } from "fs/promises";
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, copyFileSync, mkdirSync as mkdirSync3 } from "fs";
-import path5 from "path";
-import os5 from "os";
-import { execSync as execSync2 } from "child_process";
-import { fileURLToPath } from "url";
-
 // src/lib/agent-symlinks.ts
-init_employees();
 import os3 from "os";
-import path3 from "path";
+import path4 from "path";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   lstatSync,
-  mkdirSync,
+  mkdirSync as mkdirSync2,
   readlinkSync as readlinkSync2,
   symlinkSync as symlinkSync2
 } from "fs";
 function claudeAgentsDir(homeDir) {
-  return path3.join(homeDir, ".claude", "agents");
+  return path4.join(homeDir, ".claude", "agents");
 }
 function identitySourcePath(homeDir, agentId) {
-  return path3.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
+  return path4.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
 }
 function claudeAgentLinkPath(homeDir, agentId) {
-  return path3.join(claudeAgentsDir(homeDir), `${agentId}.md`);
+  return path4.join(claudeAgentsDir(homeDir), `${agentId}.md`);
 }
 function ensureAgentSymlink(agentId, homeDir = os3.homedir()) {
   const target = identitySourcePath(homeDir, agentId);
   const link = claudeAgentLinkPath(homeDir, agentId);
-  mkdirSync(claudeAgentsDir(homeDir), { recursive: true });
-  if (existsSync3(link)) {
+  mkdirSync2(claudeAgentsDir(homeDir), { recursive: true });
+  if (existsSync4(link)) {
     let stat;
     try {
       stat = lstatSync(link);
@@ -377,14 +535,14 @@ 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 = "exe-os";
-var MCP_LEGACY_KEY = "exe-mem";
-var MCP_TOOL_PREFIXES = [
-  `mcp__${MCP_PRIMARY_KEY}__`,
-  `mcp__${MCP_LEGACY_KEY}__`
-];
 function expandDualPrefixTools(shortNames) {
   const out = [];
   for (const name of shortNames) {
@@ -394,64 +552,87 @@ function expandDualPrefixTools(shortNames) {
   }
   return out;
 }
+var MCP_PRIMARY_KEY, MCP_LEGACY_KEY, MCP_TOOL_PREFIXES;
+var init_mcp_prefix = __esm({
+  "src/lib/mcp-prefix.ts"() {
+    "use strict";
+    MCP_PRIMARY_KEY = "exe-os";
+    MCP_LEGACY_KEY = "exe-mem";
+    MCP_TOOL_PREFIXES = [
+      `mcp__${MCP_PRIMARY_KEY}__`,
+      `mcp__${MCP_LEGACY_KEY}__`
+    ];
+  }
+});
 
 // src/lib/preferences.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import path4 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import path5 from "path";
 import os4 from "os";
 function loadPreferences(homeDir = os4.homedir()) {
-  const configPath = path4.join(homeDir, ".exe-os", "config.json");
-  if (!existsSync4(configPath)) return {};
+  const configPath = path5.join(homeDir, ".exe-os", "config.json");
+  if (!existsSync5(configPath)) return {};
   try {
-    const config = JSON.parse(readFileSync3(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync4(configPath, "utf-8"));
     return config.preferences ?? {};
   } catch {
     return {};
   }
 }
+var init_preferences = __esm({
+  "src/lib/preferences.ts"() {
+    "use strict";
+  }
+});
 
 // src/adapters/claude/installer.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir } from "fs/promises";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, copyFileSync, mkdirSync as mkdirSync4 } from "fs";
+import path6 from "path";
+import os5 from "os";
+import { execSync as execSync2 } from "child_process";
+import { fileURLToPath } from "url";
 function resolvePackageRoot() {
   const thisFile = fileURLToPath(import.meta.url);
-  let dir = path5.dirname(thisFile);
-  const root = path5.parse(dir).root;
+  let dir = path6.dirname(thisFile);
+  const root = path6.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path5.join(dir, "package.json");
-    if (existsSync5(pkgPath)) {
+    const pkgPath = path6.join(dir, "package.json");
+    if (existsSync6(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
       } catch {
       }
     }
-    dir = path5.dirname(dir);
+    dir = path6.dirname(dir);
   }
-  return path5.resolve(path5.dirname(thisFile), "..", "..", "..");
+  return path6.resolve(path6.dirname(thisFile), "..", "..", "..");
 }
 async function copySlashCommands(packageRoot, homeDir = os5.homedir()) {
   let copied = 0;
   let skipped = 0;
-  const skillsBase = path5.join(homeDir, ".claude", "skills");
-  const exeDir = path5.join(packageRoot, "src", "commands", "exe");
-  if (existsSync5(exeDir)) {
+  const skillsBase = path6.join(homeDir, ".claude", "skills");
+  const exeDir = path6.join(packageRoot, "src", "commands", "exe");
+  if (existsSync6(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 = path5.join(skillsBase, `exe-${name}`);
+      const destDir = path6.join(skillsBase, `exe-${name}`);
       await mkdir3(destDir, { recursive: true });
-      const srcPath = path5.join(exeDir, file);
-      const destPath = path5.join(destDir, "SKILL.md");
+      const srcPath = path6.join(exeDir, file);
+      const destPath = path6.join(destDir, "SKILL.md");
       const result = await copyAsSkill(srcPath, destPath, `exe-${name}`);
       if (result) copied++;
       else skipped++;
     }
   }
-  const topLevelSrc = path5.join(packageRoot, "src", "commands", "exe.md");
-  if (existsSync5(topLevelSrc)) {
-    const destDir = path5.join(skillsBase, "exe");
+  const topLevelSrc = path6.join(packageRoot, "src", "commands", "exe.md");
+  if (existsSync6(topLevelSrc)) {
+    const destDir = path6.join(skillsBase, "exe");
     await mkdir3(destDir, { recursive: true });
-    const destPath = path5.join(destDir, "SKILL.md");
+    const destPath = path6.join(destDir, "SKILL.md");
     const result = await copyAsSkill(topLevelSrc, destPath, "exe");
     if (result) copied++;
     else skipped++;
@@ -474,7 +655,7 @@ name: ${skillName}
 `);
     }
   }
-  if (existsSync5(destPath)) {
+  if (existsSync6(destPath)) {
     const existing = await readFile3(destPath, "utf-8");
     if (existing === content) return false;
   }
@@ -482,9 +663,9 @@ name: ${skillName}
   return true;
 }
 async function registerMcpServer(packageRoot, homeDir = os5.homedir()) {
-  const claudeJsonPath = path5.join(homeDir, ".claude.json");
+  const claudeJsonPath = path6.join(homeDir, ".claude.json");
   let claudeJson = {};
-  if (existsSync5(claudeJsonPath)) {
+  if (existsSync6(claudeJsonPath)) {
     try {
       claudeJson = JSON.parse(await readFile3(claudeJsonPath, "utf-8"));
     } catch {
@@ -497,7 +678,7 @@ async function registerMcpServer(packageRoot, homeDir = os5.homedir()) {
   const newEntry = {
     type: "stdio",
     command: "node",
-    args: [path5.join(packageRoot, "dist", "mcp", "server.js")],
+    args: [path6.join(packageRoot, "dist", "mcp", "server.js")],
     env: {}
   };
   const currentMem = claudeJson.mcpServers[MCP_LEGACY_KEY];
@@ -505,17 +686,17 @@ async function registerMcpServer(packageRoot, homeDir = os5.homedir()) {
   const memMatches = currentMem && JSON.stringify(currentMem) === JSON.stringify(newEntry);
   const osMatches = currentOs && JSON.stringify(currentOs) === JSON.stringify(newEntry);
   if (memMatches && osMatches) {
-    await cleanSettingsJsonMcp(path5.join(homeDir, ".claude", "settings.json"));
+    await cleanSettingsJsonMcp(path6.join(homeDir, ".claude", "settings.json"));
     return false;
   }
   claudeJson.mcpServers[MCP_LEGACY_KEY] = newEntry;
   claudeJson.mcpServers[MCP_PRIMARY_KEY] = newEntry;
   await writeFile3(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
-  await cleanSettingsJsonMcp(path5.join(homeDir, ".claude", "settings.json"));
+  await cleanSettingsJsonMcp(path6.join(homeDir, ".claude", "settings.json"));
   return true;
 }
 async function cleanSettingsJsonMcp(settingsPath) {
-  if (!existsSync5(settingsPath)) return;
+  if (!existsSync6(settingsPath)) return;
   try {
     const settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
     const servers = settings.mcpServers;
@@ -536,13 +717,13 @@ async function cleanSettingsJsonMcp(settingsPath) {
   }
 }
 async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
-  const settingsPath = path5.join(homeDir, ".claude", "settings.json");
-  const logsDir = path5.join(homeDir, ".exe-os", "logs");
-  const hookLogPath = path5.join(logsDir, "hooks.log");
+  const settingsPath = path6.join(homeDir, ".claude", "settings.json");
+  const logsDir = path6.join(homeDir, ".exe-os", "logs");
+  const hookLogPath = path6.join(logsDir, "hooks.log");
   const logSuffix = ` 2>> "${hookLogPath}"`;
   await mkdir3(logsDir, { recursive: true });
   let settings = {};
-  if (existsSync5(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     try {
       settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
     } catch {
@@ -564,11 +745,11 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
           },
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
           }
         ]
       },
@@ -580,7 +761,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
             timeout: 1e4
           }
         ]
@@ -593,7 +774,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
           }
         ]
       },
@@ -605,7 +786,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
             timeout: 5e3
           }
         ]
@@ -618,7 +799,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
           }
         ]
       },
@@ -631,7 +812,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
           }
         ]
       },
@@ -643,7 +824,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "subagent-stop.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "subagent-stop.js")}"${logSuffix}`
           }
         ]
       },
@@ -655,7 +836,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "pre-compact.js")}"${logSuffix}`,
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "pre-compact.js")}"${logSuffix}`,
             timeout: 1e4
           }
         ]
@@ -668,7 +849,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "session-end.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "session-end.js")}"${logSuffix}`
           }
         ]
       },
@@ -680,7 +861,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "notification.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "notification.js")}"${logSuffix}`
           }
         ]
       },
@@ -692,7 +873,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "post-compact.js")}"${logSuffix}`,
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "post-compact.js")}"${logSuffix}`,
             timeout: 1e4
           }
         ]
@@ -705,7 +886,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "instructions-loaded.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "instructions-loaded.js")}"${logSuffix}`
           }
         ]
       },
@@ -804,13 +985,13 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
       allowList.push(tool);
     }
   }
-  await mkdir3(path5.dirname(settingsPath), { recursive: true });
+  await mkdir3(path6.dirname(settingsPath), { recursive: true });
   await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return { added, skipped };
 }
 async function cleanOldShellFunctions(homeDir = os5.homedir()) {
-  const rosterPath = path5.join(homeDir, ".exe-os", "exe-employees.json");
-  if (!existsSync5(rosterPath)) return 0;
+  const rosterPath = path6.join(homeDir, ".exe-os", "exe-employees.json");
+  if (!existsSync6(rosterPath)) return 0;
   let employees;
   try {
     employees = JSON.parse(await readFile3(rosterPath, "utf-8"));
@@ -825,13 +1006,13 @@ async function cleanOldShellFunctions(homeDir = os5.homedir()) {
     return { name: n, funcDef, forLoop };
   });
   const rcFiles = [
-    path5.join(homeDir, ".zshrc"),
-    path5.join(homeDir, ".bashrc")
+    path6.join(homeDir, ".zshrc"),
+    path6.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 (!existsSync5(rcPath)) continue;
+    if (!existsSync6(rcPath)) continue;
     let content;
     try {
       content = await readFile3(rcPath, "utf-8");
@@ -934,22 +1115,9 @@ async function cleanOldShellFunctions(homeDir = os5.homedir()) {
 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 -> COO -> managers -> specialists. The COO does not bypass managers for specialist work.
-- **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 = path5.join(homeDir, ".claude");
-  const claudeMdPath = path5.join(claudeDir, "CLAUDE.md");
+  const claudeDir = path6.join(homeDir, ".claude");
+  const claudeMdPath = path6.join(claudeDir, "CLAUDE.md");
   await mkdir3(claudeDir, { recursive: true });
   let existing = "";
   try {
@@ -974,16 +1142,16 @@ async function injectOrchestrationRules(homeDir) {
 async function installStatusLine(packageRoot, homeDir = os5.homedir()) {
   const prefs = loadPreferences(homeDir);
   if (prefs.ccStatusLine === false) return "opted-out";
-  const claudeDir = path5.join(homeDir, ".claude");
+  const claudeDir = path6.join(homeDir, ".claude");
   await mkdir3(claudeDir, { recursive: true });
-  const assetPath = path5.join(packageRoot, "dist", "assets", "statusline-command.sh");
-  if (!existsSync5(assetPath)) return "asset-missing";
-  const destScript = path5.join(claudeDir, "statusline-command.sh");
+  const assetPath = path6.join(packageRoot, "dist", "assets", "statusline-command.sh");
+  if (!existsSync6(assetPath)) return "asset-missing";
+  const destScript = path6.join(claudeDir, "statusline-command.sh");
   const assetContent = await readFile3(assetPath, "utf-8");
   await writeFile3(destScript, assetContent, { mode: 493 });
-  const settingsPath = path5.join(claudeDir, "settings.json");
+  const settingsPath = path6.join(claudeDir, "settings.json");
   let settings = {};
-  if (existsSync5(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     try {
       settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
     } catch {
@@ -1021,12 +1189,12 @@ async function runInstaller(homeDir) {
 `
   );
   const resolvedHome = homeDir ?? os5.homedir();
-  const exeWorkspace = path5.join(resolvedHome, "exe");
-  if (!existsSync5(exeWorkspace)) {
+  const exeWorkspace = path6.join(resolvedHome, "exe");
+  if (!existsSync6(exeWorkspace)) {
     try {
-      await mkdir3(path5.join(exeWorkspace, "content"), { recursive: true });
-      await mkdir3(path5.join(exeWorkspace, "operations"), { recursive: true });
-      await mkdir3(path5.join(exeWorkspace, "output"), { recursive: true });
+      await mkdir3(path6.join(exeWorkspace, "content"), { recursive: true });
+      await mkdir3(path6.join(exeWorkspace, "operations"), { recursive: true });
+      await mkdir3(path6.join(exeWorkspace, "output"), { recursive: true });
       process.stderr.write(
         `Created ~/exe/ \u2014 your automation workspace for non-code projects
 `
@@ -1062,33 +1230,33 @@ exe-os installed successfully.
 }
 function setupTmux(home) {
   const homeDir = home ?? os5.homedir();
-  const exeDir = path5.join(homeDir, ".exe-os");
-  const exeTmuxConf = path5.join(exeDir, "tmux.conf");
-  const userTmuxConf = path5.join(homeDir, ".tmux.conf");
-  const backupPath = path5.join(homeDir, ".tmux.conf.backup");
+  const exeDir = path6.join(homeDir, ".exe-os");
+  const exeTmuxConf = path6.join(exeDir, "tmux.conf");
+  const userTmuxConf = path6.join(homeDir, ".tmux.conf");
+  const backupPath = path6.join(homeDir, ".tmux.conf.backup");
   const sourceLine = "source-file ~/.exe-os/tmux.conf";
   const pkgRoot = resolvePackageRoot();
-  const assetPath = path5.join(pkgRoot, "dist", "assets", "tmux.conf");
-  if (!existsSync5(assetPath)) {
+  const assetPath = path6.join(pkgRoot, "dist", "assets", "tmux.conf");
+  if (!existsSync6(assetPath)) {
     process.stderr.write(`exe-os: tmux.conf asset not found at ${assetPath} \u2014 skipping tmux setup
 `);
     return;
   }
-  mkdirSync3(exeDir, { recursive: true });
+  mkdirSync4(exeDir, { recursive: true });
   copyFileSync(assetPath, exeTmuxConf);
-  if (existsSync5(userTmuxConf)) {
-    const existing = readFileSync4(userTmuxConf, "utf8");
+  if (existsSync6(userTmuxConf)) {
+    const existing = readFileSync5(userTmuxConf, "utf8");
     if (!existing.includes(sourceLine)) {
-      if (!existsSync5(backupPath)) {
+      if (!existsSync6(backupPath)) {
         copyFileSync(userTmuxConf, backupPath);
         process.stderr.write(`exe-os: backed up existing tmux config to ${backupPath}
 `);
       }
-      writeFileSync3(userTmuxConf, `${sourceLine}
+      writeFileSync4(userTmuxConf, `${sourceLine}
 ${existing}`);
     }
   } else {
-    writeFileSync3(userTmuxConf, `# Exe OS tmux defaults \u2014 remove this line to use your own config
+    writeFileSync4(userTmuxConf, `# Exe OS tmux defaults \u2014 remove this line to use your own config
 ${sourceLine}
 `);
   }
@@ -1100,9 +1268,9 @@ ${sourceLine}
 }
 function setupGhostty(home) {
   const homeDir = home ?? os5.homedir();
-  const xdgConfig = path5.join(homeDir, ".config", "ghostty");
-  const macConfig = path5.join(homeDir, "Library", "Application Support", "com.mitchellh.ghostty");
-  const ghosttyInstalled = existsSync5(xdgConfig) || existsSync5(macConfig) || (() => {
+  const xdgConfig = path6.join(homeDir, ".config", "ghostty");
+  const macConfig = path6.join(homeDir, "Library", "Application Support", "com.mitchellh.ghostty");
+  const ghosttyInstalled = existsSync6(xdgConfig) || existsSync6(macConfig) || (() => {
     try {
       execSync2("which ghostty 2>/dev/null");
       return true;
@@ -1114,47 +1282,47 @@ function setupGhostty(home) {
     return;
   }
   const pkgRoot = resolvePackageRoot();
-  const assetPath = path5.join(pkgRoot, "dist", "assets", "ghostty.conf");
-  if (!existsSync5(assetPath)) {
+  const assetPath = path6.join(pkgRoot, "dist", "assets", "ghostty.conf");
+  if (!existsSync6(assetPath)) {
     process.stderr.write("exe-os: ghostty.conf asset not found \u2014 skipping Ghostty setup\n");
     return;
   }
   const configDir = xdgConfig;
-  const configPath = path5.join(configDir, "config");
-  const backupPath = path5.join(configDir, "config.backup");
-  mkdirSync3(configDir, { recursive: true });
+  const configPath = path6.join(configDir, "config");
+  const backupPath = path6.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 = readFileSync4(assetPath, "utf8").trim();
+  const assetContent = readFileSync5(assetPath, "utf8").trim();
   const markedSection = `${START_MARKER}
 ${assetContent}
 ${END_MARKER}`;
-  if (existsSync5(configPath)) {
-    const existing = readFileSync4(configPath, "utf8");
+  if (existsSync6(configPath)) {
+    const existing = readFileSync5(configPath, "utf8");
     if (existing.includes(START_MARKER) && existing.includes(END_MARKER)) {
       const before = existing.slice(0, existing.indexOf(START_MARKER));
       const after = existing.slice(existing.indexOf(END_MARKER) + END_MARKER.length);
-      writeFileSync3(configPath, `${before}${markedSection}${after}`);
+      writeFileSync4(configPath, `${before}${markedSection}${after}`);
     } else if (existing.includes("Exe OS")) {
-      if (!existsSync5(backupPath)) {
+      if (!existsSync6(backupPath)) {
         copyFileSync(configPath, backupPath);
         process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
 `);
       }
-      writeFileSync3(configPath, `${markedSection}
+      writeFileSync4(configPath, `${markedSection}
 `);
     } else {
-      if (!existsSync5(backupPath)) {
+      if (!existsSync6(backupPath)) {
         copyFileSync(configPath, backupPath);
         process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
 `);
       }
-      writeFileSync3(configPath, `${markedSection}
+      writeFileSync4(configPath, `${markedSection}
 
 ${existing}`);
     }
   } else {
-    writeFileSync3(configPath, `${markedSection}
+    writeFileSync4(configPath, `${markedSection}
 `);
   }
   process.stderr.write("exe-os: Ghostty config installed\n");
@@ -1171,46 +1339,275 @@ function summarizeSymlinkResults(results) {
   }
   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();
+    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 -> COO -> managers -> specialists. The COO does not bypass managers for specialist work.
+- **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, {
+  installCodexStatusLine: () => installCodexStatusLine,
+  mergeCodexHooks: () => mergeCodexHooks,
+  runCodexInstaller: () => runCodexInstaller,
+  verifyCodexHooks: () => verifyCodexHooks
+});
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import path8 from "path";
+import os6 from "os";
+async function mergeCodexHooks(packageRoot, homeDir = os6.homedir()) {
+  const codexDir = path8.join(homeDir, ".codex");
+  const hooksPath = path8.join(codexDir, "hooks.json");
+  const logsDir = path8.join(homeDir, ".exe-os", "logs");
+  const hookLogPath = path8.join(logsDir, "hooks.log");
+  const logSuffix = ` 2>> "${hookLogPath}"`;
+  await mkdir4(codexDir, { recursive: true });
+  await mkdir4(logsDir, { recursive: true });
+  let hooksJson = {};
+  if (existsSync8(hooksPath)) {
+    try {
+      hooksJson = JSON.parse(await readFile4(hooksPath, "utf-8"));
+    } catch {
+      hooksJson = {};
+    }
+  }
+  if (!hooksJson.hooks) {
+    hooksJson.hooks = {};
+  }
+  const hooksToRegister = [
+    {
+      event: "SessionStart",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
+            timeout: 30,
+            statusMessage: "exe-os: loading memory brief"
+          }
+        ]
+      },
+      marker: "dist/hooks/session-start.js"
+    },
+    {
+      event: "PostToolUse",
+      group: {
+        matcher: "Bash|apply_patch|Edit|Write|Read|Glob|Grep|mcp__.*",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
+          },
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: "dist/hooks/ingest.js"
+    },
+    {
+      event: "UserPromptSubmit",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
+          },
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
+            timeout: 5
+          }
+        ]
+      },
+      marker: "dist/hooks/prompt-submit.js"
+    },
+    {
+      event: "Stop",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: "dist/hooks/stop.js"
+    },
+    {
+      event: "PreToolUse",
+      group: {
+        matcher: "Bash|apply_patch",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path8.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
+          }
+        ]
+      },
+      marker: "dist/hooks/pre-tool-use.js"
+    }
+  ];
+  let added = 0;
+  let skipped = 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 = os6.homedir()) {
+  const hooksPath = path8.join(homeDir, ".codex", "hooks.json");
+  if (!existsSync8(hooksPath)) return false;
+  try {
+    const hooksJson = JSON.parse(
+      __require("fs").readFileSync(hooksPath, "utf-8")
+    );
+    if (!hooksJson.hooks) return false;
+    const required = ["SessionStart", "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;
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installCodexStatusLine(homeDir = os6.homedir()) {
+  const prefs = loadPreferences(homeDir);
+  if (prefs.codexStatusLine === false) return "opted-out";
+  const codexDir = path8.join(homeDir, ".codex");
+  const configPath = path8.join(codexDir, "config.toml");
+  await mkdir4(codexDir, { recursive: true });
+  let content = "";
+  if (existsSync8(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";
+}
+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 statusResult = await installCodexStatusLine(homeDir);
+  process.stderr.write(
+    `[exe-os] Codex status line: ${statusResult}
+`
+  );
+}
+var DEFAULT_CODEX_STATUS_LINE;
+var init_installer2 = __esm({
+  "src/adapters/codex/installer.ts"() {
+    "use strict";
+    init_installer();
+    init_preferences();
+    DEFAULT_CODEX_STATUS_LINE = [
+      "model-with-reasoning",
+      "current-dir",
+      "project-name",
+      "git-branch",
+      "run-state",
+      "context-used"
+    ];
+  }
+});
 
 // src/bin/install.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, unlinkSync as unlinkSync3, readdirSync as readdirSync2, openSync, closeSync } from "fs";
+init_installer();
+import { existsSync as existsSync9, readFileSync as readFileSync7, unlinkSync as unlinkSync3, readdirSync as readdirSync2, openSync, closeSync } from "fs";
 import { spawn, execSync as execSync3 } from "child_process";
-import path7 from "path";
-import os6 from "os";
+import path9 from "path";
+import os7 from "os";
 
 // src/lib/session-wrappers.ts
 import {
-  existsSync as existsSync6,
-  readFileSync as readFileSync5,
-  writeFileSync as writeFileSync4,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync7,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync5,
+  mkdirSync as mkdirSync5,
   chmodSync,
   readdirSync,
   unlinkSync as unlinkSync2
 } from "fs";
-import path6 from "path";
+import path7 from "path";
 import { homedir } from "os";
 var MAX_N = 9;
 function generateSessionWrappers(packageRoot, homeDir) {
   const home = homeDir ?? homedir();
-  const binDir = path6.join(home, ".exe-os", "bin");
-  const rosterPath = path6.join(home, ".exe-os", "exe-employees.json");
-  mkdirSync4(binDir, { recursive: true });
-  const exeStartDst = path6.join(binDir, "exe-start");
+  const binDir = path7.join(home, ".exe-os", "bin");
+  const rosterPath = path7.join(home, ".exe-os", "exe-employees.json");
+  mkdirSync5(binDir, { recursive: true });
+  const exeStartDst = path7.join(binDir, "exe-start");
   const candidates = [
-    path6.join(packageRoot, "dist", "bin", "exe-start.sh"),
-    path6.join(packageRoot, "src", "bin", "exe-start.sh")
+    path7.join(packageRoot, "dist", "bin", "exe-start.sh"),
+    path7.join(packageRoot, "src", "bin", "exe-start.sh")
   ];
   for (const src of candidates) {
-    if (existsSync6(src)) {
-      writeFileSync4(exeStartDst, readFileSync5(src));
+    if (existsSync7(src)) {
+      writeFileSync5(exeStartDst, readFileSync6(src));
       chmodSync(exeStartDst, 493);
       break;
     }
   }
   let employees = [];
   try {
-    employees = JSON.parse(readFileSync5(rosterPath, "utf8"));
+    employees = JSON.parse(readFileSync6(rosterPath, "utf8"));
   } catch {
     return { created: 0, pathConfigured: false };
   }
@@ -1220,9 +1617,9 @@ function generateSessionWrappers(packageRoot, homeDir) {
   try {
     for (const f of readdirSync(binDir)) {
       if (f === "exe-start") continue;
-      const fPath = path6.join(binDir, f);
+      const fPath = path7.join(binDir, f);
       try {
-        const content = readFileSync5(fPath, "utf8");
+        const content = readFileSync6(fPath, "utf8");
         if (content.includes("exe-start")) {
           unlinkSync2(fPath);
         }
@@ -1237,30 +1634,30 @@ exec "${exeStartDst}" "$0" "$@"
 `;
   for (const emp of employees) {
     for (let n = 1; n <= MAX_N; n++) {
-      const wrapperPath = path6.join(binDir, `${emp.name}${n}`);
-      writeFileSync4(wrapperPath, wrapperContent);
+      const wrapperPath = path7.join(binDir, `${emp.name}${n}`);
+      writeFileSync5(wrapperPath, wrapperContent);
       chmodSync(wrapperPath, 493);
       created++;
     }
   }
   const codexLauncherCandidates = [
-    path6.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
-    path6.join(packageRoot, "src", "bin", "exe-start-codex.ts")
+    path7.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
+    path7.join(packageRoot, "src", "bin", "exe-start-codex.ts")
   ];
   let codexLauncher = null;
   for (const c of codexLauncherCandidates) {
-    if (existsSync6(c)) {
+    if (existsSync7(c)) {
       codexLauncher = c;
       break;
     }
   }
   if (codexLauncher) {
     for (const emp of employees) {
-      const wrapperPath = path6.join(binDir, `${emp.name}-codex`);
+      const wrapperPath = path7.join(binDir, `${emp.name}-codex`);
       const content = `#!/bin/bash
 exec node "${codexLauncher}" --agent ${emp.name} "$@"
 `;
-      writeFileSync4(wrapperPath, content);
+      writeFileSync5(wrapperPath, content);
       chmodSync(wrapperPath, 493);
       created++;
     }
@@ -1279,24 +1676,24 @@ export PATH="${binDir}:$PATH"
   const shell = process.env.SHELL ?? "/bin/bash";
   const profilePaths = [];
   if (shell.includes("zsh")) {
-    profilePaths.push(path6.join(home, ".zshrc"));
+    profilePaths.push(path7.join(home, ".zshrc"));
   } else if (shell.includes("bash")) {
-    profilePaths.push(path6.join(home, ".bashrc"));
-    profilePaths.push(path6.join(home, ".bash_profile"));
+    profilePaths.push(path7.join(home, ".bashrc"));
+    profilePaths.push(path7.join(home, ".bash_profile"));
   } else {
-    profilePaths.push(path6.join(home, ".profile"));
+    profilePaths.push(path7.join(home, ".profile"));
   }
   for (const profilePath of profilePaths) {
     try {
       let content = "";
       try {
-        content = readFileSync5(profilePath, "utf8");
+        content = readFileSync6(profilePath, "utf8");
       } catch {
       }
       if (content.includes(".exe-os/bin")) {
         return false;
       }
-      writeFileSync4(profilePath, content + exportLine);
+      writeFileSync5(profilePath, content + exportLine);
       return true;
     } catch {
       continue;
@@ -1306,14 +1703,14 @@ export PATH="${binDir}:$PATH"
 }
 
 // src/bin/install.ts
-var homedir2 = os6.homedir;
-var EXE_DIR = path7.join(homedir2(), ".exe-os");
+var homedir2 = os7.homedir;
+var EXE_DIR = path9.join(homedir2(), ".exe-os");
 function restartDaemon() {
-  const pidPath = path7.join(EXE_DIR, "exed.pid");
-  const sockPath = path7.join(EXE_DIR, "exed.sock");
+  const pidPath = path9.join(EXE_DIR, "exed.pid");
+  const sockPath = path9.join(EXE_DIR, "exed.sock");
   try {
-    if (existsSync7(pidPath)) {
-      const pid = parseInt(readFileSync6(pidPath, "utf8").trim(), 10);
+    if (existsSync9(pidPath)) {
+      const pid = parseInt(readFileSync7(pidPath, "utf8").trim(), 10);
       if (!isNaN(pid) && pid > 0) {
         try {
           process.kill(pid, "SIGKILL");
@@ -1354,11 +1751,11 @@ function restartDaemon() {
     } catch {
     }
     try {
-      const wpDir = path7.join(EXE_DIR, "worker-pids");
-      if (existsSync7(wpDir)) {
+      const wpDir = path9.join(EXE_DIR, "worker-pids");
+      if (existsSync9(wpDir)) {
         for (const f of readdirSync2(wpDir)) {
           try {
-            unlinkSync3(path7.join(wpDir, f));
+            unlinkSync3(path9.join(wpDir, f));
           } catch {
           }
         }
@@ -1375,7 +1772,7 @@ function restartDaemon() {
     }
   } catch {
   }
-  const totalGB = os6.totalmem() / (1024 * 1024 * 1024);
+  const totalGB = os7.totalmem() / (1024 * 1024 * 1024);
   if (totalGB <= 8) {
     process.stderr.write(
       `exe-os: ${totalGB.toFixed(0)}GB system \u2014 skipping daemon spawn (keyword search mode)
@@ -1385,13 +1782,13 @@ function restartDaemon() {
   }
   try {
     const pkgRoot = resolvePackageRoot();
-    const daemonPath = path7.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-    if (!existsSync7(daemonPath)) {
+    const daemonPath = path9.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+    if (!existsSync9(daemonPath)) {
       process.stderr.write(`exe-os: daemon not found at ${daemonPath} \u2014 skipping respawn
 `);
       return;
     }
-    const logPath = path7.join(EXE_DIR, "exed.log");
+    const logPath = path9.join(EXE_DIR, "exed.log");
     let stderrFd = "ignore";
     try {
       stderrFd = openSync(logPath, "a");
@@ -1461,6 +1858,12 @@ if (args.includes("--commands-only")) {
     } catch (err) {
       process.stderr.write(`exe-os: session wrapper generation failed: ${err instanceof Error ? err.message : String(err)}
 `);
+    }
+    try {
+      execSync3("which codex", { encoding: "utf8", timeout: 5e3 });
+      const { runCodexInstaller: runCodexInstaller2 } = await Promise.resolve().then(() => (init_installer2(), installer_exports));
+      await runCodexInstaller2();
+    } catch {
     }
     restartDaemon();
   } catch (err) {