@askexenow/exe-os 0.9.140 → 0.9.142

package/dist/{chunk-UEWGUOXB.js → chunk-55LEDLDE.js}

@@ -1,17 +1,23 @@
 import {
   init_db_backup,
   listBackups
-} from "./chunk-7SVGVGE3.js";
+} from "./chunk-5UCBVXKO.js";
 import {
   EMBEDDING_DIM,
   init_memory
 } from "./chunk-4NYQAS33.js";
 import {
-  getCoordinatorName,
-  init_employees
-} from "./chunk-ZHJNMC4W.js";
+  EXE_AI_DIR,
+  init_config
+} from "./chunk-VA42PIIY.js";
 import {
-  __esm
+  atomicWriteJson,
+  init_secure_files
+} from "./chunk-FZ23OZL3.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
 } from "./chunk-KFQGP6VL.js";
 
 // src/lib/db-retry.ts
@@ -69,9 +75,418 @@ var init_db_retry = __esm({
   }
 });
 
-// src/lib/database-adapter.ts
-import os from "os";
+// src/lib/identity.ts
+var identity_exports = {};
+__export(identity_exports, {
+  getIdentity: () => getIdentity,
+  getIdentityInjection: () => getIdentityInjection,
+  identityPath: () => identityPath,
+  listIdentities: () => listIdentities,
+  updateIdentity: () => updateIdentity
+});
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { readdirSync } from "fs";
 import path from "path";
+import { createHash } from "crypto";
+function ensureDir() {
+  if (!existsSync(IDENTITY_DIR)) {
+    mkdirSync(IDENTITY_DIR, { recursive: true });
+  }
+}
+function identityPath(agentId) {
+  return path.join(IDENTITY_DIR, `${agentId}.md`);
+}
+function sanitizeIdentityBody(body) {
+  return body.replace(/<!--[\s\S]*?-->/g, "").trim();
+}
+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: sanitizeIdentityBody(raw)
+    };
+  }
+  const yamlStr = match[1];
+  const body = sanitizeIdentityBody(match[2]);
+  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 createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function getIdentity(agentId) {
+  const filePath = identityPath(agentId);
+  if (!existsSync(filePath)) return null;
+  const raw = readFileSync(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);
+  writeFileSync(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 = readdirSync(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,
+      // User-facing/team-facing title only. `frontmatter.role` is internal
+      // routing metadata and must not leak as an external title.
+      title: identity.frontmatter.title,
+      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"() {
+    init_config();
+    init_database();
+    IDENTITY_DIR = path.join(EXE_AI_DIR, "identity");
+  }
+});
+
+// src/lib/employees.ts
+var employees_exports = {};
+__export(employees_exports, {
+  COORDINATOR_ROLE: () => COORDINATOR_ROLE,
+  DEFAULT_COORDINATOR_TEMPLATE_NAME: () => DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  EMPLOYEES_PATH: () => EMPLOYEES_PATH,
+  addEmployee: () => addEmployee,
+  baseAgentName: () => baseAgentName,
+  canCoordinate: () => canCoordinate,
+  getCoordinatorDisplayTitle: () => getCoordinatorDisplayTitle,
+  getCoordinatorEmployee: () => getCoordinatorEmployee,
+  getCoordinatorName: () => getCoordinatorName,
+  getEmployee: () => getEmployee,
+  getEmployeeByRole: () => getEmployeeByRole,
+  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
+  hasRole: () => hasRole,
+  hireEmployee: () => hireEmployee,
+  isCoordinatorName: () => isCoordinatorName,
+  isCoordinatorRole: () => isCoordinatorRole,
+  isMultiInstance: () => isMultiInstance,
+  loadEmployees: () => loadEmployees,
+  loadEmployeesSync: () => loadEmployeesSync,
+  normalizeRole: () => normalizeRole,
+  normalizeRosterCase: () => normalizeRosterCase,
+  registerBinSymlinks: () => registerBinSymlinks,
+  saveEmployees: () => saveEmployees,
+  validateEmployeeName: () => validateEmployeeName
+});
+import { readFile, mkdir } from "fs/promises";
+import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { execSync } from "child_process";
+import path2 from "path";
+import os from "os";
+function normalizeRole(role) {
+  return (role ?? "").trim().toLowerCase();
+}
+function isCoordinatorRole(role) {
+  return normalizeRole(role) === normalizeRole(COORDINATOR_ROLE);
+}
+function getCoordinatorEmployee(employees) {
+  return employees.find((e) => isCoordinatorRole(e.role));
+}
+function getCoordinatorName(employees = loadEmployeesSync()) {
+  return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+}
+function getCoordinatorDisplayTitle(employees = loadEmployeesSync()) {
+  const coordinator = getCoordinatorEmployee(employees);
+  if (coordinator) {
+    try {
+      const { getIdentity: getIdentity2 } = (init_identity(), __toCommonJS(identity_exports));
+      const identity = getIdentity2(coordinator.name);
+      if (identity?.title) return identity.title;
+    } catch {
+    }
+  }
+  return "Coordinator";
+}
+function isCoordinatorName(agentName, employees = loadEmployeesSync()) {
+  if (!agentName) return false;
+  return agentName.toLowerCase() === getCoordinatorName(employees).toLowerCase();
+}
+function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
+  return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
+}
+function validateEmployeeName(name) {
+  if (!name) {
+    return { valid: false, error: "Name is required" };
+  }
+  if (name.length > 32) {
+    return { valid: false, error: "Name must be 32 characters or fewer" };
+  }
+  if (!/^[a-z][a-z0-9]*$/.test(name)) {
+    return {
+      valid: false,
+      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
+    };
+  }
+  return { valid: true };
+}
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
+  await mkdir(path2.dirname(employeesPath), { recursive: true });
+  await atomicWriteJson(employeesPath, employees);
+}
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+function getEmployeeByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.find((e) => e.role.toLowerCase() === lower);
+}
+function getEmployeeNamesByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.filter((e) => e.role.toLowerCase() === lower).map((e) => e.name);
+}
+function hasRole(agentName, role) {
+  const employees = loadEmployeesSync();
+  const emp = getEmployee(employees, agentName);
+  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
+}
+function baseAgentName(name, employees) {
+  const match = name.match(/^([a-zA-Z]+)\d+$/);
+  if (!match) return name;
+  const base = match[1];
+  const roster = employees ?? loadEmployeesSync();
+  if (getEmployee(roster, base)) return base;
+  return name;
+}
+function isMultiInstance(agentName, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
+function addEmployee(employees, employee) {
+  const { systemPrompt: _legacyPrompt, ...rest } = employee;
+  const normalized = { ...rest, name: employee.name.toLowerCase() };
+  if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
+    throw new Error(`Employee '${normalized.name}' already exists`);
+  }
+  return [...employees, normalized];
+}
+function appendToCoordinatorTeam(employee) {
+  const coordinator = getCoordinatorEmployee(loadEmployeesSync());
+  if (!coordinator) return;
+  const idPath = path2.join(IDENTITY_DIR2, `${coordinator.name}.md`);
+  if (!existsSync2(idPath)) return;
+  const content = readFileSync2(idPath, "utf-8");
+  if (content.includes(`**${capitalize(employee.name)}`)) return;
+  const teamMatch = content.match(TEAM_SECTION_RE);
+  if (!teamMatch || teamMatch.index === void 0) return;
+  const afterTeam = content.slice(teamMatch.index + teamMatch[0].length);
+  const nextHeading = afterTeam.match(/\n## /);
+  const entry = `
+**${capitalize(employee.name)} (${employee.role}):** Newly hired. Update this description as the role develops.
+`;
+  let updated;
+  if (nextHeading && nextHeading.index !== void 0) {
+    const insertAt = teamMatch.index + teamMatch[0].length + nextHeading.index;
+    updated = content.slice(0, insertAt) + entry + content.slice(insertAt);
+  } else {
+    updated = content.trimEnd() + "\n" + entry;
+  }
+  writeFileSync2(idPath, updated, "utf-8");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+async function hireEmployee(employee) {
+  const employees = await loadEmployees();
+  const updated = addEmployee(employees, employee);
+  await saveEmployees(updated);
+  try {
+    appendToCoordinatorTeam(employee);
+  } catch {
+  }
+  try {
+    const { loadAgentConfig, saveAgentConfig } = await import("./lib/agent-config.js");
+    const config = loadAgentConfig();
+    const name = employee.name.toLowerCase();
+    if (!config[name] && config["default"]) {
+      config[name] = { ...config["default"] };
+      saveAgentConfig(config);
+    }
+  } catch {
+  }
+  return updated;
+}
+async function normalizeRosterCase(rosterPath) {
+  const employees = await loadEmployees(rosterPath);
+  let changed = false;
+  for (const emp of employees) {
+    if (emp.name !== emp.name.toLowerCase()) {
+      const oldName = emp.name;
+      emp.name = emp.name.toLowerCase();
+      changed = true;
+      try {
+        const identityDir = path2.join(os.homedir(), ".exe-os", "identity");
+        const oldPath = path2.join(identityDir, `${oldName}.md`);
+        const newPath = path2.join(identityDir, `${emp.name}.md`);
+        if (existsSync2(oldPath) && !existsSync2(newPath)) {
+          renameSync(oldPath, newPath);
+        } else if (existsSync2(oldPath) && oldPath !== newPath) {
+          const content = readFileSync2(oldPath, "utf-8");
+          writeFileSync2(newPath, content, "utf-8");
+          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
+            unlinkSync(oldPath);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (changed) {
+    await saveEmployees(employees, rosterPath);
+  }
+  return changed;
+}
+function findExeBin() {
+  try {
+    return execSync(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  const exeBinPath = findExeBin();
+  if (!exeBinPath) {
+    errors.push("Could not find 'exe-os' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path2.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path2.join(binDir, linkName);
+    if (existsSync2(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES, IDENTITY_DIR2, TEAM_SECTION_RE;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
+    init_secure_files();
+    init_config();
+    EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
+    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
+    COORDINATOR_ROLE = "COO";
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+    IDENTITY_DIR2 = path2.join(EXE_AI_DIR, "identity");
+    TEAM_SECTION_RE = /^## Team\b.*$/m;
+  }
+});
+
+// src/lib/database-adapter.ts
+import os2 from "os";
+import path3 from "path";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
 function quotedIdentifier(identifier) {
@@ -382,8 +797,8 @@ async function loadPrismaClient() {
         }
         return new PrismaClient2();
       }
-      const exeDbRoot = process.env.EXE_DB_ROOT ?? path.join(os.homedir(), "exe-db");
-      const requireFromExeDb = createRequire(path.join(exeDbRoot, "package.json"));
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path3.join(os2.homedir(), "exe-db");
+      const requireFromExeDb = createRequire(path3.join(exeDbRoot, "package.json"));
       const prismaEntry = requireFromExeDb.resolve("@prisma/client");
       const module = await import(pathToFileURL(prismaEntry).href);
       const PrismaClient = module.PrismaClient ?? module.default?.PrismaClient;
@@ -653,7 +1068,21 @@ var init_database_adapter = __esm({
 });
 
 // src/lib/database.ts
-import { chmodSync, existsSync, statSync, copyFileSync, unlinkSync, openSync, closeSync, mkdirSync, renameSync } from "fs";
+var database_exports = {};
+__export(database_exports, {
+  SOFT_DELETE_RETENTION_DAYS: () => SOFT_DELETE_RETENTION_DAYS,
+  disposeDatabase: () => disposeDatabase,
+  disposeTurso: () => disposeTurso,
+  ensureSchema: () => ensureSchema,
+  getClient: () => getClient,
+  getRawClient: () => getRawClient,
+  initDaemonClient: () => initDaemonClient,
+  initDatabase: () => initDatabase,
+  initTurso: () => initTurso,
+  isInitialized: () => isInitialized,
+  setExternalClient: () => setExternalClient
+});
+import { chmodSync, existsSync as existsSync3, statSync, copyFileSync, unlinkSync as unlinkSync2, openSync, closeSync, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "fs";
 import { createClient } from "@libsql/client";
 import { homedir } from "os";
 import { join } from "path";
@@ -666,7 +1095,7 @@ function logCatchDebug(context, err) {
   }
 }
 function acquireDbLock() {
-  mkdirSync(join(homedir(), ".exe-os"), { recursive: true });
+  mkdirSync2(join(homedir(), ".exe-os"), { recursive: true });
   try {
     _lockFd = openSync(DB_LOCK_PATH, "wx");
   } catch (err) {
@@ -674,7 +1103,7 @@ function acquireDbLock() {
       try {
         const lockStat = statSync(DB_LOCK_PATH);
         if (Date.now() - lockStat.mtimeMs > 6e4) {
-          unlinkSync(DB_LOCK_PATH);
+          unlinkSync2(DB_LOCK_PATH);
           _lockFd = openSync(DB_LOCK_PATH, "wx");
           return;
         }
@@ -699,7 +1128,7 @@ function releaseDbLock() {
     _lockFd = null;
   }
   try {
-    unlinkSync(DB_LOCK_PATH);
+    unlinkSync2(DB_LOCK_PATH);
   } catch (e) {
     logCatchDebug("lock unlink", e);
   }
@@ -736,12 +1165,12 @@ async function _attemptBackupRestore(config) {
   const timestamp = Date.now();
   const corruptPath = `${config.dbPath}.corrupt-${timestamp}`;
   try {
-    renameSync(config.dbPath, corruptPath);
+    renameSync2(config.dbPath, corruptPath);
     for (const suffix of ["-wal", "-shm"]) {
       const sidePath = config.dbPath + suffix;
-      if (existsSync(sidePath)) {
+      if (existsSync3(sidePath)) {
         try {
-          renameSync(sidePath, corruptPath + suffix);
+          renameSync2(sidePath, corruptPath + suffix);
         } catch {
         }
       }
@@ -765,7 +1194,7 @@ async function _attemptBackupRestore(config) {
     try {
       copyFileSync(backup.path, config.dbPath);
       const backupWal = backup.path + "-wal";
-      if (existsSync(backupWal)) {
+      if (existsSync3(backupWal)) {
         copyFileSync(backupWal, config.dbPath + "-wal");
       }
       const opts = {
@@ -781,15 +1210,15 @@ async function _attemptBackupRestore(config) {
       if (isCorrupt) {
         testClient.close();
         try {
-          unlinkSync(config.dbPath);
+          unlinkSync2(config.dbPath);
         } catch {
         }
         try {
-          unlinkSync(config.dbPath + "-wal");
+          unlinkSync2(config.dbPath + "-wal");
         } catch {
         }
         try {
-          unlinkSync(config.dbPath + "-shm");
+          unlinkSync2(config.dbPath + "-shm");
         } catch {
         }
         process.stderr.write(
@@ -816,15 +1245,15 @@ async function _attemptBackupRestore(config) {
 `
       );
       try {
-        unlinkSync(config.dbPath);
+        unlinkSync2(config.dbPath);
       } catch {
       }
       try {
-        unlinkSync(config.dbPath + "-wal");
+        unlinkSync2(config.dbPath + "-wal");
       } catch {
       }
       try {
-        unlinkSync(config.dbPath + "-shm");
+        unlinkSync2(config.dbPath + "-shm");
       } catch {
       }
       continue;
@@ -839,14 +1268,14 @@ async function _attemptBackupRestore(config) {
 }
 async function initDatabase(config) {
   acquireDbLock();
-  if (existsSync(config.dbPath)) {
+  if (existsSync3(config.dbPath)) {
     const dbStat = statSync(config.dbPath);
     if (dbStat.size === 0) {
       const walPath = config.dbPath + "-wal";
-      if (existsSync(walPath) && statSync(walPath).size > 0) {
+      if (existsSync3(walPath) && statSync(walPath).size > 0) {
         const backupPath = config.dbPath + ".zeroed-" + Date.now();
         copyFileSync(config.dbPath, backupPath);
-        unlinkSync(config.dbPath);
+        unlinkSync2(config.dbPath);
         process.stderr.write(
           `[database] CRITICAL: DB was 0 bytes. Moved to ${backupPath}, attempting WAL recovery.
 `
@@ -1796,6 +2225,16 @@ async function ensureSchema() {
   } catch (e) {
     logCatchDebug("migration", e);
   }
+  try {
+    await client.execute("ALTER TABLE entities ADD COLUMN parent_type TEXT");
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
+  try {
+    await client.execute("CREATE INDEX IF NOT EXISTS idx_entities_parent_type ON entities(parent_type)");
+  } catch (e) {
+    logCatchDebug("migration", e);
+  }
   for (const col of [
     "ALTER TABLE memories ADD COLUMN source_trust_level TEXT DEFAULT 'unknown'",
     "ALTER TABLE memories ADD COLUMN quarantined INTEGER DEFAULT 0",
@@ -2746,5 +3185,38 @@ export {
   ensureSchema,
   disposeTurso,
   disposeDatabase,
-  init_database
+  database_exports,
+  init_database,
+  identityPath,
+  getIdentity,
+  updateIdentity,
+  listIdentities,
+  getIdentityInjection,
+  init_identity,
+  EMPLOYEES_PATH,
+  DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  COORDINATOR_ROLE,
+  normalizeRole,
+  isCoordinatorRole,
+  getCoordinatorEmployee,
+  getCoordinatorName,
+  getCoordinatorDisplayTitle,
+  isCoordinatorName,
+  canCoordinate,
+  validateEmployeeName,
+  loadEmployees,
+  saveEmployees,
+  loadEmployeesSync,
+  getEmployee,
+  getEmployeeByRole,
+  getEmployeeNamesByRole,
+  hasRole,
+  baseAgentName,
+  isMultiInstance,
+  addEmployee,
+  hireEmployee,
+  normalizeRosterCase,
+  registerBinSymlinks,
+  employees_exports,
+  init_employees
 };