@askexenow/exe-os 0.9.405 → 0.9.407

package/dist/chunk-XMUG7XDN.js

@@ -0,0 +1,546 @@
+// src/lib/exe-shims.ts
+import {
+  closeSync,
+  constants as fsConstants,
+  existsSync,
+  linkSync,
+  openSync,
+  readSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { randomBytes } from "crypto";
+import { spawn, spawnSync } from "child_process";
+import path from "path";
+import os from "os";
+var SHIM_MARKER = "# managed-by: exe-os postinstall";
+function readBinEntries(packageRoot) {
+  const pkgPath = path.join(packageRoot, "package.json");
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  } catch {
+    return [];
+  }
+  const bin = pkg.bin;
+  if (!bin || typeof bin !== "object") return [];
+  return Object.entries(bin).filter((entry) => typeof entry[1] === "string").map(([name, distRelative]) => ({ name, distRelative }));
+}
+function isRealGlobalInstall(env = process.env) {
+  return env.npm_config_global === "true";
+}
+var MAX_CAPTURE_BYTES = 64 * 1024;
+function spawnLoginShellCapture(shell, script, env, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let out = "";
+    let child;
+    try {
+      child = spawn(shell, ["-lic", script], {
+        env: { ...env },
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    function finish(result) {
+      if (settled) return;
+      settled = true;
+      try {
+        clearTimeout(timer);
+      } catch {
+      }
+      try {
+        child.stdout?.removeAllListeners();
+        child.stderr?.removeAllListeners();
+        child.removeAllListeners();
+      } catch {
+      }
+      try {
+        child.stdout?.destroy();
+      } catch {
+      }
+      try {
+        child.stderr?.destroy();
+      } catch {
+      }
+      if (child.pid) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+      try {
+        resolve(result);
+      } catch {
+      }
+    }
+    try {
+      child.stdout?.on("data", (chunk) => {
+        try {
+          out += chunk.toString("utf8");
+          if (out.length > MAX_CAPTURE_BYTES) {
+            finish(null);
+          }
+        } catch {
+          finish(null);
+        }
+      });
+    } catch {
+    }
+    try {
+      child.stderr?.on("data", () => {
+      });
+    } catch {
+    }
+    try {
+      child.on("error", () => {
+        try {
+          finish(null);
+        } catch {
+        }
+      });
+    } catch {
+    }
+    try {
+      child.on("exit", () => {
+        try {
+          finish(out);
+        } catch {
+        }
+      });
+    } catch {
+    }
+  });
+}
+function extractMarked(haystack, begin, end) {
+  const startIdx = haystack.indexOf(begin);
+  if (startIdx === -1) return null;
+  const from = startIdx + begin.length;
+  const endIdx = haystack.indexOf(end, from);
+  if (endIdx === -1) return null;
+  return haystack.slice(from, endIdx);
+}
+var PATH_BEGIN = "__EXE_PATH_BEGIN__";
+var PATH_END = "__EXE_PATH_END__";
+async function resolveLoginPath(env = process.env, timeoutMs = 3e3) {
+  const shell = env.SHELL;
+  if (!shell) return { path: null, unknown: true };
+  const script = `printf '%s' "${PATH_BEGIN}\${PATH}${PATH_END}"`;
+  const stdout = await spawnLoginShellCapture(shell, script, env, timeoutMs);
+  if (stdout === null) return { path: null, unknown: true };
+  const extracted = extractMarked(stdout, PATH_BEGIN, PATH_END);
+  if (extracted === null) return { path: null, unknown: true };
+  return { path: extracted, unknown: false };
+}
+function splitPath(pathStr) {
+  return pathStr.split(path.delimiter).map((entry) => entry.trim()).filter(Boolean);
+}
+function parseProcessPath(pathStr) {
+  const entries = pathStr.split(":");
+  if (entries.some((entry) => entry === "")) return null;
+  return entries;
+}
+function indexOfDirOnPath(dir, entries) {
+  const target = path.resolve(dir);
+  return entries.findIndex((entry) => path.resolve(entry) === target);
+}
+function isDirOnPath(dir, pathStr) {
+  return indexOfDirOnPath(dir, splitPath(pathStr)) !== -1;
+}
+function shQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function shimScript(nodePath, entryPath, version) {
+  return [
+    "#!/bin/sh",
+    SHIM_MARKER,
+    `# version: ${version}`,
+    "# Generated by exe-os postinstall. Do not edit by hand \u2014 it is overwritten on",
+    "# every install/update. Delete it and reinstall if it is wrong.",
+    `NODE_BIN=${shQuote(nodePath)}`,
+    `ENTRY=${shQuote(entryPath)}`,
+    'if [ ! -x "$NODE_BIN" ]; then',
+    '  echo "exe-os: $NODE_BIN not found \u2014 reinstall with: npm i -g @askexenow/exe-os" >&2',
+    "  exit 127",
+    "fi",
+    'if [ ! -f "$ENTRY" ]; then',
+    '  echo "exe-os: $ENTRY not found \u2014 reinstall with: npm i -g @askexenow/exe-os" >&2',
+    "  exit 127",
+    "fi",
+    'exec "$NODE_BIN" "$ENTRY" "$@"',
+    ""
+  ].join("\n");
+}
+function parseShimPaths(content) {
+  const nodeMatch = /^NODE_BIN=(.*)$/m.exec(content);
+  const entryMatch = /^ENTRY=(.*)$/m.exec(content);
+  const unquote = (raw) => {
+    if (!raw) return null;
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("'") || !trimmed.endsWith("'") || trimmed.length < 2) return null;
+    return trimmed.slice(1, -1).split("'\\''").join("'");
+  };
+  return { nodeBin: unquote(nodeMatch?.[1]), entry: unquote(entryMatch?.[1]) };
+}
+function safeReadHead(file, maxBytes = 1024) {
+  let fd = null;
+  try {
+    fd = openSync(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+    const buf = Buffer.alloc(maxBytes);
+    const n = readSync(fd, buf, 0, maxBytes, 0);
+    return buf.subarray(0, n).toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function safeLstat(file) {
+  try {
+    return lstatSync(file);
+  } catch {
+    return null;
+  }
+}
+function createTempFile(dir, name, content, opts) {
+  const attempts = opts?.attempts ?? 5;
+  const randomFn = opts?.randomFn ?? (() => randomBytes(6).toString("hex"));
+  let lastErr = new Error(`createTempFile: exhausted ${attempts} attempt(s) for ${name}`);
+  for (let i = 0; i < attempts; i++) {
+    const tmp = path.join(dir, `.${name}.exe-shim-tmp-${randomFn()}`);
+    try {
+      writeFileSync(tmp, content, { mode: 493, flag: "wx" });
+      return tmp;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        lastErr = err;
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastErr;
+}
+function writeShimFile(dir, name, content, opts) {
+  const target = path.join(dir, name);
+  let tmp = null;
+  try {
+    const existing = safeLstat(target);
+    const isUpdate = existing !== null;
+    if (existing) {
+      if (existing.isSymbolicLink()) return { status: "skipped_symlink", path: target };
+      if (!existing.isFile()) return { status: "skipped_special", path: target };
+      if (!safeReadHead(target).includes(SHIM_MARKER)) return { status: "skipped_unmanaged", path: target };
+    }
+    tmp = createTempFile(dir, name, content);
+    opts?.beforePublish?.();
+    if (!isUpdate) {
+      try {
+        linkSync(tmp, target);
+      } catch (err) {
+        if (err.code === "EEXIST") {
+          return { status: "skipped_race", path: target };
+        }
+        throw err;
+      }
+    } else {
+      const recheck = safeLstat(target);
+      if (!recheck || recheck.isSymbolicLink() || !recheck.isFile() || !safeReadHead(target).includes(SHIM_MARKER)) {
+        return { status: "skipped_race", path: target };
+      }
+      renameSync(tmp, target);
+    }
+    return { status: "written", path: target };
+  } catch (err) {
+    return { status: "error", path: target, detail: err instanceof Error ? err.message : String(err) };
+  } finally {
+    if (tmp) {
+      try {
+        rmSync(tmp, { force: true });
+      } catch {
+      }
+    }
+  }
+}
+function isTempShimName(name) {
+  return name.includes(".exe-shim-tmp-");
+}
+function removeStaleManagedShims(dir, keepNames) {
+  const removed = [];
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return removed;
+  }
+  const isStillAManagedRegularFile = (full) => {
+    const st = safeLstat(full);
+    if (!st || st.isSymbolicLink() || !st.isFile()) return false;
+    return safeReadHead(full).includes(SHIM_MARKER);
+  };
+  for (const entry of entries) {
+    if (keepNames.has(entry)) continue;
+    if (isTempShimName(entry)) continue;
+    const full = path.join(dir, entry);
+    if (!isStillAManagedRegularFile(full)) continue;
+    if (isTempShimName(entry) || !isStillAManagedRegularFile(full)) continue;
+    try {
+      rmSync(full, { force: true });
+      removed.push(full);
+    } catch {
+    }
+  }
+  return removed;
+}
+function isExecutableFile(p) {
+  try {
+    const st = statSync(p);
+    return st.isFile() && (st.mode & 73) !== 0;
+  } catch {
+    return false;
+  }
+}
+function isOwnExeOsPath(p) {
+  let real;
+  try {
+    real = realpathSync(p);
+  } catch {
+    real = p;
+  }
+  return /[\\/](@askexenow[\\/]exe-os|exe-os)(?:[\\/]|$)/.test(real);
+}
+function findShadowingExecutable(name, pathEntries, fromIndexExclusive) {
+  for (let i = fromIndexExclusive + 1; i < pathEntries.length; i++) {
+    const dir = pathEntries[i];
+    if (!dir) continue;
+    const candidate = path.join(dir, name);
+    if (!isExecutableFile(candidate)) continue;
+    if (isOwnExeOsPath(candidate)) continue;
+    return candidate;
+  }
+  return null;
+}
+function resolveNpmBinDir(opts) {
+  const env = opts.env ?? process.env;
+  if (env.npm_config_prefix) {
+    return path.join(env.npm_config_prefix, "bin");
+  }
+  const marker = `${path.sep}lib${path.sep}node_modules${path.sep}`;
+  const idx = opts.packageRoot.indexOf(marker);
+  if (idx !== -1) {
+    return path.join(opts.packageRoot.slice(0, idx), "bin");
+  }
+  const execDir = path.dirname(opts.execPath);
+  return execDir || null;
+}
+function verifyBinLink(binDir, name, expectedDistEntry) {
+  const binLinkPath = path.join(binDir, name);
+  let real;
+  try {
+    real = realpathSync(binLinkPath);
+  } catch {
+    return { binLinkPath, valid: false };
+  }
+  let expectedReal;
+  try {
+    expectedReal = realpathSync(expectedDistEntry);
+  } catch {
+    expectedReal = path.resolve(expectedDistEntry);
+  }
+  return { binLinkPath, valid: path.resolve(real) === path.resolve(expectedReal) };
+}
+function installStableShims(opts) {
+  const result = {
+    skipped: false,
+    written: [],
+    skippedUnmanaged: [],
+    skippedSymlinks: [],
+    skippedSpecial: [],
+    skippedRace: [],
+    skippedShadowed: [],
+    skippedNoBinLink: [],
+    removedStale: [],
+    errors: []
+  };
+  if (!opts.eligible) {
+    result.skipped = true;
+    result.reason = "not-eligible";
+    return result;
+  }
+  const homeDir = opts.homeDir ?? os.homedir();
+  const rawPath = opts.pathEnv ?? process.env.PATH ?? "";
+  const binDir = path.join(homeDir, ".local", "bin");
+  result.binDir = binDir;
+  const pathEntries = parseProcessPath(rawPath);
+  if (pathEntries === null) {
+    result.skipped = true;
+    result.reason = "path-unknown";
+    result.hint = `exe-os: your PATH could not be parsed cleanly (it contains an empty entry, which a shell reads as "current directory") \u2014 stable exe-* command shims were not installed, to avoid guessing. Fix your PATH and re-run \`npm i -g @askexenow/exe-os\` if you want them.`;
+    return result;
+  }
+  const binDirIndex = indexOfDirOnPath(binDir, pathEntries);
+  if (binDirIndex === -1) {
+    result.skipped = true;
+    result.reason = "not-on-path";
+    result.hint = `exe-os: ~/.local/bin is not on your PATH, so stable exe-* command shims were not installed. Add 'export PATH="$HOME/.local/bin:$PATH"' to your shell profile (e.g. ~/.zshrc or ~/.bashrc) to use them.`;
+    return result;
+  }
+  try {
+    mkdirSync(binDir, { recursive: true });
+  } catch (err) {
+    result.skipped = true;
+    result.reason = "mkdir-failed";
+    result.errors.push({ name: "mkdir", detail: err instanceof Error ? err.message : String(err) });
+    return result;
+  }
+  const binEntries = readBinEntries(opts.packageRoot);
+  const execPath = opts.execPath ?? process.execPath;
+  const npmBinDir = opts.npmBinDir ?? resolveNpmBinDir({ packageRoot: opts.packageRoot, execPath, env: opts.env });
+  const keep = /* @__PURE__ */ new Set();
+  for (const entry of binEntries) {
+    keep.add(entry.name);
+    const shadow = findShadowingExecutable(entry.name, pathEntries, binDirIndex);
+    if (shadow) {
+      result.skippedShadowed.push({ name: entry.name, shadowedBy: shadow });
+      continue;
+    }
+    try {
+      const entryPath = path.join(opts.packageRoot, entry.distRelative);
+      if (!npmBinDir) {
+        result.skippedNoBinLink.push({ name: entry.name, binLinkPath: "" });
+        continue;
+      }
+      const linkCheck = verifyBinLink(npmBinDir, entry.name, entryPath);
+      if (!linkCheck.valid) {
+        result.skippedNoBinLink.push({ name: entry.name, binLinkPath: linkCheck.binLinkPath });
+        continue;
+      }
+      const content = shimScript(execPath, linkCheck.binLinkPath, opts.version);
+      const writeResult = writeShimFile(binDir, entry.name, content);
+      switch (writeResult.status) {
+        case "written":
+          result.written.push(writeResult.path);
+          break;
+        case "skipped_symlink":
+          result.skippedSymlinks.push(writeResult.path);
+          break;
+        case "skipped_unmanaged":
+          result.skippedUnmanaged.push(writeResult.path);
+          break;
+        case "skipped_special":
+          result.skippedSpecial.push(writeResult.path);
+          break;
+        case "skipped_race":
+          result.skippedRace.push(writeResult.path);
+          break;
+        case "error":
+          result.errors.push({ name: entry.name, detail: writeResult.detail });
+          break;
+      }
+    } catch (err) {
+      result.errors.push({ name: entry.name, detail: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  try {
+    result.removedStale = removeStaleManagedShims(binDir, keep);
+  } catch (err) {
+    result.errors.push({ name: "stale-cleanup", detail: err instanceof Error ? err.message : String(err) });
+  }
+  return result;
+}
+function uninstallStableShims(opts) {
+  const homeDir = opts.homeDir ?? os.homedir();
+  const binDir = path.join(homeDir, ".local", "bin");
+  return removeStaleManagedShims(binDir, /* @__PURE__ */ new Set());
+}
+var NODE_BEGIN = "__EXE_NODE_BEGIN__";
+var NODE_END = "__EXE_NODE_END__";
+var EXE_BEGIN = "__EXE_EXE_BEGIN__";
+var EXE_END = "__EXE_EXE_END__";
+async function probeLoginShellNode(env = process.env, timeoutMs = 5e3) {
+  const shell = env.SHELL;
+  if (!shell) return { unknown: true, loginNodePath: null, loginExePath: null };
+  const script = `printf '%s' "${NODE_BEGIN}$(command -v node)${NODE_END}"; printf '%s' "${EXE_BEGIN}$(command -v exe-launch-agent)${EXE_END}"`;
+  const stdout = await spawnLoginShellCapture(shell, script, env, timeoutMs);
+  if (stdout === null) return { unknown: true, loginNodePath: null, loginExePath: null };
+  const node = extractMarked(stdout, NODE_BEGIN, NODE_END);
+  const exe = extractMarked(stdout, EXE_BEGIN, EXE_END);
+  if (node === null || exe === null) return { unknown: true, loginNodePath: null, loginExePath: null };
+  return {
+    unknown: false,
+    loginNodePath: node.trim() || null,
+    loginExePath: exe.trim() || null
+  };
+}
+function nodeVersionAt(nodePath, timeoutMs = 3e3) {
+  try {
+    const result = spawnSync(nodePath, ["--version"], { encoding: "utf8", timeout: timeoutMs });
+    if (result.error || result.status !== 0 || typeof result.stdout !== "string") return null;
+    return result.stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function inspectManagedShim(binDir, name, exists = existsSync) {
+  const target = path.join(binDir, name);
+  const st = safeLstat(target);
+  if (!st) {
+    return { name, present: false, managed: false, nodeBin: null, entry: null, nodeExists: false, entryExists: false };
+  }
+  if (st.isSymbolicLink() || !st.isFile()) {
+    return { name, present: true, managed: false, nodeBin: null, entry: null, nodeExists: false, entryExists: false };
+  }
+  const content = safeReadHead(target, SHIM_INSPECT_MAX_BYTES);
+  const managed = content.includes(SHIM_MARKER);
+  const { nodeBin, entry } = parseShimPaths(content);
+  return {
+    name,
+    present: true,
+    managed,
+    nodeBin,
+    entry,
+    nodeExists: nodeBin ? exists(nodeBin) : false,
+    entryExists: entry ? exists(entry) : false
+  };
+}
+var SHIM_INSPECT_MAX_BYTES = 4096;
+
+export {
+  SHIM_MARKER,
+  readBinEntries,
+  isRealGlobalInstall,
+  resolveLoginPath,
+  splitPath,
+  parseProcessPath,
+  indexOfDirOnPath,
+  isDirOnPath,
+  shimScript,
+  parseShimPaths,
+  createTempFile,
+  writeShimFile,
+  removeStaleManagedShims,
+  findShadowingExecutable,
+  resolveNpmBinDir,
+  verifyBinLink,
+  installStableShims,
+  uninstallStableShims,
+  probeLoginShellNode,
+  nodeVersionAt,
+  inspectManagedShim
+};

package/dist/{chunk-RKEREP4O.js → chunk-XT7ZZJVD.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-WCGNCH3Q.js";
 import {
   registerAllTools
-} from "./chunk-DDWLI43S.js";
+} from "./chunk-PCLIU4BP.js";
 
 // src/mcp/mcp-surface-hash.ts
 function computeMcpSurfaceHash() {

package/dist/{chunk-NSJUD5BW.js → chunk-Y73MI7UH.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-VMHZSZQJ.js";
 import {
   filterWikiRecallResults
-} from "./chunk-DJKUA73M.js";
+} from "./chunk-ZWQWLUZA.js";
 import {
   attachDocumentMetadata,
   buildRawVisibilityFilter,
@@ -16,7 +16,7 @@ import {
   buildVisibilityTierFilter,
   buildWikiScopeFilter,
   searchMemories
-} from "./chunk-MXEEMTCV.js";
+} from "./chunk-R5YD5DIP.js";
 import {
   blobToVector
 } from "./chunk-OTVEIJUQ.js";
@@ -35,7 +35,7 @@ import {
   getClient,
   isFtsShadowCorruptionMessage,
   repairFtsTable
-} from "./chunk-YWH7XWOX.js";
+} from "./chunk-HPDR3EL7.js";
 
 // src/lib/memory-reads.ts
 import crypto from "crypto";
@@ -597,7 +597,7 @@ async function hybridSearch(queryText, agentId, options) {
   let rerankerAvailable = false;
   if (process.env.EXE_IS_DAEMON === "1") {
     try {
-      const { isRerankerAvailable } = await import("./reranker-YBVXW2ZZ.js");
+      const { isRerankerAvailable } = await import("./reranker-XC2LXYD3.js");
       rerankerAvailable = isRerankerAvailable();
     } catch {
     }
@@ -637,7 +637,7 @@ ${hydeDoc}`;
   if (config.fileGrepEnabled === true && !process.env.VITEST && !onFailOpenHotPath) {
     try {
       if (process.env.EXE_IS_DAEMON !== "1") {
-        const { getProjectName } = await import("./project-name-FUSV5KYR.js");
+        const { getProjectName } = await import("./project-name-KQUBSY5O.js");
         const projectRoot = process.cwd();
         const projectName = getProjectName(projectRoot);
         if (projectName && projectName !== "tmp") {
@@ -680,7 +680,7 @@ ${hydeDoc}`;
     runGraphArm(graphSearch(effectiveQuery, agentId, fetchOptions, Math.min(fetchLimit, 20))),
     includeStructuredCards ? (async () => {
       try {
-        const { searchMemoryCards } = await import("./memory-cards-DR6VSUXF.js");
+        const { searchMemoryCards } = await import("./memory-cards-JN32U2KA.js");
         return await searchMemoryCards(effectiveQuery, agentId, fetchOptions);
       } catch {
         return [];
@@ -689,7 +689,7 @@ ${hydeDoc}`;
     // Reflection insights: patterns, contradictions, summaries across sessions
     includeStructuredCards ? (async () => {
       try {
-        const { searchReflections } = await import("./memory-reflection-SR657DTL.js");
+        const { searchReflections } = await import("./memory-reflection-R6TAIUOR.js");
         const insights = await searchReflections(effectiveQuery, agentId, 5, fetchOptions);
         return insights.map((ins) => ({
           id: ins.id,
@@ -801,7 +801,7 @@ ${hydeDoc}`;
   let entityBoostRan = false;
   if (merged.length > 0) {
     try {
-      const { applyEntityBoost } = await import("./entity-boost-EIE76PER.js");
+      const { applyEntityBoost } = await import("./entity-boost-KTADWOGJ.js");
       const boosted = await applyEntityBoost(merged, effectiveQuery, getClient());
       merged = boosted.results;
       graphContextMap = boosted.graphContext;
@@ -828,7 +828,7 @@ ${hydeDoc}`;
     try {
       let rerankedRecords;
       if (graphContextMap.size > 0) {
-        const { rerankWithContext } = await import("./reranker-YBVXW2ZZ.js");
+        const { rerankWithContext } = await import("./reranker-XC2LXYD3.js");
         const candidates = merged.map((m) => ({
           text: m.raw_text,
           context: graphContextMap.get(m.id)
@@ -836,7 +836,7 @@ ${hydeDoc}`;
         const scored = await rerankWithContext(effectiveQuery, candidates, rerankReturnLimit);
         rerankedRecords = scored.map((s) => merged[s.index]);
       } else {
-        const { rerank } = await import("./reranker-YBVXW2ZZ.js");
+        const { rerank } = await import("./reranker-XC2LXYD3.js");
         rerankedRecords = await rerank(effectiveQuery, merged, rerankReturnLimit);
       }
       if (rerankedRecords.length > 0) {
@@ -1293,7 +1293,7 @@ async function lightweightSearch(queryText, agentId, options) {
   }
   if (results.length >= 2) {
     try {
-      const { recordCoActivations } = await import("./co-activation-DGPZOQNM.js");
+      const { recordCoActivations } = await import("./co-activation-LB56BYW2.js");
       const ids = results.slice(0, 10).map((r) => r.id);
       void recordCoActivations(ids).catch((e) => {
         try {
@@ -1309,7 +1309,7 @@ async function lightweightSearch(queryText, agentId, options) {
   }
   if (options?.includeStructuredCards !== true) return results;
   try {
-    const { searchMemoryCards } = await import("./memory-cards-DR6VSUXF.js");
+    const { searchMemoryCards } = await import("./memory-cards-JN32U2KA.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-H6ET4UWS.js → chunk-YB5IW32Y.js}

@@ -4,21 +4,21 @@ import {
   assertUsableEpoch,
   deriveOrgKeyIdentities,
   describeEpochRemedy
-} from "./chunk-A2TRWGTX.js";
+} from "./chunk-ZGRLIQLE.js";
 import {
   InviteError,
   resolveAuth,
   resolveEndpoint
-} from "./chunk-AAAJKHJM.js";
+} from "./chunk-G4MVORCE.js";
 import {
   asOrgBillablePlan
 } from "./chunk-W4H2MZAS.js";
 import {
   orgKeyFingerprintDisplay
-} from "./chunk-QEGSRMGV.js";
+} from "./chunk-52JOFQOK.js";
 import {
   ed25519PrivateKeyFromSeed
-} from "./chunk-B42HMZSQ.js";
+} from "./chunk-ERIXGUSV.js";
 
 // src/lib/org-key-admin.ts
 import { sign } from "crypto";