@askexenow/exe-os 0.9.2 → 0.9.4

package/dist/bin/cli.js

@@ -1322,20 +1322,39 @@ function setupGhostty(home) {
   const configPath = path5.join(configDir, "config");
   const backupPath = path5.join(configDir, "config.backup");
   mkdirSync3(configDir, { recursive: true });
+  const START_MARKER = "# \u2500\u2500 exe-os:ghostty-start \u2500\u2500";
+  const END_MARKER = "# \u2500\u2500 exe-os:ghostty-end \u2500\u2500";
+  const assetContent = readFileSync4(assetPath, "utf8").trim();
+  const markedSection = `${START_MARKER}
+${assetContent}
+${END_MARKER}`;
   if (existsSync5(configPath)) {
     const existing = readFileSync4(configPath, "utf8");
-    if (existing.includes("Exe OS")) {
-      copyFileSync(assetPath, configPath);
+    if (existing.includes(START_MARKER) && existing.includes(END_MARKER)) {
+      const before = existing.slice(0, existing.indexOf(START_MARKER));
+      const after = existing.slice(existing.indexOf(END_MARKER) + END_MARKER.length);
+      writeFileSync3(configPath, `${before}${markedSection}${after}`);
+    } else if (existing.includes("Exe OS")) {
+      if (!existsSync5(backupPath)) {
+        copyFileSync(configPath, backupPath);
+        process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
+`);
+      }
+      writeFileSync3(configPath, `${markedSection}
+`);
     } else {
       if (!existsSync5(backupPath)) {
         copyFileSync(configPath, backupPath);
         process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
 `);
       }
-      copyFileSync(assetPath, configPath);
+      writeFileSync3(configPath, `${markedSection}
+
+${existing}`);
     }
   } else {
-    copyFileSync(assetPath, configPath);
+    writeFileSync3(configPath, `${markedSection}
+`);
   }
   process.stderr.write("exe-os: Ghostty config installed\n");
 }
@@ -7050,9 +7069,9 @@ Unclassified: ${unclassified}
 }
 async function exportBatches(options) {
   const fs8 = await import("fs");
-  const path42 = await import("path");
+  const path44 = await import("path");
   const client = getClient();
-  const outDir = path42.join(process.cwd(), "exe/output/classifications/input");
+  const outDir = path44.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",
@@ -7076,7 +7095,7 @@ async function exportBatches(options) {
       const text = String(row.text || "").replace(/\n/g, " ");
       return JSON.stringify({ id: row.id, text });
     });
-    const batchFile = path42.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
+    const batchFile = path44.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
     fs8.writeFileSync(batchFile, lines.join("\n") + "\n");
     exported += batch.rows.length;
     offset += options.batchSize;
@@ -7092,7 +7111,7 @@ async function exportBatches(options) {
 }
 async function importClassifications(importDir) {
   const fs8 = await import("fs");
-  const path42 = await import("path");
+  const path44 = 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}
@@ -7100,7 +7119,7 @@ async function importClassifications(importDir) {
   let imported = 0;
   let invalid = 0;
   for (const file of files) {
-    const lines = fs8.readFileSync(path42.join(importDir, file), "utf-8").split("\n").filter(Boolean);
+    const lines = fs8.readFileSync(path44.join(importDir, file), "utf-8").split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const rec = JSON.parse(line);
@@ -7190,42 +7209,652 @@ async function backfillMetadata(options) {
     await disposeStore();
     return { classified: result.classified, skipped: result.skipped, failed: 0, entitiesPopulated: 0, remaining: result.remaining };
   }
-  if (options.entities) {
-    entitiesPopulated = await backfillEntities(options);
-  } else {
-    const result = await backfillClassifications(options);
-    classified = result.classified;
-    skipped = result.skipped;
-    failed = result.failed;
-    remaining = result.remaining;
+  if (options.entities) {
+    entitiesPopulated = await backfillEntities(options);
+  } else {
+    const result = await backfillClassifications(options);
+    classified = result.classified;
+    skipped = result.skipped;
+    failed = result.failed;
+    remaining = result.remaining;
+  }
+  await disposeStore();
+  return { classified, skipped, failed, entitiesPopulated, remaining };
+}
+var VALID_INTENTS, VALID_OUTCOMES, VALID_DOMAINS, VALID_AUDIENCES, VALID_LANGUAGE_TYPES, MAX_TEXT_LENGTH, BATCH_SLEEP_MS, MARKETING_AGENT_MARKERS, RESEARCH_AGENT_MARKERS;
+var init_backfill_metadata = __esm({
+  "src/bin/backfill-metadata.ts"() {
+    "use strict";
+    init_store();
+    init_database();
+    init_is_main();
+    init_employees();
+    VALID_INTENTS = /* @__PURE__ */ new Set(["decision", "question", "correction", "report", "discovery", "implementation"]);
+    VALID_OUTCOMES = /* @__PURE__ */ new Set(["success", "failure", "partial", "superseded"]);
+    VALID_DOMAINS = /* @__PURE__ */ new Set(["code", "architecture", "marketing", "operations", "customer", "research"]);
+    VALID_AUDIENCES = /* @__PURE__ */ new Set(["founder", "team", "self"]);
+    VALID_LANGUAGE_TYPES = /* @__PURE__ */ new Set(["code", "prose", "mixed", "json", "sql"]);
+    MAX_TEXT_LENGTH = 2e3;
+    BATCH_SLEEP_MS = 1e3;
+    MARKETING_AGENT_MARKERS = roleAgentMarkers("CMO", "mari");
+    RESEARCH_AGENT_MARKERS = roleAgentMarkers("AI Product Lead", "gen");
+    if (isMainModule(import.meta.url)) {
+      const options = parseArgs2(process.argv.slice(2));
+      backfillMetadata(options).then((result) => {
+        console.log(JSON.stringify(result, null, 2));
+        process.exit(result.failed > 0 ? 1 : 0);
+      }).catch((err) => {
+        console.error("[backfill-metadata] Fatal:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      });
+    }
+  }
+});
+
+// src/lib/identity.ts
+var identity_exports = {};
+__export(identity_exports, {
+  getIdentity: () => getIdentity,
+  getIdentityInjection: () => getIdentityInjection,
+  identityPath: () => identityPath,
+  listIdentities: () => listIdentities,
+  updateIdentity: () => updateIdentity
+});
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { readdirSync as readdirSync3 } from "fs";
+import path13 from "path";
+import { createHash as createHash2 } from "crypto";
+function ensureDir() {
+  if (!existsSync12(IDENTITY_DIR)) {
+    mkdirSync8(IDENTITY_DIR, { recursive: true });
+  }
+}
+function identityPath(agentId) {
+  return path13.join(IDENTITY_DIR, `${agentId}.md`);
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return {
+      frontmatter: {
+        role: "unknown",
+        title: "Unknown",
+        agent_id: "unknown",
+        org_level: "specialist",
+        created_by: "system",
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      body: raw
+    };
+  }
+  const yamlStr = match[1];
+  const body = match[2].trim();
+  const fm = {};
+  for (const line of yamlStr.split("\n")) {
+    const kv = line.match(/^(\w+):\s*(.+)$/);
+    if (kv) fm[kv[1]] = kv[2].trim();
+  }
+  return {
+    frontmatter: {
+      role: fm.role ?? "unknown",
+      title: fm.title ?? "Unknown",
+      agent_id: fm.agent_id ?? "unknown",
+      org_level: fm.org_level ?? "specialist",
+      created_by: fm.created_by ?? "system",
+      updated_at: fm.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
+    },
+    body
+  };
+}
+function contentHash(content) {
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
+}
+function getIdentity(agentId) {
+  const filePath = identityPath(agentId);
+  if (!existsSync12(filePath)) return null;
+  const raw = readFileSync9(filePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(raw);
+  return {
+    agentId,
+    frontmatter,
+    body,
+    raw,
+    contentHash: contentHash(raw)
+  };
+}
+async function updateIdentity(agentId, content, updatedBy) {
+  ensureDir();
+  const filePath = identityPath(agentId);
+  const hash = contentHash(content);
+  writeFileSync7(filePath, content, "utf-8");
+  try {
+    const client = getClient();
+    await client.execute({
+      sql: `INSERT INTO identity (agent_id, content_hash, updated_at, updated_by)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(agent_id) DO UPDATE SET
+              content_hash = excluded.content_hash,
+              updated_at = excluded.updated_at,
+              updated_by = excluded.updated_by`,
+      args: [agentId, hash, (/* @__PURE__ */ new Date()).toISOString(), updatedBy]
+    });
+  } catch {
+  }
+}
+function listIdentities() {
+  ensureDir();
+  const files = readdirSync3(IDENTITY_DIR).filter((f) => f.endsWith(".md"));
+  const results = [];
+  for (const file of files) {
+    const agentId = file.replace(".md", "");
+    const identity = getIdentity(agentId);
+    if (!identity) continue;
+    const lines = identity.body.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
+    const summary = lines[0]?.trim().slice(0, 120) ?? identity.frontmatter.title;
+    results.push({
+      agentId,
+      title: `${identity.frontmatter.title} (${identity.frontmatter.role.toUpperCase()})`,
+      summary
+    });
+  }
+  return results;
+}
+function getIdentityInjection(agentId) {
+  const own = getIdentity(agentId);
+  const all = listIdentities();
+  const parts = [];
+  if (own) {
+    parts.push(`## Your Identity (exe.md)
+These define WHO YOU ARE. Non-negotiable. Permanent.
+
+${own.body}`);
+  }
+  const teamLines = all.filter((a) => a.agentId !== agentId).map((a) => `- ${a.agentId} (${a.title}): ${a.summary}`);
+  if (teamLines.length > 0) {
+    parts.push(`## Team Identities
+${teamLines.join("\n")}`);
+  }
+  return parts.join("\n\n");
+}
+var IDENTITY_DIR;
+var init_identity = __esm({
+  "src/lib/identity.ts"() {
+    "use strict";
+    init_config();
+    init_database();
+    IDENTITY_DIR = path13.join(EXE_AI_DIR, "identity");
+  }
+});
+
+// src/lib/orchestration-package.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { copyFileSync as copyFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
+import os8 from "os";
+import path14 from "path";
+function ensureObject(value, label) {
+  if (value == null || Array.isArray(value) || typeof value !== "object") {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function ensureString(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string`);
+  }
+  return value;
+}
+function ensureOptionalString(value, label) {
+  if (value == null) return void 0;
+  return ensureString(value, label);
+}
+function ensureNullableString(value, label) {
+  if (value == null) return null;
+  return ensureString(value, label);
+}
+function ensurePriority(value, label, fallback) {
+  if (value == null) return fallback;
+  if (value === "p0" || value === "p1" || value === "p2") {
+    return value;
+  }
+  throw new Error(`${label} must be one of: p0, p1, p2`);
+}
+function validateRosterEntry(value, index) {
+  const record = ensureObject(value, `roster[${index}]`);
+  return {
+    name: ensureString(record.name, `roster[${index}].name`),
+    role: ensureString(record.role, `roster[${index}].role`),
+    systemPrompt: ensureString(record.systemPrompt, `roster[${index}].systemPrompt`),
+    createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
+    templateName: ensureOptionalString(record.templateName, `roster[${index}].templateName`),
+    templateVersion: typeof record.templateVersion === "number" ? record.templateVersion : void 0
+  };
+}
+function validateBehaviorEntry(value, index) {
+  const record = ensureObject(value, `behaviors[${index}]`);
+  return {
+    agent_id: ensureString(record.agent_id, `behaviors[${index}].agent_id`),
+    project_name: ensureNullableString(record.project_name, `behaviors[${index}].project_name`),
+    domain: ensureNullableString(record.domain, `behaviors[${index}].domain`),
+    content: ensureString(record.content, `behaviors[${index}].content`),
+    priority: ensurePriority(record.priority, `behaviors[${index}].priority`, DEFAULT_BEHAVIOR_PRIORITY)
+  };
+}
+function validateProcedureEntry(value, index) {
+  const record = ensureObject(value, `procedures[${index}]`);
+  return {
+    title: ensureString(record.title, `procedures[${index}].title`),
+    content: ensureString(record.content, `procedures[${index}].content`),
+    priority: ensurePriority(record.priority, `procedures[${index}].priority`, DEFAULT_PROCEDURE_PRIORITY),
+    domain: ensureNullableString(record.domain, `procedures[${index}].domain`)
+  };
+}
+function getRosterPath() {
+  return path14.join(os8.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+}
+function getBackupPath() {
+  return path14.join(os8.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+}
+function readRosterFile() {
+  const rosterPath = getRosterPath();
+  if (!existsSync13(rosterPath)) return [];
+  const raw = readFileSync10(rosterPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error("Roster file must contain a JSON array");
+  }
+  return parsed.map((entry, index) => validateRosterEntry(entry, index));
+}
+function writeRosterFile(roster) {
+  if (roster.length === 0) {
+    throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
+  }
+  const rosterPath = getRosterPath();
+  mkdirSync9(path14.dirname(rosterPath), { recursive: true });
+  if (existsSync13(rosterPath)) {
+    const currentRoster = readRosterFile();
+    if (roster.length < currentRoster.length) {
+      throw new Error(
+        `Refusing to write roster with ${roster.length} entries \u2014 current roster has ${currentRoster.length}. Import would delete ${currentRoster.length - roster.length} employee(s). Use merge strategy instead, or add the missing entries to the package.`
+      );
+    }
+    copyFileSync2(rosterPath, getBackupPath());
+  }
+  writeFileSync8(rosterPath, `${JSON.stringify(roster, null, 2)}
+`, "utf-8");
+}
+function buildImportedRosterEntries(roster, timestamp) {
+  return roster.map((entry) => ({
+    name: entry.name,
+    role: entry.role,
+    systemPrompt: entry.systemPrompt,
+    createdAt: timestamp,
+    ...entry.templateName != null ? { templateName: entry.templateName } : {},
+    ...entry.templateVersion != null ? { templateVersion: entry.templateVersion } : {}
+  }));
+}
+async function insertBehaviors(behaviors, timestamp) {
+  const client = getClient();
+  for (const behavior of behaviors) {
+    await client.execute({
+      sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID4(),
+        behavior.agent_id,
+        behavior.project_name,
+        behavior.domain,
+        behavior.priority,
+        behavior.content,
+        timestamp,
+        timestamp
+      ]
+    });
+  }
+  return behaviors.length;
+}
+async function insertProcedures(procedures, timestamp, options) {
+  const client = getClient();
+  const skipTitles = options?.skipTitles ?? /* @__PURE__ */ new Set();
+  let inserted = 0;
+  for (const procedure of procedures) {
+    if (skipTitles.has(procedure.title) || PLATFORM_PROCEDURE_TITLES.has(procedure.title)) {
+      continue;
+    }
+    await client.execute({
+      sql: `INSERT INTO global_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID4(),
+        procedure.title,
+        procedure.content,
+        procedure.priority,
+        procedure.domain,
+        timestamp,
+        timestamp
+      ]
+    });
+    skipTitles.add(procedure.title);
+    inserted += 1;
+  }
+  return inserted;
+}
+async function replaceBehaviorsAndProcedures(behaviors, procedures, timestamp) {
+  const client = getClient();
+  const existingBehaviors = await client.execute({
+    sql: "SELECT agent_id, content FROM behaviors WHERE active = 1",
+    args: []
+  });
+  const existingBehaviorKeys = new Set(
+    existingBehaviors.rows.map((row) => `${String(row.agent_id)}::${String(row.content)}`)
+  );
+  const newBehaviors = behaviors.filter(
+    (b) => !existingBehaviorKeys.has(`${b.agent_id}::${b.content}`)
+  );
+  const existingProcedureTitles = await getActiveProcedureTitles();
+  return {
+    behaviors: await insertBehaviors(newBehaviors, timestamp),
+    procedures: await insertProcedures(procedures, timestamp, { skipTitles: existingProcedureTitles })
+  };
+}
+async function mergeRosterEntries(importedRoster, timestamp) {
+  const currentRoster = readRosterFile();
+  const existingNames = new Set(currentRoster.map((entry) => entry.name.toLowerCase()));
+  const additions = buildImportedRosterEntries(
+    importedRoster.filter((entry) => !existingNames.has(entry.name.toLowerCase())),
+    timestamp
+  );
+  if (additions.length > 0) {
+    writeRosterFile([...currentRoster, ...additions]);
+  }
+  return additions.length;
+}
+async function replaceRosterEntries(importedRoster, timestamp) {
+  const currentRoster = readRosterFile();
+  const importedByName = new Map(
+    buildImportedRosterEntries(importedRoster, timestamp).map((entry) => [entry.name.toLowerCase(), entry])
+  );
+  const merged = currentRoster.map((existing) => {
+    const imported = importedByName.get(existing.name.toLowerCase());
+    if (imported) {
+      importedByName.delete(existing.name.toLowerCase());
+      return imported;
+    }
+    return existing;
+  });
+  for (const newEntry of importedByName.values()) {
+    merged.push(newEntry);
+  }
+  writeRosterFile(merged);
+  return importedRoster.length;
+}
+async function importIdentities(identities, updatedBy) {
+  const entries = Object.entries(identities);
+  let imported = 0;
+  for (const [agentId, content] of entries) {
+    const existing = getIdentity(agentId);
+    if (existing?.raw) {
+      continue;
+    }
+    await updateIdentity(agentId, content, updatedBy);
+    imported += 1;
+  }
+  return imported;
+}
+async function getActiveProcedureTitles() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT title FROM global_procedures WHERE active = 1",
+    args: []
+  });
+  return new Set(result.rows.map((row) => String(row.title)));
+}
+async function exportOrchestration(createdBy) {
+  const client = getClient();
+  const roster = readRosterFile().map((entry) => ({
+    ...entry,
+    createdAt: ""
+  }));
+  const identities = {};
+  for (const identitySummary of listIdentities()) {
+    const identity = getIdentity(identitySummary.agentId);
+    if (identity?.raw) {
+      identities[identitySummary.agentId] = identity.raw;
+    }
+  }
+  const behaviorResult = await client.execute({
+    sql: "SELECT agent_id, project_name, domain, content, priority FROM behaviors WHERE active = 1",
+    args: []
+  });
+  const procedureResult = await client.execute({
+    sql: "SELECT title, content, priority, domain FROM global_procedures WHERE active = 1",
+    args: []
+  });
+  const behaviors = behaviorResult.rows.map((row) => ({
+    agent_id: String(row.agent_id),
+    project_name: row.project_name == null ? null : String(row.project_name),
+    domain: row.domain == null ? null : String(row.domain),
+    content: String(row.content),
+    priority: ensurePriority(row.priority, "behaviors.priority", DEFAULT_BEHAVIOR_PRIORITY)
+  }));
+  const procedures = procedureResult.rows.map((row) => ({
+    title: String(row.title),
+    content: String(row.content),
+    priority: ensurePriority(row.priority, "procedures.priority", DEFAULT_PROCEDURE_PRIORITY),
+    domain: row.domain == null ? null : String(row.domain)
+  })).filter((procedure) => !PLATFORM_PROCEDURE_TITLES.has(procedure.title));
+  return {
+    version: PACKAGE_VERSION,
+    created_by: createdBy,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    roster,
+    identities,
+    behaviors,
+    procedures
+  };
+}
+async function importOrchestration(pkg, strategy) {
+  const validated = validatePackage(pkg);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedBy = validated.created_by || DEFAULT_IDENTITY_UPDATED_BY;
+  const rosterCount = strategy === "replace" ? await replaceRosterEntries(validated.roster, timestamp) : await mergeRosterEntries(validated.roster, timestamp);
+  const identityCount = await importIdentities(validated.identities, updatedBy);
+  if (strategy === "replace") {
+    const replaced = await replaceBehaviorsAndProcedures(
+      validated.behaviors,
+      validated.procedures,
+      timestamp
+    );
+    return {
+      imported: {
+        roster: rosterCount,
+        identities: identityCount,
+        behaviors: replaced.behaviors,
+        procedures: replaced.procedures
+      }
+    };
+  }
+  const existingProcedureTitles = await getActiveProcedureTitles();
+  const behaviorCount = await insertBehaviors(validated.behaviors, timestamp);
+  const procedureCount = await insertProcedures(
+    validated.procedures,
+    timestamp,
+    { skipTitles: existingProcedureTitles }
+  );
+  return {
+    imported: {
+      roster: rosterCount,
+      identities: identityCount,
+      behaviors: behaviorCount,
+      procedures: procedureCount
+    }
+  };
+}
+function validatePackage(data) {
+  const record = ensureObject(data, "package");
+  const version = ensureString(record.version, "version");
+  if (version !== PACKAGE_VERSION) {
+    throw new Error(`Unsupported orchestration package version: ${version}`);
+  }
+  if (!Array.isArray(record.roster)) {
+    throw new Error("roster is required and must be an array");
+  }
+  if (record.identities == null || Array.isArray(record.identities) || typeof record.identities !== "object") {
+    throw new Error("identities is required and must be an object");
+  }
+  if (!Array.isArray(record.behaviors)) {
+    throw new Error("behaviors is required and must be an array");
+  }
+  if (!Array.isArray(record.procedures)) {
+    throw new Error("procedures is required and must be an array");
+  }
+  const identities = Object.entries(record.identities).reduce(
+    (acc, [agentId, content]) => {
+      acc[agentId] = ensureString(content, `identities.${agentId}`);
+      return acc;
+    },
+    {}
+  );
+  return {
+    version: PACKAGE_VERSION,
+    created_by: ensureString(record.created_by, "created_by"),
+    created_at: ensureString(record.created_at, "created_at"),
+    roster: record.roster.map((entry, index) => validateRosterEntry(entry, index)),
+    identities,
+    behaviors: record.behaviors.map((entry, index) => validateBehaviorEntry(entry, index)),
+    procedures: record.procedures.map((entry, index) => validateProcedureEntry(entry, index))
+  };
+}
+var PACKAGE_VERSION, ROSTER_FILENAME, ROSTER_BACKUP_FILENAME, EXE_OS_DIRNAME, DEFAULT_BEHAVIOR_PRIORITY, DEFAULT_PROCEDURE_PRIORITY, DEFAULT_IDENTITY_UPDATED_BY;
+var init_orchestration_package = __esm({
+  "src/lib/orchestration-package.ts"() {
+    "use strict";
+    init_database();
+    init_identity();
+    init_platform_procedures();
+    PACKAGE_VERSION = "1.0";
+    ROSTER_FILENAME = "exe-employees.json";
+    ROSTER_BACKUP_FILENAME = "exe-employees.json.bak";
+    EXE_OS_DIRNAME = ".exe-os";
+    DEFAULT_BEHAVIOR_PRIORITY = "p1";
+    DEFAULT_PROCEDURE_PRIORITY = "p0";
+    DEFAULT_IDENTITY_UPDATED_BY = "orchestration-import";
+  }
+});
+
+// src/bin/exe-export.ts
+var exe_export_exports = {};
+__export(exe_export_exports, {
+  runExeExport: () => runExeExport
+});
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
+import path15 from "path";
+function printUsage() {
+  process.stdout.write("Usage: exe-os export --output <path>\n");
+}
+function parseOutputPath(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printUsage();
+    return null;
+  }
+  const flagIndex = argv.indexOf(OUTPUT_FLAG);
+  if (flagIndex === -1 || !argv[flagIndex + 1]) {
+    throw new Error("Missing required --output <path> argument");
+  }
+  return argv[flagIndex + 1];
+}
+async function runExeExport(argv = process.argv.slice(2)) {
+  const outputPath = parseOutputPath(argv);
+  if (outputPath == null) return;
+  await initStore();
+  try {
+    const pkg = await exportOrchestration("cli");
+    mkdirSync10(path15.dirname(outputPath), { recursive: true });
+    writeFileSync9(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}
+`
+    );
+  } finally {
+    try {
+      await disposeStore();
+    } catch {
+    }
+  }
+}
+var OUTPUT_FLAG;
+var init_exe_export = __esm({
+  "src/bin/exe-export.ts"() {
+    "use strict";
+    init_orchestration_package();
+    init_is_main();
+    init_store();
+    OUTPUT_FLAG = "--output";
+    if (isMainModule(import.meta.url) && (process.argv[1] ?? "").includes("exe-export")) {
+      runExeExport().catch((err) => {
+        process.stderr.write(`exe-os export failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        process.exit(1);
+      });
+    }
+  }
+});
+
+// src/bin/exe-import.ts
+var exe_import_exports = {};
+__export(exe_import_exports, {
+  runExeImport: () => runExeImport
+});
+import { readFileSync as readFileSync11 } from "fs";
+function printUsage2() {
+  process.stdout.write("Usage: exe-os import --from <path> [--merge]\n");
+}
+function parseArgs3(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printUsage2();
+    return null;
+  }
+  const flagIndex = argv.indexOf(FROM_FLAG);
+  if (flagIndex === -1 || !argv[flagIndex + 1]) {
+    throw new Error("Missing required --from <path> argument");
   }
-  await disposeStore();
-  return { classified, skipped, failed, entitiesPopulated, remaining };
+  return {
+    packagePath: argv[flagIndex + 1],
+    strategy: argv.includes(MERGE_FLAG) ? "merge" : "replace"
+  };
 }
-var VALID_INTENTS, VALID_OUTCOMES, VALID_DOMAINS, VALID_AUDIENCES, VALID_LANGUAGE_TYPES, MAX_TEXT_LENGTH, BATCH_SLEEP_MS, MARKETING_AGENT_MARKERS, RESEARCH_AGENT_MARKERS;
-var init_backfill_metadata = __esm({
-  "src/bin/backfill-metadata.ts"() {
+async function runExeImport(argv = process.argv.slice(2)) {
+  const parsed = parseArgs3(argv);
+  if (parsed == null) return;
+  await initStore();
+  try {
+    const raw = readFileSync11(parsed.packagePath, "utf-8");
+    const pkg = validatePackage(JSON.parse(raw));
+    const result = await importOrchestration(pkg, parsed.strategy);
+    process.stdout.write(
+      `Imported ${result.imported.roster} roster entries, ${result.imported.identities} identities, ${result.imported.behaviors} behaviors, ${result.imported.procedures} procedures using ${parsed.strategy} strategy
+`
+    );
+  } finally {
+    try {
+      await disposeStore();
+    } catch {
+    }
+  }
+}
+var FROM_FLAG, MERGE_FLAG;
+var init_exe_import = __esm({
+  "src/bin/exe-import.ts"() {
     "use strict";
-    init_store();
-    init_database();
+    init_orchestration_package();
     init_is_main();
-    init_employees();
-    VALID_INTENTS = /* @__PURE__ */ new Set(["decision", "question", "correction", "report", "discovery", "implementation"]);
-    VALID_OUTCOMES = /* @__PURE__ */ new Set(["success", "failure", "partial", "superseded"]);
-    VALID_DOMAINS = /* @__PURE__ */ new Set(["code", "architecture", "marketing", "operations", "customer", "research"]);
-    VALID_AUDIENCES = /* @__PURE__ */ new Set(["founder", "team", "self"]);
-    VALID_LANGUAGE_TYPES = /* @__PURE__ */ new Set(["code", "prose", "mixed", "json", "sql"]);
-    MAX_TEXT_LENGTH = 2e3;
-    BATCH_SLEEP_MS = 1e3;
-    MARKETING_AGENT_MARKERS = roleAgentMarkers("CMO", "mari");
-    RESEARCH_AGENT_MARKERS = roleAgentMarkers("AI Product Lead", "gen");
-    if (isMainModule(import.meta.url)) {
-      const options = parseArgs2(process.argv.slice(2));
-      backfillMetadata(options).then((result) => {
-        console.log(JSON.stringify(result, null, 2));
-        process.exit(result.failed > 0 ? 1 : 0);
-      }).catch((err) => {
-        console.error("[backfill-metadata] Fatal:", err instanceof Error ? err.message : String(err));
+    init_store();
+    FROM_FLAG = "--from";
+    MERGE_FLAG = "--merge";
+    if (isMainModule(import.meta.url) && (process.argv[1] ?? "").includes("exe-import")) {
+      runExeImport().catch((err) => {
+        process.stderr.write(`exe-os import failed: ${err instanceof Error ? err.message : String(err)}
+`);
         process.exit(1);
       });
     }
@@ -7239,14 +7868,14 @@ __export(session_registry_exports, {
   pruneStaleSessions: () => pruneStaleSessions,
   registerSession: () => registerSession
 });
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
 import { execSync as execSync3 } from "child_process";
-import path13 from "path";
-import os8 from "os";
+import path16 from "path";
+import os9 from "os";
 function registerSession(entry) {
-  const dir = path13.dirname(REGISTRY_PATH);
-  if (!existsSync12(dir)) {
-    mkdirSync8(dir, { recursive: true });
+  const dir = path16.dirname(REGISTRY_PATH);
+  if (!existsSync14(dir)) {
+    mkdirSync11(dir, { recursive: true });
   }
   const sessions = listSessions();
   const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
@@ -7255,11 +7884,11 @@ function registerSession(entry) {
   } else {
     sessions.push(entry);
   }
-  writeFileSync7(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+  writeFileSync10(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
 }
 function listSessions() {
   try {
-    const raw = readFileSync9(REGISTRY_PATH, "utf8");
+    const raw = readFileSync12(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -7280,7 +7909,7 @@ function pruneStaleSessions() {
   const alive = sessions.filter((s) => liveSet.has(s.windowName));
   const pruned = sessions.length - alive.length;
   if (pruned > 0) {
-    writeFileSync7(REGISTRY_PATH, JSON.stringify(alive, null, 2));
+    writeFileSync10(REGISTRY_PATH, JSON.stringify(alive, null, 2));
   }
   return pruned;
 }
@@ -7288,7 +7917,7 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path13.join(os8.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path16.join(os9.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
@@ -7553,12 +8182,12 @@ var init_runtime_table = __esm({
 });
 
 // src/lib/agent-config.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, existsSync as existsSync13, mkdirSync as mkdirSync9 } from "fs";
-import path14 from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync11, existsSync as existsSync15, mkdirSync as mkdirSync12 } from "fs";
+import path17 from "path";
 function loadAgentConfig() {
-  if (!existsSync13(AGENT_CONFIG_PATH)) return {};
+  if (!existsSync15(AGENT_CONFIG_PATH)) return {};
   try {
-    return JSON.parse(readFileSync10(AGENT_CONFIG_PATH, "utf-8"));
+    return JSON.parse(readFileSync13(AGENT_CONFIG_PATH, "utf-8"));
   } catch {
     return {};
   }
@@ -7577,7 +8206,7 @@ var init_agent_config = __esm({
     "use strict";
     init_config();
     init_runtime_table();
-    AGENT_CONFIG_PATH = path14.join(EXE_AI_DIR, "agent-config.json");
+    AGENT_CONFIG_PATH = path17.join(EXE_AI_DIR, "agent-config.json");
     DEFAULT_MODELS = {
       claude: "claude-opus-4",
       codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
@@ -7595,25 +8224,25 @@ __export(intercom_queue_exports, {
   queueIntercom: () => queueIntercom,
   readQueue: () => readQueue
 });
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, renameSync as renameSync3, existsSync as existsSync14, mkdirSync as mkdirSync10 } from "fs";
-import path15 from "path";
-import os9 from "os";
-function ensureDir() {
-  const dir = path15.dirname(QUEUE_PATH);
-  if (!existsSync14(dir)) mkdirSync10(dir, { recursive: true });
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync12, renameSync as renameSync3, existsSync as existsSync16, mkdirSync as mkdirSync13 } from "fs";
+import path18 from "path";
+import os10 from "os";
+function ensureDir2() {
+  const dir = path18.dirname(QUEUE_PATH);
+  if (!existsSync16(dir)) mkdirSync13(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync14(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync11(QUEUE_PATH, "utf8"));
+    if (!existsSync16(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync14(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
 }
 function writeQueue(queue) {
-  ensureDir();
+  ensureDir2();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync9(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync12(tmp, JSON.stringify(queue, null, 2));
   renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -7705,20 +8334,20 @@ var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path15.join(os9.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path18.join(os10.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path15.join(os9.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path18.join(os10.homedir(), ".exe-os", "intercom.log");
   }
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync12, existsSync as existsSync15 } from "fs";
-import path16 from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync17 } from "fs";
+import path19 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync15(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync12(CACHE_PATH2, "utf8"));
+    if (!existsSync17(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync15(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -7756,8 +8385,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync15(filePath)) {
-      const raw = readFileSync12(filePath, "utf8");
+    if (existsSync17(filePath)) {
+      const raw = readFileSync15(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -7786,19 +8415,19 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path16.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path19.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/notifications.ts
 import crypto5 from "crypto";
-import path17 from "path";
-import os10 from "os";
+import path20 from "path";
+import os11 from "os";
 import {
-  readFileSync as readFileSync13,
-  readdirSync as readdirSync3,
+  readFileSync as readFileSync16,
+  readdirSync as readdirSync4,
   unlinkSync as unlinkSync5,
-  existsSync as existsSync16,
+  existsSync as existsSync18,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -7923,11 +8552,11 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto7 from "crypto";
-import path18 from "path";
-import os11 from "os";
+import path21 from "path";
+import os12 from "os";
 import { execSync as execSync6 } from "child_process";
 import { mkdir as mkdir5, writeFile as writeFile5, appendFile } from "fs/promises";
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync17 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -8102,8 +8731,8 @@ ${laneWarning}` : laneWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir5(path18.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir5(path18.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir5(path21.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir5(path21.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -8139,10 +8768,10 @@ ${laneWarning}` : laneWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path18.join(os11.homedir(), ".exe-os");
-      const mdPath = path18.join(EXE_OS_DIR, taskFile);
-      const mdDir = path18.dirname(mdPath);
-      if (!existsSync17(mdDir)) await mkdir5(mdDir, { recursive: true });
+      const EXE_OS_DIR = path21.join(os12.homedir(), ".exe-os");
+      const mdPath = path21.join(EXE_OS_DIR, taskFile);
+      const mdDir = path21.dirname(mdPath);
+      if (!existsSync19(mdDir)) await mkdir5(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
 
@@ -8442,9 +9071,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path18.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path21.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync17(archPath)) return;
+    if (existsSync19(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -8477,10 +9106,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path18.join(baseDir, ".gitignore");
+  const gitignorePath = path21.join(baseDir, ".gitignore");
   try {
-    if (existsSync17(gitignorePath)) {
-      const content = readFileSync14(gitignorePath, "utf-8");
+    if (existsSync19(gitignorePath)) {
+      const content = readFileSync17(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -8511,8 +9140,8 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/tasks-review.ts
-import path19 from "path";
-import { existsSync as existsSync18, readdirSync as readdirSync4, unlinkSync as unlinkSync6 } from "fs";
+import path22 from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync5, unlinkSync as unlinkSync6 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
@@ -8693,11 +9322,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path19.join(EXE_AI_DIR, "session-cache");
-    if (existsSync18(cacheDir)) {
-      for (const f of readdirSync4(cacheDir)) {
+    const cacheDir = path22.join(EXE_AI_DIR, "session-cache");
+    if (existsSync20(cacheDir)) {
+      for (const f of readdirSync5(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync6(path19.join(cacheDir, f));
+          unlinkSync6(path22.join(cacheDir, f));
         }
       }
     }
@@ -8718,7 +9347,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path20 from "path";
+import path23 from "path";
 import { readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -8735,7 +9364,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path20.join(baseDir, String(ur.task_file));
+        const ubFile = path23.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");
@@ -8804,7 +9433,7 @@ var init_tasks_chain = __esm({
 
 // src/lib/project-name.ts
 import { execSync as execSync7 } from "child_process";
-import path21 from "path";
+import path24 from "path";
 function getProjectName(cwd2) {
   const dir = cwd2 ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -8817,7 +9446,7 @@ function getProjectName(cwd2) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path21.dirname(gitCommonDir);
+      repoRoot = path24.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync7("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -8826,11 +9455,11 @@ function getProjectName(cwd2) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path21.basename(repoRoot);
+    _cached2 = path24.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path21.basename(dir);
+    _cached2 = path24.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -9303,8 +9932,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path22 from "path";
-import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, unlinkSync as unlinkSync7 } from "fs";
+import path25 from "path";
+import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync14, unlinkSync as unlinkSync7 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -9323,11 +9952,11 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path22.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path22.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path25.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path25.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
-      mkdirSync11(cacheDir, { recursive: true });
-      writeFileSync10(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync14(cacheDir, { recursive: true });
+      writeFileSync13(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
       try {
         unlinkSync7(cachePath);
@@ -9794,13 +10423,13 @@ __export(tmux_routing_exports, {
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
 import { execFileSync as execFileSync2, execSync as execSync8 } from "child_process";
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12, existsSync as existsSync19, appendFileSync as appendFileSync2 } from "fs";
-import path23 from "path";
-import os12 from "os";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15, existsSync as existsSync21, appendFileSync as appendFileSync2 } from "fs";
+import path26 from "path";
+import os13 from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { unlinkSync as unlinkSync8 } from "fs";
 function spawnLockPath(sessionName) {
-  return path23.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path26.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -9811,13 +10440,13 @@ function isProcessAlive(pid) {
   }
 }
 function acquireSpawnLock2(sessionName) {
-  if (!existsSync19(SPAWN_LOCK_DIR)) {
-    mkdirSync12(SPAWN_LOCK_DIR, { recursive: true });
+  if (!existsSync21(SPAWN_LOCK_DIR)) {
+    mkdirSync15(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync19(lockFile)) {
+  if (existsSync21(lockFile)) {
     try {
-      const lock = JSON.parse(readFileSync15(lockFile, "utf8"));
+      const lock = JSON.parse(readFileSync18(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
       if (isProcessAlive(lock.pid) && age < 6e4) {
         return false;
@@ -9825,7 +10454,7 @@ function acquireSpawnLock2(sessionName) {
     } catch {
     }
   }
-  writeFileSync11(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync14(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
 function releaseSpawnLock2(sessionName) {
@@ -9837,13 +10466,13 @@ function releaseSpawnLock2(sessionName) {
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const scriptPath = path23.join(
-      path23.dirname(thisFile),
+    const scriptPath = path26.join(
+      path26.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync19(scriptPath) ? scriptPath : null;
+    return existsSync21(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -9909,12 +10538,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync19(SESSION_CACHE)) {
-    mkdirSync12(SESSION_CACHE, { recursive: true });
+  if (!existsSync21(SESSION_CACHE)) {
+    mkdirSync15(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path23.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync11(filePath, JSON.stringify({
+  const filePath = path26.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync14(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -9922,7 +10551,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync15(path23.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync18(path26.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -9930,8 +10559,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync15(
-      path23.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync18(
+      path26.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -9992,8 +10621,8 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync19(DEBOUNCE_FILE)) return {};
-    const raw = JSON.parse(readFileSync15(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync21(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync18(DEBOUNCE_FILE, "utf8"));
     const state = {};
     for (const [key, val] of Object.entries(raw)) {
       if (typeof val === "number") {
@@ -10009,8 +10638,8 @@ function readDebounceState() {
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync19(SESSION_CACHE)) mkdirSync12(SESSION_CACHE, { recursive: true });
-    writeFileSync11(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync21(SESSION_CACHE)) mkdirSync15(SESSION_CACHE, { recursive: true });
+    writeFileSync14(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
@@ -10108,8 +10737,8 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const markerPath = path23.join(SESSION_CACHE, `current-task-${agent}.json`);
-      if (existsSync19(markerPath)) {
+      const markerPath = path26.join(SESSION_CACHE, `current-task-${agent}.json`);
+      if (existsSync21(markerPath)) {
         logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker \u2014 will auto-chain)`);
         return "debounced";
       }
@@ -10234,26 +10863,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 = path23.join(os12.homedir(), ".exe-os", "session-logs");
-  const logFile = path23.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync19(logDir)) {
-    mkdirSync12(logDir, { recursive: true });
+  const logDir = path26.join(os13.homedir(), ".exe-os", "session-logs");
+  const logFile = path26.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync21(logDir)) {
+    mkdirSync15(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const cleanupScript = path23.join(path23.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync19(cleanupScript)) {
+    const cleanupScript = path26.join(path26.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync21(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path23.join(os12.homedir(), ".claude.json");
+    const claudeJsonPath = path26.join(os13.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync15(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync18(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -10261,17 +10890,17 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync11(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync14(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path23.join(os12.homedir(), ".claude", "projects");
+    const settingsDir = path26.join(os13.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path23.join(settingsDir, normalizedKey);
-    const settingsPath = path23.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path26.join(settingsDir, normalizedKey);
+    const settingsPath = path26.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync15(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync18(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -10299,8 +10928,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync12(projSettingsDir, { recursive: true });
-      writeFileSync11(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync15(projSettingsDir, { recursive: true });
+      writeFileSync14(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
   }
@@ -10315,8 +10944,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath2 = path23.join(
-      os12.homedir(),
+    const identityPath2 = path26.join(
+      os13.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -10325,13 +10954,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync19(identityPath2)) {
+    } else if (existsSync21(identityPath2)) {
       identityFlag = ` --append-system-prompt-file ${identityPath2}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path23.basename(spawnCwd),
+      path26.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -10346,16 +10975,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path23.join(os12.homedir(), ".exe-os", "session-cache");
-    mkdirSync12(ctxDir, { recursive: true });
-    const ctxFile = path23.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path26.join(os13.homedir(), ".exe-os", "session-cache");
+    mkdirSync15(ctxDir, { recursive: true });
+    const ctxFile = path26.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");
-    writeFileSync11(ctxFile, ctxContent);
+    writeFileSync14(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -10432,8 +11061,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path23.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync11(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path26.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync14(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
       provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
@@ -10507,15 +11136,15 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path23.join(os12.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path23.join(os12.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path26.join(os13.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path26.join(os13.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 = path23.join(os12.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path23.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path26.join(os13.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path26.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
   }
@@ -10782,9 +11411,9 @@ __export(active_agent_exports, {
   resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, mkdirSync as mkdirSync13, unlinkSync as unlinkSync9, readdirSync as readdirSync5 } from "fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16, unlinkSync as unlinkSync9, readdirSync as readdirSync6 } from "fs";
 import { execSync as execSync9 } from "child_process";
-import path24 from "path";
+import path27 from "path";
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
   if (!candidate.startsWith(baseName)) return false;
@@ -10828,12 +11457,12 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path24.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path27.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
-    mkdirSync13(CACHE_DIR, { recursive: true });
-    writeFileSync12(
+    mkdirSync16(CACHE_DIR, { recursive: true });
+    writeFileSync15(
       getMarkerPath(),
       JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
@@ -10849,7 +11478,7 @@ function clearActiveAgent() {
 function getActiveAgent() {
   try {
     const markerPath = getMarkerPath();
-    const raw = readFileSync16(markerPath, "utf8");
+    const raw = readFileSync19(markerPath, "utf8");
     const data = JSON.parse(raw);
     if (data.agentId) {
       if (data.startedAt) {
@@ -10890,21 +11519,21 @@ function getActiveAgent() {
 }
 function getAllActiveAgents() {
   try {
-    const files = readdirSync5(CACHE_DIR);
+    const files = readdirSync6(CACHE_DIR);
     const sessions = [];
     for (const file of files) {
       if (!file.startsWith("active-agent-") || !file.endsWith(".json")) continue;
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync16(path24.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync19(path27.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 {
-              unlinkSync9(path24.join(CACHE_DIR, file));
+              unlinkSync9(path27.join(CACHE_DIR, file));
             } catch {
             }
             continue;
@@ -10927,11 +11556,11 @@ function getAllActiveAgents() {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync9(path24.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync9(path27.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync9(path24.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync9(path27.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -10942,7 +11571,7 @@ var init_active_agent = __esm({
     init_config();
     init_session_key();
     init_employees();
-    CACHE_DIR = path24.join(EXE_AI_DIR, "session-cache");
+    CACHE_DIR = path27.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
 });
@@ -11078,10 +11707,10 @@ You report to the COO. All work flows through the COO. These procedures are non-
    Use store_memory to write a structured summary. Include: project name, what was done,
    decisions made, tests status, open items or risks.
 
-6. AFTER committing changes to exe-os itself \u2014 REBUILD (mandatory, never skip):
-   - Run: npm run deploy
-   - This builds, installs globally, and re-registers hooks/MCP in one step.
-   - Do NOT ask permission. Do NOT say "want me to rebuild?" \u2014 just do it.
+6. AFTER committing changes to exe-os itself \u2014 REBUILD:
+   - If you are the COO or CTO on the MAIN branch (not a worktree): run \`npm run deploy\`.
+   - If you are in a git worktree: run \`npm run build\` ONLY. NEVER run deploy from a worktree \u2014 it re-registers hooks pointing at the worktree path, and deleting the worktree breaks every hook system-wide.
+   - Engineers and specialists: ALWAYS use \`npm run build\` only. Deploy is restricted to COO and CTO on main.
    - If the build fails, fix the error and retry before moving on.
 
 7. AFTER reporting \u2014 CHECK FOR NEXT WORK (mandatory):
@@ -11570,14 +12199,14 @@ __export(exe_rename_exports, {
   main: () => main2,
   renameEmployee: () => renameEmployee
 });
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync13, renameSync as renameSync4, unlinkSync as unlinkSync10, existsSync as existsSync20 } from "fs";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync16, renameSync as renameSync4, unlinkSync as unlinkSync10, existsSync as existsSync22 } from "fs";
 import { execSync as execSync10 } from "child_process";
-import path25 from "path";
+import path28 from "path";
 import { homedir as homedir4 } from "os";
 async function renameEmployee(oldName, newName, opts = {}) {
-  const rosterPath = opts.rosterPath ?? path25.join(homedir4(), ".exe-os", "exe-employees.json");
-  const identityDir = opts.identityDir ?? path25.join(homedir4(), ".exe-os", "identity");
-  const agentsDir = opts.agentsDir ?? path25.join(homedir4(), ".claude", "agents");
+  const rosterPath = opts.rosterPath ?? path28.join(homedir4(), ".exe-os", "exe-employees.json");
+  const identityDir = opts.identityDir ?? path28.join(homedir4(), ".exe-os", "identity");
+  const agentsDir = opts.agentsDir ?? path28.join(homedir4(), ".claude", "agents");
   const validation = validateEmployeeName(newName);
   if (!validation.valid) {
     return { success: false, error: validation.error };
@@ -11606,40 +12235,40 @@ async function renameEmployee(oldName, newName, opts = {}) {
       undo: () => {
         employee.name = originalName;
         employee.systemPrompt = originalPrompt;
-        writeFileSync13(rosterPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
+        writeFileSync16(rosterPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
       }
     });
-    const oldIdentityPath = path25.join(identityDir, `${rosterOldName}.md`);
-    const newIdentityPath = path25.join(identityDir, `${newName}.md`);
-    if (existsSync20(oldIdentityPath)) {
-      const content = readFileSync17(oldIdentityPath, "utf-8");
+    const oldIdentityPath = path28.join(identityDir, `${rosterOldName}.md`);
+    const newIdentityPath = path28.join(identityDir, `${newName}.md`);
+    if (existsSync22(oldIdentityPath)) {
+      const content = readFileSync20(oldIdentityPath, "utf-8");
       const updatedContent = content.replace(
         /^(agent_id:\s*)\S+/m,
         `$1${newName}`
       );
       renameSync4(oldIdentityPath, newIdentityPath);
-      writeFileSync13(newIdentityPath, updatedContent, "utf-8");
+      writeFileSync16(newIdentityPath, updatedContent, "utf-8");
       rollbackStack.push({
         description: "restore identity file",
         undo: () => {
-          if (existsSync20(newIdentityPath)) {
-            writeFileSync13(newIdentityPath, content, "utf-8");
+          if (existsSync22(newIdentityPath)) {
+            writeFileSync16(newIdentityPath, content, "utf-8");
             renameSync4(newIdentityPath, oldIdentityPath);
           }
         }
       });
     }
-    const oldAgentPath = path25.join(agentsDir, `${rosterOldName}.md`);
-    const newAgentPath = path25.join(agentsDir, `${newName}.md`);
-    if (existsSync20(oldAgentPath)) {
-      const agentContent = readFileSync17(oldAgentPath, "utf-8");
+    const oldAgentPath = path28.join(agentsDir, `${rosterOldName}.md`);
+    const newAgentPath = path28.join(agentsDir, `${newName}.md`);
+    if (existsSync22(oldAgentPath)) {
+      const agentContent = readFileSync20(oldAgentPath, "utf-8");
       renameSync4(oldAgentPath, newAgentPath);
       rollbackStack.push({
         description: "restore agent file",
         undo: () => {
-          if (existsSync20(newAgentPath)) {
+          if (existsSync22(newAgentPath)) {
             renameSync4(newAgentPath, oldAgentPath);
-            writeFileSync13(oldAgentPath, agentContent, "utf-8");
+            writeFileSync16(oldAgentPath, agentContent, "utf-8");
           }
         }
       });
@@ -11717,10 +12346,10 @@ function removeOldSymlinks(name) {
   try {
     const exeBinPath = findExeBin2();
     if (!exeBinPath) return;
-    const binDir = path25.dirname(exeBinPath);
+    const binDir = path28.dirname(exeBinPath);
     for (const suffix of ["", "-opencode"]) {
-      const linkPath = path25.join(binDir, `${name}${suffix}`);
-      if (existsSync20(linkPath)) {
+      const linkPath = path28.join(binDir, `${name}${suffix}`);
+      if (existsSync22(linkPath)) {
         try {
           unlinkSync10(linkPath);
         } catch {
@@ -11765,16 +12394,16 @@ var init_exe_rename = __esm({
 });
 
 // src/lib/model-downloader.ts
-import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync21, unlinkSync as unlinkSync11, renameSync as renameSync5 } from "fs";
+import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync23, unlinkSync as unlinkSync11, renameSync as renameSync5 } from "fs";
 import { mkdir as mkdir6 } from "fs/promises";
-import { createHash as createHash2 } from "crypto";
-import path26 from "path";
+import { createHash as createHash3 } from "crypto";
+import path29 from "path";
 async function downloadModel(opts) {
   const { destDir, onProgress, fetchFn = globalThis.fetch } = opts;
-  const destPath = path26.join(destDir, LOCAL_FILENAME);
+  const destPath = path29.join(destDir, LOCAL_FILENAME);
   const tmpPath = destPath + ".tmp";
   await mkdir6(destDir, { recursive: true });
-  if (existsSync21(destPath)) {
+  if (existsSync23(destPath)) {
     const hash = await fileHash(destPath);
     if (hash === EXPECTED_SHA256) {
       return destPath;
@@ -11786,7 +12415,7 @@ async function downloadModel(opts) {
   let downloaded = 0;
   for (let attempt = 1; attempt <= MAX_RETRIES4; attempt++) {
     try {
-      if (existsSync21(tmpPath)) unlinkSync11(tmpPath);
+      if (existsSync23(tmpPath)) unlinkSync11(tmpPath);
       const response = await fetchFn(GGUF_URL, {
         redirect: "follow",
         signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
@@ -11795,7 +12424,7 @@ async function downloadModel(opts) {
         throw new Error(`Download failed: HTTP ${response.status}`);
       }
       const contentLength = Number(response.headers.get("content-length") ?? EXPECTED_SIZE);
-      const hash = createHash2("sha256");
+      const hash = createHash3("sha256");
       const fileStream = createWriteStream(tmpPath);
       const reader = response.body.getReader();
       try {
@@ -11831,7 +12460,7 @@ async function downloadModel(opts) {
         process.stderr.write(`
 Download attempt ${attempt} failed, retrying...
 `);
-        if (existsSync21(tmpPath)) unlinkSync11(tmpPath);
+        if (existsSync23(tmpPath)) unlinkSync11(tmpPath);
       }
     }
   }
@@ -11839,7 +12468,7 @@ Download attempt ${attempt} failed, retrying...
 }
 async function fileHash(filePath) {
   return new Promise((resolve, reject) => {
-    const hash = createHash2("sha256");
+    const hash = createHash3("sha256");
     const stream = createReadStream2(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("end", () => resolve(hash.digest("hex")));
@@ -11894,10 +12523,10 @@ async function disposeEmbedder() {
 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: existsSync29 } = await import("fs");
-  const path42 = await import("path");
-  const modelPath = path42.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync29(modelPath)) {
+  const { existsSync: existsSync30 } = await import("fs");
+  const path44 = await import("path");
+  const modelPath = path44.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync30(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -11925,141 +12554,6 @@ var init_embedder = __esm({
   }
 });
 
-// src/lib/identity.ts
-var identity_exports = {};
-__export(identity_exports, {
-  getIdentity: () => getIdentity,
-  getIdentityInjection: () => getIdentityInjection,
-  identityPath: () => identityPath,
-  listIdentities: () => listIdentities,
-  updateIdentity: () => updateIdentity
-});
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "fs";
-import { readdirSync as readdirSync6 } from "fs";
-import path27 from "path";
-import { createHash as createHash3 } from "crypto";
-function ensureDir2() {
-  if (!existsSync22(IDENTITY_DIR)) {
-    mkdirSync14(IDENTITY_DIR, { recursive: true });
-  }
-}
-function identityPath(agentId) {
-  return path27.join(IDENTITY_DIR, `${agentId}.md`);
-}
-function parseFrontmatter(raw) {
-  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!match) {
-    return {
-      frontmatter: {
-        role: "unknown",
-        title: "Unknown",
-        agent_id: "unknown",
-        org_level: "specialist",
-        created_by: "system",
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      },
-      body: raw
-    };
-  }
-  const yamlStr = match[1];
-  const body = match[2].trim();
-  const fm = {};
-  for (const line of yamlStr.split("\n")) {
-    const kv = line.match(/^(\w+):\s*(.+)$/);
-    if (kv) fm[kv[1]] = kv[2].trim();
-  }
-  return {
-    frontmatter: {
-      role: fm.role ?? "unknown",
-      title: fm.title ?? "Unknown",
-      agent_id: fm.agent_id ?? "unknown",
-      org_level: fm.org_level ?? "specialist",
-      created_by: fm.created_by ?? "system",
-      updated_at: fm.updated_at ?? (/* @__PURE__ */ new Date()).toISOString()
-    },
-    body
-  };
-}
-function contentHash(content) {
-  return createHash3("sha256").update(content).digest("hex").slice(0, 16);
-}
-function getIdentity(agentId) {
-  const filePath = identityPath(agentId);
-  if (!existsSync22(filePath)) return null;
-  const raw = readFileSync18(filePath, "utf-8");
-  const { frontmatter, body } = parseFrontmatter(raw);
-  return {
-    agentId,
-    frontmatter,
-    body,
-    raw,
-    contentHash: contentHash(raw)
-  };
-}
-async function updateIdentity(agentId, content, updatedBy) {
-  ensureDir2();
-  const filePath = identityPath(agentId);
-  const hash = contentHash(content);
-  writeFileSync14(filePath, content, "utf-8");
-  try {
-    const client = getClient();
-    await client.execute({
-      sql: `INSERT INTO identity (agent_id, content_hash, updated_at, updated_by)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(agent_id) DO UPDATE SET
-              content_hash = excluded.content_hash,
-              updated_at = excluded.updated_at,
-              updated_by = excluded.updated_by`,
-      args: [agentId, hash, (/* @__PURE__ */ new Date()).toISOString(), updatedBy]
-    });
-  } catch {
-  }
-}
-function listIdentities() {
-  ensureDir2();
-  const files = readdirSync6(IDENTITY_DIR).filter((f) => f.endsWith(".md"));
-  const results = [];
-  for (const file of files) {
-    const agentId = file.replace(".md", "");
-    const identity = getIdentity(agentId);
-    if (!identity) continue;
-    const lines = identity.body.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
-    const summary = lines[0]?.trim().slice(0, 120) ?? identity.frontmatter.title;
-    results.push({
-      agentId,
-      title: `${identity.frontmatter.title} (${identity.frontmatter.role.toUpperCase()})`,
-      summary
-    });
-  }
-  return results;
-}
-function getIdentityInjection(agentId) {
-  const own = getIdentity(agentId);
-  const all = listIdentities();
-  const parts = [];
-  if (own) {
-    parts.push(`## Your Identity (exe.md)
-These define WHO YOU ARE. Non-negotiable. Permanent.
-
-${own.body}`);
-  }
-  const teamLines = all.filter((a) => a.agentId !== agentId).map((a) => `- ${a.agentId} (${a.title}): ${a.summary}`);
-  if (teamLines.length > 0) {
-    parts.push(`## Team Identities
-${teamLines.join("\n")}`);
-  }
-  return parts.join("\n\n");
-}
-var IDENTITY_DIR;
-var init_identity = __esm({
-  "src/lib/identity.ts"() {
-    "use strict";
-    init_config();
-    init_database();
-    IDENTITY_DIR = path27.join(EXE_AI_DIR, "identity");
-  }
-});
-
 // src/lib/identity-templates.ts
 var identity_templates_exports = {};
 __export(identity_templates_exports, {
@@ -12607,36 +13101,36 @@ __export(session_wrappers_exports, {
   generateSessionWrappers: () => generateSessionWrappers
 });
 import {
-  existsSync as existsSync23,
-  readFileSync as readFileSync19,
-  writeFileSync as writeFileSync15,
-  mkdirSync as mkdirSync15,
+  existsSync as existsSync24,
+  readFileSync as readFileSync21,
+  writeFileSync as writeFileSync17,
+  mkdirSync as mkdirSync17,
   chmodSync,
   readdirSync as readdirSync7,
   unlinkSync as unlinkSync12
 } from "fs";
-import path28 from "path";
+import path30 from "path";
 import { homedir as homedir5 } from "os";
 function generateSessionWrappers(packageRoot, homeDir) {
   const home = homeDir ?? homedir5();
-  const binDir = path28.join(home, ".exe-os", "bin");
-  const rosterPath = path28.join(home, ".exe-os", "exe-employees.json");
-  mkdirSync15(binDir, { recursive: true });
-  const exeStartDst = path28.join(binDir, "exe-start");
+  const binDir = path30.join(home, ".exe-os", "bin");
+  const rosterPath = path30.join(home, ".exe-os", "exe-employees.json");
+  mkdirSync17(binDir, { recursive: true });
+  const exeStartDst = path30.join(binDir, "exe-start");
   const candidates = [
-    path28.join(packageRoot, "dist", "bin", "exe-start.sh"),
-    path28.join(packageRoot, "src", "bin", "exe-start.sh")
+    path30.join(packageRoot, "dist", "bin", "exe-start.sh"),
+    path30.join(packageRoot, "src", "bin", "exe-start.sh")
   ];
   for (const src of candidates) {
-    if (existsSync23(src)) {
-      writeFileSync15(exeStartDst, readFileSync19(src));
+    if (existsSync24(src)) {
+      writeFileSync17(exeStartDst, readFileSync21(src));
       chmodSync(exeStartDst, 493);
       break;
     }
   }
   let employees = [];
   try {
-    employees = JSON.parse(readFileSync19(rosterPath, "utf8"));
+    employees = JSON.parse(readFileSync21(rosterPath, "utf8"));
   } catch {
     return { created: 0, pathConfigured: false };
   }
@@ -12646,9 +13140,9 @@ function generateSessionWrappers(packageRoot, homeDir) {
   try {
     for (const f of readdirSync7(binDir)) {
       if (f === "exe-start") continue;
-      const fPath = path28.join(binDir, f);
+      const fPath = path30.join(binDir, f);
       try {
-        const content = readFileSync19(fPath, "utf8");
+        const content = readFileSync21(fPath, "utf8");
         if (content.includes("exe-start")) {
           unlinkSync12(fPath);
         }
@@ -12663,30 +13157,30 @@ exec "${exeStartDst}" "$0" "$@"
 `;
   for (const emp of employees) {
     for (let n = 1; n <= MAX_N; n++) {
-      const wrapperPath = path28.join(binDir, `${emp.name}${n}`);
-      writeFileSync15(wrapperPath, wrapperContent);
+      const wrapperPath = path30.join(binDir, `${emp.name}${n}`);
+      writeFileSync17(wrapperPath, wrapperContent);
       chmodSync(wrapperPath, 493);
       created++;
     }
   }
   const codexLauncherCandidates = [
-    path28.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
-    path28.join(packageRoot, "src", "bin", "exe-start-codex.ts")
+    path30.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
+    path30.join(packageRoot, "src", "bin", "exe-start-codex.ts")
   ];
   let codexLauncher = null;
   for (const c of codexLauncherCandidates) {
-    if (existsSync23(c)) {
+    if (existsSync24(c)) {
       codexLauncher = c;
       break;
     }
   }
   if (codexLauncher) {
     for (const emp of employees) {
-      const wrapperPath = path28.join(binDir, `${emp.name}-codex`);
+      const wrapperPath = path30.join(binDir, `${emp.name}-codex`);
       const content = `#!/bin/bash
 exec node "${codexLauncher}" --agent ${emp.name} "$@"
 `;
-      writeFileSync15(wrapperPath, content);
+      writeFileSync17(wrapperPath, content);
       chmodSync(wrapperPath, 493);
       created++;
     }
@@ -12705,24 +13199,24 @@ export PATH="${binDir}:$PATH"
   const shell = process.env.SHELL ?? "/bin/bash";
   const profilePaths = [];
   if (shell.includes("zsh")) {
-    profilePaths.push(path28.join(home, ".zshrc"));
+    profilePaths.push(path30.join(home, ".zshrc"));
   } else if (shell.includes("bash")) {
-    profilePaths.push(path28.join(home, ".bashrc"));
-    profilePaths.push(path28.join(home, ".bash_profile"));
+    profilePaths.push(path30.join(home, ".bashrc"));
+    profilePaths.push(path30.join(home, ".bash_profile"));
   } else {
-    profilePaths.push(path28.join(home, ".profile"));
+    profilePaths.push(path30.join(home, ".profile"));
   }
   for (const profilePath of profilePaths) {
     try {
       let content = "";
       try {
-        content = readFileSync19(profilePath, "utf8");
+        content = readFileSync21(profilePath, "utf8");
       } catch {
       }
       if (content.includes(".exe-os/bin")) {
         return false;
       }
-      writeFileSync15(profilePath, content + exportLine);
+      writeFileSync17(profilePath, content + exportLine);
       return true;
     } catch {
       continue;
@@ -12745,36 +13239,36 @@ __export(setup_wizard_exports, {
   validateModel: () => validateModel
 });
 import crypto11 from "crypto";
-import { existsSync as existsSync24, mkdirSync as mkdirSync16, readFileSync as readFileSync20, writeFileSync as writeFileSync16, unlinkSync as unlinkSync13 } from "fs";
-import os13 from "os";
-import path29 from "path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync18, readFileSync as readFileSync22, writeFileSync as writeFileSync18, unlinkSync as unlinkSync13 } from "fs";
+import os14 from "os";
+import path31 from "path";
 import { createInterface as createInterface3 } from "readline";
 function findPackageRoot2() {
-  let dir = path29.dirname(new URL(import.meta.url).pathname);
-  const root = path29.parse(dir).root;
+  let dir = path31.dirname(new URL(import.meta.url).pathname);
+  const root = path31.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path29.join(dir, "package.json");
-    if (existsSync24(pkgPath)) {
+    const pkgPath = path31.join(dir, "package.json");
+    if (existsSync25(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync22(pkgPath, "utf-8"));
         if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
       } catch {
       }
     }
-    dir = path29.dirname(dir);
+    dir = path31.dirname(dir);
   }
   return null;
 }
 function loadSetupState() {
   try {
-    return JSON.parse(readFileSync20(SETUP_STATE_PATH, "utf8"));
+    return JSON.parse(readFileSync22(SETUP_STATE_PATH, "utf8"));
   } catch {
     return { completedSteps: [], startedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
 }
 function saveSetupState(state) {
-  mkdirSync16(path29.dirname(SETUP_STATE_PATH), { recursive: true });
-  writeFileSync16(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
+  mkdirSync18(path31.dirname(SETUP_STATE_PATH), { recursive: true });
+  writeFileSync18(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
 }
 function clearSetupState() {
   try {
@@ -12793,10 +13287,10 @@ function ask2(rl, prompt) {
   });
 }
 function getAvailableMemoryGB() {
-  return os13.freemem() / (1024 * 1024 * 1024);
+  return os14.freemem() / (1024 * 1024 * 1024);
 }
 function getTotalMemoryGB() {
-  return os13.totalmem() / (1024 * 1024 * 1024);
+  return os14.totalmem() / (1024 * 1024 * 1024);
 }
 function isLowMemory() {
   return getAvailableMemoryGB() < 2;
@@ -12807,8 +13301,8 @@ 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 = path29.join(MODELS_DIR, LOCAL_FILENAME);
-    if (existsSync24(modelPath)) {
+    const modelPath = path31.join(MODELS_DIR, LOCAL_FILENAME);
+    if (existsSync25(modelPath)) {
       const { statSync: statSync2 } = await import("fs");
       const size = statSync2(modelPath).size;
       if (size > 300 * 1e6) {
@@ -12899,7 +13393,7 @@ async function runSetupWizard(opts = {}) {
     if (state.completedSteps.length > 0) {
       log(`Resuming setup from step ${Math.max(...state.completedSteps) + 1}...`);
     }
-    if (existsSync24(LEGACY_LANCE_PATH)) {
+    if (existsSync25(LEGACY_LANCE_PATH)) {
       log("\u26A0 Found v1.0 LanceDB at ~/.exe-os/local.lance");
       log("  v1.1 uses libSQL (SQLite). Your existing memories are not automatically migrated.");
       log("  The old directory will not be modified or deleted.");
@@ -13063,19 +13557,19 @@ async function runSetupWizard(opts = {}) {
       await saveConfig(config);
       log("");
       try {
-        const claudeJsonPath = path29.join(os13.homedir(), ".claude.json");
+        const claudeJsonPath = path31.join(os14.homedir(), ".claude.json");
         let claudeJson = {};
         try {
-          claudeJson = JSON.parse(readFileSync20(claudeJsonPath, "utf8"));
+          claudeJson = JSON.parse(readFileSync22(claudeJsonPath, "utf8"));
         } catch {
         }
         if (!claudeJson.projects) claudeJson.projects = {};
         const projects = claudeJson.projects;
-        for (const dir of [process.cwd(), os13.homedir()]) {
+        for (const dir of [process.cwd(), os14.homedir()]) {
           if (!projects[dir]) projects[dir] = {};
           projects[dir].hasTrustDialogAccepted = true;
         }
-        writeFileSync16(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+        writeFileSync18(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
       } catch {
       }
       state.completedSteps.push(5);
@@ -13089,7 +13583,7 @@ async function runSetupWizard(opts = {}) {
       const prefs = { ...existingPrefs };
       log("=== Config Defaults ===");
       log("");
-      const ghosttyDetected = existsSync24(path29.join(os13.homedir(), ".config", "ghostty")) || existsSync24(path29.join(os13.homedir(), "Library", "Application Support", "com.mitchellh.ghostty"));
+      const ghosttyDetected = existsSync25(path31.join(os14.homedir(), ".config", "ghostty")) || existsSync25(path31.join(os14.homedir(), "Library", "Application Support", "com.mitchellh.ghostty"));
       if (ghosttyDetected) {
         const ghosttyAnswer = await ask2(rl, "Detected Ghostty terminal. Use exe-os Ghostty defaults? (Y/n) ");
         prefs.ghostty = ghosttyAnswer.toLowerCase() !== "n";
@@ -13136,7 +13630,7 @@ async function runSetupWizard(opts = {}) {
       let missingIdentities = [];
       for (const emp of roster) {
         const idPath = identityPath2(emp.name);
-        if (!existsSync24(idPath)) {
+        if (!existsSync25(idPath)) {
           missingIdentities.push(emp.name);
         }
       }
@@ -13168,7 +13662,7 @@ async function runSetupWizard(opts = {}) {
           }
           missingIdentities = [];
           for (const emp of roster) {
-            if (!existsSync24(identityPath2(emp.name))) {
+            if (!existsSync25(identityPath2(emp.name))) {
               missingIdentities.push(emp.name);
             }
           }
@@ -13233,9 +13727,9 @@ async function runSetupWizard(opts = {}) {
       const cooIdentityContent = getIdentityTemplate("coo");
       if (cooIdentityContent) {
         const cooIdPath = identityPath2(cooName);
-        mkdirSync16(path29.dirname(cooIdPath), { recursive: true });
+        mkdirSync18(path31.dirname(cooIdPath), { recursive: true });
         const replaced = cooIdentityContent.replace(/agent_id:\s*exe/g, `agent_id: ${cooName}`).replace(/\$\{agent_id\}/g, cooName);
-        writeFileSync16(cooIdPath, replaced, "utf-8");
+        writeFileSync18(cooIdPath, replaced, "utf-8");
       }
       registerBinSymlinks2(cooName);
       createdEmployees.push({ name: cooName, role: "COO" });
@@ -13329,9 +13823,9 @@ async function runSetupWizard(opts = {}) {
       const ctoIdentityContent = getIdentityTemplate("cto");
       if (ctoIdentityContent) {
         const ctoIdPath = identityPath2(ctoName);
-        mkdirSync16(path29.dirname(ctoIdPath), { recursive: true });
+        mkdirSync18(path31.dirname(ctoIdPath), { recursive: true });
         const replaced = ctoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${ctoName}`).replace(/\$\{agent_id\}/g, ctoName);
-        writeFileSync16(ctoIdPath, replaced, "utf-8");
+        writeFileSync18(ctoIdPath, replaced, "utf-8");
       }
       registerBinSymlinks2(ctoName);
       createdEmployees.push({ name: ctoName, role: "CTO" });
@@ -13352,9 +13846,9 @@ async function runSetupWizard(opts = {}) {
       const cmoIdentityContent = getIdentityTemplate("cmo");
       if (cmoIdentityContent) {
         const cmoIdPath = identityPath2(cmoName);
-        mkdirSync16(path29.dirname(cmoIdPath), { recursive: true });
+        mkdirSync18(path31.dirname(cmoIdPath), { recursive: true });
         const replaced = cmoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${cmoName}`).replace(/\$\{agent_id\}/g, cmoName);
-        writeFileSync16(cmoIdPath, replaced, "utf-8");
+        writeFileSync18(cmoIdPath, replaced, "utf-8");
       }
       registerBinSymlinks2(cmoName);
       createdEmployees.push({ name: cmoName, role: "CMO" });
@@ -13376,7 +13870,7 @@ async function runSetupWizard(opts = {}) {
             log(`Session shortcuts generated (${cooName}1, ${cooName}2, ...)`);
           }
           if (wrapResult.pathConfigured) {
-            const binDir = path29.join(os13.homedir(), ".exe-os", "bin");
+            const binDir = path31.join(os14.homedir(), ".exe-os", "bin");
             process.env.PATH = `${binDir}:${process.env.PATH ?? ""}`;
             pathJustConfigured = true;
           }
@@ -13419,7 +13913,7 @@ async function runSetupWizard(opts = {}) {
     const pkgRoot2 = findPackageRoot2();
     if (pkgRoot2) {
       try {
-        version = JSON.parse(readFileSync20(path29.join(pkgRoot2, "package.json"), "utf-8")).version;
+        version = JSON.parse(readFileSync22(path31.join(pkgRoot2, "package.json"), "utf-8")).version;
       } catch {
       }
     }
@@ -13453,17 +13947,17 @@ var init_setup_wizard = __esm({
     init_config();
     init_keychain();
     init_model_downloader();
-    SETUP_STATE_PATH = path29.join(os13.homedir(), ".exe-os", "setup-state.json");
+    SETUP_STATE_PATH = path31.join(os14.homedir(), ".exe-os", "setup-state.json");
   }
 });
 
 // src/lib/update-check.ts
 import { execSync as execSync11 } from "child_process";
-import { readFileSync as readFileSync21 } from "fs";
-import path30 from "path";
+import { readFileSync as readFileSync23 } from "fs";
+import path32 from "path";
 function getLocalVersion(packageRoot) {
-  const pkgPath = path30.join(packageRoot, "package.json");
-  const pkg = JSON.parse(readFileSync21(pkgPath, "utf-8"));
+  const pkgPath = path32.join(packageRoot, "package.json");
+  const pkg = JSON.parse(readFileSync23(pkgPath, "utf-8"));
   return pkg.version;
 }
 function getRemoteVersion() {
@@ -17987,8 +18481,8 @@ var init_ErrorOverview = __esm({
     "use strict";
     init_Box();
     init_Text();
-    cleanupPath = (path42) => {
-      return path42?.replace(`file://${cwd()}/`, "");
+    cleanupPath = (path44) => {
+      return path44?.replace(`file://${cwd()}/`, "");
     };
     stackUtils = new StackUtils({
       cwd: cwd(),
@@ -20396,11 +20890,11 @@ function Footer() {
       } catch {
       }
       try {
-        const { existsSync: existsSync29 } = await import("fs");
+        const { existsSync: existsSync30 } = await import("fs");
         const { join } = await import("path");
         const home = process.env.HOME ?? "";
         const pidPath = join(home, ".exe-os", "exed.pid");
-        setDaemon(existsSync29(pidPath) ? "running" : "stopped");
+        setDaemon(existsSync30(pidPath) ? "running" : "stopped");
       } catch {
         setDaemon("unknown");
       }
@@ -22133,7 +22627,7 @@ var init_anthropic = __esm({
 
 // src/gateway/providers/openai-compat.ts
 import OpenAI from "openai";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var OpenAICompatProvider;
 var init_openai_compat = __esm({
   "src/gateway/providers/openai-compat.ts"() {
@@ -22250,7 +22744,7 @@ var init_openai_compat = __esm({
             }
             content.push({
               type: "tool_use",
-              id: call.id ?? randomUUID4(),
+              id: call.id ?? randomUUID5(),
               name: fn.name,
               input
             });
@@ -22442,10 +22936,10 @@ var init_hooks = __esm({
 });
 
 // src/runtime/safety-checks.ts
-import path31 from "path";
-import os14 from "os";
+import path33 from "path";
+import os15 from "os";
 function checkPathSafety(filePath) {
-  const resolved = path31.resolve(filePath);
+  const resolved = path33.resolve(filePath);
   for (const { pattern, reason } of BYPASS_IMMUNE_PATTERNS) {
     const matches = typeof pattern === "function" ? pattern(resolved) : pattern.test(resolved);
     if (matches) {
@@ -22455,7 +22949,7 @@ function checkPathSafety(filePath) {
   return { safe: true, bypassImmune: true };
 }
 function checkReadPathSafety(filePath) {
-  const resolved = path31.resolve(filePath);
+  const resolved = path33.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"))
   );
@@ -22470,7 +22964,7 @@ var HOME, BYPASS_IMMUNE_PATTERNS;
 var init_safety_checks = __esm({
   "src/runtime/safety-checks.ts"() {
     "use strict";
-    HOME = os14.homedir();
+    HOME = os15.homedir();
     BYPASS_IMMUNE_PATTERNS = [
       {
         pattern: /\/\.git\/hooks\//,
@@ -22481,11 +22975,11 @@ var init_safety_checks = __esm({
         reason: "Git config can set hooks and command execution"
       },
       {
-        pattern: (p) => p.startsWith(path31.join(HOME, ".claude")),
+        pattern: (p) => p.startsWith(path33.join(HOME, ".claude")),
         reason: "Claude configuration files are protected"
       },
       {
-        pattern: (p) => p.startsWith(path31.join(HOME, ".exe-os")),
+        pattern: (p) => p.startsWith(path33.join(HOME, ".exe-os")),
         reason: "exe-os configuration files are protected"
       },
       {
@@ -22502,7 +22996,7 @@ var init_safety_checks = __esm({
       },
       {
         pattern: (p) => {
-          const name = path31.basename(p);
+          const name = path33.basename(p);
           return [".bashrc", ".zshrc", ".profile", ".bash_profile", ".zprofile", ".zshenv"].includes(name);
         },
         reason: "Shell configuration files can execute arbitrary code on login"
@@ -22529,7 +23023,7 @@ __export(file_read_exports, {
   FileReadTool: () => FileReadTool
 });
 import fs3 from "fs/promises";
-import path32 from "path";
+import path34 from "path";
 import { z } from "zod";
 function isBinary(buf) {
   for (let i = 0; i < buf.length; i++) {
@@ -22565,7 +23059,7 @@ var init_file_read = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path32.isAbsolute(input.file_path) ? input.file_path : path32.resolve(context.cwd, input.file_path);
+        const filePath = path34.isAbsolute(input.file_path) ? input.file_path : path34.resolve(context.cwd, input.file_path);
         let stat2;
         try {
           stat2 = await fs3.stat(filePath);
@@ -22605,7 +23099,7 @@ __export(glob_exports, {
   GlobTool: () => GlobTool
 });
 import fs4 from "fs/promises";
-import path33 from "path";
+import path35 from "path";
 import { z as z2 } from "zod";
 async function walkDir(dir, maxDepth = 10) {
   const results = [];
@@ -22621,7 +23115,7 @@ async function walkDir(dir, maxDepth = 10) {
       if (entry.isDirectory() && (entry.name === "node_modules" || entry.name === ".git")) {
         continue;
       }
-      const fullPath = path33.join(current, entry.name);
+      const fullPath = path35.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath, depth + 1);
       } else {
@@ -22655,11 +23149,11 @@ var init_glob = __esm({
       inputSchema: inputSchema2,
       isReadOnly: true,
       async call(input, context) {
-        const baseDir = input.path ? path33.isAbsolute(input.path) ? input.path : path33.resolve(context.cwd, input.path) : context.cwd;
+        const baseDir = input.path ? path35.isAbsolute(input.path) ? input.path : path35.resolve(context.cwd, input.path) : context.cwd;
         try {
           const entries = await walkDir(baseDir);
           const matched = entries.filter(
-            (e) => simpleGlobMatch(path33.relative(baseDir, e.path), input.pattern)
+            (e) => simpleGlobMatch(path35.relative(baseDir, e.path), input.pattern)
           );
           matched.sort((a, b) => b.mtime - a.mtime);
           if (matched.length === 0) {
@@ -22685,7 +23179,7 @@ __export(grep_exports, {
 });
 import { spawn as spawn2 } from "child_process";
 import fs5 from "fs/promises";
-import path34 from "path";
+import path36 from "path";
 import { z as z3 } from "zod";
 function runRipgrep(input, searchPath, context) {
   return new Promise((resolve, reject) => {
@@ -22739,7 +23233,7 @@ async function nodeGrep(input, searchPath) {
     }
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const fullPath = path34.join(dir, entry.name);
+      const fullPath = path36.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
@@ -22785,7 +23279,7 @@ var init_grep = __esm({
       inputSchema: inputSchema3,
       isReadOnly: true,
       async call(input, context) {
-        const searchPath = input.path ? path34.isAbsolute(input.path) ? input.path : path34.resolve(context.cwd, input.path) : context.cwd;
+        const searchPath = input.path ? path36.isAbsolute(input.path) ? input.path : path36.resolve(context.cwd, input.path) : context.cwd;
         try {
           const result = await runRipgrep(input, searchPath, context);
           return result;
@@ -22810,7 +23304,7 @@ __export(file_write_exports, {
   FileWriteTool: () => FileWriteTool
 });
 import fs6 from "fs/promises";
-import path35 from "path";
+import path37 from "path";
 import { z as z4 } from "zod";
 var inputSchema4, FileWriteTool;
 var init_file_write = __esm({
@@ -22838,8 +23332,8 @@ var init_file_write = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path35.isAbsolute(input.file_path) ? input.file_path : path35.resolve(context.cwd, input.file_path);
-        const dir = path35.dirname(filePath);
+        const filePath = path37.isAbsolute(input.file_path) ? input.file_path : path37.resolve(context.cwd, input.file_path);
+        const dir = path37.dirname(filePath);
         await fs6.mkdir(dir, { recursive: true });
         await fs6.writeFile(filePath, input.content, "utf-8");
         return {
@@ -22857,7 +23351,7 @@ __export(file_edit_exports, {
   FileEditTool: () => FileEditTool
 });
 import fs7 from "fs/promises";
-import path36 from "path";
+import path38 from "path";
 import { z as z5 } from "zod";
 function countOccurrences(haystack, needle) {
   let count = 0;
@@ -22898,7 +23392,7 @@ var init_file_edit = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path36.isAbsolute(input.file_path) ? input.file_path : path36.resolve(context.cwd, input.file_path);
+        const filePath = path38.isAbsolute(input.file_path) ? input.file_path : path38.resolve(context.cwd, input.file_path);
         let content;
         try {
           content = await fs7.readFile(filePath, "utf-8");
@@ -23140,7 +23634,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 path37 from "path";
+import path39 from "path";
 import { homedir as homedir6 } from "os";
 import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 function CommandCenterView({
@@ -23175,15 +23669,15 @@ 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: readFileSync25, existsSync: existsSync29 } = await import("fs");
+        const { readFileSync: readFileSync27, existsSync: existsSync30 } = await import("fs");
         const { join } = await import("path");
         const { homedir: homedir8 } = await import("os");
         const configPath = join(homedir8(), ".exe-os", "config.json");
         let failoverChain = ["anthropic", "opencode", "gemini", "openai"];
         let providerConfigs = {};
-        if (existsSync29(configPath)) {
+        if (existsSync30(configPath)) {
           try {
-            const raw = JSON.parse(readFileSync25(configPath, "utf8"));
+            const raw = JSON.parse(readFileSync27(configPath, "utf8"));
             if (Array.isArray(raw.failoverChain)) failoverChain = raw.failoverChain;
             if (raw.providers && typeof raw.providers === "object") {
               providerConfigs = raw.providers;
@@ -23244,7 +23738,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(readFileSync25(join(markerDir, f), "utf8"));
+            const data = JSON.parse(readFileSync27(join(markerDir, f), "utf8"));
             if (data.agentRole) {
               agentRole = data.agentRole;
               break;
@@ -23389,7 +23883,7 @@ function CommandCenterView({
       const demoEntries = DEMO_PROJECTS.map((p) => ({
         projectName: p.projectName,
         exeSession: p.exeSession,
-        projectDir: path37.join(homedir6(), p.projectName),
+        projectDir: path39.join(homedir6(), p.projectName),
         employeeCount: p.employees.length,
         activeCount: p.employees.filter((e) => e.status === "active").length,
         memoryCount: p.employees.length * 4e3,
@@ -23427,7 +23921,7 @@ function CommandCenterView({
         const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_session_registry(), session_registry_exports));
         const { listTmuxSessions: listTmuxSessions2, inTmux: inTmux2 } = await Promise.resolve().then(() => (init_tmux_status(), tmux_status_exports));
         const { loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
-        const { existsSync: existsSync29 } = await import("fs");
+        const { existsSync: existsSync30 } = await import("fs");
         const { join } = await import("path");
         const client = getClient2();
         if (!client) {
@@ -23498,7 +23992,7 @@ function CommandCenterView({
           }
           const memoryCount = memoryCounts.get(name) ?? 0;
           const openTaskCount = openTaskCounts.get(name) ?? 0;
-          const hasGit = projectDir ? existsSync29(join(projectDir, ".git")) : false;
+          const hasGit = projectDir ? existsSync30(join(projectDir, ".git")) : false;
           const type = hasGit ? "code" : memoryCount > 0 ? "code" : "automation";
           projectList.push({
             projectName: name,
@@ -23523,7 +24017,7 @@ function CommandCenterView({
         setHealth((h) => ({ ...h, memories: Number(totalResult.rows[0]?.cnt ?? 0) }));
         try {
           const pidPath = join(process.env.HOME ?? "", ".exe-os", "exed.pid");
-          setHealth((h) => ({ ...h, daemon: existsSync29(pidPath) ? "running" : "stopped" }));
+          setHealth((h) => ({ ...h, daemon: existsSync30(pidPath) ? "running" : "stopped" }));
         } catch {
         }
         const activityResult = await client.execute(
@@ -23870,7 +24364,7 @@ var init_TmuxPane = __esm({
 });
 
 // src/lib/task-router.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function resolveBloomRouting(complexity, config = DEFAULT_BLOOM_CONFIG) {
   const tier = config.complexityToTier[complexity];
   const rule = config.tierRules[tier];
@@ -24393,7 +24887,7 @@ var init_useOrchestrator = __esm({
 
 // src/tui/views/Sessions.tsx
 import React19, { useState as useState9, useEffect as useEffect11, useCallback as useCallback6 } from "react";
-import path38 from "path";
+import path40 from "path";
 import { homedir as homedir7 } from "os";
 import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 function isCoordinatorEntry(entry) {
@@ -24431,7 +24925,7 @@ function SessionsView({
     if (demo) {
       setProjects(DEMO_PROJECTS.map((p) => ({
         ...p,
-        projectDir: path38.join(homedir7(), p.projectName),
+        projectDir: path40.join(homedir7(), p.projectName),
         employees: p.employees.map((e) => ({ ...e, attached: e.status === "active" }))
       })));
       return;
@@ -25535,12 +26029,12 @@ async function loadGatewayConfig() {
     state.running = false;
   }
   try {
-    const { existsSync: existsSync29, readFileSync: readFileSync25 } = await import("fs");
+    const { existsSync: existsSync30, readFileSync: readFileSync27 } = await import("fs");
     const { join } = await import("path");
     const home = process.env.HOME ?? "";
     const configPath = join(home, ".exe-os", "gateway.json");
-    if (existsSync29(configPath)) {
-      const raw = JSON.parse(readFileSync25(configPath, "utf8"));
+    if (existsSync30(configPath)) {
+      const raw = JSON.parse(readFileSync27(configPath, "utf8"));
       state.port = raw.port ?? 3100;
       state.gatewayUrl = raw.gatewayUrl ?? "";
       if (raw.adapters) {
@@ -26163,12 +26657,12 @@ function TeamView({ onBack, onViewSessions }) {
         setMembers(teamData);
         setDbError(null);
         try {
-          const { existsSync: existsSync29, readFileSync: readFileSync25 } = await import("fs");
+          const { existsSync: existsSync30, readFileSync: readFileSync27 } = await import("fs");
           const { join } = await import("path");
           const home = process.env.HOME ?? "";
           const gatewayConfig = join(home, ".exe-os", "gateway.json");
-          if (existsSync29(gatewayConfig)) {
-            const raw = JSON.parse(readFileSync25(gatewayConfig, "utf8"));
+          if (existsSync30(gatewayConfig)) {
+            const raw = JSON.parse(readFileSync27(gatewayConfig, "utf8"));
             if (raw.agents && raw.agents.length > 0) {
               setExternals(raw.agents.map((a) => ({
                 name: a.name,
@@ -26349,8 +26843,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config, path42, method = "GET", body) {
-  const url = `${config.baseUrl}/api/v1${path42}`;
+async function wikiFetch(config, path44, method = "GET", body) {
+  const url = `${config.baseUrl}/api/v1${path44}`;
   const headers = {
     Authorization: `Bearer ${config.apiKey}`,
     "Content-Type": "application/json"
@@ -26383,7 +26877,7 @@ async function wikiFetch(config, path42, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path42}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path44}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -26993,12 +27487,12 @@ function SettingsView({ onBack }) {
     }
     setProviders(providerList);
     try {
-      const { existsSync: existsSync29 } = await import("fs");
+      const { existsSync: existsSync30 } = await import("fs");
       const { join } = await import("path");
       const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
       const cfg = await loadConfig2();
       const home = process.env.HOME ?? "";
-      const hasKey = existsSync29(join(home, ".exe-os", "master.key"));
+      const hasKey = existsSync30(join(home, ".exe-os", "master.key"));
       if (cfg.cloud) {
         setCloud({
           configured: true,
@@ -27011,22 +27505,22 @@ function SettingsView({ onBack }) {
       const pidPath = join(home, ".exe-os", "exed.pid");
       let daemon = "unknown";
       try {
-        daemon = existsSync29(pidPath) ? "running" : "stopped";
+        daemon = existsSync30(pidPath) ? "running" : "stopped";
       } catch {
       }
       let version = "unknown";
       try {
-        const { readFileSync: readFileSync25 } = await import("fs");
+        const { readFileSync: readFileSync27 } = await import("fs");
         const { createRequire } = await import("module");
         const require2 = createRequire(import.meta.url);
         const pkgPath = require2.resolve("@askexenow/exe-os/package.json");
-        const pkg = JSON.parse(readFileSync25(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync27(pkgPath, "utf8"));
         version = pkg.version;
       } catch {
         try {
-          const { readFileSync: readFileSync25 } = await import("fs");
+          const { readFileSync: readFileSync27 } = await import("fs");
           const { join: joinPath } = await import("path");
-          const pkg = JSON.parse(readFileSync25(joinPath(process.cwd(), "package.json"), "utf8"));
+          const pkg = JSON.parse(readFileSync27(joinPath(process.cwd(), "package.json"), "utf8"));
           version = pkg.version;
         } catch {
         }
@@ -27827,15 +28321,15 @@ __export(installer_exports2, {
   verifyOpenCodeHooks: () => verifyOpenCodeHooks
 });
 import { readFile as readFile6, writeFile as writeFile7, mkdir as mkdir7 } from "fs/promises";
-import { existsSync as existsSync26, readFileSync as readFileSync23 } from "fs";
-import path39 from "path";
-import os15 from "os";
-async function registerOpenCodeMcp(packageRoot, homeDir = os15.homedir()) {
-  const configDir = path39.join(homeDir, ".config", "opencode");
-  const configPath = path39.join(configDir, "opencode.json");
+import { existsSync as existsSync27, readFileSync as readFileSync25 } from "fs";
+import path41 from "path";
+import os16 from "os";
+async function registerOpenCodeMcp(packageRoot, homeDir = os16.homedir()) {
+  const configDir = path41.join(homeDir, ".config", "opencode");
+  const configPath = path41.join(configDir, "opencode.json");
   await mkdir7(configDir, { recursive: true });
   let config = {};
-  if (existsSync26(configPath)) {
+  if (existsSync27(configPath)) {
     try {
       config = JSON.parse(await readFile6(configPath, "utf-8"));
     } catch {
@@ -27847,7 +28341,7 @@ async function registerOpenCodeMcp(packageRoot, homeDir = os15.homedir()) {
   }
   const newEntry = {
     type: "local",
-    command: ["node", path39.join(packageRoot, "dist", "mcp", "server.js")],
+    command: ["node", path41.join(packageRoot, "dist", "mcp", "server.js")],
     enabled: true
   };
   const current = config.mcp["exe-os"];
@@ -27861,15 +28355,15 @@ async function registerOpenCodeMcp(packageRoot, homeDir = os15.homedir()) {
   await writeFile7(configPath, JSON.stringify(config, null, 2) + "\n");
   return true;
 }
-async function installOpenCodePlugin(packageRoot, homeDir = os15.homedir()) {
-  const pluginDir = path39.join(homeDir, ".config", "opencode", "plugins");
-  const pluginPath = path39.join(pluginDir, "exe-os.mjs");
+async function installOpenCodePlugin(packageRoot, homeDir = os16.homedir()) {
+  const pluginDir = path41.join(homeDir, ".config", "opencode", "plugins");
+  const pluginPath = path41.join(pluginDir, "exe-os.mjs");
   await mkdir7(pluginDir, { recursive: true });
   const pluginContent = PLUGIN_TEMPLATE.replace(
     /__PACKAGE_ROOT__/g,
     packageRoot.replace(/\\/g, "\\\\")
   );
-  if (existsSync26(pluginPath)) {
+  if (existsSync27(pluginPath)) {
     const existing = await readFile6(pluginPath, "utf-8");
     if (existing === pluginContent) {
       return false;
@@ -27878,17 +28372,17 @@ async function installOpenCodePlugin(packageRoot, homeDir = os15.homedir()) {
   await writeFile7(pluginPath, pluginContent);
   return true;
 }
-function verifyOpenCodeHooks(homeDir = os15.homedir()) {
-  const configPath = path39.join(homeDir, ".config", "opencode", "opencode.json");
-  const pluginPath = path39.join(homeDir, ".config", "opencode", "plugins", "exe-os.mjs");
-  if (!existsSync26(configPath)) return false;
+function verifyOpenCodeHooks(homeDir = os16.homedir()) {
+  const configPath = path41.join(homeDir, ".config", "opencode", "opencode.json");
+  const pluginPath = path41.join(homeDir, ".config", "opencode", "plugins", "exe-os.mjs");
+  if (!existsSync27(configPath)) return false;
   try {
-    const config = JSON.parse(readFileSync23(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync25(configPath, "utf-8"));
     if (!config.mcp?.["exe-os"]?.enabled) return false;
   } catch {
     return false;
   }
-  if (!existsSync26(pluginPath)) return false;
+  if (!existsSync27(pluginPath)) return false;
   return true;
 }
 async function runOpenCodeInstaller(homeDir) {
@@ -27921,19 +28415,19 @@ __export(installer_exports3, {
   verifyCodexHooks: () => verifyCodexHooks
 });
 import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync27 } from "fs";
-import path40 from "path";
-import os16 from "os";
-async function mergeCodexHooks(packageRoot, homeDir = os16.homedir()) {
-  const codexDir = path40.join(homeDir, ".codex");
-  const hooksPath = path40.join(codexDir, "hooks.json");
-  const logsDir = path40.join(homeDir, ".exe-os", "logs");
-  const hookLogPath = path40.join(logsDir, "hooks.log");
+import { existsSync as existsSync28 } from "fs";
+import path42 from "path";
+import os17 from "os";
+async function mergeCodexHooks(packageRoot, homeDir = os17.homedir()) {
+  const codexDir = path42.join(homeDir, ".codex");
+  const hooksPath = path42.join(codexDir, "hooks.json");
+  const logsDir = path42.join(homeDir, ".exe-os", "logs");
+  const hookLogPath = path42.join(logsDir, "hooks.log");
   const logSuffix = ` 2>> "${hookLogPath}"`;
   await mkdir8(codexDir, { recursive: true });
   await mkdir8(logsDir, { recursive: true });
   let hooksJson = {};
-  if (existsSync27(hooksPath)) {
+  if (existsSync28(hooksPath)) {
     try {
       hooksJson = JSON.parse(await readFile7(hooksPath, "utf-8"));
     } catch {
@@ -27950,7 +28444,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os16.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path40.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
+            command: `node "${path42.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
             timeout: 30,
             statusMessage: "exe-os: loading memory brief"
           }
@@ -27965,11 +28459,11 @@ async function mergeCodexHooks(packageRoot, homeDir = os16.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path40.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
+            command: `node "${path42.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
           },
           {
             type: "command",
-            command: `node "${path40.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
+            command: `node "${path42.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
           }
         ]
       },
@@ -27981,11 +28475,11 @@ async function mergeCodexHooks(packageRoot, homeDir = os16.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path40.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
+            command: `node "${path42.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
           },
           {
             type: "command",
-            command: `node "${path40.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
+            command: `node "${path42.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
             timeout: 5
           }
         ]
@@ -27998,7 +28492,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os16.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path40.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
+            command: `node "${path42.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
           }
         ]
       },
@@ -28011,7 +28505,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os16.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path40.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
+            command: `node "${path42.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
           }
         ]
       },
@@ -28042,9 +28536,9 @@ async function mergeCodexHooks(packageRoot, homeDir = os16.homedir()) {
   await writeFile8(hooksPath, JSON.stringify(hooksJson, null, 2) + "\n");
   return { added, skipped };
 }
-function verifyCodexHooks(homeDir = os16.homedir()) {
-  const hooksPath = path40.join(homeDir, ".codex", "hooks.json");
-  if (!existsSync27(hooksPath)) return false;
+function verifyCodexHooks(homeDir = os17.homedir()) {
+  const hooksPath = path42.join(homeDir, ".codex", "hooks.json");
+  if (!existsSync28(hooksPath)) return false;
   try {
     const hooksJson = JSON.parse(
       __require("fs").readFileSync(hooksPath, "utf-8")
@@ -28064,14 +28558,14 @@ function verifyCodexHooks(homeDir = os16.homedir()) {
     return false;
   }
 }
-async function installCodexStatusLine(homeDir = os16.homedir()) {
+async function installCodexStatusLine(homeDir = os17.homedir()) {
   const prefs = loadPreferences(homeDir);
   if (prefs.codexStatusLine === false) return "opted-out";
-  const codexDir = path40.join(homeDir, ".codex");
-  const configPath = path40.join(codexDir, "config.toml");
+  const codexDir = path42.join(homeDir, ".codex");
+  const configPath = path42.join(codexDir, "config.toml");
   await mkdir8(codexDir, { recursive: true });
   let content = "";
-  if (existsSync27(configPath)) {
+  if (existsSync28(configPath)) {
     content = await readFile7(configPath, "utf-8");
     if (/\[tui\][\s\S]*?status_line\s*=/.test(content)) {
       return "already-configured";
@@ -28119,14 +28613,14 @@ var init_installer3 = __esm({
 });
 
 // src/bin/cli.ts
-import { existsSync as existsSync28, readFileSync as readFileSync24, writeFileSync as writeFileSync17, readdirSync as readdirSync8, rmSync } from "fs";
-import path41 from "path";
-import os17 from "os";
+import { existsSync as existsSync29, readFileSync as readFileSync26, writeFileSync as writeFileSync19, readdirSync as readdirSync8, rmSync } from "fs";
+import path43 from "path";
+import os18 from "os";
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
   try {
-    const pkgPath = path41.join(path41.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync24(pkgPath, "utf8"));
+    const pkgPath = path43.join(path43.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync26(pkgPath, "utf8"));
     console.log(pkg.version);
   } catch {
     console.log("unknown");
@@ -28237,6 +28731,12 @@ if (args.includes("--global")) {
     console.error("Backfill failed:", err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
+} else if (args[0] === "export") {
+  const { runExeExport: runExeExport2 } = await Promise.resolve().then(() => (init_exe_export(), exe_export_exports));
+  await runExeExport2(args.slice(1));
+} else if (args[0] === "import") {
+  const { runExeImport: runExeImport2 } = await Promise.resolve().then(() => (init_exe_import(), exe_import_exports));
+  await runExeImport2(args.slice(1));
 } else if (args[0] === "send-message" || args[0] === "send_message") {
   const target = args[1];
   const msgParts = [];
@@ -28284,11 +28784,11 @@ ID: ${result.id}`);
   });
   await init_App2().then(() => App_exports);
 } else {
-  const claudeDir = path41.join(os17.homedir(), ".claude");
-  const settingsPath = path41.join(claudeDir, "settings.json");
-  const hasClaudeCode = existsSync28(settingsPath) && (() => {
+  const claudeDir = path43.join(os18.homedir(), ".claude");
+  const settingsPath = path43.join(claudeDir, "settings.json");
+  const hasClaudeCode = existsSync29(settingsPath) && (() => {
     try {
-      const raw = readFileSync24(settingsPath, "utf8");
+      const raw = readFileSync26(settingsPath, "utf8");
       return raw.includes("exe-os") || raw.includes("exe-mem");
     } catch {
       return false;
@@ -28298,9 +28798,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 = path41.join(os17.homedir(), ".exe-os", "exe-employees.json");
-      if (existsSync28(rosterPath)) {
-        const roster = JSON.parse(readFileSync24(rosterPath, "utf8"));
+      const rosterPath = path43.join(os18.homedir(), ".exe-os", "exe-employees.json");
+      if (existsSync29(rosterPath)) {
+        const roster = JSON.parse(readFileSync26(rosterPath, "utf8"));
         const coo = roster.find((e) => e.role === "COO");
         if (coo) cooName = coo.name;
       }
@@ -28364,14 +28864,14 @@ async function runCodexInstall() {
   }
 }
 async function runClaudeCheck() {
-  const claudeDir = path41.join(os17.homedir(), ".claude");
-  const settingsPath = path41.join(claudeDir, "settings.json");
-  const claudeJsonPath = path41.join(os17.homedir(), ".claude.json");
+  const claudeDir = path43.join(os18.homedir(), ".claude");
+  const settingsPath = path43.join(claudeDir, "settings.json");
+  const claudeJsonPath = path43.join(os18.homedir(), ".claude.json");
   let ok = true;
-  if (existsSync28(settingsPath)) {
+  if (existsSync29(settingsPath)) {
     let settings;
     try {
-      settings = JSON.parse(readFileSync24(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync26(settingsPath, "utf8"));
     } catch {
       console.log("\x1B[31m\u2717\x1B[0m settings.json is malformed (invalid JSON)");
       ok = false;
@@ -28397,10 +28897,10 @@ async function runClaudeCheck() {
     console.log("\x1B[31m\u2717\x1B[0m settings.json not found");
     ok = false;
   }
-  if (existsSync28(claudeJsonPath)) {
+  if (existsSync29(claudeJsonPath)) {
     let claudeJson;
     try {
-      claudeJson = JSON.parse(readFileSync24(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync26(claudeJsonPath, "utf8"));
     } catch {
       console.log("\x1B[31m\u2717\x1B[0m claude.json is malformed (invalid JSON)");
       ok = false;
@@ -28419,8 +28919,8 @@ async function runClaudeCheck() {
     console.log("\x1B[31m\u2717\x1B[0m claude.json not found");
     ok = false;
   }
-  const skillsDir = path41.join(claudeDir, "skills");
-  if (existsSync28(skillsDir)) {
+  const skillsDir = path43.join(claudeDir, "skills");
+  if (existsSync29(skillsDir)) {
     console.log("\x1B[32m\u2713\x1B[0m Slash skills directory exists");
   } else {
     console.log("\x1B[31m\u2717\x1B[0m Slash skills directory missing");
@@ -28436,17 +28936,17 @@ async function runClaudeCheck() {
 async function runClaudeUninstall(flags = []) {
   const dryRun = flags.includes("--dry-run");
   const purge = flags.includes("--purge");
-  const homeDir = os17.homedir();
-  const claudeDir = path41.join(homeDir, ".claude");
-  const settingsPath = path41.join(claudeDir, "settings.json");
-  const claudeJsonPath = path41.join(homeDir, ".claude.json");
-  const exeOsDir = path41.join(homeDir, ".exe-os");
+  const homeDir = os18.homedir();
+  const claudeDir = path43.join(homeDir, ".claude");
+  const settingsPath = path43.join(claudeDir, "settings.json");
+  const claudeJsonPath = path43.join(homeDir, ".claude.json");
+  const exeOsDir = path43.join(homeDir, ".exe-os");
   let removed = 0;
   const log = (msg) => console.log(dryRun ? `[dry-run] ${msg}` : msg);
   let settings = {};
-  if (existsSync28(settingsPath)) {
+  if (existsSync29(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync24(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync26(settingsPath, "utf8"));
     } catch {
       console.error("Your ~/.claude/settings.json appears malformed.");
       if (purge) {
@@ -28484,15 +28984,15 @@ async function runClaudeUninstall(flags = []) {
         permCount = before - settings.permissions.allow.length;
       }
       if (!dryRun) {
-        writeFileSync17(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        writeFileSync19(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`);
       removed++;
     }
   }
-  if (existsSync28(claudeJsonPath)) {
-    const raw = readFileSync24(claudeJsonPath, "utf8");
+  if (existsSync29(claudeJsonPath)) {
+    const raw = readFileSync26(claudeJsonPath, "utf8");
     if (raw.length > 1e6) {
       console.error("claude.json exceeds 1 MB \u2014 skipping parse.");
     } else {
@@ -28513,7 +29013,7 @@ async function runClaudeUninstall(flags = []) {
         }
         if (removedMcp) {
           if (!dryRun) {
-            writeFileSync17(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+            writeFileSync19(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
           }
           log("\u2713 Removed exe-os MCP server from claude.json");
           removed++;
@@ -28521,14 +29021,14 @@ async function runClaudeUninstall(flags = []) {
       }
     }
   }
-  const skillsDir = path41.join(claudeDir, "skills");
-  if (existsSync28(skillsDir)) {
+  const skillsDir = path43.join(claudeDir, "skills");
+  if (existsSync29(skillsDir)) {
     let skillCount = 0;
     try {
       const entries = readdirSync8(skillsDir);
       for (const entry of entries) {
         if (entry.startsWith("exe")) {
-          const fullPath = path41.join(skillsDir, entry);
+          const fullPath = path43.join(skillsDir, entry);
           if (!dryRun) rmSync(fullPath, { recursive: true, force: true });
           skillCount++;
         }
@@ -28540,30 +29040,30 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const claudeMdPath = path41.join(claudeDir, "CLAUDE.md");
-  if (existsSync28(claudeMdPath)) {
-    const content = readFileSync24(claudeMdPath, "utf8");
+  const claudeMdPath = path43.join(claudeDir, "CLAUDE.md");
+  if (existsSync29(claudeMdPath)) {
+    const content = readFileSync26(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) writeFileSync17(claudeMdPath, cleaned);
+      if (!dryRun) writeFileSync19(claudeMdPath, cleaned);
       log("\u2713 Removed orchestration block from CLAUDE.md");
       removed++;
     }
   }
-  const agentsDir = path41.join(claudeDir, "agents");
-  if (existsSync28(agentsDir)) {
+  const agentsDir = path43.join(claudeDir, "agents");
+  if (existsSync29(agentsDir)) {
     let agentCount = 0;
     try {
       const entries = readdirSync8(agentsDir).filter((f) => f.endsWith(".md"));
       let knownNames = /* @__PURE__ */ new Set();
-      const rosterPath = path41.join(exeOsDir, "exe-employees.json");
-      if (existsSync28(rosterPath)) {
+      const rosterPath = path43.join(exeOsDir, "exe-employees.json");
+      if (existsSync29(rosterPath)) {
         try {
-          const roster = JSON.parse(readFileSync24(rosterPath, "utf8"));
+          const roster = JSON.parse(readFileSync26(rosterPath, "utf8"));
           knownNames = new Set(roster.map((e) => e.name));
         } catch {
         }
@@ -28571,7 +29071,7 @@ async function runClaudeUninstall(flags = []) {
       for (const entry of entries) {
         const name = entry.replace(/\.md$/, "");
         if (knownNames.has(name)) {
-          if (!dryRun) rmSync(path41.join(agentsDir, entry), { force: true });
+          if (!dryRun) rmSync(path43.join(agentsDir, entry), { force: true });
           agentCount++;
         }
       }
@@ -28582,16 +29082,16 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const projectsDir = path41.join(claudeDir, "projects");
-  if (existsSync28(projectsDir)) {
+  const projectsDir = path43.join(claudeDir, "projects");
+  if (existsSync29(projectsDir)) {
     let projectCount = 0;
     try {
       const projects = readdirSync8(projectsDir);
       for (const proj of projects) {
-        const projSettings = path41.join(projectsDir, proj, "settings.json");
-        if (!existsSync28(projSettings)) continue;
+        const projSettings = path43.join(projectsDir, proj, "settings.json");
+        if (!existsSync29(projSettings)) continue;
         try {
-          const pSettings = JSON.parse(readFileSync24(projSettings, "utf8"));
+          const pSettings = JSON.parse(readFileSync26(projSettings, "utf8"));
           let changed = false;
           if (Array.isArray(pSettings.permissions?.allow)) {
             const before = pSettings.permissions.allow.length;
@@ -28601,7 +29101,7 @@ async function runClaudeUninstall(flags = []) {
             if (pSettings.permissions.allow.length < before) changed = true;
           }
           if (changed && !dryRun) {
-            writeFileSync17(projSettings, JSON.stringify(pSettings, null, 2) + "\n");
+            writeFileSync19(projSettings, JSON.stringify(pSettings, null, 2) + "\n");
           }
           if (changed) projectCount++;
         } catch {
@@ -28625,18 +29125,18 @@ async function runClaudeUninstall(flags = []) {
     };
     const exeBinPath = findExeBin3();
     if (!exeBinPath) throw new Error("exe-os not found in PATH");
-    const binDir = path41.dirname(exeBinPath);
+    const binDir = path43.dirname(exeBinPath);
     let symlinkCount = 0;
-    const rosterPath = path41.join(exeOsDir, "exe-employees.json");
-    if (existsSync28(rosterPath)) {
-      const roster = JSON.parse(readFileSync24(rosterPath, "utf8"));
+    const rosterPath = path43.join(exeOsDir, "exe-employees.json");
+    if (existsSync29(rosterPath)) {
+      const roster = JSON.parse(readFileSync26(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 = path41.join(binDir, `${emp.name}${suffix}`);
-          if (existsSync28(linkPath)) {
+          const linkPath = path43.join(binDir, `${emp.name}${suffix}`);
+          if (existsSync29(linkPath)) {
             if (!dryRun) rmSync(linkPath, { force: true });
             symlinkCount++;
           }
@@ -28649,7 +29149,7 @@ async function runClaudeUninstall(flags = []) {
     }
   } catch {
   }
-  if (purge && existsSync28(exeOsDir)) {
+  if (purge && existsSync29(exeOsDir)) {
     if (!dryRun) {
       process.stdout.write("\x1B[33m\u26A0 This will delete all memories, identities, and agent data.\x1B[0m\n");
       process.stdout.write("  Removing ~/.exe-os...\n");
@@ -28674,7 +29174,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 = path41.resolve(
+    const packageRoot = path43.resolve(
       new URL("../..", import.meta.url).pathname
     );
     const result = checkForUpdate2(packageRoot);
@@ -28734,7 +29234,7 @@ async function runActivate(key) {
       const idTemplate = getIdentityTemplate(identityKey);
       if (idTemplate) {
         const idPath = identityPath2(name);
-        const dir = path41.dirname(idPath);
+        const dir = path43.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");
       }