@remnic/core 1.0.3 → 1.1.1

package/dist/chunk-54V4BZWP.js

@@ -0,0 +1,139 @@
+// src/reasoning-trace-types.ts
+function normalizeReasoningTraceSteps(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (let i = 0; i < raw.length; i++) {
+    const s = raw[i];
+    let description = "";
+    let orderRaw;
+    if (typeof s === "string") {
+      description = s.trim();
+    } else if (s && typeof s === "object") {
+      const o = s;
+      if (typeof o.description === "string") description = o.description.trim();
+      else if (typeof o.intent === "string") description = o.intent.trim();
+      else if (typeof o.step === "string") description = o.step.trim();
+      else if (typeof o.text === "string") description = o.text.trim();
+      orderRaw = o.order;
+    }
+    if (!description) continue;
+    const order = typeof orderRaw === "number" && Number.isFinite(orderRaw) ? Math.max(1, Math.floor(orderRaw)) : i + 1;
+    out.push({ order, description });
+  }
+  return out;
+}
+function normalizeReasoningTrace(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const o = raw;
+  const steps = normalizeReasoningTraceSteps(o.steps);
+  const finalAnswer = typeof o.finalAnswer === "string" ? o.finalAnswer.trim() : typeof o.final_answer === "string" ? o.final_answer.trim() : "";
+  if (steps.length < 2 || finalAnswer.length === 0) return null;
+  const observedRaw = typeof o.observedOutcome === "string" ? o.observedOutcome : typeof o.observed_outcome === "string" ? o.observed_outcome : void 0;
+  const observedOutcome = observedRaw?.trim();
+  return {
+    steps,
+    finalAnswer,
+    observedOutcome: observedOutcome && observedOutcome.length > 0 ? observedOutcome : void 0
+  };
+}
+function buildReasoningTraceMarkdownBody(trace) {
+  const sorted = [...trace.steps].sort((a, b) => a.order - b.order);
+  const lines = [];
+  for (const step of sorted) {
+    const n = Number.isFinite(step.order) ? Math.max(1, Math.floor(step.order)) : 1;
+    lines.push(`## Step ${n}`);
+    lines.push("");
+    lines.push(step.description.trim());
+    lines.push("");
+  }
+  lines.push("## Final Answer");
+  lines.push("");
+  lines.push(trace.finalAnswer.trim());
+  lines.push("");
+  if (trace.observedOutcome && trace.observedOutcome.trim().length > 0) {
+    lines.push("## Observed Outcome");
+    lines.push("");
+    lines.push(trace.observedOutcome.trim());
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+function buildReasoningTracePersistBody(title, trace) {
+  const head = typeof title === "string" ? title.trim() : "";
+  const body = buildReasoningTraceMarkdownBody(trace);
+  if (!head) return body;
+  return `${head}
+
+${body}`.trimEnd() + "\n";
+}
+var STEP_HEADER_RE = /^##\s+Step\s+(\d+)\s*$/im;
+var FINAL_HEADER_RE = /^##\s+Final Answer\s*$/im;
+var OBSERVED_HEADER_RE = /^##\s+Observed Outcome\s*$/im;
+function parseReasoningTraceFromBody(content) {
+  const text = content.replace(/\r\n/g, "\n").trim();
+  if (!text) return null;
+  const stepMatches = [...text.matchAll(new RegExp(STEP_HEADER_RE.source, "gim"))];
+  const finalMatch = FINAL_HEADER_RE.exec(text);
+  if (stepMatches.length === 0 || !finalMatch) return null;
+  const observedMatch = OBSERVED_HEADER_RE.exec(text);
+  const steps = [];
+  for (let i = 0; i < stepMatches.length; i++) {
+    const m = stepMatches[i];
+    const order = Number.parseInt(m[1] ?? String(i + 1), 10);
+    const start = (m.index ?? 0) + m[0].length;
+    const nextStepStart = i + 1 < stepMatches.length ? stepMatches[i + 1].index ?? text.length : text.length;
+    const end = Math.min(nextStepStart, finalMatch.index ?? text.length);
+    const block = text.slice(start, end).trim();
+    const description = block.split("\n").map((l) => l.trim()).filter((l) => l.length > 0).join(" ");
+    if (!description) continue;
+    steps.push({
+      order: Number.isFinite(order) ? order : i + 1,
+      description
+    });
+  }
+  if (steps.length < 2) return null;
+  const finalStart = (finalMatch.index ?? 0) + finalMatch[0].length;
+  const finalEnd = observedMatch?.index ?? text.length;
+  const finalAnswer = text.slice(finalStart, finalEnd).split("\n").map((l) => l.trim()).filter((l) => l.length > 0).join(" ").trim();
+  if (!finalAnswer) return null;
+  let observedOutcome;
+  if (observedMatch) {
+    const obsStart = (observedMatch.index ?? 0) + observedMatch[0].length;
+    const raw = text.slice(obsStart).split("\n").map((l) => l.trim()).filter((l) => l.length > 0).join(" ").trim();
+    if (raw) observedOutcome = raw;
+  }
+  return { steps, finalAnswer, observedOutcome };
+}
+function looksLikeReasoningTrace(message) {
+  if (typeof message !== "string") return false;
+  const text = message.trim();
+  if (text.length < 80) return false;
+  const stepMarkerRes = [
+    /\bstep\s+\d+\s*[:.\-]/i,
+    /^\s*\d+[.)]\s+\S/,
+    /^\s*(first|second|third|fourth|finally|then|next)\b[,:]/i
+  ];
+  const lines = text.split(/\r?\n/);
+  let stepCount = 0;
+  for (const line of lines) {
+    if (stepMarkerRes.some((re) => re.test(line))) {
+      stepCount += 1;
+      if (stepCount >= 2) break;
+    }
+  }
+  if (stepCount < 2) return false;
+  const wordFinalMarker = /\b(final answer|so the answer|therefore|conclusion|in the end|ended up|picked|chose)\b/i;
+  const colonMarker = /\b(answer:|result:)/i;
+  if (!wordFinalMarker.test(text) && !colonMarker.test(text)) return false;
+  return true;
+}
+
+export {
+  normalizeReasoningTraceSteps,
+  normalizeReasoningTrace,
+  buildReasoningTraceMarkdownBody,
+  buildReasoningTracePersistBody,
+  parseReasoningTraceFromBody,
+  looksLikeReasoningTrace
+};
+//# sourceMappingURL=chunk-54V4BZWP.js.map

package/dist/chunk-54V4BZWP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/reasoning-trace-types.ts"],"sourcesContent":["/**\n * Reasoning-trace memory structural types (issue #564).\n *\n * Captures stored solution chains / chain-of-thought the user walked through\n * to solve a problem. Traces have an ordered list of steps, a final answer,\n * and an optional observed outcome.\n */\n\nexport interface ReasoningTraceStep {\n  /** 1-based ordinal within the trace. */\n  order: number;\n  /** Human-readable description of what happened at this step. */\n  description: string;\n}\n\nexport interface ReasoningTraceStructuredData {\n  steps: ReasoningTraceStep[];\n  finalAnswer: string;\n  /** Optional confirmation of how the answer played out in practice. */\n  observedOutcome?: string;\n}\n\n/** Normalize loose extraction JSON into ReasoningTraceStep records. */\nexport function normalizeReasoningTraceSteps(raw: unknown): ReasoningTraceStep[] {\n  if (!Array.isArray(raw)) return [];\n  const out: ReasoningTraceStep[] = [];\n  for (let i = 0; i < raw.length; i++) {\n    const s = raw[i];\n    let description = \"\";\n    let orderRaw: unknown;\n    if (typeof s === \"string\") {\n      description = s.trim();\n    } else if (s && typeof s === \"object\") {\n      const o = s as Record<string, unknown>;\n      if (typeof o.description === \"string\") description = o.description.trim();\n      else if (typeof o.intent === \"string\") description = o.intent.trim();\n      else if (typeof o.step === \"string\") description = o.step.trim();\n      else if (typeof o.text === \"string\") description = o.text.trim();\n      orderRaw = o.order;\n    }\n    if (!description) continue;\n    const order =\n      typeof orderRaw === \"number\" && Number.isFinite(orderRaw)\n        ? Math.max(1, Math.floor(orderRaw))\n        : i + 1;\n    out.push({ order, description });\n  }\n  return out;\n}\n\n/**\n * Normalize a loose reasoningTrace object (e.g. coming back from the LLM) to\n * a strict ReasoningTraceStructuredData shape. Returns null when the data is\n * clearly incomplete (no steps or no final answer).\n */\nexport function normalizeReasoningTrace(raw: unknown): ReasoningTraceStructuredData | null {\n  if (!raw || typeof raw !== \"object\" || Array.isArray(raw)) return null;\n  const o = raw as Record<string, unknown>;\n  const steps = normalizeReasoningTraceSteps(o.steps);\n  const finalAnswer =\n    typeof o.finalAnswer === \"string\"\n      ? o.finalAnswer.trim()\n      : typeof o.final_answer === \"string\"\n      ? (o.final_answer as string).trim()\n      : \"\";\n  // Prompts describe reasoning_trace as requiring ≥2 ordered steps + a final\n  // answer. Rejecting one-step payloads here keeps the category semantically\n  // distinct from ordinary `decision` facts and prevents malformed traces\n  // from sneaking through loose local/direct extraction JSON.\n  if (steps.length < 2 || finalAnswer.length === 0) return null;\n  const observedRaw =\n    typeof o.observedOutcome === \"string\"\n      ? o.observedOutcome\n      : typeof o.observed_outcome === \"string\"\n      ? (o.observed_outcome as string)\n      : undefined;\n  const observedOutcome = observedRaw?.trim();\n  return {\n    steps,\n    finalAnswer,\n    observedOutcome: observedOutcome && observedOutcome.length > 0 ? observedOutcome : undefined,\n  };\n}\n\n/**\n * Serialize a normalized reasoning trace into a human-readable markdown body.\n * Output shape mirrors the procedure body format: ## Step N sections followed\n * by final answer and optional observed outcome.\n */\nexport function buildReasoningTraceMarkdownBody(trace: ReasoningTraceStructuredData): string {\n  const sorted = [...trace.steps].sort((a, b) => a.order - b.order);\n  const lines: string[] = [];\n  for (const step of sorted) {\n    const n = Number.isFinite(step.order) ? Math.max(1, Math.floor(step.order)) : 1;\n    lines.push(`## Step ${n}`);\n    lines.push(\"\");\n    lines.push(step.description.trim());\n    lines.push(\"\");\n  }\n  lines.push(\"## Final Answer\");\n  lines.push(\"\");\n  lines.push(trace.finalAnswer.trim());\n  lines.push(\"\");\n  if (trace.observedOutcome && trace.observedOutcome.trim().length > 0) {\n    lines.push(\"## Observed Outcome\");\n    lines.push(\"\");\n    lines.push(trace.observedOutcome.trim());\n    lines.push(\"\");\n  }\n  return lines.join(\"\\n\").trimEnd() + \"\\n\";\n}\n\n/**\n * Combine a short title with the structured trace body. The title becomes the\n * one-line content of the stored memory, and the full body is appended below.\n */\nexport function buildReasoningTracePersistBody(\n  title: string,\n  trace: ReasoningTraceStructuredData,\n): string {\n  const head = typeof title === \"string\" ? title.trim() : \"\";\n  const body = buildReasoningTraceMarkdownBody(trace);\n  if (!head) return body;\n  return `${head}\\n\\n${body}`.trimEnd() + \"\\n\";\n}\n\nconst STEP_HEADER_RE = /^##\\s+Step\\s+(\\d+)\\s*$/im;\nconst FINAL_HEADER_RE = /^##\\s+Final Answer\\s*$/im;\nconst OBSERVED_HEADER_RE = /^##\\s+Observed Outcome\\s*$/im;\n\n/**\n * Best-effort parse of a reasoning-trace markdown body back into structured\n * data. Returns null when the document does not look like a reasoning trace.\n */\nexport function parseReasoningTraceFromBody(content: string): ReasoningTraceStructuredData | null {\n  const text = content.replace(/\\r\\n/g, \"\\n\").trim();\n  if (!text) return null;\n  const stepMatches = [...text.matchAll(new RegExp(STEP_HEADER_RE.source, \"gim\"))];\n  const finalMatch = FINAL_HEADER_RE.exec(text);\n  if (stepMatches.length === 0 || !finalMatch) return null;\n\n  const observedMatch = OBSERVED_HEADER_RE.exec(text);\n\n  const steps: ReasoningTraceStep[] = [];\n  for (let i = 0; i < stepMatches.length; i++) {\n    const m = stepMatches[i];\n    const order = Number.parseInt(m[1] ?? String(i + 1), 10);\n    const start = (m.index ?? 0) + m[0].length;\n    const nextStepStart =\n      i + 1 < stepMatches.length ? stepMatches[i + 1].index ?? text.length : text.length;\n    const end = Math.min(nextStepStart, finalMatch.index ?? text.length);\n    const block = text.slice(start, end).trim();\n    const description = block.split(\"\\n\").map((l) => l.trim()).filter((l) => l.length > 0).join(\" \");\n    if (!description) continue;\n    steps.push({\n      order: Number.isFinite(order) ? order : i + 1,\n      description,\n    });\n  }\n\n  // Honor the >=2 ordered-steps invariant enforced everywhere else in the\n  // pipeline (prompts, normalizer, schema). A single-step manually-edited\n  // or corrupt file should not round-trip back in as a reasoning_trace.\n  if (steps.length < 2) return null;\n\n  const finalStart = (finalMatch.index ?? 0) + finalMatch[0].length;\n  const finalEnd = observedMatch?.index ?? text.length;\n  const finalAnswer = text\n    .slice(finalStart, finalEnd)\n    .split(\"\\n\")\n    .map((l) => l.trim())\n    .filter((l) => l.length > 0)\n    .join(\" \")\n    .trim();\n  if (!finalAnswer) return null;\n\n  let observedOutcome: string | undefined;\n  if (observedMatch) {\n    const obsStart = (observedMatch.index ?? 0) + observedMatch[0].length;\n    const raw = text\n      .slice(obsStart)\n      .split(\"\\n\")\n      .map((l) => l.trim())\n      .filter((l) => l.length > 0)\n      .join(\" \")\n      .trim();\n    if (raw) observedOutcome = raw;\n  }\n\n  return { steps, finalAnswer, observedOutcome };\n}\n\n/**\n * Heuristic detector for whether a user message contains a chain-of-thought /\n * solution trace that should be extracted. This is intentionally conservative:\n * we require at least two explicitly-ordered steps and some form of final\n * answer / resolution. Used by the extraction pipeline to decide whether to\n * even consider emitting a reasoning_trace fact, so false positives are more\n * costly than false negatives.\n */\nexport function looksLikeReasoningTrace(message: string): boolean {\n  if (typeof message !== \"string\") return false;\n  const text = message.trim();\n  if (text.length < 80) return false;\n\n  // Count lines that carry at least one step marker, not the total number of\n  // marker matches. Summing across multiple regexes can let a single line\n  // contribute two \"steps\" (e.g. \"Step 1: First,…\" matches both patterns),\n  // which weakens the \"false positives > false negatives\" bias. Per-line\n  // counting keeps the gate symmetric with real step structure.\n  const stepMarkerRes = [\n    /\\bstep\\s+\\d+\\s*[:.\\-]/i,\n    /^\\s*\\d+[.)]\\s+\\S/,\n    /^\\s*(first|second|third|fourth|finally|then|next)\\b[,:]/i,\n  ];\n  const lines = text.split(/\\r?\\n/);\n  let stepCount = 0;\n  for (const line of lines) {\n    if (stepMarkerRes.some((re) => re.test(line))) {\n      stepCount += 1;\n      if (stepCount >= 2) break;\n    }\n  }\n  if (stepCount < 2) return false;\n\n  // Final-answer / resolution marker. Split into two checks so the trailing\n  // `\\b` on the word-final alternatives doesn't accidentally require a word\n  // character after `answer:` / `result:` (both end in a non-word `:`).\n  const wordFinalMarker =\n    /\\b(final answer|so the answer|therefore|conclusion|in the end|ended up|picked|chose)\\b/i;\n  const colonMarker = /\\b(answer:|result:)/i;\n  if (!wordFinalMarker.test(text) && !colonMarker.test(text)) return false;\n\n  return true;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-5JRF2PZA.js

@@ -0,0 +1,67 @@
+import {
+  cosineSimilarity
+} from "./chunk-KVE7R4CG.js";
+
+// src/buffer-surprise.ts
+var DEFAULT_SURPRISE_K = 5;
+async function computeSurprise(turn, recentMemories, options) {
+  if (typeof turn !== "string") {
+    throw new TypeError("computeSurprise: `turn` must be a string");
+  }
+  if (!options || typeof options.embedFn !== "function") {
+    throw new TypeError(
+      "computeSurprise: `options.embedFn` is required and must be a function"
+    );
+  }
+  const candidates = Array.isArray(recentMemories) ? recentMemories : [];
+  if (candidates.length === 0) return 1;
+  const kRaw = typeof options.k === "number" ? options.k : DEFAULT_SURPRISE_K;
+  const kClamped = clampK(kRaw, candidates.length);
+  const turnEmbedding = await options.embedFn(turn);
+  const candidateEmbeddings = await Promise.all(
+    candidates.map((c) => options.embedFn(c.content))
+  );
+  const sims = [];
+  for (let i = 0; i < candidates.length; i += 1) {
+    const candEmbedding = candidateEmbeddings[i] ?? [];
+    sims.push(safeCosine(turnEmbedding, candEmbedding));
+  }
+  sims.sort((a, b) => b - a);
+  const top = sims.slice(0, kClamped);
+  if (top.length === 0) {
+    return 1;
+  }
+  let sum = 0;
+  for (const s of top) sum += s;
+  const nearestSim = sum / top.length;
+  const surprise = 1 - nearestSim;
+  if (!Number.isFinite(surprise)) return 1;
+  if (surprise < 0) return 0;
+  if (surprise > 1) return 1;
+  return surprise;
+}
+function clampK(k, ceiling) {
+  if (!Number.isFinite(k)) {
+    return Math.min(DEFAULT_SURPRISE_K, Math.max(1, ceiling));
+  }
+  const floored = Math.floor(k);
+  if (floored < 1) return 1;
+  if (floored > ceiling) return ceiling;
+  return floored;
+}
+function safeCosine(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return 0;
+  if (a.length === 0 || b.length === 0) return 0;
+  if (a.length !== b.length) return 0;
+  const raw = cosineSimilarity(a, b);
+  if (!Number.isFinite(raw)) return 0;
+  if (raw < 0) return 0;
+  if (raw > 1) return 1;
+  return raw;
+}
+
+export {
+  DEFAULT_SURPRISE_K,
+  computeSurprise
+};
+//# sourceMappingURL=chunk-5JRF2PZA.js.map

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