@remnic/core 9.57.6 → 9.58.0

package/dist/chunk-KSXJOC4F.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/connectors/codex-materialize.ts"],"sourcesContent":["/**\n * codex-materialize.ts — Codex CLI native memory artifact materialization (#378)\n *\n * Periodically writes Remnic memories into the file layout that Codex CLI's\n * phase-2 consolidation reads directly under `<codex_home>/memories/`:\n *\n *   memory_summary.md                — always-loaded at session start (tight budget)\n *   MEMORY.md                        — searchable handbook (task-group schema)\n *   raw_memories.md                  — mechanical merge of raw memories, latest first\n *   rollout_summaries/<slug>.md      — per-session recaps\n *\n * Codex's own read path is agnostic to which producer wrote these files — it\n * tags reads by `memory_md` / `memory_summary` / `raw_memories` /\n * `rollout_summaries` / `skills`. By materializing Remnic content into this\n * exact layout we let Codex pick up Remnic memories without a single MCP call.\n *\n * Safety invariants\n * ─────────────────\n *  - **Atomic writes.** Every file is rendered under `.remnic-tmp/` and then\n *    `rename()`d into place so Codex never observes a half-written file.\n *  - **Sentinel-based opt-in.** If `<codex_home>/memories/.remnic-managed` is\n *    missing, we SKIP materialization entirely and log a warning. This honors\n *    user hand-edits to the directory — a user who manually curated their\n *    Codex memory layout will never have those edits overwritten.\n *  - **Schema validation.** `MEMORY.md` content is validated against the\n *    task-group schema before write. Invalid content throws and nothing is\n *    written.\n *  - **Idempotent no-ops.** A content hash is written into the sentinel. If\n *    the re-rendered hash matches the previous run, we skip writes entirely.\n *  - **Token budget.** `memory_summary.md` is truncated to fit under the\n *    configured token budget (whitespace-tokenized approximation), leaving\n *    headroom under Codex's 5000-token summary cap.\n *\n * Privacy\n * ───────\n * This module does not persist any user content outside `<codex_home>/memories`\n * — it only mirrors the memories that Remnic already wrote. It does not log\n * memory content to stdout; it logs file names, counts, and hashes.\n */\n\nimport {\n  createHash,\n} from \"node:crypto\";\nimport fs from \"node:fs\";\nimport path from \"node:path\";\n\nimport { log } from \"../logger.js\";\nimport { readEnvVar, resolveHomeDir } from \"../runtime/env.js\";\nimport type { MemoryFile } from \"../types.js\";\nimport { expandTildePath } from \"../utils/path.js\";\n\n// ─── Types ─────────────────────────────────────────────────────────────────\n\n/**\n * Input for {@link materializeForNamespace}. Prefer passing pre-loaded\n * `memories` so this module stays I/O-agnostic and trivially testable.\n */\nexport interface MaterializeOptions {\n  /** Pre-loaded Remnic memories for this namespace (required). */\n  memories: MemoryFile[];\n  /** Override `<codex_home>`. Defaults to `$CODEX_HOME` or `~/.codex`. */\n  codexHome?: string;\n  /** Maximum whitespace-tokenized size of memory_summary.md. Default 4500. */\n  maxSummaryTokens?: number;\n  /** Maximum age of rollout_summaries/*.md in days. Default 30. */\n  rolloutRetentionDays?: number;\n  /** Per-session rollout summaries to render. */\n  rolloutSummaries?: RolloutSummaryInput[];\n  /** Current time, injected for deterministic tests. */\n  now?: Date;\n  /** Optional logger override for tests. */\n  logger?: { info: (msg: string) => void; warn: (msg: string) => void; debug?: (msg: string) => void };\n}\n\n/** Input describing one Codex rollout summary file. */\nexport interface RolloutSummaryInput {\n  /** Stable slug for the file (becomes `<slug>.md`). */\n  slug: string;\n  /** Working directory used during the rollout. */\n  cwd?: string;\n  /** Path to the raw Codex rollout log, if known. */\n  rolloutPath?: string;\n  /** ISO-8601 timestamp of the last update. */\n  updatedAt?: string;\n  /** Opaque thread / session id. */\n  threadId?: string;\n  /** Markdown body for the recap. */\n  body: string;\n  /** Freeform keywords / search hints. */\n  keywords?: string[];\n}\n\n/** Result of a materialization run. */\nexport interface MaterializeResult {\n  /** Namespace that was materialized. */\n  namespace: string;\n  /** `<codex_home>/memories` path this run targeted. */\n  memoriesDir: string;\n  /** Was anything actually written (vs. skipped / idempotent no-op)? */\n  wrote: boolean;\n  /** True if the sentinel was missing and we skipped with a warning. */\n  skippedNoSentinel: boolean;\n  /** True if the hash matched the previous run and we short-circuited. */\n  skippedIdempotent: boolean;\n  /** Files that were written this run (relative to `memoriesDir`). */\n  filesWritten: string[];\n  /** Content hash computed for this run. */\n  contentHash: string;\n}\n\n/** On-disk shape of the `.remnic-managed` sentinel. */\ninterface SentinelFile {\n  version: number;\n  namespace: string;\n  updated_at: string;\n  content_hash: string;\n}\n\n// ─── Constants ─────────────────────────────────────────────────────────────\n\n/** Bump when the on-disk layout or semantics change. */\nexport const MATERIALIZE_VERSION = 1;\n\n/** Sentinel file name at the root of the materialized memories dir. */\nexport const SENTINEL_FILE = \".remnic-managed\";\n\n/** Scratch directory used for atomic renames. */\nexport const TMP_DIR = \".remnic-tmp\";\n\n/** File names we own. Anything else in the directory is considered user-managed. */\nconst OWNED_FILES = new Set<string>([\n  \"memory_summary.md\",\n  \"MEMORY.md\",\n  \"raw_memories.md\",\n]);\n\n/** Sub-directory for per-session rollout recaps. */\nconst ROLLOUT_SUBDIR = \"rollout_summaries\";\n\n// ─── Public entry points ───────────────────────────────────────────────────\n\n/**\n * Materialize a Remnic namespace into Codex's native memory layout.\n *\n * Returns a {@link MaterializeResult} describing what happened. Callers\n * should treat \"skipped\" as success — the sentinel / idempotent cases are\n * expected and intentional.\n *\n * @throws if `MEMORY.md` fails schema validation (we do not write garbage).\n */\nexport function materializeForNamespace(\n  namespace: string,\n  options: MaterializeOptions,\n): MaterializeResult {\n  const logger = options.logger ?? {\n    info: (msg) => log.info(`[codex-materialize] ${msg}`),\n    warn: (msg) => log.warn(`[codex-materialize] ${msg}`),\n    debug: (msg) => log.debug(`[codex-materialize] ${msg}`),\n  };\n  const memoriesDir = resolveCodexMemoriesDir(options.codexHome);\n  const now = options.now ?? new Date();\n  // Honor `0` as \"no summary budget\" — parseConfig already clamps to non-\n  // negative integers, so any provided number is meaningful. Only fall back\n  // to the default when the caller did not provide the option at all.\n  const maxSummaryTokens =\n    typeof options.maxSummaryTokens === \"number\" && options.maxSummaryTokens >= 0\n      ? options.maxSummaryTokens\n      : 4500;\n  const rolloutRetentionDays =\n    typeof options.rolloutRetentionDays === \"number\" && options.rolloutRetentionDays >= 0\n      ? options.rolloutRetentionDays\n      : 30;\n\n  // ── Sentinel check ─────────────────────────────────────────────────────\n  // We deliberately do NOT `mkdirSync(memoriesDir)` before reading the\n  // sentinel: creating `~/.codex/memories/` for every user (including ones\n  // who never use Codex) would make Remnic's post-consolidation hook leave\n  // empty opt-in directories behind on disk. Instead we only check whether\n  // the sentinel already exists — if the parent dir doesn't exist, the\n  // sentinel can't exist either and we fall straight through to the skip\n  // path without touching the filesystem. The `mkdirSync` for `memoriesDir`\n  // happens later, only once we know we're actually going to write.\n  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);\n  const existingSentinel = readSentinel(sentinelPath);\n  if (!existingSentinel) {\n    // Log at `debug` when the entire memories dir doesn't exist — that's\n    // the common \"user never opted in\" case and should not be noisy.\n    // Keep the `warn` level only when the dir exists but lacks a sentinel,\n    // which is the \"user hand-curated layout, don't overwrite\" case that\n    // genuinely warrants attention.\n    if (fs.existsSync(memoriesDir)) {\n      logger.warn(\n        `sentinel ${SENTINEL_FILE} missing in ${memoriesDir}; skipping materialization to preserve hand-edits`,\n      );\n    } else {\n      logger.debug?.(\n        `skipping materialization — ${memoriesDir} does not exist (user not opted in)`,\n      );\n    }\n    return {\n      namespace,\n      memoriesDir,\n      wrote: false,\n      skippedNoSentinel: true,\n      skippedIdempotent: false,\n      filesWritten: [],\n      contentHash: \"\",\n    };\n  }\n\n  // Now that we know the user has opted in (sentinel exists), it's safe to\n  // ensure the memories dir is present. In practice this is almost always a\n  // no-op because the sentinel read above already succeeded, but a defensive\n  // mkdirSync protects against a race where the dir was removed between the\n  // sentinel read and the first write.\n  fs.mkdirSync(memoriesDir, { recursive: true });\n\n  // ── Render ─────────────────────────────────────────────────────────────\n  const memories = [...options.memories];\n  // Track whether the caller actually supplied a rollout set. `undefined`\n  // means \"don't touch rollout_summaries/\"; an empty array is still\n  // authoritative and means \"we own this dir and it should be empty\".\n  const rolloutsSupplied = options.rolloutSummaries !== undefined;\n  const rolloutSummaries = options.rolloutSummaries ?? [];\n\n  // Prune-before-render: MEMORY.md and memory_summary.md both embed rollout\n  // filenames in their body, so they must only ever see the *retained* set.\n  // Running pruneRollouts after the renderers (as an earlier revision did)\n  // caused MEMORY.md to list `rollout_summaries/<slug>.md` paths for rollouts\n  // that were then pruned and never written — a broken link pointing at a\n  // ghost file. See review feedback on PR #392.\n  const retainedRollouts = pruneRollouts(rolloutSummaries, rolloutRetentionDays, now);\n\n  // Deduplicate on sanitized filename. Two different slugs (\"Session 1\" and\n  // \"session!!!1\") can sanitize to the same output (\"session-1\"), which would\n  // otherwise make the first entry's tmp file get overwritten and cause the\n  // later rename step to crash with ENOENT. For each collision slot we keep\n  // the entry with the newest `updatedAt` so an unsorted input (or a caller\n  // that accidentally appends older recaps after newer ones) can't have an\n  // older recap clobber a newer one.\n  // We do this at the retained-input level (not just at the written-file\n  // level) so MEMORY.md's \"rollout_summary_files\" section lists each slot\n  // exactly once and matches what actually gets written to disk.\n  const dedupedRollouts: RolloutSummaryInput[] = [];\n  const seenNames = new Map<string, number>();\n  const parseTs = (value: string | undefined): number => {\n    if (!value) return Number.NEGATIVE_INFINITY;\n    const parsed = Date.parse(value);\n    return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;\n  };\n  for (const r of retainedRollouts) {\n    const name = `${sanitizeSlug(r.slug)}.md`;\n    const existingIdx = seenNames.get(name);\n    if (existingIdx === undefined) {\n      seenNames.set(name, dedupedRollouts.length);\n      dedupedRollouts.push(r);\n      continue;\n    }\n    // Newest-wins: only replace the existing entry if the incoming one has a\n    // strictly newer timestamp. Ties keep the earlier entry (stable for\n    // unsorted inputs) because overwriting on ties would flip rendering output\n    // for benign call-order changes.\n    const existing = dedupedRollouts[existingIdx];\n    if (parseTs(r.updatedAt) > parseTs(existing.updatedAt)) {\n      dedupedRollouts[existingIdx] = r;\n    }\n  }\n\n  const memorySummary = renderMemorySummary({\n    namespace,\n    memories,\n    rolloutSummaries: dedupedRollouts,\n    maxTokens: maxSummaryTokens,\n  });\n\n  const memoryMd = renderMemoryMd({\n    namespace,\n    memories,\n    rolloutSummaries: dedupedRollouts,\n  });\n\n  // Fail fast on schema issues — do not write garbage.\n  const validation = validateMemoryMd(memoryMd);\n  if (!validation.valid) {\n    const reason = validation.errors.join(\"; \");\n    logger.warn(`MEMORY.md failed schema validation: ${reason}`);\n    throw new Error(`codex-materialize: MEMORY.md schema validation failed: ${reason}`);\n  }\n\n  const rawMemories = renderRawMemories({ memories });\n\n  const rolloutFiles = dedupedRollouts.map((r) => ({\n    name: `${sanitizeSlug(r.slug)}.md`,\n    body: renderRolloutSummary(r),\n  }));\n  const destRolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);\n  const retainedRolloutNames = new Set(rolloutFiles.map((r) => r.name));\n\n  // ── Idempotence check ──────────────────────────────────────────────────\n  const hash = computeContentHash({\n    namespace,\n    memorySummary,\n    memoryMd,\n    rawMemories,\n    rolloutFiles,\n  });\n\n  if (existingSentinel.content_hash === hash) {\n    // Idempotence early-return is only safe when the managed files we would\n    // have written are still on disk. If a user or external process deleted\n    // `MEMORY.md` / `memory_summary.md` / `raw_memories.md` (or any retained\n    // rollout file) while the sentinel's hash stayed the same, we must fall\n    // through and rewrite — otherwise Codex would be stuck with missing\n    // artifacts until a memory-content change happens to flip the hash.\n    const requiredFiles = [\n      path.join(memoriesDir, \"memory_summary.md\"),\n      path.join(memoriesDir, \"MEMORY.md\"),\n      path.join(memoriesDir, \"raw_memories.md\"),\n      ...rolloutFiles.map((r) => path.join(memoriesDir, ROLLOUT_SUBDIR, r.name)),\n    ];\n    const allPresent = requiredFiles.every((f) => fs.existsSync(f));\n    const rolloutsClean =\n      !rolloutsSupplied ||\n      rolloutDirectoryMatchesRetainedSet(\n        ensureSafeRolloutsDir(memoriesDir, destRolloutsDir),\n        retainedRolloutNames,\n      );\n    if (allPresent && rolloutsClean) {\n      logger.debug?.(`no-op materialization for namespace=${namespace} (hash unchanged)`);\n      return {\n        namespace,\n        memoriesDir,\n        wrote: false,\n        skippedNoSentinel: false,\n        skippedIdempotent: true,\n        filesWritten: [],\n        contentHash: hash,\n      };\n    }\n    logger.debug?.(\n      `hash unchanged for namespace=${namespace} but managed files need refresh — forcing rewrite`,\n    );\n  }\n\n  // ── Atomic writes ──────────────────────────────────────────────────────\n  // Use a unique, per-run staging sub-directory so two overlapping runs\n  // (e.g. a session-end trigger overlapping with a consolidation post-hook)\n  // can't stomp each other's tmp files mid-rename. The old \"fixed TMP_DIR,\n  // wipe-on-entry\" layout meant run B would delete run A's staging area out\n  // from under it, causing ENOENT on A's rename loop. Per-run uniqueness\n  // turns the shared dir into an insulated workspace. See review feedback on\n  // PR #392.\n  const runTag = `${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n  const tmpDir = path.join(memoriesDir, `${TMP_DIR}-${runTag}`);\n  // Opportunistic GC for stale scratch dirs left behind by a previous\n  // crashed run. We only remove entries whose mtime is older than the\n  // stale-threshold below — that way we never delete another in-flight\n  // run's staging area out from under it. The threshold is deliberately\n  // generous (1h) because a healthy materialize completes in milliseconds\n  // and there's no legitimate reason for a live staging dir to be older.\n  //\n  // NB: we compare against `Date.now()` (wall-clock), not against the\n  // injected `options.now`. Tests and deterministic replays commonly\n  // inject a non-current timestamp, but file mtimes on disk are always\n  // wall-clock, so mixing the two would either false-positive delete\n  // fresh dirs (test-time in the past) or false-negative skip stale ones\n  // (test-time in the future).\n  const TMP_STALE_MS = 60 * 60 * 1000;\n  const wallClockMs = Date.now();\n  try {\n    for (const entry of fs.readdirSync(memoriesDir, { withFileTypes: true })) {\n      if (!entry.isDirectory()) continue;\n      if (!entry.name.startsWith(TMP_DIR)) continue;\n      const stalePath = path.join(memoriesDir, entry.name);\n      try {\n        const stat = fs.statSync(stalePath);\n        if (wallClockMs - stat.mtimeMs < TMP_STALE_MS) continue;\n        fs.rmSync(stalePath, { recursive: true, force: true });\n      } catch {\n        // ignore — another concurrent run may own it, or we lack perms\n      }\n    }\n  } catch {\n    // ignore — dir may not exist yet\n  }\n  fs.mkdirSync(tmpDir, { recursive: true });\n  fs.mkdirSync(path.join(tmpDir, ROLLOUT_SUBDIR), { recursive: true });\n\n  const filesWritten: string[] = [];\n\n  fs.writeFileSync(path.join(tmpDir, \"memory_summary.md\"), memorySummary);\n  filesWritten.push(\"memory_summary.md\");\n\n  fs.writeFileSync(path.join(tmpDir, \"MEMORY.md\"), memoryMd);\n  filesWritten.push(\"MEMORY.md\");\n\n  fs.writeFileSync(path.join(tmpDir, \"raw_memories.md\"), rawMemories);\n  filesWritten.push(\"raw_memories.md\");\n\n  for (const rollout of rolloutFiles) {\n    fs.writeFileSync(path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name), rollout.body);\n    filesWritten.push(path.join(ROLLOUT_SUBDIR, rollout.name));\n  }\n\n  // Rename into place. Atomic per-file is sufficient — Codex reads each file\n  // independently and tolerates an inconsistent in-between snapshot across\n  // files for the duration of the rename loop (milliseconds).\n  for (const rel of [\"memory_summary.md\", \"MEMORY.md\", \"raw_memories.md\"]) {\n    const src = path.join(tmpDir, rel);\n    const dest = path.join(memoriesDir, rel);\n    fs.renameSync(src, dest);\n  }\n\n  const safeDestRolloutsDir = ensureSafeRolloutsDir(memoriesDir, destRolloutsDir);\n  // Only garbage-collect rollout files when the caller actually supplied a\n  // `rolloutSummaries` array — otherwise we'd wipe legitimately\n  // user/Codex-created recap files on every session-end run, since those\n  // calls typically omit the rollout set entirely. When rollouts were\n  // supplied (even as an empty array — meaning \"we own this dir and it\n  // should be empty\"), we clear the stale files we previously owned.\n  if (rolloutsSupplied) {\n    let existingRollouts: fs.Dirent[];\n    try {\n      existingRollouts = fs.readdirSync(safeDestRolloutsDir, { withFileTypes: true });\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code !== \"ENOENT\") throw err;\n      existingRollouts = [];\n    }\n    for (const entry of existingRollouts) {\n      if (!entry.isFile()) continue;\n      if (!entry.name.endsWith(\".md\")) continue;\n      if (retainedRolloutNames.has(entry.name)) continue;\n      try {\n        fs.unlinkSync(path.join(safeDestRolloutsDir, entry.name));\n      } catch (err) {\n        throw new Error(\n          `codex-materialize: failed to prune stale rollout summary ${entry.name}: ${err instanceof Error ? err.message : String(err)}`,\n        );\n      }\n    }\n  }\n\n  for (const rollout of rolloutFiles) {\n    const src = path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name);\n    const dest = path.join(safeDestRolloutsDir, rollout.name);\n    fs.renameSync(src, dest);\n  }\n\n  // Update sentinel last so a crash leaves hash mismatched → next run rewrites.\n  const sentinel: SentinelFile = {\n    version: MATERIALIZE_VERSION,\n    namespace,\n    updated_at: now.toISOString(),\n    content_hash: hash,\n  };\n  writeSentinelAtomically(sentinelPath, sentinel);\n\n  try {\n    fs.rmSync(tmpDir, { recursive: true, force: true });\n  } catch {\n    // ignore\n  }\n\n  logger.info(\n    `materialized namespace=${namespace} files=${filesWritten.length} hash=${hash.slice(0, 12)}`,\n  );\n\n  return {\n    namespace,\n    memoriesDir,\n    wrote: true,\n    skippedNoSentinel: false,\n    skippedIdempotent: false,\n    filesWritten,\n    contentHash: hash,\n  };\n}\n\n/**\n * Create (or refresh) the `.remnic-managed` sentinel. Callers must do this\n * explicitly the first time they want Remnic to start managing a directory —\n * we never write it implicitly, because its presence is the user's opt-in.\n */\nexport function ensureSentinel(memoriesDir: string, namespace: string, now: Date = new Date()): void {\n  fs.mkdirSync(memoriesDir, { recursive: true });\n  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);\n  if (fs.existsSync(sentinelPath)) {\n    readSentinel(sentinelPath);\n    return;\n  }\n  const sentinel: SentinelFile = {\n    version: MATERIALIZE_VERSION,\n    namespace,\n    updated_at: now.toISOString(),\n    content_hash: \"\",\n  };\n  writeSentinelAtomically(sentinelPath, sentinel);\n}\n\n// ─── Rendering ─────────────────────────────────────────────────────────────\n\ninterface RenderContext {\n  namespace: string;\n  memories: MemoryFile[];\n  rolloutSummaries: RolloutSummaryInput[];\n  // Historically this interface exposed a `now: Date` field, but neither\n  // `renderMemoryMd` nor `renderMemorySummary` ever read it (rendered output\n  // is purely a function of `namespace`, `memories`, and `rolloutSummaries`).\n  // The field was flagged as dead weight in PR #392 review and removed.\n  // If a future renderer needs a timestamp, re-add it here and update both\n  // call sites and the schema test.\n}\n\ninterface SummaryRenderContext extends RenderContext {\n  maxTokens: number;\n}\n\n/**\n * Render `memory_summary.md` — the always-loaded file.\n * Budget-capped at `maxTokens` whitespace tokens.\n */\nexport function renderMemorySummary(ctx: SummaryRenderContext): string {\n  const lines: string[] = [];\n  lines.push(\"# Memory Summary\");\n  lines.push(\"\");\n  lines.push(`_namespace: ${ctx.namespace}_`);\n  lines.push(`_source: remnic_`);\n  lines.push(\"\");\n\n  const highValue = selectSummaryMemories(ctx.memories, 12);\n  if (highValue.length > 0) {\n    lines.push(\"## Top memories\");\n    lines.push(\"\");\n    for (const mem of highValue) {\n      lines.push(`- ${oneLineSummary(mem)}`);\n    }\n    lines.push(\"\");\n  }\n\n  if (ctx.rolloutSummaries.length > 0) {\n    lines.push(\"## Recent rollouts\");\n    lines.push(\"\");\n    const sorted = [...ctx.rolloutSummaries]\n      .sort((a, b) => (b.updatedAt ?? \"\").localeCompare(a.updatedAt ?? \"\"))\n      .slice(0, 5);\n    for (const r of sorted) {\n      const when = r.updatedAt ? ` (${r.updatedAt})` : \"\";\n      lines.push(`- ${r.slug}${when}`);\n    }\n    lines.push(\"\");\n  }\n\n  // Collapse trailing newlines to one without the anchored /\\n+$/ quantifier,\n  // which backtracks polynomially (CodeQL js/polynomial-redos).\n  const joined = lines.join(\"\\n\");\n  let joinedEnd = joined.length;\n  while (joinedEnd > 0 && joined[joinedEnd - 1] === \"\\n\") joinedEnd--;\n  const full = joinedEnd === joined.length ? joined : `${joined.slice(0, joinedEnd)}\\n`;\n  return truncateToTokenBudget(full, ctx.maxTokens);\n}\n\n/**\n * Render `MEMORY.md` — the searchable handbook in Codex's task-group schema.\n */\nexport function renderMemoryMd(ctx: RenderContext): string {\n  const lines: string[] = [];\n  lines.push(`# Task Group: ${ctx.namespace}`);\n  lines.push(`scope: ${ctx.namespace}`);\n  lines.push(`applies_to: cwd=*; reuse_rule=namespace-match`);\n  lines.push(\"\");\n\n  // One \"task\" per top-level topic cluster. For the first cut we group by\n  // memory category so the schema validator always sees at least one task.\n  const byCategory = groupMemoriesByCategory(ctx.memories);\n  let taskIndex = 1;\n  if (byCategory.size === 0) {\n    lines.push(`## Task ${taskIndex}: baseline — no memories yet`);\n    lines.push(\"\");\n    lines.push(\"### rollout_summary_files\");\n    for (const r of ctx.rolloutSummaries) {\n      lines.push(\n        `- rollout_summaries/${sanitizeSlug(r.slug)}.md (cwd=${r.cwd ?? \"*\"}, rollout_path=${r.rolloutPath ?? \"\"}, updated_at=${r.updatedAt ?? \"\"}, thread_id=${r.threadId ?? \"\"})`,\n      );\n    }\n    if (ctx.rolloutSummaries.length === 0) {\n      lines.push(\"- (none)\");\n    }\n    lines.push(\"\");\n    lines.push(\"### keywords\");\n    lines.push(`- ${ctx.namespace}`);\n    lines.push(\"\");\n    taskIndex += 1;\n  } else {\n    for (const [category, mems] of byCategory) {\n      lines.push(`## Task ${taskIndex}: ${category} memories, outcome=surface-to-codex`);\n      lines.push(\"\");\n      lines.push(\"### rollout_summary_files\");\n      const relevantRollouts = ctx.rolloutSummaries.slice(0, 5);\n      if (relevantRollouts.length === 0) {\n        lines.push(\"- (none)\");\n      } else {\n        for (const r of relevantRollouts) {\n          lines.push(\n            `- rollout_summaries/${sanitizeSlug(r.slug)}.md (cwd=${r.cwd ?? \"*\"}, rollout_path=${r.rolloutPath ?? \"\"}, updated_at=${r.updatedAt ?? \"\"}, thread_id=${r.threadId ?? \"\"})`,\n          );\n        }\n      }\n      lines.push(\"\");\n      lines.push(\"### keywords\");\n      const keywords = collectKeywords(mems, category, ctx.namespace);\n      lines.push(`- ${keywords.join(\", \")}`);\n      lines.push(\"\");\n      taskIndex += 1;\n    }\n  }\n\n  lines.push(\"## User preferences\");\n  const prefs = pickCategory(ctx.memories, [\"preference\"]);\n  if (prefs.length === 0) {\n    lines.push(\"- (none recorded)\");\n  } else {\n    for (const pref of prefs.slice(0, 20)) {\n      lines.push(`- ${oneLineSummary(pref)}`);\n    }\n  }\n  lines.push(\"\");\n\n  lines.push(\"## Reusable knowledge\");\n  const knowledge = pickCategory(ctx.memories, [\"fact\", \"decision\", \"principle\", \"rule\", \"skill\"]);\n  if (knowledge.length === 0) {\n    lines.push(\"- (none recorded)\");\n  } else {\n    for (const mem of knowledge.slice(0, 30)) {\n      lines.push(`- ${oneLineSummary(mem)}`);\n    }\n  }\n  lines.push(\"\");\n\n  lines.push(\"## Failures and how to do differently\");\n  const corrections = pickCategory(ctx.memories, [\"correction\"]);\n  if (corrections.length === 0) {\n    lines.push(\"- (none recorded)\");\n  } else {\n    for (const mem of corrections.slice(0, 20)) {\n      lines.push(`- ${oneLineSummary(mem)}`);\n    }\n  }\n  lines.push(\"\");\n\n  return lines.join(\"\\n\");\n}\n\n/** Render `raw_memories.md` — mechanical dump, latest first. */\nexport function renderRawMemories(ctx: { memories: MemoryFile[] }): string {\n  const sorted = [...ctx.memories].sort((a, b) => {\n    const aUpdated = a.frontmatter.updated ?? a.frontmatter.created ?? \"\";\n    const bUpdated = b.frontmatter.updated ?? b.frontmatter.created ?? \"\";\n    return bUpdated.localeCompare(aUpdated);\n  });\n\n  const lines: string[] = [\"# Raw Memories\", \"\", \"_source: remnic — latest first_\", \"\"];\n  for (const mem of sorted) {\n    const fm = mem.frontmatter;\n    const id = fm.id ?? \"unknown\";\n    const category = fm.category ?? \"unknown\";\n    const updated = fm.updated ?? fm.created ?? \"\";\n    lines.push(`## ${id} (${category}, updated=${updated})`);\n    lines.push(\"\");\n    lines.push(mem.content.trim());\n    lines.push(\"\");\n  }\n  return lines.join(\"\\n\");\n}\n\n/** Render a single rollout summary file. */\nexport function renderRolloutSummary(input: RolloutSummaryInput): string {\n  const lines: string[] = [];\n  lines.push(`# Rollout Summary: ${input.slug}`);\n  lines.push(\"\");\n  const meta: string[] = [];\n  if (input.cwd) meta.push(`cwd=${input.cwd}`);\n  if (input.rolloutPath) meta.push(`rollout_path=${input.rolloutPath}`);\n  if (input.updatedAt) meta.push(`updated_at=${input.updatedAt}`);\n  if (input.threadId) meta.push(`thread_id=${input.threadId}`);\n  if (meta.length > 0) {\n    lines.push(`_${meta.join(\"; \")}_`);\n    lines.push(\"\");\n  }\n  if (input.keywords && input.keywords.length > 0) {\n    lines.push(`**keywords:** ${input.keywords.join(\", \")}`);\n    lines.push(\"\");\n  }\n  lines.push(input.body.trim());\n  lines.push(\"\");\n  return lines.join(\"\\n\");\n}\n\n// ─── Schema validation ─────────────────────────────────────────────────────\n\nexport interface MemoryMdValidation {\n  valid: boolean;\n  errors: string[];\n}\n\n/**\n * Validate that a rendered `MEMORY.md` matches Codex's task-group schema.\n * We enforce the minimum set of structural requirements called out in #378:\n *\n *  - one `# Task Group:` header\n *  - `scope:` and `applies_to:` lines directly beneath it\n *  - at least one `## Task N:` section\n *  - each task section has `### rollout_summary_files` and `### keywords`\n *  - `## User preferences`, `## Reusable knowledge`,\n *    `## Failures and how to do differently` sections all present\n */\nexport function validateMemoryMd(content: string): MemoryMdValidation {\n  const errors: string[] = [];\n  const lines = content.split(/\\r?\\n/u);\n\n  const taskGroupIndex = lines.findIndex((l) => /^#\\s+Task Group:\\s+\\S+/u.test(l));\n  if (taskGroupIndex === -1) {\n    errors.push(\"missing `# Task Group:` header\");\n  } else {\n    const tail = lines.slice(taskGroupIndex + 1, taskGroupIndex + 5);\n    if (!tail.some((l) => /^scope:\\s*\\S+/u.test(l))) {\n      errors.push(\"missing `scope:` line under Task Group header\");\n    }\n    if (!tail.some((l) => /^applies_to:\\s*\\S+/u.test(l))) {\n      errors.push(\"missing `applies_to:` line under Task Group header\");\n    }\n  }\n\n  const taskHeaders = lines.filter((l) => /^##\\s+Task\\s+\\d+:/u.test(l));\n  if (taskHeaders.length === 0) {\n    errors.push(\"at least one `## Task N:` section is required\");\n  }\n\n  // For every task section, make sure we have rollout_summary_files + keywords\n  // before the next `##` header at the same level.\n  const sectionRegex = /^##\\s+/u;\n  for (let i = 0; i < lines.length; i++) {\n    if (!/^##\\s+Task\\s+\\d+:/u.test(lines[i])) continue;\n    let hasRollout = false;\n    let hasKeywords = false;\n    for (let j = i + 1; j < lines.length; j++) {\n      if (sectionRegex.test(lines[j])) break;\n      if (/^###\\s+rollout_summary_files\\s*$/u.test(lines[j])) hasRollout = true;\n      if (/^###\\s+keywords\\s*$/u.test(lines[j])) hasKeywords = true;\n    }\n    if (!hasRollout) errors.push(`task block at line ${i + 1} missing \\`### rollout_summary_files\\``);\n    if (!hasKeywords) errors.push(`task block at line ${i + 1} missing \\`### keywords\\``);\n  }\n\n  const requiredSections = [\n    /^##\\s+User preferences\\s*$/u,\n    /^##\\s+Reusable knowledge\\s*$/u,\n    /^##\\s+Failures and how to do differently\\s*$/u,\n  ];\n  for (const re of requiredSections) {\n    if (!lines.some((l) => re.test(l))) {\n      errors.push(`missing required section: ${re.source}`);\n    }\n  }\n\n  return { valid: errors.length === 0, errors };\n}\n\n// ─── Helpers ───────────────────────────────────────────────────────────────\n\nfunction resolveCodexHome(override?: string): string {\n  if (override && override.trim().length > 0) {\n    return path.resolve(expandTildePath(override.trim()));\n  }\n  const fromEnv = readEnvVar(\"CODEX_HOME\");\n  if (fromEnv && fromEnv.trim().length > 0) {\n    return path.resolve(expandTildePath(fromEnv.trim()));\n  }\n  return path.resolve(resolveHomeDir(), \".codex\");\n}\n\nexport function resolveCodexMemoriesDir(codexHome?: string): string {\n  return path.join(resolveCodexHome(codexHome), \"memories\");\n}\n\nexport function hasCodexMaterializeSentinel(codexHome?: string): boolean {\n  return readSentinel(path.join(resolveCodexMemoriesDir(codexHome), SENTINEL_FILE)) !== null;\n}\n\nfunction rolloutDirectoryMatchesRetainedSet(\n  rolloutsDir: string,\n  retainedNames: Set<string>,\n): boolean {\n  let entries: fs.Dirent[];\n  try {\n    entries = fs.readdirSync(rolloutsDir, { withFileTypes: true });\n  } catch {\n    return retainedNames.size === 0;\n  }\n  for (const entry of entries) {\n    if (!entry.isFile()) continue;\n    if (!entry.name.endsWith(\".md\")) continue;\n    if (!retainedNames.has(entry.name)) return false;\n  }\n  return true;\n}\n\nfunction isPathInside(parent: string, child: string): boolean {\n  const relative = path.relative(parent, child);\n  return relative === \"\" || (!relative.startsWith(\"..\") && !path.isAbsolute(relative));\n}\n\nfunction ensureSafeRolloutsDir(memoriesDir: string, rolloutsDir: string): string {\n  const memoriesReal = fs.realpathSync(memoriesDir);\n\n  try {\n    const stat = fs.lstatSync(rolloutsDir);\n    if (stat.isSymbolicLink()) {\n      throw new Error(\"is a symbolic link\");\n    }\n    if (!stat.isDirectory()) {\n      throw new Error(\"is not a directory\");\n    }\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code !== \"ENOENT\") {\n      throw new Error(\n        `codex-materialize: unsafe ${ROLLOUT_SUBDIR} directory at ${rolloutsDir}: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n      );\n    }\n    fs.mkdirSync(rolloutsDir, { recursive: true });\n  }\n\n  const rolloutsReal = fs.realpathSync(rolloutsDir);\n  if (!isPathInside(memoriesReal, rolloutsReal)) {\n    throw new Error(\n      `codex-materialize: unsafe ${ROLLOUT_SUBDIR} directory at ${rolloutsDir}: resolves outside ${memoriesDir}`,\n    );\n  }\n\n  return rolloutsDir;\n}\n\nfunction readSentinel(sentinelPath: string): SentinelFile | null {\n  if (!fs.existsSync(sentinelPath)) return null;\n  try {\n    const raw = fs.readFileSync(sentinelPath, \"utf-8\");\n    const parsed = JSON.parse(raw) as Partial<SentinelFile>;\n    if (\n      typeof parsed !== \"object\" ||\n      parsed === null ||\n      typeof parsed.version !== \"number\" ||\n      typeof parsed.namespace !== \"string\" ||\n      typeof parsed.updated_at !== \"string\" ||\n      typeof parsed.content_hash !== \"string\"\n    ) {\n      throw new Error(\"invalid sentinel schema\");\n    }\n    return {\n      version: parsed.version,\n      namespace: parsed.namespace,\n      updated_at: parsed.updated_at,\n      content_hash: parsed.content_hash,\n    };\n  } catch (err) {\n    throw new Error(\n      `codex-materialize: corrupt ${SENTINEL_FILE} sentinel at ${sentinelPath}: ${err instanceof Error ? err.message : String(err)}`,\n    );\n  }\n}\n\nfunction writeSentinelAtomically(\n  sentinelPath: string,\n  sentinel: SentinelFile,\n): void {\n  const tmpPath = `${sentinelPath}.${process.pid}.${Date.now()}.${Math.random()\n    .toString(16)\n    .slice(2)}.tmp`;\n  try {\n    fs.writeFileSync(tmpPath, `${JSON.stringify(sentinel, null, 2)}\\n`, {\n      flag: \"wx\",\n    });\n    fs.renameSync(tmpPath, sentinelPath);\n  } catch (err) {\n    try {\n      fs.rmSync(tmpPath, { force: true });\n    } catch {\n      // ignore cleanup failures; preserve the original write/rename error\n    }\n    throw err;\n  }\n}\n\nfunction selectSummaryMemories(memories: MemoryFile[], limit: number): MemoryFile[] {\n  const scored = memories\n    .filter((m) => !m.frontmatter.status || m.frontmatter.status === \"active\")\n    .map((m) => {\n      const confidence = typeof m.frontmatter.confidence === \"number\" ? m.frontmatter.confidence : 0;\n      const importance =\n        typeof m.frontmatter.importance === \"object\" &&\n        m.frontmatter.importance !== null &&\n        typeof (m.frontmatter.importance as { score?: number }).score === \"number\"\n          ? ((m.frontmatter.importance as { score: number }).score ?? 0)\n          : 0;\n      const updated = m.frontmatter.updated ?? m.frontmatter.created ?? \"\";\n      return { memory: m, score: importance * 2 + confidence, updated };\n    });\n\n  scored.sort((a, b) => {\n    if (b.score !== a.score) return b.score - a.score;\n    return b.updated.localeCompare(a.updated);\n  });\n\n  return scored.slice(0, limit).map((s) => s.memory);\n}\n\nfunction oneLineSummary(memory: MemoryFile): string {\n  const raw = memory.content.replace(/\\s+/gu, \" \").trim();\n  if (raw.length <= 160) return raw;\n  return `${raw.slice(0, 157)}...`;\n}\n\nfunction groupMemoriesByCategory(memories: MemoryFile[]): Map<string, MemoryFile[]> {\n  const map = new Map<string, MemoryFile[]>();\n  for (const memory of memories) {\n    if (memory.frontmatter.status && memory.frontmatter.status !== \"active\") continue;\n    const category = memory.frontmatter.category ?? \"unknown\";\n    const list = map.get(category) ?? [];\n    list.push(memory);\n    map.set(category, list);\n  }\n  return map;\n}\n\nfunction pickCategory(memories: MemoryFile[], categories: string[]): MemoryFile[] {\n  const allowed = new Set(categories);\n  return memories.filter(\n    (m) =>\n      (!m.frontmatter.status || m.frontmatter.status === \"active\") &&\n      allowed.has(m.frontmatter.category ?? \"\"),\n  );\n}\n\nfunction collectKeywords(memories: MemoryFile[], category: string, namespace: string): string[] {\n  const keywords = new Set<string>();\n  keywords.add(category);\n  keywords.add(namespace);\n  for (const mem of memories.slice(0, 10)) {\n    for (const tag of mem.frontmatter.tags ?? []) {\n      if (typeof tag === \"string\" && tag.trim().length > 0) keywords.add(tag.trim());\n    }\n  }\n  return [...keywords].slice(0, 16);\n}\n\nfunction pruneRollouts(\n  rollouts: RolloutSummaryInput[],\n  retentionDays: number,\n  now: Date,\n): RolloutSummaryInput[] {\n  // Negative retention → \"infinite retention\" escape hatch. `parseConfig`\n  // clamps the knob to >= 0, so in practice only callers passing a negative\n  // value intentionally get the all-pass behavior.\n  if (retentionDays < 0) return rollouts;\n  // retentionDays === 0 → cutoff is exactly `now`, which prunes every\n  // rollout whose `updatedAt` is in the past (i.e. all of them in practice).\n  // This matches the documented semantics of \"retain for 0 days\".\n  const cutoffMs = now.getTime() - retentionDays * 24 * 60 * 60 * 1000;\n  return rollouts.filter((r) => {\n    if (!r.updatedAt) return true;\n    const t = Date.parse(r.updatedAt);\n    if (!Number.isFinite(t)) return true;\n    return t >= cutoffMs;\n  });\n}\n\nfunction sanitizeSlug(slug: string): string {\n  const sanitized = slug\n    .toLowerCase()\n    .replace(/[^a-z0-9._-]+/gu, \"-\")\n    .slice(0, 96);\n  const trimmed = trimHyphenEdges(sanitized);\n  return trimmed || \"rollout\";\n}\n\nfunction trimHyphenEdges(value: string): string {\n  let start = 0;\n  let end = value.length;\n  while (start < end && value[start] === \"-\") start += 1;\n  while (end > start && value[end - 1] === \"-\") end -= 1;\n  return value.slice(start, end);\n}\n\n/**\n * Whitespace-tokenized approximation used by the budget check. Matches the\n * simple heuristic Codex's usage.rs reporting uses for the \"5000 token\"\n * memory_summary cap.\n */\nexport function approximateTokenCount(text: string): number {\n  const trimmed = text.trim();\n  if (trimmed.length === 0) return 0;\n  return trimmed.split(/\\s+/u).length;\n}\n\n/**\n * Truncate `text` so it fits under `maxTokens` whitespace tokens. We drop\n * trailing lines until we're under the budget and then append an ellipsis\n * marker so downstream readers can see that truncation happened.\n */\nexport function truncateToTokenBudget(text: string, maxTokens: number): string {\n  if (maxTokens <= 0) return \"\";\n  if (approximateTokenCount(text) <= maxTokens) return text;\n\n  // Reserve headroom for the truncation marker so the line-preserving path\n  // can actually fit the marker without flipping to the hard-cut fallback.\n  // Both markers are counted with the same whitespace heuristic the budget\n  // check uses, so the arithmetic stays consistent.\n  const lineMarker = \"_[truncated for summary budget]_\";\n  const tailMarker = \"[truncated]\";\n  const lineMarkerTokens = approximateTokenCount(lineMarker);\n  const tailMarkerTokens = approximateTokenCount(tailMarker);\n\n  const lines = text.split(/\\r?\\n/u);\n  const lineBudget = Math.max(0, maxTokens - lineMarkerTokens);\n  while (lines.length > 0 && approximateTokenCount(lines.join(\"\\n\")) > lineBudget) {\n    lines.pop();\n  }\n  lines.push(lineMarker);\n  let result = lines.join(\"\\n\");\n\n  // If a single huge line still blows the budget, hard-cut tokens. Reserve\n  // space for the tail marker's own token count so the final string stays\n  // within maxTokens rather than sneaking over by a few tokens.\n  if (approximateTokenCount(result) > maxTokens) {\n    const tokens = result.split(/\\s+/u);\n    const keep = Math.max(0, maxTokens - tailMarkerTokens);\n    result = keep > 0 ? `${tokens.slice(0, keep).join(\" \")} ${tailMarker}` : tailMarker;\n  }\n  return result;\n}\n\nfunction computeContentHash(input: {\n  namespace: string;\n  memorySummary: string;\n  memoryMd: string;\n  rawMemories: string;\n  rolloutFiles: Array<{ name: string; body: string }>;\n}): string {\n  const hash = createHash(\"sha256\");\n  hash.update(`v${MATERIALIZE_VERSION}\\n`);\n  hash.update(`namespace=${input.namespace}\\n`);\n  hash.update(\"---memory_summary---\\n\");\n  hash.update(input.memorySummary);\n  hash.update(\"\\n---memory_md---\\n\");\n  hash.update(input.memoryMd);\n  hash.update(\"\\n---raw_memories---\\n\");\n  hash.update(input.rawMemories);\n  const sortedRollouts = [...input.rolloutFiles].sort((a, b) => a.name.localeCompare(b.name));\n  for (const r of sortedRollouts) {\n    hash.update(`\\n---rollout:${r.name}---\\n`);\n    hash.update(r.body);\n  }\n  return hash.digest(\"hex\");\n}\n\n// ─── Stat helper for tests / debugging ─────────────────────────────────────\n\n/**\n * Return basic stats about a materialized memories dir. Useful for tests and\n * debug CLI output. Returns `null` if the dir does not exist.\n */\nexport function describeMemoriesDir(memoriesDir: string): {\n  exists: boolean;\n  hasSentinel: boolean;\n  files: string[];\n  sentinel: SentinelFile | null;\n} | null {\n  if (!fs.existsSync(memoriesDir)) return null;\n  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);\n  const sentinel = readSentinel(sentinelPath);\n  const files: string[] = [];\n  for (const entry of fs.readdirSync(memoriesDir, { withFileTypes: true })) {\n    if (entry.isFile() && OWNED_FILES.has(entry.name)) files.push(entry.name);\n  }\n  const rolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);\n  if (fs.existsSync(rolloutsDir)) {\n    try {\n      for (const entry of fs.readdirSync(rolloutsDir, { withFileTypes: true })) {\n        if (entry.isFile() && entry.name.endsWith(\".md\")) {\n          files.push(path.join(ROLLOUT_SUBDIR, entry.name));\n        }\n      }\n    } catch {\n      // ignore\n    }\n  }\n  return {\n    exists: true,\n    hasSentinel: sentinel !== null,\n    files: files.sort(),\n    sentinel,\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAwCA;AAAA,EACE;AAAA,OACK;AACP,OAAO,QAAQ;AACf,OAAO,UAAU;AA6EV,IAAM,sBAAsB;AAG5B,IAAM,gBAAgB;AAGtB,IAAM,UAAU;AAGvB,IAAM,cAAc,oBAAI,IAAY;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAGD,IAAM,iBAAiB;AAahB,SAAS,wBACd,WACA,SACmB;AACnB,QAAM,SAAS,QAAQ,UAAU;AAAA,IAC/B,MAAM,CAAC,QAAQ,IAAI,KAAK,uBAAuB,GAAG,EAAE;AAAA,IACpD,MAAM,CAAC,QAAQ,IAAI,KAAK,uBAAuB,GAAG,EAAE;AAAA,IACpD,OAAO,CAAC,QAAQ,IAAI,MAAM,uBAAuB,GAAG,EAAE;AAAA,EACxD;AACA,QAAM,cAAc,wBAAwB,QAAQ,SAAS;AAC7D,QAAM,MAAM,QAAQ,OAAO,oBAAI,KAAK;AAIpC,QAAM,mBACJ,OAAO,QAAQ,qBAAqB,YAAY,QAAQ,oBAAoB,IACxE,QAAQ,mBACR;AACN,QAAM,uBACJ,OAAO,QAAQ,yBAAyB,YAAY,QAAQ,wBAAwB,IAChF,QAAQ,uBACR;AAWN,QAAM,eAAe,KAAK,KAAK,aAAa,aAAa;AACzD,QAAM,mBAAmB,aAAa,YAAY;AAClD,MAAI,CAAC,kBAAkB;AAMrB,QAAI,GAAG,WAAW,WAAW,GAAG;AAC9B,aAAO;AAAA,QACL,YAAY,aAAa,eAAe,WAAW;AAAA,MACrD;AAAA,IACF,OAAO;AACL,aAAO;AAAA,QACL,mCAA8B,WAAW;AAAA,MAC3C;AAAA,IACF;AACA,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,OAAO;AAAA,MACP,mBAAmB;AAAA,MACnB,mBAAmB;AAAA,MACnB,cAAc,CAAC;AAAA,MACf,aAAa;AAAA,IACf;AAAA,EACF;AAOA,KAAG,UAAU,aAAa,EAAE,WAAW,KAAK,CAAC;AAG7C,QAAM,WAAW,CAAC,GAAG,QAAQ,QAAQ;AAIrC,QAAM,mBAAmB,QAAQ,qBAAqB;AACtD,QAAM,mBAAmB,QAAQ,oBAAoB,CAAC;AAQtD,QAAM,mBAAmB,cAAc,kBAAkB,sBAAsB,GAAG;AAYlF,QAAM,kBAAyC,CAAC;AAChD,QAAM,YAAY,oBAAI,IAAoB;AAC1C,QAAM,UAAU,CAAC,UAAsC;AACrD,QAAI,CAAC,MAAO,QAAO,OAAO;AAC1B,UAAM,SAAS,KAAK,MAAM,KAAK;AAC/B,WAAO,OAAO,SAAS,MAAM,IAAI,SAAS,OAAO;AAAA,EACnD;AACA,aAAW,KAAK,kBAAkB;AAChC,UAAM,OAAO,GAAG,aAAa,EAAE,IAAI,CAAC;AACpC,UAAM,cAAc,UAAU,IAAI,IAAI;AACtC,QAAI,gBAAgB,QAAW;AAC7B,gBAAU,IAAI,MAAM,gBAAgB,MAAM;AAC1C,sBAAgB,KAAK,CAAC;AACtB;AAAA,IACF;AAKA,UAAM,WAAW,gBAAgB,WAAW;AAC5C,QAAI,QAAQ,EAAE,SAAS,IAAI,QAAQ,SAAS,SAAS,GAAG;AACtD,sBAAgB,WAAW,IAAI;AAAA,IACjC;AAAA,EACF;AAEA,QAAM,gBAAgB,oBAAoB;AAAA,IACxC;AAAA,IACA;AAAA,IACA,kBAAkB;AAAA,IAClB,WAAW;AAAA,EACb,CAAC;AAED,QAAM,WAAW,eAAe;AAAA,IAC9B;AAAA,IACA;AAAA,IACA,kBAAkB;AAAA,EACpB,CAAC;AAGD,QAAM,aAAa,iBAAiB,QAAQ;AAC5C,MAAI,CAAC,WAAW,OAAO;AACrB,UAAM,SAAS,WAAW,OAAO,KAAK,IAAI;AAC1C,WAAO,KAAK,uCAAuC,MAAM,EAAE;AAC3D,UAAM,IAAI,MAAM,0DAA0D,MAAM,EAAE;AAAA,EACpF;AAEA,QAAM,cAAc,kBAAkB,EAAE,SAAS,CAAC;AAElD,QAAM,eAAe,gBAAgB,IAAI,CAAC,OAAO;AAAA,IAC/C,MAAM,GAAG,aAAa,EAAE,IAAI,CAAC;AAAA,IAC7B,MAAM,qBAAqB,CAAC;AAAA,EAC9B,EAAE;AACF,QAAM,kBAAkB,KAAK,KAAK,aAAa,cAAc;AAC7D,QAAM,uBAAuB,IAAI,IAAI,aAAa,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC;AAGpE,QAAM,OAAO,mBAAmB;AAAA,IAC9B;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAED,MAAI,iBAAiB,iBAAiB,MAAM;AAO1C,UAAM,gBAAgB;AAAA,MACpB,KAAK,KAAK,aAAa,mBAAmB;AAAA,MAC1C,KAAK,KAAK,aAAa,WAAW;AAAA,MAClC,KAAK,KAAK,aAAa,iBAAiB;AAAA,MACxC,GAAG,aAAa,IAAI,CAAC,MAAM,KAAK,KAAK,aAAa,gBAAgB,EAAE,IAAI,CAAC;AAAA,IAC3E;AACA,UAAM,aAAa,cAAc,MAAM,CAAC,MAAM,GAAG,WAAW,CAAC,CAAC;AAC9D,UAAM,gBACJ,CAAC,oBACD;AAAA,MACE,sBAAsB,aAAa,eAAe;AAAA,MAClD;AAAA,IACF;AACF,QAAI,cAAc,eAAe;AAC/B,aAAO,QAAQ,uCAAuC,SAAS,mBAAmB;AAClF,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA,OAAO;AAAA,QACP,mBAAmB;AAAA,QACnB,mBAAmB;AAAA,QACnB,cAAc,CAAC;AAAA,QACf,aAAa;AAAA,MACf;AAAA,IACF;AACA,WAAO;AAAA,MACL,gCAAgC,SAAS;AAAA,IAC3C;AAAA,EACF;AAUA,QAAM,SAAS,GAAG,QAAQ,GAAG,IAAI,KAAK,IAAI,EAAE,SAAS,EAAE,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,GAAG,EAAE,CAAC;AACnG,QAAM,SAAS,KAAK,KAAK,aAAa,GAAG,OAAO,IAAI,MAAM,EAAE;AAc5D,QAAM,eAAe,KAAK,KAAK;AAC/B,QAAM,cAAc,KAAK,IAAI;AAC7B,MAAI;AACF,eAAW,SAAS,GAAG,YAAY,aAAa,EAAE,eAAe,KAAK,CAAC,GAAG;AACxE,UAAI,CAAC,MAAM,YAAY,EAAG;AAC1B,UAAI,CAAC,MAAM,KAAK,WAAW,OAAO,EAAG;AACrC,YAAM,YAAY,KAAK,KAAK,aAAa,MAAM,IAAI;AACnD,UAAI;AACF,cAAM,OAAO,GAAG,SAAS,SAAS;AAClC,YAAI,cAAc,KAAK,UAAU,aAAc;AAC/C,WAAG,OAAO,WAAW,EAAE,WAAW,MAAM,OAAO,KAAK,CAAC;AAAA,MACvD,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF,QAAQ;AAAA,EAER;AACA,KAAG,UAAU,QAAQ,EAAE,WAAW,KAAK,CAAC;AACxC,KAAG,UAAU,KAAK,KAAK,QAAQ,cAAc,GAAG,EAAE,WAAW,KAAK,CAAC;AAEnE,QAAM,eAAyB,CAAC;AAEhC,KAAG,cAAc,KAAK,KAAK,QAAQ,mBAAmB,GAAG,aAAa;AACtE,eAAa,KAAK,mBAAmB;AAErC,KAAG,cAAc,KAAK,KAAK,QAAQ,WAAW,GAAG,QAAQ;AACzD,eAAa,KAAK,WAAW;AAE7B,KAAG,cAAc,KAAK,KAAK,QAAQ,iBAAiB,GAAG,WAAW;AAClE,eAAa,KAAK,iBAAiB;AAEnC,aAAW,WAAW,cAAc;AAClC,OAAG,cAAc,KAAK,KAAK,QAAQ,gBAAgB,QAAQ,IAAI,GAAG,QAAQ,IAAI;AAC9E,iBAAa,KAAK,KAAK,KAAK,gBAAgB,QAAQ,IAAI,CAAC;AAAA,EAC3D;AAKA,aAAW,OAAO,CAAC,qBAAqB,aAAa,iBAAiB,GAAG;AACvE,UAAM,MAAM,KAAK,KAAK,QAAQ,GAAG;AACjC,UAAM,OAAO,KAAK,KAAK,aAAa,GAAG;AACvC,OAAG,WAAW,KAAK,IAAI;AAAA,EACzB;AAEA,QAAM,sBAAsB,sBAAsB,aAAa,eAAe;AAO9E,MAAI,kBAAkB;AACpB,QAAI;AACJ,QAAI;AACF,yBAAmB,GAAG,YAAY,qBAAqB,EAAE,eAAe,KAAK,CAAC;AAAA,IAChF,SAAS,KAAK;AACZ,UAAK,IAA8B,SAAS,SAAU,OAAM;AAC5D,yBAAmB,CAAC;AAAA,IACtB;AACA,eAAW,SAAS,kBAAkB;AACpC,UAAI,CAAC,MAAM,OAAO,EAAG;AACrB,UAAI,CAAC,MAAM,KAAK,SAAS,KAAK,EAAG;AACjC,UAAI,qBAAqB,IAAI,MAAM,IAAI,EAAG;AAC1C,UAAI;AACF,WAAG,WAAW,KAAK,KAAK,qBAAqB,MAAM,IAAI,CAAC;AAAA,MAC1D,SAAS,KAAK;AACZ,cAAM,IAAI;AAAA,UACR,4DAA4D,MAAM,IAAI,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,QAC7H;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,aAAW,WAAW,cAAc;AAClC,UAAM,MAAM,KAAK,KAAK,QAAQ,gBAAgB,QAAQ,IAAI;AAC1D,UAAM,OAAO,KAAK,KAAK,qBAAqB,QAAQ,IAAI;AACxD,OAAG,WAAW,KAAK,IAAI;AAAA,EACzB;AAGA,QAAM,WAAyB;AAAA,IAC7B,SAAS;AAAA,IACT;AAAA,IACA,YAAY,IAAI,YAAY;AAAA,IAC5B,cAAc;AAAA,EAChB;AACA,0BAAwB,cAAc,QAAQ;AAE9C,MAAI;AACF,OAAG,OAAO,QAAQ,EAAE,WAAW,MAAM,OAAO,KAAK,CAAC;AAAA,EACpD,QAAQ;AAAA,EAER;AAEA,SAAO;AAAA,IACL,0BAA0B,SAAS,UAAU,aAAa,MAAM,SAAS,KAAK,MAAM,GAAG,EAAE,CAAC;AAAA,EAC5F;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP,mBAAmB;AAAA,IACnB,mBAAmB;AAAA,IACnB;AAAA,IACA,aAAa;AAAA,EACf;AACF;AAOO,SAAS,eAAe,aAAqB,WAAmB,MAAY,oBAAI,KAAK,GAAS;AACnG,KAAG,UAAU,aAAa,EAAE,WAAW,KAAK,CAAC;AAC7C,QAAM,eAAe,KAAK,KAAK,aAAa,aAAa;AACzD,MAAI,GAAG,WAAW,YAAY,GAAG;AAC/B,iBAAa,YAAY;AACzB;AAAA,EACF;AACA,QAAM,WAAyB;AAAA,IAC7B,SAAS;AAAA,IACT;AAAA,IACA,YAAY,IAAI,YAAY;AAAA,IAC5B,cAAc;AAAA,EAChB;AACA,0BAAwB,cAAc,QAAQ;AAChD;AAwBO,SAAS,oBAAoB,KAAmC;AACrE,QAAM,QAAkB,CAAC;AACzB,QAAM,KAAK,kBAAkB;AAC7B,QAAM,KAAK,EAAE;AACb,QAAM,KAAK,eAAe,IAAI,SAAS,GAAG;AAC1C,QAAM,KAAK,kBAAkB;AAC7B,QAAM,KAAK,EAAE;AAEb,QAAM,YAAY,sBAAsB,IAAI,UAAU,EAAE;AACxD,MAAI,UAAU,SAAS,GAAG;AACxB,UAAM,KAAK,iBAAiB;AAC5B,UAAM,KAAK,EAAE;AACb,eAAW,OAAO,WAAW;AAC3B,YAAM,KAAK,KAAK,eAAe,GAAG,CAAC,EAAE;AAAA,IACvC;AACA,UAAM,KAAK,EAAE;AAAA,EACf;AAEA,MAAI,IAAI,iBAAiB,SAAS,GAAG;AACnC,UAAM,KAAK,oBAAoB;AAC/B,UAAM,KAAK,EAAE;AACb,UAAM,SAAS,CAAC,GAAG,IAAI,gBAAgB,EACpC,KAAK,CAAC,GAAG,OAAO,EAAE,aAAa,IAAI,cAAc,EAAE,aAAa,EAAE,CAAC,EACnE,MAAM,GAAG,CAAC;AACb,eAAW,KAAK,QAAQ;AACtB,YAAM,OAAO,EAAE,YAAY,KAAK,EAAE,SAAS,MAAM;AACjD,YAAM,KAAK,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE;AAAA,IACjC;AACA,UAAM,KAAK,EAAE;AAAA,EACf;AAIA,QAAM,SAAS,MAAM,KAAK,IAAI;AAC9B,MAAI,YAAY,OAAO;AACvB,SAAO,YAAY,KAAK,OAAO,YAAY,CAAC,MAAM,KAAM;AACxD,QAAM,OAAO,cAAc,OAAO,SAAS,SAAS,GAAG,OAAO,MAAM,GAAG,SAAS,CAAC;AAAA;AACjF,SAAO,sBAAsB,MAAM,IAAI,SAAS;AAClD;AAKO,SAAS,eAAe,KAA4B;AACzD,QAAM,QAAkB,CAAC;AACzB,QAAM,KAAK,iBAAiB,IAAI,SAAS,EAAE;AAC3C,QAAM,KAAK,UAAU,IAAI,SAAS,EAAE;AACpC,QAAM,KAAK,+CAA+C;AAC1D,QAAM,KAAK,EAAE;AAIb,QAAM,aAAa,wBAAwB,IAAI,QAAQ;AACvD,MAAI,YAAY;AAChB,MAAI,WAAW,SAAS,GAAG;AACzB,UAAM,KAAK,WAAW,SAAS,mCAA8B;AAC7D,UAAM,KAAK,EAAE;AACb,UAAM,KAAK,2BAA2B;AACtC,eAAW,KAAK,IAAI,kBAAkB;AACpC,YAAM;AAAA,QACJ,uBAAuB,aAAa,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,kBAAkB,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,YAAY,EAAE;AAAA,MAC1K;AAAA,IACF;AACA,QAAI,IAAI,iBAAiB,WAAW,GAAG;AACrC,YAAM,KAAK,UAAU;AAAA,IACvB;AACA,UAAM,KAAK,EAAE;AACb,UAAM,KAAK,cAAc;AACzB,UAAM,KAAK,KAAK,IAAI,SAAS,EAAE;AAC/B,UAAM,KAAK,EAAE;AACb,iBAAa;AAAA,EACf,OAAO;AACL,eAAW,CAAC,UAAU,IAAI,KAAK,YAAY;AACzC,YAAM,KAAK,WAAW,SAAS,KAAK,QAAQ,qCAAqC;AACjF,YAAM,KAAK,EAAE;AACb,YAAM,KAAK,2BAA2B;AACtC,YAAM,mBAAmB,IAAI,iBAAiB,MAAM,GAAG,CAAC;AACxD,UAAI,iBAAiB,WAAW,GAAG;AACjC,cAAM,KAAK,UAAU;AAAA,MACvB,OAAO;AACL,mBAAW,KAAK,kBAAkB;AAChC,gBAAM;AAAA,YACJ,uBAAuB,aAAa,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,kBAAkB,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,EAAE,YAAY,EAAE;AAAA,UAC1K;AAAA,QACF;AAAA,MACF;AACA,YAAM,KAAK,EAAE;AACb,YAAM,KAAK,cAAc;AACzB,YAAM,WAAW,gBAAgB,MAAM,UAAU,IAAI,SAAS;AAC9D,YAAM,KAAK,KAAK,SAAS,KAAK,IAAI,CAAC,EAAE;AACrC,YAAM,KAAK,EAAE;AACb,mBAAa;AAAA,IACf;AAAA,EACF;AAEA,QAAM,KAAK,qBAAqB;AAChC,QAAM,QAAQ,aAAa,IAAI,UAAU,CAAC,YAAY,CAAC;AACvD,MAAI,MAAM,WAAW,GAAG;AACtB,UAAM,KAAK,mBAAmB;AAAA,EAChC,OAAO;AACL,eAAW,QAAQ,MAAM,MAAM,GAAG,EAAE,GAAG;AACrC,YAAM,KAAK,KAAK,eAAe,IAAI,CAAC,EAAE;AAAA,IACxC;AAAA,EACF;AACA,QAAM,KAAK,EAAE;AAEb,QAAM,KAAK,uBAAuB;AAClC,QAAM,YAAY,aAAa,IAAI,UAAU,CAAC,QAAQ,YAAY,aAAa,QAAQ,OAAO,CAAC;AAC/F,MAAI,UAAU,WAAW,GAAG;AAC1B,UAAM,KAAK,mBAAmB;AAAA,EAChC,OAAO;AACL,eAAW,OAAO,UAAU,MAAM,GAAG,EAAE,GAAG;AACxC,YAAM,KAAK,KAAK,eAAe,GAAG,CAAC,EAAE;AAAA,IACvC;AAAA,EACF;AACA,QAAM,KAAK,EAAE;AAEb,QAAM,KAAK,uCAAuC;AAClD,QAAM,cAAc,aAAa,IAAI,UAAU,CAAC,YAAY,CAAC;AAC7D,MAAI,YAAY,WAAW,GAAG;AAC5B,UAAM,KAAK,mBAAmB;AAAA,EAChC,OAAO;AACL,eAAW,OAAO,YAAY,MAAM,GAAG,EAAE,GAAG;AAC1C,YAAM,KAAK,KAAK,eAAe,GAAG,CAAC,EAAE;AAAA,IACvC;AAAA,EACF;AACA,QAAM,KAAK,EAAE;AAEb,SAAO,MAAM,KAAK,IAAI;AACxB;AAGO,SAAS,kBAAkB,KAAyC;AACzE,QAAM,SAAS,CAAC,GAAG,IAAI,QAAQ,EAAE,KAAK,CAAC,GAAG,MAAM;AAC9C,UAAM,WAAW,EAAE,YAAY,WAAW,EAAE,YAAY,WAAW;AACnE,UAAM,WAAW,EAAE,YAAY,WAAW,EAAE,YAAY,WAAW;AACnE,WAAO,SAAS,cAAc,QAAQ;AAAA,EACxC,CAAC;AAED,QAAM,QAAkB,CAAC,kBAAkB,IAAI,wCAAmC,EAAE;AACpF,aAAW,OAAO,QAAQ;AACxB,UAAM,KAAK,IAAI;AACf,UAAM,KAAK,GAAG,MAAM;AACpB,UAAM,WAAW,GAAG,YAAY;AAChC,UAAM,UAAU,GAAG,WAAW,GAAG,WAAW;AAC5C,UAAM,KAAK,MAAM,EAAE,KAAK,QAAQ,aAAa,OAAO,GAAG;AACvD,UAAM,KAAK,EAAE;AACb,UAAM,KAAK,IAAI,QAAQ,KAAK,CAAC;AAC7B,UAAM,KAAK,EAAE;AAAA,EACf;AACA,SAAO,MAAM,KAAK,IAAI;AACxB;AAGO,SAAS,qBAAqB,OAAoC;AACvE,QAAM,QAAkB,CAAC;AACzB,QAAM,KAAK,sBAAsB,MAAM,IAAI,EAAE;AAC7C,QAAM,KAAK,EAAE;AACb,QAAM,OAAiB,CAAC;AACxB,MAAI,MAAM,IAAK,MAAK,KAAK,OAAO,MAAM,GAAG,EAAE;AAC3C,MAAI,MAAM,YAAa,MAAK,KAAK,gBAAgB,MAAM,WAAW,EAAE;AACpE,MAAI,MAAM,UAAW,MAAK,KAAK,cAAc,MAAM,SAAS,EAAE;AAC9D,MAAI,MAAM,SAAU,MAAK,KAAK,aAAa,MAAM,QAAQ,EAAE;AAC3D,MAAI,KAAK,SAAS,GAAG;AACnB,UAAM,KAAK,IAAI,KAAK,KAAK,IAAI,CAAC,GAAG;AACjC,UAAM,KAAK,EAAE;AAAA,EACf;AACA,MAAI,MAAM,YAAY,MAAM,SAAS,SAAS,GAAG;AAC/C,UAAM,KAAK,iBAAiB,MAAM,SAAS,KAAK,IAAI,CAAC,EAAE;AACvD,UAAM,KAAK,EAAE;AAAA,EACf;AACA,QAAM,KAAK,MAAM,KAAK,KAAK,CAAC;AAC5B,QAAM,KAAK,EAAE;AACb,SAAO,MAAM,KAAK,IAAI;AACxB;AAoBO,SAAS,iBAAiB,SAAqC;AACpE,QAAM,SAAmB,CAAC;AAC1B,QAAM,QAAQ,QAAQ,MAAM,QAAQ;AAEpC,QAAM,iBAAiB,MAAM,UAAU,CAAC,MAAM,0BAA0B,KAAK,CAAC,CAAC;AAC/E,MAAI,mBAAmB,IAAI;AACzB,WAAO,KAAK,gCAAgC;AAAA,EAC9C,OAAO;AACL,UAAM,OAAO,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,CAAC;AAC/D,QAAI,CAAC,KAAK,KAAK,CAAC,MAAM,iBAAiB,KAAK,CAAC,CAAC,GAAG;AAC/C,aAAO,KAAK,+CAA+C;AAAA,IAC7D;AACA,QAAI,CAAC,KAAK,KAAK,CAAC,MAAM,sBAAsB,KAAK,CAAC,CAAC,GAAG;AACpD,aAAO,KAAK,oDAAoD;AAAA,IAClE;AAAA,EACF;AAEA,QAAM,cAAc,MAAM,OAAO,CAAC,MAAM,qBAAqB,KAAK,CAAC,CAAC;AACpE,MAAI,YAAY,WAAW,GAAG;AAC5B,WAAO,KAAK,+CAA+C;AAAA,EAC7D;AAIA,QAAM,eAAe;AACrB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,QAAI,CAAC,qBAAqB,KAAK,MAAM,CAAC,CAAC,EAAG;AAC1C,QAAI,aAAa;AACjB,QAAI,cAAc;AAClB,aAAS,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACzC,UAAI,aAAa,KAAK,MAAM,CAAC,CAAC,EAAG;AACjC,UAAI,oCAAoC,KAAK,MAAM,CAAC,CAAC,EAAG,cAAa;AACrE,UAAI,uBAAuB,KAAK,MAAM,CAAC,CAAC,EAAG,eAAc;AAAA,IAC3D;AACA,QAAI,CAAC,WAAY,QAAO,KAAK,sBAAsB,IAAI,CAAC,wCAAwC;AAChG,QAAI,CAAC,YAAa,QAAO,KAAK,sBAAsB,IAAI,CAAC,2BAA2B;AAAA,EACtF;AAEA,QAAM,mBAAmB;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,aAAW,MAAM,kBAAkB;AACjC,QAAI,CAAC,MAAM,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,GAAG;AAClC,aAAO,KAAK,6BAA6B,GAAG,MAAM,EAAE;AAAA,IACtD;AAAA,EACF;AAEA,SAAO,EAAE,OAAO,OAAO,WAAW,GAAG,OAAO;AAC9C;AAIA,SAAS,iBAAiB,UAA2B;AACnD,MAAI,YAAY,SAAS,KAAK,EAAE,SAAS,GAAG;AAC1C,WAAO,KAAK,QAAQ,gBAAgB,SAAS,KAAK,CAAC,CAAC;AAAA,EACtD;AACA,QAAM,UAAU,WAAW,YAAY;AACvC,MAAI,WAAW,QAAQ,KAAK,EAAE,SAAS,GAAG;AACxC,WAAO,KAAK,QAAQ,gBAAgB,QAAQ,KAAK,CAAC,CAAC;AAAA,EACrD;AACA,SAAO,KAAK,QAAQ,eAAe,GAAG,QAAQ;AAChD;AAEO,SAAS,wBAAwB,WAA4B;AAClE,SAAO,KAAK,KAAK,iBAAiB,SAAS,GAAG,UAAU;AAC1D;AAEO,SAAS,4BAA4B,WAA6B;AACvE,SAAO,aAAa,KAAK,KAAK,wBAAwB,SAAS,GAAG,aAAa,CAAC,MAAM;AACxF;AAEA,SAAS,mCACP,aACA,eACS;AACT,MAAI;AACJ,MAAI;AACF,cAAU,GAAG,YAAY,aAAa,EAAE,eAAe,KAAK,CAAC;AAAA,EAC/D,QAAQ;AACN,WAAO,cAAc,SAAS;AAAA,EAChC;AACA,aAAW,SAAS,SAAS;AAC3B,QAAI,CAAC,MAAM,OAAO,EAAG;AACrB,QAAI,CAAC,MAAM,KAAK,SAAS,KAAK,EAAG;AACjC,QAAI,CAAC,cAAc,IAAI,MAAM,IAAI,EAAG,QAAO;AAAA,EAC7C;AACA,SAAO;AACT;AAEA,SAAS,aAAa,QAAgB,OAAwB;AAC5D,QAAM,WAAW,KAAK,SAAS,QAAQ,KAAK;AAC5C,SAAO,aAAa,MAAO,CAAC,SAAS,WAAW,IAAI,KAAK,CAAC,KAAK,WAAW,QAAQ;AACpF;AAEA,SAAS,sBAAsB,aAAqB,aAA6B;AAC/E,QAAM,eAAe,GAAG,aAAa,WAAW;AAEhD,MAAI;AACF,UAAM,OAAO,GAAG,UAAU,WAAW;AACrC,QAAI,KAAK,eAAe,GAAG;AACzB,YAAM,IAAI,MAAM,oBAAoB;AAAA,IACtC;AACA,QAAI,CAAC,KAAK,YAAY,GAAG;AACvB,YAAM,IAAI,MAAM,oBAAoB;AAAA,IACtC;AAAA,EACF,SAAS,KAAK;AACZ,QAAK,IAA8B,SAAS,UAAU;AACpD,YAAM,IAAI;AAAA,QACR,6BAA6B,cAAc,iBAAiB,WAAW,KACrE,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CACjD;AAAA,MACF;AAAA,IACF;AACA,OAAG,UAAU,aAAa,EAAE,WAAW,KAAK,CAAC;AAAA,EAC/C;AAEA,QAAM,eAAe,GAAG,aAAa,WAAW;AAChD,MAAI,CAAC,aAAa,cAAc,YAAY,GAAG;AAC7C,UAAM,IAAI;AAAA,MACR,6BAA6B,cAAc,iBAAiB,WAAW,sBAAsB,WAAW;AAAA,IAC1G;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,aAAa,cAA2C;AAC/D,MAAI,CAAC,GAAG,WAAW,YAAY,EAAG,QAAO;AACzC,MAAI;AACF,UAAM,MAAM,GAAG,aAAa,cAAc,OAAO;AACjD,UAAM,SAAS,KAAK,MAAM,GAAG;AAC7B,QACE,OAAO,WAAW,YAClB,WAAW,QACX,OAAO,OAAO,YAAY,YAC1B,OAAO,OAAO,cAAc,YAC5B,OAAO,OAAO,eAAe,YAC7B,OAAO,OAAO,iBAAiB,UAC/B;AACA,YAAM,IAAI,MAAM,yBAAyB;AAAA,IAC3C;AACA,WAAO;AAAA,MACL,SAAS,OAAO;AAAA,MAChB,WAAW,OAAO;AAAA,MAClB,YAAY,OAAO;AAAA,MACnB,cAAc,OAAO;AAAA,IACvB;AAAA,EACF,SAAS,KAAK;AACZ,UAAM,IAAI;AAAA,MACR,8BAA8B,aAAa,gBAAgB,YAAY,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,IAC9H;AAAA,EACF;AACF;AAEA,SAAS,wBACP,cACA,UACM;AACN,QAAM,UAAU,GAAG,YAAY,IAAI,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EACzE,SAAS,EAAE,EACX,MAAM,CAAC,CAAC;AACX,MAAI;AACF,OAAG,cAAc,SAAS,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;AAAA,GAAM;AAAA,MAClE,MAAM;AAAA,IACR,CAAC;AACD,OAAG,WAAW,SAAS,YAAY;AAAA,EACrC,SAAS,KAAK;AACZ,QAAI;AACF,SAAG,OAAO,SAAS,EAAE,OAAO,KAAK,CAAC;AAAA,IACpC,QAAQ;AAAA,IAER;AACA,UAAM;AAAA,EACR;AACF;AAEA,SAAS,sBAAsB,UAAwB,OAA6B;AAClF,QAAM,SAAS,SACZ,OAAO,CAAC,MAAM,CAAC,EAAE,YAAY,UAAU,EAAE,YAAY,WAAW,QAAQ,EACxE,IAAI,CAAC,MAAM;AACV,UAAM,aAAa,OAAO,EAAE,YAAY,eAAe,WAAW,EAAE,YAAY,aAAa;AAC7F,UAAM,aACJ,OAAO,EAAE,YAAY,eAAe,YACpC,EAAE,YAAY,eAAe,QAC7B,OAAQ,EAAE,YAAY,WAAkC,UAAU,WAC5D,EAAE,YAAY,WAAiC,SAAS,IAC1D;AACN,UAAM,UAAU,EAAE,YAAY,WAAW,EAAE,YAAY,WAAW;AAClE,WAAO,EAAE,QAAQ,GAAG,OAAO,aAAa,IAAI,YAAY,QAAQ;AAAA,EAClE,CAAC;AAEH,SAAO,KAAK,CAAC,GAAG,MAAM;AACpB,QAAI,EAAE,UAAU,EAAE,MAAO,QAAO,EAAE,QAAQ,EAAE;AAC5C,WAAO,EAAE,QAAQ,cAAc,EAAE,OAAO;AAAA,EAC1C,CAAC;AAED,SAAO,OAAO,MAAM,GAAG,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM;AACnD;AAEA,SAAS,eAAe,QAA4B;AAClD,QAAM,MAAM,OAAO,QAAQ,QAAQ,SAAS,GAAG,EAAE,KAAK;AACtD,MAAI,IAAI,UAAU,IAAK,QAAO;AAC9B,SAAO,GAAG,IAAI,MAAM,GAAG,GAAG,CAAC;AAC7B;AAEA,SAAS,wBAAwB,UAAmD;AAClF,QAAM,MAAM,oBAAI,IAA0B;AAC1C,aAAW,UAAU,UAAU;AAC7B,QAAI,OAAO,YAAY,UAAU,OAAO,YAAY,WAAW,SAAU;AACzE,UAAM,WAAW,OAAO,YAAY,YAAY;AAChD,UAAM,OAAO,IAAI,IAAI,QAAQ,KAAK,CAAC;AACnC,SAAK,KAAK,MAAM;AAChB,QAAI,IAAI,UAAU,IAAI;AAAA,EACxB;AACA,SAAO;AACT;AAEA,SAAS,aAAa,UAAwB,YAAoC;AAChF,QAAM,UAAU,IAAI,IAAI,UAAU;AAClC,SAAO,SAAS;AAAA,IACd,CAAC,OACE,CAAC,EAAE,YAAY,UAAU,EAAE,YAAY,WAAW,aACnD,QAAQ,IAAI,EAAE,YAAY,YAAY,EAAE;AAAA,EAC5C;AACF;AAEA,SAAS,gBAAgB,UAAwB,UAAkB,WAA6B;AAC9F,QAAM,WAAW,oBAAI,IAAY;AACjC,WAAS,IAAI,QAAQ;AACrB,WAAS,IAAI,SAAS;AACtB,aAAW,OAAO,SAAS,MAAM,GAAG,EAAE,GAAG;AACvC,eAAW,OAAO,IAAI,YAAY,QAAQ,CAAC,GAAG;AAC5C,UAAI,OAAO,QAAQ,YAAY,IAAI,KAAK,EAAE,SAAS,EAAG,UAAS,IAAI,IAAI,KAAK,CAAC;AAAA,IAC/E;AAAA,EACF;AACA,SAAO,CAAC,GAAG,QAAQ,EAAE,MAAM,GAAG,EAAE;AAClC;AAEA,SAAS,cACP,UACA,eACA,KACuB;AAIvB,MAAI,gBAAgB,EAAG,QAAO;AAI9B,QAAM,WAAW,IAAI,QAAQ,IAAI,gBAAgB,KAAK,KAAK,KAAK;AAChE,SAAO,SAAS,OAAO,CAAC,MAAM;AAC5B,QAAI,CAAC,EAAE,UAAW,QAAO;AACzB,UAAM,IAAI,KAAK,MAAM,EAAE,SAAS;AAChC,QAAI,CAAC,OAAO,SAAS,CAAC,EAAG,QAAO;AAChC,WAAO,KAAK;AAAA,EACd,CAAC;AACH;AAEA,SAAS,aAAa,MAAsB;AAC1C,QAAM,YAAY,KACf,YAAY,EACZ,QAAQ,mBAAmB,GAAG,EAC9B,MAAM,GAAG,EAAE;AACd,QAAM,UAAU,gBAAgB,SAAS;AACzC,SAAO,WAAW;AACpB;AAEA,SAAS,gBAAgB,OAAuB;AAC9C,MAAI,QAAQ;AACZ,MAAI,MAAM,MAAM;AAChB,SAAO,QAAQ,OAAO,MAAM,KAAK,MAAM,IAAK,UAAS;AACrD,SAAO,MAAM,SAAS,MAAM,MAAM,CAAC,MAAM,IAAK,QAAO;AACrD,SAAO,MAAM,MAAM,OAAO,GAAG;AAC/B;AAOO,SAAS,sBAAsB,MAAsB;AAC1D,QAAM,UAAU,KAAK,KAAK;AAC1B,MAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,SAAO,QAAQ,MAAM,MAAM,EAAE;AAC/B;AAOO,SAAS,sBAAsB,MAAc,WAA2B;AAC7E,MAAI,aAAa,EAAG,QAAO;AAC3B,MAAI,sBAAsB,IAAI,KAAK,UAAW,QAAO;AAMrD,QAAM,aAAa;AACnB,QAAM,aAAa;AACnB,QAAM,mBAAmB,sBAAsB,UAAU;AACzD,QAAM,mBAAmB,sBAAsB,UAAU;AAEzD,QAAM,QAAQ,KAAK,MAAM,QAAQ;AACjC,QAAM,aAAa,KAAK,IAAI,GAAG,YAAY,gBAAgB;AAC3D,SAAO,MAAM,SAAS,KAAK,sBAAsB,MAAM,KAAK,IAAI,CAAC,IAAI,YAAY;AAC/E,UAAM,IAAI;AAAA,EACZ;AACA,QAAM,KAAK,UAAU;AACrB,MAAI,SAAS,MAAM,KAAK,IAAI;AAK5B,MAAI,sBAAsB,MAAM,IAAI,WAAW;AAC7C,UAAM,SAAS,OAAO,MAAM,MAAM;AAClC,UAAM,OAAO,KAAK,IAAI,GAAG,YAAY,gBAAgB;AACrD,aAAS,OAAO,IAAI,GAAG,OAAO,MAAM,GAAG,IAAI,EAAE,KAAK,GAAG,CAAC,IAAI,UAAU,KAAK;AAAA,EAC3E;AACA,SAAO;AACT;AAEA,SAAS,mBAAmB,OAMjB;AACT,QAAM,OAAO,WAAW,QAAQ;AAChC,OAAK,OAAO,IAAI,mBAAmB;AAAA,CAAI;AACvC,OAAK,OAAO,aAAa,MAAM,SAAS;AAAA,CAAI;AAC5C,OAAK,OAAO,wBAAwB;AACpC,OAAK,OAAO,MAAM,aAAa;AAC/B,OAAK,OAAO,qBAAqB;AACjC,OAAK,OAAO,MAAM,QAAQ;AAC1B,OAAK,OAAO,wBAAwB;AACpC,OAAK,OAAO,MAAM,WAAW;AAC7B,QAAM,iBAAiB,CAAC,GAAG,MAAM,YAAY,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAC1F,aAAW,KAAK,gBAAgB;AAC9B,SAAK,OAAO;AAAA,aAAgB,EAAE,IAAI;AAAA,CAAO;AACzC,SAAK,OAAO,EAAE,IAAI;AAAA,EACpB;AACA,SAAO,KAAK,OAAO,KAAK;AAC1B;AAQO,SAAS,oBAAoB,aAK3B;AACP,MAAI,CAAC,GAAG,WAAW,WAAW,EAAG,QAAO;AACxC,QAAM,eAAe,KAAK,KAAK,aAAa,aAAa;AACzD,QAAM,WAAW,aAAa,YAAY;AAC1C,QAAM,QAAkB,CAAC;AACzB,aAAW,SAAS,GAAG,YAAY,aAAa,EAAE,eAAe,KAAK,CAAC,GAAG;AACxE,QAAI,MAAM,OAAO,KAAK,YAAY,IAAI,MAAM,IAAI,EAAG,OAAM,KAAK,MAAM,IAAI;AAAA,EAC1E;AACA,QAAM,cAAc,KAAK,KAAK,aAAa,cAAc;AACzD,MAAI,GAAG,WAAW,WAAW,GAAG;AAC9B,QAAI;AACF,iBAAW,SAAS,GAAG,YAAY,aAAa,EAAE,eAAe,KAAK,CAAC,GAAG;AACxE,YAAI,MAAM,OAAO,KAAK,MAAM,KAAK,SAAS,KAAK,GAAG;AAChD,gBAAM,KAAK,KAAK,KAAK,gBAAgB,MAAM,IAAI,CAAC;AAAA,QAClD;AAAA,MACF;AAAA,IACF,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,aAAa,aAAa;AAAA,IAC1B,OAAO,MAAM,KAAK;AAAA,IAClB;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-LMXUWAXW.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/chunking.ts"],"sourcesContent":["/**\n * Automatic Chunking with Overlap (Phase 2A)\n *\n * Sentence-boundary chunking for long memories.\n * Preserves coherent thoughts by never splitting mid-sentence.\n */\n\nexport interface ChunkingConfig {\n  /** Target tokens per chunk (default 200) */\n  targetTokens: number;\n  /** Minimum tokens to trigger chunking (default 150) */\n  minTokens: number;\n  /** Number of sentences to overlap between chunks (default 2) */\n  overlapSentences: number;\n}\n\nexport interface Chunk {\n  /** Chunk content */\n  content: string;\n  /** 0-based index */\n  index: number;\n  /** Approximate token count */\n  tokenCount: number;\n}\n\nexport interface ChunkResult {\n  /** Whether content was chunked */\n  chunked: boolean;\n  /** Array of chunks (length 1 if not chunked) */\n  chunks: Chunk[];\n}\n\n/** Default chunking configuration */\nexport const DEFAULT_CHUNKING_CONFIG: ChunkingConfig = {\n  targetTokens: 200,\n  minTokens: 150,\n  overlapSentences: 2,\n};\n\n/**\n * Estimate token count for text.\n * Rough approximation: ~4 characters per token for English.\n */\nfunction estimateTokens(text: string): number {\n  return Math.ceil(text.length / 4);\n}\n\n/**\n * Split text into sentences.\n *\n * The scan stays linear and does not use a backtracking regular expression.\n * ASCII punctuation keeps its old whitespace rule. Unicode terminators also\n * split when the next sentence starts immediately, as in CJK text.\n */\nconst UNICODE_SENTENCE_TERMINATORS = \"。．！？؟۔।॥｡…\";\nconst ASCII_SENTENCE_TERMINATORS = \".!?\";\nconst CJK_NO_SPACE_TERMINATORS = \"。．！？｡\";\nconst CLOSING_PUNCTUATION = \"\\\"'”’»」』）］】〉》)]}\";\nconst DIGITS = \"0123456789０１２３４５６７８９\";\nconst SENTENCE_SEGMENTER =\n  typeof Intl.Segmenter === \"function\"\n    ? new Intl.Segmenter(undefined, { granularity: \"sentence\" })\n    : undefined;\n\nfunction isSentenceTerminator(character: string): boolean {\n  return (\n    ASCII_SENTENCE_TERMINATORS.includes(character) ||\n    UNICODE_SENTENCE_TERMINATORS.includes(character)\n  );\n}\n\nfunction isCjk(character: string): boolean {\n  return /[\\u3000-\\u9fff\\uf900-\\ufaff\\uac00-\\ud7af]/u.test(character);\n}\n\ntype SentenceList = string[] & { separators: string[] };\n\nfunction splitSentencesFallback(text: string): SentenceList {\n  const sentences = [] as unknown as SentenceList;\n  Object.defineProperty(sentences, \"separators\", {\n    value: [],\n    writable: true,\n  });\n  let start = 0;\n  let separator = \"\";\n  for (let i = 0; i < text.length; i++) {\n    const ch = text[i];\n    if (!isSentenceTerminator(ch)) continue;\n\n    let end = i;\n    let hasUnicodeTerminator = UNICODE_SENTENCE_TERMINATORS.includes(ch);\n    while (end + 1 < text.length && isSentenceTerminator(text[end + 1])) {\n      end++;\n      hasUnicodeTerminator ||= UNICODE_SENTENCE_TERMINATORS.includes(text[end]);\n    }\n\n    const isFullwidthDecimal =\n      ch === \"．\" &&\n      DIGITS.includes(text[i - 1] ?? \"\") &&\n      DIGITS.includes(text[end + 1] ?? \"\");\n    while (end + 1 < text.length && CLOSING_PUNCTUATION.includes(text[end + 1])) {\n      end++;\n    }\n\n    const after = text[end + 1];\n    const boundary =\n      !isFullwidthDecimal &&\n      (hasUnicodeTerminator || after === undefined || /\\s/u.test(after));\n    if (boundary) {\n      const sentence = text.slice(start, end + 1).trim();\n      if (sentence.length > 0) {\n        sentences.push(sentence);\n        if (sentences.length > 1) sentences.separators.push(separator);\n      }\n      let nextStart = end + 1;\n      while (nextStart < text.length && /\\s/u.test(text[nextStart])) nextStart++;\n      separator = text.slice(end + 1, nextStart);\n      start = nextStart;\n    }\n    i = end;\n  }\n\n  const remaining = text.slice(start).trim();\n  if (remaining.length > 0) {\n    sentences.push(remaining);\n    if (sentences.length > 1) sentences.separators.push(separator);\n  }\n  return sentences;\n}\nexport function splitSentences(text: string): string[] {\n  const canUseSegmenter =\n    SENTENCE_SEGMENTER !== undefined &&\n    !/\\s/u.test(text) &&\n    [...text].some((character) => UNICODE_SENTENCE_TERMINATORS.includes(character));\n  if (canUseSegmenter) {\n    const segments = Array.from(SENTENCE_SEGMENTER.segment(text), ({ segment }) =>\n      segment.trim(),\n    ).filter((segment) => segment.length > 0) as SentenceList;\n    if (\n      segments.length > 1 &&\n      segments.slice(0, -1).every((segment) =>\n        [...segment].some((character) =>\n          UNICODE_SENTENCE_TERMINATORS.includes(character),\n        ),\n      )\n    ) {\n      Object.defineProperty(segments, \"separators\", {\n        value: Array(segments.length - 1).fill(\"\"),\n        writable: true,\n      });\n      return segments;\n    }\n  }\n  return splitSentencesFallback(text);\n}\n\nfunction endsWithoutSpace(text: string): boolean {\n  let index = text.length - 1;\n  while (index >= 0 && CLOSING_PUNCTUATION.includes(text[index])) index--;\n  const terminator = text[index] ?? \"\";\n  if (CJK_NO_SPACE_TERMINATORS.includes(terminator)) {\n    return isCjk(text[index - 1] ?? \"\");\n  }\n  return terminator === \"…\" && isCjk(text[index - 1] ?? \"\");\n}\nexport function joinSentences(sentences: string[]): string {\n  let result = \"\";\n  const separators = (sentences as Partial<SentenceList>).separators;\n  for (let i = 0; i < sentences.length; i++) {\n    const sentence = sentences[i];\n    if (result.length > 0) {\n      const separator = separators?.[i - 1];\n      result += separator ?? (endsWithoutSpace(result) ? \"\" : \" \");\n    }\n    result += sentence;\n  }\n  return result;\n}\n\n\n/**\n * Chunk content into overlapping segments at sentence boundaries.\n *\n * @param content - The text content to chunk\n * @param config - Chunking configuration\n * @returns ChunkResult with chunks array\n */\nexport function chunkContent(\n  content: string,\n  config: ChunkingConfig = DEFAULT_CHUNKING_CONFIG,\n): ChunkResult {\n  const totalTokens = estimateTokens(content);\n\n  // Don't chunk if below minimum threshold\n  if (totalTokens < config.minTokens) {\n    return {\n      chunked: false,\n      chunks: [{\n        content,\n        index: 0,\n        tokenCount: totalTokens,\n      }],\n    };\n  }\n\n  const sentences = splitSentences(content);\n\n  // If we couldn't split into multiple sentences, don't chunk\n  if (sentences.length <= 1) {\n    return {\n      chunked: false,\n      chunks: [{\n        content,\n        index: 0,\n        tokenCount: totalTokens,\n      }],\n    };\n  }\n\n  const chunks: Chunk[] = [];\n  let currentChunkSentences: string[] = [];\n  let currentTokens = 0;\n  let chunkIndex = 0;\n\n  for (let i = 0; i < sentences.length; i++) {\n    const sentence = sentences[i];\n    const sentenceTokens = estimateTokens(sentence);\n\n    // Add sentence to current chunk\n    currentChunkSentences.push(sentence);\n    currentTokens += sentenceTokens;\n\n    // Check if we've reached target size (with some flexibility)\n    // Allow going over by up to 50% to avoid tiny final chunks\n    const atTarget = currentTokens >= config.targetTokens;\n    const isLastSentence = i === sentences.length - 1;\n\n    if (atTarget || isLastSentence) {\n      // Create chunk from accumulated sentences\n      const chunkContent = joinSentences(currentChunkSentences);\n      chunks.push({\n        content: chunkContent,\n        index: chunkIndex,\n        tokenCount: estimateTokens(chunkContent),\n      });\n      chunkIndex++;\n\n      // Start new chunk with overlap (if not at end)\n      if (!isLastSentence) {\n        // Keep last N sentences for overlap.\n        // Guard: slice(-0) === slice(0), which returns the ENTIRE array\n        // (CLAUDE.md gotcha #27). When overlapSentences is 0, clear fully.\n        const overlapCount = Math.min(config.overlapSentences, currentChunkSentences.length);\n        if (overlapCount <= 0) {\n          currentChunkSentences = [];\n          currentTokens = 0;\n        } else {\n          currentChunkSentences = currentChunkSentences.slice(-overlapCount);\n          currentTokens = currentChunkSentences.reduce((sum, s) => sum + estimateTokens(s), 0);\n        }\n      }\n    }\n  }\n\n  // Only consider it \"chunked\" if we got multiple chunks\n  return {\n    chunked: chunks.length > 1,\n    chunks,\n  };\n}\n\n/**\n * Get parent content by reassembling chunks.\n * Useful for displaying full context when a chunk is retrieved.\n *\n * @param chunks - Array of chunk contents in order\n * @returns Reassembled parent content (with overlap removed)\n */\nexport function reassembleChunks(chunks: string[]): string {\n  if (chunks.length === 0) return \"\";\n  if (chunks.length === 1) return chunks[0];\n\n  // For overlapping chunks, we need to deduplicate\n  // Simple approach: use full first chunk, then non-overlapping parts of subsequent chunks\n  // This is imperfect but handles most cases\n  const result: string[] = [chunks[0]];\n\n  for (let i = 1; i < chunks.length; i++) {\n    const prevChunk = chunks[i - 1];\n    const currChunk = chunks[i];\n\n    // Find overlap by looking for common suffix/prefix\n    // Try to find where the previous chunk ends in the current chunk\n    const prevSentences = splitSentences(prevChunk);\n    const currSentences = splitSentences(currChunk);\n\n    // Find how many sentences from prev are at the start of curr\n    let overlapCount = 0;\n    for (let j = 0; j < Math.min(prevSentences.length, currSentences.length); j++) {\n      // Check if last N sentences of prev match first N sentences of curr\n      const prevEnd = prevSentences.slice(-(j + 1));\n      const currStart = currSentences.slice(0, j + 1);\n\n      if (joinSentences(prevEnd) === joinSentences(currStart)) {\n        overlapCount = j + 1;\n      }\n    }\n\n    // Add non-overlapping portion\n    if (overlapCount > 0 && overlapCount < currSentences.length) {\n      result.push(joinSentences(currSentences.slice(overlapCount)));\n    } else if (overlapCount === 0) {\n      // No detected overlap, add full chunk\n      result.push(currChunk);\n    }\n    // If overlapCount === currSentences.length, skip (fully contained)\n  }\n\n  return joinSentences(result);\n}\n"],"mappings":"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","names":["chunkContent"]}

package/dist/chunk-LTAVSOZW.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/lcm/archive.ts"],"sourcesContent":["import type Database from \"better-sqlite3\";\nimport { log } from \"../logger.js\";\nimport {\n  parseMessageParts,\n  type LcmMessagePartInput,\n  type MessagePartSourceFormat,\n} from \"../message-parts/index.js\";\n\nexport interface LcmMessage {\n  id: number;\n  session_id: string;\n  turn_index: number;\n  role: string;\n  content: string;\n  token_count: number;\n  created_at: string;\n  metadata: string | null;\n}\n\nexport interface LcmSearchResult {\n  turn_index: number;\n  role: string;\n  snippet: string;\n  session_id: string;\n  score: number;\n}\n\nexport interface LcmSearchWithContentResult {\n  id: number;\n  turn_index: number;\n  role: string;\n  content: string;\n  session_id: string;\n  score: number;\n}\n\nexport interface LcmStructuredRecallMatch {\n  part_id: number;\n  message_id: number;\n  turn_index: number;\n  role: string;\n  content: string;\n  session_id: string;\n  kind: string;\n  tool_name: string | null;\n  file_path: string | null;\n  payload: string;\n  score: number;\n}\n\n/** Rough token count: ~4 chars per token. */\nexport function estimateTokens(text: string): number {\n  return Math.ceil(text.length / 4);\n}\n\nconst PUBLIC_LCM_SEARCH_LIMIT = 100;\n\nfunction normalizeSearchLimit(limit: number, fallback = 10, max = PUBLIC_LCM_SEARCH_LIMIT): number {\n  if (typeof limit !== \"number\" || !Number.isFinite(limit)) return fallback;\n  const normalized = Math.floor(limit);\n  if (normalized <= 0) return 0;\n  return Math.min(max, normalized);\n}\n\nfunction escapeSqlLike(value: string): string {\n  return value.replace(/[\\\\%_]/g, (match) => `\\\\${match}`);\n}\n\nexport class LcmArchive {\n  constructor(private readonly db: Database.Database) {}\n\n  /** Append a message to the archive. Returns the row id. */\n  appendMessage(\n    sessionId: string,\n    turnIndex: number,\n    role: string,\n    content: string,\n    metadata?: Record<string, unknown>,\n    parts?: LcmMessagePartInput[],\n  ): number {\n    const tokenCount = estimateTokens(content);\n    const now = new Date().toISOString();\n    const metaJson = metadata ? JSON.stringify(metadata) : null;\n\n    const stmt = this.db.prepare(`\n      INSERT INTO lcm_messages (session_id, turn_index, role, content, token_count, created_at, metadata)\n      VALUES (?, ?, ?, ?, ?, ?, ?)\n    `);\n    const result = stmt.run(sessionId, turnIndex, role, content, tokenCount, now, metaJson);\n    const rowId = Number(result.lastInsertRowid);\n\n    // Keep FTS in sync\n    this.db\n      .prepare(\"INSERT INTO lcm_messages_fts (rowid, content) VALUES (?, ?)\")\n      .run(rowId, content);\n\n    if (parts && parts.length > 0) {\n      this.insertMessageParts(rowId, parts, now);\n    }\n\n    return rowId;\n  }\n\n  /** Append multiple messages in a single transaction. */\n  appendMessages(\n    sessionId: string,\n    messages: Array<{\n      turnIndex: number;\n      role: string;\n      content: string;\n      metadata?: Record<string, unknown>;\n      parts?: LcmMessagePartInput[];\n      rawContent?: unknown;\n      sourceFormat?: MessagePartSourceFormat;\n    }>,\n    options: { messagePartsEnabled?: boolean } = {},\n  ): void {\n    if (messages.length === 0) return;\n    const captureMessageParts = options.messagePartsEnabled !== false;\n\n    const txn = this.db.transaction(() => {\n      for (const msg of messages) {\n        const explicitParts =\n          msg.parts && msg.parts.length > 0 ? msg.parts : undefined;\n        const rawContent = msg.rawContent ?? msg.content;\n        const parts =\n          captureMessageParts\n            ? explicitParts ??\n              parseMessageParts(rawContent, {\n                sourceFormat: msg.sourceFormat,\n                renderedContent: msg.content,\n              })\n            : undefined;\n        this.appendMessage(\n          sessionId,\n          msg.turnIndex,\n          msg.role,\n          msg.content,\n          msg.metadata,\n          parts,\n        );\n      }\n    });\n    txn();\n  }\n\n  insertMessageParts(\n    messageId: number,\n    parts: LcmMessagePartInput[],\n    fallbackCreatedAt: string,\n  ): void {\n    if (parts.length === 0) return;\n    const stmt = this.db.prepare(`\n      INSERT INTO lcm_message_parts (message_id, ordinal, kind, payload, tool_name, file_path, created_at)\n      VALUES (?, ?, ?, ?, ?, ?, ?)\n    `);\n    for (let index = 0; index < parts.length; index += 1) {\n      const part = parts[index]!;\n      const rawPart = part as unknown as Record<string, unknown>;\n      const toolName = part.toolName ?? asNullableString(rawPart.tool_name);\n      const filePath = part.filePath ?? asNullableString(rawPart.file_path);\n      const createdAt = part.createdAt ?? asNullableString(rawPart.created_at);\n      stmt.run(\n        messageId,\n        part.ordinal ?? index,\n        part.kind,\n        JSON.stringify(part.payload ?? {}),\n        toolName ?? null,\n        filePath ?? null,\n        createdAt ?? fallbackCreatedAt,\n      );\n    }\n  }\n\n  /** Get the highest turn_index for a session, or -1 if none. */\n  getMaxTurnIndex(sessionId: string): number {\n    const row = this.db\n      .prepare(\"SELECT MAX(turn_index) as max_turn FROM lcm_messages WHERE session_id = ?\")\n      .get(sessionId) as { max_turn: number | null } | undefined;\n    return row?.max_turn ?? -1;\n  }\n\n  /** Retrieve messages in a turn range (inclusive). */\n  getMessages(sessionId: string, fromTurn: number, toTurn: number): LcmMessage[] {\n    return this.db\n      .prepare(\n        \"SELECT * FROM lcm_messages WHERE session_id = ? AND turn_index >= ? AND turn_index <= ? ORDER BY turn_index\",\n      )\n      .all(sessionId, fromTurn, toTurn) as LcmMessage[];\n  }\n\n  /** Retrieve unsummarized messages (after last leaf summary). */\n  getUnsummarizedMessages(sessionId: string): LcmMessage[] {\n    const lastLeafEnd = this.db\n      .prepare(\n        \"SELECT MAX(msg_end) as last_end FROM lcm_summary_nodes WHERE session_id = ? AND depth = 0\",\n      )\n      .get(sessionId) as { last_end: number | null } | undefined;\n\n    const lastSummarized = lastLeafEnd?.last_end ?? -1;\n    return this.db\n      .prepare(\n        \"SELECT * FROM lcm_messages WHERE session_id = ? AND turn_index > ? ORDER BY turn_index\",\n      )\n      .all(sessionId, lastSummarized) as LcmMessage[];\n  }\n\n  /** Full-text search across all messages. */\n  search(query: string, limit: number, sessionId?: string, sessionPrefix?: string): LcmSearchResult[] {\n    try {\n      const ftsQuery = sanitizeFtsQuery(query);\n      if (!ftsQuery) return [];\n      const cappedLimit = normalizeSearchLimit(limit);\n      if (cappedLimit === 0) return [];\n\n      let sql: string;\n      const params: unknown[] = [ftsQuery];\n\n      if (sessionId) {\n        sql = `\n          SELECT m.turn_index, m.role, snippet(lcm_messages_fts, 0, '>>>', '<<<', '...', 48) as snippet,\n                 m.session_id, rank\n          FROM lcm_messages_fts f\n          JOIN lcm_messages m ON m.id = f.rowid\n          WHERE lcm_messages_fts MATCH ?\n            AND m.session_id = ?\n          ORDER BY rank\n          LIMIT ?\n        `;\n        params.push(sessionId, cappedLimit);\n      } else if (sessionPrefix) {\n        sql = `\n          SELECT m.turn_index, m.role, snippet(lcm_messages_fts, 0, '>>>', '<<<', '...', 48) as snippet,\n                 m.session_id, rank\n          FROM lcm_messages_fts f\n          JOIN lcm_messages m ON m.id = f.rowid\n          WHERE lcm_messages_fts MATCH ?\n            AND m.session_id LIKE ? ESCAPE '\\\\'\n          ORDER BY rank\n          LIMIT ?\n        `;\n        params.push(`${escapeSqlLike(sessionPrefix)}%`, cappedLimit);\n      } else {\n        sql = `\n          SELECT m.turn_index, m.role, snippet(lcm_messages_fts, 0, '>>>', '<<<', '...', 48) as snippet,\n                 m.session_id, rank\n          FROM lcm_messages_fts f\n          JOIN lcm_messages m ON m.id = f.rowid\n          WHERE lcm_messages_fts MATCH ?\n          ORDER BY rank\n          LIMIT ?\n        `;\n        params.push(cappedLimit);\n      }\n\n      const rows = this.db.prepare(sql).all(...params) as Array<{\n        turn_index: number;\n        role: string;\n        snippet: string;\n        session_id: string;\n        rank: number;\n      }>;\n\n      return rows.map((r) => ({\n        turn_index: r.turn_index,\n        role: r.role,\n        snippet: r.snippet,\n        session_id: r.session_id,\n        score: -r.rank, // FTS5 rank is negative; negate for ascending score\n      }));\n    } catch (err) {\n      log.debug(`LCM FTS search error: ${err}`);\n      return [];\n    }\n  }\n\n  /**\n   * Full-text search returning focused excerpts around matching terms.\n   * Returns ~1000-char windows centered on query term matches.\n   * Deduplicates by message id and returns results sorted by FTS rank.\n   */\n  searchWithContent(query: string, limit: number, sessionId?: string, excerptChars = 1000, sessionPrefix?: string): LcmSearchWithContentResult[] {\n    try {\n      const ftsQuery = sanitizeFtsQuery(query);\n      if (!ftsQuery) return [];\n      const cappedLimit = normalizeSearchLimit(limit);\n      if (cappedLimit === 0) return [];\n\n      // Extract content words from query for excerpt windowing\n      const queryWords = query\n        .replace(/[^\\w\\s]/g, \" \")\n        .split(/\\s+/)\n        .filter((w) => w.length > 1 && !STOPWORDS.has(w.toLowerCase()))\n        .map((w) => w.toLowerCase());\n\n      let sql: string;\n      const params: unknown[] = [ftsQuery];\n\n      if (sessionId) {\n        sql = `\n          SELECT m.id, m.turn_index, m.role, m.content, m.session_id, rank\n          FROM lcm_messages_fts f\n          JOIN lcm_messages m ON m.id = f.rowid\n          WHERE lcm_messages_fts MATCH ?\n            AND m.session_id = ?\n          ORDER BY rank\n          LIMIT ?\n        `;\n        params.push(sessionId, cappedLimit);\n      } else if (sessionPrefix) {\n        sql = `\n          SELECT m.id, m.turn_index, m.role, m.content, m.session_id, rank\n          FROM lcm_messages_fts f\n          JOIN lcm_messages m ON m.id = f.rowid\n          WHERE lcm_messages_fts MATCH ?\n            AND m.session_id LIKE ? ESCAPE '\\\\'\n          ORDER BY rank\n          LIMIT ?\n        `;\n        params.push(`${escapeSqlLike(sessionPrefix)}%`, cappedLimit);\n      } else {\n        sql = `\n          SELECT m.id, m.turn_index, m.role, m.content, m.session_id, rank\n          FROM lcm_messages_fts f\n          JOIN lcm_messages m ON m.id = f.rowid\n          WHERE lcm_messages_fts MATCH ?\n          ORDER BY rank\n          LIMIT ?\n        `;\n        params.push(cappedLimit);\n      }\n\n      const rows = this.db.prepare(sql).all(...params) as Array<{\n        id: number;\n        turn_index: number;\n        role: string;\n        content: string;\n        session_id: string;\n        rank: number;\n      }>;\n\n      // Deduplicate by message id (same message may match multiple terms)\n      const seen = new Set<number>();\n      const results: LcmSearchWithContentResult[] = [];\n      for (const r of rows) {\n        if (seen.has(r.id)) continue;\n        seen.add(r.id);\n        results.push({\n          id: r.id,\n          turn_index: r.turn_index,\n          role: r.role,\n          content: extractExcerpt(r.content, queryWords, excerptChars),\n          session_id: r.session_id,\n          score: -r.rank,\n        });\n      }\n      return results;\n    } catch (err) {\n      log.debug(`LCM FTS searchWithContent error: ${err}`);\n      return [];\n    }\n  }\n\n  searchStructuredParts(\n    query: string,\n    limit: number,\n    sessionId?: string,\n  ): LcmStructuredRecallMatch[] {\n    const cappedLimit = Math.max(0, Math.min(20, Math.floor(limit)));\n    if (cappedLimit === 0) return [];\n\n    const fileTerms = extractStructuredFileTerms(query);\n    const toolTerms = extractStructuredToolTerms(query);\n    if (fileTerms.length === 0 && toolTerms.length === 0) return [];\n\n    const matchWhere: string[] = [];\n    const whereParams: unknown[] = [];\n    for (const term of fileTerms) {\n      matchWhere.push(\"(p.file_path = ? OR p.file_path LIKE ? ESCAPE '\\\\')\");\n      whereParams.push(term, `%${escapeLike(term)}%`);\n    }\n    for (const term of toolTerms) {\n      matchWhere.push(\"p.tool_name LIKE ? ESCAPE '\\\\'\");\n      whereParams.push(`%${escapeLike(term)}%`);\n    }\n    const where = [`(${matchWhere.join(\" OR \")})`];\n    if (sessionId) {\n      where.push(\"m.session_id = ?\");\n      whereParams.push(sessionId);\n    }\n    const exactFileScoreParams = [...fileTerms];\n    const sqlParams = [...exactFileScoreParams, ...whereParams, cappedLimit];\n\n    const rows = this.db.prepare(`\n      SELECT\n        p.id AS part_id,\n        p.message_id AS message_id,\n        m.turn_index AS turn_index,\n        m.role AS role,\n        m.content AS content,\n        m.session_id AS session_id,\n        p.kind AS kind,\n        p.tool_name AS tool_name,\n        p.file_path AS file_path,\n        p.payload AS payload,\n        CASE\n          WHEN p.file_path IN (${fileTerms.map(() => \"?\").join(\",\") || \"NULL\"}) THEN 3\n          WHEN p.file_path IS NOT NULL THEN 2\n          WHEN p.tool_name IS NOT NULL THEN 1\n          ELSE 0\n        END AS score\n      FROM lcm_message_parts p\n      JOIN lcm_messages m ON m.id = p.message_id\n      WHERE ${where.join(\" AND \")}\n      ORDER BY score DESC, m.turn_index DESC, p.ordinal ASC\n      LIMIT ?\n    `).all(...sqlParams) as LcmStructuredRecallMatch[];\n\n    return rows;\n  }\n\n  /** Get total message count for a session. */\n  getMessageCount(sessionId: string): number {\n    const row = this.db\n      .prepare(\"SELECT COUNT(*) as cnt FROM lcm_messages WHERE session_id = ?\")\n      .get(sessionId) as { cnt: number };\n    return row.cnt;\n  }\n\n  /** Get total message count across all sessions. */\n  getTotalMessageCount(): number {\n    const row = this.db\n      .prepare(\"SELECT COUNT(*) as cnt FROM lcm_messages\")\n      .get() as { cnt: number };\n    return row.cnt;\n  }\n\n  /** Delete all archived messages for one session. */\n  deleteSession(sessionId: string): number {\n    const txn = this.db.transaction(() => {\n      this.db\n        .prepare(\n          \"DELETE FROM lcm_messages_fts WHERE rowid IN (SELECT id FROM lcm_messages WHERE session_id = ?)\",\n        )\n        .run(sessionId);\n      this.db\n        .prepare(\n          \"DELETE FROM lcm_message_parts WHERE message_id IN (SELECT id FROM lcm_messages WHERE session_id = ?)\",\n        )\n        .run(sessionId);\n      const result = this.db\n        .prepare(\"DELETE FROM lcm_messages WHERE session_id = ?\")\n        .run(sessionId);\n      return result.changes;\n    });\n    return txn();\n  }\n\n  /** Delete all archived messages. */\n  deleteAll(): number {\n    const txn = this.db.transaction(() => {\n      this.db.prepare(\"DELETE FROM lcm_messages_fts\").run();\n      this.db.prepare(\"DELETE FROM lcm_message_parts\").run();\n      const result = this.db.prepare(\"DELETE FROM lcm_messages\").run();\n      return result.changes;\n    });\n    return txn();\n  }\n\n  /** Prune messages older than retentionDays. */\n  pruneOldMessages(retentionDays: number): number {\n    const cutoff = new Date(Date.now() - retentionDays * 86400_000).toISOString();\n\n    const txn = this.db.transaction(() => {\n      // Delete from FTS and child tables first. Some handles may not have\n      // foreign_keys enabled, so do not rely on ON DELETE CASCADE for parts.\n      this.db\n        .prepare(\n          \"DELETE FROM lcm_messages_fts WHERE rowid IN (SELECT id FROM lcm_messages WHERE created_at < ?)\",\n        )\n        .run(cutoff);\n      this.db\n        .prepare(\n          \"DELETE FROM lcm_message_parts WHERE message_id IN (SELECT id FROM lcm_messages WHERE created_at < ?)\",\n        )\n        .run(cutoff);\n\n      const result = this.db\n        .prepare(\"DELETE FROM lcm_messages WHERE created_at < ?\")\n        .run(cutoff);\n      return result.changes;\n    });\n    return txn();\n  }\n}\n\n/**\n * Extract a focused excerpt from content centered on query term matches.\n * Returns a window of ~excerptChars around the first matching term.\n * If content is shorter than excerptChars, returns the full content.\n */\nfunction extractExcerpt(content: string, queryWords: string[], excerptChars: number): string {\n  if (content.length <= excerptChars) return content;\n\n  // Find the earliest position of any query word in the content\n  const contentLower = content.toLowerCase();\n  let bestPos = -1;\n  for (const word of queryWords) {\n    const pos = contentLower.indexOf(word);\n    if (pos !== -1 && (bestPos === -1 || pos < bestPos)) {\n      bestPos = pos;\n    }\n  }\n\n  // If no match found (shouldn't happen for FTS results), return start\n  if (bestPos === -1) {\n    return content.slice(0, excerptChars) + \"...\";\n  }\n\n  // Center the window around the match\n  const halfWindow = Math.floor(excerptChars / 2);\n  let start = Math.max(0, bestPos - halfWindow);\n  let end = Math.min(content.length, start + excerptChars);\n\n  // Adjust start if we hit the end\n  if (end === content.length) {\n    start = Math.max(0, end - excerptChars);\n  }\n\n  // Extend to sentence boundaries if possible\n  if (start > 0) {\n    const sentenceStart = content.lastIndexOf(\". \", start);\n    if (sentenceStart !== -1 && start - sentenceStart < 200) {\n      start = sentenceStart + 2;\n    }\n  }\n  if (end < content.length) {\n    const sentenceEnd = content.indexOf(\". \", end - 1);\n    if (sentenceEnd !== -1 && sentenceEnd - end < 200) {\n      end = sentenceEnd + 1;\n    }\n  }\n\n  const prefix = start > 0 ? \"...\" : \"\";\n  const suffix = end < content.length ? \"...\" : \"\";\n  return prefix + content.slice(start, end) + suffix;\n}\n\nconst STOPWORDS = new Set([\n  \"a\", \"an\", \"the\", \"is\", \"are\", \"was\", \"were\", \"be\", \"been\", \"being\",\n  \"have\", \"has\", \"had\", \"do\", \"does\", \"did\", \"will\", \"would\", \"could\",\n  \"should\", \"may\", \"might\", \"shall\", \"can\", \"to\", \"of\", \"in\", \"for\",\n  \"on\", \"with\", \"at\", \"by\", \"from\", \"as\", \"into\", \"about\", \"between\",\n  \"through\", \"during\", \"before\", \"after\", \"and\", \"but\", \"or\", \"nor\",\n  \"not\", \"so\", \"if\", \"then\", \"than\", \"that\", \"this\", \"it\", \"its\",\n  \"what\", \"which\", \"who\", \"whom\", \"how\", \"when\", \"where\", \"why\",\n  \"all\", \"each\", \"every\", \"both\", \"few\", \"more\", \"most\", \"other\",\n  \"some\", \"such\", \"no\", \"only\", \"own\", \"same\", \"just\", \"very\",\n  \"my\", \"your\", \"his\", \"her\", \"our\", \"their\", \"me\", \"him\", \"us\", \"them\",\n  \"i\", \"you\", \"he\", \"she\", \"we\", \"they\",\n]);\n\nfunction extractStructuredFileTerms(query: string): string[] {\n  const terms = new Set<string>();\n  for (const raw of splitQueryTerms(query)) {\n    const cleaned = trimStructuredQueryTerm(raw);\n    if (\n      cleaned.includes(\"/\") ||\n      hasStructuredFileExtension(cleaned)\n    ) {\n      terms.add(cleaned);\n      const basename = cleaned.split(\"/\").pop();\n      if (basename && basename !== cleaned) terms.add(basename);\n    }\n  }\n  return [...terms].filter((term) => term.length > 1).slice(0, 12);\n}\n\nfunction splitQueryTerms(query: string): string[] {\n  const terms: string[] = [];\n  let term = \"\";\n  for (const char of query.slice(0, 20_000)) {\n    if (char === \" \" || char === \"\\n\" || char === \"\\r\" || char === \"\\t\") {\n      if (term.length > 0) terms.push(term);\n      term = \"\";\n      continue;\n    }\n    term += char;\n    if (term.length > 512) {\n      terms.push(term);\n      term = \"\";\n    }\n  }\n  if (term.length > 0) terms.push(term);\n  return terms;\n}\n\nfunction trimStructuredQueryTerm(raw: string): string {\n  const leading = new Set([\"`\", \"'\", \"\\\"\", \"(\", \"[\", \"{\"]);\n  const trailing = new Set([\"`\", \"'\", \"\\\"\", \",\", \".\", \"?\", \"!\", \":\", \";\", \")\", \"]\", \"}\"]);\n  let start = 0;\n  let end = raw.length;\n  while (start < end && leading.has(raw[start]!)) start += 1;\n  while (end > start && trailing.has(raw[end - 1]!)) end -= 1;\n  return raw.slice(start, end);\n}\n\nfunction hasStructuredFileExtension(value: string): boolean {\n  const slash = value.lastIndexOf(\"/\");\n  const basename = value.slice(slash + 1);\n  const dot = basename.lastIndexOf(\".\");\n  if (dot <= 0 || dot === basename.length - 1) return false;\n  const ext = basename.slice(dot + 1);\n  if (ext.length < 1 || ext.length > 12) return false;\n  for (const char of ext) {\n    const code = char.charCodeAt(0);\n    const valid =\n      (code >= 48 && code <= 57) ||\n      (code >= 65 && code <= 90) ||\n      (code >= 97 && code <= 122) ||\n      char === \"_\" ||\n      char === \"+\" ||\n      char === \"-\";\n    if (!valid) return false;\n  }\n  return true;\n}\n\nfunction extractStructuredToolTerms(query: string): string[] {\n  const lower = query.toLowerCase();\n  if (!/\\b(tool|command|invocation|called|used|ran|read|write|patch|edit|grep|search)\\b/.test(lower)) {\n    return [];\n  }\n  return query\n    .replace(/[^\\w.-]/g, \" \")\n    .split(/\\s+/)\n    .filter((term) => term.length > 2 && !STOPWORDS.has(term.toLowerCase()))\n    .slice(0, 8);\n}\n\nfunction escapeLike(value: string): string {\n  return value.replace(/[\\\\%_]/g, (char) => `\\\\${char}`);\n}\n\nfunction asNullableString(value: unknown): string | null {\n  return typeof value === \"string\" && value.trim().length > 0 ? value : null;\n}\n\n/**\n * Sanitize a query for FTS5 MATCH.\n * Uses OR logic so partial matches rank higher than no matches.\n * Filters stopwords to focus on content words.\n */\nfunction sanitizeFtsQuery(raw: string): string {\n  const words = raw\n    .replace(/[^\\w\\s]/g, \" \")\n    .split(/\\s+/)\n    .filter((w) => w.length > 1 && !STOPWORDS.has(w.toLowerCase()));\n  if (words.length === 0) {\n    // If all words were stopwords, fall back to using all words\n    const allWords = raw.replace(/[^\\w\\s]/g, \" \").split(/\\s+/).filter((w) => w.length > 1);\n    if (allWords.length === 0) return \"\";\n    return allWords.map((w) => `\"${w}\"`).join(\" OR \");\n  }\n  return words.map((w) => `\"${w}\"`).join(\" OR \");\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-P6WBAR27.js.map

@@ -1 +0,0 @@
-{"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 {\n  chunkContent,\n  joinSentences,\n  splitSentences,\n  type Chunk,\n  type ChunkResult,\n} 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\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\nfunction findEmbeddingDimensionMismatch(\n  embeddings: number[][],\n): { expected: number; actual: number; index: number } | null {\n  if (embeddings.length <= 1) return null;\n  const expected = embeddings[0].length;\n  for (let i = 1; i < embeddings.length; i++) {\n    const actual = embeddings[i].length;\n    if (actual !== expected) {\n      return { expected, actual, index: i };\n    }\n  }\n  return null;\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(joinSentences(buffer));\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 = joinSentences(segment);\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  const dimensionMismatch = findEmbeddingDimensionMismatch(embeddings);\n  if (dimensionMismatch) {\n    if (cfg.fallbackToRecursive) {\n      return buildRecursiveFallback(content, cfg);\n    }\n    throw new Error(\n      `Semantic chunking failed: embedding vectors have mismatched dimensions ` +\n        `(${dimensionMismatch.expected} vs ${dimensionMismatch.actual} at index ${dimensionMismatch.index})`,\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 = joinSentences(segment);\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-PBGWYM3H.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/lcm/summarizer.ts"],"sourcesContent":["import { log } from \"../logger.js\";\nimport type { LcmArchive, LcmMessage } from \"./archive.js\";\nimport { LcmDag } from \"./dag.js\";\nimport { estimateTokens } from \"./archive.js\";\nimport { looksLikeMechanicalTelemetryTranscript } from \"../telemetry-transcript.js\";\n\n/** Generate a ULID-like ID (timestamp + random). */\nfunction generateNodeId(): string {\n  const ts = Date.now().toString(36).padStart(9, \"0\");\n  const rand = Math.random().toString(36).slice(2, 10);\n  return `lcm-${ts}-${rand}`;\n}\n\nexport type SummarizeFn = (\n  text: string,\n  targetTokens: number,\n  aggressive: boolean,\n) => Promise<string | null>;\n\nexport interface LcmSummarizerConfig {\n  leafBatchSize: number;\n  rollupFanIn: number;\n  maxDepth: number;\n  deterministicMaxTokens: number;\n  telemetryPrefilterEnabled: boolean;\n}\n\nexport class LcmSummarizer {\n  constructor(\n    private readonly archive: LcmArchive,\n    private readonly dag: LcmDag,\n    private readonly summarizeFn: SummarizeFn,\n    private readonly config: LcmSummarizerConfig,\n  ) {}\n\n  /**\n   * Run incremental summarization for a session.\n   * Creates leaf nodes from unsummarized messages, then rolls up as needed.\n   */\n  async summarizeIncremental(sessionId: string): Promise<number> {\n    let nodesCreated = 0;\n\n    // Phase 1: Create leaf nodes from unsummarized messages\n    const unsummarized = this.archive.getUnsummarizedMessages(sessionId);\n    if (unsummarized.length >= this.config.leafBatchSize) {\n      const batches = chunkArray(unsummarized, this.config.leafBatchSize);\n      // Only process complete batches (leave partial for next time)\n      const completeBatches = unsummarized.length % this.config.leafBatchSize === 0\n        ? batches\n        : batches.slice(0, -1);\n\n      for (const batch of completeBatches) {\n        const created = await this.createLeafNode(sessionId, batch);\n        if (created) nodesCreated++;\n      }\n    }\n\n    // Phase 2: Roll up at each depth level\n    if (nodesCreated > 0) {\n      nodesCreated += await this.rollupAll(sessionId);\n    }\n\n    return nodesCreated;\n  }\n\n  /** Create a leaf summary node (depth 0) from a batch of messages. */\n  private async createLeafNode(\n    sessionId: string,\n    messages: LcmMessage[],\n  ): Promise<boolean> {\n    if (messages.length === 0) return false;\n\n    const combinedText = messages\n      .map((m) => `[${m.role}] ${m.content}`)\n      .join(\"\\n\\n\");\n\n    const inputTokens = estimateTokens(combinedText);\n    const targetTokens = Math.max(64, Math.ceil(inputTokens * 0.25));\n\n    const summary = await this.summarizeWithEscalation(combinedText, targetTokens);\n\n    this.dag.insertNode({\n      id: generateNodeId(),\n      session_id: sessionId,\n      depth: 0,\n      parent_id: null,\n      summary_text: summary.text,\n      token_count: estimateTokens(summary.text),\n      msg_start: messages[0].turn_index,\n      msg_end: messages[messages.length - 1].turn_index,\n      escalation: summary.escalation,\n    });\n\n    return true;\n  }\n\n  /** Roll up orphan nodes at each depth level up to maxDepth. */\n  private async rollupAll(sessionId: string): Promise<number> {\n    let totalCreated = 0;\n\n    for (let depth = 0; depth < this.config.maxDepth; depth++) {\n      const orphans = this.dag.getOrphanNodesAtDepth(sessionId, depth);\n      if (orphans.length < this.config.rollupFanIn) continue;\n\n      const batches = chunkArray(orphans, this.config.rollupFanIn);\n      // Only process complete batches\n      const completeBatches = orphans.length % this.config.rollupFanIn === 0\n        ? batches\n        : batches.slice(0, -1);\n\n      for (const batch of completeBatches) {\n        const combinedText = batch\n          .map((n) => n.summary_text)\n          .join(\"\\n\\n\");\n\n        const inputTokens = estimateTokens(combinedText);\n        const targetTokens = Math.max(64, Math.ceil(inputTokens * 0.25));\n\n        const summary = await this.summarizeWithEscalation(combinedText, targetTokens);\n\n        const parentId = generateNodeId();\n        this.dag.insertNode({\n          id: parentId,\n          session_id: sessionId,\n          depth: depth + 1,\n          parent_id: null,\n          summary_text: summary.text,\n          token_count: estimateTokens(summary.text),\n          msg_start: batch[0].msg_start,\n          msg_end: batch[batch.length - 1].msg_end,\n          escalation: summary.escalation,\n        });\n\n        this.dag.setParent(\n          batch.map((n) => n.id),\n          parentId,\n        );\n\n        totalCreated++;\n      }\n    }\n\n    return totalCreated;\n  }\n\n  /**\n   * Three-level escalation:\n   * 0 = Normal LLM summary\n   * 1 = Aggressive bullet compression\n   * 2 = Deterministic truncation (no LLM)\n   */\n  private async summarizeWithEscalation(\n    text: string,\n    targetTokens: number,\n  ): Promise<{ text: string; escalation: number }> {\n    const { telemetryPrefilterEnabled } = this.config;\n    if (\n      telemetryPrefilterEnabled &&\n      looksLikeMechanicalTelemetryTranscript(text)\n    ) {\n      return {\n        text: deterministicTruncate(\n          text,\n          Math.min(targetTokens, this.config.deterministicMaxTokens),\n        ),\n        escalation: 2,\n      };\n    }\n\n    // Level 0: Normal LLM summary\n    try {\n      const result = await this.summarizeFn(text, targetTokens, false);\n      if (result && estimateTokens(result) <= targetTokens * 1.5) {\n        return { text: result, escalation: 0 };\n      }\n      // If too long, try aggressive\n    } catch (err) {\n      log.debug(`LCM level-0 summary failed: ${err}`);\n    }\n\n    // Level 1: Aggressive bullet compression\n    try {\n      const aggressiveTarget = Math.max(32, Math.ceil(targetTokens * 0.5));\n      const result = await this.summarizeFn(text, aggressiveTarget, true);\n      if (result && estimateTokens(result) <= targetTokens * 1.5) {\n        return { text: result, escalation: 1 };\n      }\n    } catch (err) {\n      log.debug(`LCM level-1 summary failed: ${err}`);\n    }\n\n    // Level 2: Deterministic truncation (guaranteed, no LLM)\n    return {\n      text: deterministicTruncate(text, this.config.deterministicMaxTokens),\n      escalation: 2,\n    };\n  }\n}\n\n/** Deterministic truncation: first and last sentence, plus middle truncation. */\nfunction deterministicTruncate(text: string, maxTokens: number): string {\n  const maxChars = maxTokens * 4;\n  if (text.length <= maxChars) return text;\n\n  const sentences = text.split(/(?<=[.!?])\\s+/).filter((s) => s.length > 0);\n  if (sentences.length <= 2) {\n    return text.slice(0, maxChars);\n  }\n\n  const first = sentences[0];\n  const last = sentences[sentences.length - 1];\n  const budget = maxChars - first.length - last.length - 20;\n\n  if (budget <= 0) {\n    return text.slice(0, maxChars);\n  }\n\n  // Fill from the beginning until budget runs out\n  const middle: string[] = [];\n  let used = 0;\n  for (let i = 1; i < sentences.length - 1; i++) {\n    if (used + sentences[i].length > budget) break;\n    middle.push(sentences[i]);\n    used += sentences[i].length;\n  }\n\n  return `${first} ${middle.join(\" \")}${middle.length < sentences.length - 2 ? \" [...] \" : \" \"}${last}`;\n}\n\nfunction chunkArray<T>(arr: T[], size: number): T[][] {\n  const chunks: T[][] = [];\n  for (let i = 0; i < arr.length; i += size) {\n    chunks.push(arr.slice(i, i + size));\n  }\n  return chunks;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-QKPDN325.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/recall-xray.ts"],"sourcesContent":["/**\n * Recall X-ray snapshot schema (issue #570, PR 1).\n *\n * The X-ray surface is the unified, per-result attribution document that\n * merges the tier that served each memory, its score decomposition, any\n * graph path, an audit entry id, and the exact filter/eligibility ladder\n * that either admitted or rejected each candidate.  This file defines the\n * schema and an in-memory builder + builder-state helper.\n *\n * Scope for PR 1 (this slice):\n *   - Types only + pure builder functions (no IO, no rendering).\n *   - Orchestrator plumbing captures a snapshot when the caller passes\n *     `xrayCapture: true`.  No behavior change when the flag is absent.\n *   - NO new public surfaces here — CLI/HTTP/MCP land in later slices.\n *\n * The shared renderer lands in PR 2 at `recall-xray-renderer.ts`.  Do not\n * fork formatting logic into other surfaces; extend the renderer.\n */\n\nimport { randomUUID } from \"node:crypto\";\n\nimport {\n  normalizeRetrievedMemoryProvenance,\n  type RetrievedMemoryProvenance,\n} from \"./memory-provenance.js\";\nimport type { RecallDisclosure, RecallTierExplain } from \"./types.js\";\nimport { isRecallDisclosure } from \"./types.js\";\n\n/**\n * Estimate token cost of a payload at the rough ~4 chars/token English\n * heuristic.  Non-negative integer; returns 0 for empty / null input.\n * Used by recall surfaces to attach `estimatedTokens` to X-ray results\n * (issue #677 PR 3/4).  Identical to the private heuristic in\n * `chunking.ts`; kept self-contained here so X-ray callers don't pull\n * in chunking internals.\n */\nexport function estimateRecallTokens(text: string | null | undefined): number {\n  if (typeof text !== \"string\" || text.length === 0) return 0;\n  return Math.ceil(text.length / 4);\n}\n\n/**\n * Aggregated per-disclosure token spend summary, computed by the\n * renderer from a snapshot's results.  Non-negative integers.\n */\nexport interface RecallXrayDisclosureSummary {\n  chunk: { count: number; estimatedTokens: number };\n  section: { count: number; estimatedTokens: number };\n  raw: { count: number; estimatedTokens: number };\n  /** Number of results without a recorded disclosure level. */\n  unspecified: { count: number; estimatedTokens: number };\n}\n\n/**\n * Which retrieval source produced a given result.  This is the X-ray\n * tier ladder called out in issue #570 and is *distinct* from the\n * `RetrievalTier` enum (which describes issue #518's tier-explain\n * block).  Keeping the sets separate lets the two observability\n * surfaces evolve without conflating their vocabularies:\n *\n *   - `RetrievalTier`     — direct-answer eligibility ladder.\n *   - `RecallXrayServedBy` — which source materialized each result.\n */\nexport type RecallXrayServedBy =\n  | \"direct-answer\"\n  | \"hybrid\"\n  | \"graph\"\n  | \"recent-scan\"\n  | \"procedural\"\n  | \"review-context\"\n  | \"lcm-file-parts\"\n  | \"lcm-tool-parts\";\n\nexport const RECALL_XRAY_SERVED_BY_VALUES: readonly RecallXrayServedBy[] = [\n  \"direct-answer\",\n  \"hybrid\",\n  \"graph\",\n  \"recent-scan\",\n  \"procedural\",\n  \"review-context\",\n  \"lcm-file-parts\",\n  \"lcm-tool-parts\",\n] as const;\n\nexport function isRecallXrayServedBy(\n  value: unknown,\n): value is RecallXrayServedBy {\n  return (\n    typeof value === \"string\" &&\n    (RECALL_XRAY_SERVED_BY_VALUES as readonly string[]).includes(value)\n  );\n}\n\n/**\n * Score decomposition for a single X-ray result.\n *\n * All fields are optional because different tiers populate different\n * terms: `hybrid` reports vector + bm25 + mmr penalty, `direct-answer`\n * reports importance + tier prior, etc.  The only guaranteed field is\n * `final`, which is the post-combination score used for ordering.\n */\nexport interface RecallXrayScoreDecomposition {\n  vector?: number;\n  bm25?: number;\n  importance?: number;\n  mmrPenalty?: number;\n  tierPrior?: number;\n  /** Additive boost from `reinforcement_count` frontmatter (issue #687 PR 3/4). */\n  reinforcementBoost?: number;\n  final: number;\n}\n\n/**\n * Per-result breakdown inside an X-ray snapshot.\n */\nexport interface RecallXrayResult {\n  memoryId: string;\n  path: string;\n  servedBy: RecallXrayServedBy;\n  scoreDecomposition: RecallXrayScoreDecomposition;\n  graphPath?: string[];\n  /**\n   * Issue #681 PR 3/3 — per-edge confidence values aligned with\n   * `graphPath`. When present, `graphEdgeConfidences[i]` is the\n   * confidence of the edge between `graphPath[i]` and `graphPath[i+1]`,\n   * so the array length is one less than `graphPath`. Legacy edges\n   * without a recorded confidence render as `1.0`. Operators use this\n   * to attribute floor-pruning and PageRank ranking decisions back to\n   * specific edges. The renderer drops the line when the array is\n   * empty or absent so legacy snapshots round-trip cleanly.\n   */\n  graphEdgeConfidences?: number[];\n  /** Graph activation node ids recorded for path-scoring provenance. */\n  pathNodeIds?: string[];\n  /** True when a graph path penalty was applied. */\n  pathPenaltyApplied?: boolean;\n  auditEntryId?: string;\n  /** Human-readable list of filters the candidate *passed*. */\n  admittedBy: string[];\n  /**\n   * First filter that *would have* rejected the candidate, or undefined\n   * when the candidate was admitted without a rejection trace.  When\n   * present, `admittedBy` may still contain filters the candidate passed\n   * before the rejecting gate; consumers should render both.\n   */\n  rejectedBy?: string;\n  /**\n   * Disclosure depth used to render this result's payload (issue #677\n   * PR 3/4).  Mirrors the per-result disclosure already exposed in the\n   * recall response so X-ray consumers can attribute token spend to\n   * the depth that produced it.\n   */\n  disclosure?: RecallDisclosure;\n  /**\n   * Estimated token cost of the rendered payload at the chosen\n   * disclosure depth.  Non-negative integer.  Computed by callers via\n   * `estimateRecallTokens(text)`; the renderer aggregates these into\n   * a per-disclosure summary so operators can see where their budget\n   * went.\n   */\n  estimatedTokens?: number;\n  /**\n   * Free-form tags from the memory's YAML frontmatter (issue #689 PR 3/3).\n   * Populated by the X-ray capture path when the caller passes a `tags`\n   * filter so per-result tags are available alongside the filter trace\n   * in `snapshot.filters`.  Also populated without a filter when the\n   * orchestrator decorates results via `xrayCapture: true` so all X-ray\n   * consumers can inspect memory labels without a separate storage read.\n   * Absent (not `[]`) when the frontmatter has no tags or the memory\n   * could not be read.\n   */\n  tags?: string[];\n  /**\n   * Per-result memory provenance and safety context. Populated by recall\n   * capture when the memory frontmatter was already loaded by retrieval.\n   */\n  provenance?: RetrievedMemoryProvenance;\n  /**\n   * Claim-level provenance span (issue #1575 PR 3). The first source excerpt\n   * backing this memory, surfaced so X-ray consumers can see the literal\n   * utterance each fact derives from alongside retrieval provenance. Absent\n   * when the memory carries no source spans (legacy or `provenance: \"none\"`).\n   */\n  sourceSpan?: {\n    /** Verbatim quote excerpt (capped at write time by `provenance.maxQuoteChars`). */\n    quote: string;\n    /** ISO timestamp of the source turn. */\n    observedAt: string;\n    /** Coarse strength tag from the frontmatter. */\n    provenance: \"verified\" | \"unverified\" | \"none\";\n  };\n  /**\n   * Issue #1577 — per-result trust score, band, and components from the\n   * unified TrustScore recall stage. Present when `trustScoreEnabled` is on.\n   * Quarantined items appear here with `quarantined: true` and a reason so\n   * exclusion never looks like \"no result\" (rule 34).\n   */\n  trust?: {\n    score: number;\n    band: \"high\" | \"medium\" | \"low\" | \"quarantine\";\n    components: Record<string, { value: number; weight: number }>;\n    multiplier: number;\n    quarantined: boolean;\n    quarantineReason?: string;\n  };\n}\n\n/**\n * Trace entry for a filter the orchestrator evaluated during recall.\n * Captures the name of the filter, how many candidates it saw, and how\n * many it let through.  Used by X-ray consumers to render the filter\n * ladder above the per-result breakdown.\n */\nexport interface RecallFilterTrace {\n  name: string;\n  considered: number;\n  admitted: number;\n  /** Optional human-readable reason for any rejections. */\n  reason?: string;\n}\n\n/**\n * Peer-profile injection annotation (issue #679 completion).\n *\n * When `peerProfileRecallEnabled` is true and a peer is registered for\n * the session, the orchestrator injects a `## Peer Profile` section into\n * the recall context. This annotation records which peer was injected and\n * how many profile fields were included so operators can correlate\n * retrieval quality with peer-context enrichment.\n *\n * `null` means no peer profile was injected (peer not registered, feature\n * disabled, or peer has no profile fields).\n */\nexport interface RecallXrayPeerProfileInjection {\n  /** The peer id whose profile was injected. */\n  peerId: string;\n  /**\n   * Number of profile fields included after the `peerProfileRecallMaxFields`\n   * cap was applied.  Zero means the profile existed but had no fields.\n   */\n  fieldsInjected: number;\n}\n\n/**\n * The unified X-ray snapshot.  CLI, HTTP, and MCP surfaces all render\n * this same shape through the shared renderer (CLAUDE.md rule 22).\n */\nexport interface RecallXraySnapshot {\n  /** Stable v1 tag so downstream consumers can version-gate their parsers. */\n  schemaVersion: \"1\";\n  query: string;\n  /** UUID minted per capture; unique across snapshots within a process. */\n  snapshotId: string;\n  /** Epoch milliseconds the snapshot was captured. */\n  capturedAt: number;\n  /**\n   * Tier-explain block from issue #518, carried verbatim when present.\n   * `null` means direct-answer tier did not run (disabled, or another\n   * tier served the query).\n   */\n  tierExplain: RecallTierExplain | null;\n  results: RecallXrayResult[];\n  appliedResultLimit: number;\n  appliedResults: RecallXrayResult[];\n  headroomResults: RecallXrayResult[];\n  filters: RecallFilterTrace[];\n  /**\n   * Character budget accounting for the final assembled recall payload.\n   * `used` is the rendered-context length; `chars` is the cap.  Both are\n   * non-negative integers in `[0, 2**31)`.\n   */\n  budget: { chars: number; used: number };\n  /** Optional session-scope fields carried for downstream filtering. */\n  sessionKey?: string;\n  namespace?: string;\n  traceId?: string;\n  /**\n   * Peer-profile injection metadata (issue #679 completion).\n   * Non-null when `peerProfileRecallEnabled` is true and a peer profile\n   * was successfully injected into this recall's context. `null` (or\n   * absent) means no peer profile was injected.\n   */\n  peerProfileInjection?: RecallXrayPeerProfileInjection | null;\n}\n\n// ─── Builder ──────────────────────────────────────────────────────────────\n\nexport interface BuildXraySnapshotInput {\n  query: string;\n  tierExplain?: RecallTierExplain | null;\n  results?: RecallXrayResult[];\n  appliedResultLimit?: number;\n  appliedResults?: RecallXrayResult[];\n  headroomResults?: RecallXrayResult[];\n  filters?: RecallFilterTrace[];\n  budget?: { chars?: number; used?: number };\n  sessionKey?: string;\n  namespace?: string;\n  traceId?: string;\n  /** Peer-profile injection metadata (issue #679 completion). */\n  peerProfileInjection?: RecallXrayPeerProfileInjection | null;\n  /** Optional injected timestamp for deterministic tests. */\n  now?: () => number;\n  /** Optional injected id generator for deterministic tests. */\n  snapshotIdGenerator?: () => string;\n}\n\n/**\n * Build a `RecallXraySnapshot` from explicit input fields.  Pure\n * function; safe to call from anywhere.  All array/object inputs are\n * shallow-copied so caller mutation after build cannot tear the\n * returned snapshot.\n */\nexport function buildXraySnapshot(\n  input: BuildXraySnapshotInput,\n): RecallXraySnapshot {\n  const now = input.now ?? Date.now;\n  const snapshotIdGenerator = input.snapshotIdGenerator ?? randomUUID;\n\n  const results = Array.isArray(input.results)\n    ? input.results.map(cloneResult)\n    : [];\n  const appliedResults = Array.isArray(input.appliedResults)\n    ? input.appliedResults.map(cloneResult)\n    : [];\n  const headroomResults = Array.isArray(input.headroomResults)\n    ? input.headroomResults.map(cloneResult)\n    : [];\n  const filters = Array.isArray(input.filters)\n    ? input.filters.map(cloneFilter)\n    : [];\n\n  const budgetChars = nonNegativeInt(input.budget?.chars);\n  const budgetUsed = nonNegativeInt(input.budget?.used);\n\n  const tierExplain =\n    input.tierExplain && typeof input.tierExplain === \"object\"\n      ? cloneTierExplain(input.tierExplain)\n      : null;\n\n  // Peer-profile injection annotation (issue #679 completion).\n  // Deep-copy via structuredClone so the caller can't mutate the snapshot\n  // after build. Accept null explicitly (no injection) or a valid object.\n  let peerProfileInjection: RecallXrayPeerProfileInjection | null | undefined;\n  if (input.peerProfileInjection && typeof input.peerProfileInjection === \"object\") {\n    const raw = input.peerProfileInjection;\n    const peerId = nonEmptyString(raw.peerId);\n    if (peerId !== undefined) {\n      peerProfileInjection = {\n        peerId,\n        fieldsInjected: nonNegativeInt(raw.fieldsInjected),\n      };\n    }\n  } else if (input.peerProfileInjection === null) {\n    peerProfileInjection = null;\n  }\n\n  const out: RecallXraySnapshot = {\n    schemaVersion: \"1\",\n    query: typeof input.query === \"string\" ? input.query : \"\",\n    snapshotId: snapshotIdGenerator(),\n    capturedAt: now(),\n    tierExplain,\n    results,\n    appliedResultLimit: nonNegativeInt(input.appliedResultLimit),\n    appliedResults,\n    headroomResults,\n    filters,\n    budget: { chars: budgetChars, used: budgetUsed },\n    sessionKey: nonEmptyString(input.sessionKey),\n    namespace: nonEmptyString(input.namespace),\n    traceId: nonEmptyString(input.traceId),\n  };\n  if (peerProfileInjection !== undefined) {\n    out.peerProfileInjection = peerProfileInjection;\n  }\n  return out;\n}\n\n/**\n * Mutable builder used by the orchestrator to accumulate X-ray fields\n * as recall progresses.  Call `build()` to get the finalized\n * immutable-ish snapshot.  All inputs are validated at insert time so\n * a malformed entry cannot poison the snapshot later.\n */\nexport class RecallXrayBuilder {\n  private readonly query: string;\n  private readonly sessionKey: string | undefined;\n  private namespace: string | undefined;\n  private traceId: string | undefined;\n  private tierExplain: RecallTierExplain | null = null;\n  private readonly results: RecallXrayResult[] = [];\n  private readonly filters: RecallFilterTrace[] = [];\n  private budgetChars = 0;\n  private budgetUsed = 0;\n  private peerProfileInjection: RecallXrayPeerProfileInjection | null | undefined;\n\n  constructor(opts: {\n    query: string;\n    sessionKey?: string;\n    namespace?: string;\n    traceId?: string;\n  }) {\n    this.query = typeof opts.query === \"string\" ? opts.query : \"\";\n    this.sessionKey = nonEmptyString(opts.sessionKey);\n    this.namespace = nonEmptyString(opts.namespace);\n    this.traceId = nonEmptyString(opts.traceId);\n  }\n\n  setNamespace(namespace: string | undefined): void {\n    this.namespace = nonEmptyString(namespace);\n  }\n\n  setTraceId(traceId: string | undefined): void {\n    this.traceId = nonEmptyString(traceId);\n  }\n\n  setTierExplain(tierExplain: RecallTierExplain | null | undefined): void {\n    this.tierExplain =\n      tierExplain && typeof tierExplain === \"object\"\n        ? cloneTierExplain(tierExplain)\n        : null;\n  }\n\n  setBudget(budget: { chars?: number; used?: number }): void {\n    this.budgetChars = nonNegativeInt(budget.chars);\n    this.budgetUsed = nonNegativeInt(budget.used);\n  }\n\n  /**\n   * Record peer-profile injection metadata for this recall snapshot\n   * (issue #679 completion). Pass `null` to explicitly record that no\n   * injection happened (feature enabled but no peer / no profile fields).\n   */\n  setPeerProfileInjection(\n    injection: RecallXrayPeerProfileInjection | null,\n  ): void {\n    this.peerProfileInjection = injection;\n  }\n\n  recordResult(result: RecallXrayResult): void {\n    this.results.push(cloneResult(result));\n  }\n\n  recordFilter(filter: RecallFilterTrace): void {\n    this.filters.push(cloneFilter(filter));\n  }\n\n  build(opts: {\n    now?: () => number;\n    snapshotIdGenerator?: () => string;\n  } = {}): RecallXraySnapshot {\n    return buildXraySnapshot({\n      query: this.query,\n      tierExplain: this.tierExplain,\n      results: this.results,\n      filters: this.filters,\n      budget: { chars: this.budgetChars, used: this.budgetUsed },\n      sessionKey: this.sessionKey,\n      namespace: this.namespace,\n      traceId: this.traceId,\n      peerProfileInjection: this.peerProfileInjection,\n      now: opts.now,\n      snapshotIdGenerator: opts.snapshotIdGenerator,\n    });\n  }\n}\n\n// ─── Internals ────────────────────────────────────────────────────────────\n\nfunction cloneResult(result: RecallXrayResult): RecallXrayResult {\n  if (!result || typeof result !== \"object\") {\n    throw new TypeError(\"RecallXrayResult must be an object\");\n  }\n  if (!isRecallXrayServedBy(result.servedBy)) {\n    throw new TypeError(\n      `RecallXrayResult.servedBy must be one of ${RECALL_XRAY_SERVED_BY_VALUES.join(\n        \", \",\n      )}; got ${JSON.stringify(result.servedBy)}`,\n    );\n  }\n  const memoryId = typeof result.memoryId === \"string\" ? result.memoryId : \"\";\n  const path = typeof result.path === \"string\" ? result.path : \"\";\n  const admittedBy = Array.isArray(result.admittedBy)\n    ? result.admittedBy.filter((x): x is string => typeof x === \"string\")\n    : [];\n  const graphPath = Array.isArray(result.graphPath)\n    ? result.graphPath.filter((x): x is string => typeof x === \"string\")\n    : undefined;\n  // Issue #681 PR 3/3 — per-edge confidences alongside graph path.\n  // Each entry is clamped into [0, 1]; the array is rejected wholesale\n  // when alignment cannot be verified so downstream surfaces can rely\n  // on `graphEdgeConfidences[i]` describing the edge between\n  // `graphPath[i]` and `graphPath[i+1]`.\n  //\n  // Cursor review (#735): the input array length MUST match\n  // `graphPath.length - 1` *before* any per-element filtering. The\n  // earlier implementation skipped non-finite entries via `continue`\n  // and then length-checked the cleaned array — that would silently\n  // shift surviving values to earlier positions. Example: input\n  // `[0.5, NaN, 0.7]` for a 3-edge path would collapse to\n  // `[0.5, 0.7]`, length-check would pass against `expected = 2`, and\n  // the renderer would mis-attribute `0.7` to edge B→C when it really\n  // came from edge C→D. Reject on either size mismatch or any\n  // non-finite entry so misalignment is impossible.\n  let graphEdgeConfidences: number[] | undefined;\n  if (Array.isArray(result.graphEdgeConfidences) && graphPath && graphPath.length > 1) {\n    const expected = graphPath.length - 1;\n    const raw = result.graphEdgeConfidences;\n    if (raw.length === expected) {\n      const cleaned: number[] = [];\n      let allFinite = true;\n      for (const value of raw) {\n        if (typeof value !== \"number\" || !Number.isFinite(value)) {\n          allFinite = false;\n          break;\n        }\n        cleaned.push(Math.min(1, Math.max(0, value)));\n      }\n      if (allFinite) {\n        graphEdgeConfidences = cleaned;\n      }\n    }\n  }\n  const pathNodeIds = Array.isArray(result.pathNodeIds)\n    ? result.pathNodeIds.filter((x): x is string => typeof x === \"string\")\n    : undefined;\n  const pathPenaltyApplied =\n    typeof result.pathPenaltyApplied === \"boolean\"\n      ? result.pathPenaltyApplied\n      : undefined;\n  const auditEntryId = nonEmptyString(result.auditEntryId);\n  const rejectedBy = nonEmptyString(result.rejectedBy);\n  const scoreDecomposition = cloneScoreDecomposition(result.scoreDecomposition);\n  const out: RecallXrayResult = {\n    memoryId,\n    path,\n    servedBy: result.servedBy,\n    scoreDecomposition,\n    admittedBy,\n  };\n  if (graphPath !== undefined) out.graphPath = graphPath;\n  if (graphEdgeConfidences !== undefined) {\n    out.graphEdgeConfidences = graphEdgeConfidences;\n  }\n  if (pathNodeIds !== undefined) out.pathNodeIds = pathNodeIds;\n  if (pathPenaltyApplied !== undefined) out.pathPenaltyApplied = pathPenaltyApplied;\n  if (auditEntryId !== undefined) out.auditEntryId = auditEntryId;\n  if (rejectedBy !== undefined) out.rejectedBy = rejectedBy;\n  // Disclosure + token telemetry (issue #677 PR 3/4).  Only attach when\n  // present and well-formed; unknown disclosure values are dropped so a\n  // bad caller can't poison downstream renderers.  Uses the shared\n  // `isRecallDisclosure` guard so adding a fourth disclosure level\n  // requires touching only `types.ts`.\n  if (isRecallDisclosure(result.disclosure)) {\n    out.disclosure = result.disclosure;\n  }\n  if (\n    typeof result.estimatedTokens === \"number\" &&\n    Number.isFinite(result.estimatedTokens) &&\n    result.estimatedTokens >= 0\n  ) {\n    out.estimatedTokens = Math.floor(result.estimatedTokens);\n  }\n  // Tags from frontmatter (issue #689 PR 3/3).  Normalize identically to\n  // the recall-surface path: trim and drop empty strings so consumers can\n  // compare tags directly without a secondary normalization step.\n  if (Array.isArray(result.tags)) {\n    const cleanedTags = result.tags\n      .filter((t): t is string => typeof t === \"string\")\n      .map((t) => t.trim())\n      .filter((t) => t.length > 0);\n    if (cleanedTags.length > 0) {\n      out.tags = cleanedTags;\n    }\n  }\n  const provenance = normalizeRetrievedMemoryProvenance(result.provenance);\n  if (provenance !== undefined) {\n    out.provenance = provenance;\n  }\n  // Claim-level provenance span (#1575 PR 3). Deep-copy the three scalar\n  // fields so the snapshot returned by getLastXraySnapshot is independent\n  // of the caller's object (matches the structuredClone contract).\n  const ss = result.sourceSpan;\n  if (\n    ss &&\n    typeof ss.quote === \"string\" &&\n    typeof ss.observedAt === \"string\" &&\n    (ss.provenance === \"verified\" ||\n      ss.provenance === \"unverified\" ||\n      ss.provenance === \"none\")\n  ) {\n    out.sourceSpan = {\n      quote: ss.quote,\n      observedAt: ss.observedAt,\n      provenance: ss.provenance,\n    };\n  }\n  // Issue #1577 — preserve the trust projection through the clone so\n  // getLastXraySnapshot surfaces trust score/band/quarantine reason (review\n  // Oqg_o: cloneResult was silently dropping the field). Deep-copy the scalar +\n  // record fields so the snapshot is independent of the caller's object,\n  // matching the structuredClone contract used for every other field above.\n  if (result.trust) {\n    const t = result.trust;\n    const components: Record<string, { value: number; weight: number }> = {};\n    for (const [k, v] of Object.entries(t.components)) {\n      components[k] = { value: v.value, weight: v.weight };\n    }\n    out.trust = {\n      score: t.score,\n      band: t.band,\n      components,\n      multiplier: t.multiplier,\n      quarantined: t.quarantined,\n      ...(t.quarantineReason ? { quarantineReason: t.quarantineReason } : {}),\n    };\n  }\n  return out;\n}\n\n/**\n * Summarize per-disclosure token spend across an X-ray snapshot's\n * results.  Pure helper — used by the markdown renderer to print a\n * \"per-disclosure token spend\" line and exposed for tests / surfaces.\n */\nexport function summarizeDisclosureTokens(\n  results: ReadonlyArray<RecallXrayResult>,\n): RecallXrayDisclosureSummary {\n  const summary: RecallXrayDisclosureSummary = {\n    chunk: { count: 0, estimatedTokens: 0 },\n    section: { count: 0, estimatedTokens: 0 },\n    raw: { count: 0, estimatedTokens: 0 },\n    unspecified: { count: 0, estimatedTokens: 0 },\n  };\n  for (const result of results) {\n    const tokens =\n      typeof result.estimatedTokens === \"number\" &&\n      Number.isFinite(result.estimatedTokens) &&\n      result.estimatedTokens >= 0\n        ? Math.floor(result.estimatedTokens)\n        : 0;\n    const bucket = isRecallDisclosure(result.disclosure)\n      ? result.disclosure\n      : \"unspecified\";\n    summary[bucket].count += 1;\n    summary[bucket].estimatedTokens += tokens;\n  }\n  return summary;\n}\n\nfunction cloneFilter(filter: RecallFilterTrace): RecallFilterTrace {\n  if (!filter || typeof filter !== \"object\") {\n    throw new TypeError(\"RecallFilterTrace must be an object\");\n  }\n  const out: RecallFilterTrace = {\n    name: typeof filter.name === \"string\" ? filter.name : \"\",\n    considered: nonNegativeInt(filter.considered),\n    admitted: nonNegativeInt(filter.admitted),\n  };\n  const reason = nonEmptyString(filter.reason);\n  if (reason !== undefined) out.reason = reason;\n  return out;\n}\n\nfunction cloneScoreDecomposition(\n  value: RecallXrayScoreDecomposition | undefined,\n): RecallXrayScoreDecomposition {\n  if (!value || typeof value !== \"object\") {\n    return { final: 0 };\n  }\n  const out: RecallXrayScoreDecomposition = {\n    final: finiteNumber(value.final) ?? 0,\n  };\n  const vector = finiteNumber(value.vector);\n  if (vector !== undefined) out.vector = vector;\n  const bm25 = finiteNumber(value.bm25);\n  if (bm25 !== undefined) out.bm25 = bm25;\n  const importance = finiteNumber(value.importance);\n  if (importance !== undefined) out.importance = importance;\n  const mmrPenalty = finiteNumber(value.mmrPenalty);\n  if (mmrPenalty !== undefined) out.mmrPenalty = mmrPenalty;\n  const tierPrior = finiteNumber(value.tierPrior);\n  if (tierPrior !== undefined) out.tierPrior = tierPrior;\n  const reinforcementBoost = finiteNumber(value.reinforcementBoost);\n  if (reinforcementBoost !== undefined && reinforcementBoost > 0) {\n    out.reinforcementBoost = reinforcementBoost;\n  }\n  return out;\n}\n\nfunction cloneTierExplain(tierExplain: RecallTierExplain): RecallTierExplain {\n  // Use structuredClone so future RecallTierExplain additions do not\n  // silently share references through hand-enumerated fields.  The\n  // payload is JSON-shaped.\n  return structuredClone(tierExplain);\n}\n\nfunction nonNegativeInt(value: unknown): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return 0;\n  if (value <= 0) return 0;\n  return Math.floor(value);\n}\n\nfunction finiteNumber(value: unknown): number | undefined {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return undefined;\n  return value;\n}\n\nfunction nonEmptyString(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const trimmed = value.trim();\n  if (trimmed.length === 0) return undefined;\n  return trimmed;\n}\n"],"mappings":";;;;;;;;AAmBA,SAAS,kBAAkB;AAiBpB,SAAS,qBAAqB,MAAyC;AAC5E,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAAG,QAAO;AAC1D,SAAO,KAAK,KAAK,KAAK,SAAS,CAAC;AAClC;AAkCO,IAAM,+BAA8D;AAAA,EACzE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,SAAS,qBACd,OAC6B;AAC7B,SACE,OAAO,UAAU,YAChB,6BAAmD,SAAS,KAAK;AAEtE;AA8NO,SAAS,kBACd,OACoB;AACpB,QAAM,MAAM,MAAM,OAAO,KAAK;AAC9B,QAAM,sBAAsB,MAAM,uBAAuB;AAEzD,QAAM,UAAU,MAAM,QAAQ,MAAM,OAAO,IACvC,MAAM,QAAQ,IAAI,WAAW,IAC7B,CAAC;AACL,QAAM,iBAAiB,MAAM,QAAQ,MAAM,cAAc,IACrD,MAAM,eAAe,IAAI,WAAW,IACpC,CAAC;AACL,QAAM,kBAAkB,MAAM,QAAQ,MAAM,eAAe,IACvD,MAAM,gBAAgB,IAAI,WAAW,IACrC,CAAC;AACL,QAAM,UAAU,MAAM,QAAQ,MAAM,OAAO,IACvC,MAAM,QAAQ,IAAI,WAAW,IAC7B,CAAC;AAEL,QAAM,cAAc,eAAe,MAAM,QAAQ,KAAK;AACtD,QAAM,aAAa,eAAe,MAAM,QAAQ,IAAI;AAEpD,QAAM,cACJ,MAAM,eAAe,OAAO,MAAM,gBAAgB,WAC9C,iBAAiB,MAAM,WAAW,IAClC;AAKN,MAAI;AACJ,MAAI,MAAM,wBAAwB,OAAO,MAAM,yBAAyB,UAAU;AAChF,UAAM,MAAM,MAAM;AAClB,UAAM,SAAS,eAAe,IAAI,MAAM;AACxC,QAAI,WAAW,QAAW;AACxB,6BAAuB;AAAA,QACrB;AAAA,QACA,gBAAgB,eAAe,IAAI,cAAc;AAAA,MACnD;AAAA,IACF;AAAA,EACF,WAAW,MAAM,yBAAyB,MAAM;AAC9C,2BAAuB;AAAA,EACzB;AAEA,QAAM,MAA0B;AAAA,IAC9B,eAAe;AAAA,IACf,OAAO,OAAO,MAAM,UAAU,WAAW,MAAM,QAAQ;AAAA,IACvD,YAAY,oBAAoB;AAAA,IAChC,YAAY,IAAI;AAAA,IAChB;AAAA,IACA;AAAA,IACA,oBAAoB,eAAe,MAAM,kBAAkB;AAAA,IAC3D;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ,EAAE,OAAO,aAAa,MAAM,WAAW;AAAA,IAC/C,YAAY,eAAe,MAAM,UAAU;AAAA,IAC3C,WAAW,eAAe,MAAM,SAAS;AAAA,IACzC,SAAS,eAAe,MAAM,OAAO;AAAA,EACvC;AACA,MAAI,yBAAyB,QAAW;AACtC,QAAI,uBAAuB;AAAA,EAC7B;AACA,SAAO;AACT;AAQO,IAAM,oBAAN,MAAwB;AAAA,EACZ;AAAA,EACA;AAAA,EACT;AAAA,EACA;AAAA,EACA,cAAwC;AAAA,EAC/B,UAA8B,CAAC;AAAA,EAC/B,UAA+B,CAAC;AAAA,EACzC,cAAc;AAAA,EACd,aAAa;AAAA,EACb;AAAA,EAER,YAAY,MAKT;AACD,SAAK,QAAQ,OAAO,KAAK,UAAU,WAAW,KAAK,QAAQ;AAC3D,SAAK,aAAa,eAAe,KAAK,UAAU;AAChD,SAAK,YAAY,eAAe,KAAK,SAAS;AAC9C,SAAK,UAAU,eAAe,KAAK,OAAO;AAAA,EAC5C;AAAA,EAEA,aAAa,WAAqC;AAChD,SAAK,YAAY,eAAe,SAAS;AAAA,EAC3C;AAAA,EAEA,WAAW,SAAmC;AAC5C,SAAK,UAAU,eAAe,OAAO;AAAA,EACvC;AAAA,EAEA,eAAe,aAAyD;AACtE,SAAK,cACH,eAAe,OAAO,gBAAgB,WAClC,iBAAiB,WAAW,IAC5B;AAAA,EACR;AAAA,EAEA,UAAU,QAAiD;AACzD,SAAK,cAAc,eAAe,OAAO,KAAK;AAC9C,SAAK,aAAa,eAAe,OAAO,IAAI;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,wBACE,WACM;AACN,SAAK,uBAAuB;AAAA,EAC9B;AAAA,EAEA,aAAa,QAAgC;AAC3C,SAAK,QAAQ,KAAK,YAAY,MAAM,CAAC;AAAA,EACvC;AAAA,EAEA,aAAa,QAAiC;AAC5C,SAAK,QAAQ,KAAK,YAAY,MAAM,CAAC;AAAA,EACvC;AAAA,EAEA,MAAM,OAGF,CAAC,GAAuB;AAC1B,WAAO,kBAAkB;AAAA,MACvB,OAAO,KAAK;AAAA,MACZ,aAAa,KAAK;AAAA,MAClB,SAAS,KAAK;AAAA,MACd,SAAS,KAAK;AAAA,MACd,QAAQ,EAAE,OAAO,KAAK,aAAa,MAAM,KAAK,WAAW;AAAA,MACzD,YAAY,KAAK;AAAA,MACjB,WAAW,KAAK;AAAA,MAChB,SAAS,KAAK;AAAA,MACd,sBAAsB,KAAK;AAAA,MAC3B,KAAK,KAAK;AAAA,MACV,qBAAqB,KAAK;AAAA,IAC5B,CAAC;AAAA,EACH;AACF;AAIA,SAAS,YAAY,QAA4C;AAC/D,MAAI,CAAC,UAAU,OAAO,WAAW,UAAU;AACzC,UAAM,IAAI,UAAU,oCAAoC;AAAA,EAC1D;AACA,MAAI,CAAC,qBAAqB,OAAO,QAAQ,GAAG;AAC1C,UAAM,IAAI;AAAA,MACR,4CAA4C,6BAA6B;AAAA,QACvE;AAAA,MACF,CAAC,SAAS,KAAK,UAAU,OAAO,QAAQ,CAAC;AAAA,IAC3C;AAAA,EACF;AACA,QAAM,WAAW,OAAO,OAAO,aAAa,WAAW,OAAO,WAAW;AACzE,QAAM,OAAO,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO;AAC7D,QAAM,aAAa,MAAM,QAAQ,OAAO,UAAU,IAC9C,OAAO,WAAW,OAAO,CAAC,MAAmB,OAAO,MAAM,QAAQ,IAClE,CAAC;AACL,QAAM,YAAY,MAAM,QAAQ,OAAO,SAAS,IAC5C,OAAO,UAAU,OAAO,CAAC,MAAmB,OAAO,MAAM,QAAQ,IACjE;AAiBJ,MAAI;AACJ,MAAI,MAAM,QAAQ,OAAO,oBAAoB,KAAK,aAAa,UAAU,SAAS,GAAG;AACnF,UAAM,WAAW,UAAU,SAAS;AACpC,UAAM,MAAM,OAAO;AACnB,QAAI,IAAI,WAAW,UAAU;AAC3B,YAAM,UAAoB,CAAC;AAC3B,UAAI,YAAY;AAChB,iBAAW,SAAS,KAAK;AACvB,YAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,GAAG;AACxD,sBAAY;AACZ;AAAA,QACF;AACA,gBAAQ,KAAK,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,KAAK,CAAC,CAAC;AAAA,MAC9C;AACA,UAAI,WAAW;AACb,+BAAuB;AAAA,MACzB;AAAA,IACF;AAAA,EACF;AACA,QAAM,cAAc,MAAM,QAAQ,OAAO,WAAW,IAChD,OAAO,YAAY,OAAO,CAAC,MAAmB,OAAO,MAAM,QAAQ,IACnE;AACJ,QAAM,qBACJ,OAAO,OAAO,uBAAuB,YACjC,OAAO,qBACP;AACN,QAAM,eAAe,eAAe,OAAO,YAAY;AACvD,QAAM,aAAa,eAAe,OAAO,UAAU;AACnD,QAAM,qBAAqB,wBAAwB,OAAO,kBAAkB;AAC5E,QAAM,MAAwB;AAAA,IAC5B;AAAA,IACA;AAAA,IACA,UAAU,OAAO;AAAA,IACjB;AAAA,IACA;AAAA,EACF;AACA,MAAI,cAAc,OAAW,KAAI,YAAY;AAC7C,MAAI,yBAAyB,QAAW;AACtC,QAAI,uBAAuB;AAAA,EAC7B;AACA,MAAI,gBAAgB,OAAW,KAAI,cAAc;AACjD,MAAI,uBAAuB,OAAW,KAAI,qBAAqB;AAC/D,MAAI,iBAAiB,OAAW,KAAI,eAAe;AACnD,MAAI,eAAe,OAAW,KAAI,aAAa;AAM/C,MAAI,mBAAmB,OAAO,UAAU,GAAG;AACzC,QAAI,aAAa,OAAO;AAAA,EAC1B;AACA,MACE,OAAO,OAAO,oBAAoB,YAClC,OAAO,SAAS,OAAO,eAAe,KACtC,OAAO,mBAAmB,GAC1B;AACA,QAAI,kBAAkB,KAAK,MAAM,OAAO,eAAe;AAAA,EACzD;AAIA,MAAI,MAAM,QAAQ,OAAO,IAAI,GAAG;AAC9B,UAAM,cAAc,OAAO,KACxB,OAAO,CAAC,MAAmB,OAAO,MAAM,QAAQ,EAChD,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,EACnB,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC;AAC7B,QAAI,YAAY,SAAS,GAAG;AAC1B,UAAI,OAAO;AAAA,IACb;AAAA,EACF;AACA,QAAM,aAAa,mCAAmC,OAAO,UAAU;AACvE,MAAI,eAAe,QAAW;AAC5B,QAAI,aAAa;AAAA,EACnB;AAIA,QAAM,KAAK,OAAO;AAClB,MACE,MACA,OAAO,GAAG,UAAU,YACpB,OAAO,GAAG,eAAe,aACxB,GAAG,eAAe,cACjB,GAAG,eAAe,gBAClB,GAAG,eAAe,SACpB;AACA,QAAI,aAAa;AAAA,MACf,OAAO,GAAG;AAAA,MACV,YAAY,GAAG;AAAA,MACf,YAAY,GAAG;AAAA,IACjB;AAAA,EACF;AAMA,MAAI,OAAO,OAAO;AAChB,UAAM,IAAI,OAAO;AACjB,UAAM,aAAgE,CAAC;AACvE,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,EAAE,UAAU,GAAG;AACjD,iBAAW,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,QAAQ,EAAE,OAAO;AAAA,IACrD;AACA,QAAI,QAAQ;AAAA,MACV,OAAO,EAAE;AAAA,MACT,MAAM,EAAE;AAAA,MACR;AAAA,MACA,YAAY,EAAE;AAAA,MACd,aAAa,EAAE;AAAA,MACf,GAAI,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,iBAAiB,IAAI,CAAC;AAAA,IACvE;AAAA,EACF;AACA,SAAO;AACT;AAOO,SAAS,0BACd,SAC6B;AAC7B,QAAM,UAAuC;AAAA,IAC3C,OAAO,EAAE,OAAO,GAAG,iBAAiB,EAAE;AAAA,IACtC,SAAS,EAAE,OAAO,GAAG,iBAAiB,EAAE;AAAA,IACxC,KAAK,EAAE,OAAO,GAAG,iBAAiB,EAAE;AAAA,IACpC,aAAa,EAAE,OAAO,GAAG,iBAAiB,EAAE;AAAA,EAC9C;AACA,aAAW,UAAU,SAAS;AAC5B,UAAM,SACJ,OAAO,OAAO,oBAAoB,YAClC,OAAO,SAAS,OAAO,eAAe,KACtC,OAAO,mBAAmB,IACtB,KAAK,MAAM,OAAO,eAAe,IACjC;AACN,UAAM,SAAS,mBAAmB,OAAO,UAAU,IAC/C,OAAO,aACP;AACJ,YAAQ,MAAM,EAAE,SAAS;AACzB,YAAQ,MAAM,EAAE,mBAAmB;AAAA,EACrC;AACA,SAAO;AACT;AAEA,SAAS,YAAY,QAA8C;AACjE,MAAI,CAAC,UAAU,OAAO,WAAW,UAAU;AACzC,UAAM,IAAI,UAAU,qCAAqC;AAAA,EAC3D;AACA,QAAM,MAAyB;AAAA,IAC7B,MAAM,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO;AAAA,IACtD,YAAY,eAAe,OAAO,UAAU;AAAA,IAC5C,UAAU,eAAe,OAAO,QAAQ;AAAA,EAC1C;AACA,QAAM,SAAS,eAAe,OAAO,MAAM;AAC3C,MAAI,WAAW,OAAW,KAAI,SAAS;AACvC,SAAO;AACT;AAEA,SAAS,wBACP,OAC8B;AAC9B,MAAI,CAAC,SAAS,OAAO,UAAU,UAAU;AACvC,WAAO,EAAE,OAAO,EAAE;AAAA,EACpB;AACA,QAAM,MAAoC;AAAA,IACxC,OAAO,aAAa,MAAM,KAAK,KAAK;AAAA,EACtC;AACA,QAAM,SAAS,aAAa,MAAM,MAAM;AACxC,MAAI,WAAW,OAAW,KAAI,SAAS;AACvC,QAAM,OAAO,aAAa,MAAM,IAAI;AACpC,MAAI,SAAS,OAAW,KAAI,OAAO;AACnC,QAAM,aAAa,aAAa,MAAM,UAAU;AAChD,MAAI,eAAe,OAAW,KAAI,aAAa;AAC/C,QAAM,aAAa,aAAa,MAAM,UAAU;AAChD,MAAI,eAAe,OAAW,KAAI,aAAa;AAC/C,QAAM,YAAY,aAAa,MAAM,SAAS;AAC9C,MAAI,cAAc,OAAW,KAAI,YAAY;AAC7C,QAAM,qBAAqB,aAAa,MAAM,kBAAkB;AAChE,MAAI,uBAAuB,UAAa,qBAAqB,GAAG;AAC9D,QAAI,qBAAqB;AAAA,EAC3B;AACA,SAAO;AACT;AAEA,SAAS,iBAAiB,aAAmD;AAI3E,SAAO,gBAAgB,WAAW;AACpC;AAEA,SAAS,eAAe,OAAwB;AAC9C,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACjE,MAAI,SAAS,EAAG,QAAO;AACvB,SAAO,KAAK,MAAM,KAAK;AACzB;AAEA,SAAS,aAAa,OAAoC;AACxD,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACjE,SAAO;AACT;AAEA,SAAS,eAAe,OAAoC;AAC1D,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,QAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,SAAO;AACT;","names":[]}