@askexenow/exe-os 0.9.359 → 0.9.362

package/dist/chunk-J6KMGEJW.js

@@ -0,0 +1,238 @@
+// src/lib/preflight.ts
+import { spawnSync } from "child_process";
+import { readFileSync } from "fs";
+var TMUX_MIN_MAJOR = 3;
+var TMUX_MIN_MINOR = 2;
+function parseTmuxVersion(raw) {
+  const text = (raw ?? "").trim();
+  if (!text) return null;
+  const m = /^tmux\s+(\d+)\.(\d+)([a-z]*)/i.exec(text);
+  if (!m) return null;
+  const major = Number.parseInt(m[1] ?? "", 10);
+  const minor = Number.parseInt(m[2] ?? "", 10);
+  if (!Number.isFinite(major) || !Number.isFinite(minor)) return null;
+  return { major, minor, suffix: m[3] ?? "", raw: text };
+}
+function tmuxVersionSatisfies(v) {
+  if (v.major !== TMUX_MIN_MAJOR) return v.major > TMUX_MIN_MAJOR;
+  return v.minor >= TMUX_MIN_MINOR;
+}
+function detectDistroFamily(osReleaseContent) {
+  if (!osReleaseContent) return "unknown";
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of osReleaseContent.split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    const value = line.slice(eq + 1).trim().replace(/^["']|["']$/g, "").toLowerCase();
+    fields.set(key, value);
+  }
+  const tokens = [
+    ...(fields.get("ID") ?? "").split(/\s+/),
+    ...(fields.get("ID_LIKE") ?? "").split(/\s+/)
+  ].filter(Boolean);
+  for (const t of tokens) {
+    if (["debian", "ubuntu", "linuxmint", "pop", "raspbian"].includes(t)) return "debian";
+    if (["rhel", "fedora", "centos", "rocky", "almalinux", "amzn"].includes(t)) return "rhel";
+    if (["arch", "archarm", "manjaro", "endeavouros"].includes(t)) return "arch";
+    if (["suse", "opensuse", "sles", "opensuse-leap", "opensuse-tumbleweed"].includes(t)) return "suse";
+    if (["alpine"].includes(t)) return "alpine";
+  }
+  return "unknown";
+}
+function readOsRelease() {
+  try {
+    return readFileSync("/etc/os-release", "utf8");
+  } catch {
+    return null;
+  }
+}
+function installCommand(pkg, ctx) {
+  if (ctx.platform === "darwin") {
+    return pkg === "tmux" ? "brew install tmux" : null;
+  }
+  if (ctx.platform !== "linux") return null;
+  if (pkg === "tmux") {
+    switch (ctx.family) {
+      case "debian":
+        return "sudo apt update && sudo apt install -y tmux";
+      case "rhel":
+        return "sudo dnf install -y tmux";
+      case "arch":
+        return "sudo pacman -S --noconfirm tmux";
+      case "suse":
+        return "sudo zypper install -y tmux";
+      case "alpine":
+        return "sudo apk add tmux";
+      default:
+        return null;
+    }
+  }
+  switch (ctx.family) {
+    case "debian":
+      return "sudo apt install -y libsecret-tools gnome-keyring";
+    case "rhel":
+      return "sudo dnf install -y libsecret gnome-keyring";
+    case "arch":
+      return "sudo pacman -S --noconfirm libsecret gnome-keyring";
+    case "suse":
+      return "sudo zypper install -y libsecret-tools gnome-keyring";
+    case "alpine":
+      return "sudo apk add libsecret gnome-keyring";
+    default:
+      return null;
+  }
+}
+function assessTmux(probe, ctx) {
+  const fix = installCommand("tmux", ctx);
+  if (probe.errorCode === "ENOENT") {
+    return {
+      name: "tmux",
+      state: "missing",
+      required: true,
+      detail: "not found on PATH. exe-os runs every agent in a tmux session, so without it sessions never start \u2014 and the session list reads as empty rather than erroring.",
+      fix: fix ?? "install tmux with your package manager"
+    };
+  }
+  if (probe.errorCode) {
+    return {
+      name: "tmux",
+      state: "unknown",
+      required: true,
+      detail: `could not run \`tmux -V\` (${probe.errorCode}) \u2014 tmux may well be installed; not treating this as missing.`
+    };
+  }
+  const parsed = parseTmuxVersion(probe.stdout ?? "");
+  if (!parsed) {
+    const seen = (probe.stdout ?? "").trim() || (probe.stderr ?? "").trim();
+    return {
+      name: "tmux",
+      state: "unknown",
+      required: true,
+      detail: `tmux is installed but \`tmux -V\` printed something unrecognised${seen ? ` (${seen})` : ""} \u2014 assuming it is fine. exe-os needs ${TMUX_MIN_MAJOR}.${TMUX_MIN_MINOR}+ for \`new-session -e\`.`
+    };
+  }
+  if (!tmuxVersionSatisfies(parsed)) {
+    return {
+      name: "tmux",
+      state: "too-old",
+      required: true,
+      detail: `tmux ${parsed.major}.${parsed.minor}${parsed.suffix} is too old. exe-os passes each agent's environment with \`tmux new-session -e KEY=VAL\`, and \`-e\` was added in tmux ${TMUX_MIN_MAJOR}.${TMUX_MIN_MINOR}. On this version EVERY employee spawn fails with "unknown flag -e".`,
+      // apt on Ubuntu 20.04 / Debian 11 will hand back the same too-old build,
+      // so quoting the install command here would send the user in a circle.
+      fix: ctx.family === "debian" ? "your distro's tmux package is older than 3.2 (Ubuntu 20.04 ships 3.0a, Debian 11 ships 3.1c) \u2014 upgrade the distro (Ubuntu 22.04+/Debian 12+ ship 3.2a+), or build tmux from source" : fix ?? "upgrade tmux to 3.2 or newer"
+    };
+  }
+  return {
+    name: "tmux",
+    state: "ok",
+    required: true,
+    detail: `tmux ${parsed.major}.${parsed.minor}${parsed.suffix}`
+  };
+}
+function assessKeyring(probe, ctx) {
+  if (ctx.platform !== "linux") {
+    return { name: "keyring", state: "ok", required: false, detail: "OS keychain is built in on this platform" };
+  }
+  const fix = installCommand("keyring", ctx);
+  if (probe.errorCode === "ENOENT") {
+    return {
+      name: "keyring",
+      state: "missing",
+      required: false,
+      detail: "`secret-tool` not found, so there is no Secret Service to store the master key in. The key will go in a machine-bound encrypted file instead.",
+      fix: fix ?? "install libsecret's CLI tools and a keyring daemon"
+    };
+  }
+  if (probe.errorCode) {
+    return {
+      name: "keyring",
+      state: "unknown",
+      required: false,
+      detail: `could not run \`secret-tool\` (${probe.errorCode}) \u2014 not drawing a conclusion about key custody from that.`
+    };
+  }
+  if (ctx.serviceReachable === false) {
+    return {
+      name: "keyring",
+      state: "missing",
+      required: false,
+      detail: "`secret-tool` is installed but no Secret Service is answering (the keyring daemon is not running). The key will go in a machine-bound encrypted file instead.",
+      fix: "start your keyring daemon for this session (e.g. `gnome-keyring-daemon --start`), then re-run `exe-os setup`"
+    };
+  }
+  if (ctx.serviceReachable === void 0) {
+    return {
+      name: "keyring",
+      state: "unknown",
+      required: false,
+      detail: "`secret-tool` is installed; did not probe whether a Secret Service is answering."
+    };
+  }
+  return { name: "keyring", state: "ok", required: false, detail: "Secret Service is reachable" };
+}
+function prereqLines(findings) {
+  const notable = findings.filter((f) => f.state !== "ok");
+  if (notable.length === 0) return [];
+  const out = ["System check:"];
+  for (const f of notable) {
+    const marker = f.state === "unknown" ? "?" : f.required ? "\u2717" : "\u26A0";
+    const label = f.state === "missing" ? f.required ? "MISSING (required)" : "missing" : f.state === "too-old" ? "TOO OLD" : "could not check";
+    out.push(`  ${marker} ${f.name} \u2014 ${label}`);
+    out.push(`    ${f.detail}`);
+    if (f.fix) out.push(`    Fix: ${f.fix}`);
+  }
+  out.push("");
+  out.push("  Setup will continue \u2014 none of the above blocks it. Nothing here is");
+  out.push("  a guess about your machine: anything we could not determine is");
+  out.push('  reported as "could not check" rather than as a problem.');
+  return out;
+}
+function probeCommand(cmd, args, timeoutMs = 3e3) {
+  try {
+    const r = spawnSync(cmd, args, { encoding: "utf8", timeout: timeoutMs });
+    if (r.error) {
+      const code = r.error.code;
+      return { errorCode: code ?? "ESPAWN", stderr: r.error.message };
+    }
+    return {
+      exitCode: r.status,
+      stdout: (r.stdout ?? "").toString(),
+      stderr: (r.stderr ?? "").toString()
+    };
+  } catch (err) {
+    return { errorCode: err.code ?? "ESPAWN" };
+  }
+}
+function runPrereqPreflight(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const family = deps.family ?? (platform === "linux" ? detectDistroFamily(readOsRelease()) : "unknown");
+  const ctx = { platform, family };
+  const findings = [
+    assessTmux((deps.probeTmux ?? (() => probeCommand("tmux", ["-V"])))(), ctx)
+  ];
+  if (!deps.skipKeyring) {
+    findings.push(
+      assessKeyring((deps.probeSecretTool ?? (() => probeCommand("secret-tool", ["--version"])))(), {
+        ...ctx,
+        serviceReachable: deps.secretServiceReachable
+      })
+    );
+  }
+  return findings;
+}
+
+export {
+  TMUX_MIN_MAJOR,
+  TMUX_MIN_MINOR,
+  parseTmuxVersion,
+  tmuxVersionSatisfies,
+  detectDistroFamily,
+  readOsRelease,
+  installCommand,
+  assessTmux,
+  assessKeyring,
+  prereqLines,
+  probeCommand,
+  runPrereqPreflight
+};

package/dist/chunk-JKKZGDLP.js

@@ -0,0 +1,182 @@
+// src/lib/key-dir.ts
+import { statSync, readFileSync } from "fs";
+import { execFileSync } from "child_process";
+import path from "path";
+import os from "os";
+var INSTALL_DIR_NAME = ".exe-os";
+var KeyDirRefusalError = class extends Error {
+  code = "EXE_KEY_DIR_REFUSED";
+  constructor(message) {
+    super(message);
+    this.name = "KeyDirRefusalError";
+  }
+};
+var KEY_DIR_REFUSAL_HINT = "Run exe-os as the user that owns the install (without sudo), or set EXE_OS_DIR to that install's directory explicitly. exe-os will never adopt another user's key directory.";
+function realOwnerUidOf(p) {
+  try {
+    return statSync(p).uid;
+  } catch {
+    return null;
+  }
+}
+function resolveKeyDirStrict(ctx) {
+  if (ctx.envDir) return ctx.envDir;
+  const ownerUidOf = ctx.ownerUidOf ?? realOwnerUidOf;
+  if (ctx.uid === 0 && ctx.sudoUser && ctx.sudoHome && typeof ctx.sudoUid === "number") {
+    const sudoDir = path.join(ctx.sudoHome, INSTALL_DIR_NAME);
+    const owner2 = ownerUidOf(sudoDir);
+    if (owner2 !== null) {
+      if (owner2 !== ctx.sudoUid && owner2 !== 0) {
+        throw new KeyDirRefusalError(
+          `refusing to use ${sudoDir}: it is owned by uid ${owner2}, not by SUDO_USER=${ctx.sudoUser} (uid ${ctx.sudoUid}). ${KEY_DIR_REFUSAL_HINT}`
+        );
+      }
+      return sudoDir;
+    }
+  }
+  const selfDir = path.join(ctx.selfHome, INSTALL_DIR_NAME);
+  const owner = ownerUidOf(selfDir);
+  if (owner !== null && ctx.uid >= 0 && owner !== ctx.uid) {
+    throw new KeyDirRefusalError(
+      `refusing to use ${selfDir}: it is owned by uid ${owner}, not by the current user (uid ${ctx.uid}). ` + KEY_DIR_REFUSAL_HINT
+    );
+  }
+  return selfDir;
+}
+function parsePasswdLine(line, user) {
+  const fields = line.split(":");
+  if (fields[0] !== user) return null;
+  const uid = Number(fields[2]);
+  const home = fields[5]?.trim() ?? "";
+  if (!Number.isInteger(uid) || !home) return null;
+  return { uid, home };
+}
+function lookupPasswd(user) {
+  try {
+    const entry = execFileSync("getent", ["passwd", user], { encoding: "utf8", timeout: 3e3 });
+    const parsed = parsePasswdLine(entry.trim(), user);
+    if (parsed) return parsed;
+  } catch {
+  }
+  try {
+    for (const line of readFileSync("/etc/passwd", "utf8").split("\n")) {
+      const parsed = parsePasswdLine(line.trim(), user);
+      if (parsed) return parsed;
+    }
+  } catch {
+  }
+  if (process.platform === "darwin") {
+    try {
+      const home = execFileSync("dscl", [".", "-read", `/Users/${user}`, "NFSHomeDirectory"], {
+        encoding: "utf8",
+        timeout: 3e3
+      }).split(":").slice(1).join(":").trim();
+      const uid = Number(
+        execFileSync("id", ["-u", user], { encoding: "utf8", timeout: 3e3 }).trim()
+      );
+      if (home && Number.isInteger(uid)) return { uid, home };
+    } catch {
+    }
+  }
+  return null;
+}
+var emittedNotices = /* @__PURE__ */ new Set();
+function noticeOnce(key, message) {
+  if (emittedNotices.has(key)) return;
+  emittedNotices.add(key);
+  process.stderr.write(message.endsWith("\n") ? message : `${message}
+`);
+}
+function describeInstallAmbiguity(ctx, chosen) {
+  if (ctx.envDir) return null;
+  const ownerUidOf = ctx.ownerUidOf ?? realOwnerUidOf;
+  const candidates = [];
+  if (ctx.sudoHome) candidates.push(path.join(ctx.sudoHome, INSTALL_DIR_NAME));
+  candidates.push(path.join(ctx.selfHome, INSTALL_DIR_NAME));
+  const other = candidates.find((c) => c !== chosen && ownerUidOf(c) !== null);
+  if (!other) return null;
+  return `[exe-os] Two exe-os installs exist on this host. Using: ${chosen}
+[exe-os]   NOT using: ${other}
+[exe-os]   Both the encryption key and the memory database come from the install above. If that is the wrong one, set EXE_OS_DIR=${other} explicitly (or run without sudo).`;
+}
+function currentKeyDirContext() {
+  const envDir = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || void 0;
+  const uid = typeof process.getuid === "function" ? process.getuid() : -1;
+  let selfHome = os.homedir();
+  if (uid === 0) {
+    let passwdHome = "";
+    try {
+      passwdHome = os.userInfo().homedir;
+    } catch {
+      passwdHome = "";
+    }
+    selfHome = passwdHome || "/root";
+  }
+  const ctx = {
+    envDir,
+    uid,
+    selfHome,
+    // Recorded, never read by the resolver — see KeyDirContext.homeBase.
+    homeBase: process.platform === "darwin" ? "/Users" : "/home"
+  };
+  if (uid === 0) {
+    const sudoUser = process.env.SUDO_USER ?? "";
+    if (sudoUser) {
+      const entry = lookupPasswd(sudoUser);
+      if (entry) {
+        ctx.sudoUser = sudoUser;
+        ctx.sudoHome = entry.home;
+        ctx.sudoUid = entry.uid;
+      } else {
+        noticeOnce(
+          `sudo-user-unresolved:${sudoUser}`,
+          `[exe-os] Running as root under sudo, but user "${sudoUser}" could not be resolved in the passwd database (getent, /etc/passwd${process.platform === "darwin" ? ", dscl" : ""} all failed).
+[exe-os]   Falling back to root's own install at ${path.join(selfHome, INSTALL_DIR_NAME)}. Set EXE_OS_DIR explicitly if that is not the install you meant.`
+        );
+      }
+    }
+  }
+  return ctx;
+}
+function resolveInstallDir() {
+  const ctx = currentKeyDirContext();
+  const dir = resolveKeyDirStrict(ctx);
+  const ambiguity = describeInstallAmbiguity(ctx, dir);
+  if (ambiguity) noticeOnce(`ambiguous:${dir}`, ambiguity);
+  if (ctx.envDir && ctx.uid >= 0) {
+    const owner = (ctx.ownerUidOf ?? realOwnerUidOf)(ctx.envDir);
+    if (owner !== null && owner !== ctx.uid) {
+      noticeOnce(
+        `env-dir-foreign:${ctx.envDir}`,
+        `[exe-os] WARNING: ${ctx.envDir} is owned by uid ${owner}, not by the current user (uid ${ctx.uid}).
+[exe-os]   It was used because EXE_OS_DIR names it explicitly. Everything in it \u2014 the master key and its recovery phrase \u2014 belongs to that user, not to you.`
+      );
+    }
+  }
+  return dir;
+}
+var REFUSED_DIR_MARKER = "exe-os-REFUSED";
+function refusedQuarantineDir(uid) {
+  return path.join(os.tmpdir(), `${REFUSED_DIR_MARKER}-${uid}-${process.pid}`);
+}
+function isRefusedQuarantinePath(p) {
+  return p.includes(REFUSED_DIR_MARKER);
+}
+function getKeyDirSafe() {
+  try {
+    return { dir: resolveInstallDir(), error: null };
+  } catch (err) {
+    return { dir: null, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+export {
+  KeyDirRefusalError,
+  KEY_DIR_REFUSAL_HINT,
+  resolveKeyDirStrict,
+  currentKeyDirContext,
+  resolveInstallDir,
+  refusedQuarantineDir,
+  isRefusedQuarantinePath,
+  getKeyDirSafe
+};

package/dist/{chunk-3ZEVMZ4G.js → chunk-JYKZVAS6.js}

@@ -1,7 +1,7 @@
 import {
   clean,
   stableId
-} from "./chunk-BGYCUZYK.js";
+} from "./chunk-YAZ5ECEG.js";
 
 // src/lib/reflection-checkpoints.ts
 function parsePayload(payload) {

package/dist/{chunk-4DYJ6NOK.js → chunk-KA4WVDLX.js}

@@ -8,11 +8,11 @@ import {
 import {
   loadLicense,
   readCachedLicenseToken
-} from "./chunk-2OVTGZYH.js";
+} from "./chunk-HSKABJE6.js";
 import {
   EXE_AI_DIR,
   loadConfig
-} from "./chunk-BCZF3AGJ.js";
+} from "./chunk-BRIZ6OZ3.js";
 
 // src/bin/exe-support.ts
 import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";

package/dist/{chunk-QH2XAUZ5.js → chunk-KBI4FVBZ.js}

@@ -263,7 +263,7 @@ async function runRegistryProxy(options = registryProxyOptionsFromEnv()) {
   await new Promise((resolve) => server.listen(options.port, options.host, resolve));
   console.log(`exe-registry-proxy listening on ${options.host ?? "0.0.0.0"}:${options.port}`);
   console.log(`proxying /v2/${options.allowedNamespace ?? "askexe"}/* -> ${options.upstream ?? "https://ghcr.io"}`);
-  const { licenseSyncConfigFromEnv, startLicenseSyncScheduler } = await import("./license-sync-XFDOXL3Z.js");
+  const { licenseSyncConfigFromEnv, startLicenseSyncScheduler } = await import("./license-sync-VBJCXBAP.js");
   const syncConfig = licenseSyncConfigFromEnv();
   if (syncConfig) {
     startLicenseSyncScheduler(syncConfig);

package/dist/{chunk-VAY6IXWY.js → chunk-KDMVVHZH.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-WNBZJSQT.js";
 import {
   EXE_AI_DIR
-} from "./chunk-BCZF3AGJ.js";
+} from "./chunk-BRIZ6OZ3.js";
 import {
   atomicWriteJsonSync,
   ensurePrivateDirSync

package/dist/{chunk-4FQIWAXA.js → chunk-KID6T2A4.js}

@@ -11,7 +11,7 @@ import {
   buildSystemStateExclusionFilter,
   buildWikiScopeFilter,
   searchMemories
-} from "./chunk-W5YV2PZE.js";
+} from "./chunk-DKRDU2AX.js";
 import {
   blobToVector
 } from "./chunk-OTVEIJUQ.js";
@@ -24,7 +24,7 @@ import {
 } from "./chunk-GJV3WDWM.js";
 import {
   getClient
-} from "./chunk-EA5FVACM.js";
+} from "./chunk-HLU52KTO.js";
 
 // src/lib/memory-reads.ts
 import crypto from "crypto";
@@ -566,7 +566,7 @@ async function hybridSearch(queryText, agentId, options) {
   let rerankerAvailable = false;
   if (process.env.EXE_IS_DAEMON === "1") {
     try {
-      const { isRerankerAvailable } = await import("./reranker-YVTLJCFC.js");
+      const { isRerankerAvailable } = await import("./reranker-NUIGAPA3.js");
       rerankerAvailable = isRerankerAvailable();
     } catch {
     }
@@ -635,7 +635,7 @@ async function hybridSearch(queryText, agentId, options) {
     ]).catch(() => []),
     includeStructuredCards ? (async () => {
       try {
-        const { searchMemoryCards } = await import("./memory-cards-KG4TPNKK.js");
+        const { searchMemoryCards } = await import("./memory-cards-4EXX3BQS.js");
         return await searchMemoryCards(effectiveQuery, agentId, fetchOptions);
       } catch {
         return [];
@@ -644,7 +644,7 @@ async function hybridSearch(queryText, agentId, options) {
     // Reflection insights: patterns, contradictions, summaries across sessions
     includeStructuredCards ? (async () => {
       try {
-        const { searchReflections } = await import("./memory-reflection-EQC4FXSW.js");
+        const { searchReflections } = await import("./memory-reflection-V2SNAUIB.js");
         const insights = await searchReflections(effectiveQuery, agentId, 5, {
           includeArchived: options?.includeArchived
         });
@@ -745,7 +745,7 @@ async function hybridSearch(queryText, agentId, options) {
   let entityBoostRan = false;
   if (merged.length > 0) {
     try {
-      const { applyEntityBoost } = await import("./entity-boost-HLFG2CH3.js");
+      const { applyEntityBoost } = await import("./entity-boost-VXXED26D.js");
       const boosted = await applyEntityBoost(merged, effectiveQuery, getClient());
       merged = boosted.results;
       graphContextMap = boosted.graphContext;
@@ -769,7 +769,7 @@ async function hybridSearch(queryText, agentId, options) {
     try {
       let rerankedRecords;
       if (graphContextMap.size > 0) {
-        const { rerankWithContext } = await import("./reranker-YVTLJCFC.js");
+        const { rerankWithContext } = await import("./reranker-NUIGAPA3.js");
         const candidates = merged.map((m) => ({
           text: m.raw_text,
           context: graphContextMap.get(m.id)
@@ -777,7 +777,7 @@ async function hybridSearch(queryText, agentId, options) {
         const scored = await rerankWithContext(effectiveQuery, candidates, rerankReturnLimit);
         rerankedRecords = scored.map((s) => merged[s.index]);
       } else {
-        const { rerank } = await import("./reranker-YVTLJCFC.js");
+        const { rerank } = await import("./reranker-NUIGAPA3.js");
         rerankedRecords = await rerank(effectiveQuery, merged, rerankReturnLimit);
       }
       if (rerankedRecords.length > 0) {
@@ -1191,7 +1191,7 @@ async function lightweightSearch(queryText, agentId, options) {
   }
   if (results.length >= 2) {
     try {
-      const { recordCoActivations } = await import("./co-activation-XNBLOGK3.js");
+      const { recordCoActivations } = await import("./co-activation-UEEDCM5U.js");
       const ids = results.slice(0, 10).map((r) => r.id);
       void recordCoActivations(ids).catch((e) => {
         try {
@@ -1207,7 +1207,7 @@ async function lightweightSearch(queryText, agentId, options) {
   }
   if (options?.includeStructuredCards !== true) return results;
   try {
-    const { searchMemoryCards } = await import("./memory-cards-KG4TPNKK.js");
+    const { searchMemoryCards } = await import("./memory-cards-4EXX3BQS.js");
     const cardResults = await searchMemoryCards(queryText, agentId, options);
     if (cardResults.length > 0) {
       return rrfMergeMulti([results, cardResults], limit, RRF_K, [1, 0.85]);

package/dist/{chunk-HNPHPGGF.js → chunk-KIKB6FY3.js}

@@ -1,9 +1,9 @@
 import {
   sendMessage
-} from "./chunk-SNWV44E5.js";
+} from "./chunk-DSKEYEL2.js";
 import {
   getActiveAgent
-} from "./chunk-WRP5AG4D.js";
+} from "./chunk-23KWUA7Z.js";
 
 // src/mcp/tools/send-message.ts
 import { z } from "zod";

package/dist/{chunk-STFR72YH.js → chunk-LCDW2HUL.js}

@@ -1,7 +1,7 @@
 import {
   getIdentity,
   loadEmployeesSync
-} from "./chunk-EA5FVACM.js";
+} from "./chunk-HLU52KTO.js";
 
 // src/lib/drift-probes.ts
 var DRIFT_THRESHOLD = 80;

package/dist/{chunk-RFUTLZ2U.js → chunk-LG37UBBE.js}

@@ -1,13 +1,13 @@
 import {
   embed
-} from "./chunk-I5AVZOL2.js";
+} from "./chunk-3YBJ36UX.js";
 import {
   reserveVersions,
   vectorToBlob
-} from "./chunk-W5YV2PZE.js";
+} from "./chunk-DKRDU2AX.js";
 import {
   getClient
-} from "./chunk-EA5FVACM.js";
+} from "./chunk-HLU52KTO.js";
 
 // src/lib/documents.ts
 import crypto from "crypto";
@@ -270,7 +270,7 @@ async function ingestDocument(input) {
   await client.batch([documentStmt, ...chunkStmts], "write");
   const embedded = vectors.filter((v) => v !== null).length;
   const originalTexts = input.chunks.map((c) => c.text);
-  import("./doc-graph-extractor-FNCYPFKY.js").then(
+  import("./doc-graph-extractor-RR2VSO4W.js").then(
     ({ extractAndStoreDocumentGraph }) => extractAndStoreDocumentGraph(documentId, originalTexts)
   ).catch((err) => {
     process.stderr.write(