@remnic/core 9.45.3 → 9.45.5

package/dist/{chunk-4J7G5SY4.js → chunk-NZBZ7IS2.js}

@@ -2,6 +2,10 @@ import {
   normalizeSupersessionKey
 } from "./chunk-DNHVPZOD.js";
 import {
+  invalidateForScope
+} from "./chunk-XMMESCPD.js";
+import {
+  serializeMutations,
   withHeldFileLock
 } from "./chunk-FFAZ2XFU.js";
 import {
@@ -14,6 +18,66 @@ import {
   log
 } from "./chunk-3WCASNQZ.js";
 
+// src/storage/entity-canonical-id-lock.ts
+import { appendFileSync, mkdirSync, realpathSync } from "fs";
+import path from "path";
+var ENTITY_CANONICAL_ID_MUTATION_LOCK_STALE_MS = 6e4;
+var ENTITY_CANONICAL_ID_MUTATION_LOCK_MAX_WAIT_MS = 3e5;
+function isEntityPagePath(baseDir, filePath) {
+  if (path.extname(filePath) !== ".md") return false;
+  const parentDir = path.dirname(path.resolve(filePath));
+  const entitiesDir = path.resolve(baseDir, "entities");
+  if (parentDir === entitiesDir) return true;
+  try {
+    return realpathSync(parentDir) === path.join(realpathSync(baseDir), "entities");
+  } catch {
+    return false;
+  }
+}
+function recordRawEntityMutation(baseDir, stateDir) {
+  invalidateForScope(baseDir, "entity-write");
+  mkdirSync(stateDir, { recursive: true });
+  appendFileSync(path.join(stateDir, ".entity-mutation-version.log"), "x");
+}
+function withEntityCanonicalMutationLock(stateDir, task) {
+  const lockPath = path.join(stateDir, "entity-canonical-id-mutation.lock");
+  return serializeMutations(
+    lockPath,
+    () => withHeldFileLock(
+      lockPath,
+      {
+        staleMs: ENTITY_CANONICAL_ID_MUTATION_LOCK_STALE_MS,
+        maxWaitMs: ENTITY_CANONICAL_ID_MUTATION_LOCK_MAX_WAIT_MS
+      },
+      async (acquired, lock) => {
+        if (!acquired) throw new Error("Timed out waiting for entity mutation lock.");
+        return task(() => lock.refresh());
+      }
+    )
+  );
+}
+async function withRawEntityPageMutation(baseDir, filePath, task) {
+  if (!isEntityPagePath(baseDir, filePath)) {
+    return task(async () => true);
+  }
+  const stateDir = path.join(baseDir, "state");
+  return withEntityCanonicalMutationLock(stateDir, async (refreshLock) => {
+    try {
+      return await task(refreshLock);
+    } finally {
+      recordRawEntityMutation(baseDir, stateDir);
+    }
+  });
+}
+
+// src/storage/entity-id-safety.ts
+var UNSAFE_ENTITY_ID_PATTERN = /[\/\\\p{Cc}\p{Zl}\p{Zp}]/u;
+function assertSafeEntityId(entityId) {
+  if (UNSAFE_ENTITY_ID_PATTERN.test(entityId)) {
+    throw new Error("Refusing unsafe entity id containing a path separator or control character.");
+  }
+}
+
 // src/storage/entity-canonical-id-references.ts
 import path2 from "path";
 import {
@@ -21,7 +85,7 @@ import {
   constants,
   fstatSync,
   lstatSync,
-  realpathSync,
+  realpathSync as realpathSync2,
   openSync,
   readFileSync,
   renameSync,
@@ -29,26 +93,6 @@ import {
   writeFileSync
 } from "fs";
 import { randomUUID } from "crypto";
-
-// src/storage/entity-canonical-id-lock.ts
-import path from "path";
-var ENTITY_CANONICAL_ID_MUTATION_LOCK_STALE_MS = 6e4;
-var ENTITY_CANONICAL_ID_MUTATION_LOCK_MAX_WAIT_MS = 3e5;
-async function withEntityCanonicalMutationLock(stateDir, task) {
-  return withHeldFileLock(
-    path.join(stateDir, "entity-canonical-id-mutation.lock"),
-    {
-      staleMs: ENTITY_CANONICAL_ID_MUTATION_LOCK_STALE_MS,
-      maxWaitMs: ENTITY_CANONICAL_ID_MUTATION_LOCK_MAX_WAIT_MS
-    },
-    async (acquired, lock) => {
-      if (!acquired) throw new Error("Timed out waiting for entity mutation lock.");
-      return task(() => lock.refresh());
-    }
-  );
-}
-
-// src/storage/entity-canonical-id-references.ts
 var ENTITY_CANONICAL_ID_MIGRATION_FILE = "entity-canonical-id-migration-v1.json";
 function parseJournalMappings(raw) {
   const parsed = JSON.parse(raw);
@@ -58,6 +102,8 @@ function parseJournalMappings(raw) {
   const cleaned = /* @__PURE__ */ Object.create(null);
   for (const [legacyId, canonicalId] of Object.entries(mappings)) {
     if (legacyId.length > 0 && typeof canonicalId === "string" && canonicalId.length > 0) {
+      assertSafeEntityId(legacyId);
+      assertSafeEntityId(canonicalId);
       cleaned[legacyId] = canonicalId;
     }
   }
@@ -211,11 +257,11 @@ function requestEntityCanonicalIdReconcileSync(stateDir) {
       log.warn(`refusing to write entity canonical-id reconcile marker: ${stateDir} is not a real directory`);
       return;
     }
-    const parentRealPath = realpathSync(stateDir);
+    const parentRealPath = realpathSync2(stateDir);
     writeFileSync(temporary, `${(/* @__PURE__ */ new Date()).toISOString()}
 `, { mode: 384 });
     const recheck = lstatSync(stateDir);
-    if (recheck.isSymbolicLink() || !recheck.isDirectory() || realpathSync(stateDir) !== parentRealPath) {
+    if (recheck.isSymbolicLink() || !recheck.isDirectory() || realpathSync2(stateDir) !== parentRealPath) {
       rmSync(temporary, { force: true });
       log.warn(`refusing to publish entity canonical-id reconcile marker: ${stateDir} changed during write`);
       return;
@@ -317,6 +363,8 @@ function repairContentAfterJournalMoveSync(options) {
 
 export {
   withEntityCanonicalMutationLock,
+  withRawEntityPageMutation,
+  assertSafeEntityId,
   ENTITY_CANONICAL_ID_MIGRATION_FILE,
   appendCanonicalizedTombstone,
   HistoricalEntityCanonicalIdCache,
@@ -335,4 +383,4 @@ export {
   repairContentAfterJournalMove,
   repairContentAfterJournalMoveSync
 };
-//# sourceMappingURL=chunk-4J7G5SY4.js.map
+//# sourceMappingURL=chunk-NZBZ7IS2.js.map

package/dist/chunk-NZBZ7IS2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/entity-canonical-id-lock.ts","../src/storage/entity-id-safety.ts","../src/storage/entity-canonical-id-references.ts"],"sourcesContent":["import { appendFileSync, mkdirSync, realpathSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { invalidateForScope } from \"../memory-cache.js\";\nimport { serializeMutations, withHeldFileLock } from \"../utils/serialize-mutations.js\";\n\nconst ENTITY_CANONICAL_ID_MUTATION_LOCK_STALE_MS = 60_000;\nconst ENTITY_CANONICAL_ID_MUTATION_LOCK_MAX_WAIT_MS = 300_000;\n\nexport function isEntityPagePath(baseDir: string, filePath: string): boolean {\n  if (path.extname(filePath) !== \".md\") return false;\n  const parentDir = path.dirname(path.resolve(filePath));\n  const entitiesDir = path.resolve(baseDir, \"entities\");\n  if (parentDir === entitiesDir) return true;\n  try {\n    return realpathSync(parentDir) === path.join(realpathSync(baseDir), \"entities\");\n  } catch {\n    return false;\n  }\n}\n\nfunction recordRawEntityMutation(baseDir: string, stateDir: string): void {\n  invalidateForScope(baseDir, \"entity-write\");\n  mkdirSync(stateDir, { recursive: true });\n  appendFileSync(path.join(stateDir, \".entity-mutation-version.log\"), \"x\");\n}\n\nexport function withEntityCanonicalMutationLock<T>(\n  stateDir: string,\n  task: (refreshLock: () => Promise<boolean>) => Promise<T>,\n): Promise<T> {\n  const lockPath = path.join(stateDir, \"entity-canonical-id-mutation.lock\");\n  return serializeMutations(lockPath, () =>\n    withHeldFileLock(\n      lockPath,\n      {\n        staleMs: ENTITY_CANONICAL_ID_MUTATION_LOCK_STALE_MS,\n        maxWaitMs: ENTITY_CANONICAL_ID_MUTATION_LOCK_MAX_WAIT_MS,\n      },\n      async (acquired, lock) => {\n        if (!acquired) throw new Error(\"Timed out waiting for entity mutation lock.\");\n        return task(() => lock.refresh());\n      },\n    ),\n  );\n}\n\nexport async function withRawEntityPageMutation<T>(\n  baseDir: string,\n  filePath: string,\n  task: (refreshLock: () => Promise<boolean>) => Promise<T>,\n): Promise<T> {\n  if (!isEntityPagePath(baseDir, filePath)) {\n    return task(async () => true);\n  }\n  const stateDir = path.join(baseDir, \"state\");\n  return withEntityCanonicalMutationLock(stateDir, async (refreshLock) => {\n    try {\n      return await task(refreshLock);\n    } finally {\n      recordRawEntityMutation(baseDir, stateDir);\n    }\n  });\n}\n","const UNSAFE_ENTITY_ID_PATTERN = /[\\/\\\\\\p{Cc}\\p{Zl}\\p{Zp}]/u;\n\nexport function assertSafeEntityId(entityId: string): void {\n  if (UNSAFE_ENTITY_ID_PATTERN.test(entityId)) {\n    throw new Error(\"Refusing unsafe entity id containing a path separator or control character.\");\n  }\n}\n","/**\n * Write-boundary surface of the entity canonical-id migration (issue #2213).\n *\n * The migration itself (entity-canonical-id-migration.ts) renames legacy\n * entity files and rewrites references ONCE, to convergence, then retires.\n * Everything here exists so nothing can re-introduce a legacy reference\n * afterwards without the migration having to rescan the corpus:\n *\n * - store-mediated writes canonicalize the caller-supplied `entityRef`\n *   ({@link canonicalizeEntityRefOption});\n * - bulk writers that persist raw record bytes (capsule import/merge)\n *   canonicalize the frontmatter line ({@link canonicalizeEntityRefFrontmatter});\n * - raw-byte writers that CANNOT parse what they write (offline sync,\n *   consolidation-undo, governance restores) request one bounded\n *   reconciliation pass instead ({@link requestEntityCanonicalIdReconcile}).\n */\nimport path from \"node:path\";\nimport {\n  closeSync,\n  constants,\n  fstatSync,\n  lstatSync,\n  realpathSync,\n  openSync,\n  readFileSync,\n  renameSync,\n  rmSync,\n  writeFileSync,\n} from \"node:fs\";\nimport { randomUUID } from \"node:crypto\";\nimport { log } from \"../logger.js\";\nimport { isErrnoCode } from \"../utils/errno.js\";\nimport { RECALL_FALLBACK_DIRS } from \"../utils/category-dir.js\";\nimport { withEntityCanonicalMutationLock } from \"./entity-canonical-id-lock.js\";\nimport { assertSafeEntityId } from \"./entity-id-safety.js\";\nimport { normalizeSupersessionKey } from \"../temporal-supersession.js\";\n\nexport const ENTITY_CANONICAL_ID_MIGRATION_FILE = \"entity-canonical-id-migration-v1.json\";\n\n/**\n * Parse a journal document into a mapping table. A document without a valid\n * `mappings` object is a LEGITIMATELY empty table; an unreadable/unparsable\n * document THROWS so callers can distinguish \"empty\" from \"failed\".\n */\nfunction parseJournalMappings(raw: string): Readonly<Record<string, string>> {\n  const parsed: unknown = JSON.parse(raw);\n  if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed) || !(\"mappings\" in parsed)) return {};\n  const mappings = parsed.mappings;\n  if (!mappings || typeof mappings !== \"object\" || Array.isArray(mappings)) return {};\n  // Null prototype: journal-supplied ids like `constructor` must be own\n  // entries, never collide with Object.prototype (Codex P2, round 20).\n  const cleaned: Record<string, string> = Object.create(null) as Record<string, string>;\n  for (const [legacyId, canonicalId] of Object.entries(mappings)) {\n    if (legacyId.length > 0 && typeof canonicalId === \"string\" && canonicalId.length > 0) {\n      assertSafeEntityId(legacyId);\n      assertSafeEntityId(canonicalId);\n      cleaned[legacyId] = canonicalId;\n    }\n  }\n  return cleaned;\n}\n\ntype JournalRead =\n  | { kind: \"ok\"; raw: string; key: string }\n  | { kind: \"missing\" }\n  | { kind: \"refused\" }\n  | { kind: \"error\" };\n\n/**\n * Open the journal WITHOUT following symlinks and read content + identity\n * from the same opened inode (repo rule: reject symlink traversal from\n * memory directories). O_NOFOLLOW makes the open refuse a symlinked FINAL\n * component (ELOOP); the parent `state/` directory is verified AFTER the\n * open, together with a path↔fd identity pairing, so a parent swapped\n * around the open cannot hold: a swap still in place fails the parent\n * lstat, and a swap reverted fails the dev/ino pairing against the real\n * journal. Platforms without O_NOFOLLOW get the same post-open checks.\n */\nfunction readJournalFileNoFollow(statePath: string): JournalRead {\n  let fd: number;\n  try {\n    fd = openSync(statePath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));\n  } catch (error) {\n    if (isErrnoCode(error, \"ENOENT\")) return { kind: \"missing\" };\n    if (isErrnoCode(error, \"ELOOP\")) return { kind: \"refused\" };\n    return { kind: \"error\" };\n  }\n  try {\n    const s = fstatSync(fd);\n    if (!s.isFile()) return { kind: \"refused\" };\n    const parent = lstatSync(path.dirname(statePath));\n    if (parent.isSymbolicLink() || !parent.isDirectory()) return { kind: \"refused\" };\n    const l = lstatSync(statePath);\n    if (l.isSymbolicLink() || l.dev !== s.dev || l.ino !== s.ino) return { kind: \"refused\" };\n    return {\n      kind: \"ok\",\n      raw: readFileSync(fd, \"utf-8\"),\n      key: `${s.dev}:${s.ino}:${s.mtimeMs}:${s.ctimeMs}:${s.size}`,\n    };\n  } catch {\n    return { kind: \"error\" };\n  } finally {\n    closeSync(fd);\n  }\n}\n\nexport function loadHistoricalEntityCanonicalIds(stateDir: string): Readonly<Record<string, string>> {\n  const result = readJournalFileNoFollow(path.join(stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE));\n  if (result.kind !== \"ok\") return {};\n  try {\n    return parseJournalMappings(result.raw);\n  } catch {\n    return {};\n  }\n}\n\n/**\n * Append a tombstone with its identity canonicalized against the CURRENT\n * journal, then recheck: a peer publishing a mapping inside the\n * resolve-to-append window would leave the guard under the legacy id while\n * lookups canonicalize. Each identity change appends the replacement FIRST\n * (AGENTS.md §14 — the retired fact must never be without an active guard),\n * then revokes the superseded one — a park makes the prior canonical\n * claimant a distinct entity, and a stale keyed guard under it would\n * suppress that entity's facts. When the journal will not settle, one final\n * replacement runs under the entity MUTATION lock (parks publish under it).\n */\nexport async function appendCanonicalizedTombstone(\n  stateDir: string,\n  input: { entityRef?: string; supersessionKey?: string },\n  currentIds: () => Readonly<Record<string, string>>,\n  append: (identity: TombstoneIdentity) => Promise<string | null>,\n  revoke: (tombstoneId: string) => Promise<unknown>,\n  label: string,\n): Promise<string | null> {\n  let refIds = currentIds();\n  let identity = canonicalizeTombstoneIdentity(input.entityRef, input.supersessionKey, refIds);\n  let result = await append(identity);\n  const replaceIfChanged = async (next: TombstoneIdentity): Promise<boolean> => {\n    if (next.entityRef === identity.entityRef && next.supersessionKey === identity.supersessionKey) {\n      return false;\n    }\n    identity = next;\n    const superseded = result;\n    result = await append(next);\n    if (superseded !== null) {\n      try {\n        await revoke(superseded);\n      } catch (err) {\n        log.warn(`failed to revoke superseded tombstone ${superseded} for ${label}: ${err}`);\n      }\n    }\n    return true;\n  };\n  for (let attempt = 0; attempt < 3; attempt += 1) {\n    const fresh = currentIds();\n    if (fresh === refIds) return result;\n    refIds = fresh;\n    if (!(await replaceIfChanged(canonicalizeTombstoneIdentity(input.entityRef, input.supersessionKey, fresh)))) {\n      return result;\n    }\n  }\n  await withEntityCanonicalMutationLock(stateDir, async () => {\n    await replaceIfChanged(canonicalizeTombstoneIdentity(input.entityRef, input.supersessionKey, currentIds()));\n  });\n  return result;\n}\n\n/**\n * Journal mapping table keyed by the journal FILE's identity, so a long-lived\n * StorageManager never canonicalizes against a stale snapshot after ANY other\n * writer changes the journal — a peer process completing a migration, or\n * `pruneBlocked()` parking a contested mapping (which rewrites the journal\n * without bumping any shared version). `writeState` publishes via\n * temp-file-plus-rename, so every journal write swaps the inode and the key\n * always moves — the identity is taken from the fstat of the SAME opened\n * inode the content is read from (no stat→read window). Reload cost is one\n * open per lookup and one journal parse per actual change.\n *\n * Failure semantics: last-known data is served ONLY for the SAME state dir\n * (module-level instances can face several stores — another store's table\n * must never leak in), and a failed read/parse never commits the journal's\n * identity, so the next lookup retries instead of caching an empty table\n * under a valid key.\n */\nexport class HistoricalEntityCanonicalIdCache {\n  private mappings: Readonly<Record<string, string>> = {};\n  private key: string | null = null;\n  private stateDir: string | null = null;\n\n  get(stateDir: string): Readonly<Record<string, string>> {\n    const lastKnown = this.stateDir === stateDir ? this.mappings : {};\n    const result = readJournalFileNoFollow(path.join(stateDir, ENTITY_CANONICAL_ID_MIGRATION_FILE));\n    if (result.kind === \"refused\") {\n      // Symlinked/non-regular journal: never follow it, never adopt its\n      // identity — serve this store's last-known table. If it later becomes\n      // a regular file its identity differs from the stored key and reloads.\n      log.warn(\"ignoring non-regular entity canonical-id journal (symlink refused)\");\n      return lastKnown;\n    }\n    if (result.kind === \"error\") {\n      // A TRANSIENT open/read failure (EACCES/EIO) must not dump a valid\n      // table for {}: a write during the outage would skip canonicalization\n      // AND its post-write identity check would compare equal. Serve this\n      // store's last-known table; only a genuine ENOENT means \"no journal\".\n      return lastKnown;\n    }\n    const key = result.kind === \"missing\" ? \"missing\" : result.key;\n    if (key !== this.key || stateDir !== this.stateDir) {\n      let table: Readonly<Record<string, string>> = {};\n      if (result.kind === \"ok\") {\n        try {\n          table = parseJournalMappings(result.raw);\n        } catch {\n          // Parse failed under a VALID identity: do not commit the key —\n          // the next lookup retries instead of pinning an empty table.\n          return lastKnown;\n        }\n      }\n      this.mappings = table;\n      this.key = key;\n      this.stateDir = stateDir;\n    }\n    return this.mappings;\n  }\n}\n\nexport function resolveHistoricalEntityCanonicalId(\n  normalized: string,\n  mappings: Readonly<Record<string, string>>,\n): string {\n  let current = normalized;\n  const seen = new Set<string>();\n  while (!seen.has(current)) {\n    seen.add(current);\n    // Own properties only: an unmapped id like `constructor` must not read\n    // Object.prototype and return a function (Codex P2, round 20).\n    const next = Object.hasOwn(mappings, current) ? mappings[current] : undefined;\n    if (!next || next === current) break;\n    current = next;\n  }\n  return current;\n}\n\n/**\n * Canonicalize the `entityRef` a memory-write caller supplied (issue #2213).\n *\n * Extraction and capture callers pass whatever id the LLM or user produced,\n * which can name a legacy id this migration already renamed. Resolving at the\n * WRITE boundary means store-mediated writes can never re-introduce legacy\n * references — which is what let the completed migration retire its recurring\n * full-corpus reference rewrite. It also keeps write-time tombstone lookups on\n * the same id space as migrated tombstones. Unknown ids pass through verbatim.\n */\nexport function canonicalizeEntityRefOption<T extends { entityRef?: string }>(\n  options: T,\n  mappings: Readonly<Record<string, string>>,\n): T {\n  // Non-strings (absent, or a JS caller's null/junk) pass through untouched:\n  // this boundary canonicalizes ids, it does not take over input validation\n  // the write path never performed — serialization already drops falsy refs.\n  if (typeof options.entityRef !== \"string\") return options;\n  return { ...options, entityRef: resolveHistoricalEntityCanonicalId(options.entityRef, mappings) };\n}\n\n/**\n * Canonicalize the effective `entityRef:` line inside a raw memory record's\n * leading frontmatter block (issue #2213). Bulk writers that persist record\n * bytes verbatim — capsule import/merge — are a write boundary too: a capsule\n * can carry pre-migration memories whose refs the target's completed journal\n * already renamed, and no later reconciliation pass exists to absorb them.\n *\n * Line selection mirrors the frontmatter parser and the migration's own\n * serializer: the LAST `entityRef` key wins (indentation tolerated), its\n * indent is preserved, and CRLF records keep their line endings. The closing\n * delimiter must be a standalone `---` line. Non-frontmatter content, records\n * without an `entityRef` line, and ids the journal does not map all pass\n * through byte-identical.\n */\nexport function canonicalizeEntityRefFrontmatter(\n  content: string,\n  mappings: Readonly<Record<string, string>>,\n): string {\n  if (Object.keys(mappings).length === 0) return content;\n  const loc = locateEntityRefLine(content);\n  if (loc === null) return content;\n  const canonical = resolveHistoricalEntityCanonicalId(loc.value, mappings);\n  if (canonical === loc.value) return content;\n  const line = loc.lines[loc.index]!;\n  const indent = /^\\s*/.exec(line)?.[0] ?? \"\";\n  loc.lines[loc.index] = `${indent}entityRef: ${canonical}${line.endsWith(\"\\r\") ? \"\\r\" : \"\"}`;\n  return loc.lines.join(\"\\n\") + content.slice(loc.closeIndex);\n}\n\n/** The raw `entityRef` value in a record's leading frontmatter, or null. */\nexport function readEntityRefFromFrontmatter(content: string): string | null {\n  return locateEntityRefLine(content)?.value ?? null;\n}\n\nfunction locateEntityRefLine(\n  content: string,\n): { lines: string[]; index: number; value: string; closeIndex: number } | null {\n  if (!/^---\\r?\\n/.test(content)) return null;\n  const close = /\\r?\\n---(?:\\r?\\n|$)/g;\n  close.lastIndex = content.indexOf(\"\\n\") + 1;\n  const closeMatch = close.exec(content);\n  if (!closeMatch) return null;\n  const lines = content.slice(0, closeMatch.index).split(\"\\n\");\n  let index = -1;\n  for (let i = 1; i < lines.length; i += 1) {\n    if (/^\\s*entityRef\\s*:/.test(lines[i] ?? \"\")) index = i;\n  }\n  if (index === -1) return null;\n  const line = lines[index]!;\n  const value = line.slice(line.indexOf(\":\") + 1).replace(/\\r$/, \"\").trim();\n  if (value.length === 0) return null;\n  return { lines, index, value, closeIndex: closeMatch.index };\n}\n\n/**\n * Reconcile-pending marker (issue #2213). Raw-byte memory writers that CANNOT\n * canonicalize inline — offline-sync file replication (opaque, possibly\n * encrypted buffers), consolidation-undo restores, governance-run restores —\n * touch this marker instead. The next migration invocation honors it by\n * running ONE bounded reference-reconciliation pass over the completed\n * journal's retained mappings, then clears it. This replaces the retired\n * every-run corpus rewrite with a signal that fires only when a raw writer\n * actually landed unvetted bytes.\n */\nexport const ENTITY_CANONICAL_ID_RECONCILE_MARKER = \"entity-canonical-id-reconcile.pending\";\n/** The generation a migration run renamed aside for consumption; a crash can strand it. */\nexport const ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER = `${ENTITY_CANONICAL_ID_RECONCILE_MARKER}.consuming`;\n\nexport function requestEntityCanonicalIdReconcileSync(stateDir: string): void {\n  const markerPath = path.join(stateDir, ENTITY_CANONICAL_ID_RECONCILE_MARKER);\n  const temporary = `${markerPath}.${process.pid}.${randomUUID()}.tmp`;\n  try {\n    // Never write THROUGH a symlinked marker OR a symlinked state dir (repo\n    // rule: reject symlink traversal from memory directories). The parent is\n    // lstat-verified as a real directory — direct restore/import callers can\n    // reach this helper without validateRoots() — and temp-file-plus-rename\n    // handles the final component: rename() replaces a planted link ITSELF\n    // rather than following it, with no O_NOFOLLOW dependency.\n    const parent = lstatSync(stateDir);\n    if (parent.isSymbolicLink() || !parent.isDirectory()) {\n      log.warn(`refusing to write entity canonical-id reconcile marker: ${stateDir} is not a real directory`);\n      return;\n    }\n    const parentRealPath = realpathSync(stateDir);\n    writeFileSync(temporary, `${new Date().toISOString()}\\n`, { mode: 0o600 });\n    // Revalidate the parent between the temp write and publication (Codex\n    // P2, round 20): a state-dir swapped for a symlink after the check above\n    // would have landed the temp file through the link. Node has no openat,\n    // so the residual window is the realpath→rename gap — this recheck\n    // reduces check-then-use to the platform primitive's own atomicity.\n    const recheck = lstatSync(stateDir);\n    if (recheck.isSymbolicLink() || !recheck.isDirectory() || realpathSync(stateDir) !== parentRealPath) {\n      rmSync(temporary, { force: true });\n      log.warn(`refusing to publish entity canonical-id reconcile marker: ${stateDir} changed during write`);\n      return;\n    }\n    renameSync(temporary, markerPath);\n  } catch (error) {\n    rmSync(temporary, { force: true });\n    // Best effort by design: a marker failure must not fail the restore/sync\n    // that requested it (AGENTS.md §4). The reference stays legacy-but-readable\n    // until the next mapping change.\n    log.warn(`could not request entity canonical-id reconcile: ${error}`);\n  }\n}\n\nexport async function requestEntityCanonicalIdReconcile(stateDir: string): Promise<void> {\n  requestEntityCanonicalIdReconcileSync(stateDir);\n}\n\n/**\n * Post-persist TOCTOU guard (issue #2213). A writer resolves `entityRef`\n * against one journal generation, then awaits (snapshots, locks, fsyncs)\n * before its bytes land — a peer migration can publish AND finish its final\n * reference scan inside that window, leaving the just-written file behind.\n * Callers pass the mapping table captured at resolve time plus a fresh cache\n * read taken AFTER the write: the cache returns the identical object while\n * the journal file is unchanged, so an identity mismatch means the journal\n * moved mid-write and one bounded reconcile pass is requested.\n */\nexport function reconcileIfJournalMovedSync(\n  stateDir: string,\n  idsAtResolve: Readonly<Record<string, string>>,\n  idsAfterWrite: Readonly<Record<string, string>>,\n): void {\n  if (idsAtResolve === idsAfterWrite) return;\n  requestEntityCanonicalIdReconcileSync(stateDir);\n}\n\nexport async function reconcileIfJournalMoved(\n  stateDir: string,\n  idsAtResolve: Readonly<Record<string, string>>,\n  idsAfterWrite: Readonly<Record<string, string>>,\n): Promise<void> {\n  reconcileIfJournalMovedSync(stateDir, idsAtResolve, idsAfterWrite);\n}\n\n/**\n * Classify a raw write target for entity-reference handling (issue #2213):\n * - `\"memory\"` — hot recall / cold / archive record whose FRONTMATTER\n *   `entityRef` the writer must canonicalize at the write (and repair after).\n * - `\"entity\"` — an `entities/` page. Its migrated surface is relationship\n *   TARGETS in the body, which only `rewriteRelationshipTargets` understands;\n *   raw writers persist bytes faithfully and request the bounded reconcile\n *   pass instead of attempting a frontmatter rewrite.\n * - `\"outside\"` — transcripts, profiles, runtime state, and every other file\n *   outside the migration's scan scope: write byte-identical, no marker.\n */\nexport type EntityRefWritePathKind = \"memory\" | \"entity\" | \"outside\";\n\nexport function classifyEntityRefWritePath(baseDir: string, filePath: string): EntityRefWritePathKind {\n  if (!filePath.endsWith(\".md\")) return \"outside\";\n  const rel = path.relative(baseDir, filePath);\n  if (rel.startsWith(\"..\") || path.isAbsolute(rel)) return \"outside\";\n  const top = rel.split(path.sep)[0] ?? \"\";\n  if (top === \"entities\") return \"entity\";\n  return RECALL_FALLBACK_DIRS.includes(top) || top === \"cold\" || top === \"archive\" ? \"memory\" : \"outside\";\n}\n\n/** True when `filePath` is in the migration's scan scope at all. */\nexport function pathMayCarryEntityRefs(baseDir: string, filePath: string): boolean {\n  return classifyEntityRefWritePath(baseDir, filePath) !== \"outside\";\n}\n\n/**\n * Canonicalize a tombstone's identity fields at the append chokepoint\n * (issue #2213): emitters (forget, temporal supersession, pattern\n * reinforcement, supersede) build inputs from records that may have been\n * read before a peer migration completed. The supersession key embeds the\n * NORMALIZED entity segment (`entity::attr`), so it is re-prefixed when the\n * ref moved — otherwise the keyed guard lands in the legacy id space while\n * write-time lookups canonicalize, and a paraphrase resurrects.\n */\nexport interface TombstoneIdentity {\n  entityRef: string | undefined;\n  supersessionKey: string | undefined;\n}\n\nexport function canonicalizeTombstoneIdentity(\n  entityRef: string | undefined,\n  supersessionKey: string | undefined,\n  refIds: Readonly<Record<string, string>>,\n): TombstoneIdentity {\n  if (typeof entityRef !== \"string\") return { entityRef, supersessionKey };\n  const canonical = resolveHistoricalEntityCanonicalId(entityRef, refIds);\n  if (canonical === entityRef) return { entityRef, supersessionKey };\n  if (supersessionKey) {\n    const stalePrefix = `${normalizeSupersessionKey(entityRef)}::`;\n    if (supersessionKey.startsWith(stalePrefix)) {\n      supersessionKey = `${normalizeSupersessionKey(canonical)}::${supersessionKey.slice(stalePrefix.length)}`;\n    }\n  }\n  return { entityRef: canonical, supersessionKey };\n}\n\n/**\n * Post-persist repair (issue #2213): when the journal moved across a persist,\n * re-resolve the caller's ORIGINAL ref against the fresh table and rewrite\n * the file in place (bounded). When the journal will not settle, take the\n * entity MUTATION lock — parks/removals (the direction the reconcile pass\n * cannot repair, because the removed mapping is gone from the table) publish\n * under it — settle once, then request the marker for additive moves only.\n */\nexport async function repairEntityRefAfterJournalMove(options: {\n  stateDir: string;\n  currentIds: () => Readonly<Record<string, string>>;\n  idsAtResolve: Readonly<Record<string, string>>;\n  rawRef: string;\n  frontmatter: { entityRef?: string };\n  rewrite: () => Promise<void>;\n}): Promise<void> {\n  let refIds = options.idsAtResolve;\n  for (let attempt = 0; attempt < 3; attempt += 1) {\n    const fresh = options.currentIds();\n    if (fresh === refIds) return;\n    refIds = fresh;\n    const desired = resolveHistoricalEntityCanonicalId(options.rawRef, fresh);\n    if (desired === options.frontmatter.entityRef) return;\n    options.frontmatter.entityRef = desired;\n    await options.rewrite();\n  }\n  await withEntityCanonicalMutationLock(options.stateDir, async () => {\n    const desired = resolveHistoricalEntityCanonicalId(options.rawRef, options.currentIds());\n    if (desired !== options.frontmatter.entityRef) {\n      options.frontmatter.entityRef = desired;\n      await options.rewrite();\n    }\n  });\n  await requestEntityCanonicalIdReconcile(options.stateDir);\n}\n\n/**\n * Content-form counterpart of {@link repairEntityRefAfterJournalMove} for\n * async writers that persist raw record bytes (capsule import/merge,\n * binary-lifecycle redirects): same bounded loop, same locked settle.\n */\nexport async function repairContentAfterJournalMove(options: {\n  stateDir: string;\n  cache: HistoricalEntityCanonicalIdCache;\n  idsAtWrite: Readonly<Record<string, string>>;\n  rawContent: string;\n  lastWritten: string;\n  rewrite: (content: string) => Promise<void>;\n}): Promise<void> {\n  let refIds = options.idsAtWrite;\n  let written = options.lastWritten;\n  for (let attempt = 0; attempt < 3; attempt += 1) {\n    const fresh = options.cache.get(options.stateDir);\n    if (fresh === refIds) return;\n    refIds = fresh;\n    const desired = canonicalizeEntityRefFrontmatter(options.rawContent, fresh);\n    if (desired === written) return;\n    written = desired;\n    await options.rewrite(desired);\n  }\n  await withEntityCanonicalMutationLock(options.stateDir, async () => {\n    const desired = canonicalizeEntityRefFrontmatter(options.rawContent, options.cache.get(options.stateDir));\n    if (desired !== written) {\n      written = desired;\n      await options.rewrite(desired);\n    }\n  });\n  await requestEntityCanonicalIdReconcile(options.stateDir);\n}\n\n/**\n * Sync variant (space promotion, curation, review actions). Sync callers\n * cannot take the async mutation lock, so exhaustion surfaces a retryable\n * error after requesting the marker — a silent return could leave the bytes\n * on a parked canonical claimant the reconcile pass cannot restore.\n */\nexport function repairContentAfterJournalMoveSync(options: {\n  stateDir: string;\n  cache: HistoricalEntityCanonicalIdCache;\n  idsAtWrite: Readonly<Record<string, string>>;\n  rawContent: string;\n  lastWritten: string;\n  rewrite: (content: string) => void;\n}): void {\n  let refIds = options.idsAtWrite;\n  let written = options.lastWritten;\n  for (let attempt = 0; attempt < 3; attempt += 1) {\n    const fresh = options.cache.get(options.stateDir);\n    if (fresh === refIds) return;\n    refIds = fresh;\n    const desired = canonicalizeEntityRefFrontmatter(options.rawContent, fresh);\n    if (desired === written) return;\n    written = desired;\n    options.rewrite(desired);\n  }\n  requestEntityCanonicalIdReconcileSync(options.stateDir);\n  throw new Error(\n    \"entity canonical-id journal kept changing during post-write repair; retry the write\",\n  );\n}\n"],"mappings":"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","names":["path","realpathSync","path","path","realpathSync","path"]}

package/dist/{chunk-3TBLDMJA.js → chunk-O4KMGRXE.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SOBJ6NEY.js";
 import {
   summarizeDisclosureTokens
-} from "./chunk-TDHTVMPG.js";
+} from "./chunk-HFPASSFV.js";
 import {
   summarizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -175,6 +175,9 @@ function toRecallXraySnapshotFromLegacy(snapshot) {
     // behavior of the non-markdown surfaces.
     tierExplain: normalizeTierExplain(snapshot.tierExplain) ?? null,
     results,
+    appliedResultLimit: 0,
+    appliedResults: [],
+    headroomResults: [],
     filters,
     budget: { chars: 0, used: 0 },
     // Sanitize legacy session metadata at the adapter boundary so a
@@ -587,4 +590,4 @@ export {
   renderRecallExplain,
   parseRecallExplainFormat
 };
-//# sourceMappingURL=chunk-3TBLDMJA.js.map
+//# sourceMappingURL=chunk-O4KMGRXE.js.map

package/dist/chunk-O4KMGRXE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-explain-renderer.ts","../src/recall-xray-renderer.ts"],"sourcesContent":["/**\n * Renderers for RecallTierExplain (issue #518).\n *\n * Pure functions that format a `LastRecallSnapshot` and its\n * optional `tierExplain` field for human text and machine JSON\n * consumption.  CLI / HTTP / MCP surfaces consume these — they do\n * not format explain output themselves, so rendering is tested in\n * one place.\n */\n\nimport type { LastRecallSnapshot } from \"./recall-state.js\";\nimport type { RecallTierExplain } from \"./types.js\";\nimport { isRetrievalTier } from \"./retrieval-tiers.js\";\nimport type {\n  RecallXraySnapshot,\n  RecallFilterTrace,\n  RecallXrayResult,\n} from \"./recall-xray.js\";\nimport { renderXrayMarkdown } from \"./recall-xray-renderer.js\";\n\nfunction sanitizeString(v: unknown): string | null {\n  return typeof v === \"string\" && v.length > 0 ? v : null;\n}\n\nfunction sanitizeFiniteNumber(v: unknown): number | null {\n  return typeof v === \"number\" && Number.isFinite(v) ? v : null;\n}\n\n/**\n * `text` and `json` are the original formats (backwards-compatible\n * since issue #518).  `markdown` was added in issue #570 PR 7 and\n * delegates to the shared X-ray renderer so the three observability\n * surfaces stay in lock-step (CLAUDE.md rule 22).\n */\nexport type RecallExplainFormat = \"text\" | \"json\" | \"markdown\";\n\nexport interface RecallExplainJsonPayload {\n  hasExplain: boolean;\n  snapshotFound: boolean;\n  sessionKey: string | null;\n  recordedAt: string | null;\n  namespace: string | null;\n  memoryIds: string[];\n  source: string | null;\n  sourcesUsed: string[] | null;\n  latencyMs: number | null;\n  tierExplain: RecallTierExplain | null;\n}\n\nfunction normalizeTierExplain(value: unknown): RecallTierExplain | null {\n  if (!value || typeof value !== \"object\" || Array.isArray(value)) return null;\n  const raw = value as Record<string, unknown>;\n  const filteredBy = Array.isArray(raw.filteredBy)\n    ? raw.filteredBy.filter((x): x is string => typeof x === \"string\")\n    : [];\n  const sourceAnchors = Array.isArray(raw.sourceAnchors)\n    ? raw.sourceAnchors\n        .filter(\n          (a): a is { path: string; lineRange?: unknown } =>\n            !!a && typeof a === \"object\" && typeof (a as { path?: unknown }).path === \"string\",\n        )\n        .map((a) => {\n          const lr = (a as { lineRange?: unknown }).lineRange;\n          const lineRange =\n            Array.isArray(lr) &&\n            lr.length === 2 &&\n            Number.isFinite(lr[0]) &&\n            Number.isFinite(lr[1])\n              ? ([lr[0] as number, lr[1] as number] as [number, number])\n              : undefined;\n          return lineRange\n            ? { path: (a as { path: string }).path, lineRange }\n            : { path: (a as { path: string }).path };\n        })\n    : undefined;\n  return {\n    tier: isRetrievalTier(raw.tier) ? raw.tier : \"hybrid\",\n    tierReason: typeof raw.tierReason === \"string\" ? raw.tierReason : \"\",\n    filteredBy,\n    candidatesConsidered: sanitizeFiniteNumber(raw.candidatesConsidered) ?? 0,\n    latencyMs: sanitizeFiniteNumber(raw.latencyMs) ?? 0,\n    ...(sourceAnchors !== undefined ? { sourceAnchors } : {}),\n  };\n}\n\nexport function toRecallExplainJson(\n  snapshot: LastRecallSnapshot | null,\n): RecallExplainJsonPayload {\n  if (!snapshot) {\n    return {\n      hasExplain: false,\n      snapshotFound: false,\n      sessionKey: null,\n      recordedAt: null,\n      namespace: null,\n      memoryIds: [],\n      source: null,\n      sourcesUsed: null,\n      latencyMs: null,\n      tierExplain: null,\n    };\n  }\n  const normalizedExplain = normalizeTierExplain(snapshot.tierExplain);\n  return {\n    hasExplain: normalizedExplain !== null,\n    snapshotFound: true,\n    sessionKey: sanitizeString(snapshot.sessionKey),\n    recordedAt: sanitizeString(snapshot.recordedAt),\n    namespace: sanitizeString(snapshot.namespace),\n    memoryIds: Array.isArray(snapshot.memoryIds)\n      ? snapshot.memoryIds.filter((x): x is string => typeof x === \"string\")\n      : [],\n    source: sanitizeString(snapshot.source),\n    sourcesUsed: Array.isArray(snapshot.sourcesUsed)\n      ? snapshot.sourcesUsed.filter((x): x is string => typeof x === \"string\")\n      : null,\n    latencyMs: sanitizeFiniteNumber(snapshot.latencyMs),\n    tierExplain: normalizedExplain,\n  };\n}\n\n/**\n * Render the shared \"--- tier explain ---\" text block used by both the\n * recall-explain surface and the Recall X-ray surface.  Callers provide\n * the normalized `RecallTierExplain` (or `null` for the\n * not-populated/disabled case) so the block stays character-for-character\n * identical across surfaces (CLAUDE.md rule 22).  The returned strings do\n * NOT include leading blank lines or headers — callers own that framing.\n */\nexport function renderTierExplainTextLines(\n  tierExplain: RecallTierExplain | null,\n): string[] {\n  const lines: string[] = [];\n  if (!tierExplain) {\n    lines.push(\n      \"(not populated — direct-answer tier disabled or did not fire)\",\n    );\n    return lines;\n  }\n  lines.push(`tier: ${tierExplain.tier}`);\n  lines.push(`reason: ${tierExplain.tierReason}`);\n  lines.push(`candidates-considered: ${tierExplain.candidatesConsidered}`);\n  lines.push(`latency-ms: ${tierExplain.latencyMs}`);\n  if (tierExplain.filteredBy.length > 0) {\n    lines.push(`filtered-by: ${tierExplain.filteredBy.join(\", \")}`);\n  } else {\n    lines.push(\"filtered-by: (none)\");\n  }\n  if (tierExplain.sourceAnchors && tierExplain.sourceAnchors.length > 0) {\n    lines.push(\"source-anchors:\");\n    for (const anchor of tierExplain.sourceAnchors) {\n      const range = anchor.lineRange\n        ? `:${anchor.lineRange[0]}-${anchor.lineRange[1]}`\n        : \"\";\n      lines.push(`  - ${anchor.path}${range}`);\n    }\n  }\n  return lines;\n}\n\nexport function toRecallExplainText(\n  snapshot: LastRecallSnapshot | null,\n): string {\n  const lines: string[] = [\"=== Recall Explain ===\"];\n\n  if (!snapshot) {\n    lines.push(\"No recall snapshot recorded yet.\");\n    return lines.join(\"\\n\");\n  }\n\n  const sessionKey = sanitizeString(snapshot.sessionKey);\n  const recordedAt = sanitizeString(snapshot.recordedAt);\n  const namespace = sanitizeString(snapshot.namespace);\n  const source = sanitizeString(snapshot.source);\n  lines.push(`session: ${sessionKey ?? \"(unknown)\"}`);\n  lines.push(`recorded: ${recordedAt ?? \"(unknown)\"}`);\n  if (namespace) lines.push(`namespace: ${namespace}`);\n  if (source) lines.push(`source: ${source}`);\n  const sourcesUsed = Array.isArray(snapshot.sourcesUsed)\n    ? snapshot.sourcesUsed.filter((x): x is string => typeof x === \"string\")\n    : [];\n  if (sourcesUsed.length > 0) {\n    lines.push(`sources-used: ${sourcesUsed.join(\", \")}`);\n  }\n  const latencyMs = sanitizeFiniteNumber(snapshot.latencyMs);\n  if (latencyMs !== null) {\n    lines.push(`latency-ms: ${latencyMs}`);\n  }\n  const memoryIds = Array.isArray(snapshot.memoryIds)\n    ? snapshot.memoryIds.filter((x): x is string => typeof x === \"string\")\n    : [];\n  if (memoryIds.length > 0) {\n    lines.push(`memories: ${memoryIds.join(\", \")}`);\n  }\n\n  const ex = normalizeTierExplain(snapshot.tierExplain);\n  if (!ex) {\n    lines.push(\"\");\n    lines.push(\n      \"tier-explain: (not populated — direct-answer tier disabled or did not fire)\",\n    );\n    return lines.join(\"\\n\");\n  }\n\n  lines.push(\"\");\n  lines.push(\"--- tier explain ---\");\n  for (const line of renderTierExplainTextLines(ex)) {\n    lines.push(line);\n  }\n  return lines.join(\"\\n\");\n}\n\n/**\n * Adapter: convert a `LastRecallSnapshot` into a best-effort\n * `RecallXraySnapshot` so the markdown renderer can produce a\n * consistent, richly-formatted document for callers that have asked\n * for `markdown` format.  The LastRecallSnapshot and the X-ray\n * snapshot share session/namespace/memoryIds; additional X-ray-only\n * fields (filters, score decomposition, graph path, audit id) are\n * left empty because the legacy snapshot doesn't carry them.  The\n * renderer handles missing fields gracefully.\n */\n/**\n * Strip backticks, pipes, and newlines from a host-provided value so it\n * cannot escape its enclosing markdown code span, break the surrounding\n * table row, or inject extra rows when it lands in\n * `renderXrayMarkdown`.  Applied at the adapter boundary because\n * `LastRecallSnapshot` is hydrated from on-disk JSON without schema\n * validation (codex P2 review on #605).\n *\n * Accepts `unknown` so non-string truthy values (numbers, objects,\n * booleans, arrays) coming from a corrupted snapshot are coerced to\n * the empty string rather than crashing on `.replace(...)`.  Callers\n * should treat an empty return as \"drop this field.\"\n */\nfunction sanitizeForMarkdownInline(value: unknown): string {\n  if (typeof value !== \"string\") return \"\";\n  return value.replace(/[`|\\r\\n]/g, \" \").trim();\n}\n\n/**\n * Map the legacy `LastRecallSnapshot.source` field to the\n * `RecallXrayServedBy` union used by the unified x-ray renderer.\n * Mirrors the `mapRecallSourceToXrayServedBy` helper inside\n * `orchestrator.ts` (which is private).  Keep the two in sync when a\n * new source lands — unknown values collapse to `\"hybrid\"` to preserve\n * backwards compatibility with older on-disk snapshots.\n */\nfunction mapLegacySourceToServedBy(\n  source: unknown,\n): \"hybrid\" | \"recent-scan\" {\n  if (source === \"recent_scan\") return \"recent-scan\";\n  return \"hybrid\";\n}\n\nexport function toRecallXraySnapshotFromLegacy(\n  snapshot: LastRecallSnapshot | null,\n): RecallXraySnapshot | null {\n  if (!snapshot) return null;\n  const capturedAt = (() => {\n    if (typeof snapshot.recordedAt !== \"string\") return 0;\n    const ms = Date.parse(snapshot.recordedAt);\n    return Number.isFinite(ms) && ms >= 0 ? ms : 0;\n  })();\n  const memoryIds = Array.isArray(snapshot.memoryIds)\n    ? snapshot.memoryIds.filter((x): x is string => typeof x === \"string\")\n    : [];\n  // Codex P2 + Cursor Medium on #605: every converted result used to\n  // be stamped with `servedBy: \"hybrid\"`, misattributing legacy\n  // snapshots that came from `recent_scan` (or any future source).\n  // Propagate the recorded `source` so markdown `recall-explain`\n  // output matches the `served-by=` string the native x-ray capture\n  // would emit for the same recall.\n  const servedBy = mapLegacySourceToServedBy(snapshot.source);\n  const results: RecallXrayResult[] = memoryIds.map((memoryId) => ({\n    memoryId,\n    path: \"\",\n    servedBy,\n    scoreDecomposition: { final: 0 },\n    admittedBy: [],\n  }));\n  const filters: RecallFilterTrace[] = [];\n  return {\n    schemaVersion: \"1\",\n    // `LastRecallSnapshot` does not preserve the original query text;\n    // synthesize a placeholder so the renderer has a non-empty\n    // string to print.  `queryHash` + `queryLen` stay in the JSON\n    // payload via `toRecallExplainJson` for callers that need them.\n    query:\n      snapshot.queryHash\n        ? `(legacy explain; queryHash=${snapshot.queryHash})`\n        : \"(legacy explain)\",\n    // `snapshotId` is synthesized here; `sessionKey` is already\n    // sanitized before it reaches the ID because we re-use the\n    // sanitized string below.\n    snapshotId: `legacy-${sanitizeForMarkdownInline(snapshot.sessionKey ?? \"unknown\") || \"unknown\"}-${capturedAt}`,\n    capturedAt,\n    // Run the raw on-disk value through the same normalizer the text\n    // and JSON paths use so the markdown adapter cannot render\n    // unvalidated tier-explain payloads (cursor / codex review on\n    // #605).  A malformed tierExplain is dropped to null, matching the\n    // behavior of the non-markdown surfaces.\n    tierExplain: normalizeTierExplain(snapshot.tierExplain) ?? null,\n    results,\n    appliedResultLimit: 0,\n    appliedResults: [],\n    headroomResults: [],\n    filters,\n    budget: { chars: 0, used: 0 },\n    // Sanitize legacy session metadata at the adapter boundary so a\n    // malformed on-disk value (containing backticks, pipes, or\n    // newlines) cannot break the enclosing markdown table when\n    // `renderXrayMarkdown` prints it in a raw code-span cell (codex P2\n    // review on #605).\n    ...(snapshot.sessionKey\n      ? (() => {\n          const clean = sanitizeForMarkdownInline(snapshot.sessionKey);\n          return clean ? { sessionKey: clean } : {};\n        })()\n      : {}),\n    ...(snapshot.namespace\n      ? (() => {\n          const clean = sanitizeForMarkdownInline(snapshot.namespace);\n          return clean ? { namespace: clean } : {};\n        })()\n      : {}),\n  };\n}\n\nexport function renderRecallExplain(\n  snapshot: LastRecallSnapshot | null,\n  format: RecallExplainFormat,\n): string {\n  if (format === \"json\") {\n    return JSON.stringify(toRecallExplainJson(snapshot), null, 2);\n  }\n  if (format === \"markdown\") {\n    // Delegate to the shared X-ray renderer so CLI / HTTP / MCP\n    // markdown output all share one implementation (CLAUDE.md rule\n    // 22).  The JSON and text paths remain byte-for-byte\n    // backwards-compatible with pre-#570 behavior.\n    return renderXrayMarkdown(toRecallXraySnapshotFromLegacy(snapshot));\n  }\n  return toRecallExplainText(snapshot);\n}\n\nexport function parseRecallExplainFormat(value: unknown): RecallExplainFormat {\n  if (value === undefined || value === null) return \"text\";\n  if (typeof value !== \"string\") {\n    throw new Error(\n      `--format expects \"text\", \"json\", or \"markdown\", got ${typeof value}`,\n    );\n  }\n  const v = value.trim().toLowerCase();\n  if (v === \"text\" || v === \"json\" || v === \"markdown\") return v;\n  throw new Error(\n    `--format expects \"text\", \"json\", or \"markdown\", got ${JSON.stringify(value)}`,\n  );\n}\n","/**\n * Unified Recall X-ray renderer (issue #570, PR 2).\n *\n * Pure functions that format a `RecallXraySnapshot` for human text,\n * GitHub-flavored markdown, and machine JSON consumption.  CLI / HTTP\n * / MCP surfaces all call into this module — they do NOT format X-ray\n * output themselves, so rendering is tested in one place (CLAUDE.md\n * rule 22).\n *\n * Scope for PR 2 (this slice):\n *   - Pure rendering.  No IO, no transport, no capture.\n *   - `renderXray(snapshot, format)` with format ∈\n *     `{\"json\", \"text\", \"markdown\"}`.\n *   - `parseXrayFormat(value)` — input validator that rejects unknown\n *     formats with a listed-options error (CLAUDE.md rule 51).\n *   - Golden-file-style tests in `recall-xray-renderer.test.ts`.\n */\n\nimport type {\n  RecallFilterTrace,\n  RecallXrayResult,\n  RecallXraySnapshot,\n  RecallXrayServedBy,\n} from \"./recall-xray.js\";\nimport { summarizeDisclosureTokens } from \"./recall-xray.js\";\nimport { renderTierExplainTextLines } from \"./recall-explain-renderer.js\";\nimport { summarizeRetrievedMemoryProvenance } from \"./memory-provenance.js\";\n\nexport type RecallXrayFormat = \"json\" | \"text\" | \"markdown\";\n\nexport const RECALL_XRAY_FORMATS: readonly RecallXrayFormat[] = [\n  \"json\",\n  \"text\",\n  \"markdown\",\n] as const;\n\n/**\n * Validate and coerce a user-provided `--format` / `format` argument to\n * `RecallXrayFormat`.  Unknown values throw an error listing valid\n * options (CLAUDE.md rule 51).  `undefined`/`null` defaults to `\"text\"`.\n */\nexport function parseXrayFormat(value: unknown): RecallXrayFormat {\n  if (value === undefined || value === null) return \"text\";\n  if (typeof value !== \"string\") {\n    throw new Error(\n      `--format expects one of ${RECALL_XRAY_FORMATS.join(\", \")}; got ${typeof value}`,\n    );\n  }\n  const v = value.trim().toLowerCase();\n  if (v === \"json\" || v === \"text\" || v === \"markdown\") return v;\n  throw new Error(\n    `--format expects one of ${RECALL_XRAY_FORMATS.join(\", \")}; got ${JSON.stringify(value)}`,\n  );\n}\n\n/**\n * Top-level dispatcher.  CLI / HTTP / MCP callers should always route\n * through this function so the three formats stay in lock-step.\n */\nexport function renderXray(\n  snapshot: RecallXraySnapshot | null,\n  format: RecallXrayFormat,\n): string {\n  if (format === \"json\") return renderXrayJson(snapshot);\n  if (format === \"markdown\") return renderXrayMarkdown(snapshot);\n  return renderXrayText(snapshot);\n}\n\n// ─── JSON ─────────────────────────────────────────────────────────────────\n\n/**\n * Deterministic JSON encoding of an X-ray snapshot.  Returns a stable\n * v1 envelope when the snapshot is absent so consumers can pattern-match\n * on `snapshotFound` rather than distinguishing `null` vs `{}`.\n */\nexport function renderXrayJson(snapshot: RecallXraySnapshot | null): string {\n  if (!snapshot) {\n    return JSON.stringify(\n      { schemaVersion: \"1\", snapshotFound: false },\n      null,\n      2,\n    );\n  }\n  // `snapshotFound` is injected *before* the rest so downstream JSON\n  // consumers see it near the top of the document.\n  return JSON.stringify(\n    { snapshotFound: true, ...snapshot },\n    null,\n    2,\n  );\n}\n\n// ─── Text ─────────────────────────────────────────────────────────────────\n\nexport function renderXrayText(snapshot: RecallXraySnapshot | null): string {\n  const lines: string[] = [\"=== Recall X-ray ===\"];\n  if (!snapshot) {\n    lines.push(\"No X-ray snapshot captured.\");\n    return lines.join(\"\\n\");\n  }\n\n  lines.push(`query: ${snapshot.query}`);\n  lines.push(`snapshot-id: ${snapshot.snapshotId}`);\n  lines.push(`captured-at: ${formatCapturedAt(snapshot.capturedAt)}`);\n  if (snapshot.sessionKey) lines.push(`session: ${snapshot.sessionKey}`);\n  if (snapshot.namespace) lines.push(`namespace: ${snapshot.namespace}`);\n  if (snapshot.traceId) lines.push(`trace-id: ${snapshot.traceId}`);\n  lines.push(\n    `budget: ${snapshot.budget.used} / ${snapshot.budget.chars} chars`,\n  );\n\n  lines.push(\"\");\n  lines.push(\"--- filters ---\");\n  if (snapshot.filters.length === 0) {\n    lines.push(\"(no filter traces recorded)\");\n  } else {\n    for (const f of snapshot.filters) {\n      lines.push(renderFilterTextLine(f));\n    }\n  }\n\n  lines.push(\"\");\n  lines.push(\"--- results ---\");\n  if (snapshot.results.length === 0) {\n    lines.push(\"(no results admitted)\");\n  } else {\n    snapshot.results.forEach((result, idx) => {\n      for (const line of renderResultTextLines(result, idx + 1)) {\n        lines.push(line);\n      }\n    });\n  }\n\n  lines.push(\"\");\n  lines.push(\"--- tier explain ---\");\n  for (const line of renderTierExplainTextLines(snapshot.tierExplain ?? null)) {\n    lines.push(line);\n  }\n\n  return lines.join(\"\\n\");\n}\n\nfunction renderFilterTextLine(f: RecallFilterTrace): string {\n  const base = `- ${f.name}: ${f.admitted}/${f.considered} admitted`;\n  return f.reason ? `${base} (${f.reason})` : base;\n}\n\nfunction renderResultTextLines(\n  result: RecallXrayResult,\n  rank: number,\n): string[] {\n  const lines: string[] = [];\n  lines.push(`[${rank}] ${result.memoryId} — ${servedByLabel(result.servedBy)}`);\n  if (result.path) lines.push(`    path: ${result.path}`);\n  lines.push(`    score: ${renderScoreDecomposition(result)}`);\n  if (result.provenance) {\n    lines.push(\n      `    provenance: ${summarizeRetrievedMemoryProvenance(result.provenance)}`,\n    );\n    lines.push(`    retrieval-reason: ${result.provenance.retrievalReason}`);\n    if (result.provenance.userContextScopes.length > 0) {\n      lines.push(\n        `    context-scopes: ${result.provenance.userContextScopes.join(\", \")}`,\n      );\n    }\n    if (\n      result.provenance.safety !== \"safe\" ||\n      result.provenance.safetyReasons.length > 0\n    ) {\n      const reasonSuffix =\n        result.provenance.safetyReasons.length > 0\n          ? ` (${result.provenance.safetyReasons.join(\", \")})`\n          : \"\";\n      lines.push(`    safety: ${result.provenance.safety}${reasonSuffix}`);\n    }\n  }\n  if (result.sourceSpan) {\n    const q = truncateForXray(result.sourceSpan.quote, 120);\n    lines.push(\n      `    source: \"${q}\" (observed ${result.sourceSpan.observedAt}) [${result.sourceSpan.provenance}]`,\n    );\n  }\n  if (result.admittedBy.length > 0) {\n    lines.push(`    admitted-by: ${result.admittedBy.join(\", \")}`);\n  }\n  if (result.rejectedBy) {\n    lines.push(`    rejected-by: ${result.rejectedBy}`);\n  }\n  if (result.graphPath && result.graphPath.length > 0) {\n    lines.push(`    graph-path: ${result.graphPath.join(\" -> \")}`);\n    // Issue #681 PR 3/3 — surface per-edge confidence inline so\n    // operators can attribute floor-pruning / PageRank ranking\n    // decisions to specific edges. Skipped when no confidences were\n    // recorded (legacy snapshot or single-node path).\n    if (\n      result.graphEdgeConfidences &&\n      result.graphEdgeConfidences.length > 0\n    ) {\n      lines.push(\n        `    edge-confidences: ${result.graphEdgeConfidences\n          .map((c) => c.toFixed(2))\n          .join(\", \")}`,\n      );\n    }\n  }\n  if (result.auditEntryId) {\n    lines.push(`    audit-entry: ${result.auditEntryId}`);\n  }\n  return lines;\n}\n\n// ─── Markdown ─────────────────────────────────────────────────────────────\n\nexport function renderXrayMarkdown(\n  snapshot: RecallXraySnapshot | null,\n): string {\n  const lines: string[] = [\"# Recall X-ray\"];\n  if (!snapshot) {\n    lines.push(\"\");\n    lines.push(\"_No X-ray snapshot captured._\");\n    return lines.join(\"\\n\");\n  }\n\n  lines.push(\"\");\n  lines.push(`**Query:** ${mdInlineCode(snapshot.query)}`);\n  lines.push(\"\");\n  lines.push(\"| Field | Value |\");\n  lines.push(\"| --- | --- |\");\n  lines.push(`| Snapshot ID | \\`${snapshot.snapshotId}\\` |`);\n  lines.push(`| Captured at | ${formatCapturedAt(snapshot.capturedAt)} |`);\n  if (snapshot.sessionKey) {\n    lines.push(`| Session | \\`${snapshot.sessionKey}\\` |`);\n  }\n  if (snapshot.namespace) {\n    lines.push(`| Namespace | \\`${snapshot.namespace}\\` |`);\n  }\n  if (snapshot.traceId) {\n    lines.push(`| Trace ID | \\`${snapshot.traceId}\\` |`);\n  }\n  lines.push(\n    `| Budget | ${snapshot.budget.used} / ${snapshot.budget.chars} chars |`,\n  );\n\n  lines.push(\"\");\n  lines.push(\"## Filters\");\n  if (snapshot.filters.length === 0) {\n    lines.push(\"\");\n    lines.push(\"_No filter traces recorded._\");\n  } else {\n    lines.push(\"\");\n    lines.push(\"| Filter | Considered | Admitted | Reason |\");\n    lines.push(\"| --- | ---: | ---: | --- |\");\n    for (const f of snapshot.filters) {\n      const reason = f.reason ? mdEscape(f.reason) : \"\";\n      lines.push(`| ${mdEscape(f.name)} | ${f.considered} | ${f.admitted} | ${reason} |`);\n    }\n  }\n\n  lines.push(\"\");\n  lines.push(\"## Results\");\n  if (snapshot.results.length === 0) {\n    lines.push(\"\");\n    lines.push(\"_No results admitted._\");\n  } else {\n    snapshot.results.forEach((result, idx) => {\n      for (const line of renderResultMarkdownLines(result, idx + 1)) {\n        lines.push(line);\n      }\n    });\n\n    // Per-disclosure token-spend summary (issue #677 PR 3/4).  Only\n    // emitted when at least one result carries a disclosure level so\n    // we don't pollute the snapshot for callers who haven't wired the\n    // depth knob through.  Counts and tokens default to 0 for buckets\n    // with no contributions.\n    const summary = summarizeDisclosureTokens(snapshot.results);\n    const hasAnyDisclosure =\n      summary.chunk.count + summary.section.count + summary.raw.count > 0;\n    if (hasAnyDisclosure) {\n      lines.push(\"\");\n      lines.push(\"### Token spend by disclosure\");\n      lines.push(\"\");\n      lines.push(\"| Disclosure | Results | Estimated tokens |\");\n      lines.push(\"| --- | ---: | ---: |\");\n      lines.push(\n        `| chunk | ${summary.chunk.count} | ${summary.chunk.estimatedTokens} |`,\n      );\n      lines.push(\n        `| section | ${summary.section.count} | ${summary.section.estimatedTokens} |`,\n      );\n      lines.push(\n        `| raw | ${summary.raw.count} | ${summary.raw.estimatedTokens} |`,\n      );\n      if (summary.unspecified.count > 0) {\n        lines.push(\n          `| _(unspecified)_ | ${summary.unspecified.count} | ${summary.unspecified.estimatedTokens} |`,\n        );\n      }\n    }\n  }\n\n  lines.push(\"\");\n  lines.push(\"## Tier Explain\");\n  if (!snapshot.tierExplain) {\n    lines.push(\"\");\n    lines.push(\n      \"_Not populated — direct-answer tier disabled or did not fire._\",\n    );\n  } else {\n    const te = snapshot.tierExplain;\n    lines.push(\"\");\n    lines.push(\"| Field | Value |\");\n    lines.push(\"| --- | --- |\");\n    lines.push(`| Tier | \\`${te.tier}\\` |`);\n    lines.push(`| Reason | ${mdEscape(te.tierReason)} |`);\n    lines.push(`| Candidates considered | ${te.candidatesConsidered} |`);\n    lines.push(`| Latency (ms) | ${te.latencyMs} |`);\n    lines.push(\n      `| Filtered by | ${\n        te.filteredBy.length > 0\n          ? te.filteredBy.map(mdInlineCode).join(\", \")\n          : \"_(none)_\"\n      } |`,\n    );\n    if (te.sourceAnchors && te.sourceAnchors.length > 0) {\n      lines.push(\"\");\n      lines.push(\"**Source anchors:**\");\n      for (const anchor of te.sourceAnchors) {\n        const range = anchor.lineRange\n          ? `:${anchor.lineRange[0]}-${anchor.lineRange[1]}`\n          : \"\";\n        lines.push(`- \\`${anchor.path}${range}\\``);\n      }\n    }\n  }\n\n  return lines.join(\"\\n\");\n}\n\nfunction renderResultMarkdownLines(\n  result: RecallXrayResult,\n  rank: number,\n): string[] {\n  const lines: string[] = [];\n  lines.push(\"\");\n  lines.push(\n    `### ${rank}. \\`${result.memoryId}\\` — ${servedByLabel(result.servedBy)}`,\n  );\n  if (result.path) {\n    lines.push(\"\");\n    lines.push(`- **Path:** \\`${result.path}\\``);\n  } else {\n    lines.push(\"\");\n  }\n  lines.push(`- **Score:** ${renderScoreDecomposition(result)}`);\n  if (result.provenance) {\n    lines.push(\n      `- **Provenance:** ${mdEscape(summarizeRetrievedMemoryProvenance(result.provenance))}`,\n    );\n    lines.push(\n      `- **Retrieval reason:** ${mdInlineCode(result.provenance.retrievalReason)}`,\n    );\n    if (result.provenance.userContextScopes.length > 0) {\n      lines.push(\n        `- **Context scopes:** ${result.provenance.userContextScopes\n          .map(mdInlineCode)\n          .join(\", \")}`,\n      );\n    }\n    if (\n      result.provenance.safety !== \"safe\" ||\n      result.provenance.safetyReasons.length > 0\n    ) {\n      const reasonSuffix =\n        result.provenance.safetyReasons.length > 0\n          ? ` (${result.provenance.safetyReasons.map(mdInlineCode).join(\", \")})`\n          : \"\";\n      lines.push(\n        `- **Safety:** ${mdInlineCode(result.provenance.safety)}${reasonSuffix}`,\n      );\n    }\n  }\n  if (result.sourceSpan) {\n    const q = truncateForXray(result.sourceSpan.quote, 120);\n    lines.push(\n      `- **Source:** \"${mdEscape(q)}\" (${mdInlineCode(result.sourceSpan.observedAt)}) \\u2014 ${result.sourceSpan.provenance}`,\n    );\n  }\n  if (result.admittedBy.length > 0) {\n    lines.push(\n      `- **Admitted by:** ${result.admittedBy.map(mdInlineCode).join(\", \")}`,\n    );\n  }\n  if (result.rejectedBy) {\n    lines.push(`- **Rejected by:** ${mdInlineCode(result.rejectedBy)}`);\n  }\n  if (result.graphPath && result.graphPath.length > 0) {\n    lines.push(\n      `- **Graph path:** ${result.graphPath\n        .map(mdInlineCode)\n        .join(\" → \")}`,\n    );\n    // Issue #681 PR 3/3 — render per-edge confidences as a parallel\n    // markdown line so operators can correlate them with the path\n    // arrows above. Skipped when no confidences were recorded.\n    if (\n      result.graphEdgeConfidences &&\n      result.graphEdgeConfidences.length > 0\n    ) {\n      lines.push(\n        `- **Edge confidences:** ${result.graphEdgeConfidences\n          .map((c) => mdInlineCode(c.toFixed(2)))\n          .join(\", \")}`,\n      );\n    }\n  }\n  if (result.auditEntryId) {\n    lines.push(`- **Audit entry:** \\`${result.auditEntryId}\\``);\n  }\n  if (result.disclosure !== undefined) {\n    const tokenLine =\n      typeof result.estimatedTokens === \"number\"\n        ? ` (~${result.estimatedTokens} tokens)`\n        : \"\";\n    lines.push(`- **Disclosure:** \\`${result.disclosure}\\`${tokenLine}`);\n  } else if (typeof result.estimatedTokens === \"number\") {\n    // Disclosure unspecified but tokens recorded — still surface the\n    // budget so the operator can attribute spend.\n    lines.push(`- **Estimated tokens:** ${result.estimatedTokens}`);\n  }\n  return lines;\n}\n\n// ─── Shared helpers ───────────────────────────────────────────────────────\n\nfunction servedByLabel(servedBy: RecallXrayServedBy): string {\n  return `served-by=${servedBy}`;\n}\n\nfunction renderScoreDecomposition(result: RecallXrayResult): string {\n  const parts: string[] = [`final=${formatScore(result.scoreDecomposition.final)}`];\n  const s = result.scoreDecomposition;\n  if (s.vector !== undefined) parts.push(`vector=${formatScore(s.vector)}`);\n  if (s.bm25 !== undefined) parts.push(`bm25=${formatScore(s.bm25)}`);\n  if (s.importance !== undefined) {\n    parts.push(`importance=${formatScore(s.importance)}`);\n  }\n  if (s.mmrPenalty !== undefined) {\n    parts.push(`mmr_penalty=${formatScore(s.mmrPenalty)}`);\n  }\n  if (s.tierPrior !== undefined) {\n    parts.push(`tier_prior=${formatScore(s.tierPrior)}`);\n  }\n  if (s.reinforcementBoost !== undefined && s.reinforcementBoost > 0) {\n    parts.push(`reinforcement_boost=${formatScore(s.reinforcementBoost)}`);\n  }\n  return parts.join(\" \");\n}\n\nfunction formatScore(value: number): string {\n  // Deterministic 4-decimal formatting keeps golden files stable\n  // without printing spurious trailing zeros via toString().\n  if (!Number.isFinite(value)) return \"0.0000\";\n  return value.toFixed(4);\n}\n\nfunction formatCapturedAt(ts: number): string {\n  if (!Number.isFinite(ts) || ts < 0) return \"(unknown)\";\n  // `new Date(n).toISOString()` throws a RangeError for finite numbers\n  // outside the valid Date range (roughly |n| > 8.64e15).  That case\n  // can surface when snapshots are corrupted or captured with a\n  // custom clock, so coerce it to the same \"(unknown)\" fallback\n  // rather than crashing the renderer.\n  try {\n    return new Date(ts).toISOString();\n  } catch {\n    return \"(unknown)\";\n  }\n}\n\nfunction mdEscape(value: string): string {\n  // Pipe is the only character that breaks GFM table rendering; escape\n  // backslash first so we do not re-escape the escape character.\n  return value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\|/g, \"\\\\|\");\n}\n\n/**\n * Truncate a quote for X-ray display (issue #1575 PR 3). Collapses internal\n * whitespace runs (including newlines/carriage returns) to single spaces so\n * a multi-line source excerpt cannot split what is meant to be a single X-ray\n * row, then caps at `maxChars` on a word boundary with an ellipsis marker.\n * The JSON \\`sourceSpan.quote\\` stays verbatim — this is display-only.\n */\nfunction truncateForXray(text: string, maxChars: number): string {\n  const collapsed = text.replace(/\\s+/g, \" \").trim();\n  if (collapsed.length <= maxChars) return collapsed;\n  const slice = collapsed.slice(0, maxChars);\n  const lastSpace = slice.lastIndexOf(\" \");\n  const cut = lastSpace > Math.floor(maxChars * 0.5) ? slice.slice(0, lastSpace) : slice;\n  return `${cut}\\u2026`;\n}\n\nfunction mdInlineCode(value: string): string {\n  if (value.length === 0) return \"``\";\n  // Use exactly enough backticks to unambiguously wrap content that\n  // itself contains backticks (GFM rule).\n  const longestRun = /`+/g;\n  let maxLen = 0;\n  for (const match of value.matchAll(longestRun)) {\n    if (match[0].length > maxLen) maxLen = match[0].length;\n  }\n  const fence = \"`\".repeat(maxLen + 1);\n  const pad = value.startsWith(\"`\") || value.endsWith(\"`\") ? \" \" : \"\";\n  return `${fence}${pad}${value}${pad}${fence}`;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-7TWUCYER.js → chunk-PNRA7FAD.js}

@@ -6,9 +6,6 @@ import {
   revokeToken,
   saveTokenStore
 } from "./chunk-EMDLM3LW.js";
-import {
-  launchProcessSync
-} from "./chunk-O75CRYGF.js";
 import {
   getConnectorsDir,
   getRegistryPath
@@ -16,6 +13,12 @@ import {
 import {
   coerceInstallExtension
 } from "./chunk-PQVCH2AE.js";
+import {
+  resolveConversationContextCapabilities
+} from "./chunk-2XRE6FLM.js";
+import {
+  launchProcessSync
+} from "./chunk-O75CRYGF.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
@@ -24,9 +27,6 @@ import {
   readEnvVar,
   resolveHomeDir
 } from "./chunk-JUC24CTX.js";
-import {
-  resolveConversationContextCapabilities
-} from "./chunk-2XRE6FLM.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -3032,4 +3032,4 @@ export {
   resolveWeCloneProxyConfigPath,
   buildWeCloneProxyConfig
 };
-//# sourceMappingURL=chunk-7TWUCYER.js.map
+//# sourceMappingURL=chunk-PNRA7FAD.js.map

package/dist/{chunk-5I4M26Q7.js → chunk-QBSFOKY6.js}

@@ -5,12 +5,12 @@ import {
   coerceBool,
   coerceNumber
 } from "./chunk-PQVCH2AE.js";
-import {
-  readEnvVar
-} from "./chunk-JUC24CTX.js";
 import {
   collapseWhitespace
 } from "./chunk-6MKAMLQL.js";
+import {
+  readEnvVar
+} from "./chunk-JUC24CTX.js";
 
 // src/provenance.ts
 import { z } from "zod";
@@ -384,4 +384,4 @@ export {
   parseProvenanceConfig,
   buildFactProvenance
 };
-//# sourceMappingURL=chunk-5I4M26Q7.js.map
+//# sourceMappingURL=chunk-QBSFOKY6.js.map

package/dist/{chunk-E53DSZEN.js → chunk-QR6G5KF4.js}

@@ -1,9 +1,9 @@
 import {
   namespaceCollectionName
-} from "./chunk-HLPD7B7P.js";
+} from "./chunk-JZH4LWHB.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-LZ4LDKHZ.js";
+} from "./chunk-AMAUBUKY.js";
 import {
   namespaceIdentityFromToken,
   namespaceIdentityToken
@@ -213,4 +213,4 @@ export {
   verifyNamespaces,
   runNamespaceMigration
 };
-//# sourceMappingURL=chunk-E53DSZEN.js.map
+//# sourceMappingURL=chunk-QR6G5KF4.js.map