@remnic/core 1.1.12 → 1.1.13

package/dist/chunk-56K5QLHX.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\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): LcmSearchResult[] {\n    try {\n      const ftsQuery = sanitizeFtsQuery(query);\n      if (!ftsQuery) 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, limit);\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(limit);\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): LcmSearchWithContentResult[] {\n    try {\n      const ftsQuery = sanitizeFtsQuery(query);\n      if (!ftsQuery) 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, limit);\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(limit);\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    // Delete from FTS first\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\n    const result = this.db\n      .prepare(\"DELETE FROM lcm_messages WHERE created_at < ?\")\n      .run(cutoff);\n    return result.changes;\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-5RGLBDQF.js

@@ -0,0 +1,596 @@
+import {
+  scanSignals
+} from "./chunk-XYIK4LF6.js";
+import {
+  log
+} from "./chunk-2ODBA7MQ.js";
+
+// src/buffer.ts
+var MAX_BUFFER_ENTRY_COUNT = 200;
+var SmartBuffer = class {
+  constructor(config, storage, surpriseProbe = null) {
+    this.config = config;
+    this.storage = storage;
+    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };
+    this.surpriseProbe = surpriseProbe;
+  }
+  config;
+  storage;
+  state;
+  loaded = false;
+  loadPromise = null;
+  surpriseProbe;
+  mutationChain = Promise.resolve();
+  /**
+   * Serialized write chain for `BUFFER_SURPRISE` telemetry events.
+   *
+   * The telemetry path is fire-and-forget (`addTurn` does not await the
+   * ledger append), but multiple concurrent appends would still settle
+   * out of order under variable filesystem latency. The report path
+   * assumes chronological ordering — it slices the tail of the ledger
+   * and treats the most recent entry as the current threshold in force.
+   * Chaining ensures each append only runs after the previous settles,
+   * preserving wall-clock order.
+   *
+   * We include a `.catch` on every link so a rejected append does not
+   * poison the chain (CLAUDE.md rule #40).
+   */
+  surpriseTelemetryWriteChain = Promise.resolve();
+  enqueueMutation(op) {
+    const run = this.mutationChain.catch(() => {
+    }).then(op);
+    this.mutationChain = run.catch(() => {
+    });
+    return run;
+  }
+  entryFor(key) {
+    this.state.entries ??= {};
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      key = `__safe_${key}`;
+    }
+    if (Object.hasOwn(this.state.entries, key)) {
+      const stored = this.state.entries[key];
+      if (stored && typeof stored === "object" && Array.isArray(stored.turns)) {
+        return stored;
+      }
+    }
+    const created = {
+      turns: [],
+      lastExtractionAt: null,
+      extractionCount: 0
+    };
+    this.state.entries[key] = created;
+    return created;
+  }
+  peekEntry(key) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      key = `__safe_${key}`;
+    }
+    const existing = this.state.entries?.[key];
+    if (existing) return existing;
+    if (key !== "default") return null;
+    return {
+      turns: Array.isArray(this.state.turns) ? this.state.turns : [],
+      lastExtractionAt: this.state.lastExtractionAt ?? null,
+      extractionCount: typeof this.state.extractionCount === "number" ? this.state.extractionCount : 0
+    };
+  }
+  normalizeState(state) {
+    const entries = state.entries ?? {};
+    if (!entries.default) {
+      entries.default = {
+        turns: Array.isArray(state.turns) ? [...state.turns] : [],
+        lastExtractionAt: state.lastExtractionAt ?? null,
+        extractionCount: typeof state.extractionCount === "number" ? state.extractionCount : 0
+      };
+    }
+    return {
+      turns: entries.default.turns,
+      lastExtractionAt: entries.default.lastExtractionAt,
+      extractionCount: entries.default.extractionCount,
+      entries
+    };
+  }
+  entryActivityAt(entry) {
+    const lastTurnAt = entry.turns.reduce((latest, turn) => {
+      const parsed = Date.parse(turn.timestamp);
+      return Number.isFinite(parsed) ? Math.max(latest, parsed) : latest;
+    }, -1);
+    const lastExtractionAt = typeof entry.lastExtractionAt === "string" ? Date.parse(entry.lastExtractionAt) : Number.NaN;
+    return Math.max(
+      lastTurnAt,
+      Number.isFinite(lastExtractionAt) ? lastExtractionAt : -1
+    );
+  }
+  pruneEntries(retainKeys) {
+    const entries = this.state.entries;
+    if (!entries) return;
+    const keys = Object.keys(entries);
+    if (keys.length <= MAX_BUFFER_ENTRY_COUNT) return;
+    const insertionOrder = new Map(keys.map((key, index) => [key, index]));
+    const removable = keys.filter((key) => key !== "default" && !retainKeys.includes(key)).filter((key) => (entries[key]?.turns.length ?? 0) === 0).sort((left, right) => {
+      const leftAt = this.entryActivityAt(entries[left] ?? {
+        turns: [],
+        lastExtractionAt: null,
+        extractionCount: 0
+      });
+      const rightAt = this.entryActivityAt(entries[right] ?? {
+        turns: [],
+        lastExtractionAt: null,
+        extractionCount: 0
+      });
+      if (leftAt !== rightAt) return leftAt - rightAt;
+      return (insertionOrder.get(left) ?? 0) - (insertionOrder.get(right) ?? 0);
+    });
+    const removableCount = Math.max(0, keys.length - MAX_BUFFER_ENTRY_COUNT);
+    for (const key of removable.slice(0, removableCount)) {
+      delete entries[key];
+    }
+  }
+  async loadUnlocked() {
+    if (this.loaded) return;
+    if (!this.loadPromise) {
+      this.loadPromise = this.storage.loadBuffer().then((state) => {
+        this.state = this.normalizeState(state);
+        this.loaded = true;
+      }).finally(() => {
+        this.loadPromise = null;
+      });
+    }
+    await this.loadPromise;
+  }
+  async load() {
+    await this.enqueueMutation(async () => this.loadUnlocked());
+  }
+  /**
+   * Reset the buffer to an empty, usable state.
+   * Called when the persisted buffer file is corrupt and load() fails,
+   * so the buffer can still accept new turns for the rest of the session.
+   */
+  resetToEmpty() {
+    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };
+    this.loaded = true;
+  }
+  async saveUnlocked() {
+    await this.storage.saveBuffer(this.state);
+  }
+  async save() {
+    await this.enqueueMutation(async () => this.saveUnlocked());
+  }
+  async addTurn(bufferKey, turn) {
+    return (await this.addTurnWithOutcome(bufferKey, turn)).decision;
+  }
+  async addTurnWithOutcome(bufferKey, turn) {
+    const mutation = await this.enqueueMutation(() => this.recordTurnUnlocked(bufferKey, turn));
+    let decision = mutation.decision;
+    let extractionTurns;
+    if (decision === "keep_buffering" && this.config.bufferSurpriseTriggerEnabled && this.surpriseProbe !== null && // Matching the existing "smart" branch: surprise is a lower-tier
+    // novelty signal that should not second-guess a high-signal hit
+    // (which already flushes) or fight `every_n` / `time_based` modes.
+    this.config.triggerMode === "smart" && mutation.signalLevel !== "high") {
+      const surprise = await this.computeSurpriseSafe(bufferKey, turn, mutation.priorTurns);
+      if (surprise !== null) {
+        const shouldPromote = surprise > this.config.bufferSurpriseThreshold;
+        let triggered = false;
+        if (shouldPromote) {
+          const currentTurns = await this.getExtractionTurnsIfTurnSnapshotStillCurrent(
+            bufferKey,
+            mutation.turnSnapshot
+          );
+          if (currentTurns) {
+            log.debug(
+              `buffer[${bufferKey}]: surprise=${surprise.toFixed(3)} > threshold=${this.config.bufferSurpriseThreshold} \u2192 extract_now`
+            );
+            decision = "extract_now";
+            triggered = true;
+            extractionTurns = currentTurns;
+          } else {
+            log.debug(
+              `buffer[${bufferKey}]: surprise=${surprise.toFixed(3)} ignored because buffer changed before probe resolved`
+            );
+          }
+        }
+        this.queueSurpriseTelemetryWrite({
+          bufferKey,
+          turnRole: turn.role,
+          sessionKey: typeof turn.sessionKey === "string" ? turn.sessionKey : null,
+          surpriseScore: surprise,
+          triggered,
+          turnCountInWindow: mutation.turnCountInWindow,
+          // Stamp at decision time so backpressure on the write chain
+          // does not shift the event's apparent moment away from when
+          // the turn was actually scored.
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          // Snapshot the threshold used to compute `triggered` so a
+          // concurrent config mutation cannot retroactively change
+          // what the ledger row claims the decision was against.
+          threshold: this.config.bufferSurpriseThreshold
+        });
+      }
+    }
+    log.debug(
+      `buffer[${bufferKey}]: ${mutation.turnCountInWindow} turns, signal=${mutation.signalLevel}, decision=${decision}`
+    );
+    return extractionTurns ? { decision, extractionTurns } : { decision };
+  }
+  async recordTurnUnlocked(bufferKey, turn) {
+    await this.loadUnlocked();
+    const entry = this.entryFor(bufferKey);
+    const priorTurns = entry.turns.slice();
+    entry.turns.push(turn);
+    const turnSnapshot = copyBufferTurn(turn);
+    if (bufferKey === "default") {
+      this.state.turns = entry.turns;
+    }
+    const signal = scanSignals(turn.content, this.config.highSignalPatterns);
+    const decision = this.evaluate(entry, signal.level);
+    const turnCountInWindow = entry.turns.length;
+    this.pruneEntries([bufferKey]);
+    await this.saveUnlocked();
+    return {
+      decision,
+      signalLevel: signal.level,
+      priorTurns,
+      turnSnapshot,
+      turnCountInWindow
+    };
+  }
+  async getExtractionTurnsIfTurnSnapshotStillCurrent(bufferKey, turnSnapshot) {
+    return this.enqueueMutation(async () => {
+      await this.loadUnlocked();
+      const entry = this.peekEntry(bufferKey);
+      if (!entry) return null;
+      const stillCurrent = entry.turns.some(
+        (turn) => bufferTurnsEqual(turn, turnSnapshot)
+      );
+      if (!stillCurrent) return null;
+      const retained = entry.retainedTurns ?? [];
+      return [...retained, ...entry.turns];
+    });
+  }
+  /**
+   * Enqueue a telemetry append on the serialized write chain.
+   *
+   * The chain is a classic `writeChain = writeChain.then(fn).catch(...)`
+   * — each link waits for the previous to settle before its append
+   * starts, so out-of-order chronology cannot happen even under
+   * variable filesystem latency. We always attach `.catch` so one
+   * rejection does not poison the chain for the rest of the session
+   * (CLAUDE.md rule #40). The error is logged through
+   * `emitSurpriseEventSafe` itself, which swallows its own rejections.
+   *
+   * Public surface is deliberately narrow — only `addTurn` should call
+   * this, so the surprise telemetry path stays centralized.
+   */
+  queueSurpriseTelemetryWrite(params) {
+    this.surpriseTelemetryWriteChain = this.surpriseTelemetryWriteChain.then(() => this.emitSurpriseEventSafe(params)).catch(() => {
+    });
+  }
+  /**
+   * Append a single `BUFFER_SURPRISE` telemetry row (issue #563 PR 3).
+   *
+   * Deliberately swallows write errors: the buffer must never fail to
+   * record a turn because the observation ledger is read-only, out of
+   * disk, or otherwise unhappy. The log line at debug lets operators
+   * confirm the path fired without polluting the error channel.
+   */
+  async emitSurpriseEventSafe(params) {
+    const storage = this.storage;
+    if (typeof storage.appendBufferSurpriseEvents !== "function") {
+      return;
+    }
+    const event = {
+      event: "BUFFER_SURPRISE",
+      // Use the decision-time stamp captured when the event was
+      // queued, NOT `Date.now()` here — backpressure on the write
+      // chain could otherwise shift timestamps into the future relative
+      // to when the turn was scored.
+      timestamp: params.timestamp,
+      bufferKey: params.bufferKey,
+      sessionKey: params.sessionKey,
+      turnRole: params.turnRole,
+      surpriseScore: params.surpriseScore,
+      // Use the snapshotted threshold from the queue entry, not the
+      // live config — see `SurpriseTelemetryQueueEntry.threshold`
+      // doc for the rationale.
+      threshold: params.threshold,
+      triggeredFlush: params.triggered,
+      turnCountInWindow: params.turnCountInWindow
+    };
+    try {
+      await storage.appendBufferSurpriseEvents([event]);
+    } catch (err) {
+      log.debug(
+        `buffer[${params.bufferKey}]: surprise telemetry write failed, continuing: ${describeError(err)}`
+      );
+    }
+  }
+  /**
+   * Invoke the injected surprise probe defensively. Any error (probe throws,
+   * embedder unavailable, timeout) is swallowed and logged at debug: the
+   * surprise path must never crash the happy-path trigger evaluation. A
+   * `null` return indicates "no score available, fall through to existing
+   * triggers".
+   */
+  async computeSurpriseSafe(bufferKey, turn, priorTurns) {
+    if (!this.surpriseProbe) return null;
+    try {
+      const score = await probeWithTimeout(
+        this.surpriseProbe.scoreTurn(bufferKey, turn, priorTurns),
+        this.config.bufferSurpriseProbeTimeoutMs
+      );
+      if (score === null) return null;
+      if (typeof score !== "number" || !Number.isFinite(score)) {
+        log.debug(
+          `buffer[${bufferKey}]: surprise probe returned non-finite score (${String(score)}), ignoring`
+        );
+        return null;
+      }
+      if (score < 0) return 0;
+      if (score > 1) return 1;
+      return score;
+    } catch (err) {
+      log.debug(
+        `buffer[${bufferKey}]: surprise probe failed, falling back to existing triggers: ${describeError(err)}`
+      );
+      return null;
+    }
+  }
+  evaluate(entry, signalLevel) {
+    if (this.config.triggerMode === "smart") {
+      if (signalLevel === "high") return "extract_now";
+      if (entry.turns.length >= this.config.bufferMaxTurns) {
+        return "extract_batch";
+      }
+      if (entry.lastExtractionAt) {
+        const elapsed = Date.now() - new Date(entry.lastExtractionAt).getTime();
+        if (elapsed >= this.config.bufferMaxMinutes * 6e4) {
+          return "extract_batch";
+        }
+      }
+      return "keep_buffering";
+    }
+    if (this.config.triggerMode === "every_n") {
+      return entry.turns.length >= this.config.bufferMaxTurns ? "extract_batch" : "keep_buffering";
+    }
+    if (this.config.triggerMode === "time_based") {
+      if (!entry.lastExtractionAt) {
+        return entry.turns.length >= this.config.bufferMaxTurns ? "extract_batch" : "keep_buffering";
+      }
+      const elapsed = Date.now() - new Date(entry.lastExtractionAt).getTime();
+      return elapsed >= this.config.bufferMaxMinutes * 6e4 ? "extract_batch" : "keep_buffering";
+    }
+    return "keep_buffering";
+  }
+  getTurns(bufferKey = "default") {
+    const entry = this.peekEntry(bufferKey);
+    if (!entry) return [];
+    const retained = entry.retainedTurns ?? [];
+    return [...retained, ...entry.turns];
+  }
+  /**
+   * Retain a subset of the current turns across `clearAfterExtraction` so a
+   * future extraction pass sees the context behind a deferred candidate
+   * (issue #562, PR 2). Callers pass the turns that were seen during the
+   * current extraction; the buffer keeps the tail (latest `max` turns) as
+   * the retention window. Passing an empty array or `max <= 0` clears the
+   * retention slot instead.
+   */
+  async retainDeferredTurns(bufferKey, turns, max = 10) {
+    await this.enqueueMutation(async () => {
+      await this.loadUnlocked();
+      const entry = this.entryFor(bufferKey);
+      if (!Array.isArray(turns) || turns.length === 0 || max <= 0) {
+        delete entry.retainedTurns;
+      } else {
+        const tail = turns.slice(-max);
+        entry.retainedTurns = tail.map((t) => {
+          const copy = {
+            role: t.role,
+            content: typeof t.content === "string" ? t.content : "",
+            timestamp: typeof t.timestamp === "string" ? t.timestamp : (/* @__PURE__ */ new Date()).toISOString()
+          };
+          if (typeof t.sessionKey === "string") copy.sessionKey = t.sessionKey;
+          if (typeof t.logicalSessionKey === "string") {
+            copy.logicalSessionKey = t.logicalSessionKey;
+          }
+          if (t.providerThreadId === null || typeof t.providerThreadId === "string") {
+            copy.providerThreadId = t.providerThreadId;
+          }
+          if (typeof t.turnFingerprint === "string") {
+            copy.turnFingerprint = t.turnFingerprint;
+          }
+          if (typeof t.persistProcessedFingerprint === "boolean") {
+            copy.persistProcessedFingerprint = t.persistProcessedFingerprint;
+          }
+          return copy;
+        });
+      }
+      await this.saveUnlocked();
+    });
+  }
+  /**
+   * Return the current retention window (issue #562, PR 2). Primarily for
+   * tests and diagnostics.
+   */
+  getRetainedDeferredTurns(bufferKey = "default") {
+    const entry = this.peekEntry(bufferKey);
+    return entry?.retainedTurns ? [...entry.retainedTurns] : [];
+  }
+  async findBufferKeyForSession(sessionKey) {
+    const bufferKeys = await this.findBufferKeysForSession(sessionKey);
+    return bufferKeys[0] ?? null;
+  }
+  async findBufferKeysForSession(sessionKey) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0) return [];
+    await this.mutationChain.catch(() => {
+    });
+    await this.load();
+    const matches = [];
+    const directEntry = this.peekEntry(sessionKey);
+    if ((directEntry?.turns.length ?? 0) > 0) {
+      matches.push(sessionKey);
+    }
+    const entries = this.state.entries ?? {};
+    for (const [bufferKey, entry] of Object.entries(entries)) {
+      if (!matches.includes(bufferKey) && entry.turns.some(
+        (turn) => typeof turn.sessionKey === "string" && turn.sessionKey === sessionKey
+      )) {
+        matches.push(bufferKey);
+      }
+    }
+    return matches;
+  }
+  async clearAfterExtraction(bufferKey = "default", extractedTurns) {
+    await this.enqueueMutation(async () => {
+      await this.loadUnlocked();
+      const entry = this.entryFor(bufferKey);
+      if (Array.isArray(extractedTurns)) {
+        const liveExtractedTurns = liveTurnsFromExtractionSnapshot(
+          entry,
+          extractedTurns
+        );
+        let clearedLiveTurns = false;
+        if (liveExtractedTurns.length > 0) {
+          const matchedCount = matchingQueuedExtractionPrefixLength(
+            entry.turns,
+            liveExtractedTurns
+          );
+          if (matchedCount > 0) {
+            entry.turns = entry.turns.slice(matchedCount);
+            clearedLiveTurns = true;
+          } else {
+            log.debug(
+              `buffer[${bufferKey}]: extraction clear skipped because live turns changed before clear`
+            );
+          }
+        }
+        if (!clearedLiveTurns) {
+          await this.saveUnlocked();
+          return;
+        }
+      } else {
+        entry.turns = [];
+      }
+      entry.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
+      entry.extractionCount += 1;
+      if (bufferKey === "default") {
+        this.state.turns = entry.turns;
+        this.state.lastExtractionAt = entry.lastExtractionAt;
+        this.state.extractionCount = entry.extractionCount;
+      }
+      this.pruneEntries([bufferKey]);
+      await this.saveUnlocked();
+    });
+  }
+  getExtractionCount(bufferKey = "default") {
+    return this.peekEntry(bufferKey)?.extractionCount ?? 0;
+  }
+  /**
+   * Await any pending `BUFFER_SURPRISE` telemetry writes.
+   *
+   * The telemetry path is fire-and-forget from the hot path's point of
+   * view, but tests and before-exit hooks sometimes need to make sure
+   * the ledger has been flushed before they assert on its contents or
+   * close the process. This method resolves once the current chain
+   * head has settled; new writes scheduled after this call return a
+   * separate, later settlement.
+   *
+   * Never throws — the chain already catches its own rejections.
+   */
+  async flushSurpriseTelemetry() {
+    await this.surpriseTelemetryWriteChain;
+  }
+};
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  if (err === null) return "null";
+  if (err === void 0) return "undefined";
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function copyBufferTurn(turn) {
+  const copy = {
+    role: turn.role,
+    content: turn.content,
+    timestamp: turn.timestamp
+  };
+  if (typeof turn.sessionKey === "string") copy.sessionKey = turn.sessionKey;
+  if (typeof turn.logicalSessionKey === "string") {
+    copy.logicalSessionKey = turn.logicalSessionKey;
+  }
+  if (turn.providerThreadId === null || typeof turn.providerThreadId === "string") {
+    copy.providerThreadId = turn.providerThreadId;
+  }
+  if (typeof turn.turnFingerprint === "string") {
+    copy.turnFingerprint = turn.turnFingerprint;
+  }
+  if (typeof turn.persistProcessedFingerprint === "boolean") {
+    copy.persistProcessedFingerprint = turn.persistProcessedFingerprint;
+  }
+  return copy;
+}
+function bufferTurnsEqual(left, right) {
+  if (!left) return false;
+  return left.role === right.role && left.content === right.content && left.timestamp === right.timestamp && left.sessionKey === right.sessionKey && left.logicalSessionKey === right.logicalSessionKey && left.providerThreadId === right.providerThreadId && left.turnFingerprint === right.turnFingerprint && left.persistProcessedFingerprint === right.persistProcessedFingerprint;
+}
+function liveTurnsFromExtractionSnapshot(entry, extractedTurns) {
+  const retainedTurns = entry.retainedTurns ?? [];
+  if (retainedTurns.length > 0 && extractedTurns.length >= retainedTurns.length && retainedTurns.every(
+    (turn, index) => bufferTurnsEqual(extractedTurns[index], turn)
+  )) {
+    const withoutRetainedPrefix = extractedTurns.slice(retainedTurns.length);
+    if (withoutRetainedPrefix.length > 0 && matchingPrefixLength(entry.turns, withoutRetainedPrefix) > 0) {
+      return withoutRetainedPrefix;
+    }
+  }
+  return extractedTurns;
+}
+function matchingPrefixLength(liveTurns, extractedTurns) {
+  let index = 0;
+  while (index < liveTurns.length && index < extractedTurns.length && bufferTurnsEqual(liveTurns[index], extractedTurns[index])) {
+    index += 1;
+  }
+  return index;
+}
+function matchingQueuedExtractionPrefixLength(liveTurns, extractedTurns) {
+  let bestMatchedCount = 0;
+  for (let start = 0; start < extractedTurns.length; start += 1) {
+    const matchedCount = matchingPrefixLength(
+      liveTurns,
+      extractedTurns.slice(start)
+    );
+    if (matchedCount > bestMatchedCount) {
+      bestMatchedCount = matchedCount;
+      if (bestMatchedCount === liveTurns.length) break;
+    }
+  }
+  return bestMatchedCount;
+}
+var ProbeTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`probe exceeded ${timeoutMs}ms`);
+    this.name = "ProbeTimeoutError";
+  }
+};
+function probeWithTimeout(inflight, timeoutMs) {
+  let timer = null;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new ProbeTimeoutError(timeoutMs)), timeoutMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+  });
+  return Promise.race([inflight, timeout]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
+
+export {
+  SmartBuffer
+};
+//# sourceMappingURL=chunk-5RGLBDQF.js.map