@remnic/core 10.0.70 → 10.0.71

package/dist/{chunk-OAQO5AZJ.js → chunk-DSSTOV5M.js}

@@ -7,16 +7,16 @@ import {
   syncWearableSource,
   wearableSourceLabel
 } from "./chunk-5QV6CE6K.js";
+import {
+  CompressionGuidelineCoordinator
+} from "./chunk-5PHOU5QI.js";
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-ZYEWTVNQ.js";
+} from "./chunk-XPZM7GP6.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
-import {
-  CompressionGuidelineCoordinator
-} from "./chunk-5PHOU5QI.js";
 import {
   migrateFromEngram
 } from "./chunk-VZAKYDMJ.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-XR4QR3JT.js";
+} from "./chunk-LYOCAUI6.js";
 import {
   SharedContextManager
 } from "./chunk-5KBIOI4G.js";
@@ -176,10 +176,10 @@ import {
   classifyDrainResult,
   extractionWindowBudgetChars,
   mergeDrainResults
-} from "./chunk-VA3GNAWQ.js";
+} from "./chunk-LZIOY7ZU.js";
 import {
   ExtractionEngine
-} from "./chunk-UJ2FP2RV.js";
+} from "./chunk-KY3KJUNN.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-JHU4EYDV.js";
@@ -210,7 +210,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-2BBMCMJS.js";
+} from "./chunk-YPYSC3TX.js";
 import {
   planEpisodeWindowsWithFallback
 } from "./chunk-T3GIETKV.js";
@@ -225,7 +225,7 @@ import {
 } from "./chunk-7G5NTS7F.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-TSZP7GGJ.js";
+} from "./chunk-FGGLVCHI.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
@@ -234,7 +234,7 @@ import {
   runTimelinePublishCli,
   screenCandidateFact,
   summarizeVaultPublish
-} from "./chunk-OAKOAOEG.js";
+} from "./chunk-QUPTDKSX.js";
 import {
   RoutingRulesStore
 } from "./chunk-TBUEE7XF.js";
@@ -244,14 +244,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-ZS5LREUZ.js";
+} from "./chunk-DC3DWF2M.js";
 import {
   ThreadingManager
 } from "./chunk-VHSQU3RO.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-EIZ4MK33.js";
+} from "./chunk-BTU77RB5.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-B2NXOVZN.js";
@@ -264,10 +264,10 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-MKMIY3E7.js";
+} from "./chunk-UE5JYPU6.js";
 import {
   planNamespaceMaintenance
-} from "./chunk-MCFI6G7U.js";
+} from "./chunk-QVZZE6VH.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -296,7 +296,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-MK7HXGM6.js";
+} from "./chunk-6KBCUIZP.js";
 import {
   semanticChunkContent
 } from "./chunk-2GBFKHBZ.js";
@@ -305,7 +305,7 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   SmartBuffer
-} from "./chunk-VDYRXI3E.js";
+} from "./chunk-EGKDONTC.js";
 import {
   BootstrapEngine
 } from "./chunk-MYVPLJOO.js";
@@ -373,7 +373,7 @@ import {
 } from "./chunk-MI2OTWV5.js";
 import {
   MeetingsInputError
-} from "./chunk-64U42JL5.js";
+} from "./chunk-LHMCZ6VW.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -391,7 +391,7 @@ import {
 } from "./chunk-HQPFACXO.js";
 import {
   NamespaceCatalog
-} from "./chunk-3F7N4I5I.js";
+} from "./chunk-2R44BBPK.js";
 import {
   RecallResultFormatter,
   SessionContextCoordinator,
@@ -400,7 +400,7 @@ import {
   detectPassiveCorrections,
   renderSessionExperiencePreview,
   scoreSessionExperienceForPrompt
-} from "./chunk-B7YAIHAV.js";
+} from "./chunk-23BA3USG.js";
 import {
   importCapsule
 } from "./chunk-2R7OCBRR.js";
@@ -439,7 +439,7 @@ import {
 } from "./chunk-WGRAB3KB.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-MRN2MKB7.js";
+} from "./chunk-JY4LXMZR.js";
 import {
   ProfilingCollector
 } from "./chunk-DOWACHYO.js";
@@ -465,7 +465,7 @@ import {
 } from "./chunk-LXATZLSC.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-D3AGBN6G.js";
+} from "./chunk-UAOJVQXC.js";
 import {
   GraphIndex
 } from "./chunk-BFBS7OFQ.js";
@@ -475,8 +475,9 @@ import {
 import {
   ExtractionDeadlineError,
   ExtractionRunCoordinator,
+  ProviderCircuitBreaker,
   classifyExtractionOrigin
-} from "./chunk-LTST4R7U.js";
+} from "./chunk-DE4U5PTV.js";
 import {
   ARTIFACT_STATUS_CACHE_TTL_MS,
   BulkImportBatchPartialFailureError,
@@ -528,7 +529,7 @@ import {
 } from "./chunk-5RW247F5.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-GMSRLDVR.js";
+} from "./chunk-N2Y6COEM.js";
 import {
   capStateViewPackets,
   reconcileStateViewPairs,
@@ -566,7 +567,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-ILD7N3XC.js";
+} from "./chunk-S73ZVU37.js";
 import {
   buildRetiredFactTombstoneInputs
 } from "./chunk-QGVCFVX6.js";
@@ -671,7 +672,7 @@ import {
   bufferTurnsEqual,
   describeError,
   groupTurnsByExtractionScope
-} from "./chunk-U7MIMS2Y.js";
+} from "./chunk-OUBEJWVI.js";
 import {
   FallbackLlmClient,
   gatewayTaskChainOptions
@@ -1090,6 +1091,13 @@ var ExtractionQueueCoordinator = class {
   accepting = true;
   /** Buffer keys with a task currently running (per-key exclusion). */
   activeKeys = /* @__PURE__ */ new Set();
+  /**
+   * Buffer keys with a claim DECISION in flight (daemon backlog scheduler).
+   * A reservation is taken synchronously BEFORE the async claim/decision so
+   * no queued task for the key can start past the gate while the decision is
+   * unsettled; selection skips reserved keys until release.
+   */
+  reservedKeys = /* @__PURE__ */ new Set();
   /** Preempt slots of the currently running tasks, keyed by slot identity. */
   preemptSlots = /* @__PURE__ */ new Map();
   preemptSeq = 0;
@@ -1135,6 +1143,40 @@ var ExtractionQueueCoordinator = class {
     }
     return true;
   }
+  /**
+   * Synchronously reserve `key` so no task for it starts until the key's
+   * owner (the backlog scheduler's claim decision) settles and releases.
+   * Returns false when the key is active, queued, or already reserved —
+   * single-threaded JS makes this check+add atomic.
+   */
+  tryReserveKey(key) {
+    if (this.activeKeys.has(key) || this.reservedKeys.has(key)) return false;
+    if (this.queue.some((entry) => entry.key === key)) return false;
+    this.reservedKeys.add(key);
+    if (!this.processing && this.queue.length > 0) {
+      this.processing = true;
+      this.processQueue().catch((err) => {
+        this.logExtractionQueueFailure(err, "processor");
+        this.processing = false;
+      });
+    }
+    return true;
+  }
+  /** Settle a reservation: the key's decision is made and enqueued work (if
+   * any) now carries the key authority itself. Idempotent; wakes a parked
+   * processor waiting only on this release. */
+  releaseKeyReservation(key) {
+    if (!this.reservedKeys.delete(key)) return;
+    if (this.queue.length > 0 && !this.processing) {
+      this.processing = true;
+      this.processQueue().catch((err) => {
+        this.logExtractionQueueFailure(err, "processor");
+        this.processing = false;
+      });
+    } else {
+      this.wake?.();
+    }
+  }
   preemptRunning(preferredKey) {
     const armed = Array.from(this.preemptSlots.values()).filter((slot) => slot.armed !== void 0);
     if (armed.length === 0) return;
@@ -1201,11 +1243,11 @@ var ExtractionQueueCoordinator = class {
       this.processing = false;
     }
   }
-  /** Take the next queue entry whose key is not already running (FIFO within a key). */
+  /** Take the next queue entry whose key is not already running or reserved (FIFO within a key). */
   takeRunnable() {
     for (let index = 0; index < this.queue.length; index += 1) {
       const entry = this.queue[index];
-      if (entry.key !== void 0 && this.activeKeys.has(entry.key)) continue;
+      if (entry.key !== void 0 && (this.activeKeys.has(entry.key) || this.reservedKeys.has(entry.key))) continue;
       this.queue.splice(index, 1);
       if (entry.key !== void 0) this.activeKeys.add(entry.key);
       return entry;
@@ -15995,17 +16037,7 @@ function chunkFingerprint(chunk) {
   return hash.digest("hex");
 }
 var ExtractionDrain = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  /**
-   * Consecutive failed attempts on the head chunk, per buffer key. In memory on
-   * purpose (a restart re-counts from zero). Bound to the chunk's content: a
-   * count recorded for one chunk never applies to a different one, so a force
-   * flush that clears a failing chunk cannot make unrelated content inherit its
-   * failures.
-   */
+  /** Consecutive failed attempts on the head chunk, per buffer key. In memory on */
   failures = /* @__PURE__ */ new Map();
   /**
    * Buffer key to the first turn of the chunk a qualified window stopped on.
@@ -16015,6 +16047,13 @@ var ExtractionDrain = class {
    * window drains; one entry per key.
    */
   qualified = /* @__PURE__ */ new Map();
+  /** The claim drain runs with `dropFailedChunks: false`: a chunk that keeps */
+  dropFailedChunks;
+  deps;
+  constructor(deps, options) {
+    this.deps = deps;
+    this.dropFailedChunks = options?.dropFailedChunks !== false;
+  }
   /** Characters the coordinator would count for this window: user/assistant text, trimmed and capped per turn, context-only turns left out. */
   windowChars(turns) {
     let total = 0;
@@ -16055,17 +16094,40 @@ var ExtractionDrain = class {
    */
   async run(turns, runOptions, preemptable = false, preemptHandle) {
     const budgetChars = this.deps.extractionWindowBudgetChars?.() ?? Number.POSITIVE_INFINITY;
-    const chunkable = runOptions.clearBufferAfterExtraction && !runOptions.forceExtractionAttempt && !runOptions.failOnExtractionFailure && !turns.some((turn) => turn.acceptedCapture === true) && Number.isFinite(budgetChars) && budgetChars > 0;
-    const chunks = chunkable ? chunkExtractionWindow(turns, budgetChars) : [];
-    const resumed = chunks.length > 0 && this.qualified.get(runOptions.bufferKey) === chunkFingerprint(chunks[0].slice(0, 1));
-    if (chunks.length <= 1 && !resumed) return await this.deps.runExtraction(turns, runOptions);
-    if (!resumed) {
-      const windowUserTurns = turns.filter((turn) => turn.role === "user").length;
-      const belowChars = !runOptions.skipCharThreshold && this.windowChars(turns) < this.deps.config.extractionMinChars;
-      if (!runOptions.skipUserTurnThreshold && windowUserTurns < this.deps.config.extractionMinUserTurns || belowChars) {
-        return await this.deps.runExtraction(turns, runOptions);
-      }
+    const plan = this.chunkPlan(turns, runOptions, budgetChars);
+    if (plan.singleRun) return await this.deps.runExtraction(turns, runOptions);
+    if (!plan.resumed && this.windowBelowThreshold(turns, runOptions)) {
+      return await this.deps.runExtraction(turns, runOptions);
     }
+    return await this.runChunked(plan.chunks, runOptions, preemptable, preemptHandle);
+  }
+  /** Chunking plan for one trigger-drain window. Accepted-capture groups */
+  chunkPlan(turns, runOptions, budgetChars) {
+    const chunks = this.chunkable(runOptions, turns, budgetChars) ? this.deps.measureRenderedTurns !== void 0 ? this.chunkByRenderedSize(turns, budgetChars) : chunkExtractionWindow(turns, budgetChars) : [];
+    const resumed = chunks.length > 0 && this.qualified.get(runOptions.bufferKey) === chunkFingerprint(chunks[0].slice(0, 1));
+    return { singleRun: chunks.length <= 1 && !resumed, chunks, resumed };
+  }
+  /** Automatic chunking needs a clearable window, no fail-closed/forced
+   *  caller, and a real budget to chunk against. */
+  chunkable(runOptions, turns, budgetChars) {
+    return runOptions.clearBufferAfterExtraction && !runOptions.forceExtractionAttempt && !runOptions.failOnExtractionFailure && this.identityCleared(runOptions, turns) && Number.isFinite(budgetChars) && budgetChars > 0;
+  }
+  /** A native group clears its turns by identity (a pinned capture can sit
+   *  in front); a drop must find them the same way. */
+  identityCleared(runOptions, turns) {
+    return runOptions.clearMatchingTurns === true || !turns.some((turn) => turn.acceptedCapture === true);
+  }
+  /** Eligibility (minimum user turns and characters) belongs to the whole
+   *  window: a window that never qualified keeps the single-run path, which
+   *  judges it exactly as before. */
+  windowBelowThreshold(turns, runOptions) {
+    const windowUserTurns = turns.filter((turn) => turn.role === "user").length;
+    const belowChars = !runOptions.skipCharThreshold && this.windowChars(turns) < this.deps.config.extractionMinChars;
+    return !runOptions.skipUserTurnThreshold && windowUserTurns < this.deps.config.extractionMinUserTurns || belowChars;
+  }
+  /** The window qualified as a whole; its chunks must not be re-judged one by
+   *  one (an assistant-only or short chunk would be cleared unextracted). */
+  async runChunked(chunks, runOptions, preemptable, preemptHandle) {
     const baseOptions = { ...runOptions, skipCharThreshold: true, skipUserTurnThreshold: true };
     const bufferKey = runOptions.bufferKey;
     const byIdentity = runOptions.clearMatchingTurns === true;
@@ -16073,81 +16135,148 @@ var ExtractionDrain = class {
     let aggregate = null;
     for (const [position, chunk] of chunks.entries()) {
       this.qualified.set(bufferKey, chunkFingerprint(chunk.slice(0, 1)));
-      let chunkOptions = { ...baseOptions, retentionWindow: chunks.slice(0, position + 1).flat() };
-      let preempt;
-      if (preemptable && position > 0) {
-        const local = new AbortController();
-        preempt = local;
-        preemptHandle?.arm(() => local.abort(preemptedExtractionError()));
-        chunkOptions = {
-          ...chunkOptions,
-          abortSignal: runOptions.abortSignal ? AbortSignal.any([runOptions.abortSignal, local.signal]) : local.signal
-        };
-      }
-      let failures = this.failureCount(bufferKey, chunk);
+      const { options: chunkOptions, preempt } = this.chunkOptionsFor(
+        chunks,
+        position,
+        baseOptions,
+        runOptions,
+        preemptable,
+        preemptHandle
+      );
+      const failures = this.failureCount(bufferKey, chunk);
       let result;
       try {
         result = await this.deps.runExtraction(chunk, chunkOptions);
       } catch (err) {
-        if (isAbortError(err)) throw preempt && preempt.signal.aborted && !runOptions.abortSignal?.aborted ? preempt.signal.reason : err;
-        failures += 1;
-        if (failures < dropAfter) {
-          this.setFailureCount(bufferKey, chunk, failures);
-          throw err;
-        }
-        const thrown = {
-          status: "skipped",
-          reason: `thrown: ${describeError(err)}`,
-          persistedCount: 0,
-          durableOutputCount: 0
-        };
-        if (!await this.dropFailedChunk(bufferKey, chunk, dropAfter, thrown, byIdentity)) {
-          this.setFailureCount(bufferKey, chunk, failures);
-          throw err;
-        }
-        this.setFailureCount(bufferKey, chunk, 0);
+        this.rethrowChunkAbort(err, preempt, runOptions.abortSignal?.aborted === true);
+        aggregate = await this.settleThrownChunk(bufferKey, chunk, failures, dropAfter, err, byIdentity, aggregate);
         continue;
       }
-      const verdict = classifyDrainResult(result);
-      if (verdict === "drained") {
-        this.setFailureCount(bufferKey, chunk, 0);
-        aggregate = mergeDrainResults(aggregate, result);
+      const settled = this.settleVerdict(bufferKey, chunk, result, aggregate);
+      if (settled.action === "continue") {
+        aggregate = settled.result;
         continue;
       }
-      if (verdict === "deferred") return mergeDrainResults(aggregate, result);
-      if (result.failureClass === "provider_retryable" || result.failureClass === "auth_config") {
-        return mergeDrainResults(aggregate, result);
-      }
-      failures += 1;
-      if (failures >= dropAfter) {
-        if (!await this.dropFailedChunk(bufferKey, chunk, dropAfter, result, byIdentity)) {
-          this.setFailureCount(bufferKey, chunk, failures);
-          return mergeDrainResults(aggregate, result);
-        }
-        this.setFailureCount(bufferKey, chunk, 0);
-        aggregate = mergeDrainResults(aggregate, result);
+      if (settled.action === "return") return settled.result;
+      const failed = await this.settleFailedChunk({
+        bufferKey,
+        chunk,
+        failures,
+        dropAfter,
+        result: settled.result,
+        byIdentity,
+        aggregate: settled.aggregate
+      });
+      if (failed.action === "continue") {
+        aggregate = failed.result;
         continue;
       }
-      this.setFailureCount(bufferKey, chunk, failures);
-      return mergeDrainResults(aggregate, result);
+      return failed.result;
     }
     this.qualified.delete(bufferKey);
     return aggregate ?? { status: "skipped", persistedCount: 0, durableOutputCount: 0 };
   }
+  /** retention replaces theirs (retained turns do not pile up across chunks) */
+  chunkOptionsFor(chunks, position, baseOptions, runOptions, preemptable, preemptHandle) {
+    let options = { ...baseOptions, retentionWindow: chunks.slice(0, position + 1).flat() };
+    let preempt;
+    if (preemptable && position > 0) {
+      preempt = this.armChunkPreempt(preemptHandle);
+      options = {
+        ...options,
+        abortSignal: runOptions.abortSignal ? AbortSignal.any([runOptions.abortSignal, preempt.signal]) : preempt.signal
+      };
+    }
+    return { options, preempt };
+  }
+  /** A chunk-local abort controller so a fail-closed flush can abort the
+   *  next chunk instead of waiting behind the whole window. */
+  armChunkPreempt(preemptHandle) {
+    const local = new AbortController();
+    preemptHandle?.arm(() => local.abort(preemptedExtractionError()));
+    return local;
+  }
+  /** An abort error is rethrown (the chunk-local abort leaves the outer
+   *  signal untouched, so the host gets the preemption reason it looks for,
+   *  as it does for the first chunk). */
+  rethrowChunkAbort(cause, preempt, outerAborted) {
+    if (!isAbortError(cause)) return;
+    throw preempt && preempt.signal.aborted && !outerAborted ? preempt.signal.reason : cause;
+  }
+  /** A chunk whose extraction THREW: count the failure; below the drop
+   *  threshold (or on a no-drop drain) rethrow so the window is retained;
+   *  at the threshold a chunk that keeps throwing is dropped like one that
+   *  keeps failing, so later chunks are not stuck behind it. */
+  async settleThrownChunk(bufferKey, chunk, failures, dropAfter, cause, byIdentity, aggregate) {
+    failures += 1;
+    if (failures < dropAfter || !this.dropFailedChunks) {
+      this.setFailureCount(bufferKey, chunk, failures);
+      throw cause;
+    }
+    const thrown = {
+      status: "skipped",
+      reason: `thrown: ${describeError(cause)}`,
+      persistedCount: 0,
+      durableOutputCount: 0
+    };
+    if (!await this.dropFailedChunk(bufferKey, chunk, dropAfter, thrown, byIdentity)) {
+      this.setFailureCount(bufferKey, chunk, failures);
+      throw cause;
+    }
+    this.setFailureCount(bufferKey, chunk, 0);
+    return mergeDrainResults(aggregate, thrown);
+  }
+  /** Map one chunk result to the drain-loop action: drained chunks continue
+   *  to the next chunk; breaker/backoff retention and provider faults keep
+   *  everything for retry without counting a chunk failure. */
+  settleVerdict(bufferKey, chunk, result, aggregate) {
+    const verdict = classifyDrainResult(result);
+    if (verdict === "drained") {
+      this.setFailureCount(bufferKey, chunk, 0);
+      return { action: "continue", result: mergeDrainResults(aggregate, result), aggregate };
+    }
+    if (verdict === "deferred") return { action: "return", result: mergeDrainResults(aggregate, result), aggregate };
+    if (result.failureClass === "provider_retryable" || result.failureClass === "auth_config") {
+      return { action: "return", result: mergeDrainResults(aggregate, result), aggregate };
+    }
+    return { action: "failed", result, aggregate };
+  }
+  /** (live drains, recovery copy first) or keep it as durable retryable */
+  async settleFailedChunk(args) {
+    const failures = args.failures + 1;
+    if (failures >= args.dropAfter && this.dropFailedChunks) {
+      if (!await this.dropFailedChunk(args.bufferKey, args.chunk, args.dropAfter, args.result, args.byIdentity)) {
+        this.setFailureCount(args.bufferKey, args.chunk, failures);
+        return { action: "return", result: mergeDrainResults(args.aggregate, args.result) };
+      }
+      this.setFailureCount(args.bufferKey, args.chunk, 0);
+      return { action: "continue", result: mergeDrainResults(args.aggregate, args.result) };
+    }
+    this.setFailureCount(args.bufferKey, args.chunk, failures);
+    return { action: "return", result: mergeDrainResults(args.aggregate, args.result) };
+  }
+  /** Greedy chunking sized by the RENDERED conversation (the oracle the model */
+  chunkByRenderedSize(turns, budgetChars) {
+    const measure = this.deps.measureRenderedTurns;
+    const chunks = [];
+    let current = [];
+    for (const turn of turns) {
+      if (current.length > 0 && measure([...current, turn]) > budgetChars) {
+        chunks.push(current);
+        current = [];
+      }
+      current.push(turn);
+    }
+    if (current.length > 0) chunks.push(current);
+    return chunks;
+  }
   /** Side-file copy first (content survives a failed drop), then remove the failing chunk from the buffer. Never throws:
    *  the drop must not fail the extraction task that already settled its result. */
   async dropFailedChunk(bufferKey, chunk, dropAfter, result, byIdentity) {
     const reason = `dropped after ${dropAfter} repeated extraction failures (last result: status=${result.status} reason=${result.reason ?? "n/a"})`;
-    try {
-      const storage = await this.deps.getStorage();
-      const path42 = await storage.saveDroppedExtractionChunk(bufferKey, reason, chunk);
-      log.warn(`buffer[${bufferKey}]: dropping ${chunk.length} turns \u2014 ${reason}; copy saved to ${path42}`);
-    } catch (err) {
-      log.warn(
-        `buffer[${bufferKey}]: could not save the dropped-chunk recovery copy; keeping the chunk in the buffer: ${describeError(err)}`
-      );
-      return false;
-    }
+    const copyPath = await this.saveRecoveryCopy(bufferKey, reason, chunk);
+    if (copyPath === null) return false;
+    log.warn(`buffer[${bufferKey}]: dropping ${chunk.length} turns \u2014 ${reason}; copy saved to ${copyPath}`);
     try {
       const dropped = await this.deps.buffer.dropExtractionChunk(bufferKey, chunk, { allowNonPrefix: byIdentity });
       if (dropped > 0) {
@@ -16162,6 +16291,19 @@ var ExtractionDrain = class {
     }
     return false;
   }
+  /** The recovery side-file copy for a dropped chunk. null = the copy could
+   *  not be written — the caller must keep the only buffered copy. */
+  async saveRecoveryCopy(bufferKey, reason, chunk) {
+    try {
+      const storage = await this.deps.getStorage();
+      return await storage.saveDroppedExtractionChunk(bufferKey, reason, chunk);
+    } catch (err) {
+      log.warn(
+        `buffer[${bufferKey}]: could not save the dropped-chunk recovery copy; keeping the chunk in the buffer: ${describeError(err)}`
+      );
+      return null;
+    }
+  }
 };
 
 // src/orchestration/buffer-drain-gate.ts
@@ -16177,6 +16319,39 @@ function skipClaimedSession(buffer, bufferKey, settle) {
   return true;
 }
 
+// src/orchestration/extraction-task-queueing.ts
+function queueBufferedCaptureScopeGroups(queueBufferedExtraction, extractionTurns, bufferKey, options) {
+  for (const group of groupTurnsByExtractionScope(extractionTurns)) {
+    const groupIsAccepted = group.turns.some((turn) => turn.acceptedCapture === true);
+    if (!groupIsAccepted) {
+      void queueBufferedExtraction(group.turns, "trigger_mode", {
+        bufferKey,
+        clearMatchingTurns: true,
+        preemptable: true
+      }).catch((err) => log.error(`native trigger extraction failed: ${err}`));
+      continue;
+    }
+    const { promise: extraction, resolve, reject } = Promise.withResolvers();
+    void queueBufferedExtraction(group.turns, "trigger_mode", {
+      bufferKey,
+      clearBufferAfterExtraction: true,
+      clearMatchingTurns: true,
+      skipDedupeCheck: true,
+      skipCharThreshold: true,
+      skipUserTurnThreshold: true,
+      abortSignal: options.abortSignal,
+      extractionDeadlineMs: options.deadlineMs,
+      writeNamespaceOverride: group.writeNamespaceOverride,
+      principalOverride: group.principalOverride,
+      scopeProfileWritePlan: group.scopeProfileWritePlan ?? null,
+      preemptable: true,
+      onTaskSettled: (err) => err ? reject(err) : resolve()
+    }).catch(reject);
+    if (options.onExtractionQueued) options.onExtractionQueued(extraction);
+    else extraction.catch((err) => log.error(`buffered capture extraction failed: ${err}`));
+  }
+}
+
 // src/orchestration/turn-ingestion.ts
 var ReplayAdmissionRefusedError = class extends Error {
   constructor(message) {
@@ -16228,7 +16403,7 @@ var TurnIngestionCoordinator = class {
     if (outcome.decision === "keep_buffering") return;
     if (!outcome.extractionTurns) return;
     if (outcome.extractionTurns.some((turn2) => turn2.acceptedCapture === true)) {
-      this.queueBufferedCaptureScopeGroups(outcome.extractionTurns, bufferKey, {});
+      queueBufferedCaptureScopeGroups(this.deps.queueBufferedExtraction, outcome.extractionTurns, bufferKey, {});
       return;
     }
     await this.deps.queueBufferedExtraction(
@@ -16364,48 +16539,17 @@ var TurnIngestionCoordinator = class {
           );
         }
         if (outcome.decision !== "keep_buffering" && outcome.extractionTurns) {
-          this.queueBufferedCaptureScopeGroups(outcome.extractionTurns, bufferKey, options);
+          queueBufferedCaptureScopeGroups(
+            this.deps.queueBufferedExtraction,
+            outcome.extractionTurns,
+            bufferKey,
+            options
+          );
         }
       }
       await this.deps.buffer.flushPendingSave({ throwOnFailure: true });
     }
   }
-  /**
-   * Buffer-approved captures skip threshold/dedupe rechecks, not provider retry cooldowns.
-   * Scope and staleness are enforced at the shared queueBufferedExtraction boundary.
-   */
-  queueBufferedCaptureScopeGroups(extractionTurns, bufferKey, options) {
-    for (const group of groupTurnsByExtractionScope(extractionTurns)) {
-      const groupIsAccepted = group.turns.some((turn) => turn.acceptedCapture === true);
-      if (!groupIsAccepted) {
-        void this.deps.queueBufferedExtraction(group.turns, "trigger_mode", {
-          bufferKey,
-          clearMatchingTurns: true,
-          preemptable: true
-        }).catch((err) => log.error(`native trigger extraction failed: ${err}`));
-        continue;
-      }
-      const extraction = new Promise((resolve, reject) => {
-        void this.deps.queueBufferedExtraction(group.turns, "trigger_mode", {
-          bufferKey,
-          clearBufferAfterExtraction: true,
-          clearMatchingTurns: true,
-          skipDedupeCheck: true,
-          skipCharThreshold: true,
-          skipUserTurnThreshold: true,
-          abortSignal: options.abortSignal,
-          extractionDeadlineMs: options.deadlineMs,
-          writeNamespaceOverride: group.writeNamespaceOverride,
-          principalOverride: group.principalOverride,
-          scopeProfileWritePlan: group.scopeProfileWritePlan ?? null,
-          preemptable: true,
-          onTaskSettled: (err) => err ? reject(err) : resolve()
-        }).catch(reject);
-      });
-      if (options.onExtractionQueued) options.onExtractionQueued(extraction);
-      else extraction.catch((err) => log.error(`buffered capture extraction failed: ${err}`));
-    }
-  }
   /**
    * Ingest a batch of bulk-import turns (#460). Like ingestReplayBatch, this
    * normalizes user/assistant turns into the extraction buffer and awaits
@@ -16625,7 +16769,7 @@ var TurnIngestionCoordinator = class {
         `heartbeat observer trigger: session=${sessionKey} deltaBytes=${decision.deltaBytes} deltaTokens=${decision.deltaTokens}`
       );
       if (turns.some((turn) => turn.acceptedCapture === true)) {
-        this.queueBufferedCaptureScopeGroups(turns, bufferKey, {});
+        queueBufferedCaptureScopeGroups(this.deps.queueBufferedExtraction, turns, bufferKey, {});
         return;
       }
       await this.deps.queueBufferedExtraction(turns, "heartbeat_observer", {
@@ -16644,7 +16788,7 @@ var TurnIngestionCoordinator = class {
   }
   async queueBufferedExtraction(turnsToExtract, reason, options = {}) {
     const bufferKey = options.bufferKey ?? turnsToExtract[0]?.sessionKey ?? "default";
-    if (skipClaimedSession(this.deps.buffer, bufferKey, (result) => options.onTaskSettled?.(void 0, result))) return;
+    if (skipClaimedSession(options.execution?.buffer ?? this.deps.buffer, bufferKey, (result) => options.onTaskSettled?.(void 0, result))) return;
     if (!options.skipDedupeCheck && !this.deps.shouldQueueExtraction(turnsToExtract, { bufferKey })) {
       log.debug(`extraction dedupe skip: preserving buffer (${reason})`);
       options.onTaskSettled?.(void 0, {
@@ -16710,132 +16854,139 @@ var TurnIngestionCoordinator = class {
     if (settled) return;
     const preemptable = options.preemptable === true && options.preemptRunning !== true;
     const accepted = this.deps.extractionQueueCoordinator.enqueue(async (preemptHandle) => {
-      await this.deps.extractionQueueCoordinator.runPreemptable(preemptHandle, preemptable, options.abortSignal, async (abortSignal) => {
-        if (settled) return;
-        if (typeof extractionDeadlineMs === "number" && extractionDeadlineMs <= Date.now()) {
-          settleTask(new ExtractionDeadlineError("queue_wait"));
-          return;
-        }
-        clearQueueWaitTimer();
-        try {
-          let effectiveTurns = turnsToExtract;
-          let effectiveScopePlan = options.scopeProfileWritePlan;
-          if (effectiveTurns.some((turn) => turn.acceptedCapture === true)) {
-            const liveTurns = this.deps.buffer.getTurns(bufferKey).filter((live) => effectiveTurns.some((snapshotted) => bufferTurnsEqual(live, snapshotted)));
-            if (liveTurns.length === 0) {
-              settleTask(void 0, {
-                status: "skipped",
-                reason: "already_drained",
-                persistedCount: 0,
-                durableOutputCount: 0
-              });
-              return;
-            }
-            effectiveTurns = liveTurns;
-            const namespacesOn = resolveNamespaceCapabilities(this.deps.config).namespaces === true;
-            const acceptedTurn = effectiveTurns.find((turn) => turn.acceptedCapture === true);
-            const pinnedNamespace = acceptedTurn?.writeNamespaceOverride;
-            const policySkipError = (reason2) => options.failOnExtractionFailure === true ? new Error(`accepted capture preserved: ${reason2} (${bufferKey})`) : void 0;
-            if (!namespacesOn && pinnedNamespace !== void 0 && pinnedNamespace !== this.deps.config.defaultNamespace) {
-              const err = policySkipError("pinned_namespace_unavailable");
-              if (err) {
-                settleTask(err);
-                return;
-              }
-              settleTask(void 0, {
-                status: "skipped",
-                reason: "pinned_namespace_unavailable",
-                persistedCount: 0,
-                durableOutputCount: 0
-              });
-              return;
-            }
-            const firstSessionKey = effectiveTurns[0]?.sessionKey ?? "";
-            const principal = options.principalOverride !== void 0 && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(firstSessionKey, this.deps.config);
-            if (namespacesOn && pinnedNamespace !== void 0 && !effectiveScopePlan) {
-              const originalContext = acceptedTurn?.codingContext ?? null;
-              const overlay = originalContext ? resolveCodingNamespaceOverlay(
-                originalContext,
-                this.deps.config.codingMode,
-                this.deps.config.defaultNamespace
-              ) : null;
-              const baseNamespace = defaultNamespaceForPrincipal(principal, this.deps.config);
-              const projectNamespace = overlay && this.deps.config.codingMode ? combineNamespaces(baseNamespace, overlay.namespace) : void 0;
-              const writeAuthorized = projectNamespace === pinnedNamespace ? hasExplicitNamespacePolicy(pinnedNamespace, this.deps.config) ? canWriteNamespace(principal, pinnedNamespace, this.deps.config) : canWriteNamespace(principal, baseNamespace, this.deps.config) : canWriteNamespace(principal, pinnedNamespace, this.deps.config);
-              if (!writeAuthorized) {
-                const err = policySkipError("namespace_write_revoked");
-                if (err) {
-                  settleTask(err);
-                  return;
-                }
+      try {
+        await this.deps.extractionQueueCoordinator.runPreemptable(preemptHandle, preemptable, options.abortSignal, async (abortSignal) => {
+          if (settled) return;
+          if (typeof extractionDeadlineMs === "number" && extractionDeadlineMs <= Date.now()) {
+            settleTask(new ExtractionDeadlineError("queue_wait"));
+            return;
+          }
+          clearQueueWaitTimer();
+          if (options.execution === void 0 && skipClaimedSession(this.deps.buffer, bufferKey, (result) => settleTask(void 0, result))) return;
+          try {
+            let effectiveTurns = turnsToExtract;
+            let effectiveScopePlan = options.scopeProfileWritePlan;
+            const executionBuffer = options.execution?.buffer;
+            if (effectiveTurns.some((turn) => turn.acceptedCapture === true)) {
+              const liveTurns = (executionBuffer ?? this.deps.buffer).getTurns(bufferKey).filter((live) => effectiveTurns.some((snapshotted) => bufferTurnsEqual(live, snapshotted)));
+              if (liveTurns.length === 0) {
                 settleTask(void 0, {
                   status: "skipped",
-                  reason: "namespace_write_revoked",
+                  reason: "already_drained",
                   persistedCount: 0,
                   durableOutputCount: 0
                 });
                 return;
               }
-            }
-            if (effectiveScopePlan) {
-              const originalContext = acceptedTurn?.codingContext ?? null;
-              const codingOverlay = originalContext ? resolveCodingNamespaceOverlay(
-                originalContext,
-                this.deps.config.codingMode,
-                this.deps.config.defaultNamespace
-              ) : null;
-              const fresh = resolveScopeProfilePlan({
-                config: this.deps.config,
-                principal,
-                codingContext: originalContext,
-                codingOverlay
-              });
-              const identityHolds = fresh !== null && fresh.profileId === effectiveScopePlan.profileId && fresh.writeLayer === effectiveScopePlan.writeLayer && fresh.writeNamespace === effectiveScopePlan.writeNamespace;
-              if (!identityHolds) {
-                const err = policySkipError("scope_profile_revoked");
+              effectiveTurns = liveTurns;
+              const namespacesOn = resolveNamespaceCapabilities(this.deps.config).namespaces === true;
+              const acceptedTurn = effectiveTurns.find((turn) => turn.acceptedCapture === true);
+              const pinnedNamespace = acceptedTurn?.writeNamespaceOverride;
+              const policySkipError = (reason2) => options.failOnExtractionFailure === true ? new Error(`accepted capture preserved: ${reason2} (${bufferKey})`) : void 0;
+              if (!namespacesOn && pinnedNamespace !== void 0 && pinnedNamespace !== this.deps.config.defaultNamespace) {
+                const err = policySkipError("pinned_namespace_unavailable");
                 if (err) {
                   settleTask(err);
                   return;
                 }
                 settleTask(void 0, {
                   status: "skipped",
-                  reason: "scope_profile_revoked",
+                  reason: "pinned_namespace_unavailable",
                   persistedCount: 0,
                   durableOutputCount: 0
                 });
                 return;
               }
-              effectiveScopePlan = fresh;
+              const firstSessionKey = effectiveTurns[0]?.sessionKey ?? "";
+              const principal = options.principalOverride !== void 0 && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(firstSessionKey, this.deps.config);
+              if (namespacesOn && pinnedNamespace !== void 0 && !effectiveScopePlan) {
+                const originalContext = acceptedTurn?.codingContext ?? null;
+                const overlay = originalContext ? resolveCodingNamespaceOverlay(
+                  originalContext,
+                  this.deps.config.codingMode,
+                  this.deps.config.defaultNamespace
+                ) : null;
+                const baseNamespace = defaultNamespaceForPrincipal(principal, this.deps.config);
+                const projectNamespace = overlay && this.deps.config.codingMode ? combineNamespaces(baseNamespace, overlay.namespace) : void 0;
+                const writeAuthorized = projectNamespace === pinnedNamespace ? hasExplicitNamespacePolicy(pinnedNamespace, this.deps.config) ? canWriteNamespace(principal, pinnedNamespace, this.deps.config) : canWriteNamespace(principal, baseNamespace, this.deps.config) : canWriteNamespace(principal, pinnedNamespace, this.deps.config);
+                if (!writeAuthorized) {
+                  const err = policySkipError("namespace_write_revoked");
+                  if (err) {
+                    settleTask(err);
+                    return;
+                  }
+                  settleTask(void 0, {
+                    status: "skipped",
+                    reason: "namespace_write_revoked",
+                    persistedCount: 0,
+                    durableOutputCount: 0
+                  });
+                  return;
+                }
+              }
+              if (effectiveScopePlan) {
+                const originalContext = acceptedTurn?.codingContext ?? null;
+                const codingOverlay = originalContext ? resolveCodingNamespaceOverlay(
+                  originalContext,
+                  this.deps.config.codingMode,
+                  this.deps.config.defaultNamespace
+                ) : null;
+                const fresh = resolveScopeProfilePlan({
+                  config: this.deps.config,
+                  principal,
+                  codingContext: originalContext,
+                  codingOverlay
+                });
+                const identityHolds = fresh !== null && fresh.profileId === effectiveScopePlan.profileId && fresh.writeLayer === effectiveScopePlan.writeLayer && fresh.writeNamespace === effectiveScopePlan.writeNamespace;
+                if (!identityHolds) {
+                  const err = policySkipError("scope_profile_revoked");
+                  if (err) {
+                    settleTask(err);
+                    return;
+                  }
+                  settleTask(void 0, {
+                    status: "skipped",
+                    reason: "scope_profile_revoked",
+                    persistedCount: 0,
+                    durableOutputCount: 0
+                  });
+                  return;
+                }
+                effectiveScopePlan = fresh;
+              }
+            }
+            const result = await (options.execution?.drain ?? this.drain).run(effectiveTurns, {
+              clearBufferAfterExtraction: options.clearBufferAfterExtraction ?? true,
+              clearMatchingTurns: options.clearMatchingTurns === true,
+              skipCharThreshold: options.skipCharThreshold ?? false,
+              skipUserTurnThreshold: options.skipUserTurnThreshold ?? false,
+              deadlineMs: extractionDeadlineMs,
+              bufferKey,
+              onDurableCommit: options.onDurableCommit,
+              onBeforePersist: () => preemptHandle?.disarm(),
+              abortSignal,
+              failOnExtractionFailure: options.failOnExtractionFailure === true,
+              writeNamespaceOverride: options.writeNamespaceOverride,
+              principalOverride: options.principalOverride,
+              scopeProfileWritePlan: effectiveScopePlan,
+              forceExtractionAttempt: options.forceExtractionAttempt === true
+            }, preemptable, preemptHandle);
+            settleTask(void 0, result);
+          } catch (err) {
+            const reason2 = abortSignal.reason;
+            const settledError = reason2 instanceof Error && isPreemptedExtraction(reason2) ? reason2 : err;
+            if (settleTask(settledError)) {
+              throw settledError;
             }
           }
-          const result = await this.drain.run(effectiveTurns, {
-            clearBufferAfterExtraction: options.clearBufferAfterExtraction ?? true,
-            clearMatchingTurns: options.clearMatchingTurns === true,
-            skipCharThreshold: options.skipCharThreshold ?? false,
-            skipUserTurnThreshold: options.skipUserTurnThreshold ?? false,
-            deadlineMs: extractionDeadlineMs,
-            bufferKey,
-            onDurableCommit: options.onDurableCommit,
-            onBeforePersist: () => preemptHandle?.disarm(),
-            abortSignal,
-            failOnExtractionFailure: options.failOnExtractionFailure === true,
-            writeNamespaceOverride: options.writeNamespaceOverride,
-            principalOverride: options.principalOverride,
-            scopeProfileWritePlan: effectiveScopePlan,
-            forceExtractionAttempt: options.forceExtractionAttempt === true
-          }, preemptable, preemptHandle);
-          settleTask(void 0, result);
-        } catch (err) {
-          const reason2 = abortSignal.reason;
-          const settledError = reason2 instanceof Error && isPreemptedExtraction(reason2) ? reason2 : err;
-          if (settleTask(settledError)) {
-            throw settledError;
-          }
-        }
-      });
+        });
+      } finally {
+        options.onTaskExit?.();
+      }
     }, { front: options.preemptRunning === true, key: bufferKey });
     if (!accepted) {
       settleTask(new Error("extraction queue is stopped"));
+      options.onTaskExit?.();
       return;
     }
     log.debug(`queued extraction from ${reason}`);
@@ -22275,29 +22426,50 @@ var Orchestrator = class {
   }
   extractionQueueCoordinator;
   _extractionRunCoordinator;
+  _providerBreaker;
+  /** One breaker per orchestrator: foreground and every isolated claim-backed
+   *  drain accumulate toward the same threshold and honor each other's open
+   *  state (review round — isolated coordinators must not reset
+   *  provider resilience). */
+  get providerBreaker() {
+    if (!this._providerBreaker) this._providerBreaker = new ProviderCircuitBreaker();
+    return this._providerBreaker;
+  }
+  /** The run-coordinator deps bundle, parameterized by its buffer accessor so
+   * an isolated claim-backed drain can bind its own SmartBuffer (the daemon
+   * backlog scheduler) while live extraction keeps `this.buffer`. */
+  extractionRunDeps(getBuffer) {
+    return {
+      config: this.config,
+      getBuffer,
+      providerBreaker: this.providerBreaker,
+      getExtraction: () => this.extraction,
+      getStorageRouter: () => this.storageRouter,
+      getThreading: () => this.threading,
+      persistExtraction: (result, storage, threadId, sourceContext, baseNamespace, scopeProfileWritePlan, sourceText, graphCaps, lifecycleCaps) => this.persistExtraction(result, storage, threadId, sourceContext, baseNamespace, scopeProfileWritePlan, sourceText, graphCaps, lifecycleCaps),
+      maybeCapturePassiveCorrections: (turns, opts) => this.maybeCapturePassiveCorrections(turns, opts),
+      resolveSelfNamespace: (sessionKey) => this.resolveSelfNamespace(sessionKey),
+      getCodingContextForSession: (sessionKey) => this.getCodingContextForSession(sessionKey),
+      applyCodingNamespaceOverlay: (sessionKey, namespace) => this.applyCodingNamespaceOverlay(sessionKey, namespace),
+      boxBuilderFor: (storage) => this.boxBuilderFor(storage),
+      appendPersistedThreadEpisodes: (threadId, ids, pendingReviewIds) => this.appendPersistedThreadEpisodes(threadId, ids, pendingReviewIds),
+      maybeScheduleConsolidation: (nonZero) => this.maybeScheduleConsolidation(nonZero),
+      requestQmdMaintenance: () => this.requestQmdMaintenance(),
+      runTierMigrationCycle: (storage, trigger, options) => this.runTierMigrationCycle(storage, trigger, options),
+      recordProcessedExtractionFingerprint: (storage, fingerprint, preloadedMeta) => this.recordProcessedExtractionFingerprint(storage, fingerprint, preloadedMeta)
+    };
+  }
   get extractionRunCoordinator() {
     if (!this._extractionRunCoordinator) {
-      this._extractionRunCoordinator = new ExtractionRunCoordinator({
-        config: this.config,
-        getBuffer: () => this.buffer,
-        getExtraction: () => this.extraction,
-        getStorageRouter: () => this.storageRouter,
-        getThreading: () => this.threading,
-        persistExtraction: (result, storage, threadId, sourceContext, baseNamespace, scopeProfileWritePlan, sourceText, graphCaps, lifecycleCaps) => this.persistExtraction(result, storage, threadId, sourceContext, baseNamespace, scopeProfileWritePlan, sourceText, graphCaps, lifecycleCaps),
-        maybeCapturePassiveCorrections: (turns, opts) => this.maybeCapturePassiveCorrections(turns, opts),
-        resolveSelfNamespace: (sessionKey) => this.resolveSelfNamespace(sessionKey),
-        getCodingContextForSession: (sessionKey) => this.getCodingContextForSession(sessionKey),
-        applyCodingNamespaceOverlay: (sessionKey, namespace) => this.applyCodingNamespaceOverlay(sessionKey, namespace),
-        boxBuilderFor: (storage) => this.boxBuilderFor(storage),
-        appendPersistedThreadEpisodes: (threadId, ids, pendingReviewIds) => this.appendPersistedThreadEpisodes(threadId, ids, pendingReviewIds),
-        maybeScheduleConsolidation: (nonZero) => this.maybeScheduleConsolidation(nonZero),
-        requestQmdMaintenance: () => this.requestQmdMaintenance(),
-        runTierMigrationCycle: (storage, trigger, options) => this.runTierMigrationCycle(storage, trigger, options),
-        recordProcessedExtractionFingerprint: (storage, fingerprint, preloadedMeta) => this.recordProcessedExtractionFingerprint(storage, fingerprint, preloadedMeta)
-      });
+      this._extractionRunCoordinator = new ExtractionRunCoordinator(this.extractionRunDeps(() => this.buffer));
     }
     return this._extractionRunCoordinator;
   }
+  /** An extraction run coordinator bound to `buffer` — per drain task, so a
+   * claim-backed drain never shares the live buffer's mutable state. */
+  extractionRunCoordinatorForBuffer(buffer) {
+    return new ExtractionRunCoordinator(this.extractionRunDeps(() => buffer));
+  }
   _consolidationRunCoordinator;
   get consolidationRunCoordinator() {
     if (!this._consolidationRunCoordinator) {
@@ -31906,8 +32078,9 @@ export {
   mergeGraphExpandedResults,
   graphPathRelativeToStorage,
   blendGraphExpandedRecallScore,
+  ExtractionDrain,
   TurnIngestionCoordinator,
   qmdStartupCollectionChecksWithTimeout,
   Orchestrator
 };
-//# sourceMappingURL=chunk-OAQO5AZJ.js.map
+//# sourceMappingURL=chunk-DSSTOV5M.js.map