@remnic/core 9.69.56 → 9.69.58

package/dist/chunk-DZP2XMZC.js

@@ -1,1084 +0,0 @@
-import {
-  raceRecallAbort,
-  throwIfRecallAborted
-} from "./chunk-K4KE5MYE.js";
-import {
-  classifyOrigin
-} from "./chunk-6Q3ZTEF6.js";
-import {
-  tagPersistedMemories
-} from "./chunk-IGEZE6QB.js";
-import {
-  resolveScopeProfilePlan
-} from "./chunk-MNIPH6LD.js";
-import {
-  parseFlexibleIsoTimestamp
-} from "./chunk-P7FMDTKL.js";
-import {
-  defaultNamespaceForPrincipal,
-  resolvePrincipal
-} from "./chunk-MRV7VSQK.js";
-import {
-  resolveMemoryLifecycleCapabilities,
-  resolvePresentationCapabilities
-} from "./chunk-JUOZ62Y7.js";
-import {
-  resolveCodingNamespaceOverlay
-} from "./chunk-3Q3N35W7.js";
-import {
-  log
-} from "./chunk-3WCASNQZ.js";
-
-// src/orchestration/extraction-run-helpers.ts
-function combineExtractionAbortSignals(primary, deadlineController) {
-  if (!deadlineController) return primary;
-  return primary ? AbortSignal.any([primary, deadlineController.signal]) : deadlineController.signal;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function deriveTopicsFromExtraction(result) {
-  if (!isRecord(result)) return [];
-  const topics = /* @__PURE__ */ new Set();
-  const facts = Array.isArray(result.facts) ? result.facts : [];
-  for (const rawFact of facts) {
-    if (!isRecord(rawFact)) continue;
-    const tags = Array.isArray(rawFact.tags) ? rawFact.tags : [];
-    for (const tag of tags) {
-      if (typeof tag === "string" && tag.length >= 2) topics.add(tag.toLowerCase());
-    }
-    if (typeof rawFact.entityRef === "string" && rawFact.entityRef.length >= 2) {
-      topics.add(rawFact.entityRef.toLowerCase());
-    }
-    if (typeof rawFact.category === "string" && rawFact.category.length > 0) {
-      topics.add(rawFact.category);
-    }
-  }
-  const entities = Array.isArray(result.entities) ? result.entities : [];
-  for (const rawEntity of entities) {
-    if (!isRecord(rawEntity)) continue;
-    if (typeof rawEntity.name === "string" && rawEntity.name.length >= 2) {
-      topics.add(rawEntity.name.toLowerCase());
-    }
-  }
-  return [...topics].slice(0, 16);
-}
-var EXTRACTION_RETRY_STATE_MAX_ENTRIES = 500;
-function computeExtractionRetryNextEligibleMs(attempts, scheduleMs, maxBackoffMs, jitterRatio, now, rng = Math.random) {
-  if (!Number.isFinite(attempts) || !Number.isInteger(attempts) || attempts < 1) {
-    throw new RangeError("attempts must be a finite integer >= 1");
-  }
-  if (!Number.isFinite(maxBackoffMs) || maxBackoffMs < 0) {
-    throw new RangeError("maxBackoffMs must be a finite number >= 0");
-  }
-  if (!Number.isFinite(jitterRatio) || jitterRatio < 0 || jitterRatio > 1) {
-    throw new RangeError("jitterRatio must be a finite number in [0, 1]");
-  }
-  const safeNow = Number.isFinite(now) ? now : 0;
-  const cap = maxBackoffMs;
-  if (!Array.isArray(scheduleMs) || scheduleMs.length === 0) {
-    return safeNow + cap;
-  }
-  const idx = Math.min(attempts - 1, scheduleMs.length - 1);
-  const step = scheduleMs[idx];
-  const base = Math.min(typeof step === "number" && Number.isFinite(step) && step > 0 ? step : cap, cap);
-  const randomValue = rng();
-  if (!Number.isFinite(randomValue) || randomValue < 0 || randomValue > 1) {
-    throw new RangeError("rng() must return a finite number in [0, 1]");
-  }
-  const jitter = 1 + (randomValue * 2 - 1) * jitterRatio;
-  return safeNow + Math.max(0, Math.round(base * jitter));
-}
-function capExtractionRetryStateEntries(entries, maxEntries) {
-  if (!Number.isFinite(maxEntries) || !Number.isInteger(maxEntries) || maxEntries <= 0) return [];
-  const sorted = [...entries].sort((a, b) => a.firstFailedAt.localeCompare(b.firstFailedAt));
-  return sorted.slice(-maxEntries);
-}
-function deriveSourceConnector(turns) {
-  if (turns.length === 0) return void 0;
-  const connectors = /* @__PURE__ */ new Set();
-  let untaggedCount = 0;
-  for (const turn of turns) {
-    if (typeof turn.sourceConnector === "string" && turn.sourceConnector.length > 0) {
-      connectors.add(turn.sourceConnector);
-    } else {
-      untaggedCount += 1;
-    }
-  }
-  if (untaggedCount > 0) return void 0;
-  return connectors.size === 1 ? [...connectors][0] : void 0;
-}
-async function runExtractionPostPersistBestEffort(runDeadlineAware, stage, operation, options) {
-  try {
-    await runDeadlineAware(operation, stage, false, {
-      ignoreAbort: options?.ignoreAbort,
-      ignoreDeadline: options?.ignoreDeadline
-    });
-  } catch (error) {
-    if (options?.propagateErrors) throw error;
-    log.warn(`runExtraction: ${stage} failed after persistence (non-fatal)`, error);
-  }
-}
-async function runExtractionDeferRetention(runPostPersistBestEffort, options) {
-  await runPostPersistBestEffort("during_defer_retention", async () => {
-    if (options.clearBufferAfterExtraction && !options.extractionJudgeShadow) {
-      const deferredCount = options.getDeferredCount();
-      if (deferredCount > 0 && options.normalizedTurns.length > 0) {
-        await options.retainDeferredTurns(options.bufferKey, options.normalizedTurns, 10);
-      } else {
-        await options.retainDeferredTurns(options.bufferKey, [], 0);
-      }
-    }
-  });
-}
-async function runExtractionPostPersist(options) {
-  let metadataFailed = false;
-  let deadlineError;
-  const recordFailure = (stage, error) => {
-    metadataFailed = true;
-    if (options.isDeadlineError(error) && deadlineError === void 0) {
-      deadlineError = error;
-    }
-    log.warn(`runExtraction: ${stage} failed after durable persistence; continuing with buffer clear`, error);
-  };
-  let meta = options.meta;
-  try {
-    meta ??= await options.runDeadlineAware(
-      () => options.storage.loadMeta(),
-      "during_post_persist_load_meta",
-      false
-    );
-  } catch (error) {
-    recordFailure("metadata load", error);
-  }
-  if (meta && options.extractionFingerprint && options.shouldPersistProcessedFingerprint) {
-    try {
-      await options.runDeadlineAware(
-        () => options.recordProcessedExtractionFingerprint(options.storage, options.extractionFingerprint, meta),
-        "during_post_persist_fingerprint",
-        false
-      );
-    } catch (error) {
-      recordFailure("processed fingerprint", error);
-    }
-  }
-  if (meta) {
-    meta.extractionCount += 1;
-    meta.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
-    meta.totalMemories += Array.isArray(options.result.facts) ? options.result.facts.length : 0;
-    meta.totalEntities += Array.isArray(options.result.entities) ? options.result.entities.length : 0;
-    try {
-      await options.runDeadlineAware(
-        () => options.storage.saveMeta(meta),
-        "during_post_persist_meta_save",
-        false
-      );
-    } catch (error) {
-      recordFailure("metadata save", error);
-    }
-  }
-  const runBestEffort = options.runPostPersistBestEffort;
-  await runExtractionDeferRetention(runBestEffort, {
-    clearBufferAfterExtraction: options.clearBufferAfterExtraction,
-    extractionJudgeShadow: options.extractionJudgeShadow,
-    getDeferredCount: options.getDeferredCount,
-    normalizedTurns: options.normalizedTurns,
-    bufferKey: options.bufferKey,
-    retainDeferredTurns: options.retainDeferredTurns
-  });
-  await runBestEffort(
-    "during_buffer_clear",
-    () => options.clearBuffer({ ignoreAbort: true }),
-    {
-      ignoreAbort: true,
-      ignoreDeadline: options.failOnExtractionFailure,
-      propagateErrors: options.failOnExtractionFailure
-    }
-  );
-  if (options.failOnExtractionFailure && typeof options.deadlineMs === "number" && Date.now() >= options.deadlineMs) {
-    throw options.createDeadlineError("during_buffer_clear");
-  }
-  if (deadlineError) throw deadlineError;
-  return { meta, metadataFailed };
-}
-async function commitEmptySuccessExtraction(args) {
-  const {
-    storage,
-    meta: existingMeta,
-    extractionFingerprint,
-    shouldPersistProcessedFingerprint,
-    hasExtractionFailure,
-    extractionSkippedReason,
-    recordProcessedExtractionFingerprint,
-    runDeadlineAware,
-    isDeadlineError
-  } = args;
-  const shouldRecordFingerprint = extractionFingerprint !== null && shouldPersistProcessedFingerprint && !hasExtractionFailure;
-  const shouldStampLiveness = !hasExtractionFailure && extractionSkippedReason === void 0;
-  if (!shouldRecordFingerprint && !shouldStampLiveness) return;
-  const metadataFailureIsFatal = shouldRecordFingerprint;
-  try {
-    const meta = existingMeta ?? await runDeadlineAware(
-      () => storage.loadMeta(),
-      "during_empty_success_liveness_load",
-      false
-    );
-    if (shouldRecordFingerprint) {
-      await recordProcessedExtractionFingerprint(storage, extractionFingerprint, meta);
-    }
-    if (shouldStampLiveness) {
-      meta.extractionCount += 1;
-      meta.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    await runDeadlineAware(
-      () => storage.saveMeta(meta),
-      "during_empty_success_liveness_save",
-      false
-    );
-  } catch (err) {
-    if (isDeadlineError(err)) throw err;
-    if (metadataFailureIsFatal) throw err;
-    log.warn("runExtraction: failed to stamp empty-success liveness watermark (non-fatal)", err);
-  }
-}
-
-// src/orchestration/extraction-run.ts
-import { createHash } from "crypto";
-
-// src/orchestration/extraction-origin-context.ts
-function deriveExtractionOriginContext(targetTurns, fallbackConnector) {
-  const originRoles = new Set(targetTurns.map((turn) => turn.role));
-  const turnRole = originRoles.size === 1 ? [...originRoles][0] : void 0;
-  const originConnectors = new Set(
-    targetTurns.map((turn) => turn.sourceConnector).filter((connector2) => typeof connector2 === "string" && connector2.length > 0)
-  );
-  const connector = targetTurns.length > 0 && targetTurns.every(
-    (turn) => typeof turn.sourceConnector === "string" && turn.sourceConnector.length > 0
-  ) && originConnectors.size === 1 ? [...originConnectors][0] : void 0;
-  const originAdapters = new Set(
-    targetTurns.map((turn) => turn.importProvenance?.sourceLabel).filter((adapter) => typeof adapter === "string" && adapter.length > 0)
-  );
-  const everyTurnHasConnector = targetTurns.length > 0 && targetTurns.every((turn) => typeof turn.sourceConnector === "string" && turn.sourceConnector.length > 0);
-  const everyTurnHasAdapter = targetTurns.length > 0 && targetTurns.every(
-    (turn) => typeof turn.importProvenance?.sourceLabel === "string" && turn.importProvenance.sourceLabel.length > 0
-  );
-  const originConflict = originConnectors.size > 1 || originAdapters.size > 1 || originConnectors.size > 0 && originAdapters.size > 0 || originConnectors.size > 0 && !everyTurnHasConnector || originAdapters.size > 0 && !everyTurnHasAdapter;
-  const importAdapter = targetTurns.length > 0 && targetTurns.every(
-    (turn) => typeof turn.importProvenance?.sourceLabel === "string" && turn.importProvenance.sourceLabel.length > 0
-  ) && originAdapters.size === 1 ? [...originAdapters][0] : void 0;
-  return {
-    ...turnRole ? { turnRole } : {},
-    ...importAdapter ? { importAdapter } : {},
-    ...originConflict ? { originConflict: true } : {},
-    sourceConnector: fallbackConnector ?? connector
-  };
-}
-function classifyExtractionOrigin(sourceContext) {
-  if (sourceContext?.originConflict === true) return "unknown";
-  return classifyOrigin({
-    turnRole: sourceContext?.turnRole,
-    connectorId: sourceContext?.sourceConnector,
-    importAdapter: sourceContext?.importAdapter
-  });
-}
-
-// src/orchestration/extraction-run.ts
-var ExtractionDeadlineError = class extends Error {
-  stage;
-  constructor(stage) {
-    super(`replay extraction deadline exceeded (${stage})`);
-    this.name = "ExtractionDeadlineError";
-    this.stage = stage;
-  }
-};
-var ExtractionRunCoordinator = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  recentExtractionFingerprints = /* @__PURE__ */ new Map();
-  // Per-fingerprint extraction retry/backoff state (extraction hot-loop
-  // hardening). Outer key = namespace, inner key = fingerprint. Hydrated lazily
-  // from namespace-scoped meta so the hot path is a Map lookup; persisted back
-  // to meta on change (restart-safe, cross-process coherent via the shared
-  // meta.json). The breaker below is intentionally per-process in-memory
-  // (mirrors local-llm.cooldownUntilMs); a restart clears it but the persisted
-  // backoff still throttles, so a restart can't resurrect the hot loop.
-  extractionRetryState = /* @__PURE__ */ new Map();
-  hydratedRetryNamespaces = /* @__PURE__ */ new Set();
-  providerBreaker = { consecutiveFailures: 0, openUntilMs: 0, state: "closed", lastReason: "" };
-  get config() {
-    return this.deps.config;
-  }
-  // -------------------------------------------------------------------------
-  // Source-valid-at helpers (moved from orchestrator.ts module scope)
-  // -------------------------------------------------------------------------
-  latestSourceValidAtFromTurns(turns) {
-    let latestMs = null;
-    for (const turn of turns) {
-      if (turn.extractionContextOnly === true) continue;
-      if (typeof turn.sourceValidAt !== "string") continue;
-      const parsed = parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
-      if (parsed === null) continue;
-      if (latestMs === null || parsed > latestMs) {
-        latestMs = parsed;
-      }
-    }
-    return latestMs === null ? void 0 : new Date(latestMs).toISOString();
-  }
-  // -------------------------------------------------------------------------
-  // Extraction dedupe fingerprint helpers
-  // -------------------------------------------------------------------------
-  normalizeExtractionFingerprintTurns(turns) {
-    if (!Array.isArray(turns) || turns.length === 0) return [];
-    return turns.filter((turn) => turn.role === "user" || turn.role === "assistant").map((turn) => {
-      if (typeof turn.turnFingerprint === "string" && turn.turnFingerprint.length > 0) {
-        return `fp:${turn.turnFingerprint}`;
-      }
-      return `${turn.role}:${(turn.content ?? "").replace(/\s+/g, " ").trim().slice(0, this.config.extractionMaxTurnChars)}`;
-    }).filter((value) => value.length > 0);
-  }
-  buildExtractionFingerprint(turns, bufferKey) {
-    const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
-    if (!normalized) return null;
-    return createHash("sha256").update(`${bufferKey}
-${normalized}`).digest("hex");
-  }
-  shouldQueueExtraction(turns, options = {}) {
-    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
-    if (!lifecycleCaps.extractionDedupe) return true;
-    if (!Array.isArray(turns) || turns.length === 0) return false;
-    const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
-    const fingerprint = this.buildExtractionFingerprint(turns, bufferKey);
-    if (!fingerprint) return false;
-    const now = Date.now();
-    const seenAt = this.recentExtractionFingerprints.get(fingerprint);
-    if (seenAt && now - seenAt < this.config.extractionDedupeWindowMs) {
-      log.debug("extraction dedupe: skipped duplicate buffered turn set");
-      return false;
-    }
-    if (options.commit !== false) {
-      this.recentExtractionFingerprints.set(fingerprint, now);
-    }
-    if (options.commit !== false && this.recentExtractionFingerprints.size > 200) {
-      const entries = Array.from(this.recentExtractionFingerprints.entries()).sort((a, b) => a[1] - b[1]);
-      for (const [key] of entries.slice(0, entries.length - 200)) {
-        this.recentExtractionFingerprints.delete(key);
-      }
-    }
-    return true;
-  }
-  // -------------------------------------------------------------------------
-  // Processed-fingerprint recording
-  // -------------------------------------------------------------------------
-  async recordProcessedExtractionFingerprint(storage, fingerprint, preloadedMeta) {
-    const meta = preloadedMeta ?? await storage.loadMeta();
-    const observedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const seen = new Map(
-      (meta.processedExtractionFingerprints ?? []).map((entry) => [entry.fingerprint, entry.observedAt])
-    );
-    seen.set(fingerprint, observedAt);
-    meta.processedExtractionFingerprints = Array.from(seen.entries()).map(([value, at]) => ({ fingerprint: value, observedAt: at })).sort((left, right) => left.observedAt.localeCompare(right.observedAt)).slice(-500);
-    if (!preloadedMeta) {
-      await storage.saveMeta(meta);
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Extraction retry/backoff + circuit breaker (extraction hot-loop hardening)
-  // -------------------------------------------------------------------------
-  /** Lazily hydrate the in-memory retry-state mirror for a namespace from meta.
-   *  One-time per namespace per coordinator; the hot path is then a Map lookup.
-   *  Cross-process coherence: a fresh coordinator hydrates from the shared
-   *  meta.json, so a failure persisted by another process is honored here. */
-  hydrateRetryStateFromMeta(namespace, meta) {
-    if (this.hydratedRetryNamespaces.has(namespace)) return;
-    this.hydratedRetryNamespaces.add(namespace);
-    const nsMap = this.extractionRetryState.get(namespace) ?? /* @__PURE__ */ new Map();
-    for (const entry of meta.extractionRetryState ?? []) {
-      const nextEligibleAtMs = Date.parse(entry.nextEligibleAt);
-      const firstFailedAtMs = Date.parse(entry.firstFailedAt);
-      nsMap.set(entry.fingerprint, {
-        attempts: entry.attempts,
-        nextEligibleAtMs: Number.isFinite(nextEligibleAtMs) ? nextEligibleAtMs : 0,
-        firstFailedAtMs: Number.isFinite(firstFailedAtMs) ? firstFailedAtMs : Date.now(),
-        lastFailureClass: entry.lastFailureClass
-      });
-    }
-    this.extractionRetryState.set(namespace, nsMap);
-  }
-  logBreakerTransition(state) {
-    log.warn("extraction: provider circuit breaker transition", {
-      state,
-      consecutiveFailures: this.providerBreaker.consecutiveFailures,
-      lastReason: this.providerBreaker.lastReason,
-      openUntilMs: this.providerBreaker.openUntilMs
-    });
-  }
-  /** True while the breaker suppresses non-forced attempts. Flips an expired
-   *  `open` breaker to `half_open`, which allows exactly one probe (the next
-   *  non-forced attempt) because the extraction queue is a serial drain. */
-  isProviderBreakerOpen(now) {
-    if (now < this.providerBreaker.openUntilMs) return true;
-    if (this.providerBreaker.state === "open") {
-      this.providerBreaker.state = "half_open";
-      this.logBreakerTransition("half_open");
-    }
-    return false;
-  }
-  onProviderFailure(cls, now) {
-    this.providerBreaker.consecutiveFailures += 1;
-    const trip = cls === "auth_config" || // A failed half-open probe re-opens immediately (standard breaker
-    // semantics). Without this, an auth_config-opened breaker (which trips
-    // below the threshold) would get stuck half_open after a transient
-    // probe failure and stop suppressing (cursor review).
-    this.providerBreaker.state === "half_open" || this.providerBreaker.consecutiveFailures >= this.config.extractionBreakerFailureThreshold;
-    if (!trip) return;
-    const cooldown = cls === "auth_config" ? this.config.extractionBreakerAuthCooldownMs : this.config.extractionBreakerCooldownMs;
-    this.providerBreaker.openUntilMs = now + Math.max(0, cooldown);
-    this.providerBreaker.lastReason = cls;
-    if (this.providerBreaker.state !== "open") {
-      this.providerBreaker.state = "open";
-      this.logBreakerTransition("open");
-    }
-  }
-  resetProviderBreakerOnSuccess() {
-    const wasDisturbed = this.providerBreaker.state !== "closed" || this.providerBreaker.consecutiveFailures > 0 || this.providerBreaker.openUntilMs > 0;
-    if (!wasDisturbed) return;
-    const wasOpen = this.providerBreaker.state !== "closed";
-    this.providerBreaker.consecutiveFailures = 0;
-    this.providerBreaker.openUntilMs = 0;
-    this.providerBreaker.lastReason = "";
-    this.providerBreaker.state = "closed";
-    if (wasOpen) this.logBreakerTransition("closed");
-  }
-  /** Rebuild `meta.extractionRetryState` from the in-memory namespace mirror,
-   *  bounded to the newest entries, and prune the mirror to match. */
-  persistRetryStateToMeta(namespace, meta) {
-    const nsMap = this.extractionRetryState.get(namespace);
-    const entries = nsMap ? Array.from(nsMap.entries()).map(([fingerprint, st]) => ({
-      fingerprint,
-      attempts: st.attempts,
-      nextEligibleAt: new Date(st.nextEligibleAtMs).toISOString(),
-      firstFailedAt: new Date(st.firstFailedAtMs).toISOString(),
-      lastFailureClass: st.lastFailureClass
-    })) : [];
-    const capped = capExtractionRetryStateEntries(entries, EXTRACTION_RETRY_STATE_MAX_ENTRIES);
-    meta.extractionRetryState = capped;
-    if (nsMap && capped.length < nsMap.size) {
-      const kept = new Set(capped.map((e) => e.fingerprint));
-      for (const key of Array.from(nsMap.keys())) {
-        if (!kept.has(key)) nsMap.delete(key);
-      }
-    }
-  }
-  /** Record an extraction failure into per-fingerprint backoff state + breaker,
-   *  persisting to namespace meta. Fail-open: never throws upward. */
-  async recordExtractionFailure(storage, namespace, fingerprint, cls, meta, now) {
-    try {
-      this.hydrateRetryStateFromMeta(namespace, meta);
-      const nsMap = this.extractionRetryState.get(namespace) ?? /* @__PURE__ */ new Map();
-      const prev = nsMap.get(fingerprint);
-      const attempts = (prev?.attempts ?? 0) + 1;
-      const firstFailedAtMs = prev?.firstFailedAtMs ?? now;
-      let nextEligibleAtMs;
-      if (cls === "parse_empty" && attempts > this.config.extractionParseEmptyMaxAttempts) {
-        nextEligibleAtMs = now + Math.max(0, this.config.extractionRetryMaxBackoffMs);
-      } else {
-        nextEligibleAtMs = computeExtractionRetryNextEligibleMs(
-          attempts,
-          this.config.extractionRetryScheduleMs,
-          this.config.extractionRetryMaxBackoffMs,
-          this.config.extractionRetryJitterRatio,
-          now
-        );
-      }
-      nsMap.set(fingerprint, { attempts, nextEligibleAtMs, firstFailedAtMs, lastFailureClass: cls });
-      this.extractionRetryState.set(namespace, nsMap);
-      this.onProviderFailure(cls, now);
-      this.persistRetryStateToMeta(namespace, meta);
-      await storage.saveMeta(meta);
-    } catch (err) {
-      log.warn("runExtraction: failed to record extraction retry state (non-fatal)", err);
-    }
-  }
-  /** Delete a fingerprint's retry entry from the mirror + meta. Returns whether
-   *  meta changed (so the caller can decide to persist). Does not touch the
-   *  breaker — callers pair this with `resetProviderBreakerOnSuccess`. */
-  clearExtractionRetryEntry(namespace, fingerprint, meta) {
-    const nsMap = this.extractionRetryState.get(namespace);
-    if (!nsMap?.has(fingerprint)) return false;
-    nsMap.delete(fingerprint);
-    this.persistRetryStateToMeta(namespace, meta);
-    return true;
-  }
-  /** Live in-process resilience snapshot (breaker + backoff population). */
-  getExtractionResilienceStatus() {
-    let backoffFingerprintCount = 0;
-    for (const nsMap of this.extractionRetryState.values()) {
-      backoffFingerprintCount += nsMap.size;
-    }
-    return {
-      breaker: {
-        state: this.providerBreaker.state,
-        openUntilMs: this.providerBreaker.openUntilMs,
-        consecutiveFailures: this.providerBreaker.consecutiveFailures,
-        lastReason: this.providerBreaker.lastReason
-      },
-      backoffFingerprintCount
-    };
-  }
-  // -------------------------------------------------------------------------
-  // Main extraction pipeline
-  // -------------------------------------------------------------------------
-  async runExtraction(turns, options = {}) {
-    log.debug(`running extraction on ${turns.length} turns`);
-    const clearBufferAfterExtraction = options.clearBufferAfterExtraction ?? true;
-    const clearMatchingTurns = options.clearMatchingTurns === true;
-    const skipCharThreshold = options.skipCharThreshold ?? false;
-    const skipUserTurnThreshold = options.skipUserTurnThreshold ?? false;
-    const deadlineMs = typeof options.deadlineMs === "number" && Number.isFinite(options.deadlineMs) ? options.deadlineMs : void 0;
-    const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
-    const throwIfDeadlineExceeded = (stage) => {
-      if (typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
-        throw new ExtractionDeadlineError(stage);
-      }
-    };
-    const throwIfAborted = (stage) => {
-      throwIfRecallAborted(options.abortSignal, `extraction aborted (${stage})`);
-    };
-    const runPassiveCapture = async (captureTurns, captureOptions) => {
-      const deadlineController = typeof deadlineMs === "number" && Number.isFinite(deadlineMs) ? new AbortController() : void 0;
-      const captureSignal = combineExtractionAbortSignals(
-        captureOptions.abortSignal ?? options.abortSignal,
-        deadlineController
-      );
-      let deadlineTimer;
-      if (deadlineController && typeof deadlineMs === "number") {
-        const scheduleDeadlineAbort = () => {
-          const remainingMs = deadlineMs - Date.now();
-          if (remainingMs <= 0) {
-            deadlineController.abort();
-            return;
-          }
-          deadlineTimer = setTimeout(
-            () => {
-              if (Date.now() >= deadlineMs) {
-                deadlineController.abort();
-              } else {
-                scheduleDeadlineAbort();
-              }
-            },
-            Math.min(remainingMs, 2147483647)
-          );
-        };
-        scheduleDeadlineAbort();
-      }
-      try {
-        await raceRecallAbort(
-          this.deps.maybeCapturePassiveCorrections(captureTurns, {
-            ...captureOptions,
-            ...captureSignal ? { abortSignal: captureSignal } : {}
-          }),
-          captureSignal,
-          "extraction aborted (during_passive_capture)"
-        );
-      } catch (error) {
-        if (typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
-          throw new ExtractionDeadlineError("during_passive_capture");
-        }
-        throw error;
-      } finally {
-        if (deadlineTimer) clearTimeout(deadlineTimer);
-      }
-    };
-    const clearBuffer = async (options2) => {
-      if (options2?.ignoreAbort !== true) {
-        throwIfDeadlineExceeded("before_clear_buffer");
-        throwIfAborted("before_clear_buffer");
-      }
-      if (clearBufferAfterExtraction) {
-        await this.deps.getBuffer().clearAfterExtraction(bufferKey, turns, clearMatchingTurns ? { allowNonPrefix: true } : void 0);
-      }
-    };
-    const sessionKey = turns[0]?.sessionKey ?? "";
-    if (sessionKey.includes(":cron:")) {
-      log.debug(`skipping extraction for cron session: ${sessionKey}`);
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "cron_session",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
-    }
-    const normalizedTurns = turns.filter((t) => (t.role === "user" || t.role === "assistant") && typeof t.content === "string").map((t) => ({
-      ...t,
-      content: t.content.trim().slice(0, this.config.extractionMaxTurnChars)
-    })).filter((t) => t.content.length > 0);
-    const targetTurns = normalizedTurns.filter((turn) => turn.extractionContextOnly !== true);
-    if (targetTurns.length === 0) {
-      log.debug("skipping extraction: no non-context turns after normalization");
-      if (normalizedTurns.length > 0) {
-        throwIfDeadlineExceeded("before_context_only_capture");
-        const capturePrincipal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-        const captureNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : this.deps.resolveSelfNamespace(sessionKey);
-        await runPassiveCapture(normalizedTurns, {
-          sessionKey,
-          principal: capturePrincipal,
-          namespace: captureNamespace,
-          bufferKey,
-          isLiveSession: clearBufferAfterExtraction
-        });
-        throwIfDeadlineExceeded("before_context_only_clear");
-      }
-      await clearBuffer();
-      return { status: "skipped", reason: "empty_normalized_turns", persistedCount: 0, durableOutputCount: 0 };
-    }
-    const sourceValidAt = this.latestSourceValidAtFromTurns(targetTurns);
-    throwIfDeadlineExceeded("before_extract");
-    throwIfAborted("before_extract");
-    const userTurns = targetTurns.filter((t) => t.role === "user");
-    const totalChars = targetTurns.reduce((sum, t) => sum + t.content.length, 0);
-    const belowCharThreshold = totalChars < this.config.extractionMinChars;
-    const belowUserTurnThreshold = !skipUserTurnThreshold && userTurns.length < this.config.extractionMinUserTurns;
-    if (!skipCharThreshold && belowCharThreshold || belowUserTurnThreshold) {
-      log.debug(`skipping extraction: below threshold (totalChars=${totalChars}, userTurns=${userTurns.length})`);
-      {
-        const capturePrincipal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-        const captureWO = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : void 0;
-        const captureCodingCtx = sessionKey ? this.deps.getCodingContextForSession(sessionKey) : null;
-        const captureCodingOv = resolveCodingNamespaceOverlay(
-          captureCodingCtx,
-          this.config.codingMode,
-          this.config.defaultNamespace
-        );
-        const captureScopePlan = resolveScopeProfilePlan({
-          config: this.config,
-          principal: capturePrincipal,
-          codingContext: captureCodingCtx,
-          codingOverlay: captureCodingOv
-        });
-        const captureNamespace = captureWO ?? captureScopePlan?.writeNamespace ?? this.deps.resolveSelfNamespace(sessionKey);
-        await runPassiveCapture(normalizedTurns, {
-          sessionKey,
-          principal: capturePrincipal,
-          namespace: captureNamespace,
-          bufferKey,
-          isLiveSession: clearBufferAfterExtraction
-        });
-      }
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "below_threshold",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
-    }
-    const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-    const explicitWriteNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : void 0;
-    const codingContextForWrite = sessionKey ? this.deps.getCodingContextForSession(sessionKey) : null;
-    const codingOverlayForWrite = resolveCodingNamespaceOverlay(
-      codingContextForWrite,
-      this.config.codingMode,
-      this.config.defaultNamespace
-    );
-    const scopeProfileGatePlan = options.scopeProfileWritePlan !== void 0 ? options.scopeProfileWritePlan : resolveScopeProfilePlan({
-      config: this.config,
-      principal,
-      codingContext: codingContextForWrite,
-      codingOverlay: codingOverlayForWrite
-    });
-    const scopeProfileWritePlan = explicitWriteNamespace && options.scopeProfileWritePlan === void 0 ? null : scopeProfileGatePlan;
-    if (scopeProfileWritePlan) {
-      const selectedLayer = scopeProfileWritePlan.layers.find((layer) => layer.id === scopeProfileWritePlan.writeLayer);
-      const writeNamespaceReadable = scopeProfileWritePlan.readNamespaces.includes(
-        scopeProfileWritePlan.writeNamespace
-      );
-      if (!selectedLayer?.writable || !writeNamespaceReadable) {
-        log.warn(
-          `runExtraction: skipping scope profile ${scopeProfileWritePlan.profileId} because write layer ${scopeProfileWritePlan.writeLayer} is not writable inside the profile read stack`
-        );
-        await clearBuffer();
-        return {
-          status: "skipped",
-          reason: "scope_profile_no_writable_layer",
-          persistedCount: 0,
-          durableOutputCount: 0
-        };
-      }
-    }
-    const selfNamespace = explicitWriteNamespace ?? scopeProfileWritePlan?.writeNamespace ?? this.deps.applyCodingNamespaceOverlay(sessionKey, defaultNamespaceForPrincipal(principal, this.config));
-    const extractionDeadlineController = typeof deadlineMs === "number" && Number.isFinite(deadlineMs) ? new AbortController() : void 0;
-    const extractionAbortSignal = extractionDeadlineController ? options.abortSignal ? AbortSignal.any([options.abortSignal, extractionDeadlineController.signal]) : extractionDeadlineController.signal : options.abortSignal;
-    let extractionDeadlineTimer;
-    const clearExtractionDeadlineTimer = () => {
-      if (extractionDeadlineTimer) {
-        clearTimeout(extractionDeadlineTimer);
-        extractionDeadlineTimer = void 0;
-      }
-    };
-    const runDeadlineAware = async (operation, phase, clearTimerOnError = true, options2 = {}) => {
-      const operationSignal = options2.ignoreAbort ? void 0 : extractionAbortSignal;
-      try {
-        if (!options2.ignoreDeadline && typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
-          throwIfDeadlineExceeded(phase);
-        }
-        if (operationSignal?.aborted) {
-          throwIfAborted(phase);
-        }
-        return await raceRecallAbort(
-          operation(),
-          operationSignal,
-          `extraction aborted (${phase})`
-        );
-      } catch (error) {
-        if (clearTimerOnError) clearExtractionDeadlineTimer();
-        if (!options2.ignoreDeadline && typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
-          throw new ExtractionDeadlineError(phase);
-        }
-        throw error;
-      }
-    };
-    if (extractionDeadlineController && typeof deadlineMs === "number") {
-      const deadline = deadlineMs;
-      const maxTimerDelayMs = 2147483647;
-      const scheduleDeadlineAbort = () => {
-        const remainingMs = deadline - Date.now();
-        if (remainingMs <= 0) {
-          extractionDeadlineController.abort();
-          return;
-        }
-        extractionDeadlineTimer = setTimeout(() => {
-          if (Date.now() >= deadline) {
-            extractionDeadlineController.abort();
-          } else {
-            scheduleDeadlineAbort();
-          }
-        }, Math.min(remainingMs, maxTimerDelayMs));
-      };
-      scheduleDeadlineAbort();
-    }
-    const storage = await runDeadlineAware(
-      () => this.deps.getStorageRouter().storageFor(selfNamespace),
-      "during_storage"
-    );
-    const shouldPersistProcessedFingerprint = targetTurns.some((turn) => turn.persistProcessedFingerprint === true);
-    const extractionFingerprint = this.buildExtractionFingerprint(targetTurns, bufferKey);
-    let meta = extractionFingerprint && shouldPersistProcessedFingerprint ? await runDeadlineAware(() => storage.loadMeta(), "during_load_meta") : null;
-    if (extractionFingerprint && shouldPersistProcessedFingerprint && (meta?.processedExtractionFingerprints ?? []).some((entry) => entry.fingerprint === extractionFingerprint)) {
-      await runDeadlineAware(() => clearBuffer(), "during_clear_buffer");
-      clearExtractionDeadlineTimer();
-      return {
-        status: "skipped",
-        reason: "processed_fingerprint",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
-    }
-    const forcedExtractionAttempt = options.failOnExtractionFailure === true || options.forceExtractionAttempt === true;
-    const extractionRetryEnabled = resolveMemoryLifecycleCapabilities(this.config).extractionRetry;
-    if (extractionFingerprint && !forcedExtractionAttempt && extractionRetryEnabled) {
-      try {
-        meta ??= await runDeadlineAware(() => storage.loadMeta(), "during_retry_gate");
-        this.hydrateRetryStateFromMeta(selfNamespace, meta);
-        const nowMs = Date.now();
-        let suppressReason = null;
-        if (this.isProviderBreakerOpen(nowMs)) {
-          suppressReason = "provider_circuit_open";
-        } else {
-          const st = this.extractionRetryState.get(selfNamespace)?.get(extractionFingerprint);
-          if (st && nowMs < st.nextEligibleAtMs) suppressReason = "extraction_backoff";
-        }
-        if (suppressReason) {
-          try {
-            await runDeadlineAware(
-              () => runPassiveCapture(normalizedTurns, {
-                sessionKey,
-                principal,
-                namespace: selfNamespace,
-                bufferKey,
-                isLiveSession: clearBufferAfterExtraction
-              }),
-              "during_passive_capture"
-            );
-          } catch (captureErr) {
-            if (captureErr instanceof ExtractionDeadlineError) throw captureErr;
-            log.warn("runExtraction: passive correction capture failed on suppressed attempt (non-fatal)", captureErr);
-          }
-          clearExtractionDeadlineTimer();
-          return { status: "skipped", reason: suppressReason, persistedCount: 0, durableOutputCount: 0 };
-        }
-      } catch (err) {
-        if (err instanceof ExtractionDeadlineError) throw err;
-        log.warn("runExtraction: extraction retry gate check failed; proceeding (fail-open)", err);
-      }
-    }
-    const existingEntities = await runDeadlineAware(
-      () => storage.listEntityNames(),
-      "during_list_entity_names"
-    );
-    let result;
-    try {
-      result = await raceRecallAbort(
-        this.deps.getExtraction().extract(normalizedTurns, existingEntities, extractionAbortSignal),
-        extractionAbortSignal,
-        "extraction aborted (during_extract)"
-      );
-    } catch (error) {
-      clearExtractionDeadlineTimer();
-      if (typeof deadlineMs === "number" && Date.now() >= deadlineMs) {
-        throw new ExtractionDeadlineError("during_extract");
-      }
-      throw error;
-    }
-    try {
-      throwIfDeadlineExceeded("before_persist");
-      throwIfAborted("before_persist");
-      if (!result) {
-        log.warn("runExtraction: extraction returned null/undefined");
-        if (options.failOnExtractionFailure) {
-          throw new Error("extraction failed: invalid_extraction_result");
-        }
-        await clearBuffer();
-        return {
-          status: "skipped",
-          reason: "invalid_extraction_result",
-          persistedCount: 0,
-          durableOutputCount: 0
-        };
-      }
-      const invalidExtractionResultFields = [
-        ["facts", result.facts],
-        ["entities", result.entities],
-        ["questions", result.questions],
-        ["profileUpdates", result.profileUpdates]
-      ].filter(([, value]) => !Array.isArray(value)).map(([field]) => field);
-      if (invalidExtractionResultFields.length > 0) {
-        log.warn("runExtraction: extraction returned invalid collection fields", {
-          invalidFields: invalidExtractionResultFields,
-          resultKeys: typeof result === "object" && result !== null ? Object.keys(result) : []
-        });
-        if (options.failOnExtractionFailure) {
-          throw new Error("extraction failed: invalid_extraction_result");
-        }
-        await clearBuffer();
-        return {
-          status: "skipped",
-          reason: "invalid_extraction_result",
-          persistedCount: 0,
-          durableOutputCount: 0
-        };
-      }
-      const extractionFailure = typeof result.extractionFailure === "string" && result.extractionFailure.trim().length > 0 ? result.extractionFailure : void 0;
-      let recordedRetryFailure = false;
-      if (extractionFingerprint && extractionRetryEnabled) {
-        if (extractionFailure) {
-          try {
-            meta ??= await runDeadlineAware(() => storage.loadMeta(), "during_retry_bookkeeping_load", false);
-            await runDeadlineAware(
-              () => this.recordExtractionFailure(
-                storage,
-                selfNamespace,
-                extractionFingerprint,
-                result.extractionFailureClass ?? "provider_retryable",
-                meta,
-                Date.now()
-              ),
-              "during_retry_bookkeeping_save",
-              false
-            );
-            recordedRetryFailure = true;
-          } catch (err) {
-            if (err instanceof ExtractionDeadlineError) throw err;
-            log.warn("runExtraction: failed to load meta for retry bookkeeping (non-fatal)", err);
-          }
-        } else if (result.extractionSkippedReason === void 0) {
-          this.resetProviderBreakerOnSuccess();
-          try {
-            meta ??= await runDeadlineAware(() => storage.loadMeta(), "during_retry_bookkeeping_load", false);
-            this.hydrateRetryStateFromMeta(selfNamespace, meta);
-            if (this.clearExtractionRetryEntry(selfNamespace, extractionFingerprint, meta)) {
-              await runDeadlineAware(() => storage.saveMeta(meta), "during_retry_bookkeeping_save", false);
-            }
-          } catch (err) {
-            if (err instanceof ExtractionDeadlineError) throw err;
-            log.warn("runExtraction: failed to persist cleared retry state (non-fatal)", err);
-          }
-        }
-      }
-      if (options.failOnExtractionFailure && extractionFailure) {
-        throw new Error(`extraction failed: ${extractionFailure}`);
-      }
-      if (result.facts.length === 0 && result.entities.length === 0 && result.questions.length === 0 && result.profileUpdates.length === 0) {
-        log.debug("runExtraction: extraction produced no durable outputs; skipping persistence");
-        if (extractionFailure) {
-          log.warn(
-            "runExtraction: extraction reported failure with no durable outputs; not marking fingerprint processed",
-            { extractionFailure }
-          );
-        }
-        const emptySuccessCommit = {
-          storage,
-          meta,
-          extractionFingerprint,
-          shouldPersistProcessedFingerprint,
-          hasExtractionFailure: Boolean(extractionFailure),
-          extractionSkippedReason: result.extractionSkippedReason,
-          recordProcessedExtractionFingerprint: this.deps.recordProcessedExtractionFingerprint,
-          runDeadlineAware,
-          isDeadlineError: (error) => error instanceof ExtractionDeadlineError
-        };
-        if (shouldPersistProcessedFingerprint) {
-          await commitEmptySuccessExtraction(emptySuccessCommit);
-        }
-        await runPassiveCapture(normalizedTurns, {
-          sessionKey,
-          principal,
-          namespace: selfNamespace,
-          bufferKey,
-          isLiveSession: clearBufferAfterExtraction
-        });
-        if (recordedRetryFailure) {
-          log.debug("runExtraction: retaining buffer for backoff retry after failure");
-        } else {
-          await clearBuffer();
-        }
-        if (!shouldPersistProcessedFingerprint) {
-          await commitEmptySuccessExtraction(emptySuccessCommit);
-        }
-        return { status: "skipped", reason: "empty_extraction_result", persistedCount: 0, durableOutputCount: 0 };
-      }
-      let threadIdForExtraction = null;
-      if (resolvePresentationCapabilities(this.config).threading && turns.length > 0) {
-        const lastTurn = turns[turns.length - 1];
-        try {
-          threadIdForExtraction = await runDeadlineAware(
-            () => this.deps.getThreading().processTurn(lastTurn, []),
-            "during_threading"
-          );
-        } catch (err) {
-          if (err instanceof ExtractionDeadlineError) throw err;
-          log.warn("[threading] processTurn failed before persistence (non-fatal)", err);
-        }
-      }
-      const originContext = deriveExtractionOriginContext(targetTurns, result.sourceConnector);
-      throwIfDeadlineExceeded("before_persist");
-      throwIfAborted("before_persist");
-      const { persistedIds } = await this.deps.persistExtraction(
-        result,
-        storage,
-        threadIdForExtraction,
-        { sessionKey, principal, validAt: sourceValidAt, ...originContext },
-        // Pass the KNOWN base namespace (NHIdx) so the catalog write touch records the
-        // real namespace rather than a guess decoded from the storage dir.
-        selfNamespace,
-        scopeProfileWritePlan,
-        // Verbatim source turns for the faithfulness gate (#1576) so it can
-        // locate a quote per fact when #1575 spans are absent.
-        normalizedTurns.map((t) => t.content).join("\n\n")
-      );
-      const durableOutputCount = result.facts.length + result.entities.length + result.questions.length + result.profileUpdates.length;
-      try {
-        options.onDurableCommit?.();
-      } catch (error) {
-        log.warn("runExtraction: durable-commit callback failed", error);
-      }
-      const runPostPersistBestEffort = runExtractionPostPersistBestEffort.bind(null, runDeadlineAware);
-      await tagPersistedMemories(storage, persistedIds, this.config);
-      const postPersist = await runExtractionPostPersist({
-        result,
-        storage,
-        meta: meta ?? void 0,
-        extractionFingerprint: extractionFingerprint ?? void 0,
-        shouldPersistProcessedFingerprint,
-        recordProcessedExtractionFingerprint: this.deps.recordProcessedExtractionFingerprint,
-        runDeadlineAware,
-        isDeadlineError: (error) => error instanceof ExtractionDeadlineError,
-        createDeadlineError: (stage) => new ExtractionDeadlineError(stage),
-        deadlineMs,
-        clearBufferAfterExtraction,
-        runPostPersistBestEffort,
-        extractionJudgeShadow: this.config.extractionJudgeShadow,
-        getDeferredCount: () => this.deps.getLastPersistExtractionDeferredCount(),
-        normalizedTurns,
-        bufferKey,
-        retainDeferredTurns: (key, retainedTurns, max) => this.deps.getBuffer().retainDeferredTurns(key, retainedTurns, max),
-        clearBuffer,
-        failOnExtractionFailure: options.failOnExtractionFailure === true
-      });
-      meta = postPersist.meta ?? null;
-      const postPersistMetadataFailed = postPersist.metadataFailed;
-      await runPostPersistBestEffort(
-        "during_post_persist_passive_capture",
-        () => runPassiveCapture(normalizedTurns, {
-          sessionKey,
-          principal,
-          namespace: selfNamespace,
-          bufferKey,
-          isLiveSession: clearBufferAfterExtraction,
-          abortSignal: extractionAbortSignal
-        })
-      );
-      if (resolvePresentationCapabilities(this.config).memoryBoxes && persistedIds.length > 0) {
-        const extractionTopics = deriveTopicsFromExtraction(result);
-        const firstUserTurn = turns.find((t) => t.role === "user");
-        const boxGoal = firstUserTurn?.content?.slice(0, 100)?.trim() || void 0;
-        await runPostPersistBestEffort(
-          "during_memory_box",
-          () => this.deps.boxBuilderFor(storage).onExtraction({
-            topics: extractionTopics,
-            memoryIds: persistedIds,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            goal: boxGoal
-          })
-        );
-      }
-      if (resolvePresentationCapabilities(this.config).threading && threadIdForExtraction && persistedIds.length > 0) {
-        await runPostPersistBestEffort(
-          "during_thread_episode_append",
-          () => this.deps.appendPersistedThreadEpisodes(threadIdForExtraction, persistedIds)
-        );
-      }
-      if (resolvePresentationCapabilities(this.config).threading && threadIdForExtraction) {
-        const conversationContent = turns.map((t) => t.content).join(" ");
-        await runPostPersistBestEffort(
-          "during_thread_title_update",
-          () => this.deps.getThreading().updateThreadTitle(threadIdForExtraction, conversationContent)
-        );
-      }
-      const nonZeroExtraction = durableOutputCount > 0;
-      try {
-        this.deps.maybeScheduleConsolidation(nonZeroExtraction);
-      } catch (err) {
-        log.warn("runExtraction: consolidation scheduling failed after persistence (non-fatal)", err);
-      }
-      try {
-        this.deps.requestQmdMaintenance();
-      } catch (err) {
-        log.warn("runExtraction: QMD maintenance scheduling failed after persistence (non-fatal)", err);
-      }
-      await runPostPersistBestEffort(
-        "during_tier_migration",
-        () => this.deps.runTierMigrationCycle(storage, "extraction")
-      );
-      return {
-        status: "completed",
-        persistedCount: persistedIds.length,
-        durableOutputCount,
-        postPersistMetadataFailed
-      };
-    } finally {
-      clearExtractionDeadlineTimer();
-    }
-  }
-};
-
-export {
-  classifyExtractionOrigin,
-  deriveTopicsFromExtraction,
-  deriveSourceConnector,
-  ExtractionDeadlineError,
-  ExtractionRunCoordinator
-};
-//# sourceMappingURL=chunk-DZP2XMZC.js.map