@askexenow/exe-os 0.9.77 → 0.9.79

package/dist/bin/cli.js

@@ -2619,8 +2619,8 @@ function deriveMachineKey() {
 }
 function readMachineId() {
   try {
-    const { readFileSync: readFileSync36 } = __require("fs");
-    return readFileSync36("/etc/machine-id", "utf-8").trim();
+    const { readFileSync: readFileSync37 } = __require("fs");
+    return readFileSync37("/etc/machine-id", "utf-8").trim();
   } catch {
     return "";
   }
@@ -8667,7 +8667,7 @@ var init_platform_procedures = __esm({
         title: "Customer patch triage \u2014 upstream bug vs customization",
         domain: "support",
         priority: "p0",
-        content: "When an agent encounters a suspected Exe OS bug, update breakage, MCP/tool failure, installer issue, memory/orchestration defect, or customer-local patch need, it MUST use create_bug_report. Do this before or alongside any local workaround so the report reaches AskExe support directly via the customer's license. Do NOT ask the founder for permission to file a required bug report. If create_bug_report is deferred/lazy-loaded, load it and call it. If it is unavailable in the live MCP surface, report 'create_bug_report unavailable in this session' and save a local report in exe/output \u2014 never claim the tool does not exist unless the live MCP surface was checked. Classify first: upstream_bug = reproducible exe-os/platform defect; customer_customization = identity, behavior, procedure, config, branding, workflow preference that belongs in customer-owned layers; emergency_hotfix = temporary local patch. For upstream bugs/emergency hotfixes include version, repro steps, expected/actual, files changed, workaround, and local diff summary. Avoid permanent platform-code patches unless founder approves; if a hotfix is unavoidable, document it in the bug report and re-check after npm update."
+        content: "When an agent encounters a suspected Exe OS bug, update breakage, MCP/tool failure, installer issue, memory/orchestration defect, or customer-local patch need, it MUST use create_bug_report. Do this before or alongside any local workaround so the report reaches AskExe support directly via the customer's license. Do NOT ask the founder for permission to file a required bug report. If create_bug_report is deferred/lazy-loaded, load it and call it. If it is unavailable in the live MCP surface, report 'create_bug_report unavailable in this session' and save a local report in exe/output \u2014 never claim the tool does not exist unless the live MCP surface was checked. If upstream delivery fails, run `exe-os support test` and include its result in the local report so AskExe can distinguish customer setup, license provisioning, and server intake issues. Classify first: upstream_bug = reproducible exe-os/platform defect; customer_customization = identity, behavior, procedure, config, branding, workflow preference that belongs in customer-owned layers; emergency_hotfix = temporary local patch. For upstream bugs/emergency hotfixes include version, repro steps, expected/actual, files changed, workaround, and local diff summary. Avoid permanent platform-code patches unless founder approves; if a hotfix is unavoidable, document it in the bug report and re-check after npm update."
       },
       // --- Operations ---
       {
@@ -8749,7 +8749,7 @@ var init_platform_procedures = __esm({
         title: "MCP tools \u2014 identity, behavior, and decisions",
         domain: "tool-use",
         priority: "p1",
-        content: "get_identity: read an agent's exe.md (Layer 1 identity). update_identity: write an agent's exe.md. Identity > behavior \u2014 use for permanent rules. store_behavior: record a correction or pattern for an agent (Layer 2 expertise). list_behaviors: view an agent's active behaviors. deactivate_behavior: soft-delete a stale or conflicting behavior. store_decision: record an ADR (architectural decision record). get_decision: retrieve a past decision by query. create_bug_report: customer-facing bug/support intake; use whenever an Exe OS bug or emergency hotfix is encountered so the report reaches AskExe directly. Customers only get report access; internal list/get/triage support tools are AskExe-only."
+        content: "get_identity: read an agent's exe.md (Layer 1 identity). update_identity: write an agent's exe.md. Identity > behavior \u2014 use for permanent rules. store_behavior: record a correction or pattern for an agent (Layer 2 expertise). list_behaviors: view an agent's active behaviors. deactivate_behavior: soft-delete a stale or conflicting behavior. store_decision: record an ADR (architectural decision record). get_decision: retrieve a past decision by query. create_bug_report: customer-facing bug/support intake; use whenever an Exe OS bug or emergency hotfix is encountered so the report reaches AskExe directly. Customers only get report access; internal list/get/triage support tools are AskExe-only. If a customer-side agent cannot send upstream, run `exe-os support test` from the terminal to verify local file write, license auth, support endpoint health, and upstream POST."
       },
       {
         title: "MCP tools \u2014 communication and messaging",
@@ -10945,12 +10945,310 @@ var init_exe_key = __esm({
   }
 });
 
+// src/bin/exe-support.ts
+var exe_support_exports = {};
+__export(exe_support_exports, {
+  main: () => main4
+});
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, unlinkSync as unlinkSync7, writeFileSync as writeFileSync13 } from "fs";
+import path20 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+async function main4(argv = process.argv.slice(2)) {
+  const command = argv[0] && !argv[0].startsWith("--") ? argv[0] : "health";
+  const json = argv.includes("--json");
+  const project = getArg(argv, "--project") ?? "support-smoke";
+  if (command === "help" || argv.includes("--help") || argv.includes("-h")) {
+    printHelp();
+    return;
+  }
+  if (command === "health") {
+    const result = await runHealth();
+    output(result, json, "health");
+    process.exitCode = hasFailures(result) ? 1 : 0;
+    return;
+  }
+  if (command === "test") {
+    const result = await runTest(project);
+    output(result, json, "test");
+    process.exitCode = hasFailures(result) ? 1 : 0;
+    return;
+  }
+  console.error("Usage: exe-os support health|test [--project <name>] [--json]");
+  process.exitCode = 1;
+}
+async function runHealth() {
+  const checks = [];
+  const endpoints = await resolveEndpoints();
+  checks.push(checkLocalWrite());
+  checks.push({
+    check: "license_key_present",
+    level: loadLicense() ? "pass" : "fail",
+    detail: loadLicense() ? "license.key found" : "missing ~/.exe-os/license.key; run exe-os setup or exe-os cloud setup",
+    next: loadLicense() ? void 0 : "Run `exe-os setup` or ask AskExe for the customer license key."
+  });
+  checks.push({
+    check: "license_token_cached",
+    level: readCachedLicenseToken() ? "pass" : "warn",
+    detail: readCachedLicenseToken() ? "cached license token found" : "no cached token yet; support can still use license.key",
+    next: readCachedLicenseToken() ? void 0 : "This is OK if license.key exists. It refreshes after cloud/license validation."
+  });
+  try {
+    const res = await fetch(endpoints.healthEndpoint, { method: "GET", signal: AbortSignal.timeout(1e4) });
+    const body = await safeJson2(res);
+    checks.push({
+      check: "support_health_endpoint",
+      level: res.ok && body?.status !== "down" ? "pass" : "fail",
+      detail: `${res.status} ${body?.status ?? res.statusText}`,
+      next: res.ok ? void 0 : "Check internet access, DNS, or AskExe support status."
+    });
+    for (const remote of body?.checks ?? []) {
+      const name = remote.name ?? "unknown";
+      checks.push({
+        check: `server_${name}`,
+        level: remote.ok === true ? "pass" : name === "admin_inbox_configured" ? "warn" : "fail",
+        detail: remote.detail ?? (remote.ok ? "ok" : "failed"),
+        next: remote.ok ? void 0 : "AskExe must fix this server-side."
+      });
+    }
+  } catch (err) {
+    checks.push({
+      check: "support_health_endpoint",
+      level: "fail",
+      detail: err instanceof Error ? err.message : String(err),
+      next: "Check internet access, then run `exe-os support health` again."
+    });
+  }
+  return checks;
+}
+async function runTest(project) {
+  const checks = await runHealth();
+  const endpoints = await resolveEndpoints();
+  const licenseKey = loadLicense();
+  const licenseToken = readCachedLicenseToken();
+  const id = randomUUID4();
+  const version = readPackageVersion();
+  const reportPath = writeLocalTestReport(id, project, version);
+  checks.push({ check: "local_report_file", level: "pass", detail: reportPath });
+  if (!licenseKey && !licenseToken) {
+    checks.push({
+      check: "upstream_post",
+      level: "fail",
+      detail: "not sent because this device has no license key/token",
+      next: "Run `exe-os setup` or ask AskExe to provision this customer device."
+    });
+    return checks;
+  }
+  const payload = {
+    id,
+    title: `TEST \u2014 ${project} support intake (${version})`,
+    classification: "unclear",
+    severity: "p3",
+    summary: "Synthetic exe-os support intake smoke test. Safe to close.",
+    customer_impact: "No customer impact; diagnostic only.",
+    reproduction_steps: ["Run exe-os support test"],
+    expected: "The report reaches AskExe support intake and can be triaged.",
+    actual: "Smoke test submitted by exe-os support test.",
+    package_version: `@askexenow/exe-os@${version}`,
+    project_name: project,
+    agent_id: "support-test",
+    agent_role: "diagnostic",
+    report_path: reportPath,
+    markdown: readFileSync14(reportPath, "utf8")
+  };
+  try {
+    const headers = { "content-type": "application/json" };
+    if (licenseKey) headers["x-exe-license-key"] = licenseKey;
+    if (licenseToken) headers["x-exe-license-token"] = licenseToken;
+    const res = await fetch(endpoints.bugEndpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(15e3)
+    });
+    const data = await safeJson2(res);
+    checks.push({
+      check: "upstream_post",
+      level: res.ok ? "pass" : "fail",
+      detail: res.ok ? `sent id=${String(data?.id ?? id)}` : summarizeHttpFailure(res.status, data),
+      next: res.ok ? void 0 : nextForPostFailure(res.status)
+    });
+    if (res.ok) {
+      checks.push(await maybeCloseAdmin(String(data?.id ?? id), endpoints.adminEndpoint, version));
+    }
+  } catch (err) {
+    checks.push({
+      check: "upstream_post",
+      level: "fail",
+      detail: err instanceof Error ? err.message : String(err),
+      next: "Check internet access, then run `exe-os support test` again."
+    });
+  }
+  return checks;
+}
+async function resolveEndpoints() {
+  const config = await loadConfig();
+  const bugEndpoint = process.env.EXE_SUPPORT_BUG_REPORT_ENDPOINT ?? config.support?.bugReportEndpoint ?? DEFAULT_BUG_ENDPOINT;
+  const healthEndpoint = process.env.EXE_SUPPORT_HEALTH_ENDPOINT ?? bugEndpoint.replace(/\/bug-reports\/?$/, "/health");
+  const adminEndpoint = process.env.ASKEXE_SUPPORT_ADMIN_ENDPOINT ?? process.env.EXE_SUPPORT_ADMIN_ENDPOINT ?? DEFAULT_ADMIN_ENDPOINT;
+  return { bugEndpoint, healthEndpoint, adminEndpoint };
+}
+function checkLocalWrite() {
+  const dir = path20.join(EXE_AI_DIR, "bug-reports");
+  const testPath = path20.join(dir, ".support-write-test");
+  try {
+    mkdirSync13(dir, { recursive: true, mode: 448 });
+    writeFileSync13(testPath, "ok\n", { mode: 384 });
+    unlinkSync7(testPath);
+    return { check: "local_bug_report_dir_writable", level: "pass", detail: dir };
+  } catch (err) {
+    return {
+      check: "local_bug_report_dir_writable",
+      level: "fail",
+      detail: err instanceof Error ? err.message : String(err),
+      next: "Fix permissions on ~/.exe-os or rerun setup on a writable user account."
+    };
+  }
+}
+function writeLocalTestReport(id, project, version) {
+  const dir = path20.join(EXE_AI_DIR, "bug-reports");
+  mkdirSync13(dir, { recursive: true, mode: 448 });
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const filePath = path20.join(dir, `${date}-support-intake-test-${id.slice(0, 8)}.md`);
+  writeFileSync13(filePath, `# TEST \u2014 ${project} support intake
+
+Report ID: ${id}
+Package: @askexenow/exe-os@${version}
+
+Synthetic smoke test from \`exe-os support test\`. Safe to close.
+`, { mode: 384 });
+  return filePath;
+}
+async function maybeCloseAdmin(id, adminEndpoint, version) {
+  const token = process.env.ASKEXE_SUPPORT_ADMIN_TOKEN ?? process.env.EXE_SUPPORT_ADMIN_TOKEN;
+  if (!token) {
+    return { check: "askexe_admin_autoclose", level: "warn", detail: "skipped; admin token is AskExe-only" };
+  }
+  try {
+    const res = await fetch(`${adminEndpoint}/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify({
+        status: "closed",
+        triage_notes: "Auto-closed synthetic support smoke test.",
+        fixed_version: version
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    return {
+      check: "askexe_admin_autoclose",
+      level: res.ok ? "pass" : "warn",
+      detail: res.ok ? "closed" : `${res.status} ${await res.text()}`,
+      next: res.ok ? void 0 : "Report was sent; AskExe can close the smoke report manually."
+    };
+  } catch (err) {
+    return {
+      check: "askexe_admin_autoclose",
+      level: "warn",
+      detail: err instanceof Error ? err.message : String(err),
+      next: "Report was sent; AskExe can close the smoke report manually."
+    };
+  }
+}
+function readPackageVersion() {
+  let dir = path20.dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 6; i++) {
+    const pkg = path20.join(dir, "package.json");
+    try {
+      const parsed = JSON.parse(readFileSync14(pkg, "utf8"));
+      if (parsed.version) return parsed.version;
+    } catch {
+    }
+    dir = path20.dirname(dir);
+  }
+  return "unknown";
+}
+async function safeJson2(res) {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function getArg(argv, name) {
+  const idx = argv.indexOf(name);
+  if (idx >= 0) return argv[idx + 1];
+  const prefix = `${name}=`;
+  const found = argv.find((arg) => arg.startsWith(prefix));
+  return found?.slice(prefix.length);
+}
+function hasFailures(rows) {
+  return rows.some((row) => row.level === "fail");
+}
+function summarizeHttpFailure(status, data) {
+  const error = data?.error;
+  return `${status} ${error?.message ?? JSON.stringify(data)}`;
+}
+function nextForPostFailure(status) {
+  if (status === 401) return "License credentials were not sent. Run `exe-os support health` and check license_key_present.";
+  if (status === 403) return "License is valid locally but not accepted by support intake. AskExe must check server-side license provisioning.";
+  if (status >= 500) return "AskExe support intake is unhealthy server-side. Try again shortly and report the local file path.";
+  return "Run `exe-os support health`; if it passes, send this output to AskExe.";
+}
+function printHelp() {
+  console.log(`
+exe-os support
+
+Customer-safe diagnostics for AskExe bug-report intake.
+
+Commands:
+  exe-os support health              Check local setup + AskExe support server health
+  exe-os support test --project hygo Send a safe smoke report end-to-end
+
+What success means:
+  health = this device looks ready
+  test   = AskExe received a real report from this device
+`);
+}
+function output(rows, json, command) {
+  if (json) {
+    console.log(JSON.stringify({ ok: !hasFailures(rows), checks: rows }, null, 2));
+    return;
+  }
+  console.log(`
+exe-os support ${command}
+`);
+  for (const row of rows) {
+    const icon = row.level === "pass" ? "\u2705" : row.level === "warn" ? "\u26A0\uFE0F " : "\u274C";
+    console.log(`${icon} ${row.check}: ${row.detail}`);
+    if (row.next) console.log(`   \u2192 ${row.next}`);
+  }
+  console.log("");
+  if (hasFailures(rows)) {
+    console.log("Result: not ready. Fix the failed item(s), then rerun this command.");
+  } else if (rows.some((row) => row.level === "warn")) {
+    console.log("Result: ready with warnings. Bug reports can be sent; warnings are informational unless AskExe asked for stricter validation.");
+  } else {
+    console.log(command === "test" ? "Result: ready. AskExe received the test report." : "Result: ready. Run `exe-os support test --project <customer>` for an end-to-end send test.");
+  }
+  console.log("");
+}
+var DEFAULT_BUG_ENDPOINT, DEFAULT_ADMIN_ENDPOINT;
+var init_exe_support = __esm({
+  "src/bin/exe-support.ts"() {
+    "use strict";
+    init_config();
+    init_license();
+    DEFAULT_BUG_ENDPOINT = "https://askexe.com/v1/support/bug-reports";
+    DEFAULT_ADMIN_ENDPOINT = "https://askexe.com/admin/support/bug-reports";
+  }
+});
+
 // src/bin/bulk-sync-postgres.ts
 var bulk_sync_postgres_exports = {};
 __export(bulk_sync_postgres_exports, {
-  main: () => main4
+  main: () => main5
 });
-async function main4() {
+async function main5() {
   process.env.EXE_IS_DAEMON = "1";
   await initStore({ lightweight: true });
   const client = getClient();
@@ -11013,7 +11311,7 @@ var init_bulk_sync_postgres = __esm({
     init_cloud_sync();
     BATCH_SIZE = 500;
     if (import.meta.url === `file://${process.argv[1]}`) {
-      main4().catch((err) => {
+      main5().catch((err) => {
         process.stderr.write(`[bulk-sync] FATAL: ${err instanceof Error ? err.message : String(err)}
 `);
         process.exit(1);
@@ -11030,12 +11328,12 @@ __export(backfill_conversations_exports, {
 import crypto6 from "crypto";
 import { createReadStream } from "fs";
 import { readdir as readdir2, stat } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 import { createInterface as createInterface3 } from "readline";
 import { homedir as homedir3 } from "os";
 import { parseArgs } from "util";
 async function findJsonlFiles(sinceDate, projectFilter) {
-  const projectsDir = path20.join(homedir3(), ".claude", "projects");
+  const projectsDir = path21.join(homedir3(), ".claude", "projects");
   const files = [];
   async function walk(dir, depth = 0) {
     if (depth > MAX_WALK_DEPTH) return;
@@ -11046,7 +11344,7 @@ async function findJsonlFiles(sinceDate, projectFilter) {
       return;
     }
     for (const entry of entries) {
-      const full = path20.join(dir, entry.name);
+      const full = path21.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "subagents" || entry.name === "tool-results") continue;
         await walk(full, depth + 1);
@@ -11071,7 +11369,7 @@ async function findJsonlFiles(sinceDate, projectFilter) {
       if (!entry.isDirectory()) continue;
       const decoded = decodeProjectDir(entry.name);
       if (decoded.toLowerCase().includes(projectFilter.toLowerCase())) {
-        await walk(path20.join(projectsDir, entry.name));
+        await walk(path21.join(projectsDir, entry.name));
       }
     }
   } else {
@@ -11088,14 +11386,14 @@ function decodeProjectDir(dirName) {
   return dirName;
 }
 function projectNameFromPath(filePath) {
-  const projectsDir = path20.join(homedir3(), ".claude", "projects");
-  const relative = path20.relative(projectsDir, filePath);
-  const projectDir = relative.split(path20.sep)[0] ?? "unknown";
+  const projectsDir = path21.join(homedir3(), ".claude", "projects");
+  const relative = path21.relative(projectsDir, filePath);
+  const projectDir = relative.split(path21.sep)[0] ?? "unknown";
   return decodeProjectDir(projectDir);
 }
 async function parseConversation(filePath) {
   const conv = {
-    sessionId: path20.basename(filePath, ".jsonl"),
+    sessionId: path21.basename(filePath, ".jsonl"),
     projectName: projectNameFromPath(filePath),
     cwd: void 0,
     startTime: void 0,
@@ -11159,7 +11457,7 @@ async function parseConversation(filePath) {
     }
   }
   if (conv.cwd) {
-    conv.projectName = path20.basename(conv.cwd);
+    conv.projectName = path21.basename(conv.cwd);
     const worktreeMatch = conv.cwd.match(/\.worktrees\/([^/]+)/);
     if (worktreeMatch?.[1]) {
       conv.agentId = worktreeMatch[1];
@@ -11811,9 +12109,9 @@ Unclassified: ${unclassified}
 }
 async function exportBatches(options) {
   const fs8 = await import("fs");
-  const path55 = await import("path");
+  const path56 = await import("path");
   const client = getClient();
-  const outDir = path55.join(process.cwd(), "exe/output/classifications/input");
+  const outDir = path56.join(process.cwd(), "exe/output/classifications/input");
   fs8.mkdirSync(outDir, { recursive: true });
   const countResult = await client.execute({
     sql: "SELECT COUNT(*) as cnt FROM memories WHERE intent IS NULL AND outcome IS NULL AND domain IS NULL",
@@ -11837,7 +12135,7 @@ async function exportBatches(options) {
       const text = String(row.text || "").replace(/\n/g, " ");
       return JSON.stringify({ id: row.id, text });
     });
-    const batchFile = path55.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
+    const batchFile = path56.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
     fs8.writeFileSync(batchFile, lines.join("\n") + "\n");
     exported += batch.rows.length;
     offset += options.batchSize;
@@ -11853,7 +12151,7 @@ async function exportBatches(options) {
 }
 async function importClassifications(importDir) {
   const fs8 = await import("fs");
-  const path55 = await import("path");
+  const path56 = await import("path");
   const client = getClient();
   const files = fs8.readdirSync(importDir).filter((f) => f.endsWith(".jsonl")).sort();
   process.stderr.write(`[backfill-metadata] Found ${files.length} JSONL files to import from ${importDir}
@@ -11861,7 +12159,7 @@ async function importClassifications(importDir) {
   let imported = 0;
   let invalid = 0;
   for (const file of files) {
-    const lines = fs8.readFileSync(path55.join(importDir, file), "utf-8").split("\n").filter(Boolean);
+    const lines = fs8.readFileSync(path56.join(importDir, file), "utf-8").split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const rec = JSON.parse(line);
@@ -12002,17 +12300,17 @@ __export(identity_exports, {
   listIdentities: () => listIdentities,
   updateIdentity: () => updateIdentity
 });
-import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync14 } from "fs";
 import { readdirSync as readdirSync4 } from "fs";
-import path21 from "path";
+import path22 from "path";
 import { createHash as createHash5 } from "crypto";
 function ensureDir() {
   if (!existsSync20(IDENTITY_DIR2)) {
-    mkdirSync13(IDENTITY_DIR2, { recursive: true });
+    mkdirSync14(IDENTITY_DIR2, { recursive: true });
   }
 }
 function identityPath(agentId) {
-  return path21.join(IDENTITY_DIR2, `${agentId}.md`);
+  return path22.join(IDENTITY_DIR2, `${agentId}.md`);
 }
 function sanitizeIdentityBody(body) {
   return body.replace(/<!--[\s\S]*?-->/g, "").trim();
@@ -12057,7 +12355,7 @@ function contentHash(content) {
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
   if (!existsSync20(filePath)) return null;
-  const raw = readFileSync14(filePath, "utf-8");
+  const raw = readFileSync15(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
   return {
     agentId,
@@ -12071,7 +12369,7 @@ async function updateIdentity(agentId, content, updatedBy) {
   ensureDir();
   const filePath = identityPath(agentId);
   const hash = contentHash(content);
-  writeFileSync13(filePath, content, "utf-8");
+  writeFileSync14(filePath, content, "utf-8");
   try {
     const client = getClient();
     await client.execute({
@@ -12129,15 +12427,15 @@ var init_identity = __esm({
     "use strict";
     init_config();
     init_database();
-    IDENTITY_DIR2 = path21.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR2 = path22.join(EXE_AI_DIR, "identity");
   }
 });
 
 // src/lib/orchestration-package.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { copyFileSync as copyFileSync4, existsSync as existsSync21, mkdirSync as mkdirSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync14 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import { copyFileSync as copyFileSync4, existsSync as existsSync21, mkdirSync as mkdirSync15, readFileSync as readFileSync16, writeFileSync as writeFileSync15 } from "fs";
 import os13 from "os";
-import path22 from "path";
+import path23 from "path";
 function ensureObject(value, label) {
   if (value == null || Array.isArray(value) || typeof value !== "object") {
     throw new Error(`${label} must be an object`);
@@ -12196,15 +12494,15 @@ function validateProcedureEntry(value, index) {
   };
 }
 function getRosterPath() {
-  return path22.join(os13.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+  return path23.join(os13.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
 }
 function getBackupPath() {
-  return path22.join(os13.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+  return path23.join(os13.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
 }
 function readRosterFile() {
   const rosterPath = getRosterPath();
   if (!existsSync21(rosterPath)) return [];
-  const raw = readFileSync15(rosterPath, "utf-8");
+  const raw = readFileSync16(rosterPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!Array.isArray(parsed)) {
     throw new Error("Roster file must contain a JSON array");
@@ -12216,7 +12514,7 @@ function writeRosterFile(roster) {
     throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
   }
   const rosterPath = getRosterPath();
-  mkdirSync14(path22.dirname(rosterPath), { recursive: true });
+  mkdirSync15(path23.dirname(rosterPath), { recursive: true });
   if (existsSync21(rosterPath)) {
     const currentRoster = readRosterFile();
     if (roster.length < currentRoster.length) {
@@ -12226,7 +12524,7 @@ function writeRosterFile(roster) {
     }
     copyFileSync4(rosterPath, getBackupPath());
   }
-  writeFileSync14(rosterPath, `${JSON.stringify(roster, null, 2)}
+  writeFileSync15(rosterPath, `${JSON.stringify(roster, null, 2)}
 `, "utf-8");
 }
 function buildImportedRosterEntries(roster, timestamp) {
@@ -12246,7 +12544,7 @@ async function insertBehaviors(behaviors, timestamp) {
       sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
             VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
       args: [
-        randomUUID4(),
+        randomUUID5(),
         behavior.agent_id,
         behavior.project_name,
         behavior.domain,
@@ -12271,7 +12569,7 @@ async function insertProcedures(procedures, timestamp, options) {
       sql: `INSERT INTO company_procedures (id, title, content, priority, domain, active, created_at, updated_at)
             VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
       args: [
-        randomUUID4(),
+        randomUUID5(),
         procedure.title,
         procedure.content,
         procedure.priority,
@@ -12493,8 +12791,8 @@ var exe_export_exports = {};
 __export(exe_export_exports, {
   runExeExport: () => runExeExport
 });
-import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync15 } from "fs";
-import path23 from "path";
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync16 } from "fs";
+import path24 from "path";
 function printUsage() {
   process.stdout.write("Usage: exe-os export --output <path>\n");
 }
@@ -12515,8 +12813,8 @@ async function runExeExport(argv = process.argv.slice(2)) {
   await initStore();
   try {
     const pkg = await exportOrchestration("cli");
-    mkdirSync15(path23.dirname(outputPath), { recursive: true });
-    writeFileSync15(outputPath, `${JSON.stringify(pkg, null, 2)}
+    mkdirSync16(path24.dirname(outputPath), { recursive: true });
+    writeFileSync16(outputPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
     process.stdout.write(
       `Exported ${pkg.roster.length} roster entries, ${Object.keys(pkg.identities).length} identities, ${pkg.behaviors.length} behaviors, ${pkg.procedures.length} procedures to ${outputPath}
@@ -12552,7 +12850,7 @@ var exe_import_exports = {};
 __export(exe_import_exports, {
   runExeImport: () => runExeImport
 });
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 function printUsage2() {
   process.stdout.write("Usage: exe-os import --from <path> [--merge]\n");
 }
@@ -12575,7 +12873,7 @@ async function runExeImport(argv = process.argv.slice(2)) {
   if (parsed == null) return;
   await initStore();
   try {
-    const raw = readFileSync16(parsed.packagePath, "utf-8");
+    const raw = readFileSync17(parsed.packagePath, "utf-8");
     const pkg = validatePackage(JSON.parse(raw));
     const result = await importOrchestration(pkg, parsed.strategy);
     process.stdout.write(
@@ -12616,14 +12914,14 @@ __export(session_registry_exports, {
   refreshSessionProject: () => refreshSessionProject,
   registerSession: () => registerSession
 });
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync16, mkdirSync as mkdirSync16, existsSync as existsSync22 } from "fs";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync17, mkdirSync as mkdirSync17, existsSync as existsSync22 } from "fs";
 import { execSync as execSync5 } from "child_process";
-import path24 from "path";
+import path25 from "path";
 import os14 from "os";
 function registerSession(entry) {
-  const dir = path24.dirname(REGISTRY_PATH);
+  const dir = path25.dirname(REGISTRY_PATH);
   if (!existsSync22(dir)) {
-    mkdirSync16(dir, { recursive: true });
+    mkdirSync17(dir, { recursive: true });
   }
   const sessions = listSessions();
   const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
@@ -12632,7 +12930,7 @@ function registerSession(entry) {
   } else {
     sessions.push(entry);
   }
-  writeFileSync16(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+  writeFileSync17(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
 }
 function refreshSessionProject(windowName, projectDir) {
   const sessions = listSessions();
@@ -12640,13 +12938,13 @@ function refreshSessionProject(windowName, projectDir) {
   if (!entry || entry.projectDir === projectDir) return;
   entry.projectDir = projectDir;
   try {
-    writeFileSync16(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+    writeFileSync17(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
   } catch {
   }
 }
 function listSessions() {
   try {
-    const raw = readFileSync17(REGISTRY_PATH, "utf8");
+    const raw = readFileSync18(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -12667,7 +12965,7 @@ function pruneStaleSessions() {
   const alive = sessions.filter((s) => liveSet.has(s.windowName));
   const pruned = sessions.length - alive.length;
   if (pruned > 0) {
-    writeFileSync16(REGISTRY_PATH, JSON.stringify(alive, null, 2));
+    writeFileSync17(REGISTRY_PATH, JSON.stringify(alive, null, 2));
   }
   return pruned;
 }
@@ -12675,7 +12973,7 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path24.join(os14.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path25.join(os14.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
@@ -12931,17 +13229,17 @@ __export(intercom_queue_exports, {
   queueIntercom: () => queueIntercom,
   readQueue: () => readQueue
 });
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync17, renameSync as renameSync5, existsSync as existsSync23, mkdirSync as mkdirSync17 } from "fs";
-import path25 from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync18, renameSync as renameSync5, existsSync as existsSync23, mkdirSync as mkdirSync18 } from "fs";
+import path26 from "path";
 import os15 from "os";
 function ensureDir2() {
-  const dir = path25.dirname(QUEUE_PATH);
-  if (!existsSync23(dir)) mkdirSync17(dir, { recursive: true });
+  const dir = path26.dirname(QUEUE_PATH);
+  if (!existsSync23(dir)) mkdirSync18(dir, { recursive: true });
 }
 function readQueue() {
   try {
     if (!existsSync23(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync18(QUEUE_PATH, "utf8"));
+    return JSON.parse(readFileSync19(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -12949,7 +13247,7 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir2();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync17(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync18(tmp, JSON.stringify(queue, null, 2));
   renameSync5(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -13041,20 +13339,20 @@ var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path25.join(os15.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path26.join(os15.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path25.join(os15.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path26.join(os15.homedir(), ".exe-os", "intercom.log");
   }
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync19, existsSync as existsSync24 } from "fs";
-import path26 from "path";
+import { readFileSync as readFileSync20, existsSync as existsSync24 } from "fs";
+import path27 from "path";
 function getLicenseSync() {
   try {
     if (!existsSync24(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync19(CACHE_PATH2, "utf8"));
+    const raw = JSON.parse(readFileSync20(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -13093,7 +13391,7 @@ function assertEmployeeLimitSync(rosterPath) {
   let count = 0;
   try {
     if (existsSync24(filePath)) {
-      const raw = readFileSync19(filePath, "utf8");
+      const raw = readFileSync20(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -13122,7 +13420,7 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path26.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path27.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
@@ -13167,12 +13465,12 @@ var init_task_scope = __esm({
 
 // src/lib/notifications.ts
 import crypto7 from "crypto";
-import path27 from "path";
+import path28 from "path";
 import os16 from "os";
 import {
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   readdirSync as readdirSync5,
-  unlinkSync as unlinkSync7,
+  unlinkSync as unlinkSync8,
   existsSync as existsSync25,
   rmdirSync
 } from "fs";
@@ -13258,7 +13556,7 @@ var init_session_kill_telemetry = __esm({
 
 // src/lib/project-name.ts
 import { execSync as execSync8 } from "child_process";
-import path28 from "path";
+import path29 from "path";
 function getProjectName(cwd2) {
   const dir = cwd2 ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -13271,7 +13569,7 @@ function getProjectName(cwd2) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path28.dirname(gitCommonDir);
+      repoRoot = path29.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync8("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -13280,11 +13578,11 @@ function getProjectName(cwd2) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path28.basename(repoRoot);
+    _cached2 = path29.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path28.basename(dir);
+    _cached2 = path29.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -13378,11 +13676,11 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto9 from "crypto";
-import path29 from "path";
+import path30 from "path";
 import os17 from "os";
 import { execSync as execSync9 } from "child_process";
 import { mkdir as mkdir5, writeFile as writeFile5, appendFile } from "fs/promises";
-import { existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync22 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -13581,8 +13879,8 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir5(path29.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir5(path29.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir5(path30.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir5(path30.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -13618,9 +13916,9 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path29.join(os17.homedir(), ".exe-os");
-      const mdPath = path29.join(EXE_OS_DIR, taskFile);
-      const mdDir = path29.dirname(mdPath);
+      const EXE_OS_DIR = path30.join(os17.homedir(), ".exe-os");
+      const mdPath = path30.join(EXE_OS_DIR, taskFile);
+      const mdDir = path30.dirname(mdPath);
       if (!existsSync26(mdDir)) await mkdir5(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
@@ -13725,12 +14023,12 @@ function isTmuxSessionAlive(identifier) {
   if (!identifier || identifier === "unknown") return true;
   try {
     if (identifier.startsWith("%")) {
-      const output = execSync9("tmux list-panes -a -F '#{pane_id}'", {
+      const output2 = execSync9("tmux list-panes -a -F '#{pane_id}'", {
         timeout: 2e3,
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       });
-      return output.split("\n").some((l) => l.trim() === identifier);
+      return output2.split("\n").some((l) => l.trim() === identifier);
     } else {
       execSync9(`tmux has-session -t ${JSON.stringify(identifier)}`, {
         timeout: 2e3,
@@ -13921,7 +14219,7 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path29.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path30.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
     if (existsSync26(archPath)) return;
     const template = [
@@ -13956,10 +14254,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path29.join(baseDir, ".gitignore");
+  const gitignorePath = path30.join(baseDir, ".gitignore");
   try {
     if (existsSync26(gitignorePath)) {
-      const content = readFileSync21(gitignorePath, "utf-8");
+      const content = readFileSync22(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -14002,8 +14300,8 @@ __export(tasks_review_exports, {
   isStale: () => isStale,
   listPendingReviews: () => listPendingReviews
 });
-import path30 from "path";
-import { existsSync as existsSync27, readdirSync as readdirSync6, unlinkSync as unlinkSync8 } from "fs";
+import path31 from "path";
+import { existsSync as existsSync27, readdirSync as readdirSync6, unlinkSync as unlinkSync9 } from "fs";
 function formatAge(isoTimestamp) {
   if (!isoTimestamp) return "";
   const ms = Date.now() - new Date(isoTimestamp).getTime();
@@ -14272,11 +14570,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path30.join(EXE_AI_DIR, "session-cache");
+    const cacheDir = path31.join(EXE_AI_DIR, "session-cache");
     if (existsSync27(cacheDir)) {
       for (const f of readdirSync6(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync8(path30.join(cacheDir, f));
+          unlinkSync9(path31.join(cacheDir, f));
         }
       }
     }
@@ -14298,7 +14596,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path31 from "path";
+import path32 from "path";
 import { readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now2) {
   const client = getClient();
@@ -14315,7 +14613,7 @@ async function cascadeUnblock(taskId, baseDir, now2) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path31.join(baseDir, String(ur.task_file));
+        const ubFile = path32.join(baseDir, String(ur.task_file));
         let ubContent = await readFile5(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -14500,8 +14798,8 @@ async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
   const { existsSync: existsSync41 } = await import("fs");
-  const path55 = await import("path");
-  const modelPath = path55.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  const path56 = await import("path");
+  const modelPath = path56.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
   if (!existsSync41(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
@@ -14868,8 +15166,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path32 from "path";
-import { writeFileSync as writeFileSync18, mkdirSync as mkdirSync18, unlinkSync as unlinkSync9 } from "fs";
+import path33 from "path";
+import { writeFileSync as writeFileSync19, mkdirSync as mkdirSync19, unlinkSync as unlinkSync10 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -14888,14 +15186,14 @@ async function updateTask(input) {
   const { row, taskFile, now: now2, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path32.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path32.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path33.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path33.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
-      mkdirSync18(cacheDir, { recursive: true });
-      writeFileSync18(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync19(cacheDir, { recursive: true });
+      writeFileSync19(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled" || input.status === "closed") {
       try {
-        unlinkSync9(cachePath);
+        unlinkSync10(cachePath);
       } catch {
       }
     }
@@ -15361,13 +15659,13 @@ __export(tmux_routing_exports, {
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
 import { execFileSync as execFileSync3, execSync as execSync10 } from "child_process";
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync19, mkdirSync as mkdirSync19, existsSync as existsSync28, appendFileSync as appendFileSync2, readdirSync as readdirSync7 } from "fs";
-import path33 from "path";
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync20, mkdirSync as mkdirSync20, existsSync as existsSync28, appendFileSync as appendFileSync2, readdirSync as readdirSync7 } from "fs";
+import path34 from "path";
 import os18 from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { unlinkSync as unlinkSync10 } from "fs";
+import { unlinkSync as unlinkSync11 } from "fs";
 function spawnLockPath(sessionName) {
-  return path33.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path34.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -15379,12 +15677,12 @@ function isProcessAlive(pid) {
 }
 function acquireSpawnLock2(sessionName) {
   if (!existsSync28(SPAWN_LOCK_DIR)) {
-    mkdirSync19(SPAWN_LOCK_DIR, { recursive: true });
+    mkdirSync20(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
   if (existsSync28(lockFile)) {
     try {
-      const lock = JSON.parse(readFileSync22(lockFile, "utf8"));
+      const lock = JSON.parse(readFileSync23(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
       if (isProcessAlive(lock.pid) && age < 6e4) {
         return false;
@@ -15392,20 +15690,20 @@ function acquireSpawnLock2(sessionName) {
     } catch {
     }
   }
-  writeFileSync19(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync20(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
 function releaseSpawnLock2(sessionName) {
   try {
-    unlinkSync10(spawnLockPath(sessionName));
+    unlinkSync11(spawnLockPath(sessionName));
   } catch {
   }
 }
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const scriptPath = path33.join(
-      path33.dirname(thisFile),
+    const scriptPath = path34.join(
+      path34.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
@@ -15419,12 +15717,12 @@ function exportBehaviorsSync(agentId, projectName, sessionKey) {
   const script = resolveBehaviorsExporterScript();
   if (!script) return null;
   try {
-    const output = execFileSync3(
+    const output2 = execFileSync3(
       process.execPath,
       [script, agentId, projectName, sessionKey],
       { encoding: "utf-8", timeout: BEHAVIORS_EXPORT_TIMEOUT_MS }
     ).trim();
-    return output.length > 0 ? output : null;
+    return output2.length > 0 ? output2 : null;
   } catch (err) {
     process.stderr.write(
       `[tmux-routing] behaviors export failed for ${agentId}: ${err instanceof Error ? err.message : String(err)}
@@ -15477,11 +15775,11 @@ function extractRootExe(name) {
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
   if (!existsSync28(SESSION_CACHE)) {
-    mkdirSync19(SESSION_CACHE, { recursive: true });
+    mkdirSync20(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path33.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync19(filePath, JSON.stringify({
+  const filePath = path34.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync20(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -15489,7 +15787,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync22(path33.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync23(path34.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -15497,8 +15795,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync22(
-      path33.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync23(
+      path34.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -15569,7 +15867,7 @@ async function verifyPaneAtCapacity(sessionName) {
 function readDebounceState() {
   try {
     if (!existsSync28(DEBOUNCE_FILE)) return {};
-    const raw = JSON.parse(readFileSync22(DEBOUNCE_FILE, "utf8"));
+    const raw = JSON.parse(readFileSync23(DEBOUNCE_FILE, "utf8"));
     const state = {};
     for (const [key, val] of Object.entries(raw)) {
       if (typeof val === "number") {
@@ -15585,8 +15883,8 @@ function readDebounceState() {
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync28(SESSION_CACHE)) mkdirSync19(SESSION_CACHE, { recursive: true });
-    writeFileSync19(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync28(SESSION_CACHE)) mkdirSync20(SESSION_CACHE, { recursive: true });
+    writeFileSync20(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
@@ -15685,7 +15983,7 @@ function sendIntercom(targetSession) {
       try {
         const rawAgent = targetSession.split("-")[0] ?? targetSession;
         const agent = baseAgentName(rawAgent);
-        const markerPath = path33.join(SESSION_CACHE, `current-task-${agent}.json`);
+        const markerPath = path34.join(SESSION_CACHE, `current-task-${agent}.json`);
         if (existsSync28(markerPath)) {
           logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker + not idle \u2014 will auto-chain)`);
           return "debounced";
@@ -15696,7 +15994,7 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const taskDir = path33.join(process.cwd(), "exe", agent);
+      const taskDir = path34.join(process.cwd(), "exe", agent);
       if (existsSync28(taskDir)) {
         const files = readdirSync7(taskDir).filter(
           (f) => f.endsWith(".md") && f !== "DONE.txt"
@@ -15856,26 +16154,26 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const transport = getTransport();
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path33.join(os18.homedir(), ".exe-os", "session-logs");
-  const logFile = path33.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  const logDir = path34.join(os18.homedir(), ".exe-os", "session-logs");
+  const logFile = path34.join(logDir, `${instanceLabel}-${Date.now()}.log`);
   if (!existsSync28(logDir)) {
-    mkdirSync19(logDir, { recursive: true });
+    mkdirSync20(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const cleanupScript = path33.join(path33.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    const cleanupScript = path34.join(path34.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
     if (existsSync28(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path33.join(os18.homedir(), ".claude.json");
+    const claudeJsonPath = path34.join(os18.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync22(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync23(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -15883,17 +16181,17 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync19(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync20(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path33.join(os18.homedir(), ".claude", "projects");
+    const settingsDir = path34.join(os18.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path33.join(settingsDir, normalizedKey);
-    const settingsPath = path33.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path34.join(settingsDir, normalizedKey);
+    const settingsPath = path34.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync22(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync23(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -15921,8 +16219,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync19(projSettingsDir, { recursive: true });
-      writeFileSync19(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync20(projSettingsDir, { recursive: true });
+      writeFileSync20(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
   }
@@ -15937,7 +16235,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath2 = path33.join(
+    const identityPath2 = path34.join(
       os18.homedir(),
       ".exe-os",
       "identity",
@@ -15960,7 +16258,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path33.basename(spawnCwd),
+      path34.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -15975,16 +16273,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path33.join(os18.homedir(), ".exe-os", "session-cache");
-    mkdirSync19(ctxDir, { recursive: true });
-    const ctxFile = path33.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path34.join(os18.homedir(), ".exe-os", "session-cache");
+    mkdirSync20(ctxDir, { recursive: true });
+    const ctxFile = path34.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
       `Your parent coordinator session is ${exeSession}.`,
       `Your employees (if any) use the -${exeSession} suffix.`
     ].join("\n");
-    writeFileSync19(ctxFile, ctxContent);
+    writeFileSync20(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -16067,8 +16365,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path33.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync19(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path34.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync20(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
       provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
@@ -16143,15 +16441,15 @@ var init_tmux_routing = __esm({
     init_plan_limits();
     init_employees();
     init_agent_symlinks();
-    SPAWN_LOCK_DIR = path33.join(os18.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path33.join(os18.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path34.join(os18.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path34.join(os18.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
     CODEX_DEBOUNCE_MS = 12e4;
-    INTERCOM_LOG2 = path33.join(os18.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path33.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path34.join(os18.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path34.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
   }
@@ -16453,9 +16751,9 @@ __export(active_agent_exports, {
   resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync20, mkdirSync as mkdirSync20, unlinkSync as unlinkSync11, readdirSync as readdirSync8 } from "fs";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync21, mkdirSync as mkdirSync21, unlinkSync as unlinkSync12, readdirSync as readdirSync8 } from "fs";
 import { execSync as execSync11 } from "child_process";
-import path34 from "path";
+import path35 from "path";
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
   if (!candidate.startsWith(baseName)) return false;
@@ -16499,12 +16797,12 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path34.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path35.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
-    mkdirSync20(CACHE_DIR, { recursive: true });
-    writeFileSync20(
+    mkdirSync21(CACHE_DIR, { recursive: true });
+    writeFileSync21(
       getMarkerPath(),
       JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
@@ -16513,7 +16811,7 @@ function writeActiveAgent(agentId, agentRole) {
 }
 function clearActiveAgent() {
   try {
-    unlinkSync11(getMarkerPath());
+    unlinkSync12(getMarkerPath());
   } catch {
   }
 }
@@ -16522,14 +16820,14 @@ function getActiveAgent() {
   if (httpCtx) return httpCtx;
   try {
     const markerPath = getMarkerPath();
-    const raw = readFileSync23(markerPath, "utf8");
+    const raw = readFileSync24(markerPath, "utf8");
     const data = JSON.parse(raw);
     if (data.agentId) {
       if (data.startedAt) {
         const age = Date.now() - new Date(data.startedAt).getTime();
         if (age > STALE_MS) {
           try {
-            unlinkSync11(markerPath);
+            unlinkSync12(markerPath);
           } catch {
           }
         } else {
@@ -16570,14 +16868,14 @@ function getAllActiveAgents() {
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync23(path34.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync24(path35.join(CACHE_DIR, file), "utf8");
         const data = JSON.parse(raw);
         if (!data.agentId) continue;
         if (data.startedAt) {
           const age = Date.now() - new Date(data.startedAt).getTime();
           if (age > STALE_MS) {
             try {
-              unlinkSync11(path34.join(CACHE_DIR, file));
+              unlinkSync12(path35.join(CACHE_DIR, file));
             } catch {
             }
             continue;
@@ -16600,11 +16898,11 @@ function getAllActiveAgents() {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync11(path34.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync12(path35.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync11(path34.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync12(path35.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -16616,7 +16914,7 @@ var init_active_agent = __esm({
     init_session_key();
     init_agent_context();
     init_employees();
-    CACHE_DIR = path34.join(EXE_AI_DIR, "session-cache");
+    CACHE_DIR = path35.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
 });
@@ -17269,17 +17567,17 @@ All memory, tasks, behaviors, documents, and wiki content belonging to {{company
 // src/bin/exe-rename.ts
 var exe_rename_exports = {};
 __export(exe_rename_exports, {
-  main: () => main5,
+  main: () => main6,
   renameEmployee: () => renameEmployee
 });
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync21, renameSync as renameSync6, unlinkSync as unlinkSync12, existsSync as existsSync29 } from "fs";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync22, renameSync as renameSync6, unlinkSync as unlinkSync13, existsSync as existsSync29 } from "fs";
 import { execSync as execSync12 } from "child_process";
-import path35 from "path";
+import path36 from "path";
 import { homedir as homedir4 } from "os";
 async function renameEmployee(oldName, newName, opts = {}) {
-  const rosterPath = opts.rosterPath ?? path35.join(homedir4(), ".exe-os", "exe-employees.json");
-  const identityDir = opts.identityDir ?? path35.join(homedir4(), ".exe-os", "identity");
-  const agentsDir = opts.agentsDir ?? path35.join(homedir4(), ".claude", "agents");
+  const rosterPath = opts.rosterPath ?? path36.join(homedir4(), ".exe-os", "exe-employees.json");
+  const identityDir = opts.identityDir ?? path36.join(homedir4(), ".exe-os", "identity");
+  const agentsDir = opts.agentsDir ?? path36.join(homedir4(), ".claude", "agents");
   const validation = validateEmployeeName(newName);
   if (!validation.valid) {
     return { success: false, error: validation.error };
@@ -17309,39 +17607,39 @@ async function renameEmployee(oldName, newName, opts = {}) {
       undo: () => {
         employee.name = originalName;
         employee.systemPrompt = originalPrompt;
-        writeFileSync21(rosterPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
+        writeFileSync22(rosterPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
       }
     });
-    const oldIdentityPath = path35.join(identityDir, `${rosterOldName}.md`);
-    const newIdentityPath = path35.join(identityDir, `${newName}.md`);
+    const oldIdentityPath = path36.join(identityDir, `${rosterOldName}.md`);
+    const newIdentityPath = path36.join(identityDir, `${newName}.md`);
     if (existsSync29(oldIdentityPath)) {
-      const content = readFileSync24(oldIdentityPath, "utf-8");
+      const content = readFileSync25(oldIdentityPath, "utf-8");
       const updatedContent = rewriteRenamedEmployeeContent(content, rosterOldName, newName);
       renameSync6(oldIdentityPath, newIdentityPath);
-      writeFileSync21(newIdentityPath, updatedContent, "utf-8");
+      writeFileSync22(newIdentityPath, updatedContent, "utf-8");
       rollbackStack.push({
         description: "restore identity file",
         undo: () => {
           if (existsSync29(newIdentityPath)) {
-            writeFileSync21(newIdentityPath, content, "utf-8");
+            writeFileSync22(newIdentityPath, content, "utf-8");
             renameSync6(newIdentityPath, oldIdentityPath);
           }
         }
       });
     }
-    const oldAgentPath = path35.join(agentsDir, `${rosterOldName}.md`);
-    const newAgentPath = path35.join(agentsDir, `${newName}.md`);
+    const oldAgentPath = path36.join(agentsDir, `${rosterOldName}.md`);
+    const newAgentPath = path36.join(agentsDir, `${newName}.md`);
     if (existsSync29(oldAgentPath)) {
-      const agentContent = readFileSync24(oldAgentPath, "utf-8");
+      const agentContent = readFileSync25(oldAgentPath, "utf-8");
       const updatedAgentContent = rewriteRenamedEmployeeContent(agentContent, rosterOldName, newName);
       renameSync6(oldAgentPath, newAgentPath);
-      writeFileSync21(newAgentPath, updatedAgentContent, "utf-8");
+      writeFileSync22(newAgentPath, updatedAgentContent, "utf-8");
       rollbackStack.push({
         description: "restore agent file",
         undo: () => {
           if (existsSync29(newAgentPath)) {
             renameSync6(newAgentPath, oldAgentPath);
-            writeFileSync21(oldAgentPath, agentContent, "utf-8");
+            writeFileSync22(oldAgentPath, agentContent, "utf-8");
           }
         }
       });
@@ -17423,12 +17721,12 @@ function removeOldSymlinks(name) {
   try {
     const exeBinPath = findExeBin2();
     if (!exeBinPath) return;
-    const binDir = path35.dirname(exeBinPath);
+    const binDir = path36.dirname(exeBinPath);
     for (const suffix of ["", "-opencode"]) {
-      const linkPath = path35.join(binDir, `${name}${suffix}`);
+      const linkPath = path36.join(binDir, `${name}${suffix}`);
       if (existsSync29(linkPath)) {
         try {
-          unlinkSync12(linkPath);
+          unlinkSync13(linkPath);
         } catch {
         }
       }
@@ -17436,7 +17734,7 @@ function removeOldSymlinks(name) {
   } catch {
   }
 }
-async function main5() {
+async function main6() {
   const args2 = process.argv.slice(2);
   if (args2.length < 2) {
     console.error("Usage: exe-os rename <oldName> <newName>");
@@ -17464,7 +17762,7 @@ var init_exe_rename = __esm({
     init_employee_templates();
     init_is_main();
     if (isMainModule(import.meta.url)) {
-      main5().catch((err) => {
+      main6().catch((err) => {
         console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
       });
@@ -17473,13 +17771,13 @@ var init_exe_rename = __esm({
 });
 
 // src/lib/model-downloader.ts
-import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync30, unlinkSync as unlinkSync13, renameSync as renameSync7 } from "fs";
+import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync30, unlinkSync as unlinkSync14, renameSync as renameSync7 } from "fs";
 import { mkdir as mkdir6 } from "fs/promises";
 import { createHash as createHash6 } from "crypto";
-import path36 from "path";
+import path37 from "path";
 async function downloadModel(opts) {
   const { destDir, onProgress, fetchFn = globalThis.fetch } = opts;
-  const destPath = path36.join(destDir, LOCAL_FILENAME);
+  const destPath = path37.join(destDir, LOCAL_FILENAME);
   const tmpPath = destPath + ".tmp";
   await mkdir6(destDir, { recursive: true });
   if (existsSync30(destPath)) {
@@ -17494,7 +17792,7 @@ async function downloadModel(opts) {
   let downloaded = 0;
   for (let attempt = 1; attempt <= MAX_RETRIES4; attempt++) {
     try {
-      if (existsSync30(tmpPath)) unlinkSync13(tmpPath);
+      if (existsSync30(tmpPath)) unlinkSync14(tmpPath);
       const response = await fetchFn(GGUF_URL, {
         redirect: "follow",
         signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
@@ -17526,7 +17824,7 @@ async function downloadModel(opts) {
       }
       const actualHash = hash.digest("hex");
       if (actualHash !== EXPECTED_SHA256) {
-        unlinkSync13(tmpPath);
+        unlinkSync14(tmpPath);
         throw new Error(
           `SHA256 mismatch: expected ${EXPECTED_SHA256}, got ${actualHash}`
         );
@@ -17539,7 +17837,7 @@ async function downloadModel(opts) {
         process.stderr.write(`
 Download attempt ${attempt} failed, retrying...
 `);
-        if (existsSync30(tmpPath)) unlinkSync13(tmpPath);
+        if (existsSync30(tmpPath)) unlinkSync14(tmpPath);
       }
     }
   }
@@ -18113,37 +18411,37 @@ __export(session_wrappers_exports, {
 });
 import {
   existsSync as existsSync31,
-  readFileSync as readFileSync25,
-  writeFileSync as writeFileSync22,
-  mkdirSync as mkdirSync21,
+  readFileSync as readFileSync26,
+  writeFileSync as writeFileSync23,
+  mkdirSync as mkdirSync22,
   chmodSync as chmodSync3,
   readdirSync as readdirSync9,
-  unlinkSync as unlinkSync14
+  unlinkSync as unlinkSync15
 } from "fs";
 import { execSync as execSync13 } from "child_process";
-import path37 from "path";
+import path38 from "path";
 import { homedir as homedir5 } from "os";
 function generateSessionWrappers(packageRoot, homeDir) {
   const home = homeDir ?? homedir5();
-  const binDir = path37.join(home, ".exe-os", "bin");
-  const rosterPath = path37.join(home, ".exe-os", "exe-employees.json");
+  const binDir = path38.join(home, ".exe-os", "bin");
+  const rosterPath = path38.join(home, ".exe-os", "exe-employees.json");
   const shouldMirrorToGlobalBin = homeDir === void 0;
-  mkdirSync21(binDir, { recursive: true });
-  const exeStartDst = path37.join(binDir, "exe-start");
+  mkdirSync22(binDir, { recursive: true });
+  const exeStartDst = path38.join(binDir, "exe-start");
   const candidates = [
-    path37.join(packageRoot, "dist", "bin", "exe-start.sh"),
-    path37.join(packageRoot, "src", "bin", "exe-start.sh")
+    path38.join(packageRoot, "dist", "bin", "exe-start.sh"),
+    path38.join(packageRoot, "src", "bin", "exe-start.sh")
   ];
   for (const src of candidates) {
     if (existsSync31(src)) {
-      writeFileSync22(exeStartDst, readFileSync25(src));
+      writeFileSync23(exeStartDst, readFileSync26(src));
       chmodSync3(exeStartDst, 493);
       break;
     }
   }
   let employees = [];
   try {
-    employees = JSON.parse(readFileSync25(rosterPath, "utf8"));
+    employees = JSON.parse(readFileSync26(rosterPath, "utf8"));
   } catch {
     return { created: 0, pathConfigured: false };
   }
@@ -18153,11 +18451,11 @@ function generateSessionWrappers(packageRoot, homeDir) {
   try {
     for (const f of readdirSync9(binDir)) {
       if (f === "exe-start") continue;
-      const fPath = path37.join(binDir, f);
+      const fPath = path38.join(binDir, f);
       try {
-        const content = readFileSync25(fPath, "utf8");
+        const content = readFileSync26(fPath, "utf8");
         if (content.includes("exe-start")) {
-          unlinkSync14(fPath);
+          unlinkSync15(fPath);
         }
       } catch {
       }
@@ -18171,21 +18469,21 @@ exec "${exeStartDst}" "$0" "$@"
   const globalBinDir = shouldMirrorToGlobalBin ? resolveGlobalBinDir() : null;
   for (const emp of employees) {
     for (let n = 1; n <= MAX_N; n++) {
-      writeWrapper(path37.join(binDir, `${emp.name}${n}`), wrapperContent);
+      writeWrapper(path38.join(binDir, `${emp.name}${n}`), wrapperContent);
       if (globalBinDir) {
-        writeWrapper(path37.join(globalBinDir, `${emp.name}${n}`), wrapperContent);
+        writeWrapper(path38.join(globalBinDir, `${emp.name}${n}`), wrapperContent);
       }
       created++;
-      writeWrapper(path37.join(binDir, `${emp.name}${n}-codex`), wrapperContent);
+      writeWrapper(path38.join(binDir, `${emp.name}${n}-codex`), wrapperContent);
       if (globalBinDir) {
-        writeWrapper(path37.join(globalBinDir, `${emp.name}${n}-codex`), wrapperContent);
+        writeWrapper(path38.join(globalBinDir, `${emp.name}${n}-codex`), wrapperContent);
       }
       created++;
     }
   }
   const codexLauncherCandidates = [
-    path37.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
-    path37.join(packageRoot, "src", "bin", "exe-start-codex.ts")
+    path38.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
+    path38.join(packageRoot, "src", "bin", "exe-start-codex.ts")
   ];
   let codexLauncher = null;
   for (const c of codexLauncherCandidates) {
@@ -18196,11 +18494,11 @@ exec "${exeStartDst}" "$0" "$@"
   }
   if (codexLauncher) {
     for (const emp of employees) {
-      const wrapperPath = path37.join(binDir, `${emp.name}-codex`);
+      const wrapperPath = path38.join(binDir, `${emp.name}-codex`);
       const content = `#!/bin/bash
 exec node "${codexLauncher}" --agent ${emp.name} "$@"
 `;
-      writeFileSync22(wrapperPath, content);
+      writeFileSync23(wrapperPath, content);
       chmodSync3(wrapperPath, 493);
       created++;
     }
@@ -18210,7 +18508,7 @@ exec node "${codexLauncher}" --agent ${emp.name} "$@"
 }
 function writeWrapper(wrapperPath, content) {
   try {
-    writeFileSync22(wrapperPath, content);
+    writeFileSync23(wrapperPath, content);
     chmodSync3(wrapperPath, 493);
   } catch {
   }
@@ -18218,12 +18516,12 @@ function writeWrapper(wrapperPath, content) {
 function resolveGlobalBinDir() {
   try {
     const exeOsPath = execSync13("command -v exe-os", { encoding: "utf8", timeout: 3e3 }).trim().split("\n")[0];
-    if (exeOsPath) return path37.dirname(exeOsPath);
+    if (exeOsPath) return path38.dirname(exeOsPath);
   } catch {
   }
   try {
     const prefix = execSync13("npm prefix -g", { encoding: "utf8", timeout: 3e3 }).trim();
-    if (prefix) return path37.join(prefix, "bin");
+    if (prefix) return path38.join(prefix, "bin");
   } catch {
   }
   return null;
@@ -18239,24 +18537,24 @@ export PATH="${binDir}:$PATH"
   const shell = process.env.SHELL ?? "/bin/bash";
   const profilePaths = [];
   if (shell.includes("zsh")) {
-    profilePaths.push(path37.join(home, ".zshrc"));
+    profilePaths.push(path38.join(home, ".zshrc"));
   } else if (shell.includes("bash")) {
-    profilePaths.push(path37.join(home, ".bashrc"));
-    profilePaths.push(path37.join(home, ".bash_profile"));
+    profilePaths.push(path38.join(home, ".bashrc"));
+    profilePaths.push(path38.join(home, ".bash_profile"));
   } else {
-    profilePaths.push(path37.join(home, ".profile"));
+    profilePaths.push(path38.join(home, ".profile"));
   }
   for (const profilePath of profilePaths) {
     try {
       let content = "";
       try {
-        content = readFileSync25(profilePath, "utf8");
+        content = readFileSync26(profilePath, "utf8");
       } catch {
       }
       if (content.includes(".exe-os/bin")) {
         return false;
       }
-      writeFileSync22(profilePath, content + exportLine);
+      writeFileSync23(profilePath, content + exportLine);
       return true;
     } catch {
       continue;
@@ -18279,40 +18577,40 @@ __export(setup_wizard_exports, {
   validateModel: () => validateModel
 });
 import crypto13 from "crypto";
-import { existsSync as existsSync32, mkdirSync as mkdirSync22, readFileSync as readFileSync26, writeFileSync as writeFileSync23, unlinkSync as unlinkSync15 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync23, readFileSync as readFileSync27, writeFileSync as writeFileSync24, unlinkSync as unlinkSync16 } from "fs";
 import os19 from "os";
-import path38 from "path";
+import path39 from "path";
 import { createInterface as createInterface4 } from "readline";
 function findPackageRoot2() {
-  let dir = path38.dirname(new URL(import.meta.url).pathname);
-  const root = path38.parse(dir).root;
+  let dir = path39.dirname(new URL(import.meta.url).pathname);
+  const root = path39.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path38.join(dir, "package.json");
+    const pkgPath = path39.join(dir, "package.json");
     if (existsSync32(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync26(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync27(pkgPath, "utf-8"));
         if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
       } catch {
       }
     }
-    dir = path38.dirname(dir);
+    dir = path39.dirname(dir);
   }
   return null;
 }
 function loadSetupState() {
   try {
-    return JSON.parse(readFileSync26(SETUP_STATE_PATH, "utf8"));
+    return JSON.parse(readFileSync27(SETUP_STATE_PATH, "utf8"));
   } catch {
     return { completedSteps: [], startedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
 }
 function saveSetupState(state) {
-  mkdirSync22(path38.dirname(SETUP_STATE_PATH), { recursive: true });
-  writeFileSync23(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
+  mkdirSync23(path39.dirname(SETUP_STATE_PATH), { recursive: true });
+  writeFileSync24(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
 }
 function clearSetupState() {
   try {
-    unlinkSync15(SETUP_STATE_PATH);
+    unlinkSync16(SETUP_STATE_PATH);
   } catch {
   }
 }
@@ -18358,7 +18656,7 @@ async function validateModel(log) {
   if (totalGB <= 8 || isLowMemory()) {
     log(`System memory: ${totalGB.toFixed(0)}GB total, ${freeGB.toFixed(1)}GB free`);
     log("Skipping in-memory model validation (low memory \u2014 will validate on first use).");
-    const modelPath = path38.join(MODELS_DIR, LOCAL_FILENAME);
+    const modelPath = path39.join(MODELS_DIR, LOCAL_FILENAME);
     if (existsSync32(modelPath)) {
       const { statSync: statSync8 } = await import("fs");
       const size = statSync8(modelPath).size;
@@ -18645,10 +18943,10 @@ async function runSetupWizard(opts = {}) {
       await saveConfig(config);
       log("");
       try {
-        const claudeJsonPath = path38.join(os19.homedir(), ".claude.json");
+        const claudeJsonPath = path39.join(os19.homedir(), ".claude.json");
         let claudeJson = {};
         try {
-          claudeJson = JSON.parse(readFileSync26(claudeJsonPath, "utf8"));
+          claudeJson = JSON.parse(readFileSync27(claudeJsonPath, "utf8"));
         } catch {
         }
         if (!claudeJson.projects) claudeJson.projects = {};
@@ -18657,7 +18955,7 @@ async function runSetupWizard(opts = {}) {
           if (!projects[dir]) projects[dir] = {};
           projects[dir].hasTrustDialogAccepted = true;
         }
-        writeFileSync23(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+        writeFileSync24(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
       } catch {
       }
       state.completedSteps.push(5);
@@ -18671,7 +18969,7 @@ async function runSetupWizard(opts = {}) {
       const prefs = { ...existingPrefs };
       log("=== Config Defaults ===");
       log("");
-      const ghosttyDetected = existsSync32(path38.join(os19.homedir(), ".config", "ghostty")) || existsSync32(path38.join(os19.homedir(), "Library", "Application Support", "com.mitchellh.ghostty"));
+      const ghosttyDetected = existsSync32(path39.join(os19.homedir(), ".config", "ghostty")) || existsSync32(path39.join(os19.homedir(), "Library", "Application Support", "com.mitchellh.ghostty"));
       if (ghosttyDetected) {
         const ghosttyAnswer = await ask3(rl, "Detected Ghostty terminal. Use exe-os Ghostty defaults? (Y/n) ");
         prefs.ghostty = ghosttyAnswer.toLowerCase() !== "n";
@@ -18809,9 +19107,9 @@ async function runSetupWizard(opts = {}) {
       const cooIdentityContent = getIdentityTemplate("coo");
       if (cooIdentityContent) {
         const cooIdPath = identityPath2(cooName);
-        mkdirSync22(path38.dirname(cooIdPath), { recursive: true });
+        mkdirSync23(path39.dirname(cooIdPath), { recursive: true });
         const replaced = cooIdentityContent.replace(/agent_id:\s*exe/g, `agent_id: ${cooName}`).replace(/\$\{agent_id\}/g, cooName);
-        writeFileSync23(cooIdPath, replaced, "utf-8");
+        writeFileSync24(cooIdPath, replaced, "utf-8");
       }
       registerBinSymlinks2(cooName);
       createdEmployees.push({ name: cooName, role: "COO" });
@@ -18927,9 +19225,9 @@ async function runSetupWizard(opts = {}) {
         const ctoIdentityContent = getIdentityTemplate("cto");
         if (ctoIdentityContent) {
           const ctoIdPath = identityPath2(ctoName);
-          mkdirSync22(path38.dirname(ctoIdPath), { recursive: true });
+          mkdirSync23(path39.dirname(ctoIdPath), { recursive: true });
           const replaced = ctoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${ctoName}`).replace(/\$\{agent_id\}/g, ctoName);
-          writeFileSync23(ctoIdPath, replaced, "utf-8");
+          writeFileSync24(ctoIdPath, replaced, "utf-8");
         }
         registerBinSymlinks2(ctoName);
         createdEmployees.push({ name: ctoName, role: "CTO" });
@@ -18950,9 +19248,9 @@ async function runSetupWizard(opts = {}) {
         const cmoIdentityContent = getIdentityTemplate("cmo");
         if (cmoIdentityContent) {
           const cmoIdPath = identityPath2(cmoName);
-          mkdirSync22(path38.dirname(cmoIdPath), { recursive: true });
+          mkdirSync23(path39.dirname(cmoIdPath), { recursive: true });
           const replaced = cmoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${cmoName}`).replace(/\$\{agent_id\}/g, cmoName);
-          writeFileSync23(cmoIdPath, replaced, "utf-8");
+          writeFileSync24(cmoIdPath, replaced, "utf-8");
         }
         registerBinSymlinks2(cmoName);
         createdEmployees.push({ name: cmoName, role: "CMO" });
@@ -18975,7 +19273,7 @@ async function runSetupWizard(opts = {}) {
             log(`Session shortcuts generated (${cooName}1, ${cooName}2, ...)`);
           }
           if (wrapResult.pathConfigured) {
-            const binDir = path38.join(os19.homedir(), ".exe-os", "bin");
+            const binDir = path39.join(os19.homedir(), ".exe-os", "bin");
             process.env.PATH = `${binDir}:${process.env.PATH ?? ""}`;
             pathJustConfigured = true;
           }
@@ -19018,7 +19316,7 @@ async function runSetupWizard(opts = {}) {
     const pkgRoot2 = findPackageRoot2();
     if (pkgRoot2) {
       try {
-        version = JSON.parse(readFileSync26(path38.join(pkgRoot2, "package.json"), "utf-8")).version;
+        version = JSON.parse(readFileSync27(path39.join(pkgRoot2, "package.json"), "utf-8")).version;
       } catch {
       }
     }
@@ -19034,6 +19332,7 @@ async function runSetupWizard(opts = {}) {
     log("");
     log("  Recommended start:        Phase 1 \u2014 talk to your COO first");
     log("  Check/change phase:       exe-os org phase");
+    log("  Verify support intake:    exe-os support test");
     log("  Unlock executives later:  exe-os org unlock executives");
     log("");
     log(`  cd into a project folder:  cd ~/my-project`);
@@ -19056,46 +19355,46 @@ var init_setup_wizard = __esm({
     init_config();
     init_keychain();
     init_model_downloader();
-    SETUP_STATE_PATH = path38.join(os19.homedir(), ".exe-os", "setup-state.json");
+    SETUP_STATE_PATH = path39.join(os19.homedir(), ".exe-os", "setup-state.json");
   }
 });
 
 // src/lib/update-backup.ts
 import { copyFile, readFile as readFile6, readdir as readdir3, writeFile as writeFile7, rm as rm2, mkdir as mkdir7, cp } from "fs/promises";
 import { existsSync as existsSync33 } from "fs";
-import path39 from "path";
+import path40 from "path";
 import os20 from "os";
 function resolveDataDir2() {
   if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  return path39.join(os20.homedir(), ".exe-os");
+  return path40.join(os20.homedir(), ".exe-os");
 }
 function externalBackupTargets(homeDir) {
   return [
-    { name: "claude.json", path: path39.join(homeDir, ".claude.json") },
-    { name: "claude-settings.json", path: path39.join(homeDir, ".claude", "settings.json") },
-    { name: "claude-CLAUDE.md", path: path39.join(homeDir, ".claude", "CLAUDE.md") },
-    { name: "tmux.conf", path: path39.join(homeDir, ".tmux.conf") },
-    { name: "zshrc", path: path39.join(homeDir, ".zshrc") },
-    { name: "bashrc", path: path39.join(homeDir, ".bashrc") },
-    { name: "ghostty-config", path: path39.join(homeDir, ".config", "ghostty", "config") },
-    { name: "codex-config.toml", path: path39.join(homeDir, ".codex", "config.toml") },
-    { name: "codex-hooks.json", path: path39.join(homeDir, ".codex", "hooks.json") },
-    { name: "opencode-config.json", path: path39.join(homeDir, ".config", "opencode", "opencode.json") }
+    { name: "claude.json", path: path40.join(homeDir, ".claude.json") },
+    { name: "claude-settings.json", path: path40.join(homeDir, ".claude", "settings.json") },
+    { name: "claude-CLAUDE.md", path: path40.join(homeDir, ".claude", "CLAUDE.md") },
+    { name: "tmux.conf", path: path40.join(homeDir, ".tmux.conf") },
+    { name: "zshrc", path: path40.join(homeDir, ".zshrc") },
+    { name: "bashrc", path: path40.join(homeDir, ".bashrc") },
+    { name: "ghostty-config", path: path40.join(homeDir, ".config", "ghostty", "config") },
+    { name: "codex-config.toml", path: path40.join(homeDir, ".codex", "config.toml") },
+    { name: "codex-hooks.json", path: path40.join(homeDir, ".codex", "hooks.json") },
+    { name: "opencode-config.json", path: path40.join(homeDir, ".config", "opencode", "opencode.json") }
   ];
 }
 async function createUpdateBackup(currentVersion, dataDir2, homeDir = os20.homedir()) {
   const dir = dataDir2 ?? resolveDataDir2();
-  const backupDir = path39.join(dir, BACKUP_DIR_NAME);
+  const backupDir = path40.join(dir, BACKUP_DIR_NAME);
   if (existsSync33(backupDir)) {
     await rm2(backupDir, { recursive: true, force: true });
   }
   await mkdir7(backupDir, { recursive: true });
   const backedUpFiles = [];
   for (const target of BACKUP_TARGETS) {
-    const src = path39.join(dir, target.name);
+    const src = path40.join(dir, target.name);
     if (!existsSync33(src)) continue;
-    const dest = path39.join(backupDir, target.name);
+    const dest = path40.join(backupDir, target.name);
     if (target.type === "file") {
       await copyFile(src, dest);
     } else {
@@ -19106,18 +19405,18 @@ async function createUpdateBackup(currentVersion, dataDir2, homeDir = os20.homed
   const entries = await readdir3(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".db") && entry.name !== BACKUP_DIR_NAME) {
-      const src = path39.join(dir, entry.name);
-      const dest = path39.join(backupDir, entry.name);
+      const src = path40.join(dir, entry.name);
+      const dest = path40.join(backupDir, entry.name);
       await copyFile(src, dest);
       backedUpFiles.push(entry.name);
     }
   }
   const externalFiles = [];
-  const externalDir = path39.join(backupDir, "external");
+  const externalDir = path40.join(backupDir, "external");
   for (const target of externalBackupTargets(homeDir)) {
     if (!existsSync33(target.path)) continue;
     await mkdir7(externalDir, { recursive: true });
-    await copyFile(target.path, path39.join(externalDir, target.name));
+    await copyFile(target.path, path40.join(externalDir, target.name));
     externalFiles.push(target);
   }
   const manifest = {
@@ -19127,15 +19426,15 @@ async function createUpdateBackup(currentVersion, dataDir2, homeDir = os20.homed
     ...externalFiles.length > 0 ? { externalFiles } : {}
   };
   await writeFile7(
-    path39.join(backupDir, "manifest.json"),
+    path40.join(backupDir, "manifest.json"),
     JSON.stringify(manifest, null, 2) + "\n"
   );
   return manifest;
 }
 async function restoreFromBackup(dataDir2) {
   const dir = dataDir2 ?? resolveDataDir2();
-  const backupDir = path39.join(dir, BACKUP_DIR_NAME);
-  const manifestPath = path39.join(backupDir, "manifest.json");
+  const backupDir = path40.join(dir, BACKUP_DIR_NAME);
+  const manifestPath = path40.join(backupDir, "manifest.json");
   if (!existsSync33(manifestPath)) {
     throw new Error(
       `No backup found at ${backupDir}. Nothing to restore.`
@@ -19145,8 +19444,8 @@ async function restoreFromBackup(dataDir2) {
     await readFile6(manifestPath, "utf-8")
   );
   for (const fileName of manifest.files) {
-    const src = path39.join(backupDir, fileName);
-    const dest = path39.join(dir, fileName);
+    const src = path40.join(backupDir, fileName);
+    const dest = path40.join(dir, fileName);
     if (!existsSync33(src)) continue;
     const stat2 = await import("fs/promises").then((m) => m.stat(src));
     if (stat2.isDirectory()) {
@@ -19156,16 +19455,16 @@ async function restoreFromBackup(dataDir2) {
     }
   }
   for (const external of manifest.externalFiles ?? []) {
-    const src = path39.join(backupDir, "external", external.name);
+    const src = path40.join(backupDir, "external", external.name);
     if (!existsSync33(src)) continue;
-    await mkdir7(path39.dirname(external.path), { recursive: true });
+    await mkdir7(path40.dirname(external.path), { recursive: true });
     await copyFile(src, external.path);
   }
   return manifest;
 }
 async function deleteBackup(dataDir2) {
   const dir = dataDir2 ?? resolveDataDir2();
-  const backupDir = path39.join(dir, BACKUP_DIR_NAME);
+  const backupDir = path40.join(dir, BACKUP_DIR_NAME);
   if (existsSync33(backupDir)) {
     await rm2(backupDir, { recursive: true, force: true });
   }
@@ -19191,21 +19490,21 @@ var init_update_backup = __esm({
 
 // src/lib/update-check.ts
 import { execSync as execSync14 } from "child_process";
-import { readFileSync as readFileSync27 } from "fs";
-import path40 from "path";
+import { readFileSync as readFileSync28 } from "fs";
+import path41 from "path";
 function getLocalVersion(packageRoot) {
-  const pkgPath = path40.join(packageRoot, "package.json");
-  const pkg = JSON.parse(readFileSync27(pkgPath, "utf-8"));
+  const pkgPath = path41.join(packageRoot, "package.json");
+  const pkg = JSON.parse(readFileSync28(pkgPath, "utf-8"));
   return pkg.version;
 }
 function getRemoteVersion() {
   try {
-    const output = execSync14("npm view @askexenow/exe-os version", {
+    const output2 = execSync14("npm view @askexenow/exe-os version", {
       encoding: "utf-8",
       timeout: 15e3,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    return output.trim();
+    return output2.trim();
   } catch {
     return null;
   }
@@ -19415,6 +19714,15 @@ async function runUpdate(cliArgs) {
     }
   } catch {
   }
+  try {
+    console.log("\u{1FA7A} Checking AskExe support intake...");
+    execSync15("exe-os support health", {
+      stdio: ["pipe", "inherit", "inherit"],
+      timeout: 3e4
+    });
+  } catch {
+    console.log("   \u26A0\uFE0F  Support health check failed. Run: exe-os support test");
+  }
   console.log("\n\u{1F680} Ready. Start your COO session to use the new version.\n");
 }
 var init_update = __esm({
@@ -19436,10 +19744,10 @@ var init_update = __esm({
 // src/lib/stack-update.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { createVerify, verify as verifySignature } from "crypto";
-import { existsSync as existsSync34, mkdirSync as mkdirSync23, readdirSync as readdirSync10, readFileSync as readFileSync28, renameSync as renameSync8, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync24, readdirSync as readdirSync10, readFileSync as readFileSync29, renameSync as renameSync8, writeFileSync as writeFileSync25 } from "fs";
 import http from "http";
 import https from "https";
-import path41 from "path";
+import path42 from "path";
 function isSignedEnvelope(value) {
   return !!value && typeof value === "object" && "manifest" in value && "signature" in value;
 }
@@ -19473,21 +19781,21 @@ function stableJson(value) {
   return `{${Object.keys(obj).sort().map((key) => `${JSON.stringify(key)}:${stableJson(obj[key])}`).join(",")}}`;
 }
 function findLatestBackupEnvFile(envFile) {
-  const backupDir = path41.join(path41.dirname(envFile), ".exe-stack-backups");
+  const backupDir = path42.join(path42.dirname(envFile), ".exe-stack-backups");
   if (!existsSync34(backupDir)) return null;
   const backups = readdirSync10(backupDir).filter((name) => name.startsWith("env-") && name.endsWith(".bak")).sort();
   const latest = backups.at(-1);
-  return latest ? path41.join(backupDir, latest) : null;
+  return latest ? path42.join(backupDir, latest) : null;
 }
 async function rollbackStackUpdate(options) {
   const exec2 = options.exec ?? defaultExec;
-  const backupEnvFile = options.lockFile && existsSync34(options.lockFile) ? JSON.parse(readFileSync28(options.lockFile, "utf8")).backupEnvFile : void 0;
+  const backupEnvFile = options.lockFile && existsSync34(options.lockFile) ? JSON.parse(readFileSync29(options.lockFile, "utf8")).backupEnvFile : void 0;
   const rollbackEnv = backupEnvFile && existsSync34(backupEnvFile) ? backupEnvFile : findLatestBackupEnvFile(options.envFile);
   if (!rollbackEnv) throw new Error(`No stack backup env found beside ${options.envFile}`);
-  writeFileSync24(options.envFile, readFileSync28(rollbackEnv), { mode: 384 });
+  writeFileSync25(options.envFile, readFileSync29(rollbackEnv), { mode: 384 });
   const composeArgs = ["compose", "--file", options.composeFile, "--env-file", options.envFile];
   exec2("docker", [...composeArgs, "up", "-d"]);
-  return { status: "rolled_back", targetVersion: "previous", changes: [], backupEnvFile: rollbackEnv, lockFile: options.lockFile ?? path41.join(path41.dirname(options.envFile), ".exe-stack-lock.json") };
+  return { status: "rolled_back", targetVersion: "previous", changes: [], backupEnvFile: rollbackEnv, lockFile: options.lockFile ?? path42.join(path42.dirname(options.envFile), ".exe-stack-lock.json") };
 }
 function parseStackManifest(raw, publicKey) {
   const parsedRaw = JSON.parse(raw);
@@ -19512,7 +19820,7 @@ function parseStackManifest(raw, publicKey) {
 }
 async function loadStackManifest(ref, fetchText = defaultFetchText, publicKey, authToken) {
   if (/^https?:\/\//.test(ref)) return parseStackManifest(await fetchTextWithAuth(ref, fetchText, authToken), publicKey);
-  return parseStackManifest(readFileSync28(ref, "utf8"), publicKey);
+  return parseStackManifest(readFileSync29(ref, "utf8"), publicKey);
 }
 async function fetchTextWithAuth(ref, fetchText, authToken) {
   if (!authToken || fetchText !== defaultFetchText) return fetchText(ref);
@@ -19641,9 +19949,9 @@ Emergency override requires --break-glass <reason> and writes an audit file.`
 function writeBreakGlassAudit(plan, issues, options) {
   const now2 = options.now ?? (() => /* @__PURE__ */ new Date());
   const stamp = now2().toISOString().replace(/[:.]/g, "-");
-  const defaultDir = existsSync34("exe/output") ? "exe/output" : path41.dirname(options.envFile ?? ".");
-  const auditFile = options.breakGlassAuditFile ?? path41.join(defaultDir, `stack-update-break-glass-${stamp}.md`);
-  mkdirSync23(path41.dirname(auditFile), { recursive: true });
+  const defaultDir = existsSync34("exe/output") ? "exe/output" : path42.dirname(options.envFile ?? ".");
+  const auditFile = options.breakGlassAuditFile ?? path42.join(defaultDir, `stack-update-break-glass-${stamp}.md`);
+  mkdirSync24(path42.dirname(auditFile), { recursive: true });
   const body = [
     `# Stack Update Break-Glass Audit \u2014 ${now2().toISOString()}`,
     "",
@@ -19657,7 +19965,7 @@ function writeBreakGlassAudit(plan, issues, options) {
     "Return this deployment to the standard pinned GHCR image path immediately after the emergency is resolved.",
     ""
   ].join("\n");
-  writeFileSync24(auditFile, body, { mode: 384 });
+  writeFileSync25(auditFile, body, { mode: 384 });
   console.warn(`[stack-update] BREAK-GLASS deploy override recorded: ${auditFile}`);
 }
 function assertBreakingChangesAllowed(plan, allowedIds) {
@@ -19679,33 +19987,33 @@ async function runStackUpdate(options) {
   const now2 = options.now ?? (() => /* @__PURE__ */ new Date());
   if (options.rollback) return rollbackStackUpdate(options);
   const manifest = await loadStackManifest(options.manifestRef, options.fetchText, options.manifestPublicKey, options.manifestAuthToken);
-  const envRaw = readFileSync28(options.envFile, "utf8");
+  const envRaw = readFileSync29(options.envFile, "utf8");
   const plan = createStackUpdatePlan(manifest, envRaw, options.targetVersion);
   assertBreakingChangesAllowed(plan, options.allowedBreakingChangeIds ?? []);
   assertDeploymentScopeAllowed(plan, options.deploymentPersona ?? "customer");
   const plannedEnvRaw = patchEnv(envRaw, Object.fromEntries(plan.changes.map((c) => [c.key, c.after])));
-  const composeRaw = readFileSync28(options.composeFile, "utf8");
+  const composeRaw = readFileSync29(options.composeFile, "utf8");
   assertProductionDeployGate(plan, plannedEnvRaw, composeRaw, {
     breakGlassReason: options.breakGlassReason,
     breakGlassAuditFile: options.breakGlassAuditFile,
     now: now2,
     envFile: options.envFile
   });
-  const lockFile = options.lockFile ?? path41.join(path41.dirname(options.envFile), ".exe-stack-lock.json");
+  const lockFile = options.lockFile ?? path42.join(path42.dirname(options.envFile), ".exe-stack-lock.json");
   const previousVersion = readCurrentStackVersion(lockFile);
   if (options.dryRun || plan.changes.length === 0) {
     return { status: "planned", targetVersion: plan.targetVersion, changes: plan.changes, lockFile };
   }
   await postDeployAudit(options, "started", plan.targetVersion, previousVersion);
-  const backupDir = path41.join(path41.dirname(options.envFile), ".exe-stack-backups");
-  mkdirSync23(backupDir, { recursive: true });
+  const backupDir = path42.join(path42.dirname(options.envFile), ".exe-stack-backups");
+  mkdirSync24(backupDir, { recursive: true });
   const stamp = now2().toISOString().replace(/[:.]/g, "-");
-  const backupEnvFile = path41.join(backupDir, `env-${stamp}.bak`);
-  writeFileSync24(backupEnvFile, envRaw, { mode: 384 });
+  const backupEnvFile = path42.join(backupDir, `env-${stamp}.bak`);
+  writeFileSync25(backupEnvFile, envRaw, { mode: 384 });
   const updates = Object.fromEntries(plan.changes.map((c) => [c.key, c.after]));
   const patched = patchEnv(envRaw, updates);
   const tmp = `${options.envFile}.tmp-${process.pid}`;
-  writeFileSync24(tmp, patched, { mode: 384 });
+  writeFileSync25(tmp, patched, { mode: 384 });
   renameSync8(tmp, options.envFile);
   const composeArgs = ["compose", "--file", options.composeFile, "--env-file", options.envFile];
   let registryForLogout;
@@ -19718,11 +20026,11 @@ async function runStackUpdate(options) {
     exec2("docker", [...composeArgs, "pull"]);
     exec2("docker", [...composeArgs, "up", "-d"]);
     await verifyReleaseHealth(plan.release, options.healthRetries ?? 12, options.healthDelayMs ?? 5e3);
-    writeFileSync24(lockFile, JSON.stringify({ stackVersion: plan.targetVersion, updatedAt: now2().toISOString(), backupEnvFile, services: plan.release.services }, null, 2) + "\n");
+    writeFileSync25(lockFile, JSON.stringify({ stackVersion: plan.targetVersion, updatedAt: now2().toISOString(), backupEnvFile, services: plan.release.services }, null, 2) + "\n");
     await postDeployAudit(options, "success", plan.targetVersion, previousVersion, void 0, { changes: plan.changes.length });
     return { status: "updated", targetVersion: plan.targetVersion, changes: plan.changes, backupEnvFile, lockFile };
   } catch (err) {
-    writeFileSync24(options.envFile, envRaw, { mode: 384 });
+    writeFileSync25(options.envFile, envRaw, { mode: 384 });
     try {
       exec2("docker", [...composeArgs, "up", "-d"]);
     } catch {
@@ -19755,7 +20063,7 @@ async function fetchImageCredentials(options) {
 function readCurrentStackVersion(lockFile) {
   if (!existsSync34(lockFile)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync28(lockFile, "utf8"));
+    const parsed = JSON.parse(readFileSync29(lockFile, "utf8"));
     return parsed.stackVersion;
   } catch {
     return void 0;
@@ -19843,8 +20151,8 @@ async function defaultPostJson(url, body, authToken) {
   if (!res.ok) throw new Error(`Failed to POST ${url}: HTTP ${res.status}`);
 }
 function defaultStackPaths() {
-  const cwdCompose = path41.resolve("docker-compose.yml");
-  const cwdEnv = path41.resolve(".env");
+  const cwdCompose = path42.resolve("docker-compose.yml");
+  const cwdEnv = path42.resolve(".env");
   return {
     composeFile: process.env.EXE_STACK_COMPOSE_FILE || (existsSync34(cwdCompose) ? cwdCompose : "/opt/exe-stack/docker-compose.yml"),
     envFile: process.env.EXE_STACK_ENV_FILE || (existsSync34(cwdEnv) ? cwdEnv : "/opt/exe-stack/.env"),
@@ -19858,7 +20166,7 @@ function defaultStackPaths() {
 function loadDefaultPublicKey() {
   if (process.env.EXE_STACK_PUBLIC_KEY) return process.env.EXE_STACK_PUBLIC_KEY;
   if (process.env.EXE_STACK_PUBLIC_KEY_FILE && existsSync34(process.env.EXE_STACK_PUBLIC_KEY_FILE)) {
-    return readFileSync28(process.env.EXE_STACK_PUBLIC_KEY_FILE, "utf8");
+    return readFileSync29(process.env.EXE_STACK_PUBLIC_KEY_FILE, "utf8");
   }
   return void 0;
 }
@@ -19873,9 +20181,9 @@ var init_stack_update = __esm({
 // src/bin/stack-update.ts
 var stack_update_exports = {};
 __export(stack_update_exports, {
-  runStackUpdateCli: () => main6
+  runStackUpdateCli: () => main7
 });
-import { readFileSync as readFileSync29 } from "fs";
+import { readFileSync as readFileSync30 } from "fs";
 function parseArgs4(args2) {
   const defaults = defaultStackPaths();
   const opts = {
@@ -19907,8 +20215,8 @@ function parseArgs4(args2) {
     else if (arg === "--env-file") opts.envFile = next();
     else if (arg.startsWith("--env-file=")) opts.envFile = arg.split("=").slice(1).join("=");
     else if (arg === "--lock-file") opts.lockFile = next();
-    else if (arg === "--public-key") opts.manifestPublicKey = readFileSync29(next(), "utf8");
-    else if (arg.startsWith("--public-key=")) opts.manifestPublicKey = readFileSync29(arg.split("=").slice(1).join("="), "utf8");
+    else if (arg === "--public-key") opts.manifestPublicKey = readFileSync30(next(), "utf8");
+    else if (arg.startsWith("--public-key=")) opts.manifestPublicKey = readFileSync30(arg.split("=").slice(1).join("="), "utf8");
     else if (arg === "--auth-token") opts.manifestAuthToken = next();
     else if (arg.startsWith("--auth-token=")) opts.manifestAuthToken = arg.split("=").slice(1).join("=");
     else if (arg === "--auth-token-env") opts.manifestAuthToken = process.env[next()] ?? "";
@@ -19940,7 +20248,7 @@ function parseArgs4(args2) {
     else if (arg === "--allow-breaking") opts.allowedBreakingChangeIds.push(...next().split(",").map((s) => s.trim()).filter(Boolean));
     else if (arg.startsWith("--allow-breaking=")) opts.allowedBreakingChangeIds.push(...arg.split("=")[1].split(",").map((s) => s.trim()).filter(Boolean));
     else if (arg === "--help" || arg === "-h") {
-      printHelp();
+      printHelp2();
       process.exit(0);
     } else {
       throw new Error(`Unknown option: ${arg}`);
@@ -19948,7 +20256,7 @@ function parseArgs4(args2) {
   }
   return opts;
 }
-function printHelp() {
+function printHelp2() {
   console.log(`exe-os stack-update \u2014 update a self-hosted Exe OS stack from a pinned manifest
 
 Usage:
@@ -19999,7 +20307,7 @@ function printBreaking(changes) {
     if (c.expectedDowntimeMinutes) console.log(`    Expected downtime: ${c.expectedDowntimeMinutes} minutes`);
   }
 }
-async function main6() {
+async function main7() {
   const opts = parseArgs4(process.argv.slice(2));
   if (opts.rollback) {
     if (!opts.yes) {
@@ -20011,11 +20319,11 @@ async function main6() {
     return;
   }
   const manifest = await loadStackManifest(opts.manifestRef, void 0, opts.manifestPublicKey, opts.manifestAuthToken);
-  const envRaw = readFileSync29(opts.envFile, "utf8");
+  const envRaw = readFileSync30(opts.envFile, "utf8");
   const plan = createStackUpdatePlan(manifest, envRaw, opts.targetVersion);
   assertDeploymentScopeAllowed(plan, opts.deploymentPersona);
   const plannedEnvRaw = patchEnv(envRaw, Object.fromEntries(plan.changes.map((c) => [c.key, c.after])));
-  assertProductionDeployGate(plan, plannedEnvRaw, readFileSync29(opts.composeFile, "utf8"), {
+  assertProductionDeployGate(plan, plannedEnvRaw, readFileSync30(opts.composeFile, "utf8"), {
     breakGlassReason: opts.breakGlassReason,
     breakGlassAuditFile: opts.breakGlassAuditFile,
     envFile: opts.envFile
@@ -20044,7 +20352,7 @@ var init_stack_update2 = __esm({
     init_is_main();
     init_stack_update();
     if (isMainModule(import.meta.url)) {
-      main6().catch((err) => {
+      main7().catch((err) => {
         console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
       });
@@ -20216,9 +20524,9 @@ var init_registry_proxy = __esm({
 // src/bin/registry-proxy.ts
 var registry_proxy_exports = {};
 __export(registry_proxy_exports, {
-  main: () => main7
+  main: () => main8
 });
-function printHelp2() {
+function printHelp3() {
   console.log(`exe-os registry-proxy \u2014 authenticated pull-through proxy for AskExe customer images
 
 Environment:
@@ -20235,9 +20543,9 @@ Docker image shape for clients:
   registry.askexe.com/askexe/exe-crm:v0.9.3
 `);
 }
-async function main7(args2 = process.argv.slice(2)) {
+async function main8(args2 = process.argv.slice(2)) {
   if (args2.includes("--help") || args2.includes("-h")) {
-    printHelp2();
+    printHelp3();
     return;
   }
   await runRegistryProxy(registryProxyOptionsFromEnv());
@@ -20248,7 +20556,7 @@ var init_registry_proxy2 = __esm({
     init_is_main();
     init_registry_proxy();
     if (isMainModule(import.meta.url)) {
-      main7().catch((err) => {
+      main8().catch((err) => {
         console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
       });
@@ -22567,17 +22875,17 @@ var init_sanitize_ansi = __esm({
       if (!hasAnsiControlCharacters(text)) {
         return text;
       }
-      let output = "";
+      let output2 = "";
       for (const token of tokenizeAnsi(text)) {
         if (token.type === "text" || token.type === "osc") {
-          output += token.value;
+          output2 += token.value;
           continue;
         }
         if (token.type === "csi" && token.finalCharacter === "m" && token.intermediateString === "" && sgrParametersRegex.test(token.parameterString)) {
-          output += token.value;
+          output2 += token.value;
         }
       }
-      return output;
+      return output2;
     };
     sanitize_ansi_default = sanitizeAnsi;
   }
@@ -23364,7 +23672,7 @@ var init_render_border = __esm({
   "src/tui/ink/render-border.js"() {
     "use strict";
     init_colorize();
-    renderBorder = (x, y, node, output) => {
+    renderBorder = (x, y, node, output2) => {
       if (node.style.borderStyle) {
         const width = node.yogaNode.getComputedWidth();
         const height = node.yogaNode.getComputedHeight();
@@ -23407,18 +23715,18 @@ var init_render_border = __esm({
         }
         const offsetY = showTopBorder ? 1 : 0;
         if (topBorder) {
-          output.write(x, y, topBorder, { transformers: [] });
+          output2.write(x, y, topBorder, { transformers: [] });
         }
         if (showLeftBorder) {
-          output.write(x, y + offsetY, leftBorder, { transformers: [] });
+          output2.write(x, y + offsetY, leftBorder, { transformers: [] });
         }
         if (showRightBorder) {
-          output.write(x + width - 1, y + offsetY, rightBorder, {
+          output2.write(x + width - 1, y + offsetY, rightBorder, {
             transformers: []
           });
         }
         if (bottomBorder) {
-          output.write(x, y + height - 1, bottomBorder, { transformers: [] });
+          output2.write(x, y + height - 1, bottomBorder, { transformers: [] });
         }
       }
     };
@@ -23432,7 +23740,7 @@ var init_render_background = __esm({
   "src/tui/ink/render-background.js"() {
     "use strict";
     init_colorize();
-    renderBackground = (x, y, node, output) => {
+    renderBackground = (x, y, node, output2) => {
       if (!node.style.backgroundColor) {
         return;
       }
@@ -23449,7 +23757,7 @@ var init_render_background = __esm({
       }
       const backgroundLine = colorize_default(" ".repeat(contentWidth), node.style.backgroundColor, "background");
       for (let row = 0; row < contentHeight; row++) {
-        output.write(x + leftBorderWidth, y + topBorderHeight + row, backgroundLine, { transformers: [] });
+        output2.write(x + leftBorderWidth, y + topBorderHeight + row, backgroundLine, { transformers: [] });
       }
     };
     render_background_default = renderBackground;
@@ -23485,13 +23793,13 @@ var init_render_node_to_output = __esm({
       if (node.yogaNode?.getDisplay() === src_default.DISPLAY_NONE) {
         return "";
       }
-      let output = "";
+      let output2 = "";
       if (node.nodeName === "ink-text") {
-        output = squash_text_nodes_default(node);
+        output2 = squash_text_nodes_default(node);
       } else if (node.nodeName === "ink-box" || node.nodeName === "ink-root") {
         const separator = node.style.flexDirection === "row" || node.style.flexDirection === "row-reverse" ? " " : "\n";
         const childNodes = node.style.flexDirection === "row-reverse" || node.style.flexDirection === "column-reverse" ? [...node.childNodes].reverse() : [...node.childNodes];
-        output = childNodes.map((childNode) => {
+        output2 = childNodes.map((childNode) => {
           const screenReaderOutput = renderNodeToScreenReaderOutput(childNode, {
             parentRole: node.internal_accessibility?.role,
             skipStaticElements: options.skipStaticElements
@@ -23505,16 +23813,16 @@ var init_render_node_to_output = __esm({
           const stateKeys = Object.keys(state);
           const stateDescription = stateKeys.filter((key) => state[key]).join(", ");
           if (stateDescription) {
-            output = `(${stateDescription}) ${output}`;
+            output2 = `(${stateDescription}) ${output2}`;
           }
         }
         if (role && role !== options.parentRole) {
-          output = `${role}: ${output}`;
+          output2 = `${role}: ${output2}`;
         }
       }
-      return output;
+      return output2;
     };
-    renderNodeToOutput = (node, output, options) => {
+    renderNodeToOutput = (node, output2, options) => {
       const { offsetX = 0, offsetY = 0, transformers = [], skipStaticElements } = options;
       if (skipStaticElements && node.internal_static) {
         return;
@@ -23540,14 +23848,14 @@ var init_render_node_to_output = __esm({
               text = wrap_text_default(text, maxWidth, textWrap);
             }
             text = applyPaddingToText(node, text);
-            output.write(x, y, text, { transformers: newTransformers });
+            output2.write(x, y, text, { transformers: newTransformers });
           }
           return;
         }
         let clipped = false;
         if (node.nodeName === "ink-box") {
-          render_background_default(x, y, node, output);
-          render_border_default(x, y, node, output);
+          render_background_default(x, y, node, output2);
+          render_border_default(x, y, node, output2);
           const clipHorizontally = node.style.overflowX === "hidden" || node.style.overflow === "hidden";
           const clipVertically = node.style.overflowY === "hidden" || node.style.overflow === "hidden";
           if (clipHorizontally || clipVertically) {
@@ -23555,13 +23863,13 @@ var init_render_node_to_output = __esm({
             const x2 = clipHorizontally ? x + yogaNode.getComputedWidth() - yogaNode.getComputedBorder(src_default.EDGE_RIGHT) : void 0;
             const y1 = clipVertically ? y + yogaNode.getComputedBorder(src_default.EDGE_TOP) : void 0;
             const y2 = clipVertically ? y + yogaNode.getComputedHeight() - yogaNode.getComputedBorder(src_default.EDGE_BOTTOM) : void 0;
-            output.clip({ x1, x2, y1, y2 });
+            output2.clip({ x1, x2, y1, y2 });
             clipped = true;
           }
         }
         if (node.nodeName === "ink-root" || node.nodeName === "ink-box") {
           for (const childNode of node.childNodes) {
-            renderNodeToOutput(childNode, output, {
+            renderNodeToOutput(childNode, output2, {
               offsetX: x,
               offsetY: y,
               transformers: newTransformers,
@@ -23569,7 +23877,7 @@ var init_render_node_to_output = __esm({
             });
           }
           if (clipped) {
-            output.unclip();
+            output2.unclip();
           }
         }
       }
@@ -23654,7 +23962,7 @@ var init_output = __esm({
         });
       }
       get() {
-        const output = [];
+        const output2 = [];
         for (let y = 0; y < this.height; y++) {
           const row = [];
           for (let x = 0; x < this.width; x++) {
@@ -23665,7 +23973,7 @@ var init_output = __esm({
               styles: []
             });
           }
-          output.push(row);
+          output2.push(row);
         }
         const clips = [];
         for (const operation of this.operations) {
@@ -23718,7 +24026,7 @@ var init_output = __esm({
             }
             let offsetY = 0;
             for (let [index, line] of lines.entries()) {
-              const currentLine = output[y + offsetY];
+              const currentLine = output2[y + offsetY];
               if (!currentLine) {
                 continue;
               }
@@ -23746,13 +24054,13 @@ var init_output = __esm({
             }
           }
         }
-        const generatedOutput = output.map((line) => {
+        const generatedOutput = output2.map((line) => {
           const lineWithoutEmptyItems = line.filter((item) => item !== void 0);
           return styledCharsToString(lineWithoutEmptyItems).trimEnd();
         }).join("\n");
         return {
           output: generatedOutput,
-          height: output.length
+          height: output2.length
         };
       }
     };
@@ -23769,10 +24077,10 @@ var init_renderer = __esm({
     renderer = (node, isScreenReaderEnabled) => {
       if (node.yogaNode) {
         if (isScreenReaderEnabled) {
-          const output2 = renderNodeToScreenReaderOutput(node, {
+          const output3 = renderNodeToScreenReaderOutput(node, {
             skipStaticElements: true
           });
-          const outputHeight2 = output2 === "" ? 0 : output2.split("\n").length;
+          const outputHeight2 = output3 === "" ? 0 : output3.split("\n").length;
           let staticOutput2 = "";
           if (node.staticNode) {
             staticOutput2 = renderNodeToScreenReaderOutput(node.staticNode, {
@@ -23780,17 +24088,17 @@ var init_renderer = __esm({
             });
           }
           return {
-            output: output2,
+            output: output3,
             outputHeight: outputHeight2,
             staticOutput: staticOutput2 ? `${staticOutput2}
 ` : ""
           };
         }
-        const output = new Output({
+        const output2 = new Output({
           width: node.yogaNode.getComputedWidth(),
           height: node.yogaNode.getComputedHeight()
         });
-        render_node_to_output_default(node, output, {
+        render_node_to_output_default(node, output2, {
           skipStaticElements: true
         });
         let staticOutput;
@@ -23803,7 +24111,7 @@ var init_renderer = __esm({
             skipStaticElements: false
           });
         }
-        const { output: generatedOutput, height: outputHeight } = output.get();
+        const { output: generatedOutput, height: outputHeight } = output2.get();
         return {
           output: generatedOutput,
           outputHeight,
@@ -24614,8 +24922,8 @@ var init_ErrorOverview = __esm({
     "use strict";
     init_Box();
     init_Text();
-    cleanupPath = (path55) => {
-      return path55?.replace(`file://${cwd()}/`, "");
+    cleanupPath = (path56) => {
+      return path56?.replace(`file://${cwd()}/`, "");
     };
     stackUtils = new StackUtils({
       cwd: cwd(),
@@ -25236,13 +25544,13 @@ var init_ink = __esm({
           incremental: options.incrementalRendering
         });
         this.cursorPosition = void 0;
-        this.throttledLog = unthrottled ? this.log : throttle((output) => {
-          const shouldWrite = this.log.willRender(output);
+        this.throttledLog = unthrottled ? this.log : throttle((output2) => {
+          const shouldWrite = this.log.willRender(output2);
           const sync = shouldSynchronize(this.options.stdout);
           if (sync && shouldWrite) {
             this.options.stdout.write(bsu);
           }
-          this.log(output);
+          this.log(output2);
           if (sync && shouldWrite) {
             this.options.stdout.write(esu);
           }
@@ -25333,22 +25641,22 @@ var init_ink = __esm({
           return;
         }
         const startTime = performance.now();
-        const { output, outputHeight, staticOutput } = renderer_default(this.rootNode, this.isScreenReaderEnabled);
+        const { output: output2, outputHeight, staticOutput } = renderer_default(this.rootNode, this.isScreenReaderEnabled);
         this.options.onRender?.({ renderTime: performance.now() - startTime });
         const hasStaticOutput = staticOutput && staticOutput !== "\n";
         if (this.options.debug) {
           if (hasStaticOutput) {
             this.fullStaticOutput += staticOutput;
           }
-          this.options.stdout.write(this.fullStaticOutput + output);
+          this.options.stdout.write(this.fullStaticOutput + output2);
           return;
         }
         if (isInCi2) {
           if (hasStaticOutput) {
             this.options.stdout.write(staticOutput);
           }
-          this.lastOutput = output;
-          this.lastOutputToRender = output + "\n";
+          this.lastOutput = output2;
+          this.lastOutputToRender = output2 + "\n";
           this.lastOutputHeight = outputHeight;
           return;
         }
@@ -25362,14 +25670,14 @@ var init_ink = __esm({
             this.options.stdout.write(erase + staticOutput);
             this.lastOutputHeight = 0;
           }
-          if (output === this.lastOutput && !hasStaticOutput) {
+          if (output2 === this.lastOutput && !hasStaticOutput) {
             if (sync) {
               this.options.stdout.write(esu);
             }
             return;
           }
           const terminalWidth = this.getTerminalWidth();
-          const wrappedOutput = wrapAnsi2(output, terminalWidth, {
+          const wrappedOutput = wrapAnsi2(output2, terminalWidth, {
             trim: false,
             hard: true
           });
@@ -25379,7 +25687,7 @@ var init_ink = __esm({
             const erase = this.lastOutputHeight > 0 ? ansiEscapes3.eraseLines(this.lastOutputHeight) : "";
             this.options.stdout.write(erase + wrappedOutput);
           }
-          this.lastOutput = output;
+          this.lastOutput = output2;
           this.lastOutputToRender = wrappedOutput;
           this.lastOutputHeight = wrappedOutput === "" ? 0 : wrappedOutput.split("\n").length;
           if (sync) {
@@ -25391,14 +25699,14 @@ var init_ink = __esm({
           this.fullStaticOutput += staticOutput;
         }
         const isFullscreen = this.options.stdout.isTTY && outputHeight >= this.options.stdout.rows;
-        const outputToRender = isFullscreen ? output : output + "\n";
+        const outputToRender = isFullscreen ? output2 : output2 + "\n";
         if (this.lastOutputHeight >= this.options.stdout.rows) {
           const sync = shouldSynchronize(this.options.stdout);
           if (sync) {
             this.options.stdout.write(bsu);
           }
-          this.options.stdout.write(ansiEscapes3.clearTerminal + this.fullStaticOutput + output);
-          this.lastOutput = output;
+          this.options.stdout.write(ansiEscapes3.clearTerminal + this.fullStaticOutput + output2);
+          this.lastOutput = output2;
           this.lastOutputToRender = outputToRender;
           this.lastOutputHeight = outputHeight;
           this.log.sync(outputToRender);
@@ -25418,10 +25726,10 @@ var init_ink = __esm({
           if (sync) {
             this.options.stdout.write(esu);
           }
-        } else if (output !== this.lastOutput || this.log.isCursorDirty()) {
+        } else if (output2 !== this.lastOutput || this.log.isCursorDirty()) {
           this.throttledLog(outputToRender);
         }
-        this.lastOutput = output;
+        this.lastOutput = output2;
         this.lastOutputToRender = outputToRender;
         this.lastOutputHeight = outputHeight;
       };
@@ -28760,7 +29068,7 @@ var init_anthropic = __esm({
 
 // src/lib/providers/openai-compat.ts
 import OpenAI from "openai";
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var OpenAICompatProvider;
 var init_openai_compat = __esm({
   "src/lib/providers/openai-compat.ts"() {
@@ -28877,7 +29185,7 @@ var init_openai_compat = __esm({
             }
             content.push({
               type: "tool_use",
-              id: call.id ?? randomUUID5(),
+              id: call.id ?? randomUUID6(),
               name: fn.name,
               input
             });
@@ -29078,10 +29386,10 @@ var init_hooks = __esm({
 });
 
 // src/runtime/safety-checks.ts
-import path42 from "path";
+import path43 from "path";
 import os21 from "os";
 function checkPathSafety(filePath) {
-  const resolved = path42.resolve(filePath);
+  const resolved = path43.resolve(filePath);
   for (const { pattern, reason } of BYPASS_IMMUNE_PATTERNS) {
     const matches = typeof pattern === "function" ? pattern(resolved) : pattern.test(resolved);
     if (matches) {
@@ -29091,7 +29399,7 @@ function checkPathSafety(filePath) {
   return { safe: true, bypassImmune: true };
 }
 function checkReadPathSafety(filePath) {
-  const resolved = path42.resolve(filePath);
+  const resolved = path43.resolve(filePath);
   const credPatterns = BYPASS_IMMUNE_PATTERNS.filter(
     (p) => typeof p.pattern !== "function" && (p.reason.includes("secrets") || p.reason.includes("Private key") || p.reason.includes("Credential"))
   );
@@ -29117,11 +29425,11 @@ var init_safety_checks = __esm({
         reason: "Git config can set hooks and command execution"
       },
       {
-        pattern: (p) => p.startsWith(path42.join(HOME, ".claude")),
+        pattern: (p) => p.startsWith(path43.join(HOME, ".claude")),
         reason: "Claude configuration files are protected"
       },
       {
-        pattern: (p) => p.startsWith(path42.join(HOME, ".exe-os")),
+        pattern: (p) => p.startsWith(path43.join(HOME, ".exe-os")),
         reason: "exe-os configuration files are protected"
       },
       {
@@ -29138,7 +29446,7 @@ var init_safety_checks = __esm({
       },
       {
         pattern: (p) => {
-          const name = path42.basename(p);
+          const name = path43.basename(p);
           return [".bashrc", ".zshrc", ".profile", ".bash_profile", ".zprofile", ".zshenv"].includes(name);
         },
         reason: "Shell configuration files can execute arbitrary code on login"
@@ -29165,7 +29473,7 @@ __export(file_read_exports, {
   FileReadTool: () => FileReadTool
 });
 import fs3 from "fs/promises";
-import path43 from "path";
+import path44 from "path";
 import { z } from "zod";
 function isBinary(buf) {
   for (let i = 0; i < buf.length; i++) {
@@ -29201,7 +29509,7 @@ var init_file_read = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path43.isAbsolute(input.file_path) ? input.file_path : path43.resolve(context.cwd, input.file_path);
+        const filePath = path44.isAbsolute(input.file_path) ? input.file_path : path44.resolve(context.cwd, input.file_path);
         let stat2;
         try {
           stat2 = await fs3.stat(filePath);
@@ -29241,7 +29549,7 @@ __export(glob_exports, {
   GlobTool: () => GlobTool
 });
 import fs4 from "fs/promises";
-import path44 from "path";
+import path45 from "path";
 import { z as z2 } from "zod";
 async function walkDir(dir, maxDepth = 10) {
   const results = [];
@@ -29257,7 +29565,7 @@ async function walkDir(dir, maxDepth = 10) {
       if (entry.isDirectory() && (entry.name === "node_modules" || entry.name === ".git")) {
         continue;
       }
-      const fullPath = path44.join(current, entry.name);
+      const fullPath = path45.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath, depth + 1);
       } else {
@@ -29291,11 +29599,11 @@ var init_glob = __esm({
       inputSchema: inputSchema2,
       isReadOnly: true,
       async call(input, context) {
-        const baseDir = input.path ? path44.isAbsolute(input.path) ? input.path : path44.resolve(context.cwd, input.path) : context.cwd;
+        const baseDir = input.path ? path45.isAbsolute(input.path) ? input.path : path45.resolve(context.cwd, input.path) : context.cwd;
         try {
           const entries = await walkDir(baseDir);
           const matched = entries.filter(
-            (e) => simpleGlobMatch(path44.relative(baseDir, e.path), input.pattern)
+            (e) => simpleGlobMatch(path45.relative(baseDir, e.path), input.pattern)
           );
           matched.sort((a, b) => b.mtime - a.mtime);
           if (matched.length === 0) {
@@ -29321,7 +29629,7 @@ __export(grep_exports, {
 });
 import { spawn as spawn2 } from "child_process";
 import fs5 from "fs/promises";
-import path45 from "path";
+import path46 from "path";
 import { z as z3 } from "zod";
 function runRipgrep(input, searchPath, context) {
   return new Promise((resolve, reject) => {
@@ -29349,8 +29657,8 @@ function runRipgrep(input, searchPath, context) {
     context.abortSignal.addEventListener("abort", onAbort, { once: true });
     child.on("close", (code) => {
       context.abortSignal.removeEventListener("abort", onAbort);
-      const output = Buffer.concat(chunks).toString("utf-8").trim();
-      if (code === 1 && !output) {
+      const output2 = Buffer.concat(chunks).toString("utf-8").trim();
+      if (code === 1 && !output2) {
         resolve({ content: "No matches found." });
         return;
       }
@@ -29358,7 +29666,7 @@ function runRipgrep(input, searchPath, context) {
         reject(new Error("ripgrep error"));
         return;
       }
-      resolve({ content: output || "No matches found." });
+      resolve({ content: output2 || "No matches found." });
     });
     child.on("error", () => reject(new Error("rg not found")));
   });
@@ -29375,7 +29683,7 @@ async function nodeGrep(input, searchPath) {
     }
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const fullPath = path45.join(dir, entry.name);
+      const fullPath = path46.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
@@ -29421,7 +29729,7 @@ var init_grep = __esm({
       inputSchema: inputSchema3,
       isReadOnly: true,
       async call(input, context) {
-        const searchPath = input.path ? path45.isAbsolute(input.path) ? input.path : path45.resolve(context.cwd, input.path) : context.cwd;
+        const searchPath = input.path ? path46.isAbsolute(input.path) ? input.path : path46.resolve(context.cwd, input.path) : context.cwd;
         try {
           const result = await runRipgrep(input, searchPath, context);
           return result;
@@ -29446,7 +29754,7 @@ __export(file_write_exports, {
   FileWriteTool: () => FileWriteTool
 });
 import fs6 from "fs/promises";
-import path46 from "path";
+import path47 from "path";
 import { z as z4 } from "zod";
 var inputSchema4, FileWriteTool;
 var init_file_write = __esm({
@@ -29474,8 +29782,8 @@ var init_file_write = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path46.isAbsolute(input.file_path) ? input.file_path : path46.resolve(context.cwd, input.file_path);
-        const dir = path46.dirname(filePath);
+        const filePath = path47.isAbsolute(input.file_path) ? input.file_path : path47.resolve(context.cwd, input.file_path);
+        const dir = path47.dirname(filePath);
         await fs6.mkdir(dir, { recursive: true });
         await fs6.writeFile(filePath, input.content, "utf-8");
         return {
@@ -29493,7 +29801,7 @@ __export(file_edit_exports, {
   FileEditTool: () => FileEditTool
 });
 import fs7 from "fs/promises";
-import path47 from "path";
+import path48 from "path";
 import { z as z5 } from "zod";
 function countOccurrences(haystack, needle) {
   let count = 0;
@@ -29534,7 +29842,7 @@ var init_file_edit = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path47.isAbsolute(input.file_path) ? input.file_path : path47.resolve(context.cwd, input.file_path);
+        const filePath = path48.isAbsolute(input.file_path) ? input.file_path : path48.resolve(context.cwd, input.file_path);
         let content;
         try {
           content = await fs7.readFile(filePath, "utf-8");
@@ -29757,8 +30065,8 @@ var init_bash = __esm({
               return;
             }
             if (code !== 0) {
-              const output = stderr || stdout || `Exit code ${code}`;
-              resolve({ content: output, isError: true });
+              const output2 = stderr || stdout || `Exit code ${code}`;
+              resolve({ content: output2, isError: true });
               return;
             }
             resolve({ content: stdout || "(no output)" });
@@ -29776,7 +30084,7 @@ var init_bash = __esm({
 // src/tui/views/CommandCenter.tsx
 import { useState as useState6, useEffect as useEffect8, useMemo as useMemo4, useCallback as useCallback4, useRef as useRef4 } from "react";
 import TextInput from "ink-text-input";
-import path48 from "path";
+import path49 from "path";
 import { homedir as homedir6 } from "os";
 import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 function CommandCenterView({
@@ -29811,7 +30119,7 @@ function CommandCenterView({
         const { createPermissionsFromPreset: createPermissionsFromPreset2, EMPLOYEE_PERMISSIONS: EMPLOYEE_PERMISSIONS2 } = await Promise.resolve().then(() => (init_permissions(), permissions_exports));
         const { getPresetByRole: getPresetByRole2 } = await Promise.resolve().then(() => (init_permission_presets(), permission_presets_exports));
         const { createDefaultHooks: createDefaultHooks2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
-        const { readFileSync: readFileSync36, existsSync: existsSync41 } = await import("fs");
+        const { readFileSync: readFileSync37, existsSync: existsSync41 } = await import("fs");
         const { join } = await import("path");
         const { homedir: homedir8 } = await import("os");
         const configPath = join(homedir8(), ".exe-os", "config.json");
@@ -29819,7 +30127,7 @@ function CommandCenterView({
         let providerConfigs = {};
         if (existsSync41(configPath)) {
           try {
-            const raw = JSON.parse(readFileSync36(configPath, "utf8"));
+            const raw = JSON.parse(readFileSync37(configPath, "utf8"));
             if (Array.isArray(raw.failoverChain)) failoverChain = raw.failoverChain;
             if (raw.providers && typeof raw.providers === "object") {
               providerConfigs = raw.providers;
@@ -29880,7 +30188,7 @@ function CommandCenterView({
           const markerDir = join(homedir8(), ".exe-os", "session-cache");
           const agentFiles = (await import("fs")).readdirSync(markerDir).filter((f) => f.startsWith("active-agent-"));
           for (const f of agentFiles) {
-            const data = JSON.parse(readFileSync36(join(markerDir, f), "utf8"));
+            const data = JSON.parse(readFileSync37(join(markerDir, f), "utf8"));
             if (data.agentRole) {
               agentRole = data.agentRole;
               break;
@@ -30025,7 +30333,7 @@ function CommandCenterView({
       const demoEntries = DEMO_PROJECTS.map((p) => ({
         projectName: p.projectName,
         exeSession: p.exeSession,
-        projectDir: path48.join(homedir6(), p.projectName),
+        projectDir: path49.join(homedir6(), p.projectName),
         employeeCount: p.employees.length,
         activeCount: p.employees.filter((e) => e.status === "active").length,
         memoryCount: p.employees.length * 4e3,
@@ -30401,11 +30709,11 @@ function TmuxPane({ sessionName, employeeName, employeeRole, projectName, onDeta
     const capture = () => {
       try {
         const { execSync: execSync18 } = __require("child_process");
-        const output = execSync18(
+        const output2 = execSync18(
           `tmux capture-pane -t ${JSON.stringify(sessionName)} -p -e 2>/dev/null | tail -${CAPTURE_LINES}`,
           { encoding: "utf8", timeout: 3e3 }
         );
-        setLines(output.split("\n"));
+        setLines(output2.split("\n"));
         setAlive(true);
       } catch {
         setAlive(false);
@@ -30506,7 +30814,7 @@ var init_TmuxPane = __esm({
 });
 
 // src/lib/task-router.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 function resolveBloomRouting(complexity, config = DEFAULT_BLOOM_CONFIG) {
   const tier = config.complexityToTier[complexity];
   const rule = config.tierRules[tier];
@@ -31029,7 +31337,7 @@ var init_useOrchestrator = __esm({
 
 // src/tui/views/Sessions.tsx
 import React19, { useState as useState9, useEffect as useEffect11, useCallback as useCallback6 } from "react";
-import path49 from "path";
+import path50 from "path";
 import { homedir as homedir7 } from "os";
 import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 function isCoordinatorEntry(entry) {
@@ -31067,7 +31375,7 @@ function SessionsView({
     if (demo) {
       setProjects(DEMO_PROJECTS.map((p) => ({
         ...p,
-        projectDir: path49.join(homedir7(), p.projectName),
+        projectDir: path50.join(homedir7(), p.projectName),
         employees: p.employees.map((e) => ({ ...e, attached: e.status === "active" }))
       })));
       return;
@@ -32282,12 +32590,12 @@ async function loadGatewayConfig() {
     state.running = false;
   }
   try {
-    const { existsSync: existsSync41, readFileSync: readFileSync36 } = await import("fs");
+    const { existsSync: existsSync41, readFileSync: readFileSync37 } = await import("fs");
     const { join } = await import("path");
     const home = process.env.HOME ?? "";
     const configPath = join(home, ".exe-os", "gateway.json");
     if (existsSync41(configPath)) {
-      const raw = JSON.parse(readFileSync36(configPath, "utf8"));
+      const raw = JSON.parse(readFileSync37(configPath, "utf8"));
       state.port = raw.port ?? 3100;
       state.gatewayUrl = raw.gatewayUrl ?? "";
       if (raw.adapters) {
@@ -32885,12 +33193,12 @@ function TeamView({ onBack, onViewSessions }) {
         setMembers(teamData);
         setDbError(null);
         try {
-          const { existsSync: existsSync41, readFileSync: readFileSync36 } = await import("fs");
+          const { existsSync: existsSync41, readFileSync: readFileSync37 } = await import("fs");
           const { join } = await import("path");
           const home = process.env.HOME ?? "";
           const gatewayConfig = join(home, ".exe-os", "gateway.json");
           if (existsSync41(gatewayConfig)) {
-            const raw = JSON.parse(readFileSync36(gatewayConfig, "utf8"));
+            const raw = JSON.parse(readFileSync37(gatewayConfig, "utf8"));
             if (raw.agents && raw.agents.length > 0) {
               setExternals(raw.agents.map((a) => ({
                 name: a.name,
@@ -33070,8 +33378,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config, path55, method = "GET", body) {
-  const url = `${config.baseUrl}/api/v1${path55}`;
+async function wikiFetch(config, path56, method = "GET", body) {
+  const url = `${config.baseUrl}/api/v1${path56}`;
   const headers = {
     Authorization: `Bearer ${config.apiKey}`,
     "Content-Type": "application/json"
@@ -33104,7 +33412,7 @@ async function wikiFetch(config, path55, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path55}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path56}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -33721,17 +34029,17 @@ function SettingsView({ onBack }) {
       }
       let version = "unknown";
       try {
-        const { readFileSync: readFileSync36 } = await import("fs");
+        const { readFileSync: readFileSync37 } = await import("fs");
         const { createRequire: createRequire3 } = await import("module");
         const require2 = createRequire3(import.meta.url);
         const pkgPath = require2.resolve("@askexenow/exe-os/package.json");
-        const pkg = JSON.parse(readFileSync36(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync37(pkgPath, "utf8"));
         version = pkg.version;
       } catch {
         try {
-          const { readFileSync: readFileSync36 } = await import("fs");
+          const { readFileSync: readFileSync37 } = await import("fs");
           const { join: joinPath } = await import("path");
-          const pkg = JSON.parse(readFileSync36(joinPath(process.cwd(), "package.json"), "utf8"));
+          const pkg = JSON.parse(readFileSync37(joinPath(process.cwd(), "package.json"), "utf8"));
           version = pkg.version;
         } catch {
         }
@@ -34588,24 +34896,24 @@ __export(code_context_index_exports, {
   traceCodeSymbol: () => traceCodeSymbol
 });
 import crypto14 from "crypto";
-import path50 from "path";
-import { existsSync as existsSync36, mkdirSync as mkdirSync24, readFileSync as readFileSync31, readdirSync as readdirSync11, statSync as statSync7, writeFileSync as writeFileSync25 } from "fs";
+import path51 from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync25, readFileSync as readFileSync32, readdirSync as readdirSync11, statSync as statSync7, writeFileSync as writeFileSync26 } from "fs";
 import { spawnSync } from "child_process";
 function normalizeProjectRoot(projectRoot) {
-  return path50.resolve(projectRoot || process.cwd());
+  return path51.resolve(projectRoot || process.cwd());
 }
 function hashText(text) {
   return crypto14.createHash("sha256").update(text).digest("hex");
 }
 function indexDir() {
-  const dir = path50.join(EXE_AI_DIR, "code-context");
-  mkdirSync24(dir, { recursive: true });
+  const dir = path51.join(EXE_AI_DIR, "code-context");
+  mkdirSync25(dir, { recursive: true });
   return dir;
 }
 function getCodeContextIndexPath(projectRoot) {
   const root = normalizeProjectRoot(projectRoot);
   const rootHash = hashText(root).slice(0, 16);
-  return path50.join(indexDir(), `${rootHash}.json`);
+  return path51.join(indexDir(), `${rootHash}.json`);
 }
 function currentBranch(projectRoot) {
   const result = spawnSync("git", ["branch", "--show-current"], { cwd: projectRoot, encoding: "utf8", timeout: 2e3 });
@@ -34618,8 +34926,8 @@ function shouldIgnore(relPath) {
 }
 function listRecursive(projectRoot, dir = projectRoot, out = []) {
   for (const entry of readdirSync11(dir, { withFileTypes: true })) {
-    const abs = path50.join(dir, entry.name);
-    const rel = path50.relative(projectRoot, abs).replaceAll(path50.sep, "/");
+    const abs = path51.join(dir, entry.name);
+    const rel = path51.relative(projectRoot, abs).replaceAll(path51.sep, "/");
     if (shouldIgnore(rel)) continue;
     if (entry.isDirectory()) listRecursive(projectRoot, abs, out);
     else if (entry.isFile()) out.push(rel);
@@ -34635,7 +34943,7 @@ function listCodeFiles(projectRoot, maxFiles) {
     const rg = spawnSync("rg", ["--files"], { cwd: projectRoot, encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024 * 16 });
     files = rg.status === 0 && rg.stdout.trim() ? rg.stdout.split("\n").map((s) => s.trim()).filter(Boolean) : listRecursive(projectRoot);
   }
-  return files.map((file) => file.replaceAll(path50.sep, "/")).filter((file) => isChunkable(file) && !shouldIgnore(file)).slice(0, maxFiles).sort();
+  return files.map((file) => file.replaceAll(path51.sep, "/")).filter((file) => isChunkable(file) && !shouldIgnore(file)).slice(0, maxFiles).sort();
 }
 function parseImportPaths(importText) {
   const paths = [];
@@ -34648,13 +34956,13 @@ function parseImportPaths(importText) {
 }
 function resolveImport(fromFile, importPath, allFiles) {
   if (!importPath.startsWith(".")) return null;
-  const base = path50.posix.normalize(path50.posix.join(path50.posix.dirname(fromFile.replaceAll(path50.sep, "/")), importPath));
+  const base = path51.posix.normalize(path51.posix.join(path51.posix.dirname(fromFile.replaceAll(path51.sep, "/")), importPath));
   const withoutKnownExt = base.replace(/\.(?:[a-z0-9]+)$/i, "");
   const candidates = [base];
   for (const ext of ["ts", "tsx", "js", "jsx", "py", "rs", "go", "java", "cs", "cpp", "c", "rb", "php", "swift", "kt", "scala", "sql", "md", "json", "yaml", "yml"]) {
     candidates.push(`${withoutKnownExt}.${ext}`, `${base}.${ext}`);
   }
-  for (const indexName of ["index.ts", "index.tsx", "index.js", "mod.rs", "__init__.py"]) candidates.push(path50.posix.join(base, indexName));
+  for (const indexName of ["index.ts", "index.tsx", "index.js", "mod.rs", "__init__.py"]) candidates.push(path51.posix.join(base, indexName));
   return candidates.find((candidate) => allFiles.has(candidate)) ?? null;
 }
 function symbolId(filePath, chunk) {
@@ -34664,7 +34972,7 @@ function loadIndex(projectRoot) {
   const file = getCodeContextIndexPath(projectRoot);
   if (!existsSync36(file)) return null;
   try {
-    const parsed = JSON.parse(readFileSync31(file, "utf8"));
+    const parsed = JSON.parse(readFileSync32(file, "utf8"));
     if (parsed.version !== INDEX_VERSION || parsed.projectRoot !== projectRoot) return null;
     return parsed;
   } catch {
@@ -34672,10 +34980,10 @@ function loadIndex(projectRoot) {
   }
 }
 function saveIndex(index) {
-  writeFileSync25(getCodeContextIndexPath(index.projectRoot), JSON.stringify(index, null, 2));
+  writeFileSync26(getCodeContextIndexPath(index.projectRoot), JSON.stringify(index, null, 2));
 }
 function buildFileRecord(projectRoot, relPath, allFiles, previous) {
-  const absPath = path50.join(projectRoot, relPath);
+  const absPath = path51.join(projectRoot, relPath);
   let stat2;
   try {
     stat2 = statSync7(absPath);
@@ -34685,7 +34993,7 @@ function buildFileRecord(projectRoot, relPath, allFiles, previous) {
   if (!stat2.isFile()) return { record: null, reused: false };
   const language = languageForFile(relPath);
   if (!language || !isChunkable(relPath)) return { record: null, reused: false };
-  const source = readFileSync31(absPath, "utf8");
+  const source = readFileSync32(absPath, "utf8");
   const hash = hashText(source);
   if (previous && previous.hash === hash && previous.mtimeMs === stat2.mtimeMs && previous.size === stat2.size && previous.language === language) {
     return { record: previous, reused: true };
@@ -34713,13 +35021,13 @@ function buildCodeContextIndex(options = {}) {
   const branch = currentBranch(projectRoot);
   const previous = options.force ? null : loadIndex(projectRoot);
   const files = listCodeFiles(projectRoot, maxFiles);
-  const allFiles = new Set(files.map((file) => file.replaceAll(path50.sep, "/")));
+  const allFiles = new Set(files.map((file) => file.replaceAll(path51.sep, "/")));
   const fileRecords = {};
   let rebuiltFiles = 0;
   let reusedFiles = 0;
   let skippedFiles = 0;
   for (const rel of files) {
-    const normalized = rel.replaceAll(path50.sep, "/");
+    const normalized = rel.replaceAll(path51.sep, "/");
     const { record, reused } = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
     if (record) {
       fileRecords[normalized] = record;
@@ -34748,11 +35056,11 @@ function loadOrBuildCodeContextIndex(options = {}) {
     if (loaded) {
       const currentFiles = listCodeFiles(projectRoot, options.maxFiles ?? DEFAULT_MAX_FILES);
       const unchanged = currentFiles.every((rel) => {
-        const normalized = rel.replaceAll(path50.sep, "/");
+        const normalized = rel.replaceAll(path51.sep, "/");
         const existing = loaded.files[normalized];
         if (!existing) return false;
         try {
-          const stat2 = statSync7(path50.join(projectRoot, normalized));
+          const stat2 = statSync7(path51.join(projectRoot, normalized));
           return stat2.mtimeMs === existing.mtimeMs && stat2.size === existing.size;
         } catch {
           return false;
@@ -34805,9 +35113,9 @@ function globToRegex(pattern) {
 }
 function matchesPath(filePath, patterns) {
   if (!patterns || patterns.length === 0) return true;
-  const normalized = filePath.replaceAll(path50.sep, "/");
+  const normalized = filePath.replaceAll(path51.sep, "/");
   return patterns.some((pattern) => {
-    const p = pattern.replaceAll(path50.sep, "/").replace(/^\.\//, "");
+    const p = pattern.replaceAll(path51.sep, "/").replace(/^\.\//, "");
     return normalized === p || normalized.startsWith(`${p}/`) || normalized.endsWith(p) || globToRegex(p).test(normalized);
   });
 }
@@ -34925,7 +35233,7 @@ function traceCodeSymbol(symbolName, options = {}) {
 }
 function resolveTargetFile(index, input) {
   if (input.filePath) {
-    const normalized = input.filePath.replaceAll(path50.sep, "/").replace(/^\.\//, "");
+    const normalized = input.filePath.replaceAll(path51.sep, "/").replace(/^\.\//, "");
     if (index.files[normalized]) return { filePath: normalized, target: normalized };
     const suffix = Object.keys(index.files).find((file) => file.endsWith(normalized));
     if (suffix) return { filePath: suffix, target: input.filePath };
@@ -34955,7 +35263,7 @@ function analyzeBlastRadius(input) {
       }
     }
   }
-  const targetBase = path50.basename(target.filePath).replace(/\.[^.]+$/, "").toLowerCase();
+  const targetBase = path51.basename(target.filePath).replace(/\.[^.]+$/, "").toLowerCase();
   const symbolLower = input.symbol?.toLowerCase();
   const tests = Object.keys(index.files).filter((file) => {
     const lower = file.toLowerCase();
@@ -35188,13 +35496,13 @@ __export(installer_exports2, {
   verifyOpenCodeHooks: () => verifyOpenCodeHooks
 });
 import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync37, readFileSync as readFileSync32 } from "fs";
-import path51 from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync33 } from "fs";
+import path52 from "path";
 import os22 from "os";
 async function registerOpenCodeMcp(packageRoot, homeDir = os22.homedir()) {
   void packageRoot;
-  const configDir = path51.join(homeDir, ".config", "opencode");
-  const configPath = path51.join(configDir, "opencode.json");
+  const configDir = path52.join(homeDir, ".config", "opencode");
+  const configPath = path52.join(configDir, "opencode.json");
   await mkdir8(configDir, { recursive: true });
   let config = {};
   if (existsSync37(configPath)) {
@@ -35225,8 +35533,8 @@ async function registerOpenCodeMcp(packageRoot, homeDir = os22.homedir()) {
   return true;
 }
 async function installOpenCodePlugin(packageRoot, homeDir = os22.homedir()) {
-  const pluginDir = path51.join(homeDir, ".config", "opencode", "plugins");
-  const pluginPath = path51.join(pluginDir, "exe-os.mjs");
+  const pluginDir = path52.join(homeDir, ".config", "opencode", "plugins");
+  const pluginPath = path52.join(pluginDir, "exe-os.mjs");
   await mkdir8(pluginDir, { recursive: true });
   const pluginContent = PLUGIN_TEMPLATE.replace(
     /__PACKAGE_ROOT__/g,
@@ -35242,18 +35550,18 @@ async function installOpenCodePlugin(packageRoot, homeDir = os22.homedir()) {
   return true;
 }
 function verifyOpenCodeHooks(homeDir = os22.homedir()) {
-  const configPath = path51.join(homeDir, ".config", "opencode", "opencode.json");
-  const pluginPath = path51.join(homeDir, ".config", "opencode", "plugins", "exe-os.mjs");
+  const configPath = path52.join(homeDir, ".config", "opencode", "opencode.json");
+  const pluginPath = path52.join(homeDir, ".config", "opencode", "plugins", "exe-os.mjs");
   if (!existsSync37(configPath)) return false;
   try {
-    const config = JSON.parse(readFileSync32(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync33(configPath, "utf-8"));
     if (!config.mcp?.["exe-os"]?.enabled) return false;
   } catch {
     return false;
   }
   if (!existsSync37(pluginPath)) return false;
   try {
-    const plugin = readFileSync32(pluginPath, "utf-8");
+    const plugin = readFileSync33(pluginPath, "utf-8");
     if (!plugin.includes(EXE_HOOK_FILES.postToolCombined)) return false;
     if (textHasLegacySplitPostToolHook(plugin)) return false;
   } catch {
@@ -35295,14 +35603,14 @@ __export(installer_exports3, {
   verifyCodexHooks: () => verifyCodexHooks
 });
 import { readFile as readFile8, writeFile as writeFile9, mkdir as mkdir9 } from "fs/promises";
-import { existsSync as existsSync38, readFileSync as readFileSync33 } from "fs";
-import path52 from "path";
+import { existsSync as existsSync38, readFileSync as readFileSync34 } from "fs";
+import path53 from "path";
 import os23 from "os";
 async function mergeCodexHooks(packageRoot, homeDir = os23.homedir()) {
-  const codexDir = path52.join(homeDir, ".codex");
-  const hooksPath = path52.join(codexDir, "hooks.json");
-  const logsDir = path52.join(homeDir, ".exe-os", "logs");
-  const hookLogPath = path52.join(logsDir, "hooks.log");
+  const codexDir = path53.join(homeDir, ".codex");
+  const hooksPath = path53.join(codexDir, "hooks.json");
+  const logsDir = path53.join(homeDir, ".exe-os", "logs");
+  const hookLogPath = path53.join(logsDir, "hooks.log");
   const logSuffix = ` 2>> "${hookLogPath}"`;
   await mkdir9(codexDir, { recursive: true });
   await mkdir9(logsDir, { recursive: true });
@@ -35327,7 +35635,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os23.homedir()) {
             // Combined hook: runs ingest + error-recall in one Node process.
             // Eliminates a cold-start cycle per tool call (~3-6s savings on Codex).
             type: "command",
-            command: `node "${path52.join(packageRoot, "dist", "hooks", "post-tool-combined.js")}"${logSuffix}`
+            command: `node "${path53.join(packageRoot, "dist", "hooks", "post-tool-combined.js")}"${logSuffix}`
           }
         ]
       },
@@ -35341,7 +35649,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os23.homedir()) {
             // Single hook: prompt-submit handles memory retrieval + entity boost.
             // exe-heartbeat-hook is CC-specific (intercom) — omitted on Codex.
             type: "command",
-            command: `node "${path52.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
+            command: `node "${path53.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
           }
         ]
       },
@@ -35353,7 +35661,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os23.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path52.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
+            command: `node "${path53.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
           }
         ]
       },
@@ -35366,7 +35674,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os23.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path52.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
+            command: `node "${path53.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
           }
         ]
       },
@@ -35415,10 +35723,10 @@ async function mergeCodexHooks(packageRoot, homeDir = os23.homedir()) {
   return { added, skipped };
 }
 function verifyCodexHooks(homeDir = os23.homedir()) {
-  const hooksPath = path52.join(homeDir, ".codex", "hooks.json");
+  const hooksPath = path53.join(homeDir, ".codex", "hooks.json");
   if (!existsSync38(hooksPath)) return false;
   try {
-    const hooksJson = JSON.parse(readFileSync33(hooksPath, "utf-8"));
+    const hooksJson = JSON.parse(readFileSync34(hooksPath, "utf-8"));
     if (!hooksJson.hooks) return false;
     const required = ["PostToolUse", "UserPromptSubmit", "Stop", "PreToolUse"];
     for (const event of required) {
@@ -35450,8 +35758,8 @@ function verifyCodexHooks(homeDir = os23.homedir()) {
 async function installCodexStatusLine(homeDir = os23.homedir()) {
   const prefs = loadPreferences(homeDir);
   if (prefs.codexStatusLine === false) return "opted-out";
-  const codexDir = path52.join(homeDir, ".codex");
-  const configPath = path52.join(codexDir, "config.toml");
+  const codexDir = path53.join(homeDir, ".codex");
+  const configPath = path53.join(codexDir, "config.toml");
   await mkdir9(codexDir, { recursive: true });
   let content = "";
   if (existsSync38(configPath)) {
@@ -35506,8 +35814,8 @@ ${line}
   return { content: next, changed: next !== sectionContent };
 }
 async function registerCodexMcpServer(packageRoot, homeDir = os23.homedir()) {
-  const codexDir = path52.join(homeDir, ".codex");
-  const configPath = path52.join(codexDir, "config.toml");
+  const codexDir = path53.join(homeDir, ".codex");
+  const configPath = path53.join(codexDir, "config.toml");
   void packageRoot;
   await mkdir9(codexDir, { recursive: true });
   let content = "";
@@ -35536,8 +35844,8 @@ async function registerCodexMcpServer(packageRoot, homeDir = os23.homedir()) {
   return "registered";
 }
 async function ensureCodexHooksFeature(homeDir = os23.homedir()) {
-  const configPath = path52.join(homeDir, ".codex", "config.toml");
-  await mkdir9(path52.join(homeDir, ".codex"), { recursive: true });
+  const configPath = path53.join(homeDir, ".codex", "config.toml");
+  await mkdir9(path53.join(homeDir, ".codex"), { recursive: true });
   let content = "";
   if (existsSync38(configPath)) {
     content = await readFile8(configPath, "utf-8");
@@ -35614,32 +35922,32 @@ __export(mcp_diagnostics_exports, {
   diagnoseClaudeMcpConfig: () => diagnoseClaudeMcpConfig,
   formatMcpDiagnosticReport: () => formatMcpDiagnosticReport
 });
-import { existsSync as existsSync39, readFileSync as readFileSync34 } from "fs";
-import path53 from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync35 } from "fs";
+import path54 from "path";
 import os24 from "os";
 function readJson(filePath) {
   if (!existsSync39(filePath)) return null;
   try {
-    return JSON.parse(readFileSync34(filePath, "utf8"));
+    return JSON.parse(readFileSync35(filePath, "utf8"));
   } catch {
     return null;
   }
 }
 function pathApplies2(projectPath, cwd2) {
-  const project = path53.resolve(projectPath);
-  const current = path53.resolve(cwd2);
-  return current === project || current.startsWith(project + path53.sep);
+  const project = path54.resolve(projectPath);
+  const current = path54.resolve(cwd2);
+  return current === project || current.startsWith(project + path54.sep);
 }
 function findAncestorMcpJsons2(cwd2, homeDir) {
   const files = [];
-  let dir = path53.resolve(cwd2);
-  const root = path53.parse(dir).root;
-  const stop = path53.resolve(homeDir);
+  let dir = path54.resolve(cwd2);
+  const root = path54.parse(dir).root;
+  const stop = path54.resolve(homeDir);
   while (dir !== root) {
-    const candidate = path53.join(dir, ".mcp.json");
+    const candidate = path54.join(dir, ".mcp.json");
     if (existsSync39(candidate)) files.push(candidate);
     if (dir === stop) break;
-    dir = path53.dirname(dir);
+    dir = path54.dirname(dir);
   }
   return files;
 }
@@ -35656,8 +35964,8 @@ function serverAllowedByPermissions(serverName, prefixes) {
   return prefixes.has(serverName) || prefixes.has(serverName.replace(/-/g, "_"));
 }
 function diagnoseClaudeMcpConfig(homeDir = os24.homedir(), cwd2 = process.cwd(), env = process.env) {
-  const claudeJsonPath = path53.join(homeDir, ".claude.json");
-  const settingsPath = path53.join(homeDir, ".claude", "settings.json");
+  const claudeJsonPath = path54.join(homeDir, ".claude.json");
+  const settingsPath = path54.join(homeDir, ".claude", "settings.json");
   const claudeJson = readJson(claudeJsonPath);
   const settings = readJson(settingsPath);
   const issues = [];
@@ -35777,7 +36085,7 @@ function diagnoseClaudeMcpConfig(homeDir = os24.homedir(), cwd2 = process.cwd(),
     });
   }
   return {
-    cwd: path53.resolve(cwd2),
+    cwd: path54.resolve(cwd2),
     globalServers,
     projectServers: projectServers.sort((a, b) => a.name.localeCompare(b.name)),
     mcpJsonServers: mcpJsonServers.sort((a, b) => a.name.localeCompare(b.name)),
@@ -35814,14 +36122,14 @@ var init_mcp_diagnostics = __esm({
 });
 
 // src/bin/cli.ts
-import { existsSync as existsSync40, readFileSync as readFileSync35, writeFileSync as writeFileSync26, readdirSync as readdirSync12, rmSync as rmSync2 } from "fs";
-import path54 from "path";
+import { existsSync as existsSync40, readFileSync as readFileSync36, writeFileSync as writeFileSync27, readdirSync as readdirSync12, rmSync as rmSync2 } from "fs";
+import path55 from "path";
 import os25 from "os";
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
   try {
-    const pkgPath = path54.join(path54.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync35(pkgPath, "utf8"));
+    const pkgPath = path55.join(path55.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync36(pkgPath, "utf8"));
     console.log(pkg.version);
   } catch {
     console.log("unknown");
@@ -35943,6 +36251,9 @@ if (args.includes("--global")) {
     const { main: runCloud } = await Promise.resolve().then(() => (init_exe_cloud(), exe_cloud_exports));
     await runCloud();
   }
+} else if (args[0] === "support") {
+  const { main: runSupport } = await Promise.resolve().then(() => (init_exe_support(), exe_support_exports));
+  await runSupport(args.slice(1));
 } else if (args[0] === "bulk-sync-postgres") {
   const { main: runBulkSyncPostgres } = await Promise.resolve().then(() => (init_bulk_sync_postgres(), bulk_sync_postgres_exports));
   await runBulkSyncPostgres();
@@ -36046,11 +36357,11 @@ ID: ${result.id}`);
   });
   await init_App2().then(() => App_exports);
 } else {
-  const claudeDir = path54.join(os25.homedir(), ".claude");
-  const settingsPath = path54.join(claudeDir, "settings.json");
+  const claudeDir = path55.join(os25.homedir(), ".claude");
+  const settingsPath = path55.join(claudeDir, "settings.json");
   const hasClaudeCode = existsSync40(settingsPath) && (() => {
     try {
-      const raw = readFileSync35(settingsPath, "utf8");
+      const raw = readFileSync36(settingsPath, "utf8");
       return raw.includes("exe-os") || raw.includes("exe-mem");
     } catch {
       return false;
@@ -36060,9 +36371,9 @@ ID: ${result.id}`);
     const { DEFAULT_COORDINATOR_TEMPLATE_NAME: DEFAULT_COORDINATOR_TEMPLATE_NAME2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
     let cooName = DEFAULT_COORDINATOR_TEMPLATE_NAME2;
     try {
-      const rosterPath = path54.join(os25.homedir(), ".exe-os", "exe-employees.json");
+      const rosterPath = path55.join(os25.homedir(), ".exe-os", "exe-employees.json");
       if (existsSync40(rosterPath)) {
-        const roster = JSON.parse(readFileSync35(rosterPath, "utf8"));
+        const roster = JSON.parse(readFileSync36(rosterPath, "utf8"));
         const coo = roster.find((e) => e.role === "COO");
         if (coo) cooName = coo.name;
       }
@@ -36215,14 +36526,14 @@ async function runCodexInstall() {
 }
 async function runClaudeCheck() {
   const { detectMcpNameCollisions: detectMcpNameCollisions2 } = await Promise.resolve().then(() => (init_installer(), installer_exports));
-  const claudeDir = path54.join(os25.homedir(), ".claude");
-  const settingsPath = path54.join(claudeDir, "settings.json");
-  const claudeJsonPath = path54.join(os25.homedir(), ".claude.json");
+  const claudeDir = path55.join(os25.homedir(), ".claude");
+  const settingsPath = path55.join(claudeDir, "settings.json");
+  const claudeJsonPath = path55.join(os25.homedir(), ".claude.json");
   let ok = true;
   if (existsSync40(settingsPath)) {
     let settings;
     try {
-      settings = JSON.parse(readFileSync35(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync36(settingsPath, "utf8"));
     } catch {
       console.log("\x1B[31m\u2717\x1B[0m settings.json is malformed (invalid JSON)");
       ok = false;
@@ -36251,7 +36562,7 @@ async function runClaudeCheck() {
   if (existsSync40(claudeJsonPath)) {
     let claudeJson;
     try {
-      claudeJson = JSON.parse(readFileSync35(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync36(claudeJsonPath, "utf8"));
     } catch {
       console.log("\x1B[31m\u2717\x1B[0m claude.json is malformed (invalid JSON)");
       ok = false;
@@ -36284,7 +36595,7 @@ async function runClaudeCheck() {
   } else {
     console.log("\x1B[32m\u2713\x1B[0m No .mcp.json/project MCP name collisions detected");
   }
-  const skillsDir = path54.join(claudeDir, "skills");
+  const skillsDir = path55.join(claudeDir, "skills");
   if (existsSync40(skillsDir)) {
     console.log("\x1B[32m\u2713\x1B[0m Slash skills directory exists");
   } else {
@@ -36309,16 +36620,16 @@ async function runClaudeUninstall(flags = []) {
   const dryRun = flags.includes("--dry-run");
   const purge = flags.includes("--purge");
   const homeDir = os25.homedir();
-  const claudeDir = path54.join(homeDir, ".claude");
-  const settingsPath = path54.join(claudeDir, "settings.json");
-  const claudeJsonPath = path54.join(homeDir, ".claude.json");
-  const exeOsDir = path54.join(homeDir, ".exe-os");
+  const claudeDir = path55.join(homeDir, ".claude");
+  const settingsPath = path55.join(claudeDir, "settings.json");
+  const claudeJsonPath = path55.join(homeDir, ".claude.json");
+  const exeOsDir = path55.join(homeDir, ".exe-os");
   let removed = 0;
   const log = (msg) => console.log(dryRun ? `[dry-run] ${msg}` : msg);
   let settings = {};
   if (existsSync40(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync35(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync36(settingsPath, "utf8"));
     } catch {
       console.error("Your ~/.claude/settings.json appears malformed.");
       if (purge) {
@@ -36356,7 +36667,7 @@ async function runClaudeUninstall(flags = []) {
         permCount = before - settings.permissions.allow.length;
       }
       if (!dryRun) {
-        writeFileSync26(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        writeFileSync27(settingsPath, JSON.stringify(settings, null, 2) + "\n");
       }
       log("\u2713 Removed exe-os hooks from settings.json");
       if (permCount > 0) log(`\u2713 Removed ${permCount} MCP permission entries`);
@@ -36364,7 +36675,7 @@ async function runClaudeUninstall(flags = []) {
     }
   }
   if (existsSync40(claudeJsonPath)) {
-    const raw = readFileSync35(claudeJsonPath, "utf8");
+    const raw = readFileSync36(claudeJsonPath, "utf8");
     if (raw.length > 1e6) {
       console.error("claude.json exceeds 1 MB \u2014 skipping parse.");
     } else {
@@ -36385,7 +36696,7 @@ async function runClaudeUninstall(flags = []) {
         }
         if (removedMcp) {
           if (!dryRun) {
-            writeFileSync26(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+            writeFileSync27(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
           }
           log("\u2713 Removed exe-os MCP server from claude.json");
           removed++;
@@ -36393,14 +36704,14 @@ async function runClaudeUninstall(flags = []) {
       }
     }
   }
-  const skillsDir = path54.join(claudeDir, "skills");
+  const skillsDir = path55.join(claudeDir, "skills");
   if (existsSync40(skillsDir)) {
     let skillCount = 0;
     try {
       const entries = readdirSync12(skillsDir);
       for (const entry of entries) {
         if (entry.startsWith("exe")) {
-          const fullPath = path54.join(skillsDir, entry);
+          const fullPath = path55.join(skillsDir, entry);
           if (!dryRun) rmSync2(fullPath, { recursive: true, force: true });
           skillCount++;
         }
@@ -36412,30 +36723,30 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const claudeMdPath = path54.join(claudeDir, "CLAUDE.md");
+  const claudeMdPath = path55.join(claudeDir, "CLAUDE.md");
   if (existsSync40(claudeMdPath)) {
-    const content = readFileSync35(claudeMdPath, "utf8");
+    const content = readFileSync36(claudeMdPath, "utf8");
     const startMarker = "<!-- exe-os:orchestration-start -->";
     const endMarker = "<!-- exe-os:orchestration-end -->";
     const startIdx = content.indexOf(startMarker);
     const endIdx = content.indexOf(endMarker);
     if (startIdx !== -1 && endIdx !== -1) {
       const cleaned = (content.slice(0, startIdx) + content.slice(endIdx + endMarker.length)).replace(/\n{3,}/g, "\n\n").trim() + "\n";
-      if (!dryRun) writeFileSync26(claudeMdPath, cleaned);
+      if (!dryRun) writeFileSync27(claudeMdPath, cleaned);
       log("\u2713 Removed orchestration block from CLAUDE.md");
       removed++;
     }
   }
-  const agentsDir = path54.join(claudeDir, "agents");
+  const agentsDir = path55.join(claudeDir, "agents");
   if (existsSync40(agentsDir)) {
     let agentCount = 0;
     try {
       const entries = readdirSync12(agentsDir).filter((f) => f.endsWith(".md"));
       let knownNames = /* @__PURE__ */ new Set();
-      const rosterPath = path54.join(exeOsDir, "exe-employees.json");
+      const rosterPath = path55.join(exeOsDir, "exe-employees.json");
       if (existsSync40(rosterPath)) {
         try {
-          const roster = JSON.parse(readFileSync35(rosterPath, "utf8"));
+          const roster = JSON.parse(readFileSync36(rosterPath, "utf8"));
           knownNames = new Set(roster.map((e) => e.name));
         } catch {
         }
@@ -36443,7 +36754,7 @@ async function runClaudeUninstall(flags = []) {
       for (const entry of entries) {
         const name = entry.replace(/\.md$/, "");
         if (knownNames.has(name)) {
-          if (!dryRun) rmSync2(path54.join(agentsDir, entry), { force: true });
+          if (!dryRun) rmSync2(path55.join(agentsDir, entry), { force: true });
           agentCount++;
         }
       }
@@ -36454,16 +36765,16 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const projectsDir = path54.join(claudeDir, "projects");
+  const projectsDir = path55.join(claudeDir, "projects");
   if (existsSync40(projectsDir)) {
     let projectCount = 0;
     try {
       const projects = readdirSync12(projectsDir);
       for (const proj of projects) {
-        const projSettings = path54.join(projectsDir, proj, "settings.json");
+        const projSettings = path55.join(projectsDir, proj, "settings.json");
         if (!existsSync40(projSettings)) continue;
         try {
-          const pSettings = JSON.parse(readFileSync35(projSettings, "utf8"));
+          const pSettings = JSON.parse(readFileSync36(projSettings, "utf8"));
           let changed = false;
           if (Array.isArray(pSettings.permissions?.allow)) {
             const before = pSettings.permissions.allow.length;
@@ -36473,7 +36784,7 @@ async function runClaudeUninstall(flags = []) {
             if (pSettings.permissions.allow.length < before) changed = true;
           }
           if (changed && !dryRun) {
-            writeFileSync26(projSettings, JSON.stringify(pSettings, null, 2) + "\n");
+            writeFileSync27(projSettings, JSON.stringify(pSettings, null, 2) + "\n");
           }
           if (changed) projectCount++;
         } catch {
@@ -36497,17 +36808,17 @@ async function runClaudeUninstall(flags = []) {
     };
     const exeBinPath = findExeBin3();
     if (!exeBinPath) throw new Error("exe-os not found in PATH");
-    const binDir = path54.dirname(exeBinPath);
+    const binDir = path55.dirname(exeBinPath);
     let symlinkCount = 0;
-    const rosterPath = path54.join(exeOsDir, "exe-employees.json");
+    const rosterPath = path55.join(exeOsDir, "exe-employees.json");
     if (existsSync40(rosterPath)) {
-      const roster = JSON.parse(readFileSync35(rosterPath, "utf8"));
+      const roster = JSON.parse(readFileSync36(rosterPath, "utf8"));
       const { DEFAULT_COORDINATOR_TEMPLATE_NAME: DEFAULT_COORDINATOR_TEMPLATE_NAME2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
       const coordinatorName = roster.find((e) => e.role?.toLowerCase() === "coo")?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME2;
       for (const emp of roster) {
         if (emp.name === coordinatorName) continue;
         for (const suffix of ["", "-opencode"]) {
-          const linkPath = path54.join(binDir, `${emp.name}${suffix}`);
+          const linkPath = path55.join(binDir, `${emp.name}${suffix}`);
           if (existsSync40(linkPath)) {
             if (!dryRun) rmSync2(linkPath, { force: true });
             symlinkCount++;
@@ -36546,7 +36857,7 @@ async function checkForUpdateOnBoot() {
     const config = await loadConfig2();
     if (!config.autoUpdate.checkOnBoot) return;
     const { checkForUpdate: checkForUpdate2 } = await Promise.resolve().then(() => (init_update(), update_exports));
-    const packageRoot = path54.resolve(
+    const packageRoot = path55.resolve(
       new URL("../..", import.meta.url).pathname
     );
     const result = checkForUpdate2(packageRoot);
@@ -36607,7 +36918,7 @@ async function runActivate(key) {
       const idTemplate = getIdentityTemplate(identityKey);
       if (idTemplate) {
         const idPath = identityPath2(name);
-        const dir = path54.dirname(idPath);
+        const dir = path55.dirname(idPath);
         if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
         fs8.writeFileSync(idPath, idTemplate.replace(/^agent_id: \w+/m, `agent_id: ${name}`), "utf-8");
       }