@remnic/core 1.1.30 → 9.3.515

package/dist/{chunk-NN2DKE4T.js.map → chunk-4H5ZJHEN.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/source-attribution.ts"],"sourcesContent":["/**\n * Inline Source Attribution Protocol (issue #369)\n *\n * Extracted facts carry provenance inline inside the fact body, so the\n * citation survives hostile memory text, copy/paste, and LLM quoting. This\n * complements — never replaces — the YAML frontmatter provenance stored on\n * disk.\n *\n * Default format (matches issue #369 proposal):\n *\n *   The foo service uses Redis for rate limiting. [Source: agent=planner, session=abc123, ts=2026-04-10T14:25:07Z]\n *\n * Key properties:\n *   - Inline (part of the body, not metadata).\n *   - Compact (typically <80 chars of overhead per fact).\n *   - Machine-parseable by a single regex.\n *   - Opt-in via `inlineSourceAttributionEnabled` config flag (default off\n *     for backwards compatibility with existing downstream consumers).\n *   - Legacy facts without a citation remain fully readable.\n *\n * The format template is configurable via `inlineSourceAttributionFormat`\n * with supported placeholders:\n *\n *   {agent}     — principal / agent identifier\n *   {session}   — full session key (colon-delimited)\n *   {sessionId} — short stable session id (trailing component)\n *   {ts}        — extraction timestamp (ISO 8601)\n *   {date}      — extraction date (YYYY-MM-DD)\n *\n * Any privacy-sensitive identifiers should be normalized before being passed\n * to `formatCitation` — the helper treats them as opaque strings.\n */\n\n/** Default citation format template (matches issue #369). */\nexport const DEFAULT_CITATION_FORMAT =\n  \"[Source: agent={agent}, session={sessionId}, ts={ts}]\";\n\n/** Sentinel value used when a provenance field is missing. */\nexport const CITATION_UNKNOWN = \"unknown\";\n\nexport interface CitationContext {\n  /** Principal / agent identifier (e.g. resolved via resolvePrincipal). */\n  agent?: string;\n  /** Full session key (e.g. \"agent:planner:main\"). */\n  session?: string;\n  /**\n   * Opaque short session id. Derived from the trailing component of the\n   * session key when not provided explicitly. Use this for compact formats\n   * that do not need the full colon-delimited session key.\n   */\n  sessionId?: string;\n  /** Extraction timestamp as an ISO 8601 string. */\n  ts?: string;\n}\n\nexport interface ParsedCitation {\n  /** Agent identifier parsed from the citation (never crashes on malformed input). */\n  agent?: string;\n  /** Session identifier parsed from the citation. */\n  session?: string;\n  /** Extraction timestamp parsed from the citation. */\n  ts?: string;\n  /** The full matched citation substring. */\n  raw: string;\n}\n\n/**\n * Regex that matches the default `[Source: agent=X, session=Y, ts=Z]` shape\n * as well as human-edited variants (extra whitespace, reordered fields,\n * subset of fields). Matches non-greedily so it can be anchored anywhere in\n * the text. Kept as a getter factory so callers do not share regex state.\n */\nfunction defaultCitationMatcher(): RegExp {\n  return /\\[Source:\\s*([^\\]\\n]+?)\\]/gi;\n}\n\n/**\n * Derive a short session id from a full session key.\n * Falls back to the raw session string if no colon is present.\n */\nexport function deriveSessionId(session: string | undefined): string | undefined {\n  if (!session) return undefined;\n  const trimmed = session.trim();\n  if (trimmed.length === 0) return undefined;\n  const parts = trimmed.split(\":\").filter((p) => p.length > 0);\n  if (parts.length === 0) return trimmed;\n  return parts[parts.length - 1];\n}\n\n/**\n * Format an inline citation tag using the provided template.\n *\n * Missing context fields fall back to {@link CITATION_UNKNOWN} — the caller\n * should always get a non-empty, parseable tag.\n *\n * Uses a single-pass substitution so that values which themselves contain\n * placeholder syntax (e.g. an agent literally named `\"{ts}\"`) cannot be\n * re-interpreted by subsequent replacement steps. Each placeholder slot\n * receives exactly one lookup and the substituted value is treated as\n * terminal text, not template source.\n */\nexport function formatCitation(\n  ctx: CitationContext,\n  template: string = DEFAULT_CITATION_FORMAT,\n): string {\n  const session = ctx.session ?? \"\";\n  const sessionId = ctx.sessionId ?? deriveSessionId(session) ?? CITATION_UNKNOWN;\n  const ts = ctx.ts ?? CITATION_UNKNOWN;\n  const agent = ctx.agent && ctx.agent.trim().length > 0 ? ctx.agent : CITATION_UNKNOWN;\n  const date = ts && ts !== CITATION_UNKNOWN ? ts.slice(0, 10) : CITATION_UNKNOWN;\n  const sessionForTemplate = session.trim().length > 0 ? session : CITATION_UNKNOWN;\n\n  // Map from recognised placeholder names to their resolved value. Unknown\n  // placeholder names are left intact (returning the original `{name}`).\n  const values: Record<string, string> = {\n    agent,\n    session: sessionForTemplate,\n    sessionId,\n    ts,\n    date,\n  };\n\n  // Single-pass scan: replace every recognised `{name}` in one sweep so that\n  // substituted values cannot themselves be treated as template source on a\n  // subsequent pass. The replacer-function form also guarantees that `$` /\n  // `$&` / `$1` sequences inside values are emitted literally.\n  return template.replace(/\\{([a-zA-Z_][\\w]*)\\}/g, (match, name: string) => {\n    return Object.prototype.hasOwnProperty.call(values, name)\n      ? values[name]!\n      : match;\n  });\n}\n\n/**\n * Returns true if the text already carries at least one citation marker.\n * Safe to call on any string — never throws.\n */\nexport function hasCitation(text: string): boolean {\n  if (typeof text !== \"string\" || text.length === 0) return false;\n  return defaultCitationMatcher().test(text);\n}\n\n/**\n * Escape a string for use as a regex literal.\n */\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Escape a single character for use INSIDE a character class `[...]`.\n * Special chars inside character classes: `]`, `\\`, `^`, `-`.\n */\nfunction escapeRegExpCharClass(ch: string): string {\n  if (ch === \"]\") return \"\\\\]\";\n  if (ch === \"\\\\\") return \"\\\\\\\\\";\n  if (ch === \"^\") return \"\\\\^\";\n  if (ch === \"-\") return \"\\\\-\";\n  // Other regex meta chars are NOT special inside [...] but escaping them is safe.\n  return escapeRegExp(ch);\n}\n\n/**\n * Build a per-placeholder token pattern that excludes newlines, whitespace,\n * and any punctuation characters used as inner separators in the template.\n *\n * This prevents a placeholder span from consuming separator bytes and\n * matching strings that cross separator boundaries in user-supplied content.\n *\n * @param nonWordSepChars - Set of non-word (non-alphanumeric, non-`_`) chars\n *   extracted from the inner separator literals of the template.\n */\nfunction buildTokenPattern(nonWordSepChars: Set<string>): string {\n  // Always exclude newlines and whitespace.\n  const base = \"\\\\n\\\\s\";\n  if (nonWordSepChars.size === 0) {\n    // No inner separator punctuation — the placeholder spans the full space\n    // between prefix and suffix. Fall back to a generous no-newline match.\n    return `[^\\\\n]+?`;\n  }\n  const escaped = [...nonWordSepChars].map(escapeRegExpCharClass).join(\"\");\n  return `[^${base}${escaped}]+?`;\n}\n\n/** Regex that matches a `{placeholder}` token inside a template string. */\nconst PLACEHOLDER_REGEX = /\\{[a-zA-Z_][\\w]*\\}/g;\n\n/**\n * Build a regex that matches a citation produced by the given template.\n *\n * The approach depends on the shape of the template:\n *\n *  - **Normal case (non-empty literal prefix or suffix).** Anchor the match\n *    on the outer literal frame and reconstruct the interior as\n *    `interToken + sep + interToken + sep + ... + sep + lastToken`.\n *    All **intermediate** per-placeholder tokens exclude the combined set of\n *    non-word separator characters used between any two adjacent placeholders,\n *    preventing a value from consuming a separator and crossing placeholder\n *    boundaries.  The **last** token is only required to avoid newlines because\n *    it is terminated by the literal suffix anchor — this lets placeholder\n *    values that legitimately contain a separator character be recognised (e.g.\n *    an ISO-8601 timestamp `2026-04-10T14:25:07Z` in `[src:{agent}:{ts}]`\n *    where `:` is the inter-placeholder separator).  A template like\n *    `[src:{agent}/{sessionId}@{date}]` emits\n *    `\\[src:[^\\n\\s/@]+?\\/[^\\n\\s/@]+?@[^\\n]+?\\]` so that `[src:foo/bar]`\n *    is NOT matched (wrong separator count), `[src:foo/bar/extra@2026]`\n *    is NOT matched (intermediate token crosses a `/` boundary), and\n *    `[src:planner/main@2026-04-10]` IS matched correctly.\n *\n *  - **Placeholder-bounded with whitespace separator.** Both prefix and\n *    suffix are empty and the separator literal(s) between placeholders\n *    contain at least one whitespace character (e.g. `{source}: {content}`,\n *    `{agent} {sessionId}`). A whitespace-containing separator produces\n *    output that is visually indistinguishable from ordinary prose, so the\n *    safe strategy is to require a **hard bracket/paren/angle delimiter** on\n *    both sides of the reconstructed match. Prose almost never places\n *    `[...]` / `(...)` / `<...>` around a phrase, so this yields clean\n *    false-positive rejection.\n *\n *  - **Placeholder-bounded with compact (non-whitespace) separator.** Both\n *    prefix and suffix are empty and the separator literal(s) contain NO\n *    whitespace (e.g. `{agent}:{sessionId}`, `{agent}/{sessionId}`).\n *    `formatCitation` emits a compact token like `planner:main` with no\n *    surrounding delimiters, so the bracket strategy cannot detect it.\n *    Instead, the pattern requires that the entire token is bordered by\n *    whitespace or a bracket/paren/angle on each side:\n *\n *      `(?:(?<=[\\[\\(\\<])|(?<!\\S))[\\w.-]+<sep>[\\w.-]+(?:(?=[\\]\\)\\>])|(?!\\S))`\n *\n *    This accepts `planner:main` when it appears standalone or inside a\n *    bracket-wrapped token, and rejects `host:80` embedded inside a URL like\n *    `http://host:80` because `host` is immediately preceded by `/`\n *    (non-whitespace, non-bracket).\n *\n *  - **All-placeholder case (no literals between placeholders either).** No\n *    reliable regex can be built — a template like `{agent}{sessionId}`\n *    contains no anchor characters. Returns `null`; {@link\n *    hasCitationForTemplate} treats this as \"cannot detect\" and returns\n *    false, falling back on explicit sentinel/format detection only for the\n *    default `[Source: ...]` shape.\n *\n * Returns `null` when the template has no placeholders (fully-literal\n * citation, handled by the string-equality fast path in {@link\n * hasCitationForTemplate}) **or** when the template is entirely placeholder-\n * only with no literal content whatsoever.\n */\nfunction templateMatcher(template: string): RegExp | null {\n  // Split around all {placeholder} tokens.\n  const parts = template.split(PLACEHOLDER_REGEX);\n  if (parts.length <= 1) return null;\n\n  const prefix = parts[0] ?? \"\";\n  const suffix = parts[parts.length - 1] ?? \"\";\n\n  // Normal case: at least one literal frame on the outside.\n  // Tighten the per-placeholder token so it cannot consume separator\n  // characters and match strings that cross separator boundaries\n  // (Finding 3 — Uru3).\n  if (prefix.length > 0 || suffix.length > 0) {\n    const escapedPrefix = escapeRegExp(prefix);\n    const escapedSuffix = escapeRegExp(suffix);\n\n    // Inner parts: literal separators that sit between adjacent placeholders.\n    // For `[src:{agent}/{sessionId}@{date}]`, parts = [\"[src:\", \"/\", \"@\", \"]\"]\n    // so innerParts = [\"/\", \"@\"].\n    const innerParts = parts.slice(1, -1);\n\n    // Collect only the non-word (punctuation/symbol) characters from each\n    // inner separator so alphabetic separator text (unlikely but valid) does\n    // not exclude letters from the per-placeholder token pattern.\n    const nonWordSepChars = new Set<string>();\n    for (const sep of innerParts) {\n      for (const ch of sep) {\n        if (!/\\w/.test(ch)) {\n          nonWordSepChars.add(ch);\n        }\n      }\n    }\n\n    // All intermediate tokens (every placeholder except the last) use the\n    // combined exclusion so they cannot cross placeholder boundaries.\n    //\n    // The LAST token is different: it is terminated by the literal suffix anchor\n    // (e.g. `\\]`), so it does not need to exclude inner-separator characters.\n    // Dropping that restriction lets placeholder values that legitimately contain\n    // a separator character (e.g. an ISO-8601 timestamp `2026-04-10T14:25:07Z`\n    // in template `[src:{agent}:{ts}]`) be recognised correctly instead of\n    // producing false-negative misses that trigger duplicate citation injection.\n    //\n    // Only the LAST token is relaxed.  Intermediate tokens keep the combined\n    // exclusion so that cross-boundary false positives are still rejected\n    // (e.g. `[src:foo/bar/extra@2026-04-11]` for `[src:{a}/{b}@{c}]`).\n    const interToken = buildTokenPattern(nonWordSepChars);\n    // Last token: terminated by suffix anchor — exclude only newlines.\n    const lastToken = buildTokenPattern(new Set<string>());\n\n    // Reconstruct the interior: interToken sep interToken sep ... sep lastToken\n    // (or just lastToken when there are no inner separators at all).\n    const middle =\n      innerParts.length === 0\n        ? lastToken\n        : interToken +\n          innerParts\n            .slice(0, -1)\n            .map((sep) => escapeRegExp(sep) + interToken)\n            .join(\"\") +\n          escapeRegExp(innerParts[innerParts.length - 1]!) +\n          lastToken;\n\n    const pattern = escapedPrefix + middle + escapedSuffix;\n    return new RegExp(pattern, \"i\");\n  }\n\n  // Placeholder-bounded case: prefix and suffix are both empty.\n  const middleLiterals = parts.slice(1, -1);\n  const hasNonEmptyMiddle = middleLiterals.some((p) => p.length > 0);\n  if (!hasNonEmptyMiddle) {\n    // All-placeholder template with no literal content. Impossible to anchor\n    // reliably without sentinel markers; signal the caller.\n    return null;\n  }\n\n  // Identifier token: one or more word chars, dots, dashes, or colons.\n  // Colons are included to allow timestamp values like \"10:30\" or session\n  // keys like \"agent:planner:main\" inside compact placeholder-bounded\n  // templates.  URL-like fragments (`http://host:80`) are still rejected\n  // because the lead anchor requires whitespace or a bracket immediately\n  // before the first id-token group (`http` is preceded by `/`).\n  const idToken = \"[\\\\w.:-]+\";\n  const body =\n    idToken +\n    middleLiterals.map((lit) => escapeRegExp(lit) + idToken).join(\"\");\n\n  const separatorText = middleLiterals.join(\"\");\n  if (/\\s/.test(separatorText)) {\n    // Separator contains whitespace: the emitted citation looks like ordinary\n    // prose (e.g. `planner main`). Require a hard bracket/paren/angle\n    // delimiter on both sides to prevent false matches on English text.\n    const opener = \"[\\\\[\\\\(\\\\<]\";\n    const closer = \"[\\\\]\\\\)\\\\>]\";\n    return new RegExp(opener + body + closer, \"i\");\n  }\n\n  // Separator is compact (no whitespace): `formatCitation` emits a token like\n  // `planner:main` without surrounding delimiters. The challenge is that the\n  // same token shape also matches ordinary hyphenated or slashed prose words\n  // (e.g. `long-term`, `docs/setup`), causing `hasCitationForTemplate` to\n  // return true on uncited fact bodies and silently suppress citation injection\n  // from `attachCitation`.\n  //\n  // Fix (Finding 1): tighten the trail anchor so a bare compact token is only\n  // accepted when it sits at the very end of the string (possibly followed by\n  // optional trailing whitespace or a newline). Since `attachCitation` always\n  // appends the citation at the trimmed end of the fact body, a real citation\n  // token will always appear at the tail. Prose like `\"long-term solution\"`\n  // has `long-term` in the middle of the string (followed by ` solution`), so\n  // the end-of-string anchor rejects it — no false positive, no silent drop.\n  //\n  // The lead anchor still accepts either a bracket opener or a whitespace\n  // boundary (or start of string), so `\"Fact. planner:main\"` and standalone\n  // `\"planner:main\"` are both detected after the first attachment pass.\n  //\n  // Bracket-wrapped form (e.g. `[planner:main]`) is also accepted via the\n  // opener/closer pair — bracket still takes precedence over end-of-string.\n  //\n  // Example — why `http://host:80` does NOT match:\n  //   Trying to match `host:80`: the char before `h` is `/` (non-whitespace,\n  //   non-bracket), so `(?<=[\\[\\(\\<])` and `(?<!\\S)` both fail ⟹ no match.\n  //   Trying to match `http:...`: after `http:` the next chars are `//` which\n  //   are not `[\\w.-]+`, so the second id-token group fails ⟹ no match.\n  const leadAnchor = \"(?:(?<=[\\\\[\\\\(\\\\<])|(?<!\\\\S))\";\n  // Trail: either a bracket closer (for `[token]` shape) or end-of-string\n  // optionally preceded by whitespace. The `(?!\\S)` is deliberately removed\n  // so that a compact token in the MIDDLE of a sentence does not match.\n  const trailAnchor = \"(?:(?=[\\\\]\\\\)\\\\>])|(?=\\\\s*$))\";\n  return new RegExp(leadAnchor + body + trailAnchor, \"i\");\n}\n\n/**\n * Returns true if `text` already carries a citation produced by `template`\n * **or** by the default `[Source: ...]` format (for facts that were tagged\n * before a config change).\n *\n * Use this instead of {@link hasCitation} whenever the caller has access to\n * the configured `inlineSourceAttributionFormat`.\n *\n * All-placeholder templates such as `{agent}{sessionId}` have no literal\n * content to anchor on and therefore cannot be reliably detected without\n * dedicated sentinel markers. In that case the function returns `false` —\n * callers that need idempotent dedup for such templates should either adopt\n * a template with literal delimiters (recommended) or rely on the default\n * `[Source: ...]` marker detection which is always available via\n * {@link hasCitation}.\n */\nexport function hasCitationForTemplate(text: string, template: string): boolean {\n  if (typeof text !== \"string\" || text.length === 0) return false;\n  // Always accept the default format as a fallback so facts tagged before a\n  // configuration change are not double-tagged on reprocessing.\n  if (hasCitation(text)) return true;\n  // If the configured template matches the default, we're done.\n  //\n  // Known limitation (Thread 2 — Codex P2): this fast path exits without\n  // checking whether the content carries a citation from a DIFFERENT custom\n  // template that was active before the config was changed back to the default.\n  // Such a fact would be detected by `hasCitation` above only if the prior\n  // custom template happened to match the default `[Source: ...]` pattern.\n  // In practice, template changes mid-stream are rare, and the false-negative\n  // (missing an old custom citation) produces a benign duplicate citation rather\n  // than data loss. A full fix would require storing the citation template used\n  // at write time in the frontmatter and checking that here.\n  if (template === DEFAULT_CITATION_FORMAT) return false;\n\n  // Fully-literal template (no placeholders): exact inclusion check.\n  if (!PLACEHOLDER_REGEX.test(template)) {\n    // Reset lastIndex because PLACEHOLDER_REGEX is declared with /g.\n    PLACEHOLDER_REGEX.lastIndex = 0;\n    return text.includes(template);\n  }\n  // Reset lastIndex after the .test() probe above.\n  PLACEHOLDER_REGEX.lastIndex = 0;\n\n  const matcher = templateMatcher(template);\n  if (!matcher) {\n    // All-placeholder template: cannot build a reliable matcher. See the\n    // docstring — callers should not rely on dedup for this shape.\n    return false;\n  }\n  return matcher.test(text);\n}\n\n/**\n * Attach an inline citation to fact text.\n *\n * If the text already has a citation — either the default `[Source: ...]`\n * marker or one produced by the configured template — it is returned unchanged.\n * Existing provenance is respected and never overwritten. Otherwise the\n * citation is appended to the trimmed text with a single space separator,\n * which keeps the marker visually adjacent to the fact body.\n */\nexport function attachCitation(\n  text: string,\n  ctx: CitationContext,\n  template: string = DEFAULT_CITATION_FORMAT,\n): string {\n  if (typeof text !== \"string\") return text as unknown as string;\n  if (hasCitationForTemplate(text, template)) return text;\n  const trimmedEnd = text.replace(/\\s+$/u, \"\");\n  if (trimmedEnd.length === 0) return text;\n  const citation = formatCitation(ctx, template);\n  // Preserve any trailing newline that callers rely on for markdown rendering.\n  const trailing = text.slice(trimmedEnd.length);\n  return `${trimmedEnd} ${citation}${trailing}`;\n}\n\n/**\n * Parse a single inline citation from a piece of text. Returns the first\n * citation encountered or `null` when none is present. Malformed citations\n * do not throw — fields that cannot be parsed simply remain `undefined`.\n */\nexport function parseCitation(text: string): ParsedCitation | null {\n  if (typeof text !== \"string\" || text.length === 0) return null;\n  const matcher = defaultCitationMatcher();\n  const match = matcher.exec(text);\n  if (!match) return null;\n\n  const body = match[1] ?? \"\";\n  const raw = match[0] ?? \"\";\n  const parsed: ParsedCitation = { raw };\n\n  const fields = body\n    .split(\",\")\n    .map((segment) => segment.trim())\n    .filter((segment) => segment.length > 0);\n\n  for (const field of fields) {\n    const eqIdx = field.indexOf(\"=\");\n    if (eqIdx <= 0) continue;\n    const key = field.slice(0, eqIdx).trim().toLowerCase();\n    const value = field.slice(eqIdx + 1).trim();\n    if (value.length === 0) continue;\n    switch (key) {\n      case \"agent\":\n        parsed.agent = value;\n        break;\n      case \"session\":\n      case \"sessionid\":\n        parsed.session = value;\n        break;\n      case \"ts\":\n      case \"timestamp\":\n        parsed.ts = value;\n        break;\n      default:\n        // Unknown fields are ignored defensively so human edits never crash.\n        break;\n    }\n  }\n\n  return parsed;\n}\n\n/**\n * Parse every citation embedded in the text. Always returns an array; empty\n * when none are present.\n */\nexport function parseAllCitations(text: string): ParsedCitation[] {\n  if (typeof text !== \"string\" || text.length === 0) return [];\n  const matcher = defaultCitationMatcher();\n  const results: ParsedCitation[] = [];\n  let match: RegExpExecArray | null;\n  while ((match = matcher.exec(text)) !== null) {\n    const parsed = parseCitation(match[0]);\n    if (parsed) results.push(parsed);\n  }\n  return results;\n}\n\n/**\n * Remove all inline citations from a piece of text.\n *\n * Callers that want the raw fact body (for dedup hashing, display, or\n * comparison) should use this helper instead of hand-rolled regexes so the\n * whole codebase agrees on the citation syntax.\n *\n * Finding 2 fix: when the input contains no citation marker, the input is\n * returned byte-for-byte unchanged. When a citation IS removed, whitespace\n * normalization is applied only at each join seam (the single space between\n * the preceding text and where the citation was), rather than across the\n * entire string. This preserves markdown hard-break spacing, aligned text,\n * and code-like snippets in fact bodies that happen to carry a citation.\n *\n * Implementation: each citation match is replaced by its \"seam fix\" — the\n * content before the match has its trailing whitespace trimmed and then a\n * single space is appended if any text remains, collapsing only the gap\n * left by the removed marker. Whitespace elsewhere in the body is untouched.\n */\nexport function stripCitation(text: string): string {\n  if (typeof text !== \"string\" || text.length === 0) return text;\n  // Early exit: no citation marker present — return the input unchanged so\n  // that callers never lose formatting fidelity on uncited strings.\n  if (!hasCitation(text)) return text;\n\n  // Walk through all citations and slice them out one by one so that we can\n  // normalise ONLY the whitespace at each seam rather than the entire string.\n  const matcher = defaultCitationMatcher();\n  let result = \"\";\n  let lastIndex = 0;\n\n  let match: RegExpExecArray | null;\n  while ((match = matcher.exec(text)) !== null) {\n    // Text before this citation. Trim trailing spaces/tabs at the seam only.\n    const before = text.slice(lastIndex, match.index).replace(/[ \\t]+$/, \"\");\n    result += before;\n    lastIndex = match.index + match[0].length;\n  }\n\n  // Append any trailing text after the last citation. Trim leading\n  // spaces/tabs and trailing whitespace at the join seam.\n  const after = text.slice(lastIndex).replace(/^[ \\t]+/, \"\");\n  if (after.length > 0) {\n    if (result.length > 0) result += \" \";\n    result += after;\n  }\n\n  return result.trimEnd();\n}\n\n/**\n * Strip an inline citation from text using a specific template regex.\n *\n * This is the template-aware counterpart to {@link stripCitation}. When the\n * caller holds the configured `inlineSourceAttributionFormat`, use this\n * function to strip citations produced by that template — including custom\n * templates that differ from the default `[Source: ...]` pattern.\n *\n * Behaviour:\n *  - If the text has a **default-format** citation, delegates to\n *    {@link stripCitation} (always safe).\n *  - If the text has a **custom-template** citation detected by\n *    `hasCitationForTemplate`, builds the template regex and removes every\n *    occurrence (citations are appended at the end of the fact body by\n *    {@link attachCitation}).\n *  - All-placeholder templates (no literal prefix/suffix/separator) cannot\n *    produce a reliable matcher. `hasCitationForTemplate` already returns\n *    `false` for such templates, so this function never attempts to strip an\n *    undetectable citation. The text is returned unchanged when no citation\n *    is detected.\n *  - If no citation is detected for the given template, returns the text\n *    unchanged.\n *\n * @returns The stripped text (or the original text when no citation is found).\n */\nexport function stripCitationForTemplate(\n  text: string,\n  template: string,\n): string {\n  if (typeof text !== \"string\" || text.length === 0) return text;\n\n  // Fast path: default-format citation — delegate to the existing stripper.\n  if (hasCitation(text)) return stripCitation(text);\n\n  // No default citation; check whether the custom template produced one.\n  // hasCitationForTemplate returns false for all-placeholder templates (no\n  // reliable matcher), so those pass through unchanged below.\n  if (!hasCitationForTemplate(text, template)) return text;\n\n  // Build the template matcher. hasCitationForTemplate already returned true,\n  // which means templateMatcher produced a non-null result. The null branch\n  // here is a defensive fallback only — delegate to stripCitation.\n  const matcher = templateMatcher(template);\n  if (!matcher) return stripCitation(text);\n\n  // The matcher regex was built without the global flag; add it for exec loop.\n  const globalMatcher = new RegExp(\n    matcher.source,\n    matcher.flags.includes(\"g\") ? matcher.flags : matcher.flags + \"g\",\n  );\n  let result = \"\";\n  let lastIndex = 0;\n  let match: RegExpExecArray | null;\n\n  while ((match = globalMatcher.exec(text)) !== null) {\n    const before = text.slice(lastIndex, match.index).replace(/[ \\t]+$/, \"\");\n    result += before;\n    lastIndex = match.index + match[0].length;\n    // Guard against zero-width matches causing an infinite loop.\n    if (match[0].length === 0) {\n      globalMatcher.lastIndex++;\n    }\n  }\n\n  const after = text.slice(lastIndex).replace(/^[ \\t]+/, \"\");\n  if (after.length > 0) {\n    if (result.length > 0) result += \" \";\n    result += after;\n  }\n\n  return result.trimEnd();\n}\n"],"mappings":";AAkCO,IAAM,0BACX;AAGK,IAAM,mBAAmB;AAkChC,SAAS,yBAAiC;AACxC,SAAO;AACT;AAMO,SAAS,gBAAgB,SAAiD;AAC/E,MAAI,CAAC,QAAS,QAAO;AACrB,QAAM,UAAU,QAAQ,KAAK;AAC7B,MAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,QAAM,QAAQ,QAAQ,MAAM,GAAG,EAAE,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC;AAC3D,MAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,SAAO,MAAM,MAAM,SAAS,CAAC;AAC/B;AAcO,SAAS,eACd,KACA,WAAmB,yBACX;AACR,QAAM,UAAU,IAAI,WAAW;AAC/B,QAAM,YAAY,IAAI,aAAa,gBAAgB,OAAO,KAAK;AAC/D,QAAM,KAAK,IAAI,MAAM;AACrB,QAAM,QAAQ,IAAI,SAAS,IAAI,MAAM,KAAK,EAAE,SAAS,IAAI,IAAI,QAAQ;AACrE,QAAM,OAAO,MAAM,OAAO,mBAAmB,GAAG,MAAM,GAAG,EAAE,IAAI;AAC/D,QAAM,qBAAqB,QAAQ,KAAK,EAAE,SAAS,IAAI,UAAU;AAIjE,QAAM,SAAiC;AAAA,IACrC;AAAA,IACA,SAAS;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAMA,SAAO,SAAS,QAAQ,yBAAyB,CAAC,OAAO,SAAiB;AACxE,WAAO,OAAO,UAAU,eAAe,KAAK,QAAQ,IAAI,IACpD,OAAO,IAAI,IACX;AAAA,EACN,CAAC;AACH;AAMO,SAAS,YAAY,MAAuB;AACjD,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAAG,QAAO;AAC1D,SAAO,uBAAuB,EAAE,KAAK,IAAI;AAC3C;AAKA,SAAS,aAAa,GAAmB;AACvC,SAAO,EAAE,QAAQ,uBAAuB,MAAM;AAChD;AAMA,SAAS,sBAAsB,IAAoB;AACjD,MAAI,OAAO,IAAK,QAAO;AACvB,MAAI,OAAO,KAAM,QAAO;AACxB,MAAI,OAAO,IAAK,QAAO;AACvB,MAAI,OAAO,IAAK,QAAO;AAEvB,SAAO,aAAa,EAAE;AACxB;AAYA,SAAS,kBAAkB,iBAAsC;AAE/D,QAAM,OAAO;AACb,MAAI,gBAAgB,SAAS,GAAG;AAG9B,WAAO;AAAA,EACT;AACA,QAAM,UAAU,CAAC,GAAG,eAAe,EAAE,IAAI,qBAAqB,EAAE,KAAK,EAAE;AACvE,SAAO,KAAK,IAAI,GAAG,OAAO;AAC5B;AAGA,IAAM,oBAAoB;AA6D1B,SAAS,gBAAgB,UAAiC;AAExD,QAAM,QAAQ,SAAS,MAAM,iBAAiB;AAC9C,MAAI,MAAM,UAAU,EAAG,QAAO;AAE9B,QAAM,SAAS,MAAM,CAAC,KAAK;AAC3B,QAAM,SAAS,MAAM,MAAM,SAAS,CAAC,KAAK;AAM1C,MAAI,OAAO,SAAS,KAAK,OAAO,SAAS,GAAG;AAC1C,UAAM,gBAAgB,aAAa,MAAM;AACzC,UAAM,gBAAgB,aAAa,MAAM;AAKzC,UAAM,aAAa,MAAM,MAAM,GAAG,EAAE;AAKpC,UAAM,kBAAkB,oBAAI,IAAY;AACxC,eAAW,OAAO,YAAY;AAC5B,iBAAW,MAAM,KAAK;AACpB,YAAI,CAAC,KAAK,KAAK,EAAE,GAAG;AAClB,0BAAgB,IAAI,EAAE;AAAA,QACxB;AAAA,MACF;AAAA,IACF;AAeA,UAAM,aAAa,kBAAkB,eAAe;AAEpD,UAAM,YAAY,kBAAkB,oBAAI,IAAY,CAAC;AAIrD,UAAM,SACJ,WAAW,WAAW,IAClB,YACA,aACA,WACG,MAAM,GAAG,EAAE,EACX,IAAI,CAAC,QAAQ,aAAa,GAAG,IAAI,UAAU,EAC3C,KAAK,EAAE,IACV,aAAa,WAAW,WAAW,SAAS,CAAC,CAAE,IAC/C;AAEN,UAAM,UAAU,gBAAgB,SAAS;AACzC,WAAO,IAAI,OAAO,SAAS,GAAG;AAAA,EAChC;AAGA,QAAM,iBAAiB,MAAM,MAAM,GAAG,EAAE;AACxC,QAAM,oBAAoB,eAAe,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC;AACjE,MAAI,CAAC,mBAAmB;AAGtB,WAAO;AAAA,EACT;AAQA,QAAM,UAAU;AAChB,QAAM,OACJ,UACA,eAAe,IAAI,CAAC,QAAQ,aAAa,GAAG,IAAI,OAAO,EAAE,KAAK,EAAE;AAElE,QAAM,gBAAgB,eAAe,KAAK,EAAE;AAC5C,MAAI,KAAK,KAAK,aAAa,GAAG;AAI5B,UAAM,SAAS;AACf,UAAM,SAAS;AACf,WAAO,IAAI,OAAO,SAAS,OAAO,QAAQ,GAAG;AAAA,EAC/C;AA6BA,QAAM,aAAa;AAInB,QAAM,cAAc;AACpB,SAAO,IAAI,OAAO,aAAa,OAAO,aAAa,GAAG;AACxD;AAkBO,SAAS,uBAAuB,MAAc,UAA2B;AAC9E,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAAG,QAAO;AAG1D,MAAI,YAAY,IAAI,EAAG,QAAO;AAY9B,MAAI,aAAa,wBAAyB,QAAO;AAGjD,MAAI,CAAC,kBAAkB,KAAK,QAAQ,GAAG;AAErC,sBAAkB,YAAY;AAC9B,WAAO,KAAK,SAAS,QAAQ;AAAA,EAC/B;AAEA,oBAAkB,YAAY;AAE9B,QAAM,UAAU,gBAAgB,QAAQ;AACxC,MAAI,CAAC,SAAS;AAGZ,WAAO;AAAA,EACT;AACA,SAAO,QAAQ,KAAK,IAAI;AAC1B;AAWO,SAAS,eACd,MACA,KACA,WAAmB,yBACX;AACR,MAAI,OAAO,SAAS,SAAU,QAAO;AACrC,MAAI,uBAAuB,MAAM,QAAQ,EAAG,QAAO;AACnD,QAAM,aAAa,KAAK,QAAQ,SAAS,EAAE;AAC3C,MAAI,WAAW,WAAW,EAAG,QAAO;AACpC,QAAM,WAAW,eAAe,KAAK,QAAQ;AAE7C,QAAM,WAAW,KAAK,MAAM,WAAW,MAAM;AAC7C,SAAO,GAAG,UAAU,IAAI,QAAQ,GAAG,QAAQ;AAC7C;AAOO,SAAS,cAAc,MAAqC;AACjE,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAAG,QAAO;AAC1D,QAAM,UAAU,uBAAuB;AACvC,QAAM,QAAQ,QAAQ,KAAK,IAAI;AAC/B,MAAI,CAAC,MAAO,QAAO;AAEnB,QAAM,OAAO,MAAM,CAAC,KAAK;AACzB,QAAM,MAAM,MAAM,CAAC,KAAK;AACxB,QAAM,SAAyB,EAAE,IAAI;AAErC,QAAM,SAAS,KACZ,MAAM,GAAG,EACT,IAAI,CAAC,YAAY,QAAQ,KAAK,CAAC,EAC/B,OAAO,CAAC,YAAY,QAAQ,SAAS,CAAC;AAEzC,aAAW,SAAS,QAAQ;AAC1B,UAAM,QAAQ,MAAM,QAAQ,GAAG;AAC/B,QAAI,SAAS,EAAG;AAChB,UAAM,MAAM,MAAM,MAAM,GAAG,KAAK,EAAE,KAAK,EAAE,YAAY;AACrD,UAAM,QAAQ,MAAM,MAAM,QAAQ,CAAC,EAAE,KAAK;AAC1C,QAAI,MAAM,WAAW,EAAG;AACxB,YAAQ,KAAK;AAAA,MACX,KAAK;AACH,eAAO,QAAQ;AACf;AAAA,MACF,KAAK;AAAA,MACL,KAAK;AACH,eAAO,UAAU;AACjB;AAAA,MACF,KAAK;AAAA,MACL,KAAK;AACH,eAAO,KAAK;AACZ;AAAA,MACF;AAEE;AAAA,IACJ;AAAA,EACF;AAEA,SAAO;AACT;AAMO,SAAS,kBAAkB,MAAgC;AAChE,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAAG,QAAO,CAAC;AAC3D,QAAM,UAAU,uBAAuB;AACvC,QAAM,UAA4B,CAAC;AACnC,MAAI;AACJ,UAAQ,QAAQ,QAAQ,KAAK,IAAI,OAAO,MAAM;AAC5C,UAAM,SAAS,cAAc,MAAM,CAAC,CAAC;AACrC,QAAI,OAAQ,SAAQ,KAAK,MAAM;AAAA,EACjC;AACA,SAAO;AACT;AAqBO,SAAS,cAAc,MAAsB;AAClD,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAAG,QAAO;AAG1D,MAAI,CAAC,YAAY,IAAI,EAAG,QAAO;AAI/B,QAAM,UAAU,uBAAuB;AACvC,MAAI,SAAS;AACb,MAAI,YAAY;AAEhB,MAAI;AACJ,UAAQ,QAAQ,QAAQ,KAAK,IAAI,OAAO,MAAM;AAE5C,UAAM,SAAS,KAAK,MAAM,WAAW,MAAM,KAAK,EAAE,QAAQ,WAAW,EAAE;AACvE,cAAU;AACV,gBAAY,MAAM,QAAQ,MAAM,CAAC,EAAE;AAAA,EACrC;AAIA,QAAM,QAAQ,KAAK,MAAM,SAAS,EAAE,QAAQ,WAAW,EAAE;AACzD,MAAI,MAAM,SAAS,GAAG;AACpB,QAAI,OAAO,SAAS,EAAG,WAAU;AACjC,cAAU;AAAA,EACZ;AAEA,SAAO,OAAO,QAAQ;AACxB;AA2BO,SAAS,yBACd,MACA,UACQ;AACR,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAAG,QAAO;AAG1D,MAAI,YAAY,IAAI,EAAG,QAAO,cAAc,IAAI;AAKhD,MAAI,CAAC,uBAAuB,MAAM,QAAQ,EAAG,QAAO;AAKpD,QAAM,UAAU,gBAAgB,QAAQ;AACxC,MAAI,CAAC,QAAS,QAAO,cAAc,IAAI;AAGvC,QAAM,gBAAgB,IAAI;AAAA,IACxB,QAAQ;AAAA,IACR,QAAQ,MAAM,SAAS,GAAG,IAAI,QAAQ,QAAQ,QAAQ,QAAQ;AAAA,EAChE;AACA,MAAI,SAAS;AACb,MAAI,YAAY;AAChB,MAAI;AAEJ,UAAQ,QAAQ,cAAc,KAAK,IAAI,OAAO,MAAM;AAClD,UAAM,SAAS,KAAK,MAAM,WAAW,MAAM,KAAK,EAAE,QAAQ,WAAW,EAAE;AACvE,cAAU;AACV,gBAAY,MAAM,QAAQ,MAAM,CAAC,EAAE;AAEnC,QAAI,MAAM,CAAC,EAAE,WAAW,GAAG;AACzB,oBAAc;AAAA,IAChB;AAAA,EACF;AAEA,QAAM,QAAQ,KAAK,MAAM,SAAS,EAAE,QAAQ,WAAW,EAAE;AACzD,MAAI,MAAM,SAAS,GAAG;AACpB,QAAI,OAAO,SAAS,EAAG,WAAU;AACjC,cAAU;AAAA,EACZ;AAEA,SAAO,OAAO,QAAQ;AACxB;","names":[]}
+{"version":3,"sources":["../src/source-attribution.ts"],"sourcesContent":["/**\n * Inline Source Attribution Protocol (issue #369)\n *\n * Extracted facts carry provenance inline inside the fact body, so the\n * citation survives hostile memory text, copy/paste, and LLM quoting. This\n * complements — never replaces — the YAML frontmatter provenance stored on\n * disk.\n *\n * Default format (matches issue #369 proposal):\n *\n *   The foo service uses Redis for rate limiting. [Source: agent=planner, session=abc123, ts=2026-04-10T14:25:07Z]\n *\n * Key properties:\n *   - Inline (part of the body, not metadata).\n *   - Compact (typically <80 chars of overhead per fact).\n *   - Machine-parseable by a single regex.\n *   - Opt-in via `inlineSourceAttributionEnabled` config flag (default off\n *     for backwards compatibility with existing downstream consumers).\n *   - Legacy facts without a citation remain fully readable.\n *\n * The format template is configurable via `inlineSourceAttributionFormat`\n * with supported placeholders:\n *\n *   {agent}     — principal / agent identifier\n *   {session}   — full session key (colon-delimited)\n *   {sessionId} — short stable session id (trailing component)\n *   {ts}        — extraction timestamp (ISO 8601)\n *   {date}      — extraction date (YYYY-MM-DD)\n *\n * Any privacy-sensitive identifiers should be normalized before being passed\n * to `formatCitation` — the helper treats them as opaque strings.\n */\n\n/** Default citation format template (matches issue #369). */\nexport const DEFAULT_CITATION_FORMAT =\n  \"[Source: agent={agent}, session={sessionId}, ts={ts}]\";\n\n/** Sentinel value used when a provenance field is missing. */\nexport const CITATION_UNKNOWN = \"unknown\";\n\nexport interface CitationContext {\n  /** Principal / agent identifier (e.g. resolved via resolvePrincipal). */\n  agent?: string;\n  /** Full session key (e.g. \"agent:planner:main\"). */\n  session?: string;\n  /**\n   * Opaque short session id. Derived from the trailing component of the\n   * session key when not provided explicitly. Use this for compact formats\n   * that do not need the full colon-delimited session key.\n   */\n  sessionId?: string;\n  /** Extraction timestamp as an ISO 8601 string. */\n  ts?: string;\n}\n\nexport interface ParsedCitation {\n  /** Agent identifier parsed from the citation (never crashes on malformed input). */\n  agent?: string;\n  /** Session identifier parsed from the citation. */\n  session?: string;\n  /** Extraction timestamp parsed from the citation. */\n  ts?: string;\n  /** The full matched citation substring. */\n  raw: string;\n}\n\n/**\n * Regex that matches the default `[Source: agent=X, session=Y, ts=Z]` shape\n * as well as human-edited variants (extra whitespace, reordered fields,\n * subset of fields). Matches non-greedily so it can be anchored anywhere in\n * the text. Kept as a getter factory so callers do not share regex state.\n */\nfunction defaultCitationMatcher(): RegExp {\n  return /\\[Source:\\s*([^\\]\\n]+?)\\]/gi;\n}\n\n/**\n * Derive a short session id from a full session key.\n * Falls back to the raw session string if no colon is present.\n */\nexport function deriveSessionId(session: string | undefined): string | undefined {\n  if (!session) return undefined;\n  const trimmed = session.trim();\n  if (trimmed.length === 0) return undefined;\n  const parts = trimmed.split(\":\").filter((p) => p.length > 0);\n  if (parts.length === 0) return trimmed;\n  return parts[parts.length - 1];\n}\n\n/**\n * Format an inline citation tag using the provided template.\n *\n * Missing context fields fall back to {@link CITATION_UNKNOWN} — the caller\n * should always get a non-empty, parseable tag.\n *\n * Uses a single-pass substitution so that values which themselves contain\n * placeholder syntax (e.g. an agent literally named `\"{ts}\"`) cannot be\n * re-interpreted by subsequent replacement steps. Each placeholder slot\n * receives exactly one lookup and the substituted value is treated as\n * terminal text, not template source.\n */\nexport function formatCitation(\n  ctx: CitationContext,\n  template: string = DEFAULT_CITATION_FORMAT,\n): string {\n  const session = ctx.session ?? \"\";\n  const sessionId = ctx.sessionId ?? deriveSessionId(session) ?? CITATION_UNKNOWN;\n  const ts = ctx.ts ?? CITATION_UNKNOWN;\n  const agent = ctx.agent && ctx.agent.trim().length > 0 ? ctx.agent : CITATION_UNKNOWN;\n  const date = ts && ts !== CITATION_UNKNOWN ? ts.slice(0, 10) : CITATION_UNKNOWN;\n  const sessionForTemplate = session.trim().length > 0 ? session : CITATION_UNKNOWN;\n\n  // Map from recognised placeholder names to their resolved value. Unknown\n  // placeholder names are left intact (returning the original `{name}`).\n  const values: Record<string, string> = {\n    agent,\n    session: sessionForTemplate,\n    sessionId,\n    ts,\n    date,\n  };\n\n  // Single-pass scan: replace every recognised `{name}` in one sweep so that\n  // substituted values cannot themselves be treated as template source on a\n  // subsequent pass. The replacer-function form also guarantees that `$` /\n  // `$&` / `$1` sequences inside values are emitted literally.\n  return template.replace(/\\{([a-zA-Z_][\\w]*)\\}/g, (match, name: string) => {\n    return Object.prototype.hasOwnProperty.call(values, name)\n      ? values[name]!\n      : match;\n  });\n}\n\n/**\n * Returns true if the text already carries at least one citation marker.\n * Safe to call on any string — never throws.\n */\nexport function hasCitation(text: string): boolean {\n  if (typeof text !== \"string\" || text.length === 0) return false;\n  return defaultCitationMatcher().test(text);\n}\n\n/**\n * Escape a string for use as a regex literal.\n */\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Escape a single character for use INSIDE a character class `[...]`.\n * Special chars inside character classes: `]`, `\\`, `^`, `-`.\n */\nfunction escapeRegExpCharClass(ch: string): string {\n  if (ch === \"]\") return \"\\\\]\";\n  if (ch === \"\\\\\") return \"\\\\\\\\\";\n  if (ch === \"^\") return \"\\\\^\";\n  if (ch === \"-\") return \"\\\\-\";\n  // Other regex meta chars are NOT special inside [...] but escaping them is safe.\n  return escapeRegExp(ch);\n}\n\n/**\n * Build a per-placeholder token pattern that excludes newlines, whitespace,\n * and any punctuation characters used as inner separators in the template.\n *\n * This prevents a placeholder span from consuming separator bytes and\n * matching strings that cross separator boundaries in user-supplied content.\n *\n * @param nonWordSepChars - Set of non-word (non-alphanumeric, non-`_`) chars\n *   extracted from the inner separator literals of the template.\n */\nfunction buildTokenPattern(nonWordSepChars: Set<string>): string {\n  // Always exclude newlines and whitespace.\n  const base = \"\\\\n\\\\s\";\n  if (nonWordSepChars.size === 0) {\n    // No inner separator punctuation — the placeholder spans the full space\n    // between prefix and suffix. Fall back to a generous no-newline match.\n    return `[^\\\\n]+?`;\n  }\n  const escaped = [...nonWordSepChars].map(escapeRegExpCharClass).join(\"\");\n  return `[^${base}${escaped}]+?`;\n}\n\n/** Regex that matches a `{placeholder}` token inside a template string. */\nconst PLACEHOLDER_REGEX = /\\{[a-zA-Z_][\\w]*\\}/g;\n\n/**\n * Build a regex that matches a citation produced by the given template.\n *\n * The approach depends on the shape of the template:\n *\n *  - **Normal case (non-empty literal prefix or suffix).** Anchor the match\n *    on the outer literal frame and reconstruct the interior as\n *    `interToken + sep + interToken + sep + ... + sep + lastToken`.\n *    All **intermediate** per-placeholder tokens exclude the combined set of\n *    non-word separator characters used between any two adjacent placeholders,\n *    preventing a value from consuming a separator and crossing placeholder\n *    boundaries.  The **last** token is only required to avoid newlines because\n *    it is terminated by the literal suffix anchor — this lets placeholder\n *    values that legitimately contain a separator character be recognised (e.g.\n *    an ISO-8601 timestamp `2026-04-10T14:25:07Z` in `[src:{agent}:{ts}]`\n *    where `:` is the inter-placeholder separator).  A template like\n *    `[src:{agent}/{sessionId}@{date}]` emits\n *    `\\[src:[^\\n\\s/@]+?\\/[^\\n\\s/@]+?@[^\\n]+?\\]` so that `[src:foo/bar]`\n *    is NOT matched (wrong separator count), `[src:foo/bar/extra@2026]`\n *    is NOT matched (intermediate token crosses a `/` boundary), and\n *    `[src:planner/main@2026-04-10]` IS matched correctly.\n *\n *  - **Placeholder-bounded with whitespace separator.** Both prefix and\n *    suffix are empty and the separator literal(s) between placeholders\n *    contain at least one whitespace character (e.g. `{source}: {content}`,\n *    `{agent} {sessionId}`). A whitespace-containing separator produces\n *    output that is visually indistinguishable from ordinary prose, so the\n *    safe strategy is to require a **hard bracket/paren/angle delimiter** on\n *    both sides of the reconstructed match. Prose almost never places\n *    `[...]` / `(...)` / `<...>` around a phrase, so this yields clean\n *    false-positive rejection.\n *\n *  - **Placeholder-bounded with compact (non-whitespace) separator.** Both\n *    prefix and suffix are empty and the separator literal(s) contain NO\n *    whitespace (e.g. `{agent}:{sessionId}`, `{agent}/{sessionId}`).\n *    `formatCitation` emits a compact token like `planner:main` with no\n *    surrounding delimiters, so the bracket strategy cannot detect it.\n *    Instead, the pattern requires that the entire token is bordered by\n *    whitespace or a bracket/paren/angle on each side:\n *\n *      `(?:(?<=[\\[\\(\\<])|(?<!\\S))[\\w.-]+<sep>[\\w.-]+(?:(?=[\\]\\)\\>])|(?!\\S))`\n *\n *    This accepts `planner:main` when it appears standalone or inside a\n *    bracket-wrapped token, and rejects `host:80` embedded inside a URL like\n *    `http://host:80` because `host` is immediately preceded by `/`\n *    (non-whitespace, non-bracket).\n *\n *  - **All-placeholder case (no literals between placeholders either).** No\n *    reliable regex can be built — a template like `{agent}{sessionId}`\n *    contains no anchor characters. Returns `null`; {@link\n *    hasCitationForTemplate} treats this as \"cannot detect\" and returns\n *    false, falling back on explicit sentinel/format detection only for the\n *    default `[Source: ...]` shape.\n *\n * Returns `null` when the template has no placeholders (fully-literal\n * citation, handled by the string-equality fast path in {@link\n * hasCitationForTemplate}) **or** when the template is entirely placeholder-\n * only with no literal content whatsoever.\n */\nfunction templateMatcher(template: string): RegExp | null {\n  // Split around all {placeholder} tokens.\n  const parts = template.split(PLACEHOLDER_REGEX);\n  if (parts.length <= 1) return null;\n\n  const prefix = parts[0] ?? \"\";\n  const suffix = parts[parts.length - 1] ?? \"\";\n\n  // Normal case: at least one literal frame on the outside.\n  // Tighten the per-placeholder token so it cannot consume separator\n  // characters and match strings that cross separator boundaries\n  // (Finding 3 — Uru3).\n  if (prefix.length > 0 || suffix.length > 0) {\n    const escapedPrefix = escapeRegExp(prefix);\n    const escapedSuffix = escapeRegExp(suffix);\n\n    // Inner parts: literal separators that sit between adjacent placeholders.\n    // For `[src:{agent}/{sessionId}@{date}]`, parts = [\"[src:\", \"/\", \"@\", \"]\"]\n    // so innerParts = [\"/\", \"@\"].\n    const innerParts = parts.slice(1, -1);\n\n    // Collect only the non-word (punctuation/symbol) characters from each\n    // inner separator so alphabetic separator text (unlikely but valid) does\n    // not exclude letters from the per-placeholder token pattern.\n    const nonWordSepChars = new Set<string>();\n    for (const sep of innerParts) {\n      for (const ch of sep) {\n        if (!/\\w/.test(ch)) {\n          nonWordSepChars.add(ch);\n        }\n      }\n    }\n\n    // All intermediate tokens (every placeholder except the last) use the\n    // combined exclusion so they cannot cross placeholder boundaries.\n    //\n    // The LAST token is different: it is terminated by the literal suffix anchor\n    // (e.g. `\\]`), so it does not need to exclude inner-separator characters.\n    // Dropping that restriction lets placeholder values that legitimately contain\n    // a separator character (e.g. an ISO-8601 timestamp `2026-04-10T14:25:07Z`\n    // in template `[src:{agent}:{ts}]`) be recognised correctly instead of\n    // producing false-negative misses that trigger duplicate citation injection.\n    //\n    // Only the LAST token is relaxed.  Intermediate tokens keep the combined\n    // exclusion so that cross-boundary false positives are still rejected\n    // (e.g. `[src:foo/bar/extra@2026-04-11]` for `[src:{a}/{b}@{c}]`).\n    const interToken = buildTokenPattern(nonWordSepChars);\n    // Last token: terminated by suffix anchor — exclude only newlines.\n    const lastToken = buildTokenPattern(new Set<string>());\n\n    // Reconstruct the interior: interToken sep interToken sep ... sep lastToken\n    // (or just lastToken when there are no inner separators at all).\n    const middle =\n      innerParts.length === 0\n        ? lastToken\n        : interToken +\n          innerParts\n            .slice(0, -1)\n            .map((sep) => escapeRegExp(sep) + interToken)\n            .join(\"\") +\n          escapeRegExp(innerParts[innerParts.length - 1]!) +\n          lastToken;\n\n    const pattern = escapedPrefix + middle + escapedSuffix;\n    return new RegExp(pattern, \"i\");\n  }\n\n  // Placeholder-bounded case: prefix and suffix are both empty.\n  const middleLiterals = parts.slice(1, -1);\n  const hasNonEmptyMiddle = middleLiterals.some((p) => p.length > 0);\n  if (!hasNonEmptyMiddle) {\n    // All-placeholder template with no literal content. Impossible to anchor\n    // reliably without sentinel markers; signal the caller.\n    return null;\n  }\n\n  // Identifier token: one or more word chars, dots, dashes, or colons.\n  // Colons are included to allow timestamp values like \"10:30\" or session\n  // keys like \"agent:planner:main\" inside compact placeholder-bounded\n  // templates.  URL-like fragments (`http://host:80`) are still rejected\n  // because the lead anchor requires whitespace or a bracket immediately\n  // before the first id-token group (`http` is preceded by `/`).\n  const idToken = \"[\\\\w.:-]+\";\n  const body =\n    idToken +\n    middleLiterals.map((lit) => escapeRegExp(lit) + idToken).join(\"\");\n\n  const separatorText = middleLiterals.join(\"\");\n  if (/\\s/.test(separatorText)) {\n    // Separator contains whitespace: the emitted citation looks like ordinary\n    // prose (e.g. `planner main`). Require a hard bracket/paren/angle\n    // delimiter on both sides to prevent false matches on English text.\n    const opener = \"[\\\\[\\\\(\\\\<]\";\n    const closer = \"[\\\\]\\\\)\\\\>]\";\n    return new RegExp(opener + body + closer, \"i\");\n  }\n\n  // Separator is compact (no whitespace): `formatCitation` emits a token like\n  // `planner:main` without surrounding delimiters. The challenge is that the\n  // same token shape also matches ordinary hyphenated or slashed prose words\n  // (e.g. `long-term`, `docs/setup`), causing `hasCitationForTemplate` to\n  // return true on uncited fact bodies and silently suppress citation injection\n  // from `attachCitation`.\n  //\n  // Fix (Finding 1): tighten the trail anchor so a bare compact token is only\n  // accepted when it sits at the very end of the string (possibly followed by\n  // optional trailing whitespace or a newline). Since `attachCitation` always\n  // appends the citation at the trimmed end of the fact body, a real citation\n  // token will always appear at the tail. Prose like `\"long-term solution\"`\n  // has `long-term` in the middle of the string (followed by ` solution`), so\n  // the end-of-string anchor rejects it — no false positive, no silent drop.\n  //\n  // The lead anchor still accepts either a bracket opener or a whitespace\n  // boundary (or start of string), so `\"Fact. planner:main\"` and standalone\n  // `\"planner:main\"` are both detected after the first attachment pass.\n  //\n  // Bracket-wrapped form (e.g. `[planner:main]`) is also accepted via the\n  // opener/closer pair — bracket still takes precedence over end-of-string.\n  //\n  // Example — why `http://host:80` does NOT match:\n  //   Trying to match `host:80`: the char before `h` is `/` (non-whitespace,\n  //   non-bracket), so `(?<=[\\[\\(\\<])` and `(?<!\\S)` both fail ⟹ no match.\n  //   Trying to match `http:...`: after `http:` the next chars are `//` which\n  //   are not `[\\w.-]+`, so the second id-token group fails ⟹ no match.\n  const leadAnchor = \"(?:(?<=[\\\\[\\\\(\\\\<])|(?<!\\\\S))\";\n  // Trail: either a bracket closer (for `[token]` shape) or end-of-string\n  // optionally preceded by whitespace. The `(?!\\S)` is deliberately removed\n  // so that a compact token in the MIDDLE of a sentence does not match.\n  const trailAnchor = \"(?:(?=[\\\\]\\\\)\\\\>])|(?=\\\\s*$))\";\n  return new RegExp(leadAnchor + body + trailAnchor, \"i\");\n}\n\n/**\n * Returns true if `text` already carries a citation produced by `template`\n * **or** by the default `[Source: ...]` format (for facts that were tagged\n * before a config change).\n *\n * Use this instead of {@link hasCitation} whenever the caller has access to\n * the configured `inlineSourceAttributionFormat`.\n *\n * All-placeholder templates such as `{agent}{sessionId}` have no literal\n * content to anchor on and therefore cannot be reliably detected without\n * dedicated sentinel markers. In that case the function returns `false` —\n * callers that need idempotent dedup for such templates should either adopt\n * a template with literal delimiters (recommended) or rely on the default\n * `[Source: ...]` marker detection which is always available via\n * {@link hasCitation}.\n */\nexport function hasCitationForTemplate(text: string, template: string): boolean {\n  if (typeof text !== \"string\" || text.length === 0) return false;\n  // Always accept the default format as a fallback so facts tagged before a\n  // configuration change are not double-tagged on reprocessing.\n  if (hasCitation(text)) return true;\n  // If the configured template matches the default, we're done.\n  //\n  // Known limitation (Thread 2 — Codex P2): this fast path exits without\n  // checking whether the content carries a citation from a DIFFERENT custom\n  // template that was active before the config was changed back to the default.\n  // Such a fact would be detected by `hasCitation` above only if the prior\n  // custom template happened to match the default `[Source: ...]` pattern.\n  // In practice, template changes mid-stream are rare, and the false-negative\n  // (missing an old custom citation) produces a benign duplicate citation rather\n  // than data loss. A full fix would require storing the citation template used\n  // at write time in the frontmatter and checking that here.\n  if (template === DEFAULT_CITATION_FORMAT) return false;\n\n  // Fully-literal template (no placeholders): exact inclusion check.\n  if (!PLACEHOLDER_REGEX.test(template)) {\n    // Reset lastIndex because PLACEHOLDER_REGEX is declared with /g.\n    PLACEHOLDER_REGEX.lastIndex = 0;\n    return text.includes(template);\n  }\n  // Reset lastIndex after the .test() probe above.\n  PLACEHOLDER_REGEX.lastIndex = 0;\n\n  const matcher = templateMatcher(template);\n  if (!matcher) {\n    // All-placeholder template: cannot build a reliable matcher. See the\n    // docstring — callers should not rely on dedup for this shape.\n    return false;\n  }\n  return matcher.test(text);\n}\n\n/**\n * Attach an inline citation to fact text.\n *\n * If the text already has a citation — either the default `[Source: ...]`\n * marker or one produced by the configured template — it is returned unchanged.\n * Existing provenance is respected and never overwritten. Otherwise the\n * citation is appended to the trimmed text with a single space separator,\n * which keeps the marker visually adjacent to the fact body.\n */\nexport function attachCitation(\n  text: string,\n  ctx: CitationContext,\n  template: string = DEFAULT_CITATION_FORMAT,\n): string {\n  if (typeof text !== \"string\") return text as unknown as string;\n  if (hasCitationForTemplate(text, template)) return text;\n  const trimmedEnd = text.replace(/\\s+$/u, \"\");\n  if (trimmedEnd.length === 0) return text;\n  const citation = formatCitation(ctx, template);\n  // Preserve any trailing newline that callers rely on for markdown rendering.\n  const trailing = text.slice(trimmedEnd.length);\n  return `${trimmedEnd} ${citation}${trailing}`;\n}\n\n/**\n * Parse a single inline citation from a piece of text. Returns the first\n * citation encountered or `null` when none is present. Malformed citations\n * do not throw — fields that cannot be parsed simply remain `undefined`.\n */\nexport function parseCitation(text: string): ParsedCitation | null {\n  if (typeof text !== \"string\" || text.length === 0) return null;\n  const matcher = defaultCitationMatcher();\n  const match = matcher.exec(text);\n  if (!match) return null;\n\n  const body = match[1] ?? \"\";\n  const raw = match[0] ?? \"\";\n  const parsed: ParsedCitation = { raw };\n\n  const fields = body\n    .split(\",\")\n    .map((segment) => segment.trim())\n    .filter((segment) => segment.length > 0);\n\n  for (const field of fields) {\n    const eqIdx = field.indexOf(\"=\");\n    if (eqIdx <= 0) continue;\n    const key = field.slice(0, eqIdx).trim().toLowerCase();\n    const value = field.slice(eqIdx + 1).trim();\n    if (value.length === 0) continue;\n    switch (key) {\n      case \"agent\":\n        parsed.agent = value;\n        break;\n      case \"session\":\n      case \"sessionid\":\n        parsed.session = value;\n        break;\n      case \"ts\":\n      case \"timestamp\":\n        parsed.ts = value;\n        break;\n      default:\n        // Unknown fields are ignored defensively so human edits never crash.\n        break;\n    }\n  }\n\n  return parsed;\n}\n\n/**\n * Parse every citation embedded in the text. Always returns an array; empty\n * when none are present.\n */\nexport function parseAllCitations(text: string): ParsedCitation[] {\n  if (typeof text !== \"string\" || text.length === 0) return [];\n  const matcher = defaultCitationMatcher();\n  const results: ParsedCitation[] = [];\n  let match: RegExpExecArray | null;\n  while ((match = matcher.exec(text)) !== null) {\n    const parsed = parseCitation(match[0]);\n    if (parsed) results.push(parsed);\n  }\n  return results;\n}\n\n/**\n * Remove all inline citations from a piece of text.\n *\n * Callers that want the raw fact body (for dedup hashing, display, or\n * comparison) should use this helper instead of hand-rolled regexes so the\n * whole codebase agrees on the citation syntax.\n *\n * Finding 2 fix: when the input contains no citation marker, the input is\n * returned byte-for-byte unchanged. When a citation IS removed, whitespace\n * normalization is applied only at each join seam (the single space between\n * the preceding text and where the citation was), rather than across the\n * entire string. This preserves markdown hard-break spacing, aligned text,\n * and code-like snippets in fact bodies that happen to carry a citation.\n *\n * Implementation: each citation match is replaced by its \"seam fix\" — the\n * content before the match has its trailing whitespace trimmed and then a\n * single space is appended if any text remains, collapsing only the gap\n * left by the removed marker. Whitespace elsewhere in the body is untouched.\n */\nexport function stripCitation(text: string): string {\n  if (typeof text !== \"string\" || text.length === 0) return text;\n  // Early exit: no citation marker present — return the input unchanged so\n  // that callers never lose formatting fidelity on uncited strings.\n  if (!hasCitation(text)) return text;\n\n  // Walk through all citations and slice them out one by one so that we can\n  // normalise ONLY the whitespace at each seam rather than the entire string.\n  const matcher = defaultCitationMatcher();\n  let result = \"\";\n  let lastIndex = 0;\n\n  let match: RegExpExecArray | null;\n  while ((match = matcher.exec(text)) !== null) {\n    // Text before this citation. Trim trailing spaces/tabs at the seam only.\n    const before = text.slice(lastIndex, match.index).replace(/[ \\t]+$/, \"\");\n    result += before;\n    lastIndex = match.index + match[0].length;\n  }\n\n  // Append any trailing text after the last citation. Trim leading\n  // spaces/tabs and trailing whitespace at the join seam.\n  const after = text.slice(lastIndex).replace(/^[ \\t]+/, \"\");\n  if (after.length > 0) {\n    if (result.length > 0) result += \" \";\n    result += after;\n  }\n\n  return result.trimEnd();\n}\n\n/**\n * Strip an inline citation from text using a specific template regex.\n *\n * This is the template-aware counterpart to {@link stripCitation}. When the\n * caller holds the configured `inlineSourceAttributionFormat`, use this\n * function to strip citations produced by that template — including custom\n * templates that differ from the default `[Source: ...]` pattern.\n *\n * Behaviour:\n *  - If the text has a **default-format** citation, delegates to\n *    {@link stripCitation} (always safe).\n *  - If the text has a **custom-template** citation detected by\n *    `hasCitationForTemplate`, builds the template regex and removes every\n *    occurrence (citations are appended at the end of the fact body by\n *    {@link attachCitation}).\n *  - All-placeholder templates (no literal prefix/suffix/separator) cannot\n *    produce a reliable matcher. `hasCitationForTemplate` already returns\n *    `false` for such templates, so this function never attempts to strip an\n *    undetectable citation. The text is returned unchanged when no citation\n *    is detected.\n *  - If no citation is detected for the given template, returns the text\n *    unchanged.\n *\n * @returns The stripped text (or the original text when no citation is found).\n */\nexport function stripCitationForTemplate(\n  text: string,\n  template: string,\n): string {\n  if (typeof text !== \"string\" || text.length === 0) return text;\n\n  // Fast path: default-format citation — delegate to the existing stripper.\n  if (hasCitation(text)) return stripCitation(text);\n\n  // No default citation; check whether the custom template produced one.\n  // hasCitationForTemplate returns false for all-placeholder templates (no\n  // reliable matcher), so those pass through unchanged below.\n  if (!hasCitationForTemplate(text, template)) return text;\n\n  // Build the template matcher. hasCitationForTemplate already returned true,\n  // which means templateMatcher produced a non-null result. The null branch\n  // here is a defensive fallback only — delegate to stripCitation.\n  const matcher = templateMatcher(template);\n  if (!matcher) return stripCitation(text);\n\n  // The matcher regex was built without the global flag; add it for exec loop.\n  const globalMatcher = new RegExp(\n    matcher.source,\n    matcher.flags.includes(\"g\") ? matcher.flags : matcher.flags + \"g\",\n  );\n  let result = \"\";\n  let lastIndex = 0;\n  let match: RegExpExecArray | null;\n\n  while ((match = globalMatcher.exec(text)) !== null) {\n    const matchEnd = match.index + match[0].length;\n    const enclosure = enclosingDelimiterRange(text, match.index, matchEnd);\n    const removalStart = enclosure?.start ?? match.index;\n    const removalEnd = enclosure?.end ?? matchEnd;\n    const before = text.slice(lastIndex, removalStart).replace(/[ \\t]+$/, \"\");\n    result += before;\n    lastIndex = removalEnd;\n    // Guard against zero-width matches causing an infinite loop.\n    if (match[0].length === 0) {\n      globalMatcher.lastIndex++;\n    }\n  }\n\n  const after = text.slice(lastIndex).replace(/^[ \\t]+/, \"\");\n  if (after.length > 0) {\n    if (result.length > 0) result += \" \";\n    result += after;\n  }\n\n  return result.trimEnd();\n}\n\nfunction enclosingDelimiterRange(\n  text: string,\n  start: number,\n  end: number,\n): { start: number; end: number } | undefined {\n  if (start <= 0 || end >= text.length) return undefined;\n  const opener = text[start - 1];\n  const closer = text[end];\n  if (\n    (opener === \"[\" && closer === \"]\") ||\n    (opener === \"(\" && closer === \")\") ||\n    (opener === \"<\" && closer === \">\")\n  ) {\n    return { start: start - 1, end: end + 1 };\n  }\n  return undefined;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-56K5QLHX.js → chunk-4HP7HIE3.js}

@@ -1,6 +1,6 @@
 import {
   parseMessageParts
-} from "./chunk-3APJ5EVB.js";
+} from "./chunk-XKIQZXUB.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -9,6 +9,16 @@ import {
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
+var PUBLIC_LCM_SEARCH_LIMIT = 100;
+function normalizeSearchLimit(limit, fallback = 10, max = PUBLIC_LCM_SEARCH_LIMIT) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) return fallback;
+  const normalized = Math.floor(limit);
+  if (normalized <= 0) return 0;
+  return Math.min(max, normalized);
+}
+function escapeSqlLike(value) {
+  return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
 var LcmArchive = class {
   constructor(db) {
     this.db = db;
@@ -100,10 +110,12 @@ var LcmArchive = class {
     ).all(sessionId, lastSummarized);
   }
   /** Full-text search across all messages. */
-  search(query, limit, sessionId) {
+  search(query, limit, sessionId, sessionPrefix) {
     try {
       const ftsQuery = sanitizeFtsQuery(query);
       if (!ftsQuery) return [];
+      const cappedLimit = normalizeSearchLimit(limit);
+      if (cappedLimit === 0) return [];
       let sql;
       const params = [ftsQuery];
       if (sessionId) {
@@ -117,7 +129,19 @@ var LcmArchive = class {
           ORDER BY rank
           LIMIT ?
         `;
-        params.push(sessionId, limit);
+        params.push(sessionId, cappedLimit);
+      } else if (sessionPrefix) {
+        sql = `
+          SELECT m.turn_index, m.role, snippet(lcm_messages_fts, 0, '>>>', '<<<', '...', 48) as snippet,
+                 m.session_id, rank
+          FROM lcm_messages_fts f
+          JOIN lcm_messages m ON m.id = f.rowid
+          WHERE lcm_messages_fts MATCH ?
+            AND m.session_id LIKE ? ESCAPE '\\'
+          ORDER BY rank
+          LIMIT ?
+        `;
+        params.push(`${escapeSqlLike(sessionPrefix)}%`, cappedLimit);
       } else {
         sql = `
           SELECT m.turn_index, m.role, snippet(lcm_messages_fts, 0, '>>>', '<<<', '...', 48) as snippet,
@@ -128,7 +152,7 @@ var LcmArchive = class {
           ORDER BY rank
           LIMIT ?
         `;
-        params.push(limit);
+        params.push(cappedLimit);
       }
       const rows = this.db.prepare(sql).all(...params);
       return rows.map((r) => ({
@@ -149,10 +173,12 @@ var LcmArchive = class {
    * Returns ~1000-char windows centered on query term matches.
    * Deduplicates by message id and returns results sorted by FTS rank.
    */
-  searchWithContent(query, limit, sessionId, excerptChars = 1e3) {
+  searchWithContent(query, limit, sessionId, excerptChars = 1e3, sessionPrefix) {
     try {
       const ftsQuery = sanitizeFtsQuery(query);
       if (!ftsQuery) return [];
+      const cappedLimit = normalizeSearchLimit(limit);
+      if (cappedLimit === 0) return [];
       const queryWords = query.replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1 && !STOPWORDS.has(w.toLowerCase())).map((w) => w.toLowerCase());
       let sql;
       const params = [ftsQuery];
@@ -166,7 +192,18 @@ var LcmArchive = class {
           ORDER BY rank
           LIMIT ?
         `;
-        params.push(sessionId, limit);
+        params.push(sessionId, cappedLimit);
+      } else if (sessionPrefix) {
+        sql = `
+          SELECT m.id, m.turn_index, m.role, m.content, m.session_id, rank
+          FROM lcm_messages_fts f
+          JOIN lcm_messages m ON m.id = f.rowid
+          WHERE lcm_messages_fts MATCH ?
+            AND m.session_id LIKE ? ESCAPE '\\'
+          ORDER BY rank
+          LIMIT ?
+        `;
+        params.push(`${escapeSqlLike(sessionPrefix)}%`, cappedLimit);
       } else {
         sql = `
           SELECT m.id, m.turn_index, m.role, m.content, m.session_id, rank
@@ -176,7 +213,7 @@ var LcmArchive = class {
           ORDER BY rank
           LIMIT ?
         `;
-        params.push(limit);
+        params.push(cappedLimit);
       }
       const rows = this.db.prepare(sql).all(...params);
       const seen = /* @__PURE__ */ new Set();
@@ -285,11 +322,17 @@ var LcmArchive = class {
   /** Prune messages older than retentionDays. */
   pruneOldMessages(retentionDays) {
     const cutoff = new Date(Date.now() - retentionDays * 864e5).toISOString();
-    this.db.prepare(
-      "DELETE FROM lcm_messages_fts WHERE rowid IN (SELECT id FROM lcm_messages WHERE created_at < ?)"
-    ).run(cutoff);
-    const result = this.db.prepare("DELETE FROM lcm_messages WHERE created_at < ?").run(cutoff);
-    return result.changes;
+    const txn = this.db.transaction(() => {
+      this.db.prepare(
+        "DELETE FROM lcm_messages_fts WHERE rowid IN (SELECT id FROM lcm_messages WHERE created_at < ?)"
+      ).run(cutoff);
+      this.db.prepare(
+        "DELETE FROM lcm_message_parts WHERE message_id IN (SELECT id FROM lcm_messages WHERE created_at < ?)"
+      ).run(cutoff);
+      const result = this.db.prepare("DELETE FROM lcm_messages WHERE created_at < ?").run(cutoff);
+      return result.changes;
+    });
+    return txn();
   }
 };
 function extractExcerpt(content, queryWords, excerptChars) {
@@ -503,4 +546,4 @@ export {
   estimateTokens,
   LcmArchive
 };
-//# sourceMappingURL=chunk-56K5QLHX.js.map
+//# sourceMappingURL=chunk-4HP7HIE3.js.map

package/dist/chunk-4HP7HIE3.js.map

@@ -0,0 +1 @@
+{"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-RK2Y4XOM.js → chunk-4JRRISLU.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2LSZVONP.js";
 import {
   emitGraphEvent
-} from "./chunk-WIICJPET.js";
+} from "./chunk-DEUNUKTD.js";
 
 // src/graph.ts
 import { mkdir, appendFile, readFile } from "fs/promises";
@@ -59,13 +59,16 @@ async function appendEdge(memoryDir, edge) {
 function isNodeError(err) {
   return typeof err === "object" && err !== null && "code" in err;
 }
-function parseEdgesJsonl(raw) {
+function parseEdgesJsonl(raw, expectedType) {
   const edges = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     try {
-      edges.push(JSON.parse(trimmed));
+      const parsed = JSON.parse(trimmed);
+      if (isValidGraphEdge(parsed, expectedType)) {
+        edges.push(parsed);
+      }
     } catch {
     }
   }
@@ -75,7 +78,7 @@ async function readEdges(memoryDir, type) {
   const filePath = graphFilePath(memoryDir, type);
   try {
     const raw = await readFile(filePath, "utf8");
-    return parseEdgesJsonl(raw);
+    return parseEdgesJsonl(raw, type);
   } catch {
     return [];
   }
@@ -84,7 +87,7 @@ async function readEdgesStrict(memoryDir, type) {
   const filePath = graphFilePath(memoryDir, type);
   try {
     const raw = await readFile(filePath, "utf8");
-    return parseEdgesJsonl(raw);
+    return parseEdgesJsonl(raw, type);
   } catch (err) {
     if (isNodeError(err) && err.code === "ENOENT") {
       return [];
@@ -489,4 +492,4 @@ export {
   applyPageRankRefinement,
   applyLateralInhibition
 };
-//# sourceMappingURL=chunk-RK2Y4XOM.js.map
+//# sourceMappingURL=chunk-4JRRISLU.js.map

package/dist/chunk-4JRRISLU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/graph.ts"],"sourcesContent":["/**\n * Multi-Graph Memory (MAGMA/SYNAPSE-inspired, v8.2)\n *\n * Maintains three typed edge graphs:\n *   entity.jsonl  — memories sharing a named entity (entityRef)\n *   time.jsonl    — consecutive memories in the same thread/session\n *   causal.jsonl  — memories linked by causal language heuristics\n *\n * Stored under `<memoryDir>/state/graphs/`.\n * All writes are fail-open: errors are caught/logged, never thrown.\n */\n\nimport { mkdir, appendFile, readFile } from \"node:fs/promises\";\nimport * as path from \"path\";\n\nimport { readEdgeConfidence } from \"./graph-edge-reinforcement.js\";\nimport { emitGraphEvent } from \"./graph-events.js\";\n\nexport type GraphType = \"entity\" | \"time\" | \"causal\";\n\nexport interface GraphEdge {\n  from: string; // relative memory path (e.g. \"facts/2026-02-22/abc.md\")\n  to: string; // relative memory path\n  type: GraphType;\n  weight: number; // 1.0 default, decay applied during traversal\n  label: string; // entity name, threadId, or matched causal phrase\n  ts: string; // ISO timestamp of edge creation\n\n  // Issue #681 — edge confidence + reinforcement (PR 1/3: schema + primitive only).\n  // Both fields are optional so existing edges without confidence still validate.\n  // Treat a missing `confidence` as 1.0 (legacy behavior) at read sites.\n  // PR 2/3 wires the maintenance decay job; PR 3/3 weights PageRank traversal by confidence.\n  confidence?: number; // [0, 1]; missing = 1.0\n  lastReinforcedAt?: string; // ISO timestamp of most recent reinforcement\n}\n\nexport interface GraphConfig {\n  multiGraphMemoryEnabled: boolean;\n  entityGraphEnabled: boolean;\n  timeGraphEnabled: boolean;\n  causalGraphEnabled: boolean;\n  maxGraphTraversalSteps: number;\n  graphActivationDecay: number;\n  maxEntityGraphEdgesPerMemory: number;\n  graphLateralInhibitionEnabled: boolean;\n  graphLateralInhibitionBeta: number;\n  graphLateralInhibitionTopM: number;\n  /**\n   * Issue #681 PR 3/3 — minimum edge confidence required for traversal.\n   * Edges with confidence below this floor are pruned. Legacy edges\n   * (no `confidence` field) are treated as 1.0 and always pass.\n   * Range `[0, 1]`. Default 0.2.\n   */\n  graphTraversalConfidenceFloor: number;\n  /**\n   * Issue #681 PR 3/3 — number of PageRank-style refinement iterations\n   * applied on top of BFS activation. Set to 0 to disable refinement\n   * and return raw BFS scores. Default 8.\n   */\n  graphTraversalPageRankIterations: number;\n}\n\n/** Default minimum edge confidence required for traversal (issue #681 PR 3/3). */\nexport const DEFAULT_GRAPH_TRAVERSAL_CONFIDENCE_FLOOR = 0.2;\n/** Default PageRank-style refinement iteration count (issue #681 PR 3/3). */\nexport const DEFAULT_GRAPH_TRAVERSAL_PAGERANK_ITERATIONS = 8;\n\n// Causal signal phrases — order matters (most specific first)\nexport const CAUSAL_PHRASES = [\n  \"as a result\",\n  \"led to\",\n  \"because of\",\n  \"therefore\",\n  \"caused\",\n  \"because\",\n];\n\nexport function graphsDir(memoryDir: string): string {\n  return path.join(memoryDir, \"state\", \"graphs\");\n}\n\nexport function graphFilePath(memoryDir: string, type: GraphType): string {\n  return path.join(graphsDir(memoryDir), `${type}.jsonl`);\n}\n\nexport async function ensureGraphsDir(memoryDir: string): Promise<void> {\n  await mkdir(graphsDir(memoryDir), { recursive: true });\n}\n\n// ---------------------------------------------------------------------------\n// Per-graph-file write lock (gotcha #40 promise-chain pattern).\n//\n// Both the append path (`appendEdge`) and the rewrite path used by the\n// decay maintenance job must serialize on the same lock keyed by the\n// JSONL file path. Without this, an extraction can append a new edge\n// between the decay job's read-snapshot and rewrite, silently dropping\n// the appended edge during active traffic (issue #729 / Codex P1).\n// ---------------------------------------------------------------------------\nconst graphWriteLocks = new Map<string, Promise<void>>();\n\n/**\n * Run `fn` while holding the write lock for the given graph JSONL file.\n *\n * The lock is keyed by absolute file path so concurrent writes to\n * different graph types proceed independently. The chain recovers from\n * rejection (gotcha #40) so a single I/O failure does not poison all\n * future writers, but the original error is still surfaced to the\n * caller of `withGraphWriteLock`.\n */\nexport function withGraphWriteLock<T>(filePath: string, fn: () => Promise<T>): Promise<T> {\n  const prev = graphWriteLocks.get(filePath) ?? Promise.resolve();\n  const next = prev.then(fn, fn);\n  graphWriteLocks.set(\n    filePath,\n    next.then(\n      () => undefined,\n      () => undefined,\n    ),\n  );\n  return next;\n}\n\nexport async function appendEdge(memoryDir: string, edge: GraphEdge): Promise<void> {\n  await ensureGraphsDir(memoryDir);\n  const filePath = graphFilePath(memoryDir, edge.type);\n  const line = JSON.stringify(edge) + \"\\n\";\n  await withGraphWriteLock(filePath, async () => {\n    await appendFile(filePath, line, \"utf8\");\n  });\n  // Emit edge-added event for SSE subscribers (issue #691 PR 5/5).\n  // Fail-open: emitGraphEvent catches listener errors so a bad SSE client\n  // can never surface into the extraction pipeline.\n  emitGraphEvent(memoryDir, \"edge-added\", {\n    source: edge.from,\n    target: edge.to,\n    kind: edge.type,\n    weight: edge.weight,\n    label: edge.label,\n    confidence: typeof edge.confidence === \"number\" ? edge.confidence : 1.0,\n  });\n}\n\nfunction isNodeError(err: unknown): err is NodeJS.ErrnoException {\n  return typeof err === \"object\" && err !== null && \"code\" in err;\n}\n\nfunction parseEdgesJsonl(raw: string, expectedType: GraphType): GraphEdge[] {\n  const edges: GraphEdge[] = [];\n  for (const line of raw.split(\"\\n\")) {\n    const trimmed = line.trim();\n    if (!trimmed) continue;\n    try {\n      const parsed = JSON.parse(trimmed) as unknown;\n      if (isValidGraphEdge(parsed, expectedType)) {\n        edges.push(parsed);\n      }\n    } catch {\n      // skip corrupt lines — fail-open for partial JSONL recovery\n    }\n  }\n  return edges;\n}\n\n/**\n * Read all edges of a given type from the JSONL file.\n * Returns [] if the file doesn't exist or any read error occurs (fail-open).\n *\n * Production traversal callers (recall/PageRank) depend on this fail-open\n * posture so a temporarily missing or unreadable graph file never blocks\n * a recall. Maintenance jobs that need to distinguish ENOENT from real\n * I/O failures must use {@link readEdgesStrict} instead.\n */\nexport async function readEdges(memoryDir: string, type: GraphType): Promise<GraphEdge[]> {\n  const filePath = graphFilePath(memoryDir, type);\n  try {\n    const raw = await readFile(filePath, \"utf8\");\n    return parseEdgesJsonl(raw, type);\n  } catch {\n    return [];\n  }\n}\n\n/**\n * Same as {@link readEdges} but only swallows `ENOENT`; all other read\n * errors (`EACCES`, `EIO`, …) are propagated. Used by the graph-edge\n * decay maintenance job so I/O outages surface as a failed run instead\n * of being silently reported as \"no edges to decay\" (issue #729 /\n * Codex P1, line 120).\n */\nexport async function readEdgesStrict(memoryDir: string, type: GraphType): Promise<GraphEdge[]> {\n  const filePath = graphFilePath(memoryDir, type);\n  try {\n    const raw = await readFile(filePath, \"utf8\");\n    return parseEdgesJsonl(raw, type);\n  } catch (err) {\n    if (isNodeError(err) && err.code === \"ENOENT\") {\n      return [];\n    }\n    throw err;\n  }\n}\n\n/**\n * Read edges from all enabled graph types.\n */\nexport async function readAllEdges(\n  memoryDir: string,\n  config: Pick<GraphConfig, \"entityGraphEnabled\" | \"timeGraphEnabled\" | \"causalGraphEnabled\">,\n): Promise<GraphEdge[]> {\n  const parts: GraphEdge[][] = await Promise.all([\n    config.entityGraphEnabled ? readEdges(memoryDir, \"entity\") : Promise.resolve([]),\n    config.timeGraphEnabled ? readEdges(memoryDir, \"time\") : Promise.resolve([]),\n    config.causalGraphEnabled ? readEdges(memoryDir, \"causal\") : Promise.resolve([]),\n  ]);\n  return parts.flat();\n}\n\nexport interface GraphHealthFileStats {\n  type: GraphType;\n  filePath: string;\n  exists: boolean;\n  totalLines: number;\n  validEdges: number;\n  corruptLines: number;\n  uniqueNodes: number;\n}\n\nexport interface GraphHealthReport {\n  generatedAt: string;\n  enabledTypes: GraphType[];\n  totals: {\n    totalLines: number;\n    validEdges: number;\n    corruptLines: number;\n    uniqueNodes: number;\n  };\n  files: GraphHealthFileStats[];\n  repairGuidance?: string[];\n}\n\nfunction isValidGraphEdge(raw: unknown, expectedType: GraphType): raw is GraphEdge {\n  if (!raw || typeof raw !== \"object\") return false;\n  const edge = raw as Record<string, unknown>;\n  return (\n    edge.type === expectedType &&\n    typeof edge.from === \"string\" && edge.from.length > 0 &&\n    typeof edge.to === \"string\" && edge.to.length > 0 &&\n    typeof edge.weight === \"number\" && Number.isFinite(edge.weight) &&\n    typeof edge.label === \"string\" &&\n    typeof edge.ts === \"string\"\n  );\n}\n\nexport async function analyzeGraphHealth(\n  memoryDir: string,\n  options?: {\n    entityGraphEnabled?: boolean;\n    timeGraphEnabled?: boolean;\n    causalGraphEnabled?: boolean;\n    includeRepairGuidance?: boolean;\n  },\n): Promise<GraphHealthReport> {\n  const enabledTypes: GraphType[] = [];\n  if (options?.entityGraphEnabled !== false) enabledTypes.push(\"entity\");\n  if (options?.timeGraphEnabled !== false) enabledTypes.push(\"time\");\n  if (options?.causalGraphEnabled !== false) enabledTypes.push(\"causal\");\n\n  const files: GraphHealthFileStats[] = [];\n  const globalNodes = new Set<string>();\n\n  for (const type of enabledTypes) {\n    const filePath = graphFilePath(memoryDir, type);\n    let exists = true;\n    let totalLines = 0;\n    let validEdges = 0;\n    let corruptLines = 0;\n    const nodes = new Set<string>();\n\n    try {\n      const raw = await readFile(filePath, \"utf8\");\n      for (const line of raw.split(\"\\n\")) {\n        const trimmed = line.trim();\n        if (!trimmed) continue;\n        totalLines += 1;\n        try {\n          const parsed = JSON.parse(trimmed) as unknown;\n          if (!isValidGraphEdge(parsed, type)) {\n            corruptLines += 1;\n            continue;\n          }\n          validEdges += 1;\n          nodes.add(parsed.from);\n          nodes.add(parsed.to);\n          globalNodes.add(parsed.from);\n          globalNodes.add(parsed.to);\n        } catch {\n          corruptLines += 1;\n        }\n      }\n    } catch {\n      exists = false;\n    }\n\n    files.push({\n      type,\n      filePath,\n      exists,\n      totalLines,\n      validEdges,\n      corruptLines,\n      uniqueNodes: nodes.size,\n    });\n  }\n\n  const totals = files.reduce(\n    (acc, item) => {\n      acc.totalLines += item.totalLines;\n      acc.validEdges += item.validEdges;\n      acc.corruptLines += item.corruptLines;\n      return acc;\n    },\n    {\n      totalLines: 0,\n      validEdges: 0,\n      corruptLines: 0,\n      uniqueNodes: globalNodes.size,\n    },\n  );\n  totals.uniqueNodes = globalNodes.size;\n\n  const report: GraphHealthReport = {\n    generatedAt: new Date().toISOString(),\n    enabledTypes,\n    totals,\n    files,\n  };\n\n  if (options?.includeRepairGuidance === true) {\n    const guidance: string[] = [];\n    if (totals.corruptLines > 0) {\n      guidance.push(\"Corrupt graph lines detected: back up memory/state/graphs, then rebuild graphs from clean memory replay/extraction runs.\");\n    }\n    if (totals.validEdges === 0) {\n      guidance.push(\"No valid edges detected yet: run normal extraction traffic (or replay ingestion) to seed graph files.\");\n    }\n    if (guidance.length > 0) report.repairGuidance = guidance;\n  }\n\n  return report;\n}\n\n/**\n * Detect causal signal phrases in text. Returns the first matched phrase, or null.\n */\nexport function detectCausalPhrase(text: string): string | null {\n  const lower = text.toLowerCase();\n  for (const phrase of CAUSAL_PHRASES) {\n    if (lower.includes(phrase)) return phrase;\n  }\n  return null;\n}\n\n/**\n * GraphIndex — builds and updates the three memory graphs.\n *\n * Usage (orchestrator):\n *   this.graphIndex = new GraphIndex(config.memoryDir, config);\n *\n *   // After each memory write:\n *   await this.graphIndex.onMemoryWritten(memoryPath, frontmatter, threadId, recentInThread);\n */\nexport class GraphIndex {\n  private readonly memoryDir: string;\n  private readonly cfg: GraphConfig;\n\n  // Cache for readAllEdges() result.  With 30k+ entity edges (6 MB JSONL) the\n  // file read + JSON parse takes 2-4 s per call.  This instance-level cache\n  // eliminates that overhead on every spreadingActivation() call; it is\n  // invalidated (set to null) in onMemoryWritten() so new edges appear promptly.\n  private edgeCache: { allEdges: GraphEdge[]; loadedAt: number } | null = null;\n  private static readonly EDGE_CACHE_TTL_MS = 300_000; // 5 minutes\n\n  constructor(memoryDir: string, cfg: GraphConfig) {\n    this.memoryDir = memoryDir;\n    this.cfg = cfg;\n  }\n\n  /** Clear the edge cache so the next spreadingActivation() re-reads from disk.\n   *  Call after any code path that appends edges outside of onMemoryWritten(). */\n  invalidateEdgeCache(): void {\n    this.edgeCache = null;\n  }\n\n  private async loadEdgesCached(): Promise<GraphEdge[]> {\n    if (\n      this.edgeCache &&\n      Date.now() - this.edgeCache.loadedAt < GraphIndex.EDGE_CACHE_TTL_MS\n    ) {\n      return this.edgeCache.allEdges;\n    }\n    const allEdges = await readAllEdges(this.memoryDir, {\n      entityGraphEnabled: this.cfg.entityGraphEnabled,\n      timeGraphEnabled: this.cfg.timeGraphEnabled,\n      causalGraphEnabled: this.cfg.causalGraphEnabled,\n    });\n    this.edgeCache = { allEdges, loadedAt: Date.now() };\n    return allEdges;\n  }\n\n  /**\n   * Called after a memory is written to disk.\n   *\n   * @param memoryPath - relative path from memoryDir (e.g. \"facts/2026-02-22/abc.md\")\n   * @param entityRef  - entityRef frontmatter field (if any)\n   * @param content    - full memory text (for causal detection)\n   * @param created    - ISO timestamp of this memory\n   * @param threadId   - current thread ID (for time graph)\n   * @param recentInThread - paths of the N most-recent memories in this thread (for time graph)\n   * @param entitySiblings - paths of other memories that share the same entityRef (for entity graph)\n   */\n  async onMemoryWritten(opts: {\n    memoryPath: string;\n    entityRef?: string;\n    content: string;\n    created: string;\n    threadId?: string;\n    recentInThread?: string[];\n    entitySiblings?: string[];\n    causalPredecessor?: string;\n  }): Promise<void> {\n    if (!this.cfg.multiGraphMemoryEnabled) return;\n    const ts = new Date().toISOString();\n\n    try {\n      // Entity graph\n      if (this.cfg.entityGraphEnabled && opts.entityRef && opts.entitySiblings?.length) {\n        const siblings = opts.entitySiblings.slice(0, this.cfg.maxEntityGraphEdgesPerMemory);\n        for (const sibling of siblings) {\n          await appendEdge(this.memoryDir, {\n            from: opts.memoryPath,\n            to: sibling,\n            type: \"entity\",\n            weight: 1.0,\n            label: opts.entityRef,\n            ts,\n          });\n        }\n      }\n\n      // Time graph — link to most recent memory in same thread\n      if (this.cfg.timeGraphEnabled && opts.threadId && opts.recentInThread?.length) {\n        const predecessor = opts.recentInThread[opts.recentInThread.length - 1];\n        if (predecessor && predecessor !== opts.memoryPath) {\n          await appendEdge(this.memoryDir, {\n            from: predecessor,\n            to: opts.memoryPath,\n            type: \"time\",\n            weight: 1.0,\n            label: opts.threadId,\n            ts,\n          });\n        }\n      }\n\n      // Causal graph\n      if (this.cfg.causalGraphEnabled && opts.causalPredecessor) {\n        const phrase = detectCausalPhrase(opts.content);\n        if (phrase) {\n          await appendEdge(this.memoryDir, {\n            from: opts.causalPredecessor,\n            to: opts.memoryPath,\n            type: \"causal\",\n            weight: 1.0,\n            label: phrase,\n            ts,\n          });\n        }\n      }\n    } catch (err) {\n      // Fail-open: graph write errors must never surface to caller\n      const { log } = await import(\"./logger.js\");\n      log.warn(`[graph] onMemoryWritten error: ${err}`);\n    } finally {\n      // Invalidate edge cache so spreadingActivation() picks up new edges.\n      // In `finally` so the cache is cleared even on partial write failure.\n      this.edgeCache = null;\n    }\n  }\n\n  /**\n   * Spreading activation BFS (SYNAPSE-inspired).\n   *\n   * Starting from `seeds`, traverse the combined graph for up to `maxSteps` hops.\n   * Each candidate gets an activation score = edge.weight × edgeConfidence × decay^hop.\n   *\n   * Issue #681 PR 3/3 — confidence-aware traversal:\n   *   - Each edge's `weight` is multiplied by its `confidence` (legacy edges\n   *     missing `confidence` are treated as 1.0, preserving prior behavior).\n   *   - Edges with `confidence < graphTraversalConfidenceFloor` are pruned and\n   *     contribute neither activation nor downstream neighbors.\n   *   - When `graphTraversalPageRankIterations > 0`, an additional PageRank-\n   *     style refinement pass redistributes activation along confidence-weighted\n   *     edges, sharpening the ranking among multi-hop candidates.\n   *   - Per-result provenance includes the highest-confidence edge that landed\n   *     on each candidate, so the X-ray surface can attribute pruning and\n   *     ranking decisions back to specific edges.\n   *\n   * @param seeds    - initial memory paths to expand from (e.g. QMD top results)\n   * @param maxSteps - max BFS hops (from config: maxGraphTraversalSteps)\n   * @returns Array of {path, score, edgeConfidence, ...} sorted descending, not including seed paths\n   */\n  async spreadingActivation(\n    seeds: string[],\n    maxSteps?: number,\n    opts?: {\n      /**\n       * Issue #681 — when `true`, bypasses the configured\n       * `graphTraversalConfidenceFloor` and includes low-confidence\n       * edges in traversal.  Equivalent to forcing the floor to `0`.\n       * Default `false` (floor from config is applied).\n       */\n      includeLowConfidence?: boolean;\n    },\n  ): Promise<Array<{\n    path: string;\n    score: number;\n    seed: string;\n    hopDepth: number;\n    decayedWeight: number;\n    graphType: \"entity\" | \"time\" | \"causal\";\n    /**\n     * Confidence of the edge that produced this candidate's recorded\n     * provenance (the strongest edge along the chosen entry path).\n     * In `[0, 1]`. Legacy edges without `confidence` surface as 1.0.\n     */\n    edgeConfidence: number;\n  }>> {\n    if (!this.cfg.multiGraphMemoryEnabled) return [];\n    const steps = maxSteps ?? this.cfg.maxGraphTraversalSteps;\n    const decay = this.cfg.graphActivationDecay;\n    // When `includeLowConfidence` is set, use floor=0 so all edges\n    // participate in traversal regardless of their decay state.\n    // Otherwise clamp the configured floor into [0, 1] so misconfiguration\n    // cannot (a) admit edges with negative confidence or (b) reject every\n    // edge.\n    const floor = opts?.includeLowConfidence === true\n      ? 0\n      : clampConfidenceFloor(this.cfg.graphTraversalConfidenceFloor);\n    const iterations = clampPageRankIterations(\n      this.cfg.graphTraversalPageRankIterations,\n    );\n\n    try {\n      const allEdges = await this.loadEdgesCached();\n\n      // Build adjacency index: from → edges, to → edges (bidirectional for entity/time, directional for causal).\n      // Edges below the confidence floor are pruned at index time so neither\n      // direct activation nor downstream BFS expansion can re-introduce them.\n      const adj = new Map<string, GraphEdge[]>();\n      for (const edge of allEdges) {\n        const conf = readEdgeConfidence(edge);\n        if (conf < floor) continue;\n        if (!adj.has(edge.from)) adj.set(edge.from, []);\n        adj.get(edge.from)!.push(edge);\n        // Entity and time edges are bidirectional\n        if (edge.type !== \"causal\") {\n          if (!adj.has(edge.to)) adj.set(edge.to, []);\n          adj.get(edge.to)!.push({ ...edge, from: edge.to, to: edge.from });\n        }\n      }\n\n      const seedSet = new Set(seeds);\n      const scores = new Map<string, number>(); // candidate path → accumulated activation score\n      const provenance = new Map<\n        string,\n        {\n          seed: string;\n          hopDepth: number;\n          decayedWeight: number;\n          graphType: \"entity\" | \"time\" | \"causal\";\n          edgeConfidence: number;\n        }\n      >();\n      const visited = new Set<string>(seeds);\n\n      // BFS queue: [nodePath, hop, seedPath]\n      const queue: Array<[string, number, string]> = seeds.map((s) => [s, 0, s]);\n\n      while (queue.length > 0) {\n        const [node, hop, sourceSeed] = queue.shift()!;\n        if (hop >= steps) continue;\n\n        const edges = adj.get(node) ?? [];\n        for (const edge of edges) {\n          const neighbor = edge.to === node ? edge.from : edge.to;\n          const conf = readEdgeConfidence(edge);\n          // Defense in depth: the adjacency build already drops sub-floor\n          // edges, but if a synthesized reverse edge ever bypassed that\n          // path, this guard keeps spreading activation honest.\n          if (conf < floor) continue;\n          const score = edge.weight * conf * Math.pow(decay, hop + 1);\n\n          if (!seedSet.has(neighbor)) {\n            const existing = scores.get(neighbor) ?? 0;\n            scores.set(neighbor, existing + score);\n\n            const prev = provenance.get(neighbor);\n            if (\n              !prev ||\n              hop + 1 < prev.hopDepth ||\n              (hop + 1 === prev.hopDepth && score > prev.decayedWeight)\n            ) {\n              provenance.set(neighbor, {\n                seed: sourceSeed,\n                hopDepth: hop + 1,\n                decayedWeight: score,\n                graphType: edge.type,\n                edgeConfidence: conf,\n              });\n            }\n          }\n\n          if (!visited.has(neighbor)) {\n            visited.add(neighbor);\n            queue.push([neighbor, hop + 1, sourceSeed]);\n          }\n        }\n      }\n\n      // Issue #681 PR 3/3 — optional PageRank-style refinement.\n      // Redistributes a node's accumulated activation along its outgoing\n      // edges, weighted by edge confidence. Damping is fixed at the\n      // canonical 0.85 so the ranking stays comparable across queries;\n      // the `iterations` knob bounds compute, not behavior shape.\n      if (iterations > 0 && scores.size > 1) {\n        applyPageRankRefinement(scores, adj, {\n          iterations,\n          floor,\n          damping: 0.85,\n        });\n      }\n\n      // Apply lateral inhibition if enabled (Synapse-inspired competitive suppression)\n      if (this.cfg.graphLateralInhibitionEnabled && scores.size > 1) {\n        const inhibited = applyLateralInhibition(scores, {\n          beta: this.cfg.graphLateralInhibitionBeta,\n          topM: this.cfg.graphLateralInhibitionTopM,\n        });\n        for (const [k, v] of inhibited) {\n          scores.set(k, v);\n        }\n      }\n\n      return Array.from(scores.entries())\n        .map(([p, score]) => ({\n          path: p,\n          score,\n          seed: provenance.get(p)?.seed ?? \"\",\n          hopDepth: provenance.get(p)?.hopDepth ?? 0,\n          decayedWeight: provenance.get(p)?.decayedWeight ?? 0,\n          graphType: provenance.get(p)?.graphType ?? \"entity\",\n          edgeConfidence: provenance.get(p)?.edgeConfidence ?? 1,\n        }))\n        .sort((a, b) => b.score - a.score);\n    } catch (err) {\n      const { log } = await import(\"./logger.js\");\n      log.warn(`[graph] spreadingActivation error: ${err}`);\n      return [];\n    }\n  }\n}\n\n/**\n * Clamp `graphTraversalConfidenceFloor` into the legal range `[0, 1]`.\n * Non-finite or non-numeric values fall back to the documented default\n * so misconfiguration cannot silently disable the floor or reject every edge.\n *\n * Exported for tests; call sites in `spreadingActivation` use it to make\n * the contract explicit at every boundary.\n */\nexport function clampConfidenceFloor(raw: unknown): number {\n  if (typeof raw !== \"number\" || !Number.isFinite(raw)) {\n    return DEFAULT_GRAPH_TRAVERSAL_CONFIDENCE_FLOOR;\n  }\n  if (raw < 0) return 0;\n  if (raw > 1) return 1;\n  return raw;\n}\n\n/**\n * Clamp `graphTraversalPageRankIterations` into a non-negative integer.\n * Negative or non-finite values fall back to 0 (disable refinement) so\n * misconfiguration cannot stall recall in an unbounded loop.\n */\nexport function clampPageRankIterations(raw: unknown): number {\n  if (typeof raw !== \"number\" || !Number.isFinite(raw)) return 0;\n  if (raw <= 0) return 0;\n  return Math.floor(raw);\n}\n\n/**\n * PageRank-style refinement on top of the BFS activation map.\n *\n * Each iteration redistributes a fraction of every node's score along\n * its outgoing edges, scaled by edge confidence. Confidence below\n * `floor` is filtered out before redistribution, mirroring the BFS\n * pruning rule. Mutates `scores` in place.\n *\n * Exported for tests; in production, call sites pass the same adjacency\n * map already used by BFS so behavior stays consistent.\n */\nexport function applyPageRankRefinement(\n  scores: Map<string, number>,\n  adj: Map<string, GraphEdge[]>,\n  opts: { iterations: number; floor: number; damping: number },\n): void {\n  const { iterations, floor, damping } = opts;\n  if (iterations <= 0 || scores.size === 0) return;\n  const safeDamping = Math.min(1, Math.max(0, damping));\n\n  // Pre-compute confidence-weighted out-edge totals for normalization.\n  // Done once per refinement, not per iteration, since adjacency is\n  // immutable inside the loop.\n  //\n  // Codex P1 (#735): the denominator MUST be computed over the same\n  // eligible-neighbor set the iteration redistributes into — i.e.\n  // edges whose neighbor is in `scores`. Counting edges-to-seeds (or\n  // edges-to-unseen-nodes) in the denominator while dropping their\n  // flow during iteration leaks `safeDamping × score` every pass and\n  // collapses leaf candidates' scores instead of just re-ranking them.\n  const eligible = (edge: GraphEdge, fromNode: string): boolean => {\n    if (readEdgeConfidence(edge) < floor) return false;\n    const neighbor = edge.to === fromNode ? edge.from : edge.to;\n    return scores.has(neighbor);\n  };\n  const outboundTotal = new Map<string, number>();\n  for (const [node, edges] of adj.entries()) {\n    if (!scores.has(node)) continue; // only candidate nodes redistribute\n    let sum = 0;\n    for (const edge of edges) {\n      if (!eligible(edge, node)) continue;\n      sum += readEdgeConfidence(edge) * edge.weight;\n    }\n    if (sum > 0) outboundTotal.set(node, sum);\n  }\n\n  for (let i = 0; i < iterations; i += 1) {\n    const next = new Map<string, number>();\n    // Teleport / damping floor: every node retains `(1 - damping) * score`\n    // of its current activation so dangling nodes do not bleed to zero.\n    for (const [node, score] of scores) {\n      next.set(node, (1 - safeDamping) * score);\n    }\n    for (const [node, score] of scores) {\n      const outEdges = adj.get(node);\n      const total = outboundTotal.get(node);\n      // Dangling-node fallback: when a candidate has zero eligible\n      // outflow (no in-scores neighbors above the floor), the\n      // `safeDamping × score` portion would otherwise evaporate. Keep\n      // it on `node` so total mass is conserved and the score reflects\n      // the candidate's standing rather than its in-degree topology.\n      if (!outEdges || outEdges.length === 0 || !total || total <= 0) {\n        next.set(node, (next.get(node) ?? 0) + safeDamping * score);\n        continue;\n      }\n      for (const edge of outEdges) {\n        if (!eligible(edge, node)) continue;\n        const conf = readEdgeConfidence(edge);\n        const neighbor = edge.to === node ? edge.from : edge.to;\n        const flow = safeDamping * score * ((conf * edge.weight) / total);\n        next.set(neighbor, (next.get(neighbor) ?? 0) + flow);\n      }\n    }\n    for (const [node, score] of next) {\n      scores.set(node, score);\n    }\n  }\n}\n\n/**\n * Lateral inhibition (Synapse-inspired).\n *\n * For each node, the top-M higher-activation competitors exert inhibition\n * proportional to their activation difference. Output is clamped to [0, ∞).\n *\n * No sigmoid is applied here — downstream `normalizeGraphActivationScore`\n * already applies x/(1+x) soft squash, so adding a sigmoid would double-\n * normalize and cap graph influence at ~50%.\n *\n * Formula: u_hat_i = max(0, u_i - beta * sum_{k in top-M where u_k > u_i}(u_k - u_i))\n *\n * When beta=0 or topM=0, returns original scores unchanged (no-op).\n */\nexport function applyLateralInhibition(\n  scores: Map<string, number>,\n  opts: { beta: number; topM: number },\n): Map<string, number> {\n  const { beta, topM } = opts;\n  if (beta === 0 || topM === 0) return new Map(scores);\n\n  const sorted = Array.from(scores.entries()).sort((a, b) => b[1] - a[1]);\n  const topCompetitors = sorted.slice(0, topM);\n\n  const result = new Map<string, number>();\n  for (const [node, u] of scores) {\n    let inhibition = 0;\n    for (const [, uK] of topCompetitors) {\n      if (uK > u) {\n        inhibition += uK - u;\n      }\n    }\n    result.set(node, Math.max(0, u - beta * inhibition));\n  }\n\n  return result;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-MG7NA5H3.js → chunk-4Q73JBSM.js}

@@ -1,16 +1,16 @@
 import {
   DEFAULT_TRANSFER_EXCLUDE_DIRS
-} from "./chunk-I6K5FBRQ.js";
+} from "./chunk-UI3NYK34.js";
 import {
   prepareSafeArchiveRoot,
   resolveSafeArchiveTarget,
   sha256Bytes,
   validateArchiveRelativePath
-} from "./chunk-AGZQD76C.js";
+} from "./chunk-GCGJW34D.js";
 import {
   MAGIC_HEADER_SIZE,
   isEncryptedFile
-} from "./chunk-MXFBBHJU.js";
+} from "./chunk-KJMYHC7K.js";
 import {
   parseFlexibleIsoTimestamp
 } from "./chunk-P7FMDTKL.js";
@@ -378,12 +378,11 @@ async function readPlainFileContentChunk(options) {
     await handle.close();
   }
 }
-async function buildOfflineSyncSnapshot(options) {
+async function* iterateOfflineSyncSnapshotFileRecords(options) {
   const rootAbs = path.resolve(options.root);
-  const root = await prepareSafeArchiveRoot(rootAbs, "buildOfflineSyncSnapshot", "root");
+  const root = await prepareSafeArchiveRoot(rootAbs, "iterateOfflineSyncSnapshotFileRecords", "root");
   const includeTranscripts = options.includeTranscripts !== false;
-  const files = [];
-  async function walk(dirAbs) {
+  async function* walk(dirAbs) {
     let entries = await readdir(dirAbs, { withFileTypes: true });
     entries = entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
@@ -392,21 +391,26 @@ async function buildOfflineSyncSnapshot(options) {
       if (shouldExcludeRelPath(relPosix, includeTranscripts)) continue;
       if (entry.isSymbolicLink()) continue;
       if (entry.isDirectory()) {
-        await walk(abs);
+        yield* walk(abs);
         continue;
       }
       if (!entry.isFile()) continue;
-      files.push(await readOfflineSyncFileRecord({
+      yield await readOfflineSyncFileRecord({
         root,
         relPath: relPosix,
         filePath: abs,
         includeContent: options.includeContent === true,
         readFile: options.readFile,
         readFileDigest: options.readFileDigest
-      }));
+      });
     }
   }
-  await walk(root.abs);
+  yield* walk(root.abs);
+}
+async function buildOfflineSyncSnapshot(options) {
+  const includeTranscripts = options.includeTranscripts !== false;
+  const files = [];
+  for await (const file of iterateOfflineSyncSnapshotFileRecords(options)) files.push(file);
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
     schemaVersion: 1,
@@ -1575,6 +1579,7 @@ export {
   normalizeOfflineSyncSnapshot,
   normalizeOfflineSyncChangeset,
   shouldPreferIncomingOfflineRuntimeFile,
+  iterateOfflineSyncSnapshotFileRecords,
   buildOfflineSyncSnapshot,
   buildOfflineSyncSnapshotFromBase,
   buildOfflineSyncSnapshotForPaths,
@@ -1594,4 +1599,4 @@ export {
   normalizeOfflineSyncState,
   fileStatesFromSnapshot
 };
-//# sourceMappingURL=chunk-MG7NA5H3.js.map
+//# sourceMappingURL=chunk-4Q73JBSM.js.map