@remnic/core 1.0.2 → 1.1.0

package/dist/{chunk-ZKYI7UVO.js → chunk-JR4ZC3G4.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-Z5LAYHGJ.js";
 import {
   log
-} from "./chunk-KWBU5S5U.js";
+} from "./chunk-2ODBA7MQ.js";
 
 // src/session-observer-state.ts
 import path from "path";
@@ -273,4 +273,4 @@ export {
   normalizeObserverBands,
   SessionObserverState
 };
-//# sourceMappingURL=chunk-ZKYI7UVO.js.map
+//# sourceMappingURL=chunk-JR4ZC3G4.js.map

package/dist/{chunk-UCYSTFZR.js → chunk-JRNQ3RNA.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./chunk-KWBU5S5U.js";
+} from "./chunk-2ODBA7MQ.js";
 
 // src/threading.ts
 import { readdir, readFile, writeFile, mkdir } from "fs/promises";
@@ -281,4 +281,4 @@ var ThreadingManager = class {
 export {
   ThreadingManager
 };
-//# sourceMappingURL=chunk-UCYSTFZR.js.map
+//# sourceMappingURL=chunk-JRNQ3RNA.js.map

package/dist/{chunk-GPGBSNKM.js → chunk-K4FLSOR5.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-V3RXWQIE.js";
 import {
   log
-} from "./chunk-KWBU5S5U.js";
+} from "./chunk-2ODBA7MQ.js";
 
 // src/retrieval-agents.ts
 import path from "path";
@@ -377,4 +377,4 @@ export {
   augmentWithDirectAndTemporal,
   parallelRetrieval
 };
-//# sourceMappingURL=chunk-GPGBSNKM.js.map
+//# sourceMappingURL=chunk-K4FLSOR5.js.map

package/dist/chunk-KVE7R4CG.js

@@ -0,0 +1,320 @@
+import {
+  chunkContent
+} from "./chunk-4WMCPJWX.js";
+
+// src/semantic-chunking.ts
+var DEFAULT_SEMANTIC_CHUNKING_CONFIG = {
+  targetTokens: 200,
+  minTokens: 100,
+  maxTokens: 400,
+  smoothingWindowSize: 3,
+  boundaryThresholdStdDevs: 1,
+  embeddingBatchSize: 32,
+  fallbackToRecursive: true
+};
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(
+      `cosineSimilarity: vector length mismatch (${a.length} vs ${b.length})`
+    );
+  }
+  if (a.length === 0) return 0;
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(magA) * Math.sqrt(magB);
+  if (denom === 0) return 0;
+  return dot / denom;
+}
+function mean(series) {
+  if (series.length === 0) return 0;
+  let sum = 0;
+  for (const v of series) sum += v;
+  return sum / series.length;
+}
+function stddev(series) {
+  if (series.length === 0) return 0;
+  const m = mean(series);
+  let sumSq = 0;
+  for (const v of series) {
+    const d = v - m;
+    sumSq += d * d;
+  }
+  return Math.sqrt(sumSq / series.length);
+}
+function movingAverage(series, windowSize) {
+  if (series.length === 0) return [];
+  if (windowSize < 1) windowSize = 1;
+  if (windowSize % 2 === 0) windowSize = windowSize + 1;
+  const halfW = Math.floor(windowSize / 2);
+  const result = new Array(series.length);
+  for (let i = 0; i < series.length; i++) {
+    const lo = Math.max(0, i - halfW);
+    const hi = Math.min(series.length - 1, i + halfW);
+    let sum = 0;
+    for (let j = lo; j <= hi; j++) sum += series[j];
+    result[i] = sum / (hi - lo + 1);
+  }
+  return result;
+}
+function findLocalMinima(series, threshold) {
+  if (series.length <= 2) return [];
+  const minima = [];
+  for (let i = 1; i < series.length - 1; i++) {
+    if (series[i] < series[i - 1] && series[i] < series[i + 1] && series[i] < threshold) {
+      minima.push(i);
+    }
+  }
+  return minima;
+}
+function splitSentences(text) {
+  const sentences = [];
+  const sentenceRegex = /[^.!?]*[.!?]+(?:\s+|$)/g;
+  let match;
+  let lastIndex = 0;
+  while ((match = sentenceRegex.exec(text)) !== null) {
+    sentences.push(match[0].trim());
+    lastIndex = sentenceRegex.lastIndex;
+  }
+  if (lastIndex < text.length) {
+    const remaining = text.slice(lastIndex).trim();
+    if (remaining) {
+      sentences.push(remaining);
+    }
+  }
+  return sentences.filter((s) => s.length > 0);
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+async function batchEmbed(sentences, embedFn, batchSize) {
+  const allEmbeddings = [];
+  for (let i = 0; i < sentences.length; i += batchSize) {
+    const batch = sentences.slice(i, i + batchSize);
+    const batchResult = await embedFn(batch);
+    for (const vec of batchResult) {
+      allEmbeddings.push(vec);
+    }
+  }
+  return allEmbeddings;
+}
+function buildSegments(sentences, boundaries) {
+  const sorted = [...boundaries].sort((a, b) => a - b);
+  const segments = [];
+  let start = 0;
+  for (const b of sorted) {
+    const splitPoint = b + 1;
+    if (splitPoint > start && splitPoint <= sentences.length) {
+      segments.push(sentences.slice(start, splitPoint));
+      start = splitPoint;
+    }
+  }
+  if (start < sentences.length) {
+    segments.push(sentences.slice(start));
+  }
+  return segments;
+}
+function mergeShortSegments(segments, minTokens) {
+  if (segments.length <= 1) return segments;
+  const merged = [];
+  let buffer = [];
+  for (let i = 0; i < segments.length; i++) {
+    buffer = [...buffer, ...segments[i]];
+    const tokenCount = estimateTokens(buffer.join(" "));
+    if (tokenCount >= minTokens || i === segments.length - 1) {
+      merged.push(buffer);
+      buffer = [];
+    }
+  }
+  if (buffer.length > 0) {
+    if (merged.length > 0) {
+      merged[merged.length - 1] = [...merged[merged.length - 1], ...buffer];
+    } else {
+      merged.push(buffer);
+    }
+  }
+  return merged;
+}
+function splitLongSegment(segment, maxTokens, targetTokens) {
+  const text = segment.join(" ");
+  const cappedTarget = Math.min(targetTokens, maxTokens);
+  const result = chunkContent(text, {
+    targetTokens: cappedTarget,
+    minTokens: Math.min(cappedTarget, maxTokens),
+    overlapSentences: 0
+  });
+  return result.chunks.map((c) => ({
+    content: c.content,
+    index: c.index,
+    tokenCount: c.tokenCount,
+    boundaryScore: 0
+  }));
+}
+async function semanticChunkContent(content, embedFn, config) {
+  const cfg = {
+    ...DEFAULT_SEMANTIC_CHUNKING_CONFIG,
+    ...config
+  };
+  const batchSize = Math.max(1, cfg.embeddingBatchSize);
+  if (!content || content.trim().length === 0) {
+    return {
+      chunked: false,
+      chunks: [],
+      boundaries: [],
+      method: "semantic"
+    };
+  }
+  const sentences = splitSentences(content);
+  if (sentences.length <= 1) {
+    const tokenCount = estimateTokens(content);
+    return {
+      chunked: false,
+      chunks: [
+        {
+          content: content.trim(),
+          index: 0,
+          tokenCount,
+          boundaryScore: 1
+        }
+      ],
+      boundaries: [],
+      method: "semantic"
+    };
+  }
+  const totalTokens = estimateTokens(content);
+  if (totalTokens <= cfg.minTokens) {
+    return {
+      chunked: false,
+      chunks: [
+        {
+          content: content.trim(),
+          index: 0,
+          tokenCount: totalTokens,
+          boundaryScore: 1
+        }
+      ],
+      boundaries: [],
+      method: "semantic"
+    };
+  }
+  let embeddings;
+  try {
+    embeddings = await batchEmbed(sentences, embedFn, batchSize);
+  } catch {
+    if (cfg.fallbackToRecursive) {
+      return buildRecursiveFallback(content, cfg);
+    }
+    throw new Error(
+      "Semantic chunking failed: embedding function threw and fallbackToRecursive is disabled"
+    );
+  }
+  if (embeddings.length !== sentences.length) {
+    if (cfg.fallbackToRecursive) {
+      return buildRecursiveFallback(content, cfg);
+    }
+    throw new Error(
+      `Semantic chunking failed: expected ${sentences.length} embeddings but received ${embeddings.length}`
+    );
+  }
+  const similarities = [];
+  for (let i = 0; i < sentences.length - 1; i++) {
+    similarities.push(cosineSimilarity(embeddings[i], embeddings[i + 1]));
+  }
+  if (similarities.length <= 1) {
+    if (totalTokens > cfg.maxTokens) {
+      return buildRecursiveFallback(content, cfg);
+    }
+    return {
+      chunked: false,
+      chunks: [
+        {
+          content: content.trim(),
+          index: 0,
+          tokenCount: totalTokens,
+          boundaryScore: similarities.length === 1 ? similarities[0] : 1
+        }
+      ],
+      boundaries: [],
+      method: "semantic"
+    };
+  }
+  const smoothed = movingAverage(similarities, cfg.smoothingWindowSize);
+  const m = mean(smoothed);
+  const s = stddev(smoothed);
+  const threshold = m - cfg.boundaryThresholdStdDevs * s;
+  const rawBoundaries = findLocalMinima(smoothed, threshold);
+  let segments = buildSegments(sentences, rawBoundaries);
+  segments = mergeShortSegments(segments, cfg.minTokens);
+  const chunks = [];
+  const finalBoundaries = [];
+  let sentenceOffset = 0;
+  for (let segIdx = 0; segIdx < segments.length; segIdx++) {
+    const segment = segments[segIdx];
+    const segText = segment.join(" ");
+    const segTokens = estimateTokens(segText);
+    if (segTokens > cfg.maxTokens) {
+      const subChunks = splitLongSegment(segment, cfg.maxTokens, cfg.targetTokens);
+      for (const sc of subChunks) {
+        chunks.push({
+          ...sc,
+          index: chunks.length
+        });
+      }
+    } else {
+      const trailingSentenceIdx = sentenceOffset + segment.length - 1;
+      let bScore = 1;
+      if (trailingSentenceIdx < similarities.length && segIdx < segments.length - 1) {
+        bScore = smoothed[trailingSentenceIdx] ?? similarities[trailingSentenceIdx] ?? 1;
+      }
+      chunks.push({
+        content: segText,
+        index: chunks.length,
+        tokenCount: segTokens,
+        boundaryScore: bScore
+      });
+    }
+    if (segIdx < segments.length - 1) {
+      finalBoundaries.push(sentenceOffset + segment.length - 1);
+    }
+    sentenceOffset += segment.length;
+  }
+  return {
+    chunked: chunks.length > 1,
+    chunks,
+    boundaries: finalBoundaries,
+    method: "semantic"
+  };
+}
+function buildRecursiveFallback(content, cfg) {
+  const cappedTarget = Math.min(cfg.targetTokens, cfg.maxTokens);
+  const result = chunkContent(content, {
+    targetTokens: cappedTarget,
+    minTokens: Math.min(cfg.minTokens, cappedTarget),
+    overlapSentences: 0
+  });
+  return {
+    chunked: result.chunked,
+    chunks: result.chunks.map((c) => ({
+      ...c,
+      boundaryScore: 0
+    })),
+    boundaries: [],
+    method: "recursive-fallback"
+  };
+}
+
+export {
+  DEFAULT_SEMANTIC_CHUNKING_CONFIG,
+  cosineSimilarity,
+  mean,
+  stddev,
+  movingAverage,
+  findLocalMinima,
+  semanticChunkContent
+};
+//# sourceMappingURL=chunk-KVE7R4CG.js.map

package/dist/chunk-KVE7R4CG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/semantic-chunking.ts"],"sourcesContent":["/**\n * Semantic Chunking with Smoothing-Based Topic Boundaries (Issue #368)\n *\n * An optional alternative to the recursive chunker in chunking.ts.\n * Uses sentence embeddings + cosine similarity + smoothing to detect\n * natural topic boundaries, producing more coherent chunks.\n */\n\nimport { chunkContent, type Chunk, type ChunkResult } from \"./chunking.js\";\n\n// ---------------------------------------------------------------------------\n// Configuration\n// ---------------------------------------------------------------------------\n\nexport interface SemanticChunkingConfig {\n  /** Target tokens per chunk. Default: 200. */\n  targetTokens: number;\n  /** Minimum tokens for a segment before merging with neighbor. Default: 100. */\n  minTokens: number;\n  /** Maximum tokens for a segment before recursive splitting. Default: 400. */\n  maxTokens: number;\n  /** Window size for the moving-average smoothing filter. Default: 3. */\n  smoothingWindowSize: number;\n  /** How many standard deviations below the mean constitutes a boundary. Default: 1.0. */\n  boundaryThresholdStdDevs: number;\n  /** Batch size for embedding requests. Default: 32. */\n  embeddingBatchSize: number;\n  /** Fall back to recursive chunking when embeddings are unavailable. Default: true. */\n  fallbackToRecursive: boolean;\n}\n\nexport const DEFAULT_SEMANTIC_CHUNKING_CONFIG: SemanticChunkingConfig = {\n  targetTokens: 200,\n  minTokens: 100,\n  maxTokens: 400,\n  smoothingWindowSize: 3,\n  boundaryThresholdStdDevs: 1.0,\n  embeddingBatchSize: 32,\n  fallbackToRecursive: true,\n};\n\n// ---------------------------------------------------------------------------\n// Result types\n// ---------------------------------------------------------------------------\n\nexport interface SemanticChunk extends Chunk {\n  /** Optional topic hint derived from position. */\n  topicLabel?: string;\n  /** Cosine similarity score at the trailing boundary of this chunk. */\n  boundaryScore: number;\n}\n\nexport interface SemanticChunkResult {\n  /** Whether content was split into multiple chunks. */\n  chunked: boolean;\n  /** The chunks produced. */\n  chunks: SemanticChunk[];\n  /** Sentence indices where topic splits occurred. */\n  boundaries: number[];\n  /** Which algorithm produced the result. */\n  method: \"semantic\" | \"recursive-fallback\";\n}\n\n// ---------------------------------------------------------------------------\n// Embedding function signature\n// ---------------------------------------------------------------------------\n\n/** Caller-provided function that embeds an array of texts, returning vectors. */\nexport type EmbedFn = (texts: string[]) => Promise<number[][]>;\n\n// ---------------------------------------------------------------------------\n// Math utilities (exported for testing)\n// ---------------------------------------------------------------------------\n\n/**\n * Cosine similarity between two vectors.\n * Returns a value in [-1, 1]. Identical direction = 1, orthogonal = 0.\n *\n * NOTE: This duplicates cosineSimilarity in recall-mmr.ts and embedding-fallback.ts.\n * Consider extracting to a shared math utility in a future refactor.\n */\nexport function cosineSimilarity(a: number[], b: number[]): number {\n  if (a.length !== b.length) {\n    throw new Error(\n      `cosineSimilarity: vector length mismatch (${a.length} vs ${b.length})`,\n    );\n  }\n  if (a.length === 0) return 0;\n\n  let dot = 0;\n  let magA = 0;\n  let magB = 0;\n  for (let i = 0; i < a.length; i++) {\n    dot += a[i] * b[i];\n    magA += a[i] * a[i];\n    magB += b[i] * b[i];\n  }\n\n  const denom = Math.sqrt(magA) * Math.sqrt(magB);\n  if (denom === 0) return 0;\n  return dot / denom;\n}\n\n/**\n * Arithmetic mean of a numeric series.\n */\nexport function mean(series: number[]): number {\n  if (series.length === 0) return 0;\n  let sum = 0;\n  for (const v of series) sum += v;\n  return sum / series.length;\n}\n\n/**\n * Population standard deviation of a numeric series.\n */\nexport function stddev(series: number[]): number {\n  if (series.length === 0) return 0;\n  const m = mean(series);\n  let sumSq = 0;\n  for (const v of series) {\n    const d = v - m;\n    sumSq += d * d;\n  }\n  return Math.sqrt(sumSq / series.length);\n}\n\n/**\n * Simple moving average over a 1D series.\n * The window is centered: for window size W, each output[i] averages\n * series[i - floor(W/2) .. i + floor(W/2)], clamped to bounds.\n *\n * Even window sizes are rounded up to the next odd value so the window\n * is symmetric around the center point (Finding 4, PR #420).\n */\nexport function movingAverage(series: number[], windowSize: number): number[] {\n  if (series.length === 0) return [];\n  if (windowSize < 1) windowSize = 1;\n  // Round even values up to the next odd so the window is symmetric.\n  if (windowSize % 2 === 0) windowSize = windowSize + 1;\n\n  const halfW = Math.floor(windowSize / 2);\n  const result: number[] = new Array(series.length);\n\n  for (let i = 0; i < series.length; i++) {\n    const lo = Math.max(0, i - halfW);\n    const hi = Math.min(series.length - 1, i + halfW);\n    let sum = 0;\n    for (let j = lo; j <= hi; j++) sum += series[j];\n    result[i] = sum / (hi - lo + 1);\n  }\n  return result;\n}\n\n/**\n * Find indices in the series that are local minima AND below the threshold.\n * A local minimum is a point lower than both its immediate neighbors\n * (or lower-or-equal at series boundaries).\n */\nexport function findLocalMinima(\n  series: number[],\n  threshold: number,\n): number[] {\n  if (series.length <= 2) return [];\n\n  const minima: number[] = [];\n  for (let i = 1; i < series.length - 1; i++) {\n    if (\n      series[i] < series[i - 1] &&\n      series[i] < series[i + 1] &&\n      series[i] < threshold\n    ) {\n      minima.push(i);\n    }\n  }\n  return minima;\n}\n\n// ---------------------------------------------------------------------------\n// Sentence tokenizer\n// ---------------------------------------------------------------------------\n\n/**\n * Split text into sentences at punctuation boundaries.\n * Preserves punctuation with the preceding sentence.\n */\nfunction splitSentences(text: string): string[] {\n  const sentences: string[] = [];\n  const sentenceRegex = /[^.!?]*[.!?]+(?:\\s+|$)/g;\n\n  let match: RegExpExecArray | null;\n  let lastIndex = 0;\n\n  while ((match = sentenceRegex.exec(text)) !== null) {\n    sentences.push(match[0].trim());\n    lastIndex = sentenceRegex.lastIndex;\n  }\n\n  if (lastIndex < text.length) {\n    const remaining = text.slice(lastIndex).trim();\n    if (remaining) {\n      sentences.push(remaining);\n    }\n  }\n\n  return sentences.filter((s) => s.length > 0);\n}\n\n// ---------------------------------------------------------------------------\n// Token estimation\n// ---------------------------------------------------------------------------\n\n/** Rough token estimate: ~4 chars per token for English. */\nfunction estimateTokens(text: string): number {\n  return Math.ceil(text.length / 4);\n}\n\n// ---------------------------------------------------------------------------\n// Core semantic chunking\n// ---------------------------------------------------------------------------\n\n/**\n * Batch-embed sentences using the provided embed function.\n * Respects the configured batch size.\n */\nasync function batchEmbed(\n  sentences: string[],\n  embedFn: EmbedFn,\n  batchSize: number,\n): Promise<number[][]> {\n  const allEmbeddings: number[][] = [];\n\n  for (let i = 0; i < sentences.length; i += batchSize) {\n    const batch = sentences.slice(i, i + batchSize);\n    const batchResult = await embedFn(batch);\n    for (const vec of batchResult) {\n      allEmbeddings.push(vec);\n    }\n  }\n\n  return allEmbeddings;\n}\n\n/**\n * Build segments from boundary indices.\n * boundaries are sentence indices at which splits occur (i.e., the split\n * happens AFTER the boundary index sentence).\n */\nfunction buildSegments(\n  sentences: string[],\n  boundaries: number[],\n): string[][] {\n  const sorted = [...boundaries].sort((a, b) => a - b);\n  const segments: string[][] = [];\n  let start = 0;\n\n  for (const b of sorted) {\n    // Split after sentence at index b: segment is [start .. b]\n    const splitPoint = b + 1;\n    if (splitPoint > start && splitPoint <= sentences.length) {\n      segments.push(sentences.slice(start, splitPoint));\n      start = splitPoint;\n    }\n  }\n\n  // Remaining sentences\n  if (start < sentences.length) {\n    segments.push(sentences.slice(start));\n  }\n\n  return segments;\n}\n\n/**\n * Merge short segments (below minTokens) with their neighbor.\n * Prefers merging forward; falls back to merging backward.\n */\nfunction mergeShortSegments(\n  segments: string[][],\n  minTokens: number,\n): string[][] {\n  if (segments.length <= 1) return segments;\n\n  const merged: string[][] = [];\n  let buffer: string[] = [];\n\n  for (let i = 0; i < segments.length; i++) {\n    buffer = [...buffer, ...segments[i]];\n    const tokenCount = estimateTokens(buffer.join(\" \"));\n\n    if (tokenCount >= minTokens || i === segments.length - 1) {\n      merged.push(buffer);\n      buffer = [];\n    }\n  }\n\n  // If the last merge left a dangling buffer, attach it to the last segment\n  if (buffer.length > 0) {\n    if (merged.length > 0) {\n      merged[merged.length - 1] = [...merged[merged.length - 1], ...buffer];\n    } else {\n      merged.push(buffer);\n    }\n  }\n\n  return merged;\n}\n\n/**\n * Split an oversized segment using recursive chunking.\n */\nfunction splitLongSegment(\n  segment: string[],\n  maxTokens: number,\n  targetTokens: number,\n): SemanticChunk[] {\n  const text = segment.join(\" \");\n  // Cap targetTokens to maxTokens so recursive splitting never produces\n  // segments larger than the configured maximum (Finding 2, PR #420).\n  const cappedTarget = Math.min(targetTokens, maxTokens);\n  const result: ChunkResult = chunkContent(text, {\n    targetTokens: cappedTarget,\n    minTokens: Math.min(cappedTarget, maxTokens),\n    overlapSentences: 0,\n  });\n\n  return result.chunks.map((c) => ({\n    content: c.content,\n    index: c.index,\n    tokenCount: c.tokenCount,\n    boundaryScore: 0,\n  }));\n}\n\n/**\n * Semantic chunking with smoothing-based topic boundary detection.\n *\n * @param content   - Full text to chunk.\n * @param embedFn   - Async function that embeds an array of texts.\n * @param config    - Optional partial config overrides.\n * @returns SemanticChunkResult\n */\nexport async function semanticChunkContent(\n  content: string,\n  embedFn: EmbedFn,\n  config?: Partial<SemanticChunkingConfig>,\n): Promise<SemanticChunkResult> {\n  const cfg: SemanticChunkingConfig = {\n    ...DEFAULT_SEMANTIC_CHUNKING_CONFIG,\n    ...config,\n  };\n\n  // Guard against non-positive batch size which would cause an infinite loop\n  const batchSize = Math.max(1, cfg.embeddingBatchSize);\n\n  // --- Empty / trivially short input ---\n  if (!content || content.trim().length === 0) {\n    return {\n      chunked: false,\n      chunks: [],\n      boundaries: [],\n      method: \"semantic\",\n    };\n  }\n\n  const sentences = splitSentences(content);\n\n  if (sentences.length <= 1) {\n    const tokenCount = estimateTokens(content);\n    return {\n      chunked: false,\n      chunks: [\n        {\n          content: content.trim(),\n          index: 0,\n          tokenCount,\n          boundaryScore: 1,\n        },\n      ],\n      boundaries: [],\n      method: \"semantic\",\n    };\n  }\n\n  // If total tokens is short enough, return as single chunk\n  const totalTokens = estimateTokens(content);\n  if (totalTokens <= cfg.minTokens) {\n    return {\n      chunked: false,\n      chunks: [\n        {\n          content: content.trim(),\n          index: 0,\n          tokenCount: totalTokens,\n          boundaryScore: 1,\n        },\n      ],\n      boundaries: [],\n      method: \"semantic\",\n    };\n  }\n\n  // --- Attempt embedding ---\n  let embeddings: number[][];\n  try {\n    embeddings = await batchEmbed(sentences, embedFn, batchSize);\n  } catch {\n    // Embedding failed — fall back if configured\n    if (cfg.fallbackToRecursive) {\n      return buildRecursiveFallback(content, cfg);\n    }\n    throw new Error(\n      \"Semantic chunking failed: embedding function threw and fallbackToRecursive is disabled\",\n    );\n  }\n\n  if (embeddings.length !== sentences.length) {\n    if (cfg.fallbackToRecursive) {\n      return buildRecursiveFallback(content, cfg);\n    }\n    throw new Error(\n      `Semantic chunking failed: expected ${sentences.length} embeddings but received ${embeddings.length}`,\n    );\n  }\n\n  // --- Compute pairwise cosine similarity ---\n  const similarities: number[] = [];\n  for (let i = 0; i < sentences.length - 1; i++) {\n    similarities.push(cosineSimilarity(embeddings[i], embeddings[i + 1]));\n  }\n\n  // If only one pair (2 sentences), nothing to smooth or split meaningfully.\n  // However, if the combined content exceeds maxTokens, apply recursive splitting.\n  if (similarities.length <= 1) {\n    if (totalTokens > cfg.maxTokens) {\n      return buildRecursiveFallback(content, cfg);\n    }\n    return {\n      chunked: false,\n      chunks: [\n        {\n          content: content.trim(),\n          index: 0,\n          tokenCount: totalTokens,\n          boundaryScore: similarities.length === 1 ? similarities[0] : 1,\n        },\n      ],\n      boundaries: [],\n      method: \"semantic\",\n    };\n  }\n\n  // --- Smooth the similarity series ---\n  const smoothed = movingAverage(similarities, cfg.smoothingWindowSize);\n\n  // --- Detect boundaries: local minima below (mean - k * stddev) ---\n  const m = mean(smoothed);\n  const s = stddev(smoothed);\n  const threshold = m - cfg.boundaryThresholdStdDevs * s;\n  const rawBoundaries = findLocalMinima(smoothed, threshold);\n\n  // --- Build segments, merge short, split long ---\n  let segments = buildSegments(sentences, rawBoundaries);\n  segments = mergeShortSegments(segments, cfg.minTokens);\n\n  // --- Convert segments to chunks, splitting oversized ones ---\n  const chunks: SemanticChunk[] = [];\n  const finalBoundaries: number[] = [];\n  let sentenceOffset = 0;\n\n  for (let segIdx = 0; segIdx < segments.length; segIdx++) {\n    const segment = segments[segIdx];\n    const segText = segment.join(\" \");\n    const segTokens = estimateTokens(segText);\n\n    if (segTokens > cfg.maxTokens) {\n      // Recursive split for oversized segment\n      const subChunks = splitLongSegment(segment, cfg.maxTokens, cfg.targetTokens);\n      for (const sc of subChunks) {\n        chunks.push({\n          ...sc,\n          index: chunks.length,\n        });\n      }\n    } else {\n      // Compute boundary score: the similarity at the trailing edge\n      const trailingSentenceIdx = sentenceOffset + segment.length - 1;\n      let bScore = 1;\n      if (\n        trailingSentenceIdx < similarities.length &&\n        segIdx < segments.length - 1\n      ) {\n        bScore = smoothed[trailingSentenceIdx] ?? similarities[trailingSentenceIdx] ?? 1;\n      }\n\n      chunks.push({\n        content: segText,\n        index: chunks.length,\n        tokenCount: segTokens,\n        boundaryScore: bScore,\n      });\n    }\n\n    // Record boundaries (all but the last segment produce a boundary)\n    if (segIdx < segments.length - 1) {\n      finalBoundaries.push(sentenceOffset + segment.length - 1);\n    }\n    sentenceOffset += segment.length;\n  }\n\n  return {\n    chunked: chunks.length > 1,\n    chunks,\n    boundaries: finalBoundaries,\n    method: \"semantic\",\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Recursive fallback helper\n// ---------------------------------------------------------------------------\n\nfunction buildRecursiveFallback(\n  content: string,\n  cfg: SemanticChunkingConfig,\n): SemanticChunkResult {\n  // Cap targetTokens to maxTokens so the recursive fallback path honours the\n  // same constraint as splitLongSegment (PR #439 post-merge cursor[bot] finding).\n  const cappedTarget = Math.min(cfg.targetTokens, cfg.maxTokens);\n  const result: ChunkResult = chunkContent(content, {\n    targetTokens: cappedTarget,\n    minTokens: Math.min(cfg.minTokens, cappedTarget),\n    overlapSentences: 0,\n  });\n\n  return {\n    chunked: result.chunked,\n    chunks: result.chunks.map((c) => ({\n      ...c,\n      boundaryScore: 0,\n    })),\n    boundaries: [],\n    method: \"recursive-fallback\",\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-LAYN4LDC.js

@@ -0,0 +1,267 @@
+import {
+  extractJsonCandidates
+} from "./chunk-UZB5KHKX.js";
+import {
+  normalizeProcedureSteps
+} from "./chunk-QDW3E4RD.js";
+import {
+  log
+} from "./chunk-2ODBA7MQ.js";
+
+// src/extraction-judge.ts
+import { createHash } from "crypto";
+var JUDGE_SYSTEM_PROMPT = `You are a memory curator evaluating whether extracted facts are **durable** \u2014 worth storing for long-term recall across sessions.
+
+A fact is **durable** if it will still be useful 30+ days from now and is relevant across multiple sessions, not just the current task.
+
+DURABLE examples (approve):
+- Personal preferences, identities, or relationships
+- Decisions with rationale that affect future work
+- Corrections to previously held beliefs
+- Principles, rules, or constraints the user wants respected
+- Stable facts about projects, tools, or workflows
+- Commitments, deadlines, or obligations
+
+NOT DURABLE examples (reject):
+- Transient task details ("currently debugging line 42")
+- Ephemeral state ("the build is running now")
+- Routine operations ("ran npm install")
+- Conversational filler or acknowledgements
+- Information that will be stale within hours
+- Step-by-step instructions for a one-time task
+
+Return a JSON array of objects with these fields:
+- index: number (the candidate index)
+- durable: boolean (true if the fact is durable)
+- reason: string (brief explanation)
+
+Rules:
+1. Return exactly one verdict per input candidate, matched by index.
+2. The reason field must be a short phrase (under 80 characters).
+3. When in doubt lean toward durable \u2014 false negatives are worse than false positives.
+4. Output valid JSON only. No markdown fences, no commentary.
+
+Example output:
+[{"index": 0, "durable": true, "reason": "Stable personal preference"}, {"index": 1, "durable": false, "reason": "Ephemeral build status"}]`;
+var VERDICT_CACHE_MAX_SIZE = 1e4;
+var defaultVerdictCache = /* @__PURE__ */ new Map();
+function cacheKey(text, category) {
+  return createHash("sha256").update(`${text}\0${category}`).digest("hex");
+}
+function enforceMaxCacheSize(cache) {
+  if (cache.size <= VERDICT_CACHE_MAX_SIZE) return;
+  const deleteCount = Math.floor(cache.size / 2);
+  let deleted = 0;
+  for (const key of cache.keys()) {
+    if (deleted >= deleteCount) break;
+    cache.delete(key);
+    deleted++;
+  }
+}
+var AUTO_APPROVE_CATEGORIES = /* @__PURE__ */ new Set(["correction", "principle"]);
+var PROCEDURE_TRIGGER_RE = /(when you|whenever|before you|before running|always\s|first\b.*\bthen|to deploy|to ship|run these steps|follow these steps|how (i|we)\s|recipe for|workflow|each time you)/i;
+function validateProcedureExtraction(input) {
+  const steps = normalizeProcedureSteps(input.procedureSteps);
+  if (steps.length < 2) {
+    return { durable: false, reason: "Procedure requires at least two steps with intents" };
+  }
+  const combined = [input.content, ...steps.map((s) => s.intent)].join(" ").toLowerCase();
+  if (!PROCEDURE_TRIGGER_RE.test(combined)) {
+    return { durable: false, reason: "Procedure missing explicit trigger phrasing" };
+  }
+  return { durable: true, reason: "Procedure structure validated" };
+}
+async function judgeFactDurability(candidates, config, localLlm, fallbackLlm, cache) {
+  const startMs = Date.now();
+  const verdicts = /* @__PURE__ */ new Map();
+  let cached = 0;
+  let judged = 0;
+  const verdictCache = cache ?? defaultVerdictCache;
+  if (candidates.length === 0) {
+    return { verdicts, cached, judged, elapsed: 0 };
+  }
+  const pendingIndices = [];
+  for (let i = 0; i < candidates.length; i++) {
+    const c = candidates[i];
+    if (AUTO_APPROVE_CATEGORIES.has(c.category)) {
+      verdicts.set(i, {
+        durable: true,
+        reason: `Auto-approved: ${c.category} category bypasses judge`
+      });
+      continue;
+    }
+    if (c.importanceLevel === "critical") {
+      verdicts.set(i, {
+        durable: true,
+        reason: "Auto-approved: critical importance"
+      });
+      continue;
+    }
+    const key = cacheKey(c.text, c.category);
+    const cachedVerdict = verdictCache.get(key);
+    if (cachedVerdict) {
+      verdicts.set(i, cachedVerdict);
+      cached++;
+      continue;
+    }
+    pendingIndices.push(i);
+  }
+  if (pendingIndices.length === 0) {
+    return { verdicts, cached, judged, elapsed: Date.now() - startMs };
+  }
+  const batchSize = config.extractionJudgeBatchSize;
+  for (let batchStart = 0; batchStart < pendingIndices.length; batchStart += batchSize) {
+    const batchIndices = pendingIndices.slice(batchStart, batchStart + batchSize);
+    const batchPayload = batchIndices.map((idx) => ({
+      index: idx,
+      text: candidates[idx].text,
+      category: candidates[idx].category,
+      confidence: candidates[idx].confidence
+    }));
+    const userPrompt = JSON.stringify(batchPayload);
+    try {
+      const llmResponse = await callJudgeLlm(
+        userPrompt,
+        config,
+        localLlm,
+        fallbackLlm
+      );
+      if (llmResponse) {
+        const parsed = parseJudgeResponse(llmResponse, batchIndices);
+        for (const [idx, verdict] of parsed.entries()) {
+          verdicts.set(idx, verdict);
+          judged++;
+          const c = candidates[idx];
+          verdictCache.set(cacheKey(c.text, c.category), verdict);
+        }
+        enforceMaxCacheSize(verdictCache);
+      }
+    } catch (err) {
+      log.warn(
+        `extraction-judge: LLM call failed, approving batch (fail-open): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    for (const idx of batchIndices) {
+      if (!verdicts.has(idx)) {
+        verdicts.set(idx, {
+          durable: true,
+          reason: "Approved by default (judge unavailable or parse error)"
+        });
+      }
+    }
+  }
+  return { verdicts, cached, judged, elapsed: Date.now() - startMs };
+}
+async function callJudgeLlm(userPrompt, config, localLlm, fallbackLlm) {
+  const messages = [
+    { role: "system", content: JUDGE_SYSTEM_PROMPT },
+    { role: "user", content: userPrompt }
+  ];
+  const modelOverride = config.extractionJudgeModel || void 0;
+  const skipLocal = config.modelSource === "gateway";
+  const agentId = config.modelSource === "gateway" ? config.gatewayAgentId || void 0 : void 0;
+  if (localLlm && !skipLocal) {
+    try {
+      const result = await localLlm.chatCompletion(messages, {
+        temperature: 0.1,
+        maxTokens: 2048,
+        responseFormat: { type: "json_object" },
+        timeoutMs: 1500,
+        operation: "extraction-judge",
+        ...modelOverride ? { model: modelOverride } : {}
+      });
+      if (result?.content) {
+        return result.content;
+      }
+    } catch (err) {
+      log.debug(
+        `extraction-judge: local LLM failed, trying fallback: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (fallbackLlm) {
+    try {
+      const result = await fallbackLlm.chatCompletion(
+        messages,
+        {
+          temperature: 0.1,
+          maxTokens: 2048,
+          timeoutMs: 1500,
+          ...modelOverride ? { model: modelOverride } : {},
+          ...agentId ? { agentId } : {}
+        }
+      );
+      if (result?.content) {
+        return result.content;
+      }
+    } catch (err) {
+      log.debug(
+        `extraction-judge: fallback LLM failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return null;
+}
+function parseJudgeResponse(raw, expectedIndices) {
+  const result = /* @__PURE__ */ new Map();
+  const expectedSet = new Set(expectedIndices);
+  try {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      const candidates = extractJsonCandidates(raw);
+      if (candidates.length > 0) {
+        parsed = JSON.parse(candidates[0]);
+      }
+    }
+    if (!Array.isArray(parsed)) {
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const values = Object.values(parsed);
+        for (const v of values) {
+          if (Array.isArray(v)) {
+            parsed = v;
+            break;
+          }
+        }
+      }
+      if (!Array.isArray(parsed)) {
+        log.debug("extraction-judge: response is not an array, cannot parse");
+        return result;
+      }
+    }
+    for (const item of parsed) {
+      if (typeof item !== "object" || item === null || typeof item.index !== "number") {
+        continue;
+      }
+      const idx = item.index;
+      if (!expectedSet.has(idx)) continue;
+      const durable = typeof item.durable === "boolean" ? item.durable : true;
+      const reason = typeof item.reason === "string" ? item.reason.slice(0, 120) : "No reason provided";
+      result.set(idx, { durable, reason });
+    }
+  } catch (err) {
+    log.debug(
+      `extraction-judge: failed to parse response: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return result;
+}
+function clearVerdictCache() {
+  defaultVerdictCache.clear();
+}
+function verdictCacheSize() {
+  return defaultVerdictCache.size;
+}
+function createVerdictCache() {
+  return /* @__PURE__ */ new Map();
+}
+
+export {
+  validateProcedureExtraction,
+  judgeFactDurability,
+  clearVerdictCache,
+  verdictCacheSize,
+  createVerdictCache
+};
+//# sourceMappingURL=chunk-LAYN4LDC.js.map