@askexenow/exe-os 0.9.1 → 0.9.3

package/dist/mcp/server.js

@@ -698,10 +698,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: existsSync31 } = await import("fs");
-  const path38 = await import("path");
-  const modelPath = path38.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync31(modelPath)) {
+  const { existsSync: existsSync32 } = await import("fs");
+  const path40 = await import("path");
+  const modelPath = path40.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync32(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -6108,7 +6108,7 @@ var init_agent_config = __esm({
     AGENT_CONFIG_PATH = path16.join(EXE_AI_DIR, "agent-config.json");
     KNOWN_RUNTIMES = {
       claude: ["claude-opus-4", "claude-sonnet-4", "claude-haiku-4.5"],
-      codex: ["gpt-5.4", "gpt-5.5", "o3", "o4-mini"],
+      codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
       opencode: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
     };
     RUNTIME_LABELS = {
@@ -9817,7 +9817,7 @@ __export(consolidation_exports, {
   selectUnconsolidated: () => selectUnconsolidated,
   storeConsolidation: () => storeConsolidation
 });
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 async function selectUnconsolidated(client, limit = 200) {
   const result = await client.execute({
     sql: `SELECT id, agent_id, project_name, tool_name, raw_text, timestamp
@@ -9913,7 +9913,7 @@ async function consolidateCluster(cluster, model) {
   return textBlock?.text ?? "";
 }
 async function storeConsolidation(client, cluster, synthesisText, embedFn) {
-  const consolidatedId = randomUUID5();
+  const consolidatedId = randomUUID6();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const rawText = `CONSOLIDATION [${cluster.dateRange}, ${cluster.projectName}]:
 
@@ -9938,7 +9938,7 @@ ${synthesisText}`;
   const linkStmts = sourceIds.map((sourceId) => ({
     sql: `INSERT INTO consolidations (id, consolidated_memory_id, source_memory_id, created_at)
           VALUES (?, ?, ?, ?)`,
-    args: [randomUUID5(), consolidatedId, sourceId, now]
+    args: [randomUUID6(), consolidatedId, sourceId, now]
   }));
   const placeholders = sourceIds.map(() => "?").join(",");
   const markStmt = {
@@ -10184,8 +10184,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config2, path38, method = "GET", body) {
-  const url = `${config2.baseUrl}/api/v1${path38}`;
+async function wikiFetch(config2, path40, method = "GET", body) {
+  const url = `${config2.baseUrl}/api/v1${path40}`;
   const headers = {
     Authorization: `Bearer ${config2.apiKey}`,
     "Content-Type": "application/json"
@@ -10218,7 +10218,7 @@ async function wikiFetch(config2, path38, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path38}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path40}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -10327,14 +10327,14 @@ __export(worker_gate_exports, {
   tryAcquireBackfillLock: () => tryAcquireBackfillLock,
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
-import { readdirSync as readdirSync9, writeFileSync as writeFileSync15, unlinkSync as unlinkSync8, mkdirSync as mkdirSync12, existsSync as existsSync24 } from "fs";
-import path31 from "path";
+import { readdirSync as readdirSync9, writeFileSync as writeFileSync17, unlinkSync as unlinkSync8, mkdirSync as mkdirSync14, existsSync as existsSync25 } from "fs";
+import path33 from "path";
 function tryAcquireWorkerSlot() {
   try {
-    mkdirSync12(WORKER_PID_DIR, { recursive: true });
+    mkdirSync14(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path31.join(WORKER_PID_DIR, `${reservationId}.pid`);
-    writeFileSync15(reservationPath, String(process.pid));
+    const reservationPath = path33.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync17(reservationPath, String(process.pid));
     const files = readdirSync9(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
@@ -10351,7 +10351,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync8(path31.join(WORKER_PID_DIR, f));
+          unlinkSync8(path33.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -10374,21 +10374,21 @@ function tryAcquireWorkerSlot() {
 }
 function registerWorkerPid(pid) {
   try {
-    mkdirSync12(WORKER_PID_DIR, { recursive: true });
-    writeFileSync15(path31.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    mkdirSync14(WORKER_PID_DIR, { recursive: true });
+    writeFileSync17(path33.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync8(path31.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync8(path33.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
 function tryAcquireBackfillLock() {
   try {
-    mkdirSync12(WORKER_PID_DIR, { recursive: true });
-    if (existsSync24(BACKFILL_LOCK)) {
+    mkdirSync14(WORKER_PID_DIR, { recursive: true });
+    if (existsSync25(BACKFILL_LOCK)) {
       try {
         const pid = parseInt(
           __require("fs").readFileSync(BACKFILL_LOCK, "utf8").trim(),
@@ -10404,7 +10404,7 @@ function tryAcquireBackfillLock() {
       } catch {
       }
     }
-    writeFileSync15(BACKFILL_LOCK, String(process.pid));
+    writeFileSync17(BACKFILL_LOCK, String(process.pid));
     return true;
   } catch {
     return true;
@@ -10421,9 +10421,9 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path31.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path33.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path31.join(WORKER_PID_DIR, "backfill.lock");
+    BACKFILL_LOCK = path33.join(WORKER_PID_DIR, "backfill.lock");
   }
 });
 
@@ -10446,8 +10446,8 @@ __export(crdt_sync_exports, {
   rebuildFromDb: () => rebuildFromDb
 });
 import * as Y from "yjs";
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync16, existsSync as existsSync27, mkdirSync as mkdirSync13, unlinkSync as unlinkSync9 } from "fs";
-import path34 from "path";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync18, existsSync as existsSync28, mkdirSync as mkdirSync15, unlinkSync as unlinkSync9 } from "fs";
+import path36 from "path";
 import { homedir as homedir5 } from "os";
 function getStatePath() {
   return _statePathOverride ?? DEFAULT_STATE_PATH;
@@ -10459,9 +10459,9 @@ function initCrdtDoc() {
   if (doc) return doc;
   doc = new Y.Doc();
   const sp = getStatePath();
-  if (existsSync27(sp)) {
+  if (existsSync28(sp)) {
     try {
-      const state = readFileSync22(sp);
+      const state = readFileSync24(sp);
       Y.applyUpdate(doc, new Uint8Array(state));
     } catch {
       console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
@@ -10603,10 +10603,10 @@ function persistState() {
   if (!doc) return;
   try {
     const sp = getStatePath();
-    const dir = path34.dirname(sp);
-    if (!existsSync27(dir)) mkdirSync13(dir, { recursive: true });
+    const dir = path36.dirname(sp);
+    if (!existsSync28(dir)) mkdirSync15(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
-    writeFileSync16(sp, Buffer.from(state));
+    writeFileSync18(sp, Buffer.from(state));
   } catch {
   }
 }
@@ -10647,7 +10647,7 @@ var DEFAULT_STATE_PATH, _statePathOverride, doc;
 var init_crdt_sync = __esm({
   "src/lib/crdt-sync.ts"() {
     "use strict";
-    DEFAULT_STATE_PATH = path34.join(homedir5(), ".exe-os", "crdt-state.bin");
+    DEFAULT_STATE_PATH = path36.join(homedir5(), ".exe-os", "crdt-state.bin");
     _statePathOverride = null;
     doc = null;
   }
@@ -10660,8 +10660,8 @@ init_database();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync30, openSync as openSync3, mkdirSync as mkdirSync15, closeSync as closeSync3 } from "fs";
-import path37 from "path";
+import { existsSync as existsSync31, openSync as openSync3, mkdirSync as mkdirSync17, closeSync as closeSync3 } from "fs";
+import path39 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/mcp/tools/recall-my-memory.ts
@@ -11331,10 +11331,10 @@ function registerCreateTask(server2) {
         skipDispatch: true
       });
       try {
-        const { existsSync: existsSync31, mkdirSync: mkdirSync16, writeFileSync: writeFileSync18 } = await import("fs");
+        const { existsSync: existsSync32, mkdirSync: mkdirSync18, writeFileSync: writeFileSync20 } = await import("fs");
         const { identityPath: identityPath2 } = await Promise.resolve().then(() => (init_identity(), identity_exports));
         const idPath = identityPath2(assigned_to);
-        if (!existsSync31(idPath)) {
+        if (!existsSync32(idPath)) {
           const { loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
           const employees = await loadEmployees2();
           const emp = employees.find((e) => e.name === assigned_to);
@@ -11343,8 +11343,8 @@ function registerCreateTask(server2) {
             const template = getTemplateForTitle2(emp.role);
             if (template) {
               const dir = (await import("path")).dirname(idPath);
-              if (!existsSync31(dir)) mkdirSync16(dir, { recursive: true });
-              writeFileSync18(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
+              if (!existsSync32(dir)) mkdirSync18(dir, { recursive: true });
+              writeFileSync20(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
             }
           }
         }
@@ -14689,9 +14689,9 @@ var HostingerApiClient = class {
     }
     this.lastRequestTime = Date.now();
   }
-  async request(method, path38, body) {
+  async request(method, path40, body) {
     await this.rateLimit();
-    const url = `${this.baseUrl}${path38}`;
+    const url = `${this.baseUrl}${path40}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`,
       "Content-Type": "application/json",
@@ -14764,8 +14764,8 @@ async function requestCloudflare(cfApiToken, zoneId, options) {
   }
   return envelope.result;
 }
-function buildUrl(zoneId, path38 = "/dns_records", query) {
-  const normalizedPath = path38.startsWith("/") ? path38 : `/${path38}`;
+function buildUrl(zoneId, path40 = "/dns_records", query) {
+  const normalizedPath = path40.startsWith("/") ? path40 : `/${path40}`;
   const url = new URL(
     `${CLOUDFLARE_API_BASE_URL}/zones/${zoneId}${normalizedPath}`
   );
@@ -15070,9 +15070,455 @@ function buildInventoryRecord(params) {
   };
 }
 
+// src/mcp/tools/export-orchestration.ts
+init_active_agent();
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
+import path29 from "path";
+import { z as z38 } from "zod";
+
+// src/lib/orchestration-package.ts
+init_database();
+init_identity();
+init_platform_procedures();
+import { randomUUID as randomUUID5 } from "crypto";
+import { copyFileSync, existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "fs";
+import os11 from "os";
+import path28 from "path";
+var PACKAGE_VERSION = "1.0";
+var ROSTER_FILENAME = "exe-employees.json";
+var ROSTER_BACKUP_FILENAME = "exe-employees.json.bak";
+var EXE_OS_DIRNAME = ".exe-os";
+var DEFAULT_BEHAVIOR_PRIORITY = "p1";
+var DEFAULT_PROCEDURE_PRIORITY = "p0";
+var DEFAULT_IDENTITY_UPDATED_BY = "orchestration-import";
+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 path28.join(os11.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+}
+function getBackupPath() {
+  return path28.join(os11.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+}
+function readRosterFile() {
+  const rosterPath = getRosterPath();
+  if (!existsSync22(rosterPath)) return [];
+  const raw = readFileSync18(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();
+  mkdirSync12(path28.dirname(rosterPath), { recursive: true });
+  if (existsSync22(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.`
+      );
+    }
+    copyFileSync(rosterPath, getBackupPath());
+  }
+  writeFileSync14(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: [
+        randomUUID5(),
+        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: [
+        randomUUID5(),
+        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))
+  };
+}
+
+// src/mcp/tools/export-orchestration.ts
+init_store();
+function registerExportOrchestration(server2) {
+  server2.registerTool(
+    "export_orchestration",
+    {
+      title: "Export Orchestration",
+      description: "Export roster, identities, behaviors, and customer procedures to a JSON package.",
+      inputSchema: {
+        output_path: z38.string().describe("File path to write the JSON package")
+      }
+    },
+    async ({ output_path }) => {
+      try {
+        await initStore();
+        const pkg = await exportOrchestration(getActiveAgent().agentId);
+        mkdirSync13(path29.dirname(output_path), { recursive: true });
+        writeFileSync15(output_path, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+        return {
+          content: [{
+            type: "text",
+            text: `Exported ${pkg.roster.length} roster entries, ${Object.keys(pkg.identities).length} identities, ${pkg.behaviors.length} behaviors, ${pkg.procedures.length} procedures to ${output_path}`
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: `Failed to export orchestration: ${err instanceof Error ? err.message : String(err)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/import-orchestration.ts
+import { readFileSync as readFileSync19 } from "fs";
+import { z as z39 } from "zod";
+init_store();
+init_active_agent();
+init_employees();
+function registerImportOrchestration(server2) {
+  server2.registerTool(
+    "import_orchestration",
+    {
+      title: "Import Orchestration",
+      description: "Import roster, identities, behaviors, and procedures from an orchestration package. Restricted to coordinator/founder.",
+      inputSchema: {
+        package_path: z39.string().describe("Path to the orchestration package JSON file"),
+        merge_strategy: z39.enum(["replace", "merge"]).default("merge").describe("How to apply the package: both strategies are additive-only \u2014 existing data is never deleted or overwritten")
+      }
+    },
+    async ({ package_path, merge_strategy }) => {
+      try {
+        const caller = getActiveAgent();
+        const allowed = canCoordinate(caller.agentId, caller.agentRole);
+        if (!allowed) {
+          return {
+            content: [{
+              type: "text",
+              text: `Permission denied. Only the coordinator or founder sessions can import orchestration packages. You are "${caller.agentId}".`
+            }],
+            isError: true
+          };
+        }
+        await initStore();
+        const raw = readFileSync19(package_path, "utf-8");
+        const pkg = validatePackage(JSON.parse(raw));
+        const result = await importOrchestration(pkg, merge_strategy);
+        return {
+          content: [{
+            type: "text",
+            text: `Imported ${result.imported.roster} roster entries, ${result.imported.identities} identities, ${result.imported.behaviors} behaviors, ${result.imported.procedures} procedures using ${merge_strategy} strategy`
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: `Failed to import orchestration: ${err instanceof Error ? err.message : String(err)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/mcp/tools/query-conversations.ts
 init_database();
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 function registerQueryConversations(server2) {
   server2.registerTool(
     "query_conversations",
@@ -15080,14 +15526,14 @@ function registerQueryConversations(server2) {
       title: "Query Conversations",
       description: "Search across all adapter messages by content, sender, date range, or platform. Returns messages with source attribution (platform, sender, timestamp).",
       inputSchema: {
-        query: z38.string().optional().describe("Full-text search query across message content and responses"),
-        sender: z38.string().optional().describe("Filter by sender ID or name (partial match)"),
-        platform: z38.string().optional().describe("Filter by platform: whatsapp, signal, telegram, discord, imessage, slack, email, webchat"),
-        after: z38.string().optional().describe("Filter messages after this ISO 8601 date (e.g. 2026-04-01)"),
-        before: z38.string().optional().describe("Filter messages before this ISO 8601 date (e.g. 2026-04-15)"),
-        channel_id: z38.string().optional().describe("Filter by channel/chat ID"),
-        thread_id: z38.string().optional().describe("Filter by conversation thread ID"),
-        limit: z38.number().int().min(1).max(100).optional().default(25).describe("Max results to return (default 25, max 100)")
+        query: z40.string().optional().describe("Full-text search query across message content and responses"),
+        sender: z40.string().optional().describe("Filter by sender ID or name (partial match)"),
+        platform: z40.string().optional().describe("Filter by platform: whatsapp, signal, telegram, discord, imessage, slack, email, webchat"),
+        after: z40.string().optional().describe("Filter messages after this ISO 8601 date (e.g. 2026-04-01)"),
+        before: z40.string().optional().describe("Filter messages before this ISO 8601 date (e.g. 2026-04-15)"),
+        channel_id: z40.string().optional().describe("Filter by channel/chat ID"),
+        thread_id: z40.string().optional().describe("Filter by conversation thread ID"),
+        limit: z40.number().int().min(1).max(100).optional().default(25).describe("Max results to return (default 25, max 100)")
       }
     },
     async (params) => {
@@ -15194,19 +15640,19 @@ function registerQueryConversations(server2) {
 }
 
 // src/mcp/tools/load-skill.ts
-import { z as z39 } from "zod";
-import { readFileSync as readFileSync18, readdirSync as readdirSync8, statSync as statSync3 } from "fs";
-import path28 from "path";
+import { z as z41 } from "zod";
+import { readFileSync as readFileSync20, readdirSync as readdirSync8, statSync as statSync3 } from "fs";
+import path30 from "path";
 import { homedir as homedir2 } from "os";
-var SKILLS_DIR = path28.join(homedir2(), ".claude", "skills");
+var SKILLS_DIR = path30.join(homedir2(), ".claude", "skills");
 function listAvailableSkills() {
   try {
     const entries = readdirSync8(SKILLS_DIR);
     return entries.filter((entry) => {
       try {
-        const entryPath = path28.join(SKILLS_DIR, entry);
+        const entryPath = path30.join(SKILLS_DIR, entry);
         if (!statSync3(entryPath).isDirectory()) return false;
-        const skillFile = path28.join(entryPath, "SKILL.md");
+        const skillFile = path30.join(entryPath, "SKILL.md");
         statSync3(skillFile);
         return true;
       } catch {
@@ -15224,7 +15670,7 @@ function registerLoadSkill(server2) {
       title: "Load Skill",
       description: "Load domain-specific guidance into your context. Use when you need specialized knowledge for a task (e.g., load_skill('seo') before doing SEO work, load_skill('code-reviewer') before reviewing code). Pass skill_name='list' to see all available skills.",
       inputSchema: {
-        skill_name: z39.string().describe(
+        skill_name: z41.string().describe(
           "Skill to load (e.g. 'seo', 'code-reviewer', 'frontend-design'). Pass 'list' to see all available skills."
         )
       }
@@ -15249,10 +15695,10 @@ ${skills.map((s) => `- ${s}`).join("\n")}`
           }]
         };
       }
-      const sanitized = path28.basename(skill_name);
-      const skillFile = path28.join(SKILLS_DIR, sanitized, "SKILL.md");
+      const sanitized = path30.basename(skill_name);
+      const skillFile = path30.join(SKILLS_DIR, sanitized, "SKILL.md");
       try {
-        const content = readFileSync18(skillFile, "utf-8");
+        const content = readFileSync20(skillFile, "utf-8");
         return {
           content: [{
             type: "text",
@@ -15281,7 +15727,7 @@ ${available.map((s) => `- ${s}`).join("\n")}` : "\n\nNo skills found in ~/.claud
 // src/mcp/tools/consolidate-memories.ts
 init_database();
 init_active_agent();
-import { z as z40 } from "zod";
+import { z as z42 } from "zod";
 function registerConsolidateMemories(server2) {
   server2.registerTool(
     "consolidate_memories",
@@ -15289,8 +15735,8 @@ function registerConsolidateMemories(server2) {
       title: "Consolidate Memories",
       description: "Trigger content-aware memory consolidation. Groups recent memories by project, uses LLM to extract key facts, decisions, and patterns, then stores a high-importance summary and archives the originals. Runs automatically during idle time, but can be triggered manually when you want to compress your working memory.",
       inputSchema: {
-        max_clusters: z40.coerce.number().optional().default(5).describe("Maximum number of clusters to consolidate (default 5)"),
-        model: z40.string().optional().describe("LLM model for summarization (defaults to config value)")
+        max_clusters: z42.coerce.number().optional().default(5).describe("Maximum number of clusters to consolidate (default 5)"),
+        model: z42.string().optional().describe("LLM model for summarization (defaults to config value)")
       }
     },
     async ({ max_clusters, model }) => {
@@ -15346,7 +15792,7 @@ Consolidated summaries stored as tier-1 (importance=9) memories.`
 init_global_procedures();
 init_active_agent();
 init_employees();
-import { z as z41 } from "zod";
+import { z as z43 } from "zod";
 function registerStoreGlobalProcedure(server2) {
   server2.registerTool(
     "store_global_procedure",
@@ -15354,10 +15800,10 @@ function registerStoreGlobalProcedure(server2) {
       title: "Store Global Procedure",
       description: "Create an organization-wide procedure (Layer 0) that supersedes identity, expertise, and experience. Use for hard rules that every employee must follow. RESTRICTED: only coordinator or founder sessions.",
       inputSchema: {
-        title: z41.string().describe("Short title for the procedure"),
-        content: z41.string().max(500).describe("The procedure content \u2014 clear, actionable instruction"),
-        priority: z41.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always (default). p1 = standard. p2 = nice-to-have."),
-        domain: z41.string().optional().describe("Category: workflow, code-style, communication, architecture, testing, security")
+        title: z43.string().describe("Short title for the procedure"),
+        content: z43.string().max(500).describe("The procedure content \u2014 clear, actionable instruction"),
+        priority: z43.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always (default). p1 = standard. p2 = nice-to-have."),
+        domain: z43.string().optional().describe("Category: workflow, code-style, communication, architecture, testing, security")
       }
     },
     async ({ title, content, priority, domain }) => {
@@ -15435,7 +15881,7 @@ init_global_procedures();
 init_active_agent();
 init_database();
 init_employees();
-import { z as z42 } from "zod";
+import { z as z44 } from "zod";
 function registerDeactivateGlobalProcedure(server2) {
   server2.registerTool(
     "deactivate_global_procedure",
@@ -15443,7 +15889,7 @@ function registerDeactivateGlobalProcedure(server2) {
       title: "Deactivate Global Procedure",
       description: "Soft-delete a global procedure by setting active = 0. RESTRICTED: only coordinator or founder sessions. Use list_global_procedures to find the procedure ID first.",
       inputSchema: {
-        procedure_id: z42.string().describe("UUID of the global procedure to deactivate")
+        procedure_id: z44.string().describe("UUID of the global procedure to deactivate")
       }
     },
     async ({ procedure_id }) => {
@@ -15498,7 +15944,7 @@ Content: ${row.content}`
 }
 
 // src/mcp/tools/search-everything.ts
-import { z as z43 } from "zod";
+import { z as z45 } from "zod";
 
 // src/lib/unified-search.ts
 var DEFAULT_LIMIT = 10;
@@ -15665,11 +16111,11 @@ function registerSearchEverything(server2) {
       title: "Search Everything",
       description: "Search across all data stores \u2014 memories, conversations, and wiki \u2014 in one query. Returns merged results sorted by relevance with entity links.",
       inputSchema: {
-        query: z43.string().describe("What to search for across all data stores"),
-        sources: z43.array(z43.enum(["memory", "conversations", "wiki"])).optional().describe(
+        query: z45.string().describe("What to search for across all data stores"),
+        sources: z45.array(z45.enum(["memory", "conversations", "wiki"])).optional().describe(
           "Which sources to search (default: all). Options: memory, conversations, wiki"
         ),
-        limit: z43.coerce.number().int().min(1).max(50).optional().default(10).describe("Max results to return (default 10, max 50)")
+        limit: z45.coerce.number().int().min(1).max(50).optional().default(10).describe("Max results to return (default 10, max 50)")
       }
     },
     async (params) => {
@@ -15730,7 +16176,7 @@ init_store();
 init_active_agent();
 init_database();
 init_plan_limits();
-import { z as z44 } from "zod";
+import { z as z46 } from "zod";
 import crypto14 from "crypto";
 function registerStoreDecision(server2) {
   server2.registerTool(
@@ -15739,13 +16185,13 @@ function registerStoreDecision(server2) {
       title: "Store Decision",
       description: "Store an authoritative decision keyed by domain. Use this when a decision is made that should be canonical \u2014 future lookups via get_decision return the latest decision for that domain. Supports supersession chains.",
       inputSchema: {
-        domain: z44.string().describe(
+        domain: z46.string().describe(
           "Domain key, e.g. 'auth-strategy', 'db-migration-approach', 'api-versioning'"
         ),
-        decision: z44.string().describe("The decision text \u2014 what was decided"),
-        rationale: z44.string().optional().describe("Why this decision was made \u2014 constraints, trade-offs, context"),
-        supersedes: z44.string().optional().describe("UUID of the decision this supersedes (previous decision for this domain)"),
-        project_name: z44.string().optional().describe("Project name")
+        decision: z46.string().describe("The decision text \u2014 what was decided"),
+        rationale: z46.string().optional().describe("Why this decision was made \u2014 constraints, trade-offs, context"),
+        supersedes: z46.string().optional().describe("UUID of the decision this supersedes (previous decision for this domain)"),
+        project_name: z46.string().optional().describe("Project name")
       }
     },
     async ({ domain, decision, rationale, supersedes, project_name }) => {
@@ -15813,7 +16259,7 @@ Supersedes: ${supersedes}` : ""}`
 
 // src/mcp/tools/get-decision.ts
 init_database();
-import { z as z45 } from "zod";
+import { z as z47 } from "zod";
 function registerGetDecision(server2) {
   server2.registerTool(
     "get_decision",
@@ -15821,7 +16267,7 @@ function registerGetDecision(server2) {
       title: "Get Decision",
       description: "Retrieve the latest authoritative decision for a domain. Returns the current active decision and the supersession history.",
       inputSchema: {
-        domain: z45.string().describe(
+        domain: z47.string().describe(
           "Domain key to look up, e.g. 'auth-strategy', 'db-migration-approach'"
         )
       }
@@ -15884,15 +16330,15 @@ function registerGetDecision(server2) {
 }
 
 // src/mcp/tools/get-agent-spend.ts
-import { z as z46 } from "zod";
+import { z as z48 } from "zod";
 
 // src/lib/token-spend.ts
 init_database();
 import { readdir } from "fs/promises";
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
-import path29 from "path";
-import os11 from "os";
+import path31 from "path";
+import os12 from "os";
 var MODEL_PRICING = {
   // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
   "claude-opus-4-7": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
@@ -15940,18 +16386,18 @@ async function getAgentSpend(period = "7d") {
   for (const row of result.rows) {
     sessionAgent.set(row.session_uuid, row.agent_id);
   }
-  const claudeDir = path29.join(os11.homedir(), ".claude", "projects");
+  const claudeDir = path31.join(os12.homedir(), ".claude", "projects");
   let projectDirs = [];
   try {
     const entries = await readdir(claudeDir);
-    projectDirs = entries.map((e) => path29.join(claudeDir, e));
+    projectDirs = entries.map((e) => path31.join(claudeDir, e));
   } catch {
     return [];
   }
   const agentTotals = /* @__PURE__ */ new Map();
   for (const [sessionUuid, agentId] of sessionAgent) {
     for (const dir of projectDirs) {
-      const jsonlPath = path29.join(dir, `${sessionUuid}.jsonl`);
+      const jsonlPath = path31.join(dir, `${sessionUuid}.jsonl`);
       try {
         const usage = await extractSessionUsage(jsonlPath);
         if (usage.input === 0 && usage.output === 0) continue;
@@ -16046,8 +16492,8 @@ function registerGetAgentSpend(server2) {
       title: "Get Agent Spend",
       description: "Get per-agent token spend attribution. Shows input, output, and cache tokens consumed by each agent over a time period, with estimated cost.",
       inputSchema: {
-        period: z46.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to query"),
-        agent_id: z46.string().optional().describe("Filter to a specific agent (e.g. 'tom', 'yoshi')")
+        period: z48.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to query"),
+        agent_id: z48.string().optional().describe("Filter to a specific agent (e.g. 'tom', 'yoshi')")
       }
     },
     async ({ period, agent_id }) => {
@@ -16113,7 +16559,7 @@ function registerGetAgentSpend(server2) {
 // src/mcp/tools/get-graph-stats.ts
 init_database();
 init_graph_query();
-import { z as z47 } from "zod";
+import { z as z49 } from "zod";
 function registerGetGraphStats(server2) {
   server2.registerTool(
     "get_graph_stats",
@@ -16121,7 +16567,7 @@ function registerGetGraphStats(server2) {
       title: "Get Graph Stats",
       description: "Get knowledge graph summary statistics: entity count, relationship count, and entity type breakdown.",
       inputSchema: {
-        _dummy: z47.string().optional().describe("Unused \u2014 no input required")
+        _dummy: z49.string().optional().describe("Unused \u2014 no input required")
       }
     },
     async () => {
@@ -16163,7 +16609,7 @@ function registerGetGraphStats(server2) {
 // src/mcp/tools/get-entity-neighbors.ts
 init_database();
 init_graph_query();
-import { z as z48 } from "zod";
+import { z as z50 } from "zod";
 function registerGetEntityNeighbors(server2) {
   server2.registerTool(
     "get_entity_neighbors",
@@ -16171,7 +16617,7 @@ function registerGetEntityNeighbors(server2) {
       title: "Get Entity Neighbors",
       description: "Get connected entities for a given entity name. Returns neighbors with relationship types, directions, and weights.",
       inputSchema: {
-        entity_name: z48.string().describe("Name of the entity to find neighbors for")
+        entity_name: z50.string().describe("Name of the entity to find neighbors for")
       }
     },
     async ({ entity_name }) => {
@@ -16240,7 +16686,7 @@ function registerGetEntityNeighbors(server2) {
 // src/mcp/tools/get-hot-entities.ts
 init_database();
 init_graph_query();
-import { z as z49 } from "zod";
+import { z as z51 } from "zod";
 var PERIOD_MS = {
   "24h": 24 * 60 * 60 * 1e3,
   "7d": 7 * 24 * 60 * 60 * 1e3,
@@ -16253,8 +16699,8 @@ function registerGetHotEntities(server2) {
       title: "Get Hot Entities",
       description: "Get trending entities \u2014 those with the most new relationships in a time period. Surfaces what's most active in the knowledge graph.",
       inputSchema: {
-        period: z49.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to look back"),
-        limit: z49.number().int().min(1).max(50).default(10).describe("Max entities to return")
+        period: z51.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to look back"),
+        limit: z51.number().int().min(1).max(50).default(10).describe("Max entities to return")
       }
     },
     async ({ period, limit }) => {
@@ -16302,7 +16748,7 @@ function registerGetHotEntities(server2) {
 
 // src/mcp/tools/export-graph.ts
 init_database();
-import { z as z50 } from "zod";
+import { z as z52 } from "zod";
 
 // src/lib/graph-export.ts
 async function loadGraphData(client) {
@@ -16515,7 +16961,7 @@ function registerExportGraph(server2) {
       title: "Export Graph",
       description: "Export the knowledge graph as a markdown report (inline) or an interactive HTML visualization (writes file, returns path).",
       inputSchema: {
-        format: z50.enum(["html", "markdown"]).default("markdown").describe("Export format: markdown (inline) or html (file)")
+        format: z52.enum(["html", "markdown"]).default("markdown").describe("Export format: markdown (inline) or html (file)")
       }
     },
     async ({ format }) => {
@@ -16529,12 +16975,12 @@ function registerExportGraph(server2) {
         }
         const html = await exportGraphHTML(client);
         const fs = await import("fs");
-        const path38 = await import("path");
-        const os13 = await import("os");
-        const outDir = path38.join(os13.homedir(), ".exe-os", "exports");
+        const path40 = await import("path");
+        const os14 = await import("os");
+        const outDir = path40.join(os14.homedir(), ".exe-os", "exports");
         fs.mkdirSync(outDir, { recursive: true });
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-        const filePath = path38.join(outDir, `graph-${timestamp}.html`);
+        const filePath = path40.join(outDir, `graph-${timestamp}.html`);
         fs.writeFileSync(filePath, html, "utf-8");
         return {
           content: [
@@ -16565,7 +17011,7 @@ Open in a browser to explore interactively.`
 
 // src/mcp/tools/find-similar-trajectories.ts
 init_skill_learning();
-import { z as z51 } from "zod";
+import { z as z53 } from "zod";
 function registerFindSimilarTrajectories(server2) {
   server2.registerTool(
     "find_similar_trajectories",
@@ -16573,7 +17019,7 @@ function registerFindSimilarTrajectories(server2) {
       title: "Find Similar Trajectories",
       description: 'Find past task trajectories that match a described tool sequence. Input a comma-separated tool sequence (e.g. "Read, Edit, Bash, Read") to find similar past workflows.',
       inputSchema: {
-        description: z51.string().describe(
+        description: z53.string().describe(
           'Tool sequence to match \u2014 comma-separated tool names (e.g. "Read, Grep, Edit, Bash:npm, Bash:git")'
         )
       }
@@ -16644,7 +17090,7 @@ ${withSkill.length} trajectory(s) already extracted into skill(s).`
 
 // src/mcp/tools/get-session-kills.ts
 init_session_kill_telemetry();
-import { z as z52 } from "zod";
+import { z as z54 } from "zod";
 var PERIOD_MS2 = {
   "24h": 24 * 60 * 60 * 1e3,
   "7d": 7 * 24 * 60 * 60 * 1e3,
@@ -16660,7 +17106,7 @@ function registerGetSessionKills(server2) {
       title: "Get Session Kills",
       description: "Get session kill telemetry: how many idle/TTL sessions were killed, tokens saved, and estimated cost savings over a time period.",
       inputSchema: {
-        period: z52.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to query")
+        period: z54.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to query")
       }
     },
     async ({ period }) => {
@@ -16700,7 +17146,7 @@ function registerGetSessionKills(server2) {
 
 // src/mcp/tools/list-agent-sessions.ts
 init_session_registry();
-import { z as z53 } from "zod";
+import { z as z55 } from "zod";
 function registerListAgentSessions(server2) {
   server2.registerTool(
     "list_agent_sessions",
@@ -16708,7 +17154,7 @@ function registerListAgentSessions(server2) {
       title: "List Agent Sessions",
       description: "List all registered agent sessions with their agent ID, project, PID, and registration time.",
       inputSchema: {
-        _placeholder: z53.string().optional().describe("No input required")
+        _placeholder: z55.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -16754,11 +17200,11 @@ function registerListAgentSessions(server2) {
 }
 
 // src/mcp/tools/get-daemon-health.ts
-import { z as z54 } from "zod";
-import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
-import path30 from "path";
+import { z as z56 } from "zod";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
+import path32 from "path";
 import { homedir as homedir3 } from "os";
-var PID_PATH2 = path30.join(homedir3(), ".exe-os", "exed.pid");
+var PID_PATH2 = path32.join(homedir3(), ".exe-os", "exed.pid");
 function formatUptime(seconds) {
   const h = Math.floor(seconds / 3600);
   const m = Math.floor(seconds % 3600 / 60);
@@ -16769,8 +17215,8 @@ function formatUptime(seconds) {
 }
 function isDaemonAlive() {
   try {
-    if (!existsSync22(PID_PATH2)) return { alive: false, pid: null };
-    const pid = parseInt(readFileSync19(PID_PATH2, "utf8").trim(), 10);
+    if (!existsSync23(PID_PATH2)) return { alive: false, pid: null };
+    const pid = parseInt(readFileSync21(PID_PATH2, "utf8").trim(), 10);
     if (isNaN(pid) || pid <= 0) return { alive: false, pid: null };
     process.kill(pid, 0);
     return { alive: true, pid };
@@ -16785,7 +17231,7 @@ function registerGetDaemonHealth(server2) {
       title: "Get Daemon Health",
       description: "Check the embedding daemon (exed) health: whether it's running, its PID, uptime, and requests served.",
       inputSchema: {
-        _placeholder: z54.string().optional().describe("No input required")
+        _placeholder: z56.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -16837,14 +17283,14 @@ function registerGetDaemonHealth(server2) {
 // src/mcp/tools/get-auto-wake-status.ts
 init_database();
 init_session_registry();
-import { z as z55 } from "zod";
+import { z as z57 } from "zod";
 
 // src/lib/daemon-orchestration.ts
 init_tmux_routing();
 init_task_scope();
 init_employees();
 import { execSync as execSync10 } from "child_process";
-import { existsSync as existsSync23, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join2 } from "path";
 var IDLE_NUDGE_DEDUP_MS = Number(process.env.EXE_NUDGE_INTERVAL_MS) || 6e4;
@@ -16865,7 +17311,7 @@ function registerGetAutoWakeStatus(server2) {
       title: "Get Auto-Wake Status",
       description: "Check auto-wake status: orphaned tasks (assigned agent has no running session), tasks blocked by auto-wake retry limit, and session activity.",
       inputSchema: {
-        _placeholder: z55.string().optional().describe("No input required")
+        _placeholder: z57.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -16946,16 +17392,16 @@ function registerGetAutoWakeStatus(server2) {
 // src/mcp/tools/get-worker-gate.ts
 init_worker_gate();
 init_config();
-import { z as z56 } from "zod";
-import { readdirSync as readdirSync10, existsSync as existsSync25 } from "fs";
-import path32 from "path";
-var WORKER_PID_DIR2 = path32.join(EXE_AI_DIR, "worker-pids");
+import { z as z58 } from "zod";
+import { readdirSync as readdirSync10, existsSync as existsSync26 } from "fs";
+import path34 from "path";
+var WORKER_PID_DIR2 = path34.join(EXE_AI_DIR, "worker-pids");
 function countAliveWorkers() {
   let alive = 0;
   let stale = 0;
   let reservations = 0;
   try {
-    if (!existsSync25(WORKER_PID_DIR2)) return { alive: 0, stale: 0, reservations: 0 };
+    if (!existsSync26(WORKER_PID_DIR2)) return { alive: 0, stale: 0, reservations: 0 };
     const files = readdirSync10(WORKER_PID_DIR2);
     for (const f of files) {
       if (!f.endsWith(".pid")) continue;
@@ -16984,7 +17430,7 @@ function registerGetWorkerGate(server2) {
       title: "Get Worker Gate",
       description: "Check worker concurrency gate status: how many worker slots are in use, the maximum allowed, and whether new workers can spawn.",
       inputSchema: {
-        _placeholder: z56.string().optional().describe("No input required")
+        _placeholder: z58.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -17020,12 +17466,12 @@ function registerGetWorkerGate(server2) {
 
 // src/mcp/tools/run-memory-audit.ts
 init_database();
-import { z as z57 } from "zod";
+import { z as z59 } from "zod";
 
 // src/bin/exe-doctor.ts
 init_store();
 init_database();
-import os12 from "os";
+import os13 from "os";
 
 // src/lib/is-main.ts
 import { realpathSync } from "fs";
@@ -17043,10 +17489,10 @@ function isMainModule(importMetaUrl) {
 }
 
 // src/bin/exe-doctor.ts
-import { existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
 import { spawn as spawn2 } from "child_process";
-import path33 from "path";
-import { randomUUID as randomUUID6 } from "crypto";
+import path35 from "path";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/lib/conflict-detector.ts
 var DEFAULT_MAX_PAIRS = 100;
@@ -17448,7 +17894,7 @@ async function auditOrphanedProjects(client) {
   for (const row of result.rows) {
     const name = row.project_name;
     const count = Number(row.cnt);
-    const exists = existsSync26(path33.join(home, name)) || existsSync26(path33.join(home, "..", name)) || existsSync26(path33.join(process.cwd(), "..", name));
+    const exists = existsSync27(path35.join(home, name)) || existsSync27(path35.join(home, "..", name)) || existsSync27(path35.join(process.cwd(), "..", name));
     if (!exists) {
       orphans.push({ project_name: name, count });
     }
@@ -17456,18 +17902,18 @@ async function auditOrphanedProjects(client) {
   return orphans;
 }
 function auditHookHealth() {
-  const logPath = path33.join(
+  const logPath = path35.join(
     process.env.HOME ?? process.env.USERPROFILE ?? "",
     ".exe-os",
     "logs",
     "hooks.log"
   );
-  if (!existsSync26(logPath)) {
+  if (!existsSync27(logPath)) {
     return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
   }
   let content;
   try {
-    content = readFileSync21(logPath, "utf-8");
+    content = readFileSync23(logPath, "utf-8");
   } catch {
     return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
   }
@@ -17542,7 +17988,7 @@ function formatReport(report, flags) {
     }
     lines.push("");
   }
-  const totalMemGB = os12.totalmem() / (1024 * 1024 * 1024);
+  const totalMemGB = os13.totalmem() / (1024 * 1024 * 1024);
   const isLowMemSystem = totalMemGB <= 8;
   if (isLowMemSystem && report.nullVectors > 0) {
     lines.push(`\u{1F7E2} Null vectors:     ${fmtNum(report.nullVectors)} / ${fmtNum(s.total)} (expected \u2014 8GB system, keyword search mode)`);
@@ -17664,7 +18110,7 @@ async function fixNullVectors() {
     }
   }
   const npmRoot = (await import("child_process")).execSync("npm root -g", { encoding: "utf8" }).trim();
-  const backfillPath = path33.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
+  const backfillPath = path35.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
   return new Promise((resolve, reject) => {
     const child = spawn2("node", [backfillPath], { stdio: "inherit" });
     if (child.pid) registerWorkerPid2(child.pid);
@@ -17720,7 +18166,7 @@ async function fixBloated(client, bloated, dryRun) {
                tool_name, project_name, has_error, raw_text, vector, version, consolidated)
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, 0, 0)`,
       args: [
-        randomUUID6(),
+        randomUUID7(),
         row.agent_id,
         row.agent_role,
         row.session_id,
@@ -17824,8 +18270,8 @@ function registerRunMemoryAudit(server2) {
       title: "Run Memory Audit",
       description: "Run a memory health audit: total counts, per-agent breakdown, null vectors, duplicates, FTS sync status, bloated records, and conflict detection (contradictory/superseded memories).",
       inputSchema: {
-        agent_id: z57.string().optional().describe("Filter audit to a specific agent"),
-        project_name: z57.string().optional().describe("Filter audit to a specific project")
+        agent_id: z59.string().optional().describe("Filter audit to a specific agent"),
+        project_name: z59.string().optional().describe("Filter audit to a specific project")
       }
     },
     async ({ agent_id, project_name }) => {
@@ -17858,13 +18304,13 @@ function registerRunMemoryAudit(server2) {
 }
 
 // src/mcp/tools/cloud-sync.ts
-import { z as z58 } from "zod";
+import { z as z60 } from "zod";
 
 // src/lib/cloud-sync.ts
 init_database();
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync17, existsSync as existsSync28, readdirSync as readdirSync11, mkdirSync as mkdirSync14, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync19, existsSync as existsSync29, readdirSync as readdirSync11, mkdirSync as mkdirSync16, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto16 from "crypto";
-import path35 from "path";
+import path37 from "path";
 import { homedir as homedir6 } from "os";
 
 // src/lib/crypto.ts
@@ -17938,7 +18384,7 @@ function sqlSafe(v) {
 }
 function logError(msg) {
   try {
-    const logPath = path35.join(homedir6(), ".exe-os", "workers.log");
+    const logPath = path37.join(homedir6(), ".exe-os", "workers.log");
     appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -17947,24 +18393,24 @@ function logError(msg) {
 var LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
 var FETCH_TIMEOUT_MS4 = 3e4;
 var PUSH_BATCH_SIZE = 5e3;
-var ROSTER_LOCK_PATH = path35.join(EXE_AI_DIR, "roster-merge.lock");
+var ROSTER_LOCK_PATH = path37.join(EXE_AI_DIR, "roster-merge.lock");
 var LOCK_STALE_MS = 3e4;
 async function withRosterLock(fn) {
   try {
     const fd = openSync2(ROSTER_LOCK_PATH, "wx");
     closeSync2(fd);
-    writeFileSync17(ROSTER_LOCK_PATH, String(Date.now()));
+    writeFileSync19(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts2 = parseInt(readFileSync23(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts2 = parseInt(readFileSync25(ROSTER_LOCK_PATH, "utf-8"), 10);
         if (Date.now() - ts2 < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
         unlinkSync10(ROSTER_LOCK_PATH);
         const fd = openSync2(ROSTER_LOCK_PATH, "wx");
         closeSync2(fd);
-        writeFileSync17(ROSTER_LOCK_PATH, String(Date.now()));
+        writeFileSync19(ROSTER_LOCK_PATH, String(Date.now()));
       } catch (retryErr) {
         if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
@@ -18338,8 +18784,8 @@ async function cloudSync(config2) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path35.join(EXE_AI_DIR, "identity");
-    if (existsSync28(idDir)) {
+    const idDir = path37.join(EXE_AI_DIR, "identity");
+    if (existsSync29(idDir)) {
       rosterResult.identities = readdirSync11(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
@@ -18357,49 +18803,49 @@ async function cloudSync(config2) {
     roster: rosterResult
   };
 }
-var ROSTER_DELETIONS_PATH = path35.join(EXE_AI_DIR, "roster-deletions.json");
+var ROSTER_DELETIONS_PATH = path37.join(EXE_AI_DIR, "roster-deletions.json");
 function consumeRosterDeletions() {
   try {
-    if (!existsSync28(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync23(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync17(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync29(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync25(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync19(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
     return [];
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path35.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path35.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path35.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path37.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path37.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path37.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync28(rosterPath)) {
+  if (existsSync29(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync23(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync25(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync28(identityDir)) {
+  if (existsSync29(identityDir)) {
     for (const file of readdirSync11(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync23(path35.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync25(path37.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config2;
-  if (existsSync28(configPath)) {
+  if (existsSync29(configPath)) {
     try {
-      config2 = JSON.parse(readFileSync23(configPath, "utf-8"));
+      config2 = JSON.parse(readFileSync25(configPath, "utf-8"));
     } catch {
     }
   }
   let agentConfig;
-  const agentConfigPath = path35.join(EXE_AI_DIR, "agent-config.json");
-  if (existsSync28(agentConfigPath)) {
+  const agentConfigPath = path37.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync29(agentConfigPath)) {
     try {
-      agentConfig = JSON.parse(readFileSync23(agentConfigPath, "utf-8"));
+      agentConfig = JSON.parse(readFileSync25(agentConfigPath, "utf-8"));
     } catch {
     }
   }
@@ -18475,23 +18921,23 @@ async function cloudPullRoster(config2) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path35.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path37.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync28(cfgPath)) {
+  if (existsSync29(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync23(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync25(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path35.dirname(cfgPath);
-  if (!existsSync28(dir)) mkdirSync14(dir, { recursive: true });
-  writeFileSync17(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  const dir = path37.dirname(cfgPath);
+  if (!existsSync29(dir)) mkdirSync16(dir, { recursive: true });
+  writeFileSync19(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path35.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path37.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -18512,15 +18958,15 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync28(identityDir)) mkdirSync14(identityDir, { recursive: true });
-        const idPath = path35.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync29(identityDir)) mkdirSync16(identityDir, { recursive: true });
+        const idPath = path37.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync28(idPath) ? readFileSync23(idPath, "utf-8") : null;
+          localIdentity = existsSync29(idPath) ? readFileSync25(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
-          writeFileSync17(idPath, remoteIdentity, "utf-8");
+          writeFileSync19(idPath, remoteIdentity, "utf-8");
           identitiesUpdated++;
         }
       }
@@ -18546,16 +18992,16 @@ async function mergeRosterFromRemote(remote, paths) {
     }
     if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
       try {
-        const agentConfigPath = path35.join(EXE_AI_DIR, "agent-config.json");
+        const agentConfigPath = path37.join(EXE_AI_DIR, "agent-config.json");
         let local = {};
-        if (existsSync28(agentConfigPath)) {
+        if (existsSync29(agentConfigPath)) {
           try {
-            local = JSON.parse(readFileSync23(agentConfigPath, "utf-8"));
+            local = JSON.parse(readFileSync25(agentConfigPath, "utf-8"));
           } catch {
           }
         }
         const merged = { ...remote.agentConfig, ...local };
-        writeFileSync17(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        writeFileSync19(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       } catch {
       }
     }
@@ -18989,7 +19435,7 @@ function registerCloudSync(server2) {
       title: "Cloud Sync",
       description: "Trigger a cloud sync cycle \u2014 pulls remote changes then pushes local. Reports pushed/pulled counts for memories, behaviors, graph, tasks, and more.",
       inputSchema: {
-        force: z58.boolean().default(false).describe("Force sync even if recently synced")
+        force: z60.boolean().default(false).describe("Force sync even if recently synced")
       }
     },
     async () => {
@@ -19042,7 +19488,7 @@ function registerCloudSync(server2) {
 
 // src/mcp/tools/get-memory-cardinality.ts
 init_database();
-import { z as z59 } from "zod";
+import { z as z61 } from "zod";
 function registerGetMemoryCardinality(server2) {
   server2.registerTool(
     "get_memory_cardinality",
@@ -19050,7 +19496,7 @@ function registerGetMemoryCardinality(server2) {
       title: "Get Memory Cardinality",
       description: "Get memory counts: total active memories and per-project breakdown. Optionally filter by agent.",
       inputSchema: {
-        agent_id: z59.string().optional().describe("Filter to a specific agent (e.g. 'tom', 'exe')")
+        agent_id: z61.string().optional().describe("Filter to a specific agent (e.g. 'tom', 'exe')")
       }
     },
     async ({ agent_id }) => {
@@ -19133,7 +19579,7 @@ function registerGetMemoryCardinality(server2) {
 init_database();
 init_consolidation();
 init_config();
-import { z as z60 } from "zod";
+import { z as z62 } from "zod";
 function registerRunConsolidation(server2) {
   server2.registerTool(
     "run_consolidation",
@@ -19141,7 +19587,7 @@ function registerRunConsolidation(server2) {
       title: "Run Consolidation",
       description: "Run memory consolidation \u2014 synthesizes unconsolidated memories into meta-insights. Use dry_run=true (default) to preview without executing.",
       inputSchema: {
-        dry_run: z60.boolean().default(true).describe("Preview mode \u2014 show what would be consolidated without doing it")
+        dry_run: z62.boolean().default(true).describe("Preview mode \u2014 show what would be consolidated without doing it")
       }
     },
     async ({ dry_run }) => {
@@ -19210,7 +19656,7 @@ function registerRunConsolidation(server2) {
 
 // src/mcp/tools/get-license-status.ts
 init_license();
-import { z as z61 } from "zod";
+import { z as z63 } from "zod";
 var FEATURES = [
   "cloud_sync",
   "external_agents",
@@ -19224,7 +19670,7 @@ function registerGetLicenseStatus(server2) {
       title: "Get License Status",
       description: "Get current license status: plan, validity, feature gates, limits, and expiry.",
       inputSchema: {
-        _dummy: z61.string().optional().describe("Unused \u2014 no input required")
+        _dummy: z63.string().optional().describe("Unused \u2014 no input required")
       }
     },
     async () => {
@@ -19276,16 +19722,16 @@ function registerGetLicenseStatus(server2) {
 }
 
 // src/mcp/tools/people-roster.ts
-import { z as z62 } from "zod";
+import { z as z64 } from "zod";
 
 // src/lib/people.ts
 init_config();
 import { readFile as readFile5, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
-import path36 from "path";
-var PEOPLE_PATH = path36.join(EXE_AI_DIR, "people.json");
+import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
+import path38 from "path";
+var PEOPLE_PATH = path38.join(EXE_AI_DIR, "people.json");
 async function loadPeople() {
-  if (!existsSync29(PEOPLE_PATH)) return [];
+  if (!existsSync30(PEOPLE_PATH)) return [];
   try {
     const raw = await readFile5(PEOPLE_PATH, "utf-8");
     return JSON.parse(raw);
@@ -19294,7 +19740,7 @@ async function loadPeople() {
   }
 }
 async function savePeople(people) {
-  await mkdir5(path36.dirname(PEOPLE_PATH), { recursive: true });
+  await mkdir5(path38.dirname(PEOPLE_PATH), { recursive: true });
   await writeFile6(PEOPLE_PATH, JSON.stringify(people, null, 2) + "\n", "utf-8");
 }
 async function addPerson(person) {
@@ -19324,10 +19770,10 @@ function registerAddPerson(server2) {
       title: "Add Person",
       description: "Add or update a key human in the people roster. Used for co-founders, partners, customers \u2014 anyone agents need to know about.",
       inputSchema: {
-        name: z62.string().describe("Person's name"),
-        role: z62.string().describe("Their role (e.g. co-founder, customer, partner)"),
-        relationship: z62.string().describe("Relationship to the organization (e.g. co-founder, early adopter, investor)"),
-        notes: z62.string().optional().describe("Additional context about this person")
+        name: z64.string().describe("Person's name"),
+        role: z64.string().describe("Their role (e.g. co-founder, customer, partner)"),
+        relationship: z64.string().describe("Relationship to the organization (e.g. co-founder, early adopter, investor)"),
+        notes: z64.string().optional().describe("Additional context about this person")
       }
     },
     async ({ name, role, relationship, notes }) => {
@@ -19373,7 +19819,7 @@ function registerGetPerson(server2) {
       title: "Get Person",
       description: "Look up a specific person by name from the people roster.",
       inputSchema: {
-        name: z62.string().describe("Person's name to look up")
+        name: z64.string().describe("Person's name to look up")
       }
     },
     async ({ name }) => {
@@ -19401,7 +19847,7 @@ init_active_agent();
 init_agent_config();
 init_runtime_table();
 init_employees();
-import { z as z63 } from "zod";
+import { z as z65 } from "zod";
 function registerSetAgentConfig(server2) {
   server2.registerTool(
     "set_agent_config",
@@ -19409,9 +19855,9 @@ function registerSetAgentConfig(server2) {
       title: "Set Agent Config",
       description: "Set or view per-agent runtime + model configuration. Controls which runtime (claude, codex, opencode) and model each agent uses when dispatched. COO-only. Omit runtime/model to view current config for an agent or all agents.",
       inputSchema: {
-        agent_id: z63.string().optional().describe("Agent name, or 'default' for org-wide default. Omit to view all agents."),
-        runtime: z63.string().optional().describe(`Runtime: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`),
-        model: z63.string().optional().describe("Model name (e.g. claude-opus-4, gpt-5.4, anthropic/claude-sonnet-4-6)")
+        agent_id: z65.string().optional().describe("Agent name, or 'default' for org-wide default. Omit to view all agents."),
+        runtime: z65.string().optional().describe(`Runtime: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`),
+        model: z65.string().optional().describe("Model name (e.g. claude-opus-4, gpt-5.4, anthropic/claude-sonnet-4-6)")
       }
     },
     async ({ agent_id, runtime, model }) => {
@@ -19604,6 +20050,8 @@ registerListWikiPages(server);
 registerGetWikiPage(server);
 registerUpdateWikiPage(server);
 registerDeployClient(server);
+registerExportOrchestration(server);
+registerImportOrchestration(server);
 registerQueryConversations(server);
 registerLoadSkill(server);
 registerConsolidateMemories(server);
@@ -19695,14 +20143,14 @@ try {
 `
       );
       const thisFile = fileURLToPath5(import.meta.url);
-      const backfillPath = path37.resolve(
-        path37.dirname(thisFile),
+      const backfillPath = path39.resolve(
+        path39.dirname(thisFile),
         "../bin/backfill-vectors.js"
       );
-      if (existsSync30(backfillPath)) {
+      if (existsSync31(backfillPath)) {
         const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const logPath = path37.join(exeDir, "workers.log");
-        mkdirSync15(path37.dirname(logPath), { recursive: true });
+        const logPath = path39.join(exeDir, "workers.log");
+        mkdirSync17(path39.dirname(logPath), { recursive: true });
         let logFd = "ignore";
         try {
           logFd = openSync3(logPath, "a");