@remnic/core 9.69.46 → 9.69.48

package/dist/chunk-P3YNEMYY.js

@@ -0,0 +1,212 @@
+import {
+  isGenericRecallExcludedPath
+} from "./chunk-DE4ZGH2N.js";
+import {
+  normalizeProjectionPreview
+} from "./chunk-SCU65EZI.js";
+import {
+  isSupportPassportPrivateMemory
+} from "./chunk-PWPIERBM.js";
+import {
+  toMemoryPathRel
+} from "./chunk-7RJUVTVF.js";
+import {
+  RECALL_FALLBACK_DIRS
+} from "./chunk-VS2IYZRU.js";
+
+// src/memory-browse.ts
+var MAX_LS_ENTRIES = 200;
+var MAX_TREE_ENTRIES = 400;
+var MAX_TREE_DEPTH = 4;
+var MAX_FIND_ENTRIES = 200;
+var MAX_PATH_CHARS = 512;
+var MAX_PATTERN_CHARS = 256;
+var BROWSABLE_ROOTS = Object.fromEntries(RECALL_FALLBACK_DIRS.map((dir) => [dir, true]));
+function isBrowsableMemoryPath(relPath) {
+  if (!relPath.endsWith(".md")) return false;
+  const top = relPath.split("/")[0] ?? "";
+  return BROWSABLE_ROOTS[top] === true && !isGenericRecallExcludedPath(relPath);
+}
+function sanitizeBrowsePath(raw) {
+  const trimmed = (raw ?? "").trim();
+  if (trimmed === "" || trimmed === "/") return "";
+  if (trimmed.length > MAX_PATH_CHARS) throw new Error("path is too long");
+  if (trimmed.includes("\\")) throw new Error("path must use '/' separators");
+  const segments = trimmed.split("/");
+  for (const segment of segments) {
+    if (segment === "") throw new Error("path has an empty segment");
+    if (segment === "." || segment === "..") throw new Error("path must not contain '.' or '..' segments");
+    for (const ch of segment) {
+      const code = ch.charCodeAt(0);
+      if (code < 32 || code === 127) throw new Error("path has control characters");
+    }
+  }
+  return segments.join("/");
+}
+function segmentRegex(segment) {
+  const source = `^${segment.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`;
+  return new RegExp(source, "i");
+}
+function browsePatternMatches(pattern, relPath) {
+  const segments = relPath.split("/");
+  const name = segments[segments.length - 1] ?? "";
+  const patternSegments = pattern.split("/");
+  if (patternSegments.length === 1) {
+    const single = patternSegments[0];
+    if (single.includes("*")) return segmentRegex(single).test(name);
+    const needle = single.toLowerCase();
+    return relPath.toLowerCase().includes(needle) || name.toLowerCase().includes(needle);
+  }
+  if (patternSegments.length !== segments.length) return false;
+  return patternSegments.every((segment, index) => segmentRegex(segment).test(segments[index]));
+}
+function emptyNode() {
+  return { subdirs: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map(), count: 0 };
+}
+function buildIndex(memories, dir) {
+  const root = emptyNode();
+  for (const memory of memories) {
+    const rel = toMemoryPathRel(dir, memory.path);
+    if (!isBrowsableMemoryPath(rel)) continue;
+    const segments = rel.split("/");
+    let node = root;
+    node.count += 1;
+    for (let index = 0; index < segments.length - 1; index += 1) {
+      const name = segments[index];
+      let child = node.subdirs.get(name);
+      if (child === void 0) {
+        child = emptyNode();
+        node.subdirs.set(name, child);
+      }
+      node = child;
+      node.count += 1;
+    }
+    node.files.set(segments[segments.length - 1], memory);
+  }
+  return root;
+}
+function byPath(left, right) {
+  return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
+}
+function dirEntries(node, dirPath) {
+  const prefix = dirPath === "" ? "" : `${dirPath}/`;
+  const entries = [];
+  for (const [name, child] of node.subdirs) {
+    entries.push({ path: `${prefix}${name}`, kind: "dir", name, description: "", count: child.count, depth: 0 });
+  }
+  for (const [name, memory] of node.files) {
+    entries.push({
+      path: `${prefix}${name}`,
+      kind: "file",
+      name,
+      description: normalizeProjectionPreview(memory.content),
+      count: 1,
+      depth: 0
+    });
+  }
+  return entries.sort(byPath);
+}
+function renderEntries(verb, namespace, browsePath, entries) {
+  const lines = [`${verb} ${namespace}:${browsePath === "" ? "/" : browsePath}`];
+  for (const entry of entries) {
+    const indent = "  ".repeat(entry.depth);
+    if (entry.kind === "dir") {
+      lines.push(`${indent}${entry.path}/ (${entry.count} memories)`);
+    } else {
+      const description = entry.description.length > 0 ? ` \u2014 ${entry.description}` : "";
+      lines.push(`${indent}${entry.path}${description}`);
+    }
+  }
+  return lines.join("\n");
+}
+function refusal(verb, browsePath, error, message) {
+  return { ok: false, verb, path: browsePath, error, message, rendered: `browse ${verb} failed: ${error} \u2014 ${message}` };
+}
+async function runMemoryBrowse(deps, request) {
+  const namespace = deps.resolveReadableNamespace(request.namespace, request.authenticatedPrincipal);
+  const storage = await deps.getStorage(namespace);
+  const memories = (await storage.readAllMemories()).filter((memory) => !isSupportPassportPrivateMemory(memory));
+  if (request.verb === "find") {
+    const pattern = (request.pattern ?? "").trim();
+    if (pattern.length === 0) return refusal(request.verb, "", "invalid_pattern", "pattern is required");
+    if (pattern.length > MAX_PATTERN_CHARS) {
+      return refusal(request.verb, "", "invalid_pattern", "pattern is too long");
+    }
+    const hits = [];
+    let truncated2 = false;
+    let total = 0;
+    for (const memory of memories) {
+      const rel = toMemoryPathRel(storage.dir, memory.path);
+      if (!isBrowsableMemoryPath(rel)) continue;
+      if (!browsePatternMatches(pattern, rel)) continue;
+      total += 1;
+      if (hits.length >= MAX_FIND_ENTRIES) {
+        truncated2 = true;
+        break;
+      }
+      hits.push({
+        path: rel,
+        kind: "file",
+        name: rel.split("/").pop() ?? rel,
+        description: normalizeProjectionPreview(memory.content),
+        count: 1,
+        depth: 0
+      });
+    }
+    hits.sort(byPath);
+    return { ok: true, verb: "find", namespace, path: "", total, entries: hits, truncated: truncated2, rendered: renderEntries("find", namespace, "", hits) };
+  }
+  let browsePath;
+  try {
+    browsePath = sanitizeBrowsePath(request.path);
+  } catch (err) {
+    return refusal(request.verb, request.path ?? "", "invalid_path", err instanceof Error ? err.message : String(err));
+  }
+  const root = buildIndex(memories, storage.dir);
+  let node = root;
+  for (const segment of browsePath === "" ? [] : browsePath.split("/")) {
+    node = node?.subdirs.get(segment);
+    if (node === void 0) break;
+  }
+  if (node === void 0) {
+    return refusal(request.verb, browsePath, "not_found", `no browsable store path: ${browsePath}`);
+  }
+  if (request.verb === "ls") {
+    const all = dirEntries(node, browsePath);
+    const truncated2 = all.length > MAX_LS_ENTRIES;
+    const entries2 = all.slice(0, MAX_LS_ENTRIES);
+    return { ok: true, verb: "ls", namespace, path: browsePath, total: all.length, entries: entries2, truncated: truncated2, rendered: renderEntries("ls", namespace, browsePath, entries2) };
+  }
+  if (request.depth !== void 0 && (!Number.isInteger(request.depth) || request.depth < 1 || request.depth > MAX_TREE_DEPTH)) {
+    return refusal(request.verb, browsePath, "invalid_depth", `depth must be an integer between 1 and ${MAX_TREE_DEPTH}`);
+  }
+  const depth = request.depth ?? 1;
+  const entries = [];
+  let truncated = false;
+  const walk = (current, currentPath, currentDepth) => {
+    for (const entry of dirEntries(current, currentPath)) {
+      if (entries.length >= MAX_TREE_ENTRIES) {
+        truncated = true;
+        return;
+      }
+      entries.push({ ...entry, depth: currentDepth });
+      if (entry.kind === "dir" && currentDepth < depth - 1) {
+        walk(current.subdirs.get(entry.name), entry.path, currentDepth + 1);
+        if (truncated) return;
+      }
+    }
+  };
+  walk(node, browsePath, 0);
+  return { ok: true, verb: "tree", namespace, path: browsePath, total: entries.length, entries, truncated, rendered: renderEntries("tree", namespace, browsePath, entries) };
+}
+
+export {
+  MAX_LS_ENTRIES,
+  MAX_TREE_ENTRIES,
+  MAX_TREE_DEPTH,
+  MAX_FIND_ENTRIES,
+  sanitizeBrowsePath,
+  browsePatternMatches,
+  runMemoryBrowse
+};
+//# sourceMappingURL=chunk-P3YNEMYY.js.map

package/dist/chunk-P3YNEMYY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-browse.ts"],"sourcesContent":["/**\n * Memory-store browse verbs (issue #2978) — deterministic `ls` / `tree` /\n * `find` over ONE resolved namespace's memory store, so an agent can see\n * what exists instead of guessing ids at an opaque search box.\n *\n * Scope rules (all existing contracts, no new ones):\n *   - Every call resolves through the caller's `resolveReadableNamespace`\n *     (read/write path symmetry) and ONE storage instance — browse never\n *     enumerates across namespaces.\n *   - Only the recall corpus is browsable: a path's top segment must be a\n *     `RECALL_FALLBACK_DIRS` category AND survive\n *     `isGenericRecallExcludedPath`. Derived stores (`artifacts/`,\n *     `meetings/` records, wearables day stores, `state/`, ...) are\n *     indistinguishable from missing paths — `not_found`, never listed.\n *   - Support-passport private memories are filtered exactly like\n *     `memoryBrowse` (the paginated list): their names never appear.\n *   - Output is deterministically sorted (plain code-point order, no\n *     locale) and entry-capped so a huge store cannot blow the response.\n *\n * `ponytail:` the index is rebuilt from `readAllMemories()` per call —\n * O(corpus) per browse. Fine at agent cadence; swap for a cached directory\n * index if browsing ever sits on a hot path.\n */\n\nimport { toMemoryPathRel } from \"./memory-lifecycle-ledger-utils.js\";\nimport { normalizeProjectionPreview } from \"./memory-projection-format.js\";\nimport { isGenericRecallExcludedPath } from \"./orchestration/generic-recall-paths.js\";\nimport { isSupportPassportPrivateMemory } from \"./support-passport/card-projection.js\";\nimport { RECALL_FALLBACK_DIRS } from \"./utils/category-dir.js\";\nimport type { MemoryFile } from \"./types.js\";\n\n/** Browse reads touch only these storage members. */\nexport interface MemoryBrowseStorage {\n  readonly dir: string;\n  readAllMemories(): Promise<MemoryFile[]>;\n}\n\n/** Injected seams; the service supplies live wiring, tests supply doubles. */\nexport interface MemoryBrowseDeps {\n  readonly resolveReadableNamespace: (namespace: string | undefined, principal?: string) => string;\n  readonly getStorage: (namespace: string) => Promise<MemoryBrowseStorage>;\n}\n\nexport type BrowseVerb = \"ls\" | \"tree\" | \"find\";\n\nexport interface MemoryStoreBrowseRequest {\n  readonly verb: BrowseVerb;\n  /** ls/tree: directory relative to the store root (\"\" or \"/\" = root). */\n  readonly path?: string;\n  /** tree: expansion depth, 1..MAX_TREE_DEPTH (default 1). */\n  readonly depth?: number;\n  /** find: glob (`*` wildcard) or substring matched against path and name. */\n  readonly pattern?: string;\n  readonly namespace?: string;\n  readonly authenticatedPrincipal?: string;\n}\n\nexport interface MemoryBrowseEntry {\n  /** Store-relative path with forward slashes; dirs carry no trailing slash. */\n  readonly path: string;\n  readonly kind: \"dir\" | \"file\";\n  readonly name: string;\n  /** Files: first content line (180-char preview). Dirs: empty. */\n  readonly description: string;\n  /** Dirs: recursive memory count beneath. Files: 1. */\n  readonly count: number;\n  /** 0-based depth relative to the browse root (tree nests; ls/find are 0). */\n  readonly depth: number;\n}\n\nexport type MemoryBrowseError = \"invalid_path\" | \"not_found\" | \"invalid_depth\" | \"invalid_pattern\";\n\nexport type MemoryStoreBrowseResult =\n  | {\n      ok: true;\n      verb: BrowseVerb;\n      namespace: string;\n      path: string;\n      total: number;\n      entries: MemoryBrowseEntry[];\n      truncated: boolean;\n      rendered: string;\n    }\n  | {\n      ok: false;\n      verb: BrowseVerb;\n      path: string;\n      error: MemoryBrowseError;\n      message: string;\n      rendered: string;\n    };\n\nexport const MAX_LS_ENTRIES = 200;\nexport const MAX_TREE_ENTRIES = 400;\nexport const MAX_TREE_DEPTH = 4;\nexport const MAX_FIND_ENTRIES = 200;\nconst MAX_PATH_CHARS = 512;\nconst MAX_PATTERN_CHARS = 256;\n\nconst BROWSABLE_ROOTS: Record<string, true> = Object.fromEntries(RECALL_FALLBACK_DIRS.map((dir) => [dir, true]));\n\n/** The recall-corpus visibility rule shared by every browse code path. */\nfunction isBrowsableMemoryPath(relPath: string): boolean {\n  if (!relPath.endsWith(\".md\")) return false;\n  const top = relPath.split(\"/\")[0] ?? \"\";\n  return BROWSABLE_ROOTS[top] === true && !isGenericRecallExcludedPath(relPath);\n}\n\n/**\n * Normalize a caller-supplied store path. Returns \"\" for the root. Throws\n * `Error` on absolute paths, `..`/`.` segments, backslashes, control\n * characters, or oversize input — never reinterpreted (pattern 39).\n */\nexport function sanitizeBrowsePath(raw: string | undefined): string {\n  const trimmed = (raw ?? \"\").trim();\n  if (trimmed === \"\" || trimmed === \"/\") return \"\";\n  if (trimmed.length > MAX_PATH_CHARS) throw new Error(\"path is too long\");\n  if (trimmed.includes(\"\\\\\")) throw new Error(\"path must use '/' separators\");\n  const segments = trimmed.split(\"/\");\n  for (const segment of segments) {\n    if (segment === \"\") throw new Error(\"path has an empty segment\");\n    if (segment === \".\" || segment === \"..\") throw new Error(\"path must not contain '.' or '..' segments\");\n    for (const ch of segment) {\n      const code = ch.charCodeAt(0);\n      if (code < 0x20 || code === 0x7f) throw new Error(\"path has control characters\");\n    }\n  }\n  return segments.join(\"/\");\n}\n\n/** Escape every regex metacharacter in a glob segment. */\nfunction segmentRegex(segment: string): RegExp {\n  const source = `^${segment.split(\"*\").map((part) => part.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\")).join(\".*\")}$`;\n  return new RegExp(source, \"i\");\n}\n\n/**\n * `*` glob (one segment per pattern segment, `find -name` semantics — `*`\n * never crosses `/`) or case-insensitive substring over path and name.\n */\nexport function browsePatternMatches(pattern: string, relPath: string): boolean {\n  const segments = relPath.split(\"/\");\n  const name = segments[segments.length - 1] ?? \"\";\n  const patternSegments = pattern.split(\"/\");\n  if (patternSegments.length === 1) {\n    const single = patternSegments[0]!;\n    if (single.includes(\"*\")) return segmentRegex(single).test(name);\n    const needle = single.toLowerCase();\n    return relPath.toLowerCase().includes(needle) || name.toLowerCase().includes(needle);\n  }\n  if (patternSegments.length !== segments.length) return false;\n  return patternSegments.every((segment, index) => segmentRegex(segment).test(segments[index]!));\n}\n\ninterface DirNode {\n  readonly subdirs: Map<string, DirNode>;\n  readonly files: Map<string, MemoryFile>;\n  count: number;\n}\n\nfunction emptyNode(): DirNode {\n  return { subdirs: new Map(), files: new Map(), count: 0 };\n}\n\n/** Directory index over the browsable corpus: root \"\" holds category dirs. */\nfunction buildIndex(memories: readonly MemoryFile[], dir: string): DirNode {\n  const root = emptyNode();\n  for (const memory of memories) {\n    const rel = toMemoryPathRel(dir, memory.path);\n    if (!isBrowsableMemoryPath(rel)) continue;\n    const segments = rel.split(\"/\");\n    let node = root;\n    node.count += 1;\n    for (let index = 0; index < segments.length - 1; index += 1) {\n      const name = segments[index]!;\n      let child = node.subdirs.get(name);\n      if (child === undefined) {\n        child = emptyNode();\n        node.subdirs.set(name, child);\n      }\n      node = child;\n      node.count += 1;\n    }\n    node.files.set(segments[segments.length - 1]!, memory);\n  }\n  return root;\n}\n\nfunction byPath(left: { path: string }, right: { path: string }): number {\n  return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;\n}\n\nfunction dirEntries(node: DirNode, dirPath: string): MemoryBrowseEntry[] {\n  const prefix = dirPath === \"\" ? \"\" : `${dirPath}/`;\n  const entries: MemoryBrowseEntry[] = [];\n  for (const [name, child] of node.subdirs) {\n    entries.push({ path: `${prefix}${name}`, kind: \"dir\", name, description: \"\", count: child.count, depth: 0 });\n  }\n  for (const [name, memory] of node.files) {\n    entries.push({\n      path: `${prefix}${name}`,\n      kind: \"file\",\n      name,\n      description: normalizeProjectionPreview(memory.content),\n      count: 1,\n      depth: 0,\n    });\n  }\n  return entries.sort(byPath);\n}\n\nfunction renderEntries(verb: BrowseVerb, namespace: string, browsePath: string, entries: readonly MemoryBrowseEntry[]): string {\n  const lines = [`${verb} ${namespace}:${browsePath === \"\" ? \"/\" : browsePath}`];\n  for (const entry of entries) {\n    const indent = \"  \".repeat(entry.depth);\n    if (entry.kind === \"dir\") {\n      lines.push(`${indent}${entry.path}/ (${entry.count} memories)`);\n    } else {\n      const description = entry.description.length > 0 ? ` — ${entry.description}` : \"\";\n      lines.push(`${indent}${entry.path}${description}`);\n    }\n  }\n  return lines.join(\"\\n\");\n}\n\nfunction refusal(verb: BrowseVerb, browsePath: string, error: MemoryBrowseError, message: string): MemoryStoreBrowseResult {\n  return { ok: false, verb, path: browsePath, error, message, rendered: `browse ${verb} failed: ${error} — ${message}` };\n}\n\n/** Run one browse verb. Malformed input throws `Error`; typed refusals return in-band. */\nexport async function runMemoryBrowse(\n  deps: MemoryBrowseDeps,\n  request: MemoryStoreBrowseRequest,\n): Promise<MemoryStoreBrowseResult> {\n  const namespace = deps.resolveReadableNamespace(request.namespace, request.authenticatedPrincipal);\n  const storage = await deps.getStorage(namespace);\n  const memories = (await storage.readAllMemories()).filter((memory) => !isSupportPassportPrivateMemory(memory));\n\n  if (request.verb === \"find\") {\n    const pattern = (request.pattern ?? \"\").trim();\n    if (pattern.length === 0) return refusal(request.verb, \"\", \"invalid_pattern\", \"pattern is required\");\n    if (pattern.length > MAX_PATTERN_CHARS) {\n      return refusal(request.verb, \"\", \"invalid_pattern\", \"pattern is too long\");\n    }\n    const hits: MemoryBrowseEntry[] = [];\n    let truncated = false;\n    let total = 0;\n    for (const memory of memories) {\n      const rel = toMemoryPathRel(storage.dir, memory.path);\n      if (!isBrowsableMemoryPath(rel)) continue;\n      if (!browsePatternMatches(pattern, rel)) continue;\n      total += 1;\n      if (hits.length >= MAX_FIND_ENTRIES) {\n        truncated = true;\n        break;\n      }\n      hits.push({\n        path: rel,\n        kind: \"file\",\n        name: rel.split(\"/\").pop() ?? rel,\n        description: normalizeProjectionPreview(memory.content),\n        count: 1,\n        depth: 0,\n      });\n    }\n    hits.sort(byPath);\n    return { ok: true, verb: \"find\", namespace, path: \"\", total, entries: hits, truncated, rendered: renderEntries(\"find\", namespace, \"\", hits) };\n  }\n\n  let browsePath: string;\n  try {\n    browsePath = sanitizeBrowsePath(request.path);\n  } catch (err) {\n    return refusal(request.verb, request.path ?? \"\", \"invalid_path\", err instanceof Error ? err.message : String(err));\n  }\n  const root = buildIndex(memories, storage.dir);\n  let node: DirNode | undefined = root;\n  for (const segment of browsePath === \"\" ? [] : browsePath.split(\"/\")) {\n    node = node?.subdirs.get(segment);\n    if (node === undefined) break;\n  }\n  // Invisible-by-design stores resolve as not_found, indistinguishable from\n  // a missing path: the index only ever contains browsable corpus paths.\n  if (node === undefined) {\n    return refusal(request.verb, browsePath, \"not_found\", `no browsable store path: ${browsePath}`);\n  }\n\n  if (request.verb === \"ls\") {\n    const all = dirEntries(node, browsePath);\n    const truncated = all.length > MAX_LS_ENTRIES;\n    const entries = all.slice(0, MAX_LS_ENTRIES);\n    return { ok: true, verb: \"ls\", namespace, path: browsePath, total: all.length, entries, truncated, rendered: renderEntries(\"ls\", namespace, browsePath, entries) };\n  }\n\n  if (request.depth !== undefined && (!Number.isInteger(request.depth) || request.depth < 1 || request.depth > MAX_TREE_DEPTH)) {\n    return refusal(request.verb, browsePath, \"invalid_depth\", `depth must be an integer between 1 and ${MAX_TREE_DEPTH}`);\n  }\n  const depth = request.depth ?? 1;\n  const entries: MemoryBrowseEntry[] = [];\n  let truncated = false;\n  const walk = (current: DirNode, currentPath: string, currentDepth: number): void => {\n    for (const entry of dirEntries(current, currentPath)) {\n      if (entries.length >= MAX_TREE_ENTRIES) {\n        truncated = true;\n        return;\n      }\n      entries.push({ ...entry, depth: currentDepth });\n      if (entry.kind === \"dir\" && currentDepth < depth - 1) {\n        walk(current.subdirs.get(entry.name)!, entry.path, currentDepth + 1);\n        if (truncated) return;\n      }\n    }\n  };\n  walk(node, browsePath, 0);\n  return { ok: true, verb: \"tree\", namespace, path: browsePath, total: entries.length, entries, truncated, rendered: renderEntries(\"tree\", namespace, browsePath, entries) };\n}\n"],"mappings":"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","names":["truncated","entries"]}

package/dist/{chunk-JOP7W24J.js → chunk-PA67GXYJ.js}

@@ -1,9 +1,3 @@
-import {
-  NoopSearchBackend
-} from "./chunk-CYEPCZN5.js";
-import {
-  OramaBackend
-} from "./chunk-G6NQ3L4T.js";
 import {
   RemoteSearchBackend
 } from "./chunk-WPGR3RW4.js";
@@ -16,6 +10,12 @@ import {
 import {
   MeilisearchBackend
 } from "./chunk-KVO2BTA4.js";
+import {
+  NoopSearchBackend
+} from "./chunk-CYEPCZN5.js";
+import {
+  OramaBackend
+} from "./chunk-G6NQ3L4T.js";
 import {
   createConversationIndexBackend
 } from "./chunk-TFA6HPOA.js";
@@ -24,7 +24,7 @@ import {
 } from "./chunk-F4TWWUMP.js";
 import {
   QmdClient
-} from "./chunk-KG2OOAFF.js";
+} from "./chunk-TQSCR5DU.js";
 import {
   resolveIndexingCapabilities,
   resolvePipelineProcessingCapabilities,
@@ -179,4 +179,4 @@ export {
   createConversationSearchBackend,
   createConversationIndexRuntime
 };
-//# sourceMappingURL=chunk-JOP7W24J.js.map
+//# sourceMappingURL=chunk-PA67GXYJ.js.map

package/dist/{chunk-FSH6KRKO.js → chunk-PPJLJD2D.js}

@@ -1,6 +1,6 @@
 import {
   parseEntityFile
-} from "./chunk-QUFJ3NJE.js";
+} from "./chunk-MNG536IS.js";
 import {
   inferMemoryStatus
 } from "./chunk-7RJUVTVF.js";
@@ -253,4 +253,4 @@ export {
   WHO_KNOWS_MCP_TOOLS,
   handleWhoKnowsHttpQuery
 };
-//# sourceMappingURL=chunk-FSH6KRKO.js.map
+//# sourceMappingURL=chunk-PPJLJD2D.js.map

package/dist/{chunk-AG6PANBG.js → chunk-PXJ6HE2W.js}

@@ -3,7 +3,7 @@ import {
   headerConnector,
   renderExtractionConversation,
   resolveSourceConnector
-} from "./chunk-4XTSKGLX.js";
+} from "./chunk-JYXLW22X.js";
 import {
   normalizeReasoningTrace
 } from "./chunk-54V4BZWP.js";
@@ -29,14 +29,6 @@ import {
   stripUntrustedFactSpans,
   truncateLocalExtractionConversation
 } from "./chunk-XVZA6VXC.js";
-import {
-  attachExtractionProvenance
-} from "./chunk-PGAB2V53.js";
-import {
-  classifyExtractionThrownError,
-  classifyFallbackParseFailure,
-  formatExtractionParseFailureLog
-} from "./chunk-PJRKLB4Z.js";
 import {
   containsExtractionPlaceholder,
   extractionAttributes,
@@ -44,6 +36,14 @@ import {
   extractionText,
   isPlainRecord
 } from "./chunk-FJMYMJLR.js";
+import {
+  attachExtractionProvenance
+} from "./chunk-SMBWBEE7.js";
+import {
+  classifyExtractionThrownError,
+  classifyFallbackParseFailure,
+  formatExtractionParseFailureLog
+} from "./chunk-PJRKLB4Z.js";
 import {
   delinearize
 } from "./chunk-VEWZZM3H.js";
@@ -82,7 +82,7 @@ import {
 } from "./chunk-WLZYGLJ4.js";
 import {
   LocalLlmClient
-} from "./chunk-WGZHSQDV.js";
+} from "./chunk-G2XZFGYN.js";
 import {
   FallbackLlmClient,
   gatewayTaskChainOptions
@@ -2437,4 +2437,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-AG6PANBG.js.map
+//# sourceMappingURL=chunk-PXJ6HE2W.js.map

package/dist/{chunk-DDBLZJRV.js → chunk-QB4VXCFN.js}

@@ -1,6 +1,6 @@
 import {
   resolveCorpusNamespaceRoots
-} from "./chunk-SW42MMAH.js";
+} from "./chunk-MQT3WP3F.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-MZWSOLMT.js";
@@ -200,4 +200,4 @@ async function readAggregateExtractionWatermark(options) {
 export {
   readAggregateExtractionWatermark
 };
-//# sourceMappingURL=chunk-DDBLZJRV.js.map
+//# sourceMappingURL=chunk-QB4VXCFN.js.map

package/dist/{chunk-L63M2PE4.js → chunk-QGAKUOKU.js}

@@ -1,6 +1,6 @@
 import {
   RECALL_DISCLOSURE_LEVELS
-} from "./chunk-66YUOI53.js";
+} from "./chunk-WQW6KPVC.js";
 
 // src/recall-navigate.ts
 var RECALL_NAV_LINK_TYPES = [
@@ -48,4 +48,4 @@ export {
   expandRecallNode,
   traverseRecallLink
 };
-//# sourceMappingURL=chunk-L63M2PE4.js.map
+//# sourceMappingURL=chunk-QGAKUOKU.js.map

package/dist/{chunk-YUQPUK6H.js → chunk-QLCMOHRE.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-QUFJ3NJE.js";
+} from "./chunk-MNG536IS.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -957,4 +957,4 @@ export {
   resolveBriefingSaveDir,
   briefingFilename
 };
-//# sourceMappingURL=chunk-YUQPUK6H.js.map
+//# sourceMappingURL=chunk-QLCMOHRE.js.map

package/dist/{chunk-Q4AUIFUA.js → chunk-QMWKENNK.js}

@@ -1,6 +1,3 @@
-import {
-  ClaudeCodeAdapter
-} from "./chunk-J64TK33U.js";
 import {
   CodexAdapter
 } from "./chunk-RSUYKGGZ.js";
@@ -10,6 +7,9 @@ import {
 import {
   ReplitAdapter
 } from "./chunk-TMSXWOBZ.js";
+import {
+  ClaudeCodeAdapter
+} from "./chunk-J64TK33U.js";
 import {
   headerValue
 } from "./chunk-7RXCMVFQ.js";
@@ -108,4 +108,4 @@ export {
   OpenCodeAdapter,
   AdapterRegistry
 };
-//# sourceMappingURL=chunk-Q4AUIFUA.js.map
+//# sourceMappingURL=chunk-QMWKENNK.js.map