@remnic/core 10.0.65 → 10.0.67

package/dist/{chunk-6D3IWYNY.js → chunk-R2BIVU2Z.js}

@@ -132,7 +132,7 @@ async function runExtractionPostPersistBestEffort(runDeadlineAware, stage, opera
 async function runExtractionDeferRetention(runPostPersistBestEffort, options) {
   await runPostPersistBestEffort("during_defer_retention", async () => {
     if (options.clearBufferAfterExtraction && !options.extractionJudgeShadow) {
-      const deferredCount = options.getDeferredCount();
+      const deferredCount = options.deferredCount;
       if (deferredCount > 0 && options.normalizedTurns.length > 0) {
         await options.retainDeferredTurns(options.bufferKey, options.normalizedTurns, 10);
       } else {
@@ -178,7 +178,7 @@ async function runExtractionPostPersist(options) {
   await runExtractionDeferRetention(runBestEffort, {
     clearBufferAfterExtraction: options.clearBufferAfterExtraction,
     extractionJudgeShadow: options.extractionJudgeShadow,
-    getDeferredCount: options.getDeferredCount,
+    deferredCount: options.deferredCount,
     normalizedTurns: options.normalizedTurns,
     bufferKey: options.bufferKey,
     retainDeferredTurns: options.retainDeferredTurns
@@ -274,6 +274,104 @@ function classifyExtractionOrigin(sourceContext) {
   });
 }
 
+// src/orchestration/provider-breaker.ts
+var ProviderCircuitBreaker = class {
+  consecutiveFailures = 0;
+  openUntilMs = 0;
+  state = "closed";
+  lastReason = "";
+  probeHeld = false;
+  probeToken = null;
+  acquire(now) {
+    if (now < this.openUntilMs) return { suppressed: true, probe: false };
+    if (this.state === "open") {
+      this.state = "half_open";
+      this.probeHeld = true;
+      const token = { __probeOwner: true };
+      this.probeToken = token;
+      this.logTransition();
+      return { suppressed: false, probe: true, token };
+    }
+    if (this.state === "half_open") {
+      if (this.probeHeld) return { suppressed: true, probe: false };
+      this.probeHeld = true;
+      const token = { __probeOwner: true };
+      this.probeToken = token;
+      return { suppressed: false, probe: true, token };
+    }
+    return { suppressed: false, probe: false };
+  }
+  /** Release an owned probe on an attempt that exits without a terminal
+   *  outcome (deadline, abort, throw). Only the matching owner releases;
+   *  idempotent; state stays half_open so the next attempt re-probes. */
+  releaseProbe(token) {
+    if (token === void 0 || this.probeToken !== token) return;
+    this.probeToken = null;
+    this.probeHeld = false;
+  }
+  failure(cls, now, config, probeToken) {
+    const owned = probeToken !== void 0 && this.probeToken === probeToken;
+    if (owned) {
+      this.probeToken = null;
+      this.probeHeld = false;
+    }
+    this.consecutiveFailures += 1;
+    const trip = (
+      // An unowned auth_config failure (forced extraction) must not reopen
+      // over a held half-open probe — same ownership rule as the threshold
+      // term; the auth cooldown still applies once the probe settles.
+      cls === "auth_config" && (this.state !== "half_open" || owned) || // 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).
+      owned && this.state === "half_open" || // PRRT_kwDORJXyws6zxG6V: an unowned (forced-extraction) failure must
+      // not cross the threshold while another attempt owns the half-open
+      // probe — reopening here would strand the owner's token and let the
+      // next cooldown mint a second concurrent probe. The failure count and
+      // retry bookkeeping still accumulate for when the state leaves
+      // half_open.
+      this.state !== "half_open" && this.consecutiveFailures >= config.failureThreshold
+    );
+    if (!trip) return;
+    const cooldown = cls === "auth_config" ? config.authCooldownMs : config.cooldownMs;
+    this.openUntilMs = now + Math.max(0, cooldown);
+    this.lastReason = cls;
+    if (this.state !== "open") {
+      this.state = "open";
+      this.logTransition();
+    }
+  }
+  success(probeToken) {
+    const wasDisturbed = this.state !== "closed" || this.consecutiveFailures > 0 || this.openUntilMs > 0;
+    if (!wasDisturbed) return;
+    if (this.probeHeld && !(probeToken !== void 0 && this.probeToken === probeToken)) return;
+    const wasOpen = this.state !== "closed";
+    this.probeToken = null;
+    this.probeHeld = false;
+    this.consecutiveFailures = 0;
+    this.openUntilMs = 0;
+    this.lastReason = "";
+    this.state = "closed";
+    if (wasOpen) this.logTransition();
+  }
+  snapshot() {
+    return {
+      state: this.state,
+      openUntilMs: this.openUntilMs,
+      consecutiveFailures: this.consecutiveFailures,
+      lastReason: this.lastReason
+    };
+  }
+  logTransition() {
+    log.warn("extraction: provider circuit breaker transition", {
+      state: this.state,
+      consecutiveFailures: this.consecutiveFailures,
+      lastReason: this.lastReason,
+      openUntilMs: this.openUntilMs
+    });
+  }
+};
+
 // src/orchestration/extraction-run.ts
 var ExtractionDeadlineError = class extends Error {
   stage;
@@ -298,7 +396,7 @@ var ExtractionRunCoordinator = class {
   // 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: "" };
+  providerBreaker = new ProviderCircuitBreaker();
   get config() {
     return this.deps.config;
   }
@@ -398,51 +496,6 @@ ${normalized}`).digest("hex");
     }
     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) {
@@ -464,10 +517,10 @@ ${normalized}`).digest("hex");
     }
   }
   /** Record an extraction failure into per-fingerprint backoff state + breaker, persisting to namespace meta. Fail-open. */
-  async recordExtractionFailure(namespace, fingerprint, cls, meta, now) {
+  async recordExtractionFailure(namespace, fingerprint, cls, meta, now, probeToken) {
     try {
       this.hydrateRetryStateFromMeta(namespace, meta);
-      this.applyExtractionFailureToMemory(namespace, fingerprint, cls, now);
+      this.applyExtractionFailureToMemory(namespace, fingerprint, cls, now, probeToken);
       this.persistRetryStateToMeta(namespace, meta);
     } catch (err) {
       log.warn("runExtraction: failed to record extraction retry state (non-fatal)", err);
@@ -475,7 +528,7 @@ ${normalized}`).digest("hex");
   }
   /** Failure backoff into the in-memory mirror + breaker WITHOUT touching meta — the fallback
    *  when the locked meta write cannot run: the retry gate reads this mirror, so it stays shut. */
-  applyExtractionFailureToMemory(namespace, fingerprint, cls, now) {
+  applyExtractionFailureToMemory(namespace, fingerprint, cls, now, probeToken) {
     const nsMap = this.extractionRetryState.get(namespace) ?? /* @__PURE__ */ new Map();
     const prev = nsMap.get(fingerprint);
     const attempts = (prev?.attempts ?? 0) + 1;
@@ -494,7 +547,11 @@ ${normalized}`).digest("hex");
     }
     nsMap.set(fingerprint, { attempts, nextEligibleAtMs, firstFailedAtMs, lastFailureClass: cls });
     this.extractionRetryState.set(namespace, nsMap);
-    this.onProviderFailure(cls, now);
+    this.providerBreaker.failure(cls, now, {
+      failureThreshold: this.config.extractionBreakerFailureThreshold,
+      cooldownMs: this.config.extractionBreakerCooldownMs,
+      authCooldownMs: this.config.extractionBreakerAuthCooldownMs
+    }, probeToken);
   }
   /** 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
@@ -513,12 +570,7 @@ ${normalized}`).digest("hex");
       backoffFingerprintCount += nsMap.size;
     }
     return {
-      breaker: {
-        state: this.providerBreaker.state,
-        openUntilMs: this.providerBreaker.openUntilMs,
-        consecutiveFailures: this.providerBreaker.consecutiveFailures,
-        lastReason: this.providerBreaker.lastReason
-      },
+      breaker: this.providerBreaker.snapshot(),
       backoffFingerprintCount
     };
   }
@@ -774,13 +826,18 @@ ${normalized}`).digest("hex");
     }
     const forcedExtractionAttempt = options.failOnExtractionFailure === true || options.forceExtractionAttempt === true;
     const extractionRetryEnabled = resolveMemoryLifecycleCapabilities(this.config).extractionRetry;
+    let extractionProbeOwned = false;
+    let extractionProbeToken;
     if (extractionFingerprint && !forcedExtractionAttempt && extractionRetryEnabled) {
       try {
         meta ??= await runDeadlineAware(() => storage.loadMeta(), "during_retry_gate");
         this.hydrateRetryStateFromMeta(selfNamespace, meta);
         const nowMs = Date.now();
+        const probeAttempt = this.providerBreaker.acquire(nowMs);
+        extractionProbeOwned = probeAttempt.probe;
+        extractionProbeToken = probeAttempt.token;
         let suppressReason = null;
-        if (this.isProviderBreakerOpen(nowMs)) {
+        if (probeAttempt.suppressed) {
           suppressReason = "provider_circuit_open";
         } else {
           const st = this.extractionRetryState.get(selfNamespace)?.get(extractionFingerprint);
@@ -803,6 +860,7 @@ ${normalized}`).digest("hex");
             log.warn("runExtraction: passive correction capture failed on suppressed attempt (non-fatal)", captureErr);
           }
           clearExtractionDeadlineTimer();
+          if (extractionProbeOwned) this.providerBreaker.releaseProbe(extractionProbeToken);
           return { status: "skipped", reason: suppressReason, persistedCount: 0, durableOutputCount: 0 };
         }
       } catch (err) {
@@ -810,268 +868,272 @@ ${normalized}`).digest("hex");
         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)"
+      const existingEntities = await runDeadlineAware(
+        () => storage.listEntityNames(),
+        "during_list_entity_names"
       );
-    } 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");
+      let result;
+      try {
+        result = await raceRecallAbort(
+          this.deps.getExtraction().extract(normalizedTurns, existingEntities, extractionAbortSignal),
+          extractionAbortSignal,
+          "extraction aborted (during_extract)"
+        );
+      } catch (error) {
+        clearExtractionDeadlineTimer();
+        if (deadlineMs !== void 0 && Date.now() >= deadlineMs) {
+          throw new ExtractionDeadlineError("during_extract");
         }
-        await clearBuffer();
-        return {
-          status: "skipped",
-          reason: "invalid_extraction_result",
-          persistedCount: 0,
-          durableOutputCount: 0
-        };
+        throw error;
       }
-      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");
+      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
+          };
         }
-        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;
-      if (extractionFailure) {
-        recordExtractionLlmFailure(extractionFailure);
-        emitExtractionLlmFailureError(extractionFailure, result.extractionFailureClass);
-      } else if (result.extractionSkippedReason !== void 0) {
-      } else {
-        recordExtractionLlmSuccess();
-      }
-      let recordedRetryFailure = false;
-      if (extractionFingerprint && extractionRetryEnabled) {
+        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;
         if (extractionFailure) {
-          const failureClass = result.extractionFailureClass ?? "provider_retryable";
-          try {
-            await runDeadlineAware(
-              () => storage.updateMeta(
-                (freshMeta) => this.recordExtractionFailure(selfNamespace, extractionFingerprint, failureClass, freshMeta, Date.now())
-              ),
-              "during_retry_bookkeeping_save",
-              false
+          recordExtractionLlmFailure(extractionFailure);
+          emitExtractionLlmFailureError(extractionFailure, result.extractionFailureClass);
+        } else if (result.extractionSkippedReason !== void 0) {
+        } else {
+          recordExtractionLlmSuccess();
+        }
+        let recordedRetryFailure = false;
+        if (extractionFingerprint && extractionRetryEnabled) {
+          if (extractionFailure) {
+            const failureClass = result.extractionFailureClass ?? "provider_retryable";
+            try {
+              await runDeadlineAware(
+                () => storage.updateMeta(
+                  (freshMeta) => this.recordExtractionFailure(selfNamespace, extractionFingerprint, failureClass, freshMeta, Date.now(), extractionProbeToken)
+                ),
+                "during_retry_bookkeeping_save",
+                false
+              );
+              recordedRetryFailure = true;
+            } catch (err) {
+              if (err instanceof ExtractionDeadlineError) throw err;
+              if (err instanceof Error && err.message.includes("meta.json.lock not acquired"))
+                this.applyExtractionFailureToMemory(selfNamespace, extractionFingerprint, failureClass, Date.now(), extractionProbeToken);
+              recordedRetryFailure = true;
+              log.warn("runExtraction: retry state kept in memory; meta persist will catch up", err);
+            }
+          } else if (result.extractionSkippedReason === void 0) {
+            this.providerBreaker.success(extractionProbeToken);
+            try {
+              await runDeadlineAware(
+                () => storage.updateMeta((freshMeta) => {
+                  this.hydrateRetryStateFromMeta(selfNamespace, freshMeta);
+                  return this.clearExtractionRetryEntry(selfNamespace, extractionFingerprint, freshMeta);
+                }),
+                "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 }
             );
-            recordedRetryFailure = true;
-          } catch (err) {
-            if (err instanceof ExtractionDeadlineError) throw err;
-            if (err instanceof Error && err.message.includes("meta.json.lock not acquired"))
-              this.applyExtractionFailureToMemory(selfNamespace, extractionFingerprint, failureClass, Date.now());
-            recordedRetryFailure = true;
-            log.warn("runExtraction: retry state kept in memory; meta persist will catch up", err);
           }
-        } else if (result.extractionSkippedReason === void 0) {
-          this.resetProviderBreakerOnSuccess();
+          const emptySuccessCommit = {
+            storage,
+            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 emptyExtractionResult(recordedRetryFailure, result.extractionFailureClass);
+        }
+        let threadIdForExtraction = null;
+        if (resolvePresentationCapabilities(this.config).threading && turns.length > 0) {
+          const lastTurn = turns[turns.length - 1];
           try {
-            await runDeadlineAware(
-              () => storage.updateMeta((freshMeta) => {
-                this.hydrateRetryStateFromMeta(selfNamespace, freshMeta);
-                return this.clearExtractionRetryEntry(selfNamespace, extractionFingerprint, freshMeta);
-              }),
-              "during_retry_bookkeeping_save",
-              false
+            threadIdForExtraction = await runDeadlineAware(
+              () => this.deps.getThreading().processTurn(lastTurn, []),
+              "during_threading"
             );
           } catch (err) {
             if (err instanceof ExtractionDeadlineError) throw err;
-            log.warn("runExtraction: failed to persist cleared retry state (non-fatal)", err);
+            log.warn("[threading] processTurn failed before persistence (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 originContext = deriveExtractionOriginContext(targetTurns, result.sourceConnector);
+        options.onBeforePersist?.();
+        throwIfDeadlineExceeded("before_persist");
+        throwIfAborted("before_persist");
+        const { persistedIds, deferredCount, pendingReviewIds } = 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 emptySuccessCommit = {
+        const runPostPersistBestEffort = runExtractionPostPersistBestEffort.bind(null, runDeadlineAware);
+        await tagPersistedMemories(storage, persistedIds, this.config);
+        const postPersist = await runExtractionPostPersist({
+          result,
           storage,
-          extractionFingerprint,
+          extractionFingerprint: extractionFingerprint ?? void 0,
           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,
+          isDeadlineError: (error) => error instanceof ExtractionDeadlineError,
+          createDeadlineError: (stage) => new ExtractionDeadlineError(stage),
+          deadlineMs,
+          clearBufferAfterExtraction,
+          runPostPersistBestEffort,
+          extractionJudgeShadow: this.config.extractionJudgeShadow,
+          deferredCount,
+          normalizedTurns,
           bufferKey,
-          isLiveSession: clearBufferAfterExtraction
+          retainDeferredTurns: (key, retainedTurns, max) => this.deps.getBuffer().retainDeferredTurns(key, retainedTurns, max, options.retentionWindow ?? turns),
+          clearBuffer,
+          failOnExtractionFailure: options.failOnExtractionFailure === true
         });
-        if (recordedRetryFailure) {
-          log.debug("runExtraction: retaining buffer for backoff retry after failure");
-        } else {
-          await clearBuffer();
+        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, pendingReviewIds)
+          );
         }
-        if (!shouldPersistProcessedFingerprint) {
-          await commitEmptySuccessExtraction(emptySuccessCommit);
+        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)
+          );
         }
-        return emptyExtractionResult(recordedRetryFailure, result.extractionFailureClass);
-      }
-      let threadIdForExtraction = null;
-      if (resolvePresentationCapabilities(this.config).threading && turns.length > 0) {
-        const lastTurn = turns[turns.length - 1];
+        const nonZeroExtraction = durableOutputCount > 0;
         try {
-          threadIdForExtraction = await runDeadlineAware(
-            () => this.deps.getThreading().processTurn(lastTurn, []),
-            "during_threading"
-          );
+          this.deps.maybeScheduleConsolidation(nonZeroExtraction);
         } catch (err) {
-          if (err instanceof ExtractionDeadlineError) throw err;
-          log.warn("[threading] processTurn failed before persistence (non-fatal)", 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);
         }
-      }
-      const originContext = deriveExtractionOriginContext(targetTurns, result.sourceConnector);
-      options.onBeforePersist?.();
-      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,
-        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, options.retentionWindow ?? turns),
-        clearBuffer,
-        failOnExtractionFailure: options.failOnExtractionFailure === true
-      });
-      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)
+          "during_tier_migration",
+          () => this.deps.runTierMigrationCycle(storage, "extraction")
         );
+        return {
+          status: "completed",
+          persistedCount: persistedIds.length,
+          durableOutputCount,
+          postPersistMetadataFailed
+        };
+      } finally {
+        clearExtractionDeadlineTimer();
       }
-      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();
+      if (extractionProbeOwned) this.providerBreaker.releaseProbe(extractionProbeToken);
     }
   }
 };
@@ -1083,4 +1145,4 @@ export {
   ExtractionDeadlineError,
   ExtractionRunCoordinator
 };
-//# sourceMappingURL=chunk-6D3IWYNY.js.map
+//# sourceMappingURL=chunk-R2BIVU2Z.js.map