@remnic/core 1.1.0 → 1.1.2

package/dist/chunk-5JRF2PZA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/buffer-surprise.ts"],"sourcesContent":["/**\n * Surprise helper — D-MEM-style novelty score for a turn against recent memories.\n *\n * Used (eventually, in a follow-up PR) by the smart buffer as an additive flush\n * trigger: a turn that is semantically far from everything already in memory is\n * \"surprising\" and worth extracting immediately, even if turn-count and signal\n * heuristics would otherwise keep buffering.\n *\n * This module intentionally contains ONLY the pure scoring function. Wiring\n * into the buffer, configuration flags, telemetry, and benchmark work live in\n * later PRs (see issue #563). Keeping the helper in a sibling file instead of\n * inside `buffer.ts` keeps the buffer module focused and makes the eventual\n * integration a small, reviewable change.\n *\n * # Formula\n *\n * Given an input `turn` and a list of `recentMemories`:\n *\n * 1. Embed the turn and every candidate memory via the caller-provided\n *    `embedFn`.\n * 2. For each candidate, compute cosine similarity `cos(turn, candidate)` in\n *    `[0, 1]` (negative cosines are clamped to 0 — \"opposite directions\"\n *    is treated as maximally diverse, consistent with `recall-mmr.ts`).\n * 3. Keep the top-`k` *highest* similarities (the turn's nearest neighbors).\n * 4. Average those top-`k` similarities → `nearestSim ∈ [0, 1]`.\n * 5. Return `1 − nearestSim` as the surprise score.\n *\n * Intuition: a turn that is close to at least one recent memory has a high\n * `nearestSim` and therefore a *low* surprise (near 0 = redundant). A turn\n * that is far from all of its k nearest neighbors has a low `nearestSim` and\n * therefore a *high* surprise (near 1 = novel).\n *\n * Using the top-k average instead of a single nearest neighbor makes the\n * score less sensitive to one outlier duplicate (e.g. an exact restatement of\n * a stale fact). `k=1` reduces to pure nearest-neighbor distance.\n *\n * # Edge cases\n *\n * - `recentMemories` empty → returns `1.0` (maximally surprising). There is\n *   nothing to compare against, so the turn cannot be redundant.\n * - `k` default is `5`. It is clamped to `[1, recentMemories.length]` so that\n *   small corpora still produce a meaningful score (e.g. 3 memories with\n *   `k=5` behaves the same as `k=3`).\n * - Zero-norm embeddings (all zeros) contribute similarity `0` (they cannot\n *   be \"close\" to anything), which is treated as maximally surprising for\n *   that pair. The rest of the corpus is scored normally.\n * - Embedding-length mismatches between the turn and a candidate are treated\n *   as similarity `0` for that pair. We do not silently truncate to the\n *   shorter vector because that would hide a real configuration bug.\n * - `embedFn` rejection is allowed to propagate. The caller decides whether\n *   to catch, fall back, or fail the flush decision — this helper has no\n *   opinion beyond the pure score.\n *\n * # Purity\n *\n * No I/O, no hidden globals. Given the same inputs and the same `embedFn`,\n * the output is deterministic.\n */\n\nimport { cosineSimilarity } from \"./semantic-chunking.js\";\n\n/** Minimal shape of a recent memory passed to `computeSurprise`. */\nexport interface RecentMemoryLike {\n  /** Stable identifier. Only used for debug/logging; not part of the score. */\n  readonly id: string;\n  /** Text to embed and compare against the incoming turn. */\n  readonly content: string;\n}\n\n/** Options accepted by `computeSurprise`. */\nexport interface ComputeSurpriseOptions {\n  /**\n   * Embedding function. Called once for the turn and once per candidate\n   * memory. Callers may wrap a provider client, a local model, or a\n   * deterministic hash for tests.\n   */\n  readonly embedFn: (text: string) => Promise<readonly number[]>;\n  /**\n   * Number of nearest neighbors to average over. Defaults to 5. Clamped to\n   * `[1, recentMemories.length]`.\n   */\n  readonly k?: number;\n}\n\n/** Default k (top nearest neighbors to average). */\nexport const DEFAULT_SURPRISE_K = 5;\n\n/**\n * Compute a surprise score in `[0, 1]` for `turn` against `recentMemories`.\n *\n * See the module-level docstring for the exact formula, edge cases, and\n * purity guarantees.\n *\n * @param turn           The incoming turn text (caller is responsible for\n *                       stringifying structured turn content — this helper\n *                       only needs the text to embed).\n * @param recentMemories Candidate memories to compare against.\n * @param options        `embedFn` (required) and optional `k` (defaults to 5).\n * @returns A scalar in `[0, 1]`. `1.0` = maximally surprising / novel;\n *          `0.0` = redundant with at least one recent memory.\n */\nexport async function computeSurprise(\n  turn: string,\n  recentMemories: readonly RecentMemoryLike[],\n  options: ComputeSurpriseOptions,\n): Promise<number> {\n  if (typeof turn !== \"string\") {\n    throw new TypeError(\"computeSurprise: `turn` must be a string\");\n  }\n  if (!options || typeof options.embedFn !== \"function\") {\n    throw new TypeError(\n      \"computeSurprise: `options.embedFn` is required and must be a function\",\n    );\n  }\n  const candidates = Array.isArray(recentMemories) ? recentMemories : [];\n\n  // Empty corpus → maximally surprising. Document decision: we prefer\n  // \"novelty by default\" over \"silence\" because the surprise score is meant\n  // to *promote* flushing, and an empty buffer of recent memories is the\n  // clearest case of \"we have no basis to call this redundant\".\n  if (candidates.length === 0) return 1;\n\n  const kRaw = typeof options.k === \"number\" ? options.k : DEFAULT_SURPRISE_K;\n  // Clamp k to [1, candidates.length]. Non-integer / non-finite values fall\n  // back to the default, then get re-clamped below.\n  const kClamped = clampK(kRaw, candidates.length);\n\n  // Embed the turn and every candidate. Rejections propagate — that's the\n  // caller's decision to handle. Run candidate embeddings in parallel so a\n  // slow embedder does not serialize the whole pass.\n  const turnEmbedding = await options.embedFn(turn);\n  const candidateEmbeddings = await Promise.all(\n    candidates.map((c) => options.embedFn(c.content)),\n  );\n\n  const sims: number[] = [];\n  for (let i = 0; i < candidates.length; i += 1) {\n    const candEmbedding = candidateEmbeddings[i] ?? [];\n    sims.push(safeCosine(turnEmbedding, candEmbedding));\n  }\n\n  // Sort similarities descending and take the top-k (the nearest neighbors).\n  sims.sort((a, b) => b - a);\n  const top = sims.slice(0, kClamped);\n\n  if (top.length === 0) {\n    // Defensive — with `candidates.length >= 1` and `kClamped >= 1`, we\n    // should always have at least one similarity. If we somehow do not,\n    // treat as maximally surprising rather than returning NaN.\n    return 1;\n  }\n\n  let sum = 0;\n  for (const s of top) sum += s;\n  const nearestSim = sum / top.length;\n\n  const surprise = 1 - nearestSim;\n  // Numerical safety: clamp the final value. Cosine is clamped to [0, 1]\n  // per-pair already, so the mean cannot escape that range under normal\n  // arithmetic, but floating-point drift is cheap to guard against.\n  if (!Number.isFinite(surprise)) return 1;\n  if (surprise < 0) return 0;\n  if (surprise > 1) return 1;\n  return surprise;\n}\n\n// -----------------------------------------------------------------------------\n// Internals\n// -----------------------------------------------------------------------------\n\nfunction clampK(k: number, ceiling: number): number {\n  if (!Number.isFinite(k)) {\n    return Math.min(DEFAULT_SURPRISE_K, Math.max(1, ceiling));\n  }\n  const floored = Math.floor(k);\n  if (floored < 1) return 1;\n  if (floored > ceiling) return ceiling;\n  return floored;\n}\n\n/**\n * Safe wrapper around `cosineSimilarity` that returns a similarity value in\n * `[0, 1]` (negative cosines are clamped to 0, matching the convention used\n * by `recall-mmr.ts`) and tolerates mismatched or empty vectors without\n * throwing. See `semantic-chunking.ts` for the shared cosine implementation.\n *\n * Returns `0` for:\n * - empty vectors,\n * - length mismatches (callers likely have a config bug, but surprise\n *   scoring is a soft signal — do not crash the buffer flush decision),\n * - non-finite cosine results (zero-norm inputs, arithmetic drift).\n */\nfunction safeCosine(a: readonly number[], b: readonly number[]): number {\n  if (!Array.isArray(a) || !Array.isArray(b)) return 0;\n  if (a.length === 0 || b.length === 0) return 0;\n  if (a.length !== b.length) return 0;\n  const raw = cosineSimilarity(a as number[], b as number[]);\n  if (!Number.isFinite(raw)) return 0;\n  if (raw < 0) return 0;\n  if (raw > 1) return 1;\n  return raw;\n}\n\n"],"mappings":";;;;;AAqFO,IAAM,qBAAqB;AAgBlC,eAAsB,gBACpB,MACA,gBACA,SACiB;AACjB,MAAI,OAAO,SAAS,UAAU;AAC5B,UAAM,IAAI,UAAU,0CAA0C;AAAA,EAChE;AACA,MAAI,CAAC,WAAW,OAAO,QAAQ,YAAY,YAAY;AACrD,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,QAAM,aAAa,MAAM,QAAQ,cAAc,IAAI,iBAAiB,CAAC;AAMrE,MAAI,WAAW,WAAW,EAAG,QAAO;AAEpC,QAAM,OAAO,OAAO,QAAQ,MAAM,WAAW,QAAQ,IAAI;AAGzD,QAAM,WAAW,OAAO,MAAM,WAAW,MAAM;AAK/C,QAAM,gBAAgB,MAAM,QAAQ,QAAQ,IAAI;AAChD,QAAM,sBAAsB,MAAM,QAAQ;AAAA,IACxC,WAAW,IAAI,CAAC,MAAM,QAAQ,QAAQ,EAAE,OAAO,CAAC;AAAA,EAClD;AAEA,QAAM,OAAiB,CAAC;AACxB,WAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK,GAAG;AAC7C,UAAM,gBAAgB,oBAAoB,CAAC,KAAK,CAAC;AACjD,SAAK,KAAK,WAAW,eAAe,aAAa,CAAC;AAAA,EACpD;AAGA,OAAK,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AACzB,QAAM,MAAM,KAAK,MAAM,GAAG,QAAQ;AAElC,MAAI,IAAI,WAAW,GAAG;AAIpB,WAAO;AAAA,EACT;AAEA,MAAI,MAAM;AACV,aAAW,KAAK,IAAK,QAAO;AAC5B,QAAM,aAAa,MAAM,IAAI;AAE7B,QAAM,WAAW,IAAI;AAIrB,MAAI,CAAC,OAAO,SAAS,QAAQ,EAAG,QAAO;AACvC,MAAI,WAAW,EAAG,QAAO;AACzB,MAAI,WAAW,EAAG,QAAO;AACzB,SAAO;AACT;AAMA,SAAS,OAAO,GAAW,SAAyB;AAClD,MAAI,CAAC,OAAO,SAAS,CAAC,GAAG;AACvB,WAAO,KAAK,IAAI,oBAAoB,KAAK,IAAI,GAAG,OAAO,CAAC;AAAA,EAC1D;AACA,QAAM,UAAU,KAAK,MAAM,CAAC;AAC5B,MAAI,UAAU,EAAG,QAAO;AACxB,MAAI,UAAU,QAAS,QAAO;AAC9B,SAAO;AACT;AAcA,SAAS,WAAW,GAAsB,GAA8B;AACtE,MAAI,CAAC,MAAM,QAAQ,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,EAAG,QAAO;AACnD,MAAI,EAAE,WAAW,KAAK,EAAE,WAAW,EAAG,QAAO;AAC7C,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,QAAM,MAAM,iBAAiB,GAAe,CAAa;AACzD,MAAI,CAAC,OAAO,SAAS,GAAG,EAAG,QAAO;AAClC,MAAI,MAAM,EAAG,QAAO;AACpB,MAAI,MAAM,EAAG,QAAO;AACpB,SAAO;AACT;","names":[]}

package/dist/chunk-64NJRYU2.js

@@ -0,0 +1,332 @@
+// src/graph-retrieval.ts
+var DEFAULT_PPR_DAMPING = 0.85;
+var DEFAULT_PPR_ITERATIONS = 20;
+var DEFAULT_PPR_TOLERANCE = 1e-6;
+function normalizeSeedWeights(input) {
+  const out = /* @__PURE__ */ new Map();
+  if (!input) return out;
+  const entries = input instanceof Map ? input.entries() : Object.entries(input);
+  for (const [k, v] of entries) {
+    if (typeof k !== "string" || !k) continue;
+    if (typeof v !== "number" || !Number.isFinite(v) || v < 0) continue;
+    out.set(k, v);
+  }
+  return out;
+}
+function buildSeedVector(graph, seedIds, options) {
+  const seed = /* @__PURE__ */ new Map();
+  const explicitWeights = normalizeSeedWeights(options.seedWeights);
+  if (explicitWeights.size > 0) {
+    const allowedKeys = seedIds.length > 0 ? new Set(seedIds.filter((id) => typeof id === "string")) : null;
+    let total = 0;
+    for (const [id, w] of explicitWeights) {
+      if (!graph.nodes.has(id)) continue;
+      if (allowedKeys !== null && !allowedKeys.has(id)) continue;
+      seed.set(id, (seed.get(id) ?? 0) + w);
+      total += w;
+    }
+    if (total > 0) {
+      for (const [id, v] of seed) seed.set(id, v / total);
+      return seed;
+    }
+    seed.clear();
+  }
+  const validSeeds = /* @__PURE__ */ new Set();
+  for (const id of seedIds) {
+    if (typeof id === "string" && graph.nodes.has(id)) validSeeds.add(id);
+  }
+  if (validSeeds.size > 0) {
+    const share = 1 / validSeeds.size;
+    for (const id of validSeeds) seed.set(id, share);
+    return seed;
+  }
+  if (graph.nodes.size > 0) {
+    const share = 1 / graph.nodes.size;
+    for (const id of graph.nodes.keys()) seed.set(id, share);
+  }
+  return seed;
+}
+function buildAdjacency(graph) {
+  const outgoing = /* @__PURE__ */ new Map();
+  const outSum = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (!edge || typeof edge.from !== "string" || typeof edge.to !== "string") continue;
+    if (!graph.nodes.has(edge.from) || !graph.nodes.has(edge.to)) continue;
+    const weight = typeof edge.weight === "number" && Number.isFinite(edge.weight) && edge.weight > 0 ? edge.weight : 1;
+    let bucket = outgoing.get(edge.from);
+    if (!bucket) {
+      bucket = [];
+      outgoing.set(edge.from, bucket);
+    }
+    bucket.push({ to: edge.to, weight });
+    outSum.set(edge.from, (outSum.get(edge.from) ?? 0) + weight);
+  }
+  return { outgoing, outSum };
+}
+function queryGraph(graph, seedIds, options = {}) {
+  const n = graph.nodes.size;
+  if (n === 0) {
+    return { rankedNodes: [], iterations: 0, converged: true };
+  }
+  let damping = typeof options.damping === "number" ? options.damping : DEFAULT_PPR_DAMPING;
+  if (!Number.isFinite(damping) || damping < 0) damping = 0;
+  if (damping >= 1) damping = 1 - 1e-9;
+  let maxIter = typeof options.iterations === "number" ? Math.floor(options.iterations) : DEFAULT_PPR_ITERATIONS;
+  if (!Number.isFinite(maxIter) || maxIter < 0) maxIter = 0;
+  let tolerance = typeof options.tolerance === "number" ? options.tolerance : DEFAULT_PPR_TOLERANCE;
+  if (!Number.isFinite(tolerance) || tolerance < 0) tolerance = 0;
+  const seed = buildSeedVector(graph, seedIds, options);
+  const hasExplicitWeights = options.seedWeights !== void 0 && options.seedWeights !== null;
+  if (!hasExplicitWeights) {
+    let priorTotal = 0;
+    for (const [id, s] of seed) {
+      const node = graph.nodes.get(id);
+      const w = node !== void 0 && typeof node.weight === "number" && Number.isFinite(node.weight) && node.weight > 0 ? node.weight : 1;
+      const biased = s * w;
+      seed.set(id, biased);
+      priorTotal += biased;
+    }
+    if (priorTotal > 0) {
+      for (const [id, s] of seed) seed.set(id, s / priorTotal);
+    }
+  }
+  const { outgoing, outSum } = buildAdjacency(graph);
+  let rank = /* @__PURE__ */ new Map();
+  for (const id of graph.nodes.keys()) rank.set(id, seed.get(id) ?? 0);
+  let seedTotal = 0;
+  for (const v of seed.values()) seedTotal += v;
+  if (seedTotal === 0) {
+    return { rankedNodes: [], iterations: 0, converged: true };
+  }
+  let converged = false;
+  let iter = 0;
+  for (; iter < maxIter; iter++) {
+    const next = /* @__PURE__ */ new Map();
+    let danglingMass = 0;
+    for (const [id, r] of rank) {
+      if ((outSum.get(id) ?? 0) === 0) danglingMass += r;
+    }
+    const teleportScale = 1 - damping + damping * danglingMass;
+    for (const [id, s] of seed) {
+      next.set(id, (next.get(id) ?? 0) + teleportScale * s);
+    }
+    for (const [from, edges] of outgoing) {
+      const r = rank.get(from) ?? 0;
+      if (r === 0) continue;
+      const total = outSum.get(from) ?? 0;
+      if (total === 0) continue;
+      const share = damping * r / total;
+      for (const { to, weight } of edges) {
+        next.set(to, (next.get(to) ?? 0) + share * weight);
+      }
+    }
+    let delta = 0;
+    for (const id of graph.nodes.keys()) {
+      delta += Math.abs((next.get(id) ?? 0) - (rank.get(id) ?? 0));
+    }
+    rank = next;
+    if (delta < tolerance) {
+      converged = true;
+      iter += 1;
+      break;
+    }
+  }
+  const ranked = [];
+  for (const [id, score] of rank) {
+    if (score > 0) ranked.push({ id, score });
+  }
+  ranked.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+  const topK = options.topK;
+  let trimmed;
+  if (typeof topK === "number") {
+    if (topK <= 0) {
+      trimmed = [];
+    } else if (topK < ranked.length) {
+      trimmed = ranked.slice(0, topK);
+    } else {
+      trimmed = ranked;
+    }
+  } else {
+    trimmed = ranked;
+  }
+  return { rankedNodes: trimmed, iterations: iter, converged };
+}
+var NODE_TYPES = /* @__PURE__ */ new Set([
+  "memory",
+  "entity",
+  "episode",
+  "concept",
+  "reflection"
+]);
+var EDGE_TYPES = /* @__PURE__ */ new Set([
+  "references",
+  "supersedes",
+  "authored-by",
+  "mentions",
+  "derived-from",
+  "temporal-next",
+  "related-to"
+]);
+function isNodeType(value) {
+  return typeof value === "string" && NODE_TYPES.has(value);
+}
+function isEdgeType(value) {
+  return typeof value === "string" && EDGE_TYPES.has(value);
+}
+var CITATION_REGEX = /\[Source:([^\]\n[]+)\]/gi;
+function parseCitationFields(body) {
+  const out = {};
+  for (const rawPart of body.split(",")) {
+    const part = rawPart.trim();
+    if (!part) continue;
+    const eq = part.indexOf("=");
+    if (eq <= 0) continue;
+    const key = part.slice(0, eq).trim().toLowerCase();
+    const value = part.slice(eq + 1).trim();
+    if (key && value) out[key] = value;
+  }
+  return out;
+}
+function stripDerivedFromVersion(ref) {
+  const colon = ref.lastIndexOf(":");
+  if (colon < 0) return ref;
+  const tail = ref.slice(colon + 1);
+  if (tail.length === 0) return ref.slice(0, colon);
+  if (/^\d+$/.test(tail)) return ref.slice(0, colon);
+  return ref;
+}
+function extractGraphEdges(memories, options = {}) {
+  const includeDangling = options.includeDanglingEdges === true;
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const seenEdgeKeys = /* @__PURE__ */ new Set();
+  const addNode = (id, type) => {
+    if (!nodes.has(id)) nodes.set(id, { id, type });
+  };
+  const addEdge = (from, to, type) => {
+    if (!from || !to || from === to) return;
+    const key = `${from}\0${to}\0${type}`;
+    if (seenEdgeKeys.has(key)) return;
+    seenEdgeKeys.add(key);
+    edges.push({ from, to, type });
+  };
+  for (const memory of memories) {
+    if (!memory?.id) continue;
+    addNode(memory.id, "memory");
+  }
+  const entityClaimed = /* @__PURE__ */ new Set();
+  for (const memory of memories) {
+    if (!memory?.id) continue;
+    if (typeof memory.entityRef === "string" && memory.entityRef) {
+      if (memory.entityRef !== memory.id) entityClaimed.add(memory.entityRef);
+    }
+    if (Array.isArray(memory.entityRefs)) {
+      for (const ref of memory.entityRefs) {
+        if (typeof ref === "string" && ref && ref !== memory.id) {
+          entityClaimed.add(ref);
+        }
+      }
+    }
+    if (typeof memory.content === "string" && memory.content.length > 0) {
+      CITATION_REGEX.lastIndex = 0;
+      let match;
+      while ((match = CITATION_REGEX.exec(memory.content)) !== null) {
+        const body = match[1];
+        if (!body) continue;
+        const agent = parseCitationFields(body).agent;
+        if (!agent) continue;
+        const agentId = `agent:${agent}`;
+        if (agentId !== memory.id) entityClaimed.add(agentId);
+      }
+    }
+  }
+  for (const memory of memories) {
+    if (memory?.id) entityClaimed.delete(memory.id);
+  }
+  for (const memory of memories) {
+    if (!memory?.id) continue;
+    const from = memory.id;
+    const canTargetMemory = (id) => {
+      const existing = nodes.get(id);
+      if (existing !== void 0) return existing.type === "memory";
+      if (entityClaimed.has(id)) return false;
+      return includeDangling;
+    };
+    if (typeof memory.supersedes === "string" && memory.supersedes) {
+      const to = memory.supersedes;
+      if (canTargetMemory(to)) {
+        if (!nodes.has(to)) addNode(to, "memory");
+        addEdge(from, to, "supersedes");
+      }
+    }
+    if (Array.isArray(memory.lineage)) {
+      for (const parent of memory.lineage) {
+        if (typeof parent !== "string" || !parent) continue;
+        if (!canTargetMemory(parent)) continue;
+        if (!nodes.has(parent)) addNode(parent, "memory");
+        addEdge(from, parent, "derived-from");
+      }
+    }
+    if (Array.isArray(memory.derived_from)) {
+      for (const raw of memory.derived_from) {
+        if (typeof raw !== "string" || !raw) continue;
+        const to = stripDerivedFromVersion(raw);
+        if (!to) continue;
+        if (!canTargetMemory(to)) continue;
+        if (!nodes.has(to)) addNode(to, "memory");
+        addEdge(from, to, "derived-from");
+      }
+    }
+    const entitySet = /* @__PURE__ */ new Set();
+    if (typeof memory.entityRef === "string" && memory.entityRef) {
+      entitySet.add(memory.entityRef);
+    }
+    if (Array.isArray(memory.entityRefs)) {
+      for (const ref of memory.entityRefs) {
+        if (typeof ref === "string" && ref) entitySet.add(ref);
+      }
+    }
+    for (const ref of entitySet) {
+      const existing = nodes.get(ref);
+      if (existing !== void 0 && existing.type !== "entity") continue;
+      if (!existing) addNode(ref, "entity");
+      addEdge(from, ref, "mentions");
+    }
+    if (typeof memory.content === "string" && memory.content.length > 0) {
+      CITATION_REGEX.lastIndex = 0;
+      let match;
+      while ((match = CITATION_REGEX.exec(memory.content)) !== null) {
+        const body = match[1];
+        if (!body) continue;
+        const fields = parseCitationFields(body);
+        const agent = fields.agent;
+        if (!agent) continue;
+        const agentId = `agent:${agent}`;
+        const existing = nodes.get(agentId);
+        if (existing !== void 0 && existing.type !== "entity") continue;
+        if (!existing) addNode(agentId, "entity");
+        addEdge(from, agentId, "authored-by");
+      }
+    }
+  }
+  return { nodes, edges };
+}
+function buildGraphFromMemories(memories, options = {}) {
+  const { nodes, edges } = extractGraphEdges(memories, options);
+  return { nodes, edges };
+}
+
+export {
+  DEFAULT_PPR_DAMPING,
+  DEFAULT_PPR_ITERATIONS,
+  DEFAULT_PPR_TOLERANCE,
+  queryGraph,
+  isNodeType,
+  isEdgeType,
+  extractGraphEdges,
+  buildGraphFromMemories
+};
+//# sourceMappingURL=chunk-64NJRYU2.js.map

package/dist/chunk-64NJRYU2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/graph-retrieval.ts"],"sourcesContent":["/**\n * Graph-based retrieval types (issue #559, PR 1 of 5).\n *\n * This module defines the forward-looking type contract for Remnic's\n * first-class retrieval graph (GAAMA / GAM inspired). It ships types\n * and a no-op `queryGraph()` stub only — no behavior, no I/O, and\n * no importers inside the codebase yet.\n *\n * Subsequent slices will land:\n *   - PR 2: Edge extraction from existing relationship facts + cross-memory\n *           entity references during indexing (writes `~/.remnic/graph.json`).\n *   - PR 3: Pure `personalizedPageRank()` implementation.\n *   - PR 4: Feature-flagged wiring into `retrieval.ts` behind\n *           `graphRetrievalEnabled` (default `false`).\n *   - PR 5: LoCoMo A/B bench harness + default flip decision.\n *\n * Keeping the node/edge type enums complete from PR 1 avoids type churn\n * when later slices add reflection/concept node synthesis or additional\n * edge semantics.\n */\n\n// ---------------------------------------------------------------------------\n// Node & edge type enums\n// ---------------------------------------------------------------------------\n\n/**\n * Kinds of nodes the retrieval graph can hold.\n *\n * - `memory`:     a stored memory file (the primary retrieval target).\n * - `entity`:     a named entity referenced by one or more memories.\n * - `episode`:    a temporally-bounded interaction or session grouping.\n * - `concept`:    an abstract topic / idea (forward-looking; synthesis\n *                 is out of scope for this issue, but the type is\n *                 defined here to keep later slices additive).\n * - `reflection`: an LLM-generated summary / meta-memory about other\n *                 nodes (also forward-looking, same rationale).\n */\nexport type NodeType =\n  | \"memory\"\n  | \"entity\"\n  | \"episode\"\n  | \"concept\"\n  | \"reflection\";\n\n/**\n * Kinds of edges the retrieval graph can hold.\n *\n * Edges are directed. `from` → `to` semantics:\n *\n * - `references`:    `from` contains an explicit reference to `to`\n *                    (e.g., a memory referencing another memory).\n * - `supersedes`:    `from` supersedes `to` (newer memory replaces older).\n * - `authored-by`:   `from` was authored by the entity in `to`.\n * - `mentions`:      `from` mentions the entity/concept in `to` without\n *                    a stronger relationship claim.\n * - `derived-from`:  `from` was derived from `to` (reflections,\n *                    consolidations, summaries).\n * - `temporal-next`: `from` immediately follows `to` in time (episodes).\n * - `related-to`:    generic weak relationship fallback for edges that\n *                    do not fit a stronger type.\n */\nexport type EdgeType =\n  | \"references\"\n  | \"supersedes\"\n  | \"authored-by\"\n  | \"mentions\"\n  | \"derived-from\"\n  | \"temporal-next\"\n  | \"related-to\";\n\n// ---------------------------------------------------------------------------\n// Graph element shapes\n// ---------------------------------------------------------------------------\n\n/**\n * A single node in the retrieval graph.\n *\n * `id` is the caller-controlled stable identifier (typically a memory\n * file path, entity slug, or episode id). `weight` is an optional prior\n * importance score used as a starting bias during Personalized PageRank;\n * it is intentionally optional because most nodes default to uniform\n * priors.\n *\n * Named `RemnicGraphNode` (not `GraphNode`) to avoid colliding with the\n * unrelated `GraphEdge` in `graph.ts`, which models Multi-Graph Memory\n * (MAGMA/SYNAPSE) edges and is an incompatible shape.\n */\nexport interface RemnicGraphNode {\n  id: string;\n  type: NodeType;\n  weight?: number;\n}\n\n/**\n * A directed edge between two nodes.\n *\n * `weight` is optional; when absent PPR implementations should treat\n * the edge as weight `1`. We keep weight optional rather than defaulting\n * at construction so producers can serialize a minimal edge shape.\n *\n * Named `RemnicGraphEdge` (not `GraphEdge`) to avoid colliding with the\n * unrelated `GraphEdge` in `graph.ts` (Multi-Graph Memory).\n */\nexport interface RemnicGraphEdge {\n  from: string;\n  to: string;\n  type: EdgeType;\n  weight?: number;\n}\n\n/**\n * The retrieval graph itself.\n *\n * Nodes are held in a `Map<string, RemnicGraphNode>` keyed by `id` so\n * PPR lookups are O(1). Edges are kept as a flat array; adjacency\n * indexing is a PR-3 concern (PPR will likely build a transient\n * outgoing-adjacency map on demand).\n */\nexport interface RemnicGraph {\n  nodes: Map<string, RemnicGraphNode>;\n  edges: RemnicGraphEdge[];\n}\n\n// ---------------------------------------------------------------------------\n// Query surface (stub)\n// ---------------------------------------------------------------------------\n\n/**\n * Options for `queryGraph()`.\n *\n * Defaults (applied when undefined):\n *   - `damping`:    0.85 (standard PageRank value — higher values make the\n *                   random walk follow edges longer before teleporting back\n *                   to the seed distribution).\n *   - `iterations`: 20 (power-iteration cap).\n *   - `tolerance`:  1e-6 (L1 convergence threshold; iteration stops early\n *                   when the L1 norm of the delta between successive\n *                   rank vectors falls below this).\n *   - `topK`:       unbounded — all nodes with positive score are returned,\n *                   ordered by descending score.\n */\nexport interface QueryGraphOptions {\n  /** Number of top-ranked nodes to return. Defaults to unbounded. */\n  topK?: number;\n  /**\n   * PPR damping factor in (0, 1). The probability of following an outgoing\n   * edge at each step (vs. teleporting back to the seed distribution).\n   * Defaults to 0.85.\n   */\n  damping?: number;\n  /** Maximum PPR iterations before falling back to current rank vector. */\n  iterations?: number;\n  /** L1 convergence threshold. Defaults to 1e-6. */\n  tolerance?: number;\n  /**\n   * Optional per-seed weights. Keys must appear in `seedIds` or (if empty)\n   * in the graph. Values must be non-negative. Weights are normalized so\n   * they sum to 1 before seeding. If omitted, seed mass is distributed\n   * uniformly across `seedIds`.\n   */\n  seedWeights?: ReadonlyMap<string, number> | Readonly<Record<string, number>>;\n}\n\n/**\n * A scored node returned by `queryGraph()`.\n */\nexport interface RankedGraphNode {\n  id: string;\n  score: number;\n}\n\n/**\n * The shape returned by `queryGraph()`.\n */\nexport interface QueryGraphResult {\n  rankedNodes: RankedGraphNode[];\n  /** Number of power-iteration rounds actually executed. */\n  iterations: number;\n  /** L1 delta at the last iteration. */\n  converged: boolean;\n}\n\n/** PPR damping factor default. */\nexport const DEFAULT_PPR_DAMPING = 0.85;\n/** Power-iteration cap default. */\nexport const DEFAULT_PPR_ITERATIONS = 20;\n/** L1 convergence threshold default. */\nexport const DEFAULT_PPR_TOLERANCE = 1e-6;\n\n/**\n * Normalize a `seedWeights` option (Map or plain object) to a plain Map.\n * Silently drops non-finite / negative / non-numeric values. Returns an\n * empty map if the input is undefined.\n */\nfunction normalizeSeedWeights(\n  input: QueryGraphOptions[\"seedWeights\"],\n): Map<string, number> {\n  const out = new Map<string, number>();\n  if (!input) return out;\n  const entries: Iterable<[string, unknown]> =\n    input instanceof Map\n      ? input.entries()\n      : Object.entries(input as Record<string, unknown>);\n  for (const [k, v] of entries) {\n    if (typeof k !== \"string\" || !k) continue;\n    if (typeof v !== \"number\" || !Number.isFinite(v) || v < 0) continue;\n    out.set(k, v);\n  }\n  return out;\n}\n\n/**\n * Build the seed probability vector.\n *\n * Strategy:\n *   1. If the caller supplied `seedWeights`, restrict to keys present in\n *      the graph, sum, and normalize.\n *   2. Otherwise, take the subset of `seedIds` present in the graph and\n *      assign each an equal 1/n share.\n *   3. If neither produces any in-graph mass, fall back to a uniform\n *      distribution over all graph nodes (matches standard PageRank).\n */\nfunction buildSeedVector(\n  graph: RemnicGraph,\n  seedIds: readonly string[],\n  options: QueryGraphOptions,\n): Map<string, number> {\n  const seed = new Map<string, number>();\n\n  const explicitWeights = normalizeSeedWeights(options.seedWeights);\n  if (explicitWeights.size > 0) {\n    // Restrict weight keys to the declared seed set (or, if empty, to\n    // graph nodes). Documented contract in `QueryGraphOptions.seedWeights`:\n    // keys must appear in `seedIds` — unrelated / stale weight entries\n    // must not silently override the requested personalization.\n    const allowedKeys =\n      seedIds.length > 0\n        ? new Set(seedIds.filter((id) => typeof id === \"string\"))\n        : null;\n    let total = 0;\n    for (const [id, w] of explicitWeights) {\n      if (!graph.nodes.has(id)) continue;\n      if (allowedKeys !== null && !allowedKeys.has(id)) continue;\n      seed.set(id, (seed.get(id) ?? 0) + w);\n      total += w;\n    }\n    if (total > 0) {\n      for (const [id, v] of seed) seed.set(id, v / total);\n      return seed;\n    }\n    seed.clear();\n  }\n\n  // Deduplicate before computing shares — `[\"a\", \"a\", \"b\"]` must behave\n  // identically to `[\"a\", \"b\"]`. Computing `share` against a de-duped set\n  // is the only way to guarantee that; renormalizing after the fact is\n  // a no-op because the pre-dedup shares already sum to 1.\n  const validSeeds = new Set<string>();\n  for (const id of seedIds) {\n    if (typeof id === \"string\" && graph.nodes.has(id)) validSeeds.add(id);\n  }\n  if (validSeeds.size > 0) {\n    const share = 1 / validSeeds.size;\n    for (const id of validSeeds) seed.set(id, share);\n    return seed;\n  }\n\n  // Uniform fallback over all graph nodes.\n  if (graph.nodes.size > 0) {\n    const share = 1 / graph.nodes.size;\n    for (const id of graph.nodes.keys()) seed.set(id, share);\n  }\n  return seed;\n}\n\n/**\n * Build an out-adjacency index with summed outgoing edge weights per source.\n *\n * Missing `weight` on an edge defaults to `1`. Edges referencing nodes that\n * are not in `graph.nodes` are skipped (dangling edges cannot propagate\n * mass). The returned `outSum` map lets the PPR loop divide once per source\n * instead of re-summing per iteration.\n */\nfunction buildAdjacency(graph: RemnicGraph): {\n  outgoing: Map<string, { to: string; weight: number }[]>;\n  outSum: Map<string, number>;\n} {\n  const outgoing = new Map<string, { to: string; weight: number }[]>();\n  const outSum = new Map<string, number>();\n  for (const edge of graph.edges) {\n    if (!edge || typeof edge.from !== \"string\" || typeof edge.to !== \"string\") continue;\n    if (!graph.nodes.has(edge.from) || !graph.nodes.has(edge.to)) continue;\n    const weight =\n      typeof edge.weight === \"number\" && Number.isFinite(edge.weight) && edge.weight > 0\n        ? edge.weight\n        : 1;\n    let bucket = outgoing.get(edge.from);\n    if (!bucket) {\n      bucket = [];\n      outgoing.set(edge.from, bucket);\n    }\n    bucket.push({ to: edge.to, weight });\n    outSum.set(edge.from, (outSum.get(edge.from) ?? 0) + weight);\n  }\n  return { outgoing, outSum };\n}\n\n/**\n * Personalized PageRank via power iteration.\n *\n * Pure function — no I/O. Deterministic given the same graph and options.\n *\n * Algorithm:\n *\n *   r_{t+1}(v) = (1 - d) * s(v)\n *              + d * Σ_{u → v} r_t(u) * w(u,v) / Σ_w w(u,·)\n *              + d * (dangling mass) * s(v)\n *\n * where:\n *   - `d` is the damping factor (default 0.85).\n *   - `s` is the seed vector (normalized personalization distribution).\n *   - dangling mass is the total rank on nodes with no outgoing edges,\n *     redistributed over the seed vector so probability mass is conserved.\n *\n * The loop stops early when `|r_{t+1} - r_t|_1 < tolerance` or after\n * `iterations` rounds, whichever comes first.\n *\n * Edge cases:\n *   - Empty graph → `{ rankedNodes: [], iterations: 0, converged: true }`.\n *   - Seed ids that are not in the graph are silently dropped.\n *   - If no in-graph seed mass remains (empty seed or all seeds missing),\n *     the uniform distribution over graph nodes is used — matching\n *     standard PageRank semantics.\n *   - `damping` is clamped to `[0, 1)` (a damping of exactly 1 would make\n *     the chain non-ergodic; damping of exactly 0 reduces to the seed\n *     distribution).\n *   - `topK <= 0` returns an empty ranked list (but the `iterations` and\n *     `converged` fields still reflect the actual computation).\n */\nexport function queryGraph(\n  graph: RemnicGraph,\n  seedIds: readonly string[],\n  options: QueryGraphOptions = {},\n): QueryGraphResult {\n  const n = graph.nodes.size;\n  if (n === 0) {\n    return { rankedNodes: [], iterations: 0, converged: true };\n  }\n\n  // Clamp options.\n  let damping = typeof options.damping === \"number\" ? options.damping : DEFAULT_PPR_DAMPING;\n  if (!Number.isFinite(damping) || damping < 0) damping = 0;\n  if (damping >= 1) damping = 1 - 1e-9;\n\n  let maxIter = typeof options.iterations === \"number\" ? Math.floor(options.iterations) : DEFAULT_PPR_ITERATIONS;\n  if (!Number.isFinite(maxIter) || maxIter < 0) maxIter = 0;\n\n  let tolerance = typeof options.tolerance === \"number\" ? options.tolerance : DEFAULT_PPR_TOLERANCE;\n  if (!Number.isFinite(tolerance) || tolerance < 0) tolerance = 0;\n\n  const seed = buildSeedVector(graph, seedIds, options);\n\n  // Apply `RemnicGraphNode.weight` as a starting-rank prior — BUT only\n  // when the caller did not supply explicit `seedWeights`. Explicit\n  // caller-supplied weights must not be silently re-biased by node\n  // priors (would double-count and contradict the documented contract\n  // for `seedWeights`). When no explicit weights are given, multiply\n  // each seed entry by its node weight (defaulting missing / non-\n  // positive / non-finite weights to 1) and renormalize.\n  const hasExplicitWeights =\n    options.seedWeights !== undefined && options.seedWeights !== null;\n  if (!hasExplicitWeights) {\n    let priorTotal = 0;\n    for (const [id, s] of seed) {\n      const node = graph.nodes.get(id);\n      const w =\n        node !== undefined &&\n        typeof node.weight === \"number\" &&\n        Number.isFinite(node.weight) &&\n        node.weight > 0\n          ? node.weight\n          : 1;\n      const biased = s * w;\n      seed.set(id, biased);\n      priorTotal += biased;\n    }\n    if (priorTotal > 0) {\n      for (const [id, s] of seed) seed.set(id, s / priorTotal);\n    }\n  }\n\n  const { outgoing, outSum } = buildAdjacency(graph);\n\n  // Initialize rank vector = seed.\n  let rank = new Map<string, number>();\n  for (const id of graph.nodes.keys()) rank.set(id, seed.get(id) ?? 0);\n  // If the seed vector is empty (e.g. graph has no nodes matching seeds\n  // AND the uniform fallback was somehow empty — shouldn't happen when\n  // n > 0, but defensively): return empty ranking.\n  let seedTotal = 0;\n  for (const v of seed.values()) seedTotal += v;\n  if (seedTotal === 0) {\n    return { rankedNodes: [], iterations: 0, converged: true };\n  }\n\n  let converged = false;\n  let iter = 0;\n  for (; iter < maxIter; iter++) {\n    const next = new Map<string, number>();\n\n    // Sum of rank on dangling nodes (no outgoing edges) — redistribute\n    // proportional to the seed vector to conserve probability mass.\n    let danglingMass = 0;\n    for (const [id, r] of rank) {\n      if ((outSum.get(id) ?? 0) === 0) danglingMass += r;\n    }\n\n    // Teleport contribution: (1 - d) * s(v) + d * danglingMass * s(v).\n    const teleportScale = 1 - damping + damping * danglingMass;\n    for (const [id, s] of seed) {\n      next.set(id, (next.get(id) ?? 0) + teleportScale * s);\n    }\n\n    // Edge contribution: d * r(u) * w(u,v) / Σ w(u,·).\n    for (const [from, edges] of outgoing) {\n      const r = rank.get(from) ?? 0;\n      if (r === 0) continue;\n      const total = outSum.get(from) ?? 0;\n      if (total === 0) continue;\n      const share = (damping * r) / total;\n      for (const { to, weight } of edges) {\n        next.set(to, (next.get(to) ?? 0) + share * weight);\n      }\n    }\n\n    // Compute L1 delta.\n    let delta = 0;\n    for (const id of graph.nodes.keys()) {\n      delta += Math.abs((next.get(id) ?? 0) - (rank.get(id) ?? 0));\n    }\n\n    rank = next;\n    if (delta < tolerance) {\n      converged = true;\n      iter += 1; // record that this iteration completed\n      break;\n    }\n  }\n\n  // Rank and trim.\n  const ranked: RankedGraphNode[] = [];\n  for (const [id, score] of rank) {\n    if (score > 0) ranked.push({ id, score });\n  }\n  // Sort by descending score, ties broken by id for determinism.\n  ranked.sort((a, b) => {\n    if (b.score !== a.score) return b.score - a.score;\n    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;\n  });\n\n  const topK = options.topK;\n  let trimmed: RankedGraphNode[];\n  if (typeof topK === \"number\") {\n    if (topK <= 0) {\n      trimmed = [];\n    } else if (topK < ranked.length) {\n      trimmed = ranked.slice(0, topK);\n    } else {\n      trimmed = ranked;\n    }\n  } else {\n    trimmed = ranked;\n  }\n\n  return { rankedNodes: trimmed, iterations: iter, converged };\n}\n\n// ---------------------------------------------------------------------------\n// Type guards (useful for defensive construction from untyped JSON)\n// ---------------------------------------------------------------------------\n\nconst NODE_TYPES: ReadonlySet<NodeType> = new Set<NodeType>([\n  \"memory\",\n  \"entity\",\n  \"episode\",\n  \"concept\",\n  \"reflection\",\n]);\n\nconst EDGE_TYPES: ReadonlySet<EdgeType> = new Set<EdgeType>([\n  \"references\",\n  \"supersedes\",\n  \"authored-by\",\n  \"mentions\",\n  \"derived-from\",\n  \"temporal-next\",\n  \"related-to\",\n]);\n\n/** Returns true iff `value` is a valid `NodeType`. */\nexport function isNodeType(value: unknown): value is NodeType {\n  return typeof value === \"string\" && NODE_TYPES.has(value as NodeType);\n}\n\n/** Returns true iff `value` is a valid `EdgeType`. */\nexport function isEdgeType(value: unknown): value is EdgeType {\n  return typeof value === \"string\" && EDGE_TYPES.has(value as EdgeType);\n}\n\n// ---------------------------------------------------------------------------\n// Edge extraction (issue #559, PR 2 of 5)\n// ---------------------------------------------------------------------------\n\n/**\n * Minimum fields the edge extractor reads from a memory record. Structural\n * typing is used so callers can pass any subset of `MemoryFrontmatter`\n * (including richer loaded memories) without a cast.\n *\n * All reference fields are optional — memories written before earlier slices\n * landed will simply contribute no edges for those dimensions.\n */\nexport interface MemoryEdgeSource {\n  /** Stable identifier for the memory (typically the file path). */\n  id: string;\n  /** Older memory id this memory supersedes (1:1). */\n  supersedes?: string;\n  /** Parent memory ids this memory was derived from (lineage). */\n  lineage?: string[];\n  /**\n   * Consolidation provenance — `\"<memory-id>:<version-number>\"` strings.\n   * The memory-id portion before the last `:` is used as the edge target.\n   */\n  derived_from?: string[];\n  /** Primary entity reference on the memory (e.g. `person:Jane Doe`). */\n  entityRef?: string;\n  /** Additional entity references (used by episodes and ledger records). */\n  entityRefs?: string[];\n  /** Raw memory body — scanned for inline `[Source: ...]` citation blocks. */\n  content?: string;\n}\n\n/** Options controlling edge extraction. */\nexport interface ExtractGraphEdgesOptions {\n  /**\n   * When true, include edges whose `to` endpoint is not present in the\n   * provided node index. Defaults to `false` — dangling edges are silently\n   * skipped because PPR cannot propagate mass through a missing node.\n   */\n  includeDanglingEdges?: boolean;\n}\n\n/**\n * Regex that matches the `[Source: ...]` citation block emitted by\n * `source-attribution.ts`. Kept local (rather than importing) because the\n * extractor intentionally has no dependency on the citation module's mutable\n * template configuration — it only recognizes the default shape plus minor\n * whitespace / ordering variants.\n */\n// Non-greedy quantifiers on classes like `[^\\]\\n]+?` can be polynomial on\n// pathological inputs (CodeQL rule js/polynomial-redos). Using a greedy\n// quantifier with a negated character class that also excludes `[` prevents\n// nested-bracket inputs from forcing catastrophic backtracking, and the `\\s*`\n// after `Source:` is bounded by the terminal `]`.\nconst CITATION_REGEX = /\\[Source:([^\\]\\n[]+)\\]/gi;\n\n/**\n * Parse `key=value` pairs out of a citation body. Whitespace-tolerant and\n * case-insensitive: keys are normalized to lowercase so callers can do\n * `fields.agent` without worrying about `[Source: Agent=...]` variants.\n */\nfunction parseCitationFields(body: string): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const rawPart of body.split(\",\")) {\n    const part = rawPart.trim();\n    if (!part) continue;\n    const eq = part.indexOf(\"=\");\n    if (eq <= 0) continue;\n    const key = part.slice(0, eq).trim().toLowerCase();\n    const value = part.slice(eq + 1).trim();\n    if (key && value) out[key] = value;\n  }\n  return out;\n}\n\n/**\n * Strip the trailing `:<version>` from a `derived_from` entry. Returns the\n * original string if no colon is present. We intentionally use `lastIndexOf`\n * because memory ids may themselves contain colons (e.g. entity-prefixed\n * ids), but the version suffix — when present — is always the final\n * `:<digits>` segment.\n */\nfunction stripDerivedFromVersion(ref: string): string {\n  const colon = ref.lastIndexOf(\":\");\n  if (colon < 0) return ref;\n  const tail = ref.slice(colon + 1);\n  if (tail.length === 0) return ref.slice(0, colon);\n  // Only strip when the tail is purely numeric; otherwise keep the full ref.\n  if (/^\\d+$/.test(tail)) return ref.slice(0, colon);\n  return ref;\n}\n\n/**\n * Extract retrieval-graph edges from a collection of memories.\n *\n * Pure function — no I/O, no config access, no time-based side effects.\n * Given the same inputs, always produces the same edges in the same order\n * so dedup downstream is deterministic.\n *\n * Source → target semantics by edge type:\n *\n *   - `supersedes`:    memory → older memory (from `supersedes` field).\n *   - `derived-from`:  memory → each parent in `lineage` OR `derived_from`.\n *   - `mentions`:      memory → each entity in `entityRef` / `entityRefs`.\n *   - `authored-by`:   memory → agent id parsed from inline `[Source: ...]`.\n *\n * `temporal-next`, `references`, `related-to`, and `concept` / `reflection`\n * node synthesis are deferred to later slices — they require either episode\n * sequencing or an abstraction synthesis pass that is out of scope for PR 2.\n *\n * @param memories     Memories to scan. Order is preserved; duplicates are\n *                     not deduped (the caller controls the input set).\n * @param options      Extraction knobs. See `ExtractGraphEdgesOptions`.\n * @returns            A `{ nodes, edges }` pair. `nodes` contains one\n *                     `memory` node per input memory plus one `entity` node\n *                     per distinct entity discovered across all mentions.\n *                     Edges reference ids in the returned node map unless\n *                     `includeDanglingEdges` is set.\n */\nexport function extractGraphEdges(\n  memories: readonly MemoryEdgeSource[],\n  options: ExtractGraphEdgesOptions = {},\n): { nodes: Map<string, RemnicGraphNode>; edges: RemnicGraphEdge[] } {\n  const includeDangling = options.includeDanglingEdges === true;\n\n  const nodes = new Map<string, RemnicGraphNode>();\n  const edges: RemnicGraphEdge[] = [];\n  // Dedupe within this extraction pass. Key is `${from}\\u0000${to}\\u0000${type}`\n  // — using a NUL separator avoids collisions with ids that contain `|`.\n  const seenEdgeKeys = new Set<string>();\n\n  const addNode = (id: string, type: NodeType) => {\n    if (!nodes.has(id)) nodes.set(id, { id, type });\n  };\n\n  const addEdge = (from: string, to: string, type: EdgeType) => {\n    if (!from || !to || from === to) return;\n    const key = `${from}\\u0000${to}\\u0000${type}`;\n    if (seenEdgeKeys.has(key)) return;\n    seenEdgeKeys.add(key);\n    edges.push({ from, to, type });\n  };\n\n  // First pass — register every memory as a node so cross-references can\n  // resolve regardless of input ordering.\n  for (const memory of memories) {\n    if (!memory?.id) continue;\n    addNode(memory.id, \"memory\");\n  }\n\n  // Pre-scan every memory for entity / agent references so the\n  // memory-target guard can reject ids that are \"claimed\" by entity\n  // mentions in the same batch — regardless of iteration order.\n  // Without this, with `includeDanglingEdges: true`, processing\n  // `{supersedes: \"shared\"}` before `{entityRef: \"shared\"}` would\n  // materialize a memory node for \"shared\" and then the later entity\n  // mention would be silently dropped (and vice versa), producing\n  // order-dependent output.\n  const entityClaimed = new Set<string>();\n  for (const memory of memories) {\n    if (!memory?.id) continue;\n    // Do not mark the memory's own id as entity-claimed just because it\n    // carries an entityRef — the memory node takes precedence over its\n    // own mention (which is impossible anyway; the edge would be a\n    // self-loop and is dropped).\n    if (typeof memory.entityRef === \"string\" && memory.entityRef) {\n      if (memory.entityRef !== memory.id) entityClaimed.add(memory.entityRef);\n    }\n    if (Array.isArray(memory.entityRefs)) {\n      for (const ref of memory.entityRefs) {\n        if (typeof ref === \"string\" && ref && ref !== memory.id) {\n          entityClaimed.add(ref);\n        }\n      }\n    }\n    if (typeof memory.content === \"string\" && memory.content.length > 0) {\n      CITATION_REGEX.lastIndex = 0;\n      let match: RegExpExecArray | null;\n      while ((match = CITATION_REGEX.exec(memory.content)) !== null) {\n        const body = match[1];\n        if (!body) continue;\n        const agent = parseCitationFields(body).agent;\n        if (!agent) continue;\n        const agentId = `agent:${agent}`;\n        if (agentId !== memory.id) entityClaimed.add(agentId);\n      }\n    }\n  }\n  // Ids claimed by both roles (memory + entity) stay memory — an\n  // explicit memory node with a given id always wins over an entity\n  // mention of the same id in a different memory. Drop any memory ids\n  // out of `entityClaimed` so the memory-target guard does not reject\n  // cross-memory supersedes / lineage references to them.\n  for (const memory of memories) {\n    if (memory?.id) entityClaimed.delete(memory.id);\n  }\n\n  // Second pass — walk each memory's relationship fields.\n  for (const memory of memories) {\n    if (!memory?.id) continue;\n    const from = memory.id;\n\n    // `supersedes`, `lineage`, and `derived_from` edges must point at a\n    // memory node specifically — never an entity / episode / concept /\n    // reflection node that happens to share an id. The guard applies\n    // regardless of `includeDanglingEdges`:\n    //\n    //   - If the target is already registered under a non-memory type,\n    //     reject the edge (type mismatch).\n    //   - If the target will be claimed by an entity mention in this\n    //     batch (pre-scan above), reject the edge.\n    //   - If the target is not yet known and is not entity-claimed,\n    //     accept only when `includeDanglingEdges` is `true`. A new\n    //     memory node is registered for the dangling reference.\n    //   - If the target is already registered as a memory, accept.\n    const canTargetMemory = (id: string): boolean => {\n      const existing = nodes.get(id);\n      if (existing !== undefined) return existing.type === \"memory\";\n      if (entityClaimed.has(id)) return false;\n      return includeDangling;\n    };\n\n    // supersedes: memory → older memory\n    if (typeof memory.supersedes === \"string\" && memory.supersedes) {\n      const to = memory.supersedes;\n      if (canTargetMemory(to)) {\n        if (!nodes.has(to)) addNode(to, \"memory\");\n        addEdge(from, to, \"supersedes\");\n      }\n    }\n\n    // lineage: memory → each parent memory\n    if (Array.isArray(memory.lineage)) {\n      for (const parent of memory.lineage) {\n        if (typeof parent !== \"string\" || !parent) continue;\n        if (!canTargetMemory(parent)) continue;\n        if (!nodes.has(parent)) addNode(parent, \"memory\");\n        addEdge(from, parent, \"derived-from\");\n      }\n    }\n\n    // derived_from: memory → parent memory (strip `:<version>` suffix)\n    if (Array.isArray(memory.derived_from)) {\n      for (const raw of memory.derived_from) {\n        if (typeof raw !== \"string\" || !raw) continue;\n        const to = stripDerivedFromVersion(raw);\n        if (!to) continue;\n        if (!canTargetMemory(to)) continue;\n        if (!nodes.has(to)) addNode(to, \"memory\");\n        addEdge(from, to, \"derived-from\");\n      }\n    }\n\n    // entityRef / entityRefs: memory → entity. The target must either be\n    // absent (we register a new entity node) or already an entity node\n    // (no type conflict). If the id is already a memory node, drop the\n    // edge rather than mis-typing it — the extractor never mutates an\n    // existing node's type.\n    const entitySet = new Set<string>();\n    if (typeof memory.entityRef === \"string\" && memory.entityRef) {\n      entitySet.add(memory.entityRef);\n    }\n    if (Array.isArray(memory.entityRefs)) {\n      for (const ref of memory.entityRefs) {\n        if (typeof ref === \"string\" && ref) entitySet.add(ref);\n      }\n    }\n    for (const ref of entitySet) {\n      const existing = nodes.get(ref);\n      if (existing !== undefined && existing.type !== \"entity\") continue;\n      if (!existing) addNode(ref, \"entity\");\n      addEdge(from, ref, \"mentions\");\n    }\n\n    // Inline [Source: agent=..., ...] citations → authored-by edge.\n    // Same type-collision guard as the entity block above.\n    if (typeof memory.content === \"string\" && memory.content.length > 0) {\n      // Reset the regex's lastIndex on each memory since it is a global regex.\n      CITATION_REGEX.lastIndex = 0;\n      let match: RegExpExecArray | null;\n      while ((match = CITATION_REGEX.exec(memory.content)) !== null) {\n        const body = match[1];\n        if (!body) continue;\n        const fields = parseCitationFields(body);\n        const agent = fields.agent;\n        if (!agent) continue;\n        const agentId = `agent:${agent}`;\n        const existing = nodes.get(agentId);\n        if (existing !== undefined && existing.type !== \"entity\") continue;\n        if (!existing) addNode(agentId, \"entity\");\n        addEdge(from, agentId, \"authored-by\");\n      }\n    }\n  }\n\n  return { nodes, edges };\n}\n\n/**\n * Build a `RemnicGraph` from a collection of memories by delegating to\n * `extractGraphEdges()`. Convenience wrapper so callers do not have to\n * re-wrap the `{ nodes, edges }` pair into the `RemnicGraph` interface.\n *\n * Pure function — no I/O. Persisting the graph (e.g. writing\n * `~/.remnic/graph.json`) is left to the caller; that decision belongs with\n * the maintenance / consolidation pass in PR 4, not the extractor.\n */\nexport function buildGraphFromMemories(\n  memories: readonly MemoryEdgeSource[],\n  options: ExtractGraphEdgesOptions = {},\n): RemnicGraph {\n  const { nodes, edges } = extractGraphEdges(memories, options);\n  return { nodes, edges };\n}\n"],"mappings":";AAuLO,IAAM,sBAAsB;AAE5B,IAAM,yBAAyB;AAE/B,IAAM,wBAAwB;AAOrC,SAAS,qBACP,OACqB;AACrB,QAAM,MAAM,oBAAI,IAAoB;AACpC,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,UACJ,iBAAiB,MACb,MAAM,QAAQ,IACd,OAAO,QAAQ,KAAgC;AACrD,aAAW,CAAC,GAAG,CAAC,KAAK,SAAS;AAC5B,QAAI,OAAO,MAAM,YAAY,CAAC,EAAG;AACjC,QAAI,OAAO,MAAM,YAAY,CAAC,OAAO,SAAS,CAAC,KAAK,IAAI,EAAG;AAC3D,QAAI,IAAI,GAAG,CAAC;AAAA,EACd;AACA,SAAO;AACT;AAaA,SAAS,gBACP,OACA,SACA,SACqB;AACrB,QAAM,OAAO,oBAAI,IAAoB;AAErC,QAAM,kBAAkB,qBAAqB,QAAQ,WAAW;AAChE,MAAI,gBAAgB,OAAO,GAAG;AAK5B,UAAM,cACJ,QAAQ,SAAS,IACb,IAAI,IAAI,QAAQ,OAAO,CAAC,OAAO,OAAO,OAAO,QAAQ,CAAC,IACtD;AACN,QAAI,QAAQ;AACZ,eAAW,CAAC,IAAI,CAAC,KAAK,iBAAiB;AACrC,UAAI,CAAC,MAAM,MAAM,IAAI,EAAE,EAAG;AAC1B,UAAI,gBAAgB,QAAQ,CAAC,YAAY,IAAI,EAAE,EAAG;AAClD,WAAK,IAAI,KAAK,KAAK,IAAI,EAAE,KAAK,KAAK,CAAC;AACpC,eAAS;AAAA,IACX;AACA,QAAI,QAAQ,GAAG;AACb,iBAAW,CAAC,IAAI,CAAC,KAAK,KAAM,MAAK,IAAI,IAAI,IAAI,KAAK;AAClD,aAAO;AAAA,IACT;AACA,SAAK,MAAM;AAAA,EACb;AAMA,QAAM,aAAa,oBAAI,IAAY;AACnC,aAAW,MAAM,SAAS;AACxB,QAAI,OAAO,OAAO,YAAY,MAAM,MAAM,IAAI,EAAE,EAAG,YAAW,IAAI,EAAE;AAAA,EACtE;AACA,MAAI,WAAW,OAAO,GAAG;AACvB,UAAM,QAAQ,IAAI,WAAW;AAC7B,eAAW,MAAM,WAAY,MAAK,IAAI,IAAI,KAAK;AAC/C,WAAO;AAAA,EACT;AAGA,MAAI,MAAM,MAAM,OAAO,GAAG;AACxB,UAAM,QAAQ,IAAI,MAAM,MAAM;AAC9B,eAAW,MAAM,MAAM,MAAM,KAAK,EAAG,MAAK,IAAI,IAAI,KAAK;AAAA,EACzD;AACA,SAAO;AACT;AAUA,SAAS,eAAe,OAGtB;AACA,QAAM,WAAW,oBAAI,IAA8C;AACnE,QAAM,SAAS,oBAAI,IAAoB;AACvC,aAAW,QAAQ,MAAM,OAAO;AAC9B,QAAI,CAAC,QAAQ,OAAO,KAAK,SAAS,YAAY,OAAO,KAAK,OAAO,SAAU;AAC3E,QAAI,CAAC,MAAM,MAAM,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,MAAM,IAAI,KAAK,EAAE,EAAG;AAC9D,UAAM,SACJ,OAAO,KAAK,WAAW,YAAY,OAAO,SAAS,KAAK,MAAM,KAAK,KAAK,SAAS,IAC7E,KAAK,SACL;AACN,QAAI,SAAS,SAAS,IAAI,KAAK,IAAI;AACnC,QAAI,CAAC,QAAQ;AACX,eAAS,CAAC;AACV,eAAS,IAAI,KAAK,MAAM,MAAM;AAAA,IAChC;AACA,WAAO,KAAK,EAAE,IAAI,KAAK,IAAI,OAAO,CAAC;AACnC,WAAO,IAAI,KAAK,OAAO,OAAO,IAAI,KAAK,IAAI,KAAK,KAAK,MAAM;AAAA,EAC7D;AACA,SAAO,EAAE,UAAU,OAAO;AAC5B;AAkCO,SAAS,WACd,OACA,SACA,UAA6B,CAAC,GACZ;AAClB,QAAM,IAAI,MAAM,MAAM;AACtB,MAAI,MAAM,GAAG;AACX,WAAO,EAAE,aAAa,CAAC,GAAG,YAAY,GAAG,WAAW,KAAK;AAAA,EAC3D;AAGA,MAAI,UAAU,OAAO,QAAQ,YAAY,WAAW,QAAQ,UAAU;AACtE,MAAI,CAAC,OAAO,SAAS,OAAO,KAAK,UAAU,EAAG,WAAU;AACxD,MAAI,WAAW,EAAG,WAAU,IAAI;AAEhC,MAAI,UAAU,OAAO,QAAQ,eAAe,WAAW,KAAK,MAAM,QAAQ,UAAU,IAAI;AACxF,MAAI,CAAC,OAAO,SAAS,OAAO,KAAK,UAAU,EAAG,WAAU;AAExD,MAAI,YAAY,OAAO,QAAQ,cAAc,WAAW,QAAQ,YAAY;AAC5E,MAAI,CAAC,OAAO,SAAS,SAAS,KAAK,YAAY,EAAG,aAAY;AAE9D,QAAM,OAAO,gBAAgB,OAAO,SAAS,OAAO;AASpD,QAAM,qBACJ,QAAQ,gBAAgB,UAAa,QAAQ,gBAAgB;AAC/D,MAAI,CAAC,oBAAoB;AACvB,QAAI,aAAa;AACjB,eAAW,CAAC,IAAI,CAAC,KAAK,MAAM;AAC1B,YAAM,OAAO,MAAM,MAAM,IAAI,EAAE;AAC/B,YAAM,IACJ,SAAS,UACT,OAAO,KAAK,WAAW,YACvB,OAAO,SAAS,KAAK,MAAM,KAC3B,KAAK,SAAS,IACV,KAAK,SACL;AACN,YAAM,SAAS,IAAI;AACnB,WAAK,IAAI,IAAI,MAAM;AACnB,oBAAc;AAAA,IAChB;AACA,QAAI,aAAa,GAAG;AAClB,iBAAW,CAAC,IAAI,CAAC,KAAK,KAAM,MAAK,IAAI,IAAI,IAAI,UAAU;AAAA,IACzD;AAAA,EACF;AAEA,QAAM,EAAE,UAAU,OAAO,IAAI,eAAe,KAAK;AAGjD,MAAI,OAAO,oBAAI,IAAoB;AACnC,aAAW,MAAM,MAAM,MAAM,KAAK,EAAG,MAAK,IAAI,IAAI,KAAK,IAAI,EAAE,KAAK,CAAC;AAInE,MAAI,YAAY;AAChB,aAAW,KAAK,KAAK,OAAO,EAAG,cAAa;AAC5C,MAAI,cAAc,GAAG;AACnB,WAAO,EAAE,aAAa,CAAC,GAAG,YAAY,GAAG,WAAW,KAAK;AAAA,EAC3D;AAEA,MAAI,YAAY;AAChB,MAAI,OAAO;AACX,SAAO,OAAO,SAAS,QAAQ;AAC7B,UAAM,OAAO,oBAAI,IAAoB;AAIrC,QAAI,eAAe;AACnB,eAAW,CAAC,IAAI,CAAC,KAAK,MAAM;AAC1B,WAAK,OAAO,IAAI,EAAE,KAAK,OAAO,EAAG,iBAAgB;AAAA,IACnD;AAGA,UAAM,gBAAgB,IAAI,UAAU,UAAU;AAC9C,eAAW,CAAC,IAAI,CAAC,KAAK,MAAM;AAC1B,WAAK,IAAI,KAAK,KAAK,IAAI,EAAE,KAAK,KAAK,gBAAgB,CAAC;AAAA,IACtD;AAGA,eAAW,CAAC,MAAM,KAAK,KAAK,UAAU;AACpC,YAAM,IAAI,KAAK,IAAI,IAAI,KAAK;AAC5B,UAAI,MAAM,EAAG;AACb,YAAM,QAAQ,OAAO,IAAI,IAAI,KAAK;AAClC,UAAI,UAAU,EAAG;AACjB,YAAM,QAAS,UAAU,IAAK;AAC9B,iBAAW,EAAE,IAAI,OAAO,KAAK,OAAO;AAClC,aAAK,IAAI,KAAK,KAAK,IAAI,EAAE,KAAK,KAAK,QAAQ,MAAM;AAAA,MACnD;AAAA,IACF;AAGA,QAAI,QAAQ;AACZ,eAAW,MAAM,MAAM,MAAM,KAAK,GAAG;AACnC,eAAS,KAAK,KAAK,KAAK,IAAI,EAAE,KAAK,MAAM,KAAK,IAAI,EAAE,KAAK,EAAE;AAAA,IAC7D;AAEA,WAAO;AACP,QAAI,QAAQ,WAAW;AACrB,kBAAY;AACZ,cAAQ;AACR;AAAA,IACF;AAAA,EACF;AAGA,QAAM,SAA4B,CAAC;AACnC,aAAW,CAAC,IAAI,KAAK,KAAK,MAAM;AAC9B,QAAI,QAAQ,EAAG,QAAO,KAAK,EAAE,IAAI,MAAM,CAAC;AAAA,EAC1C;AAEA,SAAO,KAAK,CAAC,GAAG,MAAM;AACpB,QAAI,EAAE,UAAU,EAAE,MAAO,QAAO,EAAE,QAAQ,EAAE;AAC5C,WAAO,EAAE,KAAK,EAAE,KAAK,KAAK,EAAE,KAAK,EAAE,KAAK,IAAI;AAAA,EAC9C,CAAC;AAED,QAAM,OAAO,QAAQ;AACrB,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC5B,QAAI,QAAQ,GAAG;AACb,gBAAU,CAAC;AAAA,IACb,WAAW,OAAO,OAAO,QAAQ;AAC/B,gBAAU,OAAO,MAAM,GAAG,IAAI;AAAA,IAChC,OAAO;AACL,gBAAU;AAAA,IACZ;AAAA,EACF,OAAO;AACL,cAAU;AAAA,EACZ;AAEA,SAAO,EAAE,aAAa,SAAS,YAAY,MAAM,UAAU;AAC7D;AAMA,IAAM,aAAoC,oBAAI,IAAc;AAAA,EAC1D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAED,IAAM,aAAoC,oBAAI,IAAc;AAAA,EAC1D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAGM,SAAS,WAAW,OAAmC;AAC5D,SAAO,OAAO,UAAU,YAAY,WAAW,IAAI,KAAiB;AACtE;AAGO,SAAS,WAAW,OAAmC;AAC5D,SAAO,OAAO,UAAU,YAAY,WAAW,IAAI,KAAiB;AACtE;AAwDA,IAAM,iBAAiB;AAOvB,SAAS,oBAAoB,MAAsC;AACjE,QAAM,MAA8B,CAAC;AACrC,aAAW,WAAW,KAAK,MAAM,GAAG,GAAG;AACrC,UAAM,OAAO,QAAQ,KAAK;AAC1B,QAAI,CAAC,KAAM;AACX,UAAM,KAAK,KAAK,QAAQ,GAAG;AAC3B,QAAI,MAAM,EAAG;AACb,UAAM,MAAM,KAAK,MAAM,GAAG,EAAE,EAAE,KAAK,EAAE,YAAY;AACjD,UAAM,QAAQ,KAAK,MAAM,KAAK,CAAC,EAAE,KAAK;AACtC,QAAI,OAAO,MAAO,KAAI,GAAG,IAAI;AAAA,EAC/B;AACA,SAAO;AACT;AASA,SAAS,wBAAwB,KAAqB;AACpD,QAAM,QAAQ,IAAI,YAAY,GAAG;AACjC,MAAI,QAAQ,EAAG,QAAO;AACtB,QAAM,OAAO,IAAI,MAAM,QAAQ,CAAC;AAChC,MAAI,KAAK,WAAW,EAAG,QAAO,IAAI,MAAM,GAAG,KAAK;AAEhD,MAAI,QAAQ,KAAK,IAAI,EAAG,QAAO,IAAI,MAAM,GAAG,KAAK;AACjD,SAAO;AACT;AA6BO,SAAS,kBACd,UACA,UAAoC,CAAC,GAC8B;AACnE,QAAM,kBAAkB,QAAQ,yBAAyB;AAEzD,QAAM,QAAQ,oBAAI,IAA6B;AAC/C,QAAM,QAA2B,CAAC;AAGlC,QAAM,eAAe,oBAAI,IAAY;AAErC,QAAM,UAAU,CAAC,IAAY,SAAmB;AAC9C,QAAI,CAAC,MAAM,IAAI,EAAE,EAAG,OAAM,IAAI,IAAI,EAAE,IAAI,KAAK,CAAC;AAAA,EAChD;AAEA,QAAM,UAAU,CAAC,MAAc,IAAY,SAAmB;AAC5D,QAAI,CAAC,QAAQ,CAAC,MAAM,SAAS,GAAI;AACjC,UAAM,MAAM,GAAG,IAAI,KAAS,EAAE,KAAS,IAAI;AAC3C,QAAI,aAAa,IAAI,GAAG,EAAG;AAC3B,iBAAa,IAAI,GAAG;AACpB,UAAM,KAAK,EAAE,MAAM,IAAI,KAAK,CAAC;AAAA,EAC/B;AAIA,aAAW,UAAU,UAAU;AAC7B,QAAI,CAAC,QAAQ,GAAI;AACjB,YAAQ,OAAO,IAAI,QAAQ;AAAA,EAC7B;AAUA,QAAM,gBAAgB,oBAAI,IAAY;AACtC,aAAW,UAAU,UAAU;AAC7B,QAAI,CAAC,QAAQ,GAAI;AAKjB,QAAI,OAAO,OAAO,cAAc,YAAY,OAAO,WAAW;AAC5D,UAAI,OAAO,cAAc,OAAO,GAAI,eAAc,IAAI,OAAO,SAAS;AAAA,IACxE;AACA,QAAI,MAAM,QAAQ,OAAO,UAAU,GAAG;AACpC,iBAAW,OAAO,OAAO,YAAY;AACnC,YAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,OAAO,IAAI;AACvD,wBAAc,IAAI,GAAG;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AACA,QAAI,OAAO,OAAO,YAAY,YAAY,OAAO,QAAQ,SAAS,GAAG;AACnE,qBAAe,YAAY;AAC3B,UAAI;AACJ,cAAQ,QAAQ,eAAe,KAAK,OAAO,OAAO,OAAO,MAAM;AAC7D,cAAM,OAAO,MAAM,CAAC;AACpB,YAAI,CAAC,KAAM;AACX,cAAM,QAAQ,oBAAoB,IAAI,EAAE;AACxC,YAAI,CAAC,MAAO;AACZ,cAAM,UAAU,SAAS,KAAK;AAC9B,YAAI,YAAY,OAAO,GAAI,eAAc,IAAI,OAAO;AAAA,MACtD;AAAA,IACF;AAAA,EACF;AAMA,aAAW,UAAU,UAAU;AAC7B,QAAI,QAAQ,GAAI,eAAc,OAAO,OAAO,EAAE;AAAA,EAChD;AAGA,aAAW,UAAU,UAAU;AAC7B,QAAI,CAAC,QAAQ,GAAI;AACjB,UAAM,OAAO,OAAO;AAepB,UAAM,kBAAkB,CAAC,OAAwB;AAC/C,YAAM,WAAW,MAAM,IAAI,EAAE;AAC7B,UAAI,aAAa,OAAW,QAAO,SAAS,SAAS;AACrD,UAAI,cAAc,IAAI,EAAE,EAAG,QAAO;AAClC,aAAO;AAAA,IACT;AAGA,QAAI,OAAO,OAAO,eAAe,YAAY,OAAO,YAAY;AAC9D,YAAM,KAAK,OAAO;AAClB,UAAI,gBAAgB,EAAE,GAAG;AACvB,YAAI,CAAC,MAAM,IAAI,EAAE,EAAG,SAAQ,IAAI,QAAQ;AACxC,gBAAQ,MAAM,IAAI,YAAY;AAAA,MAChC;AAAA,IACF;AAGA,QAAI,MAAM,QAAQ,OAAO,OAAO,GAAG;AACjC,iBAAW,UAAU,OAAO,SAAS;AACnC,YAAI,OAAO,WAAW,YAAY,CAAC,OAAQ;AAC3C,YAAI,CAAC,gBAAgB,MAAM,EAAG;AAC9B,YAAI,CAAC,MAAM,IAAI,MAAM,EAAG,SAAQ,QAAQ,QAAQ;AAChD,gBAAQ,MAAM,QAAQ,cAAc;AAAA,MACtC;AAAA,IACF;AAGA,QAAI,MAAM,QAAQ,OAAO,YAAY,GAAG;AACtC,iBAAW,OAAO,OAAO,cAAc;AACrC,YAAI,OAAO,QAAQ,YAAY,CAAC,IAAK;AACrC,cAAM,KAAK,wBAAwB,GAAG;AACtC,YAAI,CAAC,GAAI;AACT,YAAI,CAAC,gBAAgB,EAAE,EAAG;AAC1B,YAAI,CAAC,MAAM,IAAI,EAAE,EAAG,SAAQ,IAAI,QAAQ;AACxC,gBAAQ,MAAM,IAAI,cAAc;AAAA,MAClC;AAAA,IACF;AAOA,UAAM,YAAY,oBAAI,IAAY;AAClC,QAAI,OAAO,OAAO,cAAc,YAAY,OAAO,WAAW;AAC5D,gBAAU,IAAI,OAAO,SAAS;AAAA,IAChC;AACA,QAAI,MAAM,QAAQ,OAAO,UAAU,GAAG;AACpC,iBAAW,OAAO,OAAO,YAAY;AACnC,YAAI,OAAO,QAAQ,YAAY,IAAK,WAAU,IAAI,GAAG;AAAA,MACvD;AAAA,IACF;AACA,eAAW,OAAO,WAAW;AAC3B,YAAM,WAAW,MAAM,IAAI,GAAG;AAC9B,UAAI,aAAa,UAAa,SAAS,SAAS,SAAU;AAC1D,UAAI,CAAC,SAAU,SAAQ,KAAK,QAAQ;AACpC,cAAQ,MAAM,KAAK,UAAU;AAAA,IAC/B;AAIA,QAAI,OAAO,OAAO,YAAY,YAAY,OAAO,QAAQ,SAAS,GAAG;AAEnE,qBAAe,YAAY;AAC3B,UAAI;AACJ,cAAQ,QAAQ,eAAe,KAAK,OAAO,OAAO,OAAO,MAAM;AAC7D,cAAM,OAAO,MAAM,CAAC;AACpB,YAAI,CAAC,KAAM;AACX,cAAM,SAAS,oBAAoB,IAAI;AACvC,cAAM,QAAQ,OAAO;AACrB,YAAI,CAAC,MAAO;AACZ,cAAM,UAAU,SAAS,KAAK;AAC9B,cAAM,WAAW,MAAM,IAAI,OAAO;AAClC,YAAI,aAAa,UAAa,SAAS,SAAS,SAAU;AAC1D,YAAI,CAAC,SAAU,SAAQ,SAAS,QAAQ;AACxC,gBAAQ,MAAM,SAAS,aAAa;AAAA,MACtC;AAAA,IACF;AAAA,EACF;AAEA,SAAO,EAAE,OAAO,MAAM;AACxB;AAWO,SAAS,uBACd,UACA,UAAoC,CAAC,GACxB;AACb,QAAM,EAAE,OAAO,MAAM,IAAI,kBAAkB,UAAU,OAAO;AAC5D,SAAO,EAAE,OAAO,MAAM;AACxB;","names":[]}

package/dist/{chunk-OIT5QGG4.js → chunk-6AUUAZEX.js}

@@ -1,3 +1,13 @@
+import {
+  isDirectAnswerEligible
+} from "./chunk-Y4FHOFJ2.js";
+import {
+  throwIfAborted
+} from "./chunk-PVGDJXVK.js";
+import {
+  normalizeRecallTokens
+} from "./chunk-DT5TVLJE.js";
+
 // src/taxonomy/resolver.ts
 var DEFAULT_CATEGORY_ID = "facts";
 function resolveCategory(content, memoryCategory, taxonomy) {
@@ -74,7 +84,67 @@ function computeKeywordScore(contentLower, cat) {
   return score;
 }
 
+// src/direct-answer-wiring.ts
+async function tryDirectAnswer(input) {
+  const { query, namespace, config, sources, queryEntityRefs, abortSignal } = input;
+  const eligibilityConfig = {
+    enabled: config.recallDirectAnswerEnabled,
+    tokenOverlapFloor: config.recallDirectAnswerTokenOverlapFloor,
+    importanceFloor: config.recallDirectAnswerImportanceFloor,
+    ambiguityMargin: config.recallDirectAnswerAmbiguityMargin,
+    eligibleTaxonomyBuckets: config.recallDirectAnswerEligibleTaxonomyBuckets
+  };
+  if (!eligibilityConfig.enabled) {
+    return isDirectAnswerEligible({
+      query,
+      candidates: [],
+      config: eligibilityConfig,
+      queryEntityRefs
+    });
+  }
+  if (normalizeRecallTokens(query).length === 0) {
+    return isDirectAnswerEligible({
+      query,
+      candidates: [],
+      config: eligibilityConfig,
+      queryEntityRefs
+    });
+  }
+  throwIfAborted(abortSignal, "direct-answer wiring aborted");
+  const memories = await sources.listCandidateMemories({ namespace, abortSignal });
+  throwIfAborted(abortSignal, "direct-answer wiring aborted");
+  const candidates = [];
+  for (const memory of memories) {
+    throwIfAborted(abortSignal, "direct-answer wiring aborted");
+    const trustZone = await sources.trustZoneFor(memory.frontmatter.id);
+    throwIfAborted(abortSignal, "direct-answer wiring aborted");
+    if (trustZone !== "trusted") continue;
+    const decision = resolveCategory(
+      memory.content,
+      memory.frontmatter.category,
+      sources.taxonomy
+    );
+    const taxonomyBucket = decision.categoryId;
+    if (!eligibilityConfig.eligibleTaxonomyBuckets.includes(taxonomyBucket)) continue;
+    const importanceScore = sources.importanceFor(memory);
+    candidates.push({
+      memory,
+      trustZone,
+      taxonomyBucket,
+      importanceScore
+    });
+  }
+  throwIfAborted(abortSignal, "direct-answer wiring aborted");
+  return isDirectAnswerEligible({
+    query,
+    candidates,
+    config: eligibilityConfig,
+    queryEntityRefs
+  });
+}
+
 export {
-  resolveCategory
+  resolveCategory,
+  tryDirectAnswer
 };
-//# sourceMappingURL=chunk-OIT5QGG4.js.map
+//# sourceMappingURL=chunk-6AUUAZEX.js.map

package/dist/chunk-6AUUAZEX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/taxonomy/resolver.ts","../src/direct-answer-wiring.ts"],"sourcesContent":["/**\n * Resolver decision tree for the MECE taxonomy.\n *\n * Given extracted content and its MemoryCategory, determines which\n * taxonomy category the knowledge should be filed under.\n */\n\nimport type { MemoryCategory } from \"../types.js\";\nimport type { ResolverDecision, Taxonomy, TaxonomyCategory } from \"./types.js\";\n\nconst DEFAULT_CATEGORY_ID = \"facts\";\n\n/**\n * Resolve a piece of content to a taxonomy category.\n *\n * Algorithm:\n * 1. Find all taxonomy categories whose `memoryCategories` include\n *    the given `memoryCategory`.\n * 2. If exactly one match, return it with confidence 1.0.\n * 3. If multiple matches, pick the one with the lowest priority\n *    number (highest precedence). Apply keyword heuristics from\n *    filing rules as a secondary signal.\n * 4. If no match, fall back to the \"facts\" category (or first\n *    category if \"facts\" is absent) with low confidence.\n * 5. Always populate `alternatives` with other plausible categories.\n */\nexport function resolveCategory(\n  content: string,\n  memoryCategory: MemoryCategory,\n  taxonomy: Taxonomy,\n): ResolverDecision {\n  const contentLower = content.toLowerCase();\n\n  // Step 1: find matching categories\n  const matches = taxonomy.categories.filter((cat) =>\n    cat.memoryCategories.includes(memoryCategory),\n  );\n\n  if (matches.length === 0) {\n    // No taxonomy category accepts this MemoryCategory — fall back\n    const fallback =\n      taxonomy.categories.find((c) => c.id === DEFAULT_CATEGORY_ID) ??\n      taxonomy.categories[0];\n    if (!fallback) {\n      return {\n        categoryId: DEFAULT_CATEGORY_ID,\n        confidence: 0,\n        reason: \"Taxonomy is empty; using default category\",\n        alternatives: [],\n      };\n    }\n    const alternatives = taxonomy.categories\n      .filter((c) => c.id !== fallback.id)\n      .map((c) => ({\n        categoryId: c.id,\n        reason: c.description,\n      }));\n    return {\n      categoryId: fallback.id,\n      confidence: 0.3,\n      reason: `No taxonomy category maps to MemoryCategory \"${memoryCategory}\"; falling back to \"${fallback.name}\"`,\n      alternatives,\n    };\n  }\n\n  if (matches.length === 1) {\n    const match = matches[0]!;\n    const alternatives = taxonomy.categories\n      .filter((c) => c.id !== match.id)\n      .map((c) => ({\n        categoryId: c.id,\n        reason: c.description,\n      }));\n    return {\n      categoryId: match.id,\n      confidence: 1.0,\n      reason: `Unique match: MemoryCategory \"${memoryCategory}\" maps to \"${match.name}\"`,\n      alternatives,\n    };\n  }\n\n  // Multiple matches — use filing rule keyword heuristics + priority\n  const scored = matches.map((cat) => ({\n    cat,\n    keywordScore: computeKeywordScore(contentLower, cat),\n  }));\n\n  // Sort by keyword score descending, then priority ascending (lower wins)\n  scored.sort((a, b) => {\n    if (b.keywordScore !== a.keywordScore) return b.keywordScore - a.keywordScore;\n    return a.cat.priority - b.cat.priority;\n  });\n\n  const best = scored[0]!;\n  const runnerUp = scored[1];\n\n  // Confidence is higher when keyword match clearly differentiates\n  const confidence =\n    best.keywordScore > 0 && (!runnerUp || best.keywordScore > runnerUp.keywordScore)\n      ? 0.9\n      : 0.7;\n\n  const alternatives = taxonomy.categories\n    .filter((c) => c.id !== best.cat.id)\n    .map((c) => ({\n      categoryId: c.id,\n      reason: c.description,\n    }));\n\n  const reason =\n    best.keywordScore > 0\n      ? `Filing rules for \"${best.cat.name}\" matched content keywords (priority ${best.cat.priority})`\n      : `Priority tie-break: \"${best.cat.name}\" has lowest priority number (${best.cat.priority})`;\n\n  return {\n    categoryId: best.cat.id,\n    confidence,\n    reason,\n    alternatives,\n  };\n}\n\n/**\n * Compute a simple keyword overlap score between content and\n * a category's filing rules + description.\n */\nfunction computeKeywordScore(contentLower: string, cat: TaxonomyCategory): number {\n  let score = 0;\n  const ruleText = [...cat.filingRules, cat.description]\n    .join(\" \")\n    .toLowerCase();\n\n  // Extract meaningful words (3+ chars) from the rule text\n  const keywords = ruleText\n    .split(/[^a-z0-9]+/)\n    .filter((w) => w.length >= 3);\n\n  for (const kw of keywords) {\n    if (contentLower.includes(kw)) {\n      score += 1;\n    }\n  }\n  return score;\n}\n","/**\n * Direct-answer wiring (issue #518 slice 3).\n *\n * Binds the pure eligibility decision (`direct-answer.ts`) to the data\n * sources needed to build candidates: storage, trust-zones, taxonomy,\n * and importance scoring.  Kept as a separate module so that:\n *\n * - The eligibility layer stays pure and unit-testable without stores.\n * - Each caller injects its own source accessors.  The orchestrator\n *   binding is a follow-on slice; tests here use mock sources.\n * - The wiring is safe to ship alone — nothing calls `tryDirectAnswer`\n *   yet, so enabling this module's presence does not change recall\n *   behavior.  The next slice adds exactly one call site before QMD.\n *\n * Short-circuit contract:\n *\n * - When `config.recallDirectAnswerEnabled === false`, the function\n *   returns the eligibility verdict with reason `\"disabled\"` without\n *   touching any source accessor.  This is the documented default.\n * - When enabled, the wiring cheaply drops non-trusted-zone memories\n *   and ineligible taxonomy buckets before computing importance, so\n *   the eligibility module sees a pre-filtered candidate set.  The\n *   eligibility module still performs the same checks itself — this\n *   module is purely an I/O and prefiltering layer.\n */\n\nimport type { MemoryFile, PluginConfig } from \"./types.js\";\nimport type { TrustZoneName } from \"./trust-zones.js\";\nimport type { Taxonomy } from \"./taxonomy/types.js\";\nimport { resolveCategory } from \"./taxonomy/resolver.js\";\nimport { normalizeRecallTokens } from \"./recall-tokenization.js\";\nimport { throwIfAborted } from \"./abort-error.js\";\nimport {\n  isDirectAnswerEligible,\n  type DirectAnswerCandidate,\n  type DirectAnswerConfig,\n  type DirectAnswerResult,\n} from \"./direct-answer.js\";\n\n/**\n * Caller-provided accessors for candidate sourcing.  Decouples the\n * wiring from any specific storage / trust-zone / importance backend.\n */\nexport interface DirectAnswerSources {\n  /**\n   * List memories eligible to be considered for direct-answer.\n   * Callers are expected to return only active, non-superseded memories\n   * in the requested namespace; the wiring will cheaply re-filter on\n   * trust zone and taxonomy bucket and hand the rest to the eligibility\n   * module, which applies the full gate ladder.\n   */\n  listCandidateMemories(options: {\n    namespace: string;\n    abortSignal?: AbortSignal;\n  }): Promise<MemoryFile[]>;\n  /**\n   * Resolve the trust-zone record for a memory.  Returns `null` when\n   * the memory has no trust-zone record (treated as not trusted).\n   */\n  trustZoneFor(memoryId: string): Promise<TrustZoneName | null>;\n  /**\n   * Resolve a calibrated importance score in [0, 1] for a memory.\n   */\n  importanceFor(memory: MemoryFile): number;\n  /**\n   * Taxonomy used to classify memories into direct-answer buckets.\n   */\n  taxonomy: Taxonomy;\n}\n\nexport interface DirectAnswerWiringInput {\n  query: string;\n  namespace: string;\n  config: Pick<\n    PluginConfig,\n    | \"recallDirectAnswerEnabled\"\n    | \"recallDirectAnswerTokenOverlapFloor\"\n    | \"recallDirectAnswerImportanceFloor\"\n    | \"recallDirectAnswerAmbiguityMargin\"\n    | \"recallDirectAnswerEligibleTaxonomyBuckets\"\n  >;\n  sources: DirectAnswerSources;\n  queryEntityRefs?: string[];\n  abortSignal?: AbortSignal;\n}\n\n/**\n * Attempt direct-answer resolution.  Returns the eligibility verdict\n * produced by `isDirectAnswerEligible` with candidates materialized\n * from the caller-supplied sources.\n */\nexport async function tryDirectAnswer(\n  input: DirectAnswerWiringInput,\n): Promise<DirectAnswerResult> {\n  const { query, namespace, config, sources, queryEntityRefs, abortSignal } = input;\n\n  const eligibilityConfig: DirectAnswerConfig = {\n    enabled: config.recallDirectAnswerEnabled,\n    tokenOverlapFloor: config.recallDirectAnswerTokenOverlapFloor,\n    importanceFloor: config.recallDirectAnswerImportanceFloor,\n    ambiguityMargin: config.recallDirectAnswerAmbiguityMargin,\n    eligibleTaxonomyBuckets: config.recallDirectAnswerEligibleTaxonomyBuckets,\n  };\n\n  // Short-circuit disabled case before touching any I/O.\n  if (!eligibilityConfig.enabled) {\n    return isDirectAnswerEligible({\n      query,\n      candidates: [],\n      config: eligibilityConfig,\n      queryEntityRefs,\n    });\n  }\n\n  // Short-circuit empty-query case before any I/O.  isDirectAnswerEligible\n  // deterministically returns reason \"empty-query\" when the query\n  // normalizes to zero searchable tokens; there's no point materializing\n  // candidates just to reach the same verdict, and doing so would\n  // surface avoidable upstream errors for requests that should exit\n  // immediately.\n  if (normalizeRecallTokens(query).length === 0) {\n    return isDirectAnswerEligible({\n      query,\n      candidates: [],\n      config: eligibilityConfig,\n      queryEntityRefs,\n    });\n  }\n\n  throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n  const memories = await sources.listCandidateMemories({ namespace, abortSignal });\n  throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n  const candidates: DirectAnswerCandidate[] = [];\n\n  for (const memory of memories) {\n    // Throw rather than returning a partial verdict — a mid-loop abort\n    // that left competing candidates unprocessed could otherwise surface\n    // a spurious \"eligible\" result that the ambiguity gate never got a\n    // chance to reject.  The check repeats after every await so an\n    // abort that lands during the in-flight I/O on the final memory\n    // (after which no further iteration would exist) still stops us.\n    throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n\n    const trustZone = await sources.trustZoneFor(memory.frontmatter.id);\n    throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n\n    // Cheap pre-filter: non-trusted memories can't qualify, so skip\n    // taxonomy and importance resolution for them.\n    if (trustZone !== \"trusted\") continue;\n\n    const decision = resolveCategory(\n      memory.content,\n      memory.frontmatter.category,\n      sources.taxonomy,\n    );\n    const taxonomyBucket = decision.categoryId;\n    if (!eligibilityConfig.eligibleTaxonomyBuckets.includes(taxonomyBucket)) continue;\n\n    const importanceScore = sources.importanceFor(memory);\n\n    candidates.push({\n      memory,\n      trustZone,\n      taxonomyBucket,\n      importanceScore,\n    });\n  }\n\n  // Final check — if abort landed during the trust-zone await for the\n  // last memory, the loop condition no longer fires.  Guard before we\n  // hand candidates to the eligibility gate.\n  throwIfAborted(abortSignal, \"direct-answer wiring aborted\");\n\n  return isDirectAnswerEligible({\n    query,\n    candidates,\n    config: eligibilityConfig,\n    queryEntityRefs,\n  });\n}\n"],"mappings":"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","names":["alternatives"]}