@remnic/core 9.3.613 → 9.3.615

package/dist/chunk-IBTZEBUD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/buffer.ts"],"sourcesContent":["import { log } from \"./logger.js\";\nimport { scanSignals } from \"./signal.js\";\nimport type { StorageManager } from \"./storage.js\";\nimport type {\n  BufferEntryState,\n  BufferState,\n  BufferSurpriseEvent,\n  BufferTurn,\n  PluginConfig,\n  SignalLevel,\n} from \"./types.js\";\n\nexport type TriggerDecision = \"extract_now\" | \"extract_batch\" | \"keep_buffering\";\n\nexport interface AddTurnOutcome {\n  decision: TriggerDecision;\n  extractionTurns?: BufferTurn[];\n}\n\n/**\n * Optional surprise probe injected into `SmartBuffer`.\n *\n * Computes a D-MEM-style novelty score in `[0, 1]` for an incoming turn.\n * The buffer treats the probe as purely additive: if it is not provided, if\n * the feature flag is off, or if the probe throws/times out, the buffer\n * falls back to the existing signal/turn-count/time triggers unchanged.\n *\n * Callers are responsible for sampling recent memories and passing them\n * through the embedding pipeline — the buffer does not want to know about\n * storage, embeddings, or QMD.\n *\n * @param bufferKey Identifier for the active buffer (session/thread).\n * @param turn      The incoming turn whose novelty is being scored.\n * @param recentTurns Turns already buffered for this key (most recent first\n *                    is NOT guaranteed — treat as unordered corpus).\n * @returns A surprise score in `[0, 1]`, or `null` if no score could be\n *          produced (e.g. empty corpus, probe declined to embed).\n */\nexport interface BufferSurpriseProbe {\n  scoreTurn(\n    bufferKey: string,\n    turn: BufferTurn,\n    recentTurns: readonly BufferTurn[],\n  ): Promise<number | null>;\n}\n\nconst MAX_BUFFER_ENTRY_COUNT = 200;\n\n/**\n * Minimal data carried on the serialized telemetry write chain\n * (issue #563 PR 3).\n *\n * We intentionally do NOT capture the full `BufferTurn` here: under\n * slow filesystem latency the chain can back up, and retaining\n * `turn.content` for every pending append causes memory pressure on\n * large conversations. Only the fields the ledger row actually needs\n * cross the chain boundary.\n */\ninterface SurpriseTelemetryQueueEntry {\n  bufferKey: string;\n  turnRole: \"user\" | \"assistant\";\n  sessionKey: string | null;\n  surpriseScore: number;\n  triggered: boolean;\n  turnCountInWindow: number;\n  /**\n   * ISO timestamp captured at the moment the turn was scored, NOT when\n   * the ledger append eventually runs. Backpressure on the serialized\n   * write chain could otherwise shift event timestamps away from the\n   * real decision moment and distort the distribution report (p90\n   * inflated, current-threshold row misidentified).\n   */\n  timestamp: string;\n  /**\n   * Threshold value in force when `triggered` was computed. Must be\n   * snapshot here rather than read from `config` at emit time — a\n   * concurrent config change between queue and write would otherwise\n   * record `triggered=true` against a newer threshold the operator\n   * never set, distorting precision/recall interpretation.\n   */\n  threshold: number;\n}\n\ninterface AddTurnMutationResult {\n  decision: TriggerDecision;\n  signalLevel: SignalLevel;\n  priorTurns: BufferTurn[];\n  activeTurnsSnapshot: BufferTurn[];\n  retainedTurnsSnapshot: BufferTurn[];\n  turnCountInWindow: number;\n}\n\nexport class SmartBuffer {\n  private state: BufferState;\n  private loaded = false;\n  private loadPromise: Promise<void> | null = null;\n  private readonly surpriseProbe: BufferSurpriseProbe | null;\n  private mutationChain: Promise<unknown> = Promise.resolve();\n  /**\n   * Serialized write chain for `BUFFER_SURPRISE` telemetry events.\n   *\n   * The telemetry path is fire-and-forget (`addTurn` does not await the\n   * ledger append), but multiple concurrent appends would still settle\n   * out of order under variable filesystem latency. The report path\n   * assumes chronological ordering — it slices the tail of the ledger\n   * and treats the most recent entry as the current threshold in force.\n   * Chaining ensures each append only runs after the previous settles,\n   * preserving wall-clock order.\n   *\n   * We include a `.catch` on every link so a rejected append does not\n   * poison the chain (CLAUDE.md rule #40).\n   */\n  private surpriseTelemetryWriteChain: Promise<unknown> = Promise.resolve();\n\n  constructor(\n    private readonly config: PluginConfig,\n    private readonly storage: StorageManager,\n    surpriseProbe: BufferSurpriseProbe | null = null,\n  ) {\n    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };\n    this.surpriseProbe = surpriseProbe;\n  }\n\n  private enqueueMutation<T>(op: () => Promise<T>): Promise<T> {\n    const run = this.mutationChain.catch(() => {}).then(op);\n    this.mutationChain = run.catch(() => {});\n    return run;\n  }\n\n  private entryFor(key: string): BufferEntryState {\n    if (!this.state.entries) {\n      this.state.entries = Object.create(null) as NonNullable<BufferState[\"entries\"]>;\n    }\n    const entries = this.state.entries as NonNullable<BufferState[\"entries\"]>;\n    if (Object.hasOwn(entries, key)) {\n      const stored = entries[key];\n      // Guard against corrupted state/buffer.json — if the stored entry\n      // is not a valid object shape, discard it and recreate.\n      if (stored && typeof stored === \"object\" && Array.isArray(stored.turns)) {\n        return stored;\n      }\n      // Corrupted — fall through to recreate.\n    }\n    const created: BufferEntryState = {\n      turns: [],\n      lastExtractionAt: null,\n      extractionCount: 0,\n    };\n    entries[key] = created;\n    return created;\n  }\n\n  private peekEntry(key: string): BufferEntryState | null {\n    const existing = this.state.entries?.[key];\n    if (existing) return existing;\n    if (key !== \"default\") return null;\n    return {\n      turns: Array.isArray(this.state.turns) ? this.state.turns : [],\n      lastExtractionAt: this.state.lastExtractionAt ?? null,\n      extractionCount:\n        typeof this.state.extractionCount === \"number\" ? this.state.extractionCount : 0,\n    };\n  }\n\n  private normalizeState(state: BufferState): BufferState {\n    const entries = Object.assign(\n      Object.create(null),\n      state.entries ?? {},\n    ) as NonNullable<BufferState[\"entries\"]>;\n    if (!entries.default) {\n      entries.default = {\n        turns: Array.isArray(state.turns) ? [...state.turns] : [],\n        lastExtractionAt: state.lastExtractionAt ?? null,\n        extractionCount:\n          typeof state.extractionCount === \"number\" ? state.extractionCount : 0,\n      };\n    }\n    return {\n      turns: entries.default.turns,\n      lastExtractionAt: entries.default.lastExtractionAt,\n      extractionCount: entries.default.extractionCount,\n      entries,\n    };\n  }\n\n  private entryActivityAt(entry: BufferEntryState): number {\n    const lastTurnAt = entry.turns.reduce((latest, turn) => {\n      const parsed = Date.parse(turn.timestamp);\n      return Number.isFinite(parsed) ? Math.max(latest, parsed) : latest;\n    }, -1);\n    const lastExtractionAt =\n      typeof entry.lastExtractionAt === \"string\"\n        ? Date.parse(entry.lastExtractionAt)\n        : Number.NaN;\n    return Math.max(\n      lastTurnAt,\n      Number.isFinite(lastExtractionAt) ? lastExtractionAt : -1,\n    );\n  }\n\n  private pruneEntries(retainKeys: string[]): void {\n    const entries = this.state.entries;\n    if (!entries) return;\n    const keys = Object.keys(entries);\n    if (keys.length <= MAX_BUFFER_ENTRY_COUNT) return;\n\n    const insertionOrder = new Map(keys.map((key, index) => [key, index]));\n    const removable = keys\n      .filter((key) => key !== \"default\" && !retainKeys.includes(key))\n      .filter((key) => (entries[key]?.turns.length ?? 0) === 0)\n      .sort((left, right) => {\n        const leftAt = this.entryActivityAt(entries[left] ?? {\n          turns: [],\n          lastExtractionAt: null,\n          extractionCount: 0,\n        });\n        const rightAt = this.entryActivityAt(entries[right] ?? {\n          turns: [],\n          lastExtractionAt: null,\n          extractionCount: 0,\n        });\n        if (leftAt !== rightAt) return leftAt - rightAt;\n        return (insertionOrder.get(left) ?? 0) - (insertionOrder.get(right) ?? 0);\n      });\n\n    const removableCount = Math.max(0, keys.length - MAX_BUFFER_ENTRY_COUNT);\n    for (const key of removable.slice(0, removableCount)) {\n      delete entries[key];\n    }\n  }\n\n  private async loadUnlocked(): Promise<void> {\n    if (this.loaded) return;\n    if (!this.loadPromise) {\n      this.loadPromise = this.storage.loadBuffer()\n        .then((state) => {\n          this.state = this.normalizeState(state);\n          this.loaded = true;\n        })\n        .finally(() => {\n          this.loadPromise = null;\n        });\n    }\n    await this.loadPromise;\n  }\n\n  async load(): Promise<void> {\n    await this.enqueueMutation(async () => this.loadUnlocked());\n  }\n\n  /**\n   * Reset the buffer to an empty, usable state.\n   * Called when the persisted buffer file is corrupt and load() fails,\n   * so the buffer can still accept new turns for the rest of the session.\n   */\n  resetToEmpty(): void {\n    this.state = { turns: [], lastExtractionAt: null, extractionCount: 0 };\n    this.loaded = true;\n  }\n\n  private async saveUnlocked(): Promise<void> {\n    await this.storage.saveBuffer(this.state);\n  }\n\n  async save(): Promise<void> {\n    await this.enqueueMutation(async () => this.saveUnlocked());\n  }\n\n  async addTurn(bufferKey: string, turn: BufferTurn): Promise<TriggerDecision> {\n    return (await this.addTurnWithOutcome(bufferKey, turn)).decision;\n  }\n\n  async addTurnWithOutcome(\n    bufferKey: string,\n    turn: BufferTurn,\n  ): Promise<AddTurnOutcome> {\n    const mutation = await this.enqueueMutation(() => this.recordTurnUnlocked(bufferKey, turn));\n    let decision = mutation.decision;\n    let extractionTurns: BufferTurn[] | undefined;\n\n    // Surprise-gated flush (issue #563). Additive only: if the probe is\n    // disabled, unavailable, or the score is below threshold, the decision\n    // from the existing trigger logic stands. The probe only ever *promotes*\n    // `keep_buffering` → `extract_now`; it never suppresses an existing\n    // flush. This preserves the invariant that enabling surprise cannot\n    // *reduce* extraction frequency.\n    if (\n      decision === \"keep_buffering\" &&\n      this.config.bufferSurpriseTriggerEnabled &&\n      this.surpriseProbe !== null &&\n      // Matching the existing \"smart\" branch: surprise is a lower-tier\n      // novelty signal that should not second-guess a high-signal hit\n      // (which already flushes) or fight `every_n` / `time_based` modes.\n      this.config.triggerMode === \"smart\" &&\n      mutation.signalLevel !== \"high\"\n    ) {\n      const surprise = await this.computeSurpriseSafe(bufferKey, turn, mutation.priorTurns);\n      if (surprise !== null) {\n        const shouldPromote = surprise > this.config.bufferSurpriseThreshold;\n        let triggered = false;\n        if (shouldPromote) {\n          const currentTurns = await this.getExtractionTurnsIfBufferSnapshotStillCurrent(\n            bufferKey,\n            mutation.activeTurnsSnapshot,\n            mutation.retainedTurnsSnapshot,\n          );\n          if (currentTurns) {\n            log.debug(\n              `buffer[${bufferKey}]: surprise=${surprise.toFixed(3)} > threshold=${this.config.bufferSurpriseThreshold} → extract_now`,\n            );\n            decision = \"extract_now\";\n            triggered = true;\n            extractionTurns = currentTurns;\n          } else {\n            log.debug(\n              `buffer[${bufferKey}]: surprise=${surprise.toFixed(3)} ignored because buffer changed before probe resolved`,\n            );\n          }\n        }\n        // Emit telemetry on every scored turn — both triggering and\n        // non-triggering — so operators can fit the threshold to real\n        // traffic distributions. Fire-and-forget: `addTurn` does NOT\n        // await the ledger append, so slow/contended filesystems cannot\n        // add JSONL-append latency to every `processTurn`. But we DO\n        // serialize writes through a promise chain so concurrent\n        // appends settle in wall-clock order — the report path assumes\n        // chronological tail rows and reads the most recent as the\n        // \"current\" threshold.\n        //\n        // Project only the fields we need into the queue entry rather\n        // than capturing the full `BufferTurn` — under slow filesystem\n        // latency the chain can back up, and we must not retain the\n        // (potentially large) `turn.content` string for every pending\n        // append.\n        this.queueSurpriseTelemetryWrite({\n          bufferKey,\n          turnRole: turn.role,\n          sessionKey:\n            typeof turn.sessionKey === \"string\" ? turn.sessionKey : null,\n          surpriseScore: surprise,\n          triggered,\n          turnCountInWindow: mutation.turnCountInWindow,\n          // Stamp at decision time so backpressure on the write chain\n          // does not shift the event's apparent moment away from when\n          // the turn was actually scored.\n          timestamp: new Date().toISOString(),\n          // Snapshot the threshold used to compute `triggered` so a\n          // concurrent config mutation cannot retroactively change\n          // what the ledger row claims the decision was against.\n          threshold: this.config.bufferSurpriseThreshold,\n        });\n      }\n    }\n\n    log.debug(\n      `buffer[${bufferKey}]: ${mutation.turnCountInWindow} turns, signal=${mutation.signalLevel}, decision=${decision}`,\n    );\n    return extractionTurns ? { decision, extractionTurns } : { decision };\n  }\n\n  private async recordTurnUnlocked(bufferKey: string, turn: BufferTurn): Promise<AddTurnMutationResult> {\n    await this.loadUnlocked();\n    const entry = this.entryFor(bufferKey);\n    const priorTurns = entry.turns.slice();\n    entry.turns.push(turn);\n    const activeTurnsSnapshot = entry.turns.map(copyBufferTurn);\n    const retainedTurnsSnapshot = (entry.retainedTurns ?? []).map(copyBufferTurn);\n    if (bufferKey === \"default\") {\n      this.state.turns = entry.turns;\n    }\n\n    const signal = scanSignals(turn.content, this.config.highSignalPatterns);\n    const decision = this.evaluate(entry, signal.level);\n    const turnCountInWindow = entry.turns.length;\n\n    this.pruneEntries([bufferKey]);\n    await this.saveUnlocked();\n    return {\n      decision,\n      signalLevel: signal.level,\n      priorTurns,\n      activeTurnsSnapshot,\n      retainedTurnsSnapshot,\n      turnCountInWindow,\n    };\n  }\n\n  private async getExtractionTurnsIfBufferSnapshotStillCurrent(\n    bufferKey: string,\n    activeTurnsSnapshot: readonly BufferTurn[],\n    retainedTurnsSnapshot: readonly BufferTurn[],\n  ): Promise<BufferTurn[] | null> {\n    return this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      const entry = this.peekEntry(bufferKey);\n      if (!entry) return null;\n      const retained = entry.retainedTurns ?? [];\n      const stillCurrent =\n        bufferTurnArrayIsSuffixOfSnapshot(entry.turns, activeTurnsSnapshot) &&\n        bufferTurnArraysEqual(retained, retainedTurnsSnapshot);\n      if (!stillCurrent) return null;\n      return [...retained, ...entry.turns];\n    });\n  }\n\n  /**\n   * Enqueue a telemetry append on the serialized write chain.\n   *\n   * The chain is a classic `writeChain = writeChain.then(fn).catch(...)`\n   * — each link waits for the previous to settle before its append\n   * starts, so out-of-order chronology cannot happen even under\n   * variable filesystem latency. We always attach `.catch` so one\n   * rejection does not poison the chain for the rest of the session\n   * (CLAUDE.md rule #40). The error is logged through\n   * `emitSurpriseEventSafe` itself, which swallows its own rejections.\n   *\n   * Public surface is deliberately narrow — only `addTurn` should call\n   * this, so the surprise telemetry path stays centralized.\n   */\n  private queueSurpriseTelemetryWrite(params: SurpriseTelemetryQueueEntry): void {\n    this.surpriseTelemetryWriteChain = this.surpriseTelemetryWriteChain\n      .then(() => this.emitSurpriseEventSafe(params))\n      .catch(() => {\n        // `emitSurpriseEventSafe` already handles the logging. We\n        // swallow here only so one failure does not break the chain\n        // for future writes.\n      });\n  }\n\n  /**\n   * Append a single `BUFFER_SURPRISE` telemetry row (issue #563 PR 3).\n   *\n   * Deliberately swallows write errors: the buffer must never fail to\n   * record a turn because the observation ledger is read-only, out of\n   * disk, or otherwise unhappy. The log line at debug lets operators\n   * confirm the path fired without polluting the error channel.\n   */\n  private async emitSurpriseEventSafe(\n    params: SurpriseTelemetryQueueEntry,\n  ): Promise<void> {\n    const storage = this.storage as StorageManager & {\n      appendBufferSurpriseEvents?: (\n        events: BufferSurpriseEvent[],\n      ) => Promise<number>;\n    };\n    if (typeof storage.appendBufferSurpriseEvents !== \"function\") {\n      // Older StorageManager / test double without the telemetry sink.\n      // Silently skip — core path is still covered by the log line above.\n      return;\n    }\n    const event: BufferSurpriseEvent = {\n      event: \"BUFFER_SURPRISE\",\n      // Use the decision-time stamp captured when the event was\n      // queued, NOT `Date.now()` here — backpressure on the write\n      // chain could otherwise shift timestamps into the future relative\n      // to when the turn was scored.\n      timestamp: params.timestamp,\n      bufferKey: params.bufferKey,\n      sessionKey: params.sessionKey,\n      turnRole: params.turnRole,\n      surpriseScore: params.surpriseScore,\n      // Use the snapshotted threshold from the queue entry, not the\n      // live config — see `SurpriseTelemetryQueueEntry.threshold`\n      // doc for the rationale.\n      threshold: params.threshold,\n      triggeredFlush: params.triggered,\n      turnCountInWindow: params.turnCountInWindow,\n    };\n    try {\n      await storage.appendBufferSurpriseEvents([event]);\n    } catch (err) {\n      // Same guard as `computeSurpriseSafe`: non-Error rejections must\n      // not crash the telemetry helper, which would defeat the whole\n      // point of isolating the ledger write from the hot path.\n      log.debug(\n        `buffer[${params.bufferKey}]: surprise telemetry write failed, continuing: ${describeError(err)}`,\n      );\n    }\n  }\n\n  /**\n   * Invoke the injected surprise probe defensively. Any error (probe throws,\n   * embedder unavailable, timeout) is swallowed and logged at debug: the\n   * surprise path must never crash the happy-path trigger evaluation. A\n   * `null` return indicates \"no score available, fall through to existing\n   * triggers\".\n   */\n  private async computeSurpriseSafe(\n    bufferKey: string,\n    turn: BufferTurn,\n    priorTurns: readonly BufferTurn[],\n  ): Promise<number | null> {\n    if (!this.surpriseProbe) return null;\n    try {\n      // Hard timeout around the probe so a hung embedder cannot stall\n      // `addTurn()` before `save()`. A slow probe would otherwise\n      // prevent the just-appended turn from ever being persisted. The\n      // timeout is a soft bound — we race it against the probe, take\n      // whichever settles first, and treat the timeout as\n      // \"probe unavailable, fall through\" rather than an error that\n      // surfaces to the caller.\n      const score = await probeWithTimeout(\n        this.surpriseProbe.scoreTurn(bufferKey, turn, priorTurns),\n        this.config.bufferSurpriseProbeTimeoutMs,\n      );\n      if (score === null) return null;\n      if (typeof score !== \"number\" || !Number.isFinite(score)) {\n        log.debug(\n          `buffer[${bufferKey}]: surprise probe returned non-finite score (${String(score)}), ignoring`,\n        );\n        return null;\n      }\n      // Defensive clamp: formula lives in buffer-surprise.ts, but we never\n      // want a misbehaving probe to inject an out-of-range value into the\n      // threshold comparison.\n      if (score < 0) return 0;\n      if (score > 1) return 1;\n      return score;\n    } catch (err) {\n      // `err` may be any thrown value — `throw null` and\n      // `Promise.reject(\"x\")` are both legal. Accessing `.message` on a\n      // non-Error would itself throw and defeat the failure-isolation\n      // contract, so describe the value safely.\n      log.debug(\n        `buffer[${bufferKey}]: surprise probe failed, falling back to existing triggers: ${describeError(err)}`,\n      );\n      return null;\n    }\n  }\n\n  private evaluate(entry: BufferEntryState, signalLevel: SignalLevel): TriggerDecision {\n    if (this.config.triggerMode === \"smart\") {\n      if (signalLevel === \"high\") return \"extract_now\";\n\n      if (entry.turns.length >= this.config.bufferMaxTurns) {\n        return \"extract_batch\";\n      }\n\n      if (entry.lastExtractionAt) {\n        const elapsed =\n          Date.now() - new Date(entry.lastExtractionAt).getTime();\n        if (elapsed >= this.config.bufferMaxMinutes * 60_000) {\n          return \"extract_batch\";\n        }\n      }\n\n      return \"keep_buffering\";\n    }\n\n    if (this.config.triggerMode === \"every_n\") {\n      return entry.turns.length >= this.config.bufferMaxTurns\n        ? \"extract_batch\"\n        : \"keep_buffering\";\n    }\n\n    if (this.config.triggerMode === \"time_based\") {\n      if (!entry.lastExtractionAt) {\n        return entry.turns.length >= this.config.bufferMaxTurns\n          ? \"extract_batch\"\n          : \"keep_buffering\";\n      }\n      const elapsed =\n        Date.now() - new Date(entry.lastExtractionAt).getTime();\n      return elapsed >= this.config.bufferMaxMinutes * 60_000\n        ? \"extract_batch\"\n        : \"keep_buffering\";\n    }\n\n    return \"keep_buffering\";\n  }\n\n  getTurns(bufferKey = \"default\"): BufferTurn[] {\n    const entry = this.peekEntry(bufferKey);\n    if (!entry) return [];\n    const retained = entry.retainedTurns ?? [];\n    // Retained turns (from a previous defer verdict, issue #562 PR 2) are\n    // prepended so the chronological order — oldest context first — is\n    // preserved for the next extraction pass.\n    return [...retained, ...entry.turns];\n  }\n\n  /**\n   * Retain a subset of the current turns across `clearAfterExtraction` so a\n   * future extraction pass sees the context behind a deferred candidate\n   * (issue #562, PR 2). Callers pass the turns that were seen during the\n   * current extraction; the buffer keeps the tail (latest `max` turns) as\n   * the retention window. Passing an empty array or `max <= 0` clears the\n   * retention slot instead.\n   */\n  async retainDeferredTurns(\n    bufferKey: string,\n    turns: BufferTurn[],\n    max = 10,\n  ): Promise<void> {\n    await this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      const entry = this.entryFor(bufferKey);\n      if (!Array.isArray(turns) || turns.length === 0 || max <= 0) {\n        delete entry.retainedTurns;\n      } else {\n        // Guard `slice(-max)` against `max === 0` (CLAUDE.md gotcha 27):\n        // `slice(-0)` equals `slice(0)` and would return ALL entries. We\n        // already early-return above when max <= 0.\n        const tail = turns.slice(-max);\n        // Copy explicit fields only — never spread an external object into a\n        // plain object because spread preserves any own `__proto__` /\n        // `constructor` keys that may have arrived via JSON deserialization\n        // of untrusted input (CodeQL js/prototype-polluting-assignment).\n        entry.retainedTurns = tail.map<BufferTurn>((t) => {\n          const copy: BufferTurn = {\n            role: t.role,\n            content: typeof t.content === \"string\" ? t.content : \"\",\n            timestamp:\n              typeof t.timestamp === \"string\"\n                ? t.timestamp\n                : new Date().toISOString(),\n          };\n          if (typeof t.sessionKey === \"string\") copy.sessionKey = t.sessionKey;\n          if (typeof t.logicalSessionKey === \"string\") {\n            copy.logicalSessionKey = t.logicalSessionKey;\n          }\n          if (\n            t.providerThreadId === null ||\n            typeof t.providerThreadId === \"string\"\n          ) {\n            copy.providerThreadId = t.providerThreadId;\n          }\n          if (typeof t.turnFingerprint === \"string\") {\n            copy.turnFingerprint = t.turnFingerprint;\n          }\n          if (typeof t.persistProcessedFingerprint === \"boolean\") {\n            copy.persistProcessedFingerprint = t.persistProcessedFingerprint;\n          }\n          return copy;\n        });\n      }\n      await this.saveUnlocked();\n    });\n  }\n\n  /**\n   * Return the current retention window (issue #562, PR 2). Primarily for\n   * tests and diagnostics.\n   */\n  getRetainedDeferredTurns(bufferKey = \"default\"): BufferTurn[] {\n    const entry = this.peekEntry(bufferKey);\n    return entry?.retainedTurns ? [...entry.retainedTurns] : [];\n  }\n\n  async findBufferKeyForSession(sessionKey: string): Promise<string | null> {\n    const bufferKeys = await this.findBufferKeysForSession(sessionKey);\n    return bufferKeys[0] ?? null;\n  }\n\n  async findBufferKeysForSession(sessionKey: string): Promise<string[]> {\n    if (typeof sessionKey !== \"string\" || sessionKey.length === 0) return [];\n    await this.mutationChain.catch(() => {});\n    await this.load();\n\n    const matches: string[] = [];\n    const directEntry = this.peekEntry(sessionKey);\n    if ((directEntry?.turns.length ?? 0) > 0) {\n      matches.push(sessionKey);\n    }\n\n    const entries = this.state.entries ?? {};\n    for (const [bufferKey, entry] of Object.entries(entries)) {\n      if (\n        !matches.includes(bufferKey) &&\n        entry.turns.some(\n          (turn) =>\n            typeof turn.sessionKey === \"string\" && turn.sessionKey === sessionKey,\n        )\n      ) {\n        matches.push(bufferKey);\n      }\n    }\n\n    return matches;\n  }\n\n  async clearAfterExtraction(\n    bufferKey = \"default\",\n    extractedTurns?: readonly BufferTurn[],\n  ): Promise<void> {\n    await this.enqueueMutation(async () => {\n      await this.loadUnlocked();\n      const entry = this.entryFor(bufferKey);\n      if (Array.isArray(extractedTurns)) {\n        const liveExtractedTurns = liveTurnsFromExtractionSnapshot(\n          entry,\n          extractedTurns,\n        );\n        let clearedLiveTurns = false;\n        if (liveExtractedTurns.length > 0) {\n          const matchedCount = matchingQueuedExtractionPrefixLength(\n            entry.turns,\n            liveExtractedTurns,\n          );\n          if (matchedCount > 0) {\n            entry.turns = entry.turns.slice(matchedCount);\n            clearedLiveTurns = true;\n          } else {\n            log.debug(\n              `buffer[${bufferKey}]: extraction clear skipped because live turns changed before clear`,\n            );\n          }\n        }\n        if (!clearedLiveTurns) {\n          await this.saveUnlocked();\n          return;\n        }\n      } else {\n        entry.turns = [];\n      }\n      entry.lastExtractionAt = new Date().toISOString();\n      entry.extractionCount += 1;\n      if (bufferKey === \"default\") {\n        this.state.turns = entry.turns;\n        this.state.lastExtractionAt = entry.lastExtractionAt;\n        this.state.extractionCount = entry.extractionCount;\n      }\n      this.pruneEntries([bufferKey]);\n      await this.saveUnlocked();\n    });\n  }\n\n  getExtractionCount(bufferKey = \"default\"): number {\n    return this.peekEntry(bufferKey)?.extractionCount ?? 0;\n  }\n\n  /**\n   * Await any pending `BUFFER_SURPRISE` telemetry writes.\n   *\n   * The telemetry path is fire-and-forget from the hot path's point of\n   * view, but tests and before-exit hooks sometimes need to make sure\n   * the ledger has been flushed before they assert on its contents or\n   * close the process. This method resolves once the current chain\n   * head has settled; new writes scheduled after this call return a\n   * separate, later settlement.\n   *\n   * Never throws — the chain already catches its own rejections.\n   */\n  async flushSurpriseTelemetry(): Promise<void> {\n    await this.surpriseTelemetryWriteChain;\n  }\n}\n\n/**\n * Render an arbitrary thrown value as a short string for debug logging.\n *\n * JavaScript permits throwing *any* value (`throw null`,\n * `Promise.reject(\"x\")`, `throw { reason: \"timeout\" }`) — not just\n * `Error` instances. The defensive catch blocks in `SmartBuffer` must\n * never themselves throw while trying to log the failure, or they\n * would defeat the whole point of isolating the surprise path from the\n * core extraction decision.\n */\nfunction describeError(err: unknown): string {\n  if (err instanceof Error) return err.message;\n  if (err === null) return \"null\";\n  if (err === undefined) return \"undefined\";\n  if (typeof err === \"string\") return err;\n  try {\n    return JSON.stringify(err);\n  } catch {\n    return String(err);\n  }\n}\n\nfunction copyBufferTurn(turn: BufferTurn): BufferTurn {\n  const copy: BufferTurn = {\n    role: turn.role,\n    content: turn.content,\n    timestamp: turn.timestamp,\n  };\n  if (typeof turn.sessionKey === \"string\") copy.sessionKey = turn.sessionKey;\n  if (typeof turn.logicalSessionKey === \"string\") {\n    copy.logicalSessionKey = turn.logicalSessionKey;\n  }\n  if (\n    turn.providerThreadId === null ||\n    typeof turn.providerThreadId === \"string\"\n  ) {\n    copy.providerThreadId = turn.providerThreadId;\n  }\n  if (typeof turn.turnFingerprint === \"string\") {\n    copy.turnFingerprint = turn.turnFingerprint;\n  }\n  if (typeof turn.persistProcessedFingerprint === \"boolean\") {\n    copy.persistProcessedFingerprint = turn.persistProcessedFingerprint;\n  }\n  return copy;\n}\n\nfunction bufferTurnsEqual(left: BufferTurn | undefined, right: BufferTurn): boolean {\n  if (!left) return false;\n  return (\n    left.role === right.role &&\n    left.content === right.content &&\n    left.timestamp === right.timestamp &&\n    left.sessionKey === right.sessionKey &&\n    left.logicalSessionKey === right.logicalSessionKey &&\n    left.providerThreadId === right.providerThreadId &&\n    left.turnFingerprint === right.turnFingerprint &&\n    left.persistProcessedFingerprint === right.persistProcessedFingerprint\n  );\n}\n\nfunction bufferTurnArraysEqual(\n  left: readonly BufferTurn[],\n  right: readonly BufferTurn[],\n): boolean {\n  return (\n    left.length === right.length &&\n    left.every((turn, index) => bufferTurnsEqual(turn, right[index]))\n  );\n}\n\nfunction bufferTurnArrayIsSuffixOfSnapshot(\n  liveTurns: readonly BufferTurn[],\n  snapshot: readonly BufferTurn[],\n): boolean {\n  if (liveTurns.length === 0 || liveTurns.length > snapshot.length) {\n    return false;\n  }\n  const offset = snapshot.length - liveTurns.length;\n  return liveTurns.every((turn, index) =>\n    bufferTurnsEqual(turn, snapshot[offset + index]),\n  );\n}\n\nfunction liveTurnsFromExtractionSnapshot(\n  entry: BufferEntryState,\n  extractedTurns: readonly BufferTurn[],\n): readonly BufferTurn[] {\n  const retainedTurns = entry.retainedTurns ?? [];\n  if (\n    retainedTurns.length > 0 &&\n    extractedTurns.length >= retainedTurns.length &&\n    retainedTurns.every((turn, index) =>\n      bufferTurnsEqual(extractedTurns[index], turn),\n    )\n  ) {\n    const withoutRetainedPrefix = extractedTurns.slice(retainedTurns.length);\n    if (\n      withoutRetainedPrefix.length > 0 &&\n      matchingPrefixLength(entry.turns, withoutRetainedPrefix) > 0\n    ) {\n      return withoutRetainedPrefix;\n    }\n  }\n  return extractedTurns;\n}\n\nfunction matchingPrefixLength(\n  liveTurns: readonly BufferTurn[],\n  extractedTurns: readonly BufferTurn[],\n): number {\n  let index = 0;\n  while (\n    index < liveTurns.length &&\n    index < extractedTurns.length &&\n    bufferTurnsEqual(liveTurns[index], extractedTurns[index])\n  ) {\n    index += 1;\n  }\n  return index;\n}\n\nfunction matchingQueuedExtractionPrefixLength(\n  liveTurns: readonly BufferTurn[],\n  extractedTurns: readonly BufferTurn[],\n): number {\n  let bestMatchedCount = 0;\n  for (let start = 0; start < extractedTurns.length; start += 1) {\n    const matchedCount = matchingPrefixLength(\n      liveTurns,\n      extractedTurns.slice(start),\n    );\n    if (matchedCount > bestMatchedCount) {\n      bestMatchedCount = matchedCount;\n      if (bestMatchedCount === liveTurns.length) break;\n    }\n  }\n  return bestMatchedCount;\n}\n\n/**\n * Sentinel error class for the probe timeout path. Catching it via\n * `instanceof` lets the buffer's surprise helper distinguish a timeout\n * from a probe rejection (which could carry operational context the\n * operator wants to see).\n */\nclass ProbeTimeoutError extends Error {\n  constructor(timeoutMs: number) {\n    super(`probe exceeded ${timeoutMs}ms`);\n    this.name = \"ProbeTimeoutError\";\n  }\n}\n\n/**\n * Race `inflight` against a timeout clock. Resolves with `inflight`'s\n * value if it settles first, otherwise rejects with `ProbeTimeoutError`.\n * The timer is cleared in both branches so a fast-resolving probe does\n * not leak a handle that would keep the Node event loop alive.\n */\nfunction probeWithTimeout<T>(\n  inflight: Promise<T>,\n  timeoutMs: number,\n): Promise<T> {\n  let timer: NodeJS.Timeout | null = null;\n  const timeout = new Promise<T>((_, reject) => {\n    timer = setTimeout(() => reject(new ProbeTimeoutError(timeoutMs)), timeoutMs);\n    // `.unref()` so the timer does not hold the event loop open if the\n    // caller decides the probe result is no longer interesting.\n    if (typeof (timer as NodeJS.Timeout).unref === \"function\") {\n      (timer as NodeJS.Timeout).unref();\n    }\n  });\n  return Promise.race([inflight, timeout]).finally(() => {\n    if (timer) clearTimeout(timer);\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-DOX2CG6Y.js → chunk-IEUU7O4F.js}

@@ -4,7 +4,7 @@ import {
 import {
   compareEntityTimestamps,
   normalizeEntityName
-} from "./chunk-YFS5OEKO.js";
+} from "./chunk-7MLB4NCL.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-FVQJYWH7.js";
@@ -677,4 +677,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-DOX2CG6Y.js.map
+//# sourceMappingURL=chunk-IEUU7O4F.js.map

package/dist/{chunk-EUML3N6B.js → chunk-IMA6GU4Y.js}

@@ -308,7 +308,7 @@ async function findDuplicateExplicitCapture(orchestrator, resolvedNamespace, can
   return match?.frontmatter.id ?? null;
 }
 async function persistExplicitCapture(orchestrator, candidate, source) {
-  const resolvedNamespace = resolveExplicitCaptureNamespace(orchestrator, candidate.namespace);
+  const resolvedNamespace = candidate.namespacePreResolved ? asTrimmed(candidate.namespace) : resolveExplicitCaptureNamespace(orchestrator, candidate.namespace);
   const duplicateOf = await findDuplicateExplicitCapture(orchestrator, resolvedNamespace, candidate);
   if (duplicateOf) {
     return { id: duplicateOf, duplicateOf };
@@ -379,7 +379,7 @@ async function findQueuedExplicitCaptureDuplicate(orchestrator, namespace, conte
 async function queueExplicitCaptureForReview(orchestrator, input, source, error) {
   const reason = sanitizeReviewText(normalizeExplicitCaptureError(error), "explicit capture failed");
   const requestedNamespace = asTrimmed(input.namespace);
-  const queueNamespace = resolveExplicitCaptureReviewNamespace(orchestrator, requestedNamespace);
+  const queueNamespace = input.namespacePreResolved ? requestedNamespace : resolveExplicitCaptureReviewNamespace(orchestrator, requestedNamespace);
   const content = buildExplicitCaptureReviewContent(input, reason);
   const duplicateOf = await findQueuedExplicitCaptureDuplicate(orchestrator, queueNamespace, content);
   if (duplicateOf) {
@@ -435,4 +435,4 @@ export {
   shouldSkipImplicitExtraction,
   shouldProcessInlineExplicitCapture
 };
-//# sourceMappingURL=chunk-EUML3N6B.js.map
+//# sourceMappingURL=chunk-IMA6GU4Y.js.map

package/dist/chunk-IMA6GU4Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/explicit-capture.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport type { Orchestrator } from \"./orchestrator.js\";\nimport { isSafeRouteNamespace } from \"./routing/engine.js\";\nimport { sanitizeMemoryContent } from \"./sanitize.js\";\nimport { ContentHashIndex } from \"./storage.js\";\nimport type { CaptureMode, MemoryCategory, MemoryLifecycleEvent, PluginConfig } from \"./types.js\";\n\nexport type ExplicitCaptureInput = {\n  content: string;\n  category?: string;\n  confidence?: number;\n  namespace?: string;\n  tags?: string[];\n  entityRef?: string;\n  ttl?: string;\n  sourceReason?: string;\n};\n\nexport type ValidExplicitCapture = {\n  content: string;\n  category: MemoryCategory;\n  confidence: number;\n  namespace?: string;\n  tags: string[];\n  entityRef?: string;\n  expiresAt?: string;\n  sourceReason?: string;\n  /**\n   * When true, `namespace` was already resolved AND authorized by the caller\n   * (the access service's `resolveCodingScopedWriteNamespace`, which auth-checks\n   * the base and derives a session-owned `project-*` overlay). The persist /\n   * queue layer then routes to it directly instead of re-validating against the\n   * static policy allow-list — which would otherwise reject legitimately-derived\n   * dynamic project namespaces (#1434). Callers that do NOT pre-authorize the\n   * namespace must leave this unset so the allow-list guard still applies.\n   */\n  namespacePreResolved?: boolean;\n};\n\nexport type ExplicitCaptureSource = \"memory_store\" | \"memory_capture\" | \"suggestion_submit\" | \"inline\";\ntype ExplicitCaptureValidationMode = \"legacy_tool\" | \"strict_explicit\";\n\nconst INLINE_NOTE_RE = /<memory_note>\\s*([\\s\\S]*?)\\s*<\\/memory_note>/gi;\nconst INLINE_NOTE_MARKUP_RE = /<memory_note>\\s*[\\s\\S]*?\\s*<\\/memory_note>/i;\nconst INLINE_ALLOWED_CATEGORIES = new Set<MemoryCategory>([\n  \"fact\",\n  \"preference\",\n  \"correction\",\n  \"entity\",\n  \"decision\",\n  \"relationship\",\n  \"principle\",\n  \"commitment\",\n  \"moment\",\n  \"skill\",\n  \"rule\",\n  \"procedure\",\n  \"reasoning_trace\",\n]);\n\nconst SECRET_PATTERNS: RegExp[] = [\n  /\\bsk-[A-Za-z0-9]{16,}\\b/,\n  /\\bAKIA[0-9A-Z]{16}\\b/,\n  /\\bBearer\\s+[A-Za-z0-9._-]{16,}\\b/i,\n  /\\b(?:api[_-]?key|secret|token|password|passwd)\\s*[:=]\\s*[^\\s]{8,}\\b/i,\n  /\\b(?:authorization)\\s*:\\s*[^\\s]{8,}\\b/i,\n];\nconst SECRET_REDACTION_PATTERNS: Array<{ pattern: RegExp; replacement: string }> = [\n  { pattern: /\\bsk-[A-Za-z0-9]{16,}\\b/g, replacement: \"[redacted openai key]\" },\n  { pattern: /\\bAKIA[0-9A-Z]{16}\\b/g, replacement: \"[redacted aws key]\" },\n  { pattern: /\\bBearer\\s+[A-Za-z0-9._-]{16,}\\b/gi, replacement: \"Bearer [redacted token]\" },\n  {\n    pattern: /\\b(?:api[_-]?key|secret|token|password|passwd)\\s*[:=]\\s*[^\\s]{8,}\\b/gi,\n    replacement: \"[redacted credential]\",\n  },\n  {\n    pattern: /\\b(?:authorization)\\s*:\\s*[^\\s]{8,}\\b/gi,\n    replacement: \"authorization: [redacted credential]\",\n  },\n];\nconst EXPLICIT_CAPTURE_REVIEW_TAGS = [\"explicit-capture\", \"queued-review\"];\n\nfunction explicitCaptureActor(source: ExplicitCaptureSource): string {\n  switch (source) {\n    case \"inline\":\n      return \"inline.memory_note\";\n    case \"memory_store\":\n      return \"tool.memory_store\";\n    case \"suggestion_submit\":\n      return \"tool.suggestion_submit\";\n    default:\n      return \"tool.memory_capture\";\n  }\n}\n\nfunction asTrimmed(value: string | undefined): string | undefined {\n  const trimmed = value?.trim();\n  return trimmed && trimmed.length > 0 ? trimmed : undefined;\n}\n\nfunction normalizeCaptureContent(value: string): string {\n  return value\n    .toLowerCase()\n    .replace(/\\s+/g, \" \")\n    .trim();\n}\n\nfunction redactSecrets(value: string): string {\n  let redacted = value;\n  for (const { pattern, replacement } of SECRET_REDACTION_PATTERNS) {\n    redacted = redacted.replace(pattern, replacement);\n  }\n  return redacted;\n}\n\nfunction containsSecretLikeValue(value: string): boolean {\n  return SECRET_PATTERNS.some((pattern) => pattern.test(value));\n}\n\nfunction assertNoSecretLikeMetadata(field: string, value: string | undefined): void {\n  const trimmed = asTrimmed(value);\n  if (trimmed && containsSecretLikeValue(trimmed)) {\n    throw new Error(`${field} appears to contain a secret or credential`);\n  }\n}\n\nfunction assertNoSecretLikeMetadataList(field: string, values: string[] | undefined): void {\n  for (const value of values ?? []) {\n    assertNoSecretLikeMetadata(field, value);\n  }\n}\n\nfunction sanitizeReviewText(value: string | undefined, fallback: string): string {\n  const redacted = redactSecrets(asTrimmed(value) ?? fallback);\n  const sanitized = sanitizeMemoryContent(redacted);\n  const safe = sanitized.text.trim();\n  return safe.length > 0 ? safe : fallback;\n}\n\nfunction sanitizeReviewMetadata(value: string | undefined): string | undefined {\n  const trimmed = asTrimmed(value);\n  if (!trimmed) return undefined;\n  return sanitizeReviewText(trimmed, \"[redacted]\");\n}\n\nfunction sanitizeReviewTags(tags: string[] | undefined): string[] {\n  return Array.from(new Set((tags ?? [])\n    .map((tag) => sanitizeReviewMetadata(tag))\n    .filter((tag): tag is string => typeof tag === \"string\" && tag.length > 0)));\n}\n\nfunction normalizeExplicitCaptureError(error: unknown): string {\n  if (error instanceof Error && error.message.trim().length > 0) return error.message.trim();\n  const rendered = String(error).trim();\n  return rendered.length > 0 ? rendered : \"explicit capture failed\";\n}\n\nfunction resolveExplicitCaptureReviewNamespace(\n  orchestrator: Orchestrator,\n  namespace: string | undefined,\n): string | undefined {\n  const normalized = asTrimmed(namespace);\n  if (!normalized) return undefined;\n  return resolveExplicitCaptureNamespace(orchestrator, normalized);\n}\n\nfunction resolveExplicitCaptureNamespace(\n  orchestrator: Orchestrator,\n  namespace: string | undefined,\n): string | undefined {\n  const normalized = asTrimmed(namespace);\n  if (!normalized) return undefined;\n  if (!orchestrator.config.namespacesEnabled) {\n    if (normalized !== orchestrator.config.defaultNamespace) {\n      throw new Error(`unsupported namespace: ${normalized}`);\n    }\n    return normalized;\n  }\n  const allowed = new Set([\n    orchestrator.config.defaultNamespace,\n    orchestrator.config.sharedNamespace,\n    ...orchestrator.config.namespacePolicies.map((policy) => policy.name),\n  ].map((value) => value.trim()).filter(Boolean));\n  if (!allowed.has(normalized)) {\n    throw new Error(`unsupported namespace: ${normalized}`);\n  }\n  return normalized;\n}\n\nfunction parseExplicitCaptureTtl(ttl: string | undefined): string | undefined {\n  const raw = asTrimmed(ttl);\n  if (!raw) return undefined;\n\n  const absoluteMs = Date.parse(raw);\n  if (Number.isFinite(absoluteMs)) {\n    return new Date(absoluteMs).toISOString();\n  }\n\n  const relative = raw.match(/^(\\d+)\\s*([mhdw])$/i);\n  if (!relative) {\n    throw new Error(\"ttl must be an ISO-8601 timestamp or relative duration like 30m, 12h, 7d, or 2w\");\n  }\n\n  const amount = Number.parseInt(relative[1] ?? \"\", 10);\n  const unit = (relative[2] ?? \"\").toLowerCase();\n  if (!Number.isFinite(amount) || amount <= 0) {\n    throw new Error(\"ttl duration must be a positive integer\");\n  }\n\n  const multiplier =\n    unit === \"m\" ? 60_000\n      : unit === \"h\" ? 60 * 60_000\n        : unit === \"d\" ? 24 * 60 * 60_000\n          : 7 * 24 * 60 * 60_000;\n  return new Date(Date.now() + amount * multiplier).toISOString();\n}\n\nfunction parseInlineConfidence(value: string): number {\n  const trimmed = value.trim();\n  if (!/^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i.test(trimmed)) {\n    return Number.NaN;\n  }\n  const parsed = Number(trimmed);\n  return Number.isFinite(parsed) ? parsed : Number.NaN;\n}\n\nfunction parseInlineNote(block: string): ExplicitCaptureInput | null {\n  const lines = block.replace(/\\r/g, \"\").split(\"\\n\");\n  const note: Partial<ExplicitCaptureInput> = {};\n  let idx = 0;\n\n  while (idx < lines.length) {\n    const rawLine = lines[idx] ?? \"\";\n    const line = rawLine.trim();\n    idx += 1;\n    if (line.length === 0) continue;\n    const colonIdx = line.indexOf(\":\");\n    if (colonIdx < 0) continue;\n    const key = line.slice(0, colonIdx).trim();\n    const value = line.slice(colonIdx + 1).trim();\n\n    if (key === \"content\" && value === \"|\") {\n      const contentLines: string[] = [];\n      while (idx < lines.length) {\n        const next = lines[idx] ?? \"\";\n        if (next.startsWith(\"  \") || next.startsWith(\"\\t\")) {\n          contentLines.push(next.replace(/^(  |\\t)/, \"\"));\n          idx += 1;\n          continue;\n        }\n        if (next.trim().length === 0) {\n          contentLines.push(\"\");\n          idx += 1;\n          continue;\n        }\n        break;\n      }\n      note.content = contentLines.join(\"\\n\").trim();\n      continue;\n    }\n\n    switch (key) {\n      case \"content\":\n        note.content = value;\n        break;\n      case \"category\":\n        note.category = value;\n        break;\n      case \"confidence\":\n        note.confidence = parseInlineConfidence(value);\n        break;\n      case \"namespace\":\n        note.namespace = value;\n        break;\n      case \"tags\":\n        note.tags = value\n          .split(\",\")\n          .map((entry) => entry.trim())\n          .filter(Boolean);\n        break;\n      case \"entityRef\":\n        note.entityRef = value;\n        break;\n      case \"ttl\":\n        note.ttl = value;\n        break;\n      case \"sourceReason\":\n        note.sourceReason = value;\n        break;\n      default:\n        break;\n    }\n  }\n\n  return asTrimmed(note.content) ? (note as ExplicitCaptureInput) : null;\n}\n\nexport function parseInlineExplicitCaptureNotes(text: string): ExplicitCaptureInput[] {\n  const notes: ExplicitCaptureInput[] = [];\n  for (const match of text.matchAll(INLINE_NOTE_RE)) {\n    const parsed = parseInlineNote(match[1] ?? \"\");\n    if (parsed) notes.push(parsed);\n  }\n  return notes;\n}\n\nexport function hasInlineExplicitCaptureMarkup(text: string): boolean {\n  return INLINE_NOTE_MARKUP_RE.test(text);\n}\n\nexport function stripInlineExplicitCaptureNotes(text: string): string {\n  return text.replace(INLINE_NOTE_RE, \"\").trim();\n}\n\nexport function validateExplicitCaptureInput(\n  input: ExplicitCaptureInput,\n  mode: ExplicitCaptureValidationMode = \"strict_explicit\",\n): ValidExplicitCapture {\n  const content = asTrimmed(input.content);\n  if (!content) throw new Error(\"content is required\");\n  if (mode === \"strict_explicit\") {\n    if (content.length < 10) throw new Error(\"content must be at least 10 characters\");\n    if (content.length > 4000) throw new Error(\"content must be 4000 characters or fewer\");\n  }\n  if (/<memory_note>/i.test(content) || /<\\/memory_note>/i.test(content)) {\n    throw new Error(\"nested memory_note blocks are not allowed\");\n  }\n\n  const category = (asTrimmed(input.category) ?? \"fact\") as MemoryCategory;\n  if (!INLINE_ALLOWED_CATEGORIES.has(category)) {\n    throw new Error(`unsupported category: ${input.category ?? category}`);\n  }\n\n  const sanitized = sanitizeMemoryContent(content);\n  if (!sanitized.clean) {\n    throw new Error(\"content failed memory sanitization\");\n  }\n  for (const pattern of SECRET_PATTERNS) {\n    if (pattern.test(content)) {\n      throw new Error(\"content appears to contain a secret or credential\");\n    }\n  }\n  assertNoSecretLikeMetadata(\"sourceReason\", input.sourceReason);\n  assertNoSecretLikeMetadata(\"entityRef\", input.entityRef);\n  assertNoSecretLikeMetadata(\"ttl\", input.ttl);\n  assertNoSecretLikeMetadataList(\"tags\", input.tags);\n\n  if (input.confidence !== undefined && !Number.isFinite(input.confidence)) {\n    throw new Error(\"confidence must be a finite number\");\n  }\n  const confidence = input.confidence === undefined ? 0.95 : Number(input.confidence);\n  if (confidence < 0 || confidence > 1) {\n    throw new Error(\"confidence must be between 0 and 1\");\n  }\n  const requestedNamespace = asTrimmed(input.namespace);\n  if (requestedNamespace && !isSafeRouteNamespace(requestedNamespace)) {\n    throw new Error(`unsafe namespace: ${requestedNamespace}`);\n  }\n  const expiresAt = parseExplicitCaptureTtl(input.ttl);\n\n  return {\n    content,\n    category,\n    confidence,\n    namespace: asTrimmed(input.namespace),\n    tags: Array.from(new Set((input.tags ?? []).map((tag) => tag.trim()).filter(Boolean))),\n    entityRef: asTrimmed(input.entityRef),\n    expiresAt,\n    sourceReason: asTrimmed(input.sourceReason),\n  };\n}\n\nasync function findDuplicateExplicitCapture(\n  orchestrator: Orchestrator,\n  resolvedNamespace: string | undefined,\n  candidate: ValidExplicitCapture,\n): Promise<string | null> {\n  const storage = await orchestrator.getStorage(resolvedNamespace);\n  if (\n    candidate.category === \"fact\"\n    && typeof (storage as { hasFactContentHash?: (content: string) => Promise<boolean> }).hasFactContentHash === \"function\"\n  ) {\n    try {\n      const hasHash = await (storage as { hasFactContentHash: (content: string) => Promise<boolean> }).hasFactContentHash(\n        candidate.content,\n      );\n      if (!hasHash) {\n        const authoritative =\n          typeof (storage as { isFactContentHashAuthoritative?: () => Promise<boolean> | boolean }).isFactContentHashAuthoritative\n            === \"function\"\n            ? await (storage as { isFactContentHashAuthoritative: () => Promise<boolean> | boolean })\n              .isFactContentHashAuthoritative()\n            : false;\n        if (authoritative) return null;\n      }\n    } catch (err) {\n      // Fail open: hash index is only an optimization, so fall back to the full corpus scan.\n      void err;\n    }\n  }\n  const existing = await storage.readAllMemories();\n  const normalizedCandidate = normalizeCaptureContent(candidate.content);\n  const match = existing.find((memory) => {\n    const status = memory.frontmatter.status ?? \"active\";\n    if (status !== \"active\") return false;\n    if (memory.frontmatter.category !== candidate.category) return false;\n    return normalizeCaptureContent(memory.content) === normalizedCandidate;\n  });\n  return match?.frontmatter.id ?? null;\n}\n\nexport async function persistExplicitCapture(\n  orchestrator: Orchestrator,\n  candidate: ValidExplicitCapture,\n  source: ExplicitCaptureSource,\n): Promise<{ id: string; duplicateOf?: string }> {\n  const resolvedNamespace = candidate.namespacePreResolved\n    ? asTrimmed(candidate.namespace)\n    : resolveExplicitCaptureNamespace(orchestrator, candidate.namespace);\n  const duplicateOf = await findDuplicateExplicitCapture(orchestrator, resolvedNamespace, candidate);\n  if (duplicateOf) {\n    return { id: duplicateOf, duplicateOf };\n  }\n\n  const storage = await orchestrator.getStorage(resolvedNamespace);\n  const id = await storage.writeMemory(candidate.category, candidate.content, {\n    confidence: candidate.confidence,\n    tags: candidate.tags,\n    entityRef: candidate.entityRef,\n    expiresAt: candidate.expiresAt,\n    source: source === \"inline\" ? \"explicit-inline\" : \"explicit\",\n  });\n\n  const created = new Date().toISOString();\n  const event: MemoryLifecycleEvent = {\n    eventId: `mle-${randomUUID()}`,\n    memoryId: id,\n    eventType: \"explicit_capture_accepted\",\n    timestamp: created,\n    actor: explicitCaptureActor(source),\n    reasonCode: candidate.sourceReason,\n    ruleVersion: \"explicit-capture.v1\",\n  };\n  await storage.appendMemoryLifecycleEvents([event]);\n\n  return { id };\n}\n\nfunction buildExplicitCaptureReviewContent(input: ExplicitCaptureInput, reason: string): string {\n  const requestedContent = asTrimmed(input.content);\n  const safeContent = sanitizeReviewText(requestedContent, \"[empty explicit capture]\");\n  const safeCategory = sanitizeReviewMetadata(input.category);\n  const safeNamespace = sanitizeReviewMetadata(input.namespace);\n  const safeEntityRef = sanitizeReviewMetadata(input.entityRef);\n  const safeTtl = sanitizeReviewMetadata(input.ttl);\n  const safeSourceReason = sanitizeReviewMetadata(input.sourceReason);\n  const safeTags = sanitizeReviewTags(input.tags);\n  const lines = [\n    \"Explicit capture queued for review.\",\n    \"\",\n    `Reason: ${reason}`,\n    \"\",\n    \"Submitted content:\",\n    safeContent,\n  ];\n  const metadata = [\n    safeCategory ? `Requested category: ${safeCategory}` : undefined,\n    safeNamespace ? `Requested namespace: ${safeNamespace}` : undefined,\n    safeEntityRef ? `Requested entityRef: ${safeEntityRef}` : undefined,\n    safeTtl ? `Requested ttl: ${safeTtl}` : undefined,\n    safeSourceReason ? `Requested sourceReason: ${safeSourceReason}` : undefined,\n    safeTags.length > 0 ? `Requested tags: ${safeTags.join(\", \")}` : undefined,\n  ].filter((entry): entry is string => typeof entry === \"string\" && entry.length > 0);\n  if (metadata.length > 0) {\n    lines.push(\"\", ...metadata);\n  }\n  return lines.join(\"\\n\");\n}\n\nasync function findQueuedExplicitCaptureDuplicate(\n  orchestrator: Orchestrator,\n  namespace: string | undefined,\n  content: string,\n): Promise<string | null> {\n  const storage = await orchestrator.getStorage(namespace);\n  const existing = await storage.readAllMemories();\n  const normalized = normalizeCaptureContent(content);\n  const match = existing.find((memory) => {\n    const status = memory.frontmatter.status ?? \"active\";\n    if (status !== \"pending_review\") return false;\n    if (!(memory.frontmatter.tags ?? []).includes(\"queued-review\")) return false;\n    return normalizeCaptureContent(memory.content) === normalized;\n  });\n  return match?.frontmatter.id ?? null;\n}\n\nexport async function queueExplicitCaptureForReview(\n  orchestrator: Orchestrator,\n  input: ExplicitCaptureInput,\n  source: ExplicitCaptureSource,\n  error: unknown,\n): Promise<{ id: string; duplicateOf?: string }> {\n  const reason = sanitizeReviewText(normalizeExplicitCaptureError(error), \"explicit capture failed\");\n  const requestedNamespace = asTrimmed(input.namespace);\n  // A caller-pre-authorized namespace (e.g. a session-owned project overlay\n  // from the access service) routes directly; otherwise apply the static\n  // policy allow-list guard (#1434).\n  const queueNamespace = (input as { namespacePreResolved?: boolean }).namespacePreResolved\n    ? requestedNamespace\n    : resolveExplicitCaptureReviewNamespace(orchestrator, requestedNamespace);\n  const content = buildExplicitCaptureReviewContent(input, reason);\n  const duplicateOf = await findQueuedExplicitCaptureDuplicate(orchestrator, queueNamespace, content);\n  if (duplicateOf) {\n    return { id: duplicateOf, duplicateOf };\n  }\n\n  const requestedCategory = asTrimmed(input.category);\n  const reviewCategory = requestedCategory && INLINE_ALLOWED_CATEGORIES.has(requestedCategory as MemoryCategory)\n    ? requestedCategory as MemoryCategory\n    : \"fact\";\n  const requestedTags = sanitizeReviewTags(input.tags);\n  const storage = await orchestrator.getStorage(queueNamespace);\n  const id = await storage.writeMemory(reviewCategory, content, {\n    confidence: 0.2,\n    tags: Array.from(new Set([...EXPLICIT_CAPTURE_REVIEW_TAGS, ...requestedTags])),\n    entityRef: sanitizeReviewMetadata(input.entityRef),\n    source: source === \"inline\" ? \"explicit-inline-review\" : \"explicit-review\",\n  });\n  const created = await storage.getMemoryById(id);\n  if (created) {\n    await storage.writeMemoryFrontmatter(created, {\n      status: \"pending_review\",\n      updated: new Date().toISOString(),\n    }, {\n      actor: explicitCaptureActor(source),\n      reasonCode: reason,\n      ruleVersion: \"explicit-capture.v1\",\n    });\n  }\n  const event: MemoryLifecycleEvent = {\n    eventId: `mle-${randomUUID()}`,\n    memoryId: id,\n    eventType: \"explicit_capture_queued\",\n    timestamp: new Date().toISOString(),\n    actor: explicitCaptureActor(source),\n    reasonCode: reason,\n    ruleVersion: \"explicit-capture.v1\",\n  };\n  await storage.appendMemoryLifecycleEvents([event]);\n  return { id };\n}\n\nexport function shouldSkipImplicitExtraction(cfg: Pick<PluginConfig, \"captureMode\">): boolean {\n  return cfg.captureMode === \"explicit\";\n}\n\nexport function shouldProcessInlineExplicitCapture(cfg: Pick<PluginConfig, \"captureMode\">): boolean {\n  return cfg.captureMode !== \"implicit\";\n}\n"],"mappings":";;;;;;;;AAAA,SAAS,kBAAkB;AA0C3B,IAAM,iBAAiB;AACvB,IAAM,wBAAwB;AAC9B,IAAM,4BAA4B,oBAAI,IAAoB;AAAA,EACxD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAED,IAAM,kBAA4B;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AACA,IAAM,4BAA6E;AAAA,EACjF,EAAE,SAAS,4BAA4B,aAAa,wBAAwB;AAAA,EAC5E,EAAE,SAAS,yBAAyB,aAAa,qBAAqB;AAAA,EACtE,EAAE,SAAS,sCAAsC,aAAa,0BAA0B;AAAA,EACxF;AAAA,IACE,SAAS;AAAA,IACT,aAAa;AAAA,EACf;AAAA,EACA;AAAA,IACE,SAAS;AAAA,IACT,aAAa;AAAA,EACf;AACF;AACA,IAAM,+BAA+B,CAAC,oBAAoB,eAAe;AAEzE,SAAS,qBAAqB,QAAuC;AACnE,UAAQ,QAAQ;AAAA,IACd,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT;AACE,aAAO;AAAA,EACX;AACF;AAEA,SAAS,UAAU,OAA+C;AAChE,QAAM,UAAU,OAAO,KAAK;AAC5B,SAAO,WAAW,QAAQ,SAAS,IAAI,UAAU;AACnD;AAEA,SAAS,wBAAwB,OAAuB;AACtD,SAAO,MACJ,YAAY,EACZ,QAAQ,QAAQ,GAAG,EACnB,KAAK;AACV;AAEA,SAAS,cAAc,OAAuB;AAC5C,MAAI,WAAW;AACf,aAAW,EAAE,SAAS,YAAY,KAAK,2BAA2B;AAChE,eAAW,SAAS,QAAQ,SAAS,WAAW;AAAA,EAClD;AACA,SAAO;AACT;AAEA,SAAS,wBAAwB,OAAwB;AACvD,SAAO,gBAAgB,KAAK,CAAC,YAAY,QAAQ,KAAK,KAAK,CAAC;AAC9D;AAEA,SAAS,2BAA2B,OAAe,OAAiC;AAClF,QAAM,UAAU,UAAU,KAAK;AAC/B,MAAI,WAAW,wBAAwB,OAAO,GAAG;AAC/C,UAAM,IAAI,MAAM,GAAG,KAAK,4CAA4C;AAAA,EACtE;AACF;AAEA,SAAS,+BAA+B,OAAe,QAAoC;AACzF,aAAW,SAAS,UAAU,CAAC,GAAG;AAChC,+BAA2B,OAAO,KAAK;AAAA,EACzC;AACF;AAEA,SAAS,mBAAmB,OAA2B,UAA0B;AAC/E,QAAM,WAAW,cAAc,UAAU,KAAK,KAAK,QAAQ;AAC3D,QAAM,YAAY,sBAAsB,QAAQ;AAChD,QAAM,OAAO,UAAU,KAAK,KAAK;AACjC,SAAO,KAAK,SAAS,IAAI,OAAO;AAClC;AAEA,SAAS,uBAAuB,OAA+C;AAC7E,QAAM,UAAU,UAAU,KAAK;AAC/B,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,mBAAmB,SAAS,YAAY;AACjD;AAEA,SAAS,mBAAmB,MAAsC;AAChE,SAAO,MAAM,KAAK,IAAI,KAAK,QAAQ,CAAC,GACjC,IAAI,CAAC,QAAQ,uBAAuB,GAAG,CAAC,EACxC,OAAO,CAAC,QAAuB,OAAO,QAAQ,YAAY,IAAI,SAAS,CAAC,CAAC,CAAC;AAC/E;AAEA,SAAS,8BAA8B,OAAwB;AAC7D,MAAI,iBAAiB,SAAS,MAAM,QAAQ,KAAK,EAAE,SAAS,EAAG,QAAO,MAAM,QAAQ,KAAK;AACzF,QAAM,WAAW,OAAO,KAAK,EAAE,KAAK;AACpC,SAAO,SAAS,SAAS,IAAI,WAAW;AAC1C;AAEA,SAAS,sCACP,cACA,WACoB;AACpB,QAAM,aAAa,UAAU,SAAS;AACtC,MAAI,CAAC,WAAY,QAAO;AACxB,SAAO,gCAAgC,cAAc,UAAU;AACjE;AAEA,SAAS,gCACP,cACA,WACoB;AACpB,QAAM,aAAa,UAAU,SAAS;AACtC,MAAI,CAAC,WAAY,QAAO;AACxB,MAAI,CAAC,aAAa,OAAO,mBAAmB;AAC1C,QAAI,eAAe,aAAa,OAAO,kBAAkB;AACvD,YAAM,IAAI,MAAM,0BAA0B,UAAU,EAAE;AAAA,IACxD;AACA,WAAO;AAAA,EACT;AACA,QAAM,UAAU,IAAI,IAAI;AAAA,IACtB,aAAa,OAAO;AAAA,IACpB,aAAa,OAAO;AAAA,IACpB,GAAG,aAAa,OAAO,kBAAkB,IAAI,CAAC,WAAW,OAAO,IAAI;AAAA,EACtE,EAAE,IAAI,CAAC,UAAU,MAAM,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC;AAC9C,MAAI,CAAC,QAAQ,IAAI,UAAU,GAAG;AAC5B,UAAM,IAAI,MAAM,0BAA0B,UAAU,EAAE;AAAA,EACxD;AACA,SAAO;AACT;AAEA,SAAS,wBAAwB,KAA6C;AAC5E,QAAM,MAAM,UAAU,GAAG;AACzB,MAAI,CAAC,IAAK,QAAO;AAEjB,QAAM,aAAa,KAAK,MAAM,GAAG;AACjC,MAAI,OAAO,SAAS,UAAU,GAAG;AAC/B,WAAO,IAAI,KAAK,UAAU,EAAE,YAAY;AAAA,EAC1C;AAEA,QAAM,WAAW,IAAI,MAAM,qBAAqB;AAChD,MAAI,CAAC,UAAU;AACb,UAAM,IAAI,MAAM,iFAAiF;AAAA,EACnG;AAEA,QAAM,SAAS,OAAO,SAAS,SAAS,CAAC,KAAK,IAAI,EAAE;AACpD,QAAM,QAAQ,SAAS,CAAC,KAAK,IAAI,YAAY;AAC7C,MAAI,CAAC,OAAO,SAAS,MAAM,KAAK,UAAU,GAAG;AAC3C,UAAM,IAAI,MAAM,yCAAyC;AAAA,EAC3D;AAEA,QAAM,aACJ,SAAS,MAAM,MACX,SAAS,MAAM,KAAK,MAClB,SAAS,MAAM,KAAK,KAAK,MACvB,IAAI,KAAK,KAAK;AACxB,SAAO,IAAI,KAAK,KAAK,IAAI,IAAI,SAAS,UAAU,EAAE,YAAY;AAChE;AAEA,SAAS,sBAAsB,OAAuB;AACpD,QAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,CAAC,gDAAgD,KAAK,OAAO,GAAG;AAClE,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,SAAS,OAAO,OAAO;AAC7B,SAAO,OAAO,SAAS,MAAM,IAAI,SAAS,OAAO;AACnD;AAEA,SAAS,gBAAgB,OAA4C;AACnE,QAAM,QAAQ,MAAM,QAAQ,OAAO,EAAE,EAAE,MAAM,IAAI;AACjD,QAAM,OAAsC,CAAC;AAC7C,MAAI,MAAM;AAEV,SAAO,MAAM,MAAM,QAAQ;AACzB,UAAM,UAAU,MAAM,GAAG,KAAK;AAC9B,UAAM,OAAO,QAAQ,KAAK;AAC1B,WAAO;AACP,QAAI,KAAK,WAAW,EAAG;AACvB,UAAM,WAAW,KAAK,QAAQ,GAAG;AACjC,QAAI,WAAW,EAAG;AAClB,UAAM,MAAM,KAAK,MAAM,GAAG,QAAQ,EAAE,KAAK;AACzC,UAAM,QAAQ,KAAK,MAAM,WAAW,CAAC,EAAE,KAAK;AAE5C,QAAI,QAAQ,aAAa,UAAU,KAAK;AACtC,YAAM,eAAyB,CAAC;AAChC,aAAO,MAAM,MAAM,QAAQ;AACzB,cAAM,OAAO,MAAM,GAAG,KAAK;AAC3B,YAAI,KAAK,WAAW,IAAI,KAAK,KAAK,WAAW,GAAI,GAAG;AAClD,uBAAa,KAAK,KAAK,QAAQ,YAAY,EAAE,CAAC;AAC9C,iBAAO;AACP;AAAA,QACF;AACA,YAAI,KAAK,KAAK,EAAE,WAAW,GAAG;AAC5B,uBAAa,KAAK,EAAE;AACpB,iBAAO;AACP;AAAA,QACF;AACA;AAAA,MACF;AACA,WAAK,UAAU,aAAa,KAAK,IAAI,EAAE,KAAK;AAC5C;AAAA,IACF;AAEA,YAAQ,KAAK;AAAA,MACX,KAAK;AACH,aAAK,UAAU;AACf;AAAA,MACF,KAAK;AACH,aAAK,WAAW;AAChB;AAAA,MACF,KAAK;AACH,aAAK,aAAa,sBAAsB,KAAK;AAC7C;AAAA,MACF,KAAK;AACH,aAAK,YAAY;AACjB;AAAA,MACF,KAAK;AACH,aAAK,OAAO,MACT,MAAM,GAAG,EACT,IAAI,CAAC,UAAU,MAAM,KAAK,CAAC,EAC3B,OAAO,OAAO;AACjB;AAAA,MACF,KAAK;AACH,aAAK,YAAY;AACjB;AAAA,MACF,KAAK;AACH,aAAK,MAAM;AACX;AAAA,MACF,KAAK;AACH,aAAK,eAAe;AACpB;AAAA,MACF;AACE;AAAA,IACJ;AAAA,EACF;AAEA,SAAO,UAAU,KAAK,OAAO,IAAK,OAAgC;AACpE;AAEO,SAAS,gCAAgC,MAAsC;AACpF,QAAM,QAAgC,CAAC;AACvC,aAAW,SAAS,KAAK,SAAS,cAAc,GAAG;AACjD,UAAM,SAAS,gBAAgB,MAAM,CAAC,KAAK,EAAE;AAC7C,QAAI,OAAQ,OAAM,KAAK,MAAM;AAAA,EAC/B;AACA,SAAO;AACT;AAEO,SAAS,+BAA+B,MAAuB;AACpE,SAAO,sBAAsB,KAAK,IAAI;AACxC;AAEO,SAAS,gCAAgC,MAAsB;AACpE,SAAO,KAAK,QAAQ,gBAAgB,EAAE,EAAE,KAAK;AAC/C;AAEO,SAAS,6BACd,OACA,OAAsC,mBAChB;AACtB,QAAM,UAAU,UAAU,MAAM,OAAO;AACvC,MAAI,CAAC,QAAS,OAAM,IAAI,MAAM,qBAAqB;AACnD,MAAI,SAAS,mBAAmB;AAC9B,QAAI,QAAQ,SAAS,GAAI,OAAM,IAAI,MAAM,wCAAwC;AACjF,QAAI,QAAQ,SAAS,IAAM,OAAM,IAAI,MAAM,0CAA0C;AAAA,EACvF;AACA,MAAI,iBAAiB,KAAK,OAAO,KAAK,mBAAmB,KAAK,OAAO,GAAG;AACtE,UAAM,IAAI,MAAM,2CAA2C;AAAA,EAC7D;AAEA,QAAM,WAAY,UAAU,MAAM,QAAQ,KAAK;AAC/C,MAAI,CAAC,0BAA0B,IAAI,QAAQ,GAAG;AAC5C,UAAM,IAAI,MAAM,yBAAyB,MAAM,YAAY,QAAQ,EAAE;AAAA,EACvE;AAEA,QAAM,YAAY,sBAAsB,OAAO;AAC/C,MAAI,CAAC,UAAU,OAAO;AACpB,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AACA,aAAW,WAAW,iBAAiB;AACrC,QAAI,QAAQ,KAAK,OAAO,GAAG;AACzB,YAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AAAA,EACF;AACA,6BAA2B,gBAAgB,MAAM,YAAY;AAC7D,6BAA2B,aAAa,MAAM,SAAS;AACvD,6BAA2B,OAAO,MAAM,GAAG;AAC3C,iCAA+B,QAAQ,MAAM,IAAI;AAEjD,MAAI,MAAM,eAAe,UAAa,CAAC,OAAO,SAAS,MAAM,UAAU,GAAG;AACxE,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AACA,QAAM,aAAa,MAAM,eAAe,SAAY,OAAO,OAAO,MAAM,UAAU;AAClF,MAAI,aAAa,KAAK,aAAa,GAAG;AACpC,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AACA,QAAM,qBAAqB,UAAU,MAAM,SAAS;AACpD,MAAI,sBAAsB,CAAC,qBAAqB,kBAAkB,GAAG;AACnE,UAAM,IAAI,MAAM,qBAAqB,kBAAkB,EAAE;AAAA,EAC3D;AACA,QAAM,YAAY,wBAAwB,MAAM,GAAG;AAEnD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,WAAW,UAAU,MAAM,SAAS;AAAA,IACpC,MAAM,MAAM,KAAK,IAAI,KAAK,MAAM,QAAQ,CAAC,GAAG,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,EAAE,OAAO,OAAO,CAAC,CAAC;AAAA,IACrF,WAAW,UAAU,MAAM,SAAS;AAAA,IACpC;AAAA,IACA,cAAc,UAAU,MAAM,YAAY;AAAA,EAC5C;AACF;AAEA,eAAe,6BACb,cACA,mBACA,WACwB;AACxB,QAAM,UAAU,MAAM,aAAa,WAAW,iBAAiB;AAC/D,MACE,UAAU,aAAa,UACpB,OAAQ,QAA2E,uBAAuB,YAC7G;AACA,QAAI;AACF,YAAM,UAAU,MAAO,QAA0E;AAAA,QAC/F,UAAU;AAAA,MACZ;AACA,UAAI,CAAC,SAAS;AACZ,cAAM,gBACJ,OAAQ,QAAkF,mCACpF,aACF,MAAO,QACN,+BAA+B,IAChC;AACN,YAAI,cAAe,QAAO;AAAA,MAC5B;AAAA,IACF,SAAS,KAAK;AAEZ,WAAK;AAAA,IACP;AAAA,EACF;AACA,QAAM,WAAW,MAAM,QAAQ,gBAAgB;AAC/C,QAAM,sBAAsB,wBAAwB,UAAU,OAAO;AACrE,QAAM,QAAQ,SAAS,KAAK,CAAC,WAAW;AACtC,UAAM,SAAS,OAAO,YAAY,UAAU;AAC5C,QAAI,WAAW,SAAU,QAAO;AAChC,QAAI,OAAO,YAAY,aAAa,UAAU,SAAU,QAAO;AAC/D,WAAO,wBAAwB,OAAO,OAAO,MAAM;AAAA,EACrD,CAAC;AACD,SAAO,OAAO,YAAY,MAAM;AAClC;AAEA,eAAsB,uBACpB,cACA,WACA,QAC+C;AAC/C,QAAM,oBAAoB,UAAU,uBAChC,UAAU,UAAU,SAAS,IAC7B,gCAAgC,cAAc,UAAU,SAAS;AACrE,QAAM,cAAc,MAAM,6BAA6B,cAAc,mBAAmB,SAAS;AACjG,MAAI,aAAa;AACf,WAAO,EAAE,IAAI,aAAa,YAAY;AAAA,EACxC;AAEA,QAAM,UAAU,MAAM,aAAa,WAAW,iBAAiB;AAC/D,QAAM,KAAK,MAAM,QAAQ,YAAY,UAAU,UAAU,UAAU,SAAS;AAAA,IAC1E,YAAY,UAAU;AAAA,IACtB,MAAM,UAAU;AAAA,IAChB,WAAW,UAAU;AAAA,IACrB,WAAW,UAAU;AAAA,IACrB,QAAQ,WAAW,WAAW,oBAAoB;AAAA,EACpD,CAAC;AAED,QAAM,WAAU,oBAAI,KAAK,GAAE,YAAY;AACvC,QAAM,QAA8B;AAAA,IAClC,SAAS,OAAO,WAAW,CAAC;AAAA,IAC5B,UAAU;AAAA,IACV,WAAW;AAAA,IACX,WAAW;AAAA,IACX,OAAO,qBAAqB,MAAM;AAAA,IAClC,YAAY,UAAU;AAAA,IACtB,aAAa;AAAA,EACf;AACA,QAAM,QAAQ,4BAA4B,CAAC,KAAK,CAAC;AAEjD,SAAO,EAAE,GAAG;AACd;AAEA,SAAS,kCAAkC,OAA6B,QAAwB;AAC9F,QAAM,mBAAmB,UAAU,MAAM,OAAO;AAChD,QAAM,cAAc,mBAAmB,kBAAkB,0BAA0B;AACnF,QAAM,eAAe,uBAAuB,MAAM,QAAQ;AAC1D,QAAM,gBAAgB,uBAAuB,MAAM,SAAS;AAC5D,QAAM,gBAAgB,uBAAuB,MAAM,SAAS;AAC5D,QAAM,UAAU,uBAAuB,MAAM,GAAG;AAChD,QAAM,mBAAmB,uBAAuB,MAAM,YAAY;AAClE,QAAM,WAAW,mBAAmB,MAAM,IAAI;AAC9C,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA;AAAA,IACA,WAAW,MAAM;AAAA,IACjB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,QAAM,WAAW;AAAA,IACf,eAAe,uBAAuB,YAAY,KAAK;AAAA,IACvD,gBAAgB,wBAAwB,aAAa,KAAK;AAAA,IAC1D,gBAAgB,wBAAwB,aAAa,KAAK;AAAA,IAC1D,UAAU,kBAAkB,OAAO,KAAK;AAAA,IACxC,mBAAmB,2BAA2B,gBAAgB,KAAK;AAAA,IACnE,SAAS,SAAS,IAAI,mBAAmB,SAAS,KAAK,IAAI,CAAC,KAAK;AAAA,EACnE,EAAE,OAAO,CAAC,UAA2B,OAAO,UAAU,YAAY,MAAM,SAAS,CAAC;AAClF,MAAI,SAAS,SAAS,GAAG;AACvB,UAAM,KAAK,IAAI,GAAG,QAAQ;AAAA,EAC5B;AACA,SAAO,MAAM,KAAK,IAAI;AACxB;AAEA,eAAe,mCACb,cACA,WACA,SACwB;AACxB,QAAM,UAAU,MAAM,aAAa,WAAW,SAAS;AACvD,QAAM,WAAW,MAAM,QAAQ,gBAAgB;AAC/C,QAAM,aAAa,wBAAwB,OAAO;AAClD,QAAM,QAAQ,SAAS,KAAK,CAAC,WAAW;AACtC,UAAM,SAAS,OAAO,YAAY,UAAU;AAC5C,QAAI,WAAW,iBAAkB,QAAO;AACxC,QAAI,EAAE,OAAO,YAAY,QAAQ,CAAC,GAAG,SAAS,eAAe,EAAG,QAAO;AACvE,WAAO,wBAAwB,OAAO,OAAO,MAAM;AAAA,EACrD,CAAC;AACD,SAAO,OAAO,YAAY,MAAM;AAClC;AAEA,eAAsB,8BACpB,cACA,OACA,QACA,OAC+C;AAC/C,QAAM,SAAS,mBAAmB,8BAA8B,KAAK,GAAG,yBAAyB;AACjG,QAAM,qBAAqB,UAAU,MAAM,SAAS;AAIpD,QAAM,iBAAkB,MAA6C,uBACjE,qBACA,sCAAsC,cAAc,kBAAkB;AAC1E,QAAM,UAAU,kCAAkC,OAAO,MAAM;AAC/D,QAAM,cAAc,MAAM,mCAAmC,cAAc,gBAAgB,OAAO;AAClG,MAAI,aAAa;AACf,WAAO,EAAE,IAAI,aAAa,YAAY;AAAA,EACxC;AAEA,QAAM,oBAAoB,UAAU,MAAM,QAAQ;AAClD,QAAM,iBAAiB,qBAAqB,0BAA0B,IAAI,iBAAmC,IACzG,oBACA;AACJ,QAAM,gBAAgB,mBAAmB,MAAM,IAAI;AACnD,QAAM,UAAU,MAAM,aAAa,WAAW,cAAc;AAC5D,QAAM,KAAK,MAAM,QAAQ,YAAY,gBAAgB,SAAS;AAAA,IAC5D,YAAY;AAAA,IACZ,MAAM,MAAM,KAAK,oBAAI,IAAI,CAAC,GAAG,8BAA8B,GAAG,aAAa,CAAC,CAAC;AAAA,IAC7E,WAAW,uBAAuB,MAAM,SAAS;AAAA,IACjD,QAAQ,WAAW,WAAW,2BAA2B;AAAA,EAC3D,CAAC;AACD,QAAM,UAAU,MAAM,QAAQ,cAAc,EAAE;AAC9C,MAAI,SAAS;AACX,UAAM,QAAQ,uBAAuB,SAAS;AAAA,MAC5C,QAAQ;AAAA,MACR,UAAS,oBAAI,KAAK,GAAE,YAAY;AAAA,IAClC,GAAG;AAAA,MACD,OAAO,qBAAqB,MAAM;AAAA,MAClC,YAAY;AAAA,MACZ,aAAa;AAAA,IACf,CAAC;AAAA,EACH;AACA,QAAM,QAA8B;AAAA,IAClC,SAAS,OAAO,WAAW,CAAC;AAAA,IAC5B,UAAU;AAAA,IACV,WAAW;AAAA,IACX,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,IAClC,OAAO,qBAAqB,MAAM;AAAA,IAClC,YAAY;AAAA,IACZ,aAAa;AAAA,EACf;AACA,QAAM,QAAQ,4BAA4B,CAAC,KAAK,CAAC;AACjD,SAAO,EAAE,GAAG;AACd;AAEO,SAAS,6BAA6B,KAAiD;AAC5F,SAAO,IAAI,gBAAgB;AAC7B;AAEO,SAAS,mCAAmC,KAAiD;AAClG,SAAO,IAAI,gBAAgB;AAC7B;","names":[]}

package/dist/{chunk-JNANKJLN.js → chunk-JOASJWQR.js}

@@ -59,7 +59,7 @@ var RemoteSearchBackend = class {
   }
   async embedCollection(_collection) {
   }
-  async ensureCollection(_memoryDir, _execution) {
+  async ensureCollection(_memoryDir, _collectionOrExecution, _execution) {
     return "skipped";
   }
   headers() {
@@ -95,4 +95,4 @@ var RemoteSearchBackend = class {
 export {
   RemoteSearchBackend
 };
-//# sourceMappingURL=chunk-JNANKJLN.js.map
+//# sourceMappingURL=chunk-JOASJWQR.js.map

package/dist/chunk-JOASJWQR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/search/remote-backend.ts"],"sourcesContent":["import { log } from \"../logger.js\";\nimport type { SearchBackend, SearchExecutionOptions, SearchQueryOptions, SearchResult } from \"./port.js\";\n\nexport interface RemoteSearchBackendOptions {\n  baseUrl: string;\n  apiKey?: string;\n  timeoutMs?: number;\n}\n\n/**\n * HTTP REST search backend adapter.\n *\n * Delegates search to a remote service. Maintenance methods are no-ops\n * (remote backends manage their own indexing).\n */\nexport class RemoteSearchBackend implements SearchBackend {\n  private readonly baseUrl: string;\n  private readonly apiKey?: string;\n  private readonly timeoutMs: number;\n  private available = false;\n\n  constructor(opts: RemoteSearchBackendOptions) {\n    let url = opts.baseUrl;\n    while (url.endsWith(\"/\")) url = url.slice(0, -1);\n    this.baseUrl = url;\n    this.apiKey = opts.apiKey;\n    this.timeoutMs = opts.timeoutMs ?? 30_000;\n  }\n\n  async probe(): Promise<boolean> {\n    try {\n      const res = await fetch(`${this.baseUrl}/health`, {\n        method: \"GET\",\n        headers: this.headers(),\n        signal: AbortSignal.timeout(this.timeoutMs),\n      });\n      this.available = res.ok;\n      return this.available;\n    } catch (err) {\n      log.debug(`RemoteSearchBackend probe failed: ${err}`);\n      this.available = false;\n      return false;\n    }\n  }\n\n  isAvailable(): boolean {\n    return this.available;\n  }\n\n  debugStatus(): string {\n    return `backend=remote available=${this.available} baseUrl=${this.baseUrl}`;\n  }\n\n  async search(\n    query: string,\n    collection?: string,\n    maxResults?: number,\n    _options?: SearchQueryOptions,\n    execution?: SearchExecutionOptions,\n  ): Promise<SearchResult[]> {\n    return this.post(\"/search/deep\", { query, collection, maxResults }, execution);\n  }\n\n  async searchGlobal(query: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    return this.post(\"/search/deep\", { query, maxResults }, execution);\n  }\n\n  async bm25Search(query: string, collection?: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    return this.post(\"/search/bm25\", { query, collection, maxResults }, execution);\n  }\n\n  async vectorSearch(query: string, collection?: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    return this.post(\"/search/vector\", { query, collection, maxResults }, execution);\n  }\n\n  async hybridSearch(query: string, collection?: string, maxResults?: number, execution?: SearchExecutionOptions): Promise<SearchResult[]> {\n    return this.post(\"/search/hybrid\", { query, collection, maxResults }, execution);\n  }\n\n  async update(_execution?: SearchExecutionOptions): Promise<void> {}\n  async updateCollection(_collection: string, _execution?: SearchExecutionOptions): Promise<void> {}\n  async embed(): Promise<void> {}\n  async embedCollection(_collection: string): Promise<void> {}\n\n  async ensureCollection(\n    _memoryDir: string,\n    _collectionOrExecution?: string | SearchExecutionOptions,\n    _execution?: SearchExecutionOptions,\n  ): Promise<\"skipped\"> {\n    return \"skipped\";\n  }\n\n  private headers(): Record<string, string> {\n    const h: Record<string, string> = { \"Content-Type\": \"application/json\" };\n    if (this.apiKey) {\n      h[\"Authorization\"] = `Bearer ${this.apiKey}`;\n    }\n    return h;\n  }\n\n  private async post(\n    endpoint: string,\n    body: Record<string, unknown>,\n    execution?: SearchExecutionOptions,\n  ): Promise<SearchResult[]> {\n    if (!this.available) return [];\n    try {\n      const res = await fetch(`${this.baseUrl}${endpoint}`, {\n        method: \"POST\",\n        headers: this.headers(),\n        body: JSON.stringify(body),\n        signal: execution?.signal\n          ? AbortSignal.any([execution.signal, AbortSignal.timeout(this.timeoutMs)])\n          : AbortSignal.timeout(this.timeoutMs),\n      });\n      if (!res.ok) {\n        log.debug(`RemoteSearchBackend ${endpoint} returned ${res.status}`);\n        return [];\n      }\n      const data = await res.json();\n      if (!Array.isArray(data)) return [];\n      return data as SearchResult[];\n    } catch (err) {\n      log.debug(`RemoteSearchBackend ${endpoint} failed: ${err}`);\n      return [];\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-WSGF57U2.js → chunk-JQDZQ4TB.js}

@@ -1,6 +1,6 @@
 import {
   parseMessageParts
-} from "./chunk-XKIQZXUB.js";
+} from "./chunk-CI7RKSRE.js";
 import {
   recordObjectiveStateSnapshot
 } from "./chunk-UEY3VB6W.js";
@@ -644,4 +644,4 @@ export {
   recordObjectiveStateSnapshotsFromAgentMessages,
   recordObjectiveStateSnapshotsFromObservedMessages
 };
-//# sourceMappingURL=chunk-WSGF57U2.js.map
+//# sourceMappingURL=chunk-JQDZQ4TB.js.map

package/dist/{chunk-HINSGUA7.js → chunk-KBL3JJR6.js}

@@ -94,9 +94,9 @@ var WebSearchProvider = class {
 
 // src/enrichment/pipeline.ts
 var rateBuckets = /* @__PURE__ */ new Map();
-function isRateLimited(provider, config) {
+function reserveRateLimitSlot(provider, config) {
   const providerCfg = config.providers.find((p) => p.id === provider.id);
-  if (!providerCfg?.rateLimit) return false;
+  if (!providerCfg?.rateLimit) return true;
   const now = Date.now();
   let bucket = rateBuckets.get(provider.id);
   if (!bucket) {
@@ -117,14 +117,12 @@ function isRateLimited(provider, config) {
     bucket.dayReset = now + 864e5;
   }
   const { maxPerMinute, maxPerDay } = providerCfg.rateLimit;
-  return bucket.minuteCount >= maxPerMinute || bucket.dayCount >= maxPerDay;
-}
-function recordCall(providerId) {
-  const bucket = rateBuckets.get(providerId);
-  if (bucket) {
-    bucket.minuteCount += 1;
-    bucket.dayCount += 1;
+  if (bucket.minuteCount >= maxPerMinute || bucket.dayCount >= maxPerDay) {
+    return false;
   }
+  bucket.minuteCount += 1;
+  bucket.dayCount += 1;
+  return true;
 }
 async function runEnrichmentPipeline(entities, registry, config, log) {
   if (!config.enabled) return [];
@@ -161,7 +159,7 @@ async function runEnrichmentPipeline(entities, registry, config, log) {
         });
         continue;
       }
-      if (isRateLimited(provider, config)) {
+      if (!reserveRateLimitSlot(provider, config)) {
         log.debug?.(
           `enrichment: skipping provider ${provider.id} for ${entity.name} \u2014 rate limited`
         );
@@ -180,7 +178,6 @@ async function runEnrichmentPipeline(entities, registry, config, log) {
       try {
         candidates = await provider.enrich(entity);
       } catch (err) {
-        recordCall(provider.id);
         log.error?.(
           `enrichment: provider ${provider.id} failed for ${entity.name}: ${err instanceof Error ? err.message : String(err)}`
         );
@@ -195,7 +192,6 @@ async function runEnrichmentPipeline(entities, registry, config, log) {
         });
         continue;
       }
-      recordCall(provider.id);
       for (const candidate of candidates) {
         candidate.source = provider.id;
       }
@@ -272,4 +268,4 @@ export {
   appendAuditEntry,
   readAuditLog
 };
-//# sourceMappingURL=chunk-HINSGUA7.js.map
+//# sourceMappingURL=chunk-KBL3JJR6.js.map

package/dist/chunk-KBL3JJR6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/enrichment/types.ts","../src/enrichment/provider-registry.ts","../src/enrichment/web-search-provider.ts","../src/enrichment/pipeline.ts","../src/enrichment/audit.ts"],"sourcesContent":["/**\n * Enrichment pipeline types (issue #365).\n *\n * Defines the provider interface, candidate shape, pipeline config,\n * and result types for the external enrichment subsystem.\n */\n\nimport type { ImportanceLevel, MemoryCategory } from \"../types.js\";\n\n// ---------------------------------------------------------------------------\n// Provider config & interface\n// ---------------------------------------------------------------------------\n\nexport type EnrichmentCostTier = \"free\" | \"cheap\" | \"expensive\";\n\nexport interface EnrichmentProviderConfig {\n  id: string;\n  enabled: boolean;\n  costTier: EnrichmentCostTier;\n  rateLimit?: { maxPerMinute: number; maxPerDay: number };\n}\n\nexport interface EnrichmentCandidate {\n  text: string;\n  source: string;\n  sourceUrl?: string;\n  confidence: number;\n  category: MemoryCategory;\n  tags?: string[];\n}\n\nexport interface EnrichmentProvider {\n  readonly id: string;\n  readonly costTier: EnrichmentCostTier;\n  enrich(entity: EntityEnrichmentInput): Promise<EnrichmentCandidate[]>;\n  isAvailable(): Promise<boolean>;\n}\n\n// ---------------------------------------------------------------------------\n// Entity enrichment input\n// ---------------------------------------------------------------------------\n\nexport interface EntityEnrichmentInput {\n  name: string;\n  type: string;\n  knownFacts: string[];\n  importanceLevel: ImportanceLevel;\n}\n\n// ---------------------------------------------------------------------------\n// Pipeline result\n// ---------------------------------------------------------------------------\n\nexport interface EnrichmentResult {\n  entityName: string;\n  provider: string;\n  candidatesFound: number;\n  candidatesAccepted: number;\n  candidatesRejected: number;\n  acceptedCandidates: EnrichmentCandidate[];\n  elapsed: number;\n}\n\n// ---------------------------------------------------------------------------\n// Pipeline config\n// ---------------------------------------------------------------------------\n\nexport interface EnrichmentPipelineConfig {\n  enabled: boolean;\n  providers: EnrichmentProviderConfig[];\n  importanceThresholds: {\n    critical: string[];\n    high: string[];\n    normal: string[];\n    low: string[];\n  };\n  maxCandidatesPerEntity: number;\n  autoEnrichOnCreate: boolean;\n  scheduleIntervalMs: number;\n}\n\n/**\n * Build a default (disabled) pipeline config. Every consumer that needs a\n * config object should call this rather than duplicating the defaults.\n */\nexport function defaultEnrichmentPipelineConfig(): EnrichmentPipelineConfig {\n  return {\n    enabled: false,\n    providers: [],\n    importanceThresholds: {\n      critical: [],\n      high: [],\n      normal: [],\n      low: [],\n    },\n    maxCandidatesPerEntity: 20,\n    autoEnrichOnCreate: false,\n    scheduleIntervalMs: 3_600_000,\n  };\n}\n","/**\n * Enrichment provider registry (issue #365).\n *\n * Central registry for enrichment providers. Providers register themselves\n * at startup; the pipeline queries the registry to determine which providers\n * to run for a given importance tier.\n */\n\nimport type { ImportanceLevel } from \"../types.js\";\nimport type {\n  EnrichmentPipelineConfig,\n  EnrichmentProvider,\n} from \"./types.js\";\n\nexport class EnrichmentProviderRegistry {\n  private readonly providers = new Map<string, EnrichmentProvider>();\n\n  /** Register a provider. Overwrites any existing provider with the same id. */\n  register(provider: EnrichmentProvider): void {\n    this.providers.set(provider.id, provider);\n  }\n\n  /** Look up a single provider by id. */\n  get(id: string): EnrichmentProvider | undefined {\n    return this.providers.get(id);\n  }\n\n  /**\n   * Return all registered providers whose id appears in the config's\n   * `providers` list with `enabled: true`.\n   */\n  listEnabled(config: EnrichmentPipelineConfig): EnrichmentProvider[] {\n    const enabledIds = new Set(\n      config.providers\n        .filter((p) => p.enabled)\n        .map((p) => p.id),\n    );\n    const result: EnrichmentProvider[] = [];\n    for (const [id, provider] of this.providers.entries()) {\n      if (enabledIds.has(id)) {\n        result.push(provider);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Return providers that should run for a given importance level.\n   * Providers are resolved from `config.importanceThresholds[level]` and\n   * filtered to only those that are both registered and enabled.\n   */\n  getForImportance(\n    level: ImportanceLevel,\n    config: EnrichmentPipelineConfig,\n  ): EnrichmentProvider[] {\n    // \"trivial\" entities never get enrichment providers\n    if (level === \"trivial\") return [];\n\n    const thresholds = config.importanceThresholds;\n    const providerIds: string[] =\n      level === \"critical\"\n        ? thresholds.critical\n        : level === \"high\"\n          ? thresholds.high\n          : level === \"normal\"\n            ? thresholds.normal\n            : thresholds.low;\n\n    const enabledIds = new Set(\n      config.providers\n        .filter((p) => p.enabled)\n        .map((p) => p.id),\n    );\n\n    const result: EnrichmentProvider[] = [];\n    for (const id of providerIds) {\n      if (!enabledIds.has(id)) continue;\n      const provider = this.providers.get(id);\n      if (provider) {\n        result.push(provider);\n      }\n    }\n    return result;\n  }\n}\n","/**\n * Web search enrichment provider stub (issue #365).\n *\n * A basic provider backed by web search. Since this is opt-in and we do not\n * want to hard-code an API key, the provider accepts an optional `searchFn`\n * injection point. When no search function is configured it returns empty\n * results, making it safe to register unconditionally.\n */\n\nimport type {\n  EnrichmentCandidate,\n  EnrichmentCostTier,\n  EnrichmentProvider,\n  EntityEnrichmentInput,\n} from \"./types.js\";\n\nexport type WebSearchFn = (query: string) => Promise<string[]>;\n\nexport interface WebSearchProviderOptions {\n  /**\n   * Injected search function. Each returned string is treated as a raw\n   * snippet. When `undefined` the provider returns empty results.\n   */\n  searchFn?: WebSearchFn;\n}\n\nexport class WebSearchProvider implements EnrichmentProvider {\n  readonly id = \"web-search\";\n  readonly costTier: EnrichmentCostTier = \"cheap\";\n\n  private readonly searchFn: WebSearchFn | undefined;\n\n  constructor(options: WebSearchProviderOptions = {}) {\n    this.searchFn = options.searchFn;\n  }\n\n  async isAvailable(): Promise<boolean> {\n    return this.searchFn !== undefined;\n  }\n\n  async enrich(entity: EntityEnrichmentInput): Promise<EnrichmentCandidate[]> {\n    if (!this.searchFn) return [];\n\n    const query = `${entity.name} ${entity.type}`;\n    const snippets = await this.searchFn(query);\n\n    return snippets\n      .filter((s) => typeof s === \"string\" && s.trim().length > 0)\n      .map((snippet) => ({\n        text: snippet.trim(),\n        source: this.id,\n        sourceUrl: undefined,\n        confidence: 0.5,\n        category: \"fact\" as const,\n        tags: [\"web-search\"],\n      }));\n  }\n}\n","/**\n * Enrichment pipeline orchestrator (issue #365).\n *\n * For each entity, determines the importance tier, resolves the providers\n * to run, executes them in sequence (respecting rate limits), tags\n * candidates, and caps at `maxCandidatesPerEntity`.\n *\n * Accepted candidates are returned in each `EnrichmentResult` via the\n * `acceptedCandidates` field so that callers can persist them.\n */\n\nimport type { LoggerBackend } from \"../logger.js\";\nimport type { EnrichmentProviderRegistry } from \"./provider-registry.js\";\nimport type {\n  EnrichmentCandidate,\n  EnrichmentPipelineConfig,\n  EnrichmentProvider,\n  EnrichmentResult,\n  EntityEnrichmentInput,\n} from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// Rate-limit tracking\n// ---------------------------------------------------------------------------\n\ninterface RateLimitBucket {\n  minuteCount: number;\n  minuteReset: number;\n  dayCount: number;\n  dayReset: number;\n}\n\nconst rateBuckets = new Map<string, RateLimitBucket>();\n\nfunction reserveRateLimitSlot(\n  provider: EnrichmentProvider,\n  config: EnrichmentPipelineConfig,\n): boolean {\n  const providerCfg = config.providers.find((p) => p.id === provider.id);\n  if (!providerCfg?.rateLimit) return true;\n\n  const now = Date.now();\n  let bucket = rateBuckets.get(provider.id);\n  if (!bucket) {\n    bucket = {\n      minuteCount: 0,\n      minuteReset: now + 60_000,\n      dayCount: 0,\n      dayReset: now + 86_400_000,\n    };\n    rateBuckets.set(provider.id, bucket);\n  }\n\n  // Reset windows if expired\n  if (now >= bucket.minuteReset) {\n    bucket.minuteCount = 0;\n    bucket.minuteReset = now + 60_000;\n  }\n  if (now >= bucket.dayReset) {\n    bucket.dayCount = 0;\n    bucket.dayReset = now + 86_400_000;\n  }\n\n  const { maxPerMinute, maxPerDay } = providerCfg.rateLimit;\n  if (bucket.minuteCount >= maxPerMinute || bucket.dayCount >= maxPerDay) {\n    return false;\n  }\n\n  bucket.minuteCount += 1;\n  bucket.dayCount += 1;\n  return true;\n}\n\n// ---------------------------------------------------------------------------\n// Pipeline\n// ---------------------------------------------------------------------------\n\nexport async function runEnrichmentPipeline(\n  entities: EntityEnrichmentInput[],\n  registry: EnrichmentProviderRegistry,\n  config: EnrichmentPipelineConfig,\n  log: LoggerBackend,\n): Promise<EnrichmentResult[]> {\n  if (!config.enabled) return [];\n  if (entities.length === 0) return [];\n\n  const results: EnrichmentResult[] = [];\n\n  for (const entity of entities) {\n    const providers = registry.getForImportance(entity.importanceLevel, config);\n    const maxCandidates = config.maxCandidatesPerEntity;\n    const hasPositiveCandidateBudget = maxCandidates > 0;\n    let remainingCandidateBudget = hasPositiveCandidateBudget\n      ? maxCandidates\n      : Number.POSITIVE_INFINITY;\n\n    for (const provider of providers) {\n      if (hasPositiveCandidateBudget && remainingCandidateBudget <= 0) {\n        break;\n      }\n\n      const start = Date.now();\n\n      // Check availability\n      let available: boolean;\n      try {\n        available = await provider.isAvailable();\n      } catch {\n        available = false;\n      }\n\n      if (!available) {\n        log.debug?.(\n          `enrichment: skipping provider ${provider.id} for ${entity.name} — unavailable`,\n        );\n        results.push({\n          entityName: entity.name,\n          provider: provider.id,\n          candidatesFound: 0,\n          candidatesAccepted: 0,\n          candidatesRejected: 0,\n          acceptedCandidates: [],\n          elapsed: Date.now() - start,\n        });\n        continue;\n      }\n\n      // Reserve quota before the awaited provider call so concurrent pipelines\n      // cannot all pass the same pre-await rate-limit check.\n      if (!reserveRateLimitSlot(provider, config)) {\n        log.debug?.(\n          `enrichment: skipping provider ${provider.id} for ${entity.name} — rate limited`,\n        );\n        results.push({\n          entityName: entity.name,\n          provider: provider.id,\n          candidatesFound: 0,\n          candidatesAccepted: 0,\n          candidatesRejected: 0,\n          acceptedCandidates: [],\n          elapsed: Date.now() - start,\n        });\n        continue;\n      }\n\n      // Run provider.\n      // Count every attempt toward rate-limit buckets — including failures —\n      // because the provider may have consumed external quota before throwing\n      // (PR #425 review finding 2).\n      let candidates: EnrichmentCandidate[];\n      try {\n        candidates = await provider.enrich(entity);\n      } catch (err) {\n        log.error?.(\n          `enrichment: provider ${provider.id} failed for ${entity.name}: ${err instanceof Error ? err.message : String(err)}`,\n        );\n        results.push({\n          entityName: entity.name,\n          provider: provider.id,\n          candidatesFound: 0,\n          candidatesAccepted: 0,\n          candidatesRejected: 0,\n          acceptedCandidates: [],\n          elapsed: Date.now() - start,\n        });\n        continue;\n      }\n\n      // Tag each candidate with provider id\n      for (const candidate of candidates) {\n        candidate.source = provider.id;\n      }\n\n      // Cap at maxCandidatesPerEntity across all providers for this entity.\n      // 0 means \"accept none\"; undefined/negative means \"no cap\".\n      let accepted: EnrichmentCandidate[];\n      if (maxCandidates === 0) {\n        accepted = [];\n      } else if (hasPositiveCandidateBudget) {\n        accepted = candidates.slice(0, remainingCandidateBudget);\n        remainingCandidateBudget -= accepted.length;\n      } else {\n        accepted = candidates;\n      }\n      const rejected = candidates.length - accepted.length;\n\n      results.push({\n        entityName: entity.name,\n        provider: provider.id,\n        candidatesFound: candidates.length,\n        candidatesAccepted: accepted.length,\n        candidatesRejected: rejected,\n        acceptedCandidates: accepted,\n        elapsed: Date.now() - start,\n      });\n    }\n  }\n\n  return results;\n}\n","/**\n * Enrichment audit trail (issue #365).\n *\n * Append-only JSONL log for every enrichment candidate that was evaluated.\n * Each entry records whether the candidate was accepted or rejected, the\n * provider that produced it, and an optional reason string.\n */\n\nimport { mkdir, readFile, appendFile } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport path from \"node:path\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface EnrichmentAuditEntry {\n  timestamp: string;\n  entityName: string;\n  provider: string;\n  candidateText: string;\n  sourceUrl?: string;\n  accepted: boolean;\n  reason?: string;\n}\n\n// ---------------------------------------------------------------------------\n// File helpers\n// ---------------------------------------------------------------------------\n\nconst AUDIT_FILENAME = \"enrichment-audit.jsonl\";\n\nfunction auditFilePath(auditDir: string): string {\n  return path.join(auditDir, AUDIT_FILENAME);\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Append a single audit entry to the JSONL log. Creates the audit directory\n * and file if they do not exist.\n */\nexport async function appendAuditEntry(\n  auditDir: string,\n  entry: EnrichmentAuditEntry,\n): Promise<void> {\n  await mkdir(auditDir, { recursive: true });\n  const line = JSON.stringify(entry) + \"\\n\";\n  await appendFile(auditFilePath(auditDir), line, \"utf-8\");\n}\n\n/**\n * Read the audit log and return entries, optionally filtered to entries at\n * or after `since` (ISO 8601 timestamp, half-open interval).\n */\nexport async function readAuditLog(\n  auditDir: string,\n  since?: string,\n): Promise<EnrichmentAuditEntry[]> {\n  const filePath = auditFilePath(auditDir);\n  if (!existsSync(filePath)) return [];\n  const sinceMs = since === undefined ? undefined : Date.parse(since);\n  if (since !== undefined && !Number.isFinite(sinceMs)) {\n    throw new Error(`Invalid enrichment audit since timestamp: ${since}`);\n  }\n\n  const raw = await readFile(filePath, \"utf-8\");\n  const entries: EnrichmentAuditEntry[] = [];\n\n  for (const line of raw.split(\"\\n\")) {\n    const trimmed = line.trim();\n    if (trimmed.length === 0) continue;\n    try {\n      const parsed: unknown = JSON.parse(trimmed);\n      if (\n        typeof parsed === \"object\" &&\n        parsed !== null &&\n        \"timestamp\" in parsed &&\n        \"entityName\" in parsed\n      ) {\n        const entry = parsed as EnrichmentAuditEntry;\n        if (typeof entry.timestamp !== \"string\") continue;\n        const entryMs = Date.parse(entry.timestamp);\n        if (!Number.isFinite(entryMs)) continue;\n        if (sinceMs !== undefined && entryMs < sinceMs) continue;\n        entries.push(entry);\n      }\n    } catch {\n      // Skip malformed lines\n    }\n  }\n\n  return entries;\n}\n"],"mappings":"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","names":[]}