@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/chunk-LSDXEHKL.js

@@ -0,0 +1,381 @@
+import {
+  PLATFORM_PROCEDURE_TITLES
+} from "./chunk-VUH67PT4.js";
+import {
+  isGhostBehaviorRow
+} from "./chunk-FNHYH5U6.js";
+import {
+  getClient,
+  getIdentity,
+  listIdentities,
+  updateIdentity
+} from "./chunk-V6LOEOXG.js";
+import {
+  atomicWriteJsonSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/orchestration-package.ts
+import { randomUUID } from "crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import os from "os";
+import path 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 path.join(os.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+}
+function getBackupPath() {
+  return path.join(os.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+}
+function readRosterFile() {
+  const rosterPath = getRosterPath();
+  if (!existsSync(rosterPath)) return [];
+  const raw = readFileSync(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();
+  mkdirSync(path.dirname(rosterPath), { recursive: true });
+  if (existsSync(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());
+  }
+  atomicWriteJsonSync(rosterPath, roster);
+}
+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();
+  let inserted = 0;
+  for (const behavior of behaviors) {
+    if (isGhostBehaviorRow({ id: "import", content: behavior.content, agent_id: behavior.agent_id })) {
+      continue;
+    }
+    await client.execute({
+      sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID(),
+        behavior.agent_id,
+        behavior.project_name,
+        behavior.domain,
+        behavior.priority,
+        behavior.content,
+        timestamp,
+        timestamp
+      ]
+    });
+    inserted++;
+  }
+  return inserted;
+}
+async function insertProcedures(procedures, timestamp, options) {
+  const client = getClient();
+  const skipTitles = options?.skipTitles ?? /* @__PURE__ */ new Set();
+  let inserted = 0;
+  try {
+    const existing = await client.execute("SELECT title FROM company_procedures WHERE active = 1");
+    for (const r of existing.rows) {
+      if (r.title) skipTitles.add(r.title);
+    }
+  } catch {
+  }
+  for (const procedure of procedures) {
+    if (!procedure.title?.trim() || !procedure.content?.trim()) {
+      continue;
+    }
+    if (skipTitles.has(procedure.title) || PLATFORM_PROCEDURE_TITLES.has(procedure.title)) {
+      continue;
+    }
+    await client.execute({
+      sql: `INSERT INTO company_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID(),
+        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 company_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 company_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))
+  };
+}
+
+export {
+  exportOrchestration,
+  importOrchestration,
+  validatePackage
+};

package/dist/chunk-LY3SOO73.js

@@ -0,0 +1,76 @@
+import {
+  fastDbInit
+} from "./chunk-P5UXP53T.js";
+import {
+  sessionScopeFilter
+} from "./chunk-F5OSXH4A.js";
+import {
+  formatStatusAll,
+  formatStatusDeep,
+  getEmployeeStatuses,
+  inTmux
+} from "./chunk-SSTLTIF3.js";
+import {
+  getClient,
+  isCoordinatorRole,
+  loadEmployees
+} from "./chunk-XABJRAUW.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/exe-status.ts
+async function status(targetEmployee) {
+  if (!inTmux()) {
+    return "Not in a tmux session. Start tmux first: tmux new-session -s work";
+  }
+  const employees = await loadEmployees();
+  const names = employees.filter((e) => !isCoordinatorRole(e.role)).map((e) => e.name);
+  const roles = new Map(employees.map((e) => [e.name, e.role ?? ""]));
+  await fastDbInit();
+  const client = getClient();
+  const taskMap = /* @__PURE__ */ new Map();
+  try {
+    const esScope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `SELECT assigned_to, title, priority FROM tasks
+            WHERE status = 'in_progress'${esScope.sql}
+            ORDER BY priority ASC, created_at ASC`,
+      args: [...esScope.args]
+    });
+    for (const row of result.rows) {
+      const assignee = String(row.assigned_to);
+      if (!taskMap.has(assignee)) {
+        taskMap.set(assignee, {
+          title: String(row.title),
+          priority: String(row.priority)
+        });
+      }
+    }
+  } catch {
+  }
+  if (targetEmployee) {
+    if (!names.includes(targetEmployee)) {
+      return `Employee "${targetEmployee}" not found. Available: ${names.join(", ")}`;
+    }
+    const statuses2 = getEmployeeStatuses([targetEmployee]);
+    const s = statuses2[0];
+    return formatStatusDeep(s, taskMap.get(targetEmployee), roles.get(targetEmployee) ?? "");
+  }
+  const statuses = getEmployeeStatuses(names);
+  return formatStatusAll(statuses, taskMap, roles);
+}
+if (isMainModule(import.meta.url)) {
+  const target = process.argv[2];
+  status(target).then((output) => {
+    process.stdout.write(output + "\n");
+  }).catch((err) => {
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+
+export {
+  status
+};

package/dist/chunk-M6CIHXXB.js

@@ -0,0 +1,159 @@
+import {
+  EMBEDDING_DIM
+} from "./chunk-FXU7JOXK.js";
+
+// src/lib/tool-capability-index.ts
+var ALWAYS_ON = /* @__PURE__ */ new Set([
+  "mcp_ping",
+  "memory",
+  "task",
+  "message",
+  "identity",
+  "diagnostics",
+  "session"
+]);
+function categoryForToolName(toolName, categoryMap) {
+  const normalized = toolName.replace(/[_-]/g, "").toLowerCase();
+  for (const [registerFn, cat] of Object.entries(categoryMap)) {
+    const fnNormalized = registerFn.replace(/^register/, "").toLowerCase();
+    if (fnNormalized === normalized) return cat;
+  }
+  return "unknown";
+}
+function extractParamNames(inputSchema) {
+  if (!inputSchema || typeof inputSchema !== "object") return "";
+  return Object.keys(inputSchema).join(", ");
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length || a.length === 0) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+function keywordScore(query, tool) {
+  const words = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  if (words.length === 0) return 0;
+  const searchText = `${tool.name} ${tool.description} ${tool.category} ${tool.paramSummary}`.toLowerCase();
+  let matches = 0;
+  for (const word of words) {
+    if (searchText.includes(word)) matches++;
+  }
+  return matches / words.length;
+}
+var ToolCapabilityIndex = class {
+  capabilities = [];
+  initialized = false;
+  /**
+   * Build the index by intercepting registerAllTools via a fake McpServer.
+   *
+   * @param registerFn - function that registers tools on a server (e.g. registerAllTools)
+   * @param categoryMap - optional map of registerFnName → category (from tool-gates TOOL_CATEGORIES)
+   */
+  async buildIndex(registerFn, categoryMap, directEmbedFn) {
+    const captured = [];
+    const fakeServer = {
+      registerTool(name, config, _handler) {
+        captured.push({
+          name,
+          description: config.description ?? "",
+          inputSchema: config.inputSchema ?? {}
+        });
+      }
+    };
+    registerFn(fakeServer);
+    const capabilityDocs = [];
+    for (const tool of captured) {
+      const paramSummary = extractParamNames(tool.inputSchema);
+      const category = categoryMap ? categoryForToolName(tool.name, categoryMap) : "unknown";
+      const doc = `${tool.name}: ${tool.description}. Parameters: ${paramSummary}`;
+      capabilityDocs.push({ name: tool.name, description: tool.description, category, paramSummary, doc });
+    }
+    let vectors = capabilityDocs.map(() => null);
+    try {
+      if (directEmbedFn) {
+        const allVectors = await directEmbedFn(capabilityDocs.map((c) => c.doc));
+        vectors = allVectors.map((v) => v.length === EMBEDDING_DIM ? v : null);
+      } else {
+        const { embed } = await import("./lib/embedder.js");
+        const test = await embed("test");
+        if (test.length === EMBEDDING_DIM) {
+          for (let i = 0; i < capabilityDocs.length; i++) {
+            try {
+              vectors[i] = await embed(capabilityDocs[i].doc);
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    const capabilities = capabilityDocs.map((c, i) => ({
+      name: c.name,
+      description: c.description,
+      category: c.category,
+      vector: vectors[i] ?? null,
+      paramSummary: c.paramSummary
+    }));
+    this.capabilities = capabilities;
+    this.initialized = true;
+    process.stderr.write(
+      `[tool-capability-index] Indexed ${capabilities.length} tools (${capabilities.filter((c) => c.vector).length} with vectors)
+`
+    );
+  }
+  /**
+   * Semantic search for tools matching a natural-language query.
+   * Returns tools sorted by relevance, with always-on tools boosted.
+   */
+  async search(query, limit = 20) {
+    if (!this.initialized || this.capabilities.length === 0) return [];
+    let queryVector = null;
+    try {
+      const { embed } = await import("./lib/embedder.js");
+      queryVector = await embed(query);
+    } catch {
+    }
+    const scored = [];
+    for (const tool of this.capabilities) {
+      let relevance;
+      if (queryVector && tool.vector) {
+        const vecScore = cosineSimilarity(queryVector, tool.vector);
+        const kwScore = keywordScore(query, tool);
+        relevance = vecScore * 0.8 + kwScore * 0.2;
+      } else {
+        relevance = keywordScore(query, tool);
+      }
+      if (ALWAYS_ON.has(tool.name)) {
+        relevance = Math.max(relevance, 0.5);
+      }
+      scored.push({ ...tool, relevance });
+    }
+    scored.sort((a, b) => b.relevance - a.relevance);
+    return scored.slice(0, limit);
+  }
+  /** Whether the index has been built. */
+  isReady() {
+    return this.initialized;
+  }
+  /** Total number of indexed tools. */
+  get toolCount() {
+    return this.capabilities.length;
+  }
+};
+var _instance = null;
+function getToolCapabilityIndex() {
+  if (!_instance) {
+    _instance = new ToolCapabilityIndex();
+  }
+  return _instance;
+}
+
+export {
+  ToolCapabilityIndex,
+  getToolCapabilityIndex
+};