@askexenow/exe-os 0.9.290 → 0.9.292

package/dist/entity-boost-WXSBSZW4.js

@@ -0,0 +1,375 @@
+import {
+  buildFtsMatch,
+  tokenizeForFts
+} from "./chunk-AB4PAQYK.js";
+import "./chunk-MLKGABMK.js";
+
+// src/lib/entity-boost.ts
+var ENTITY_BOOST_WEIGHT = parseFloat(
+  process.env.ENTITY_BOOST_WEIGHT ?? "0.5"
+);
+var SEMANTIC_MATCH_THRESHOLD = parseFloat(
+  process.env.SEMANTIC_MATCH_THRESHOLD ?? "0.7"
+);
+var _entityEmbedCache = null;
+var ENTITY_EMBED_CACHE_TTL_MS = 10 * 60 * 1e3;
+var MIN_WORD_LENGTH = 3;
+var MAX_ENTITY_MATCHES = 20;
+var GRAPH_TRAVERSAL_MAX_HOPS = Math.min(
+  parseInt(process.env.GRAPH_TRAVERSAL_MAX_HOPS ?? "2", 10),
+  3
+);
+var TOP_ENTITIES_TO_TRAVERSE = 5;
+var DAEMON_SAFE_ENTITY_FTS_TERM_THRESHOLD = 3;
+var DAEMON_SAFE_ENTITY_FTS_MAX_TERMS = 5;
+var _daemonEntityBoostSkipLogged = false;
+function isDaemonProcess() {
+  return process.env.EXE_IS_DAEMON === "1";
+}
+function daemonSafeEntityTerms(words) {
+  return isDaemonProcess() ? words.slice(0, DAEMON_SAFE_ENTITY_FTS_MAX_TERMS) : words;
+}
+function escapeLikePattern(value) {
+  return value.replace(/[\\%_]/g, (m) => `\\${m}`);
+}
+function logDaemonEntityBoostSkipOnce(wordCount) {
+  if (_daemonEntityBoostSkipLogged || process.env.VITEST) return;
+  _daemonEntityBoostSkipLogged = true;
+  process.stderr.write(
+    `[entity-boost] Daemon-safe FTS: skipped entity boost for ${wordCount} terms to keep MCP responsive.
+`
+  );
+}
+var DEFAULT_RELATIONSHIP_WEIGHTS = {
+  decided: 1,
+  depends_on: 0.8,
+  part_of: 0.7,
+  related_to: 0.5,
+  mentioned_in: 0.3
+};
+var DEFAULT_REL_WEIGHT = 0.4;
+function getRelTypeWeights() {
+  const override = process.env.RELATIONSHIP_TYPE_WEIGHTS;
+  if (!override) return DEFAULT_RELATIONSHIP_WEIGHTS;
+  try {
+    return { ...DEFAULT_RELATIONSHIP_WEIGHTS, ...JSON.parse(override) };
+  } catch {
+    return DEFAULT_RELATIONSHIP_WEIGHTS;
+  }
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) 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;
+}
+async function matchEntitiesSemantic(query, client) {
+  try {
+    const { embed } = await import("./lib/embedder.js");
+    const queryVec = await embed(query);
+    const now = Date.now();
+    if (!_entityEmbedCache || now - _entityEmbedCache.loadedAt > ENTITY_EMBED_CACHE_TTL_MS) {
+      const allEntities = await client.execute({
+        sql: `SELECT id, name FROM entities ORDER BY last_seen DESC LIMIT 500`,
+        args: []
+      });
+      const embeddings = /* @__PURE__ */ new Map();
+      const namesById = /* @__PURE__ */ new Map();
+      const names = allEntities.rows.map((r) => String(r.name));
+      const ids = allEntities.rows.map((r) => String(r.id));
+      for (let i = 0; i < ids.length; i++) {
+        namesById.set(ids[i], names[i]);
+      }
+      try {
+        const { embedBatchViaClient } = await import("./lib/exe-daemon-client.js");
+        const vecs = await embedBatchViaClient(names, "low");
+        if (vecs && vecs.length === names.length) {
+          for (let i = 0; i < names.length; i++) {
+            embeddings.set(ids[i], vecs[i]);
+          }
+        }
+      } catch {
+      }
+      _entityEmbedCache = { embeddings, names: namesById, loadedAt: now };
+    }
+    const scored = [];
+    for (const [entityId, entityVec] of _entityEmbedCache.embeddings) {
+      const similarity = cosineSimilarity(queryVec, entityVec);
+      if (similarity >= SEMANTIC_MATCH_THRESHOLD) {
+        scored.push({
+          entityId,
+          name: _entityEmbedCache.names.get(entityId) ?? entityId,
+          similarity
+        });
+      }
+    }
+    scored.sort((a, b) => b.similarity - a.similarity);
+    return scored.slice(0, MAX_ENTITY_MATCHES).map(({ entityId, name }) => ({
+      entityId,
+      name
+    }));
+  } catch {
+    return [];
+  }
+}
+async function matchEntities(query, client) {
+  const words = daemonSafeEntityTerms(tokenizeForFts(query, {
+    minLen: MIN_WORD_LENGTH,
+    maxTerms: 16
+  }));
+  if (words.length === 0) return [];
+  if (isDaemonProcess() && words.length >= DAEMON_SAFE_ENTITY_FTS_TERM_THRESHOLD) {
+    logDaemonEntityBoostSkipOnce(words.length);
+    return [];
+  }
+  try {
+    const matchExpr = buildFtsMatch(words, {
+      prefix: !(isDaemonProcess() && words.length >= DAEMON_SAFE_ENTITY_FTS_TERM_THRESHOLD),
+      join: "OR"
+    });
+    const result = await client.execute({
+      sql: `SELECT e.id, e.name FROM entities e
+            JOIN entities_fts fts ON e.rowid = fts.rowid
+            WHERE entities_fts MATCH ?
+            ORDER BY rank
+            LIMIT ?`,
+      args: [matchExpr, MAX_ENTITY_MATCHES]
+    });
+    if (result.rows.length > 0) {
+      return result.rows.map((row) => ({
+        entityId: String(row.id),
+        name: String(row.name)
+      }));
+    }
+  } catch {
+  }
+  const semanticMatches = await matchEntitiesSemantic(query, client);
+  if (semanticMatches.length > 0) {
+    return semanticMatches;
+  }
+  const conditions = words.map(() => `LOWER(name) LIKE ? ESCAPE '\\'`);
+  const args = words.map((w) => `%${escapeLikePattern(w)}%`);
+  try {
+    const result = await client.execute({
+      sql: `SELECT id, name FROM entities
+            WHERE ${conditions.join(" OR ")}
+            LIMIT ?`,
+      args: [...args, MAX_ENTITY_MATCHES]
+    });
+    return result.rows.map((row) => ({
+      entityId: String(row.id),
+      name: String(row.name)
+    }));
+  } catch (err) {
+    process.stderr.write(
+      `[entity-boost] LIKE fallback query failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return [];
+  }
+}
+async function getLinkedMemories(entityIds, client, candidateMemoryIds) {
+  const linked = /* @__PURE__ */ new Map();
+  if (entityIds.length === 0) return linked;
+  const placeholders = entityIds.map(() => "?").join(",");
+  const candidateIds = candidateMemoryIds ? Array.from(candidateMemoryIds) : [];
+  const candidateClause = candidateIds.length > 0 ? ` AND memory_id IN (${candidateIds.map(() => "?").join(",")})` : "";
+  try {
+    const counts = await client.execute({
+      sql: `SELECT entity_id, COUNT(*) as cnt FROM entity_memories
+            WHERE entity_id IN (${placeholders})
+            GROUP BY entity_id`,
+      args: entityIds
+    });
+    for (const row of counts.rows) {
+      const entityId = String(row.entity_id);
+      linked.set(entityId, {
+        entityId,
+        memoryIds: /* @__PURE__ */ new Set(),
+        count: Number(row.cnt ?? 0)
+      });
+    }
+    const result = await client.execute({
+      sql: `SELECT entity_id, memory_id FROM entity_memories
+            WHERE entity_id IN (${placeholders})${candidateClause}
+            LIMIT 1000`,
+      args: [...entityIds, ...candidateIds]
+    });
+    for (const row of result.rows) {
+      const entityId = String(row.entity_id);
+      const memoryId = String(row.memory_id);
+      const entry = linked.get(entityId) ?? {
+        entityId,
+        memoryIds: /* @__PURE__ */ new Set(),
+        count: 0
+      };
+      entry.memoryIds.add(memoryId);
+      if (entry.count === 0) entry.count = entry.memoryIds.size;
+      linked.set(entityId, entry);
+    }
+  } catch {
+  }
+  return linked;
+}
+function spreadAttenuation(numLinked) {
+  return 1 / (1 + 1e-3 * (numLinked - 1) ** 2);
+}
+async function traverseAndScore(entities, client, boostMap, resultIds, graphContextMap) {
+  const topEntities = entities.slice(0, TOP_ENTITIES_TO_TRAVERSE);
+  if (topEntities.length === 0) return;
+  const { getEntityNeighbors } = await import("./graph-query-AP5R6ZHO.js");
+  const relWeights = getRelTypeWeights();
+  const neighborEntityIds = [];
+  const neighborMeta = /* @__PURE__ */ new Map();
+  for (const entity of topEntities) {
+    try {
+      const neighbors = await getEntityNeighbors(
+        client,
+        entity.entityId,
+        GRAPH_TRAVERSAL_MAX_HOPS
+      );
+      for (const n of neighbors) {
+        if (n.depth === 0) continue;
+        if (neighborMeta.has(n.entity.id)) continue;
+        neighborEntityIds.push(n.entity.id);
+        neighborMeta.set(n.entity.id, {
+          depth: n.depth,
+          relType: n.relType,
+          relConfidence: n.relConfidence,
+          sourceName: entity.name,
+          neighborName: n.entity.name
+        });
+      }
+    } catch {
+    }
+  }
+  if (neighborEntityIds.length === 0) return;
+  const neighborLinked = await getLinkedMemories(neighborEntityIds, client, resultIds);
+  for (const [entityId, entry] of neighborLinked) {
+    const meta = neighborMeta.get(entityId);
+    if (!meta) continue;
+    const relWeight = relWeights[meta.relType] ?? DEFAULT_REL_WEIGHT;
+    const depthDecay = 1 / (1 + meta.depth);
+    const neighborBoost = ENTITY_BOOST_WEIGHT * meta.relConfidence * depthDecay * relWeight;
+    const attenuation = spreadAttenuation(entry.count);
+    const finalBoost = neighborBoost * attenuation;
+    for (const memoryId of entry.memoryIds) {
+      if (resultIds.has(memoryId)) {
+        boostMap.set(memoryId, (boostMap.get(memoryId) ?? 0) + finalBoost);
+        const contextPath = `${meta.sourceName} ${meta.relType} ${meta.neighborName}`;
+        if (!graphContextMap.has(memoryId)) {
+          graphContextMap.set(memoryId, contextPath);
+        }
+      }
+    }
+  }
+}
+async function applyHyperedgeBoost(entities, client, boostMap, resultIds) {
+  if (entities.length < 2) return;
+  const entityIds = entities.map((e) => e.entityId);
+  const placeholders = entityIds.map(() => "?").join(",");
+  try {
+    const result = await client.execute({
+      sql: `SELECT hyperedge_id, entity_id FROM hyperedge_nodes
+            WHERE entity_id IN (${placeholders})`,
+      args: entityIds
+    });
+    const hyperedgeEntities = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      const hid = String(row.hyperedge_id);
+      const eid = String(row.entity_id);
+      const set = hyperedgeEntities.get(hid) ?? /* @__PURE__ */ new Set();
+      set.add(eid);
+      hyperedgeEntities.set(hid, set);
+    }
+    const sharedHyperedgeIds = [];
+    for (const [hid, eids] of hyperedgeEntities) {
+      if (eids.size >= 2) {
+        sharedHyperedgeIds.push(hid);
+      }
+    }
+    if (sharedHyperedgeIds.length === 0) return;
+    const hPlaceholders = sharedHyperedgeIds.map(() => "?").join(",");
+    const allNodesResult = await client.execute({
+      sql: `SELECT DISTINCT entity_id FROM hyperedge_nodes
+            WHERE hyperedge_id IN (${hPlaceholders})`,
+      args: sharedHyperedgeIds
+    });
+    const allEntityIds = allNodesResult.rows.map((r) => String(r.entity_id));
+    if (allEntityIds.length === 0) return;
+    const linked = await getLinkedMemories(allEntityIds, client, resultIds);
+    for (const [, entry] of linked) {
+      const attenuation = spreadAttenuation(entry.count);
+      const boost = ENTITY_BOOST_WEIGHT * attenuation;
+      for (const memoryId of entry.memoryIds) {
+        if (resultIds.has(memoryId)) {
+          boostMap.set(memoryId, (boostMap.get(memoryId) ?? 0) + boost);
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function applyEntityBoost(results, query, client) {
+  const emptyResult = { results, graphContext: /* @__PURE__ */ new Map() };
+  if (ENTITY_BOOST_WEIGHT === 0 || results.length === 0) {
+    return emptyResult;
+  }
+  const debugStart = process.env.EXE_DEBUG_HOOKS ? performance.now() : 0;
+  const debugEnd = () => {
+    if (!process.env.EXE_DEBUG_HOOKS) return;
+    process.stderr.write(
+      `[entity-boost] ${(performance.now() - debugStart).toFixed(3)}ms
+`
+    );
+  };
+  const entities = await matchEntities(query, client);
+  if (entities.length === 0) {
+    debugEnd();
+    return emptyResult;
+  }
+  const boostMap = /* @__PURE__ */ new Map();
+  const resultIds = new Set(results.map((r) => r.id));
+  const graphContextMap = /* @__PURE__ */ new Map();
+  const directLinked = await getLinkedMemories(
+    entities.map((e) => e.entityId),
+    client,
+    resultIds
+  );
+  for (const [, entry] of directLinked) {
+    const attenuation = spreadAttenuation(entry.count);
+    const boost = ENTITY_BOOST_WEIGHT * attenuation;
+    for (const memoryId of entry.memoryIds) {
+      if (resultIds.has(memoryId)) {
+        boostMap.set(memoryId, (boostMap.get(memoryId) ?? 0) + boost);
+      }
+    }
+  }
+  await traverseAndScore(entities, client, boostMap, resultIds, graphContextMap);
+  await applyHyperedgeBoost(entities, client, boostMap, resultIds);
+  if (boostMap.size === 0) {
+    debugEnd();
+    return emptyResult;
+  }
+  const scored = results.map((r, i) => ({
+    record: r,
+    baseScore: 1 / (1 + i * 0.1),
+    entityBoost: boostMap.get(r.id) ?? 0
+  }));
+  scored.sort(
+    (a, b) => b.baseScore + b.entityBoost - (a.baseScore + a.entityBoost)
+  );
+  debugEnd();
+  return {
+    results: scored.map((s) => s.record),
+    graphContext: graphContextMap
+  };
+}
+export {
+  applyEntityBoost
+};

package/dist/exe-drift-HBLGPMBH.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import {
+  runDriftProbes
+} from "./chunk-RG4OHDY7.js";
+import "./chunk-LCOPVYU2.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-LJONNOFH.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-5P3HOBZX.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/bin/exe-drift.ts
+var AXES = ["continuity", "consistency", "role-fidelity", "world-model"];
+var AXIS_HEADERS = {
+  continuity: "Cont.",
+  consistency: "Consist.",
+  "role-fidelity": "Role",
+  "world-model": "World"
+};
+function statusIcon(overall) {
+  if (overall >= 80) return "\x1B[32m\u{1F7E2} OK\x1B[0m";
+  if (overall >= 60) return "\x1B[33m\u{1F7E0} WARN\x1B[0m";
+  return "\x1B[31m\u{1F534} DRIFTING\x1B[0m";
+}
+function padRight(str, len) {
+  return str.length >= len ? str.slice(0, len) : str + " ".repeat(len - str.length);
+}
+function padLeft(str, len) {
+  return str.length >= len ? str : " ".repeat(len - str.length) + str;
+}
+function formatTable(results) {
+  const lines = [];
+  const header = padRight("Agent", 10) + AXES.map((a) => padLeft(AXIS_HEADERS[a], 9)).join("") + padLeft("Overall", 9) + "  Status";
+  lines.push(header);
+  lines.push("-".repeat(header.length + 10));
+  for (const r of results) {
+    const line = padRight(r.agent, 10) + AXES.map((a) => padLeft(String(r.scores[a]), 9)).join("") + padLeft(String(r.overall), 9) + "  " + statusIcon(r.overall);
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+async function runDrift(args) {
+  const agentIdx = args.indexOf("--agent");
+  const agentId = agentIdx >= 0 ? args[agentIdx + 1] : void 0;
+  console.log("\nexe-os doctor --drift\n");
+  const results = await runDriftProbes({ agentId });
+  if (results.length === 0) {
+    console.log("No agents found. Run /exe-team to see available employees.");
+    return;
+  }
+  console.log(formatTable(results));
+  console.log();
+  const flagged = results.filter((r) => r.flags.length > 0);
+  if (flagged.length > 0) {
+    for (const r of flagged) {
+      for (const flag of r.flags) {
+        console.log(`\u26A0 ${r.agent}: ${flag}`);
+      }
+    }
+    console.log();
+  } else {
+    console.log("All agents within role-fidelity thresholds.\n");
+  }
+}
+export {
+  runDrift
+};

package/dist/exe-drift-K7HAX5N4.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import {
+  runDriftProbes
+} from "./chunk-7UUJMSFH.js";
+import "./chunk-MUQ46NLH.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-HNDG5ZDJ.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import "./chunk-MLKGABMK.js";
+
+// src/bin/exe-drift.ts
+var AXES = ["continuity", "consistency", "role-fidelity", "world-model"];
+var AXIS_HEADERS = {
+  continuity: "Cont.",
+  consistency: "Consist.",
+  "role-fidelity": "Role",
+  "world-model": "World"
+};
+function statusIcon(overall) {
+  if (overall >= 80) return "\x1B[32m\u{1F7E2} OK\x1B[0m";
+  if (overall >= 60) return "\x1B[33m\u{1F7E0} WARN\x1B[0m";
+  return "\x1B[31m\u{1F534} DRIFTING\x1B[0m";
+}
+function padRight(str, len) {
+  return str.length >= len ? str.slice(0, len) : str + " ".repeat(len - str.length);
+}
+function padLeft(str, len) {
+  return str.length >= len ? str : " ".repeat(len - str.length) + str;
+}
+function formatTable(results) {
+  const lines = [];
+  const header = padRight("Agent", 10) + AXES.map((a) => padLeft(AXIS_HEADERS[a], 9)).join("") + padLeft("Overall", 9) + "  Status";
+  lines.push(header);
+  lines.push("-".repeat(header.length + 10));
+  for (const r of results) {
+    const line = padRight(r.agent, 10) + AXES.map((a) => padLeft(String(r.scores[a]), 9)).join("") + padLeft(String(r.overall), 9) + "  " + statusIcon(r.overall);
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+async function runDrift(args) {
+  const agentIdx = args.indexOf("--agent");
+  const agentId = agentIdx >= 0 ? args[agentIdx + 1] : void 0;
+  console.log("\nexe-os doctor --drift\n");
+  const results = await runDriftProbes({ agentId });
+  if (results.length === 0) {
+    console.log("No agents found. Run /exe-team to see available employees.");
+    return;
+  }
+  console.log(formatTable(results));
+  console.log();
+  const flagged = results.filter((r) => r.flags.length > 0);
+  if (flagged.length > 0) {
+    for (const r of flagged) {
+      for (const flag of r.flags) {
+        console.log(`\u26A0 ${r.agent}: ${flag}`);
+      }
+    }
+    console.log();
+  } else {
+    console.log("All agents within role-fidelity thresholds.\n");
+  }
+}
+export {
+  runDrift
+};

package/dist/exe-export-JSJOEDBE.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {
+  exportOrchestration
+} from "./chunk-UCBIETEA.js";
+import "./chunk-VUH67PT4.js";
+import {
+  disposeStore,
+  initStore
+} from "./chunk-NOC7GUHJ.js";
+import "./chunk-CHCA3ZM2.js";
+import "./chunk-OTVEIJUQ.js";
+import "./chunk-L2DMZT56.js";
+import "./chunk-Y25OJWOQ.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-MUQ46NLH.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-HNDG5ZDJ.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-Z42MXYWW.js";
+import "./chunk-R36FAN53.js";
+import "./chunk-LYH5HE24.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+import "./chunk-MLKGABMK.js";
+
+// src/bin/exe-export.ts
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
+var OUTPUT_FLAG = "--output";
+function printUsage() {
+  process.stdout.write("Usage: exe-os export --output <path>\n");
+}
+function parseOutputPath(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printUsage();
+    return null;
+  }
+  const flagIndex = argv.indexOf(OUTPUT_FLAG);
+  if (flagIndex === -1 || !argv[flagIndex + 1]) {
+    throw new Error("Missing required --output <path> argument");
+  }
+  return argv[flagIndex + 1];
+}
+async function runExeExport(argv = process.argv.slice(2)) {
+  const outputPath = parseOutputPath(argv);
+  if (outputPath == null) return;
+  await initStore();
+  try {
+    const pkg = await exportOrchestration("cli");
+    mkdirSync(path.dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+    process.stdout.write(
+      `Exported ${pkg.roster.length} roster entries, ${Object.keys(pkg.identities).length} identities, ${pkg.behaviors.length} behaviors, ${pkg.procedures.length} procedures to ${outputPath}
+`
+    );
+  } finally {
+    try {
+      await disposeStore();
+    } catch {
+    }
+  }
+}
+if (isMainModule(import.meta.url) && (process.argv[1] ?? "").includes("exe-export")) {
+  runExeExport().catch((err) => {
+    process.stderr.write(`exe-os export failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  runExeExport
+};

package/dist/exe-export-YVZMMVZZ.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {
+  exportOrchestration
+} from "./chunk-XRN5MQRN.js";
+import "./chunk-VUH67PT4.js";
+import {
+  disposeStore,
+  initStore
+} from "./chunk-PT3URNVT.js";
+import "./chunk-CHCA3ZM2.js";
+import "./chunk-OTVEIJUQ.js";
+import "./chunk-VPQAXUG4.js";
+import "./chunk-Y25OJWOQ.js";
+import "./chunk-MP2AFCGL.js";
+import "./chunk-LCOPVYU2.js";
+import "./chunk-2I23RPSI.js";
+import "./chunk-LJONNOFH.js";
+import "./chunk-PNQDP3OA.js";
+import "./chunk-7HLWBYH7.js";
+import "./chunk-FXU7JOXK.js";
+import "./chunk-Z42MXYWW.js";
+import "./chunk-5P3HOBZX.js";
+import "./chunk-LYH5HE24.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+import "./chunk-MLKGABMK.js";
+
+// src/bin/exe-export.ts
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
+var OUTPUT_FLAG = "--output";
+function printUsage() {
+  process.stdout.write("Usage: exe-os export --output <path>\n");
+}
+function parseOutputPath(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printUsage();
+    return null;
+  }
+  const flagIndex = argv.indexOf(OUTPUT_FLAG);
+  if (flagIndex === -1 || !argv[flagIndex + 1]) {
+    throw new Error("Missing required --output <path> argument");
+  }
+  return argv[flagIndex + 1];
+}
+async function runExeExport(argv = process.argv.slice(2)) {
+  const outputPath = parseOutputPath(argv);
+  if (outputPath == null) return;
+  await initStore();
+  try {
+    const pkg = await exportOrchestration("cli");
+    mkdirSync(path.dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+    process.stdout.write(
+      `Exported ${pkg.roster.length} roster entries, ${Object.keys(pkg.identities).length} identities, ${pkg.behaviors.length} behaviors, ${pkg.procedures.length} procedures to ${outputPath}
+`
+    );
+  } finally {
+    try {
+      await disposeStore();
+    } catch {
+    }
+  }
+}
+if (isMainModule(import.meta.url) && (process.argv[1] ?? "").includes("exe-export")) {
+  runExeExport().catch((err) => {
+    process.stderr.write(`exe-os export failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  runExeExport
+};