@remnic/core 9.6.39 → 9.7.0

package/dist/{chunk-PWSZNML3.js → chunk-NGJT7IW5.js}

@@ -4,13 +4,13 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-J3XHPFEU.js";
+} from "./chunk-VXMWDXIJ.js";
 import {
   CompressionGuidelineCoordinator
-} from "./chunk-BRDJ2HFP.js";
+} from "./chunk-TRWPCR6P.js";
 import {
   MaintenanceScheduler
-} from "./chunk-5ELELET5.js";
+} from "./chunk-HT2DQ27U.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -26,10 +26,10 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-GCTJG5MP.js";
+} from "./chunk-AWHOZTF6.js";
 import {
   SharedContextManager
-} from "./chunk-UI4FVU6T.js";
+} from "./chunk-5CJVLG3H.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -70,7 +70,7 @@ import {
 } from "./chunk-4EX5WZ4M.js";
 import {
   HourlySummarizer
-} from "./chunk-XZ5I7OZR.js";
+} from "./chunk-KIPLG7S7.js";
 import {
   SessionObserverState
 } from "./chunk-FDPZVY6D.js";
@@ -144,7 +144,7 @@ import {
 } from "./chunk-PD6O7AXF.js";
 import {
   runLiveConnectorsOnce
-} from "./chunk-VU3SVYMA.js";
+} from "./chunk-HTIIXNJQ.js";
 import {
   classifyMemoryKind
 } from "./chunk-YAZNBMNF.js";
@@ -157,14 +157,14 @@ import {
   getVerdictKind,
   judgeFactDurability,
   validateProcedureExtraction
-} from "./chunk-YFBTVOMB.js";
+} from "./chunk-SYNYI4ZM.js";
 import {
   contentMatchesRedactionRules,
   loadRedactionRules
 } from "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-CZGIIADK.js";
+} from "./chunk-FXGC5UUH.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -173,7 +173,7 @@ import {
 } from "./chunk-KAWTOYAW.js";
 import {
   LocalLlmClient
-} from "./chunk-QT2RZNRT.js";
+} from "./chunk-VY6LKKVN.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
@@ -191,18 +191,18 @@ import {
 } from "./chunk-TVIVY7KU.js";
 import {
   formatDaySummaryMemories
-} from "./chunk-I73G4UH7.js";
+} from "./chunk-IALLX7EE.js";
 import {
   tryDirectAnswer
 } from "./chunk-Q6IP2ARR.js";
 import {
   EmbeddingFallback
-} from "./chunk-O2EL7EGG.js";
+} from "./chunk-ZQ7UBUZ6.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-WHZ7MK72.js";
+} from "./chunk-4YUPLX7U.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
@@ -212,14 +212,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-7TEWOG3R.js";
+} from "./chunk-FMECZFUT.js";
 import {
   ThreadingManager
 } from "./chunk-DBRYEIGY.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-ZIKJD6NL.js";
+} from "./chunk-53Y3TETS.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -232,14 +232,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-2V6L3L56.js";
+} from "./chunk-DDHT5J5M.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-XH2Y6UIW.js";
+} from "./chunk-VD56CJRR.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-7XY6TJLM.js";
+} from "./chunk-PUPQ2PMC.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -274,7 +274,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-3BZDBG7U.js";
+} from "./chunk-PML3GU4Q.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -296,7 +296,7 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   SmartBuffer
-} from "./chunk-QLVLW7UD.js";
+} from "./chunk-KSBEEMQF.js";
 import {
   isDisagreementPrompt
 } from "./chunk-H3FZVNRN.js";
@@ -323,7 +323,7 @@ import {
   createCorrectionService,
   detectPassiveCorrections,
   qmdCollectionPathParts
-} from "./chunk-RU73ZROD.js";
+} from "./chunk-KWJP22WP.js";
 import {
   importCapsule
 } from "./chunk-M5QKGHCR.js";
@@ -339,7 +339,7 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   buildXraySnapshot
-} from "./chunk-AZK3NEHL.js";
+} from "./chunk-BLXNPBJI.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -351,14 +351,14 @@ import {
   resolveNamespaceFromStorageDir,
   resolveScopePlan,
   resolveScopeProfilePlan
-} from "./chunk-BAVVI5GP.js";
+} from "./chunk-7PND4PUC.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-DQ2CJYUM.js";
+} from "./chunk-PSQ32V5P.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-SFHI7JBE.js";
+} from "./chunk-2FSHROYK.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -381,7 +381,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-ZGPDSEKG.js";
+} from "./chunk-BFVEEB7W.js";
 import {
   searchCausalTrajectories
 } from "./chunk-7XGSIUP5.js";
@@ -394,7 +394,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-CVEEJKRD.js";
+} from "./chunk-RQTCDICG.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -409,7 +409,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-PQG2AOL4.js";
+} from "./chunk-QRYNEVHP.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -446,7 +446,7 @@ import {
 } from "./chunk-SVOZFLIQ.js";
 import {
   confidenceTier
-} from "./chunk-METJNEIB.js";
+} from "./chunk-QMUERLZK.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -464,12 +464,12 @@ import {
   applyFaithfulnessVerdict,
   createFaithfulnessCounters,
   runFaithfulnessGateBatch
-} from "./chunk-MNUHL34L.js";
+} from "./chunk-LKT755LP.js";
 import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
   gatewayTaskChainOptions
-} from "./chunk-JIKJPDQJ.js";
+} from "./chunk-GKCCHHZK.js";
 import {
   CAPSULE_ID_PATTERN
 } from "./chunk-WEHSQBFR.js";
@@ -486,7 +486,7 @@ import {
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
-} from "./chunk-PE6XR4GG.js";
+} from "./chunk-IKQTFQMI.js";
 import {
   isSafeRouteNamespace,
   selectRouteRule
@@ -512,7 +512,7 @@ import {
   resolveRecallEnhancementCapabilities,
   resolveSecurityCapabilities,
   resolveUtilityLearningCapabilities
-} from "./chunk-VSF7AAGE.js";
+} from "./chunk-BFPETA3S.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -3324,12 +3324,39 @@ function deriveTopicsFromExtraction(result) {
   }
   return [...topics].slice(0, 16);
 }
+var EXTRACTION_RETRY_STATE_MAX_ENTRIES = 500;
+function computeExtractionRetryNextEligibleMs(attempts, scheduleMs, maxBackoffMs, jitterRatio, now, rng = Math.random) {
+  const cap = Number.isFinite(maxBackoffMs) && maxBackoffMs > 0 ? maxBackoffMs : 0;
+  if (!Array.isArray(scheduleMs) || scheduleMs.length === 0) {
+    return now + cap;
+  }
+  const idx = Math.min(Math.max(attempts - 1, 0), scheduleMs.length - 1);
+  const step = scheduleMs[idx];
+  const base = Math.min(typeof step === "number" && step > 0 ? step : cap, cap);
+  const jitter = 1 + (rng() * 2 - 1) * jitterRatio;
+  return now + Math.max(0, Math.round(base * jitter));
+}
+function capExtractionRetryStateEntries(entries, maxEntries) {
+  if (maxEntries <= 0) return [];
+  const sorted = [...entries].sort((a, b) => a.firstFailedAt.localeCompare(b.firstFailedAt));
+  return sorted.slice(-maxEntries);
+}
 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;
   }
@@ -3407,6 +3434,150 @@ ${normalized}`).digest("hex");
     }
   }
   // -------------------------------------------------------------------------
+  // 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 = {}) {
@@ -3551,6 +3722,38 @@ ${normalized}`).digest("hex");
         durableOutputCount: 0
       };
     }
+    const forcedExtractionAttempt = options.failOnExtractionFailure === true || options.forceExtractionAttempt === true;
+    const extractionRetryEnabled = resolveMemoryLifecycleCapabilities(this.config).extractionRetry;
+    if (extractionFingerprint && !forcedExtractionAttempt && extractionRetryEnabled) {
+      try {
+        meta ??= await storage.loadMeta();
+        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 this.deps.maybeCapturePassiveCorrections(normalizedTurns, {
+              sessionKey,
+              principal,
+              namespace: selfNamespace,
+              bufferKey,
+              isLiveSession: clearBufferAfterExtraction
+            });
+          } catch (captureErr) {
+            log.warn("runExtraction: passive correction capture failed on suppressed attempt (non-fatal)", captureErr);
+          }
+          return { status: "skipped", reason: suppressReason, persistedCount: 0, durableOutputCount: 0 };
+        }
+      } catch (err) {
+        log.warn("runExtraction: extraction retry gate check failed; proceeding (fail-open)", err);
+      }
+    }
     const existingEntities = await storage.listEntityNames();
     const result = await raceRecallAbort(
       this.deps.getExtraction().extract(normalizedTurns, existingEntities),
@@ -3595,6 +3798,36 @@ ${normalized}`).digest("hex");
       };
     }
     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 storage.loadMeta();
+          await this.recordExtractionFailure(
+            storage,
+            selfNamespace,
+            extractionFingerprint,
+            result.extractionFailureClass ?? "provider_retryable",
+            meta,
+            Date.now()
+          );
+          recordedRetryFailure = true;
+        } catch (err) {
+          log.warn("runExtraction: failed to load meta for retry bookkeeping (non-fatal)", err);
+        }
+      } else {
+        this.resetProviderBreakerOnSuccess();
+        try {
+          meta ??= await storage.loadMeta();
+          this.hydrateRetryStateFromMeta(selfNamespace, meta);
+          if (this.clearExtractionRetryEntry(selfNamespace, extractionFingerprint, meta)) {
+            await storage.saveMeta(meta);
+          }
+        } catch (err) {
+          log.warn("runExtraction: failed to persist cleared retry state (non-fatal)", err);
+        }
+      }
+    }
     if (options.failOnExtractionFailure && extractionFailure) {
       throw new Error(`extraction failed: ${extractionFailure}`);
     }
@@ -3620,7 +3853,11 @@ ${normalized}`).digest("hex");
         bufferKey,
         isLiveSession: clearBufferAfterExtraction
       });
-      await clearBuffer();
+      if (recordedRetryFailure) {
+        log.debug("runExtraction: retaining buffer for backoff retry after failure");
+      } else {
+        await clearBuffer();
+      }
       return { status: "skipped", reason: "empty_extraction_result", persistedCount: 0, durableOutputCount: 0 };
     }
     let threadIdForExtraction = null;
@@ -11575,6 +11812,7 @@ var TurnIngestionCoordinator = class {
       ({ bufferKey, turns: sessionSlice }) => new Promise((resolve, reject) => {
         void this.deps.queueBufferedExtraction(sessionSlice, "trigger_mode", {
           skipDedupeCheck: true,
+          forceExtractionAttempt: true,
           clearBufferAfterExtraction: false,
           skipCharThreshold: true,
           skipUserTurnThreshold: true,
@@ -11715,6 +11953,7 @@ var TurnIngestionCoordinator = class {
           (resolve, reject) => {
             void this.deps.queueBufferedExtraction(sessionSlice, "trigger_mode", {
               skipDedupeCheck: true,
+              forceExtractionAttempt: true,
               clearBufferAfterExtraction: false,
               skipCharThreshold: true,
               skipUserTurnThreshold: true,
@@ -11880,7 +12119,8 @@ var TurnIngestionCoordinator = class {
           abortSignal: options.abortSignal,
           failOnExtractionFailure: options.failOnExtractionFailure === true,
           writeNamespaceOverride: options.writeNamespaceOverride,
-          principalOverride: options.principalOverride
+          principalOverride: options.principalOverride,
+          forceExtractionAttempt: options.forceExtractionAttempt === true
         });
         settleTask(void 0, result);
       } catch (err) {
@@ -12965,7 +13205,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.deps.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-4I3VDSYS.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-TI67YMLG.js");
         const result = await runFirstStartMigration({
           storage: this.deps.storage,
           config: this.deps.config,
@@ -12988,7 +13228,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (!this.deps.wearablesAutoSyncHandle && this.deps.config.wearables.enabled && this.deps.config.wearables.autoSyncEnabled && Object.values(this.deps.config.wearables.sources).some((source) => source.enabled)) {
       try {
-        const { startWearablesAutoSync } = await import("./auto-sync-4A5YBWYO.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-676N6N6Y.js");
         if (signal.aborted) return;
         this.deps.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -15434,6 +15674,7 @@ var SessionContextCoordinator = class {
           bufferKey,
           clearBufferAfterExtraction: true,
           skipDedupeCheck: true,
+          forceExtractionAttempt: true,
           abortSignal: options.abortSignal,
           onTaskSettled: (error) => error ? reject(error) : resolve()
         }).catch(reject);
@@ -17299,6 +17540,11 @@ ${doc.content}` : doc.content,
   async runExtraction(...args) {
     return this.extractionRunCoordinator.runExtraction(...args);
   }
+  /** Live extraction resilience snapshot (provider circuit breaker + per-
+   *  fingerprint backoff population) for status/doctor surfaces. */
+  getExtractionResilienceStatus() {
+    return this.extractionRunCoordinator.getExtractionResilienceStatus();
+  }
   async recordProcessedExtractionFingerprint(storage, fingerprint, preloadedMeta) {
     return this.extractionRunCoordinator.recordProcessedExtractionFingerprint(
       storage,
@@ -23092,4 +23338,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-PWSZNML3.js.map
+//# sourceMappingURL=chunk-NGJT7IW5.js.map