@remnic/core 10.0.74 → 10.0.76

package/dist/orchestration/backlog-scheduler.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/orchestration/backlog-scheduler.ts"],"sourcesContent":["/**\n * Daemon-owned extraction backlog scheduler.\n *\n * ONE bounded in-process loop that owns ALL persisted extraction backlog:\n * at startup (existing drain claims + buffered sessions), on every poll tick\n * (new persisted work), and by retrying keys that are still pending — with\n * bounded memory (per-key COUNTS only; candidate scans never retain turn\n * payloads) and bounded outstanding work (the extraction queue's own\n * maxConcurrency gates submissions, so live foreground work keeps its share\n * of the queue).\n *\n * Claim authority: an existing claim — including an EMPTY ack tombstone — is\n * authoritative over the live buffer's in-memory copy. A tombstoned key is\n * never re-claimed or counted as work; new ingress consumes the tombstone\n * through the native save handover, which is what makes the key a candidate\n * again. Claim creation is fenced: the key is reserved synchronously on the\n * extraction queue BEFORE the async claim decision, so a queued live task for\n * the same key cannot start past the claimed-session gate until the decision\n * settles; live capture continues via the native merge-into-claim protocol.\n *\n * Failed, deferred, or policy-denied outcomes keep their turns durable in the\n * claim and re-submit after backoff (exponential from `retryBaseMs` to\n * `retryMaxMs`, reset by progress; denials wait the full max) — never a busy\n * retry. `stop()` aborts in-flight drains at their chunk boundary and leaves\n * every claim retryable; a restarted daemon's scheduler adopts them.\n */\n\nimport { hostname } from \"node:os\";\nimport { log } from \"../logger.js\";\nimport type { Orchestrator } from \"../orchestrator.js\";\nimport type { BufferDrainClaims, DrainLease } from \"../storage/buffer-drain-claims.js\";\nimport { BufferDrainRunner } from \"./buffer-drain-runner.js\";\nimport type { DrainRunnerEvent, DrainSessionOutcome } from \"./buffer-drain-runner.js\";\nimport type { ExtractionQueueCoordinator } from \"./extraction-queue-coordinator.js\";\n\n/** What the scheduler needs from its host (structurally satisfied by the\n *  orchestrator wiring); injectable so tests drive ticks deterministically. */\nexport interface BacklogSchedulerDeps {\n  queue: Pick<ExtractionQueueCoordinator, \"tryReserveKey\" | \"releaseKeyReservation\" | \"maxConcurrency\">;\n  claims: Pick<BufferDrainClaims, \"list\" | \"listPage\" | \"claimFromSessionFile\" | \"isClaimed\">;\n  /** Live per-key pending counts (counts only — never turn payloads). May be\n   *  async: hosts with a lazily-loaded buffer load it here (idempotent). */\n  liveBufferCounts():\n    | Map<string, { turns: number; retainedTurns: number }>\n    | Promise<Map<string, { turns: number; retainedTurns: number }>>;\n  /** A fresh lease for claims this scheduler takes. */\n  lease(): DrainLease;\n  /** Drain one key to quiescence (BufferDrainRunner.drainSession). */\n  drainKey(\n    key: string,\n    options: { ownerId: string; signal: AbortSignal; onEvent?: (event: DrainRunnerEvent) => void }\n  ): Promise<DrainSessionOutcome>;\n  /** Test seam: monotonic-ish clock for backoff windows. */\n  now?(): number;\n}\n\nexport interface BacklogSchedulerOptions {\n  ownerId?: string;\n  /** Scan cadence in ms (startup + new-work + retry checks). */\n  pollMs?: number;\n  retryBaseMs?: number;\n  retryMaxMs?: number;\n  now?: () => number;\n}\n\nexport interface BacklogSchedulerCounters {\n  /** Keys submitted to the drain (claimed or adopted) this process lifetime. */\n  claimed: number;\n  /** Outcomes with genuinely empty claims (durable outputs preceded ack). */\n  processed: number;\n  /** Sum of durable outputs (memories + entities) across processed drains. */\n  durableOutputs: number;\n  /** Re-submissions after a failed/deferred/denied outcome. */\n  retried: number;\n  denied: { keys: number; turns: number };\n  failed: number;\n}\n\nexport type BacklogKeyState = \"inflight\" | \"backoff\" | \"denied\";\n\nexport interface BacklogKeySnapshot {\n  key: string;\n  state: BacklogKeyState;\n  turnsRemaining?: number;\n  reason?: string;\n}\n\nexport interface BacklogSchedulerSnapshot {\n  counters: BacklogSchedulerCounters;\n  inFlight: string[];\n  reservedKeys: string[];\n  keys: BacklogKeySnapshot[];\n}\n\ninterface KeyState {\n  state: BacklogKeyState;\n  nextAttemptMs: number;\n  /** Last observed remaining turns; progress resets the backoff exponent. */\n  turnsRemaining: number;\n  reason?: string;\n  backoffExponent: number;\n}\n\nconst DEFAULT_POLL_MS = 15_000;\nconst DEFAULT_RETRY_BASE_MS = 30_000;\nconst DEFAULT_RETRY_MAX_MS = 15 * 60_000;\n\nexport class BacklogScheduler {\n  private readonly deps: BacklogSchedulerDeps;\n  private readonly options: Required<Omit<BacklogSchedulerOptions, \"now\">> & Pick<BacklogSchedulerOptions, \"now\">;\n  private readonly keys = new Map<string, KeyState>();\n  private readonly inFlight = new Map<string, { controller: AbortController; settled: Promise<void> }>();\n  private readonly reserved = new Set<string>();\n  private readonly counters: BacklogSchedulerCounters = {\n    claimed: 0,\n    processed: 0,\n    durableOutputs: 0,\n    retried: 0,\n    denied: { keys: 0, turns: 0 },\n    failed: 0,\n  };\n  private claimCursor: string | undefined;\n  private timer: ReturnType<typeof setInterval> | undefined;\n  private ticking = false;\n  private stopped = true;\n\n  constructor(deps: BacklogSchedulerDeps, options: BacklogSchedulerOptions = {}) {\n    this.deps = deps;\n    this.options = {\n      ownerId: options.ownerId ?? `daemon-drain-${process.pid}`,\n      pollMs: options.pollMs ?? DEFAULT_POLL_MS,\n      retryBaseMs: options.retryBaseMs ?? DEFAULT_RETRY_BASE_MS,\n      retryMaxMs: options.retryMaxMs ?? DEFAULT_RETRY_MAX_MS,\n      now: options.now,\n    };\n  }\n\n  /** Idempotent. Starts the poll timer (unref'd) and runs an initial tick. */\n  start(): void {\n    if (!this.stopped) return;\n    this.stopped = false;\n    this.timer = setInterval(() => void this.tick(), this.options.pollMs);\n    this.timer.unref?.();\n    void this.tick();\n  }\n\n  /** Idempotent. Stops the timer, aborts in-flight drains (their claims stay\n   *  retryable) and waits for them to settle. */\n  async stop(): Promise<void> {\n    if (this.stopped) return;\n    this.stopped = true;\n    if (this.timer) {\n      clearInterval(this.timer);\n      this.timer = undefined;\n    }\n    const aborts: Promise<void>[] = [];\n    for (const entry of this.inFlight.values()) {\n      entry.controller.abort(new Error(\"backlog scheduler stopping\"));\n      aborts.push(entry.settled);\n    }\n    await Promise.allSettled(aborts);\n  }\n\n  /** Bounded snapshot for ops/watchers: counters + per-key states + live sets. */\n  snapshot(): BacklogSchedulerSnapshot {\n    return {\n      counters: {\n        claimed: this.counters.claimed,\n        processed: this.counters.processed,\n        durableOutputs: this.counters.durableOutputs,\n        retried: this.counters.retried,\n        denied: { ...this.counters.denied },\n        failed: this.counters.failed,\n      },\n      inFlight: [...this.inFlight.keys()],\n      reservedKeys: [...this.reserved],\n      keys: [...this.keys.entries()].map(([key, state]) => ({\n        key,\n        state: state.state,\n        turnsRemaining: state.turnsRemaining,\n        reason: state.reason,\n      })),\n    };\n  }\n\n  /** One scan+submit pass (tests drive this instead of the timer). Waits out\n   *  any in-progress tick first so the pass always actually scans. */\n  async tickForTest(): Promise<void> {\n    // setImmediate: yields to the event loop so pending I/O (a slow first\n    // scan) can finish; a microtask spin would starve it.\n    while (this.ticking) await new Promise((resolve) => setImmediate(resolve));\n    await this.tick();\n  }\n\n  /** Await the settle (slot release) of everything currently in flight,\n   *  optionally excluding one still-gated key (tests). */\n  async settleForTest(exclude?: string): Promise<void> {\n    for (;;) {\n      const pending = [...this.inFlight.entries()].filter(([key]) => key !== exclude).map(([, entry]) => entry.settled);\n      if (pending.length === 0) return;\n      await Promise.allSettled(pending);\n    }\n  }\n\n  private now(): number {\n    return this.options.now?.() ?? Date.now();\n  }\n\n  private async tick(): Promise<void> {\n    if (this.ticking || this.stopped) return;\n    this.ticking = true;\n    const cursorBeforeTick = this.claimCursor;\n    try {\n      // stop() may land while discovery's I/O is pending: re-check before\n      // submitting anything, and again per candidate.\n      // A discovery failure (EACCES/EIO on the claims dir) must not reject\n      // into a detached timer callback: it would be an unhandled rejection\n      // that terminates the server. Log, skip this pass, retry next poll.\n      let candidates: { key: string; needsClaim: boolean }[];\n      try {\n        candidates = await this.discoverCandidates();\n      } catch (err) {\n        // Discovery may have listed a page before it failed: the page cursor\n        // already moved, so restore it — otherwise those claims wait for the\n        // cursor to wrap instead of the next poll.\n        this.claimCursor = cursorBeforeTick;\n        log.warn(\n          `backlog drain: discovery failed; retrying next poll: ${err instanceof Error ? err.message : String(err)}`\n        );\n        return;\n      }\n      if (this.stopped) return;\n      const dropped = this.submitCandidates(candidates);\n      // The concurrency bound stopped submission mid-page: rewind the page\n      // cursor so the unsubmitted claims are re-listed on the next tick\n      // (already-submitted ones are gated by inFlight and key backoff).\n      if (dropped) this.claimCursor = cursorBeforeTick;\n    } finally {\n      this.ticking = false;\n    }\n  }\n\n  /** Bounded discovery: ONE page of existing claims with pending turns */\n  private async discoverCandidates(): Promise<{ key: string; needsClaim: boolean }[]> {\n    const out: { key: string; needsClaim: boolean }[] = [];\n    const seen = new Set<string>();\n    const pageLimit = Math.max(this.submissionLimit() * 4, 16);\n    const page = await this.deps.claims.listPage(this.claimCursor, pageLimit);\n    for (const listed of page.entries) {\n      seen.add(listed.key);\n      out.push({ key: listed.key, needsClaim: false });\n    }\n    this.claimCursor = page.nextCursor;\n    for (const [key, counts] of await this.deps.liveBufferCounts()) {\n      if (counts.turns + counts.retainedTurns <= 0) continue;\n      if (seen.has(key) || this.deps.claims.isClaimed(key)) continue;\n      seen.add(key);\n      out.push({ key, needsClaim: true });\n    }\n    return out;\n  }\n\n  /** Submission bound: the queue's own concurrency limit, read with the\n   *  documented \"0 disables\" contract — a zero limit submits nothing. */\n  private submissionLimit(): number {\n    if (this.deps.queue.maxConcurrency <= 0) return 0;\n    return this.deps.queue.maxConcurrency;\n  }\n\n  /** Submit discovery candidates within the queue's concurrency bound. */\n  private submitCandidates(candidates: { key: string; needsClaim: boolean }[]): boolean {\n    let dropped = false;\n    for (const candidate of candidates) {\n      if (this.stopped || this.inFlight.size >= this.submissionLimit()) {\n        dropped = true;\n        break;\n      }\n      if (!this.candidateEligible(candidate)) continue;\n      // Fence the claim decision: reserve the key synchronously BEFORE the\n      // async rename so no queued task for it can pass the claimed gate in\n      // the meantime. Release happens when the decision settles.\n      if (candidate.needsClaim) {\n        if (!this.deps.queue.tryReserveKey(candidate.key)) continue;\n        this.reserved.add(candidate.key);\n      }\n      void this.submit(candidate.key, candidate.needsClaim);\n    }\n    return dropped;\n  }\n\n  /** inFlight is the authority for \"already submitted\" — key state only\n   *  exists once an outcome landed (backoff/denied gating below). */\n  private candidateEligible(candidate: { key: string; needsClaim: boolean }): boolean {\n    if (this.stopped || this.inFlight.size >= this.submissionLimit()) return false;\n    if (this.inFlight.has(candidate.key)) return false;\n    const state = this.keys.get(candidate.key);\n    return !(state && this.now() < state.nextAttemptMs);\n  }\n\n  /** Claim (when needed), then drain one key; the reservation spans the async\n   *  claim decision, the queue entry carries the key afterwards. */\n  private async submit(key: string, needsClaim: boolean): Promise<void> {\n    const controller = new AbortController();\n    const { promise: settled, resolve: settle } = Promise.withResolvers<void>();\n    this.inFlight.set(key, { controller, settled });\n    try {\n      if (!(await this.claimForSubmit(key, needsClaim))) return;\n      // Stopped between the claim decision and the task: leave the claim\n      // with its lease (it expires; the next start adopts) — never drain.\n      if (this.stopped) return;\n      await this.drainClaimedKey(key, controller.signal);\n    } catch (err) {\n      // Claim/drain failures are scheduler-level: the claim content is\n      // untouched — count failed and back off (never an unhandled rejection\n      // in the detached submission).\n      this.counters.failed += 1;\n      const message = err instanceof Error ? err.message : String(err);\n      // SAFETY: a thrown non-Error (incl. null) carries no retry hint; the\n      // optional chain reads the hint off Error throws only.\n      this.setBackoff(key, (err as { turnsRemaining?: number } | null | undefined)?.turnsRemaining ?? 0, message);\n      log.warn(`backlog drain: ${key} submission failed: ${message}`);\n    } finally {\n      this.inFlight.delete(key);\n      this.reserved.delete(key);\n      this.deps.queue.releaseKeyReservation(key);\n      settle();\n    }\n  }\n\n  /** after all — the key goes quiet without a task. \"claimed\": ours. */\n  private async claimForSubmit(key: string, needsClaim: boolean): Promise<boolean> {\n    if (!needsClaim) return true;\n    try {\n      const outcome = await this.deps.claims.claimFromSessionFile(key, this.deps.lease());\n      if (outcome === \"empty\") {\n        this.keys.delete(key);\n        return false;\n      }\n      return true;\n    } finally {\n      this.reserved.delete(key);\n      this.deps.queue.releaseKeyReservation(key);\n    }\n  }\n\n  /** Drain one claimed key. drainKey reports failures as outcomes; a thrown\n   *  error still means the claim content is intact — count it failed and\n   *  back off. */\n  private async drainClaimedKey(key: string, signal: AbortSignal): Promise<void> {\n    this.counters.claimed += 1;\n    try {\n      const outcome = await this.deps.drainKey(key, {\n        ownerId: this.options.ownerId,\n        signal,\n      });\n      this.applyOutcome(key, outcome);\n    } catch (err) {\n      this.counters.failed += 1;\n      const message = err instanceof Error ? err.message : String(err);\n      // SAFETY: a thrown non-Error (incl. null) carries no retry hint; the\n      // optional chain reads the hint off Error throws only.\n      this.setBackoff(key, (err as { turnsRemaining?: number } | null | undefined)?.turnsRemaining ?? 0, message);\n      log.warn(`backlog drain: ${key} threw: ${message}`);\n    }\n  }\n\n  private applyOutcome(key: string, outcome: DrainSessionOutcome): void {\n    const deniedTurns = outcome.denied?.reduce((sum, entry) => sum + entry.turns, 0) ?? 0;\n    const previous = this.keys.get(key);\n    const progressed = outcome.turnsRemaining < (previous?.turnsRemaining ?? Number.POSITIVE_INFINITY);\n    if (outcome.status === \"drained\") {\n      // The claim is now an empty tombstone: authoritative, nothing pending.\n      // New ingress consumes it via the native save path and re-candidates.\n      this.keys.delete(key);\n      this.counters.processed += 1;\n      this.counters.durableOutputs += outcome.durableOutputCount;\n      log.info(\n        `backlog drain: ${key} drained (${outcome.turnsAtStart} turn(s), ${outcome.durableOutputCount} durable output(s))`\n      );\n      return;\n    }\n    this.recordNonDrainedCounters(previous, outcome, deniedTurns);\n    const denied = deniedTurns > 0 && outcome.turnsRemaining > 0;\n    this.keys.set(key, this.nextKeyState(previous, outcome, denied, progressed));\n    log.info(\n      `backlog drain: ${key} ${outcome.status} (${outcome.turnsRemaining} turn(s) remaining` +\n        `${denied ? `, denied: ${deniedTurns}` : \"\"}${outcome.reason ? `, ${outcome.reason}` : \"\"})`\n    );\n  }\n\n  /** Denied backlog counters for a non-drained outcome. */\n  private recordNonDrainedCounters(\n    previous: KeyState | undefined,\n    outcome: DrainSessionOutcome,\n    deniedTurns: number\n  ): void {\n    if (deniedTurns > 0) {\n      this.counters.denied.keys += 1;\n      this.counters.denied.turns += deniedTurns;\n    }\n    if (outcome.status === \"failed\") this.counters.failed += 1;\n    else if (previous !== undefined && (previous.state === \"backoff\" || previous.state === \"denied\"))\n      this.counters.retried += 1;\n  }\n\n  /** The post-drain key state: denial waits the full max window (its content\n   *  is valid but currently unauthorized); progress resets the exponent. */\n  private nextKeyState(\n    previous: KeyState | undefined,\n    outcome: DrainSessionOutcome,\n    denied: boolean,\n    progressed: boolean\n  ): KeyState {\n    return {\n      state: denied ? \"denied\" : \"backoff\",\n      nextAttemptMs: this.now() + this.backoffMs(previous, progressed && !denied),\n      turnsRemaining: outcome.turnsRemaining,\n      reason: outcome.reason,\n      backoffExponent: this.nextBackoffExponent(denied, progressed, previous),\n    };\n  }\n\n  private nextBackoffExponent(denied: boolean, progressed: boolean, previous: KeyState | undefined): number {\n    return denied || !progressed ? (previous?.backoffExponent ?? 0) + 1 : 0;\n  }\n\n  private backoffMs(previous: KeyState | undefined, progressed: boolean): number {\n    if (previous?.state === \"denied\") return this.options.retryMaxMs;\n    const exponent = progressed ? 0 : (previous?.backoffExponent ?? 0) + 1;\n    return Math.min(this.options.retryBaseMs * 2 ** exponent, this.options.retryMaxMs);\n  }\n\n  private setBackoff(key: string, turnsRemaining: number, reason: string): void {\n    const previous = this.keys.get(key);\n    this.keys.set(key, {\n      state: \"backoff\",\n      nextAttemptMs: this.now() + this.backoffMs(previous, false),\n      turnsRemaining,\n      reason,\n      backoffExponent: (previous?.backoffExponent ?? 0) + 1,\n    });\n  }\n}\n\n/** Lease lifetime for claims the scheduler takes (matches the runner default). */\nconst SCHEDULER_LEASE_MS = 120_000;\n\n/** Wire the scheduler to an orchestrator's own queue, claim store, live buffer\n *  counts and drain runner — the daemon's single ownership point. */\nexport function wireBacklogScheduler(\n  orchestrator: Orchestrator,\n  options: BacklogSchedulerOptions = {}\n): BacklogScheduler {\n  const ownerId = options.ownerId ?? `daemon-drain-${process.pid}`;\n  const runner = new BufferDrainRunner(orchestrator);\n  return new BacklogScheduler(\n    {\n      queue: orchestrator.extractionQueueCoordinator,\n      claims: orchestrator.storage.bufferDrainClaims(),\n      liveBufferCounts: async () => {\n        // The daemon's buffer may be lazy: ensure the persisted state is in\n        // memory before counting (load is guarded/idempotent).\n        await orchestrator.buffer.load();\n        return orchestrator.buffer.entryCounts();\n      },\n      lease: () => {\n        const now = new Date().toISOString();\n        return {\n          ownerId,\n          pid: process.pid,\n          host: hostname(),\n          acquiredAt: now,\n          heartbeatAt: now,\n          leaseMs: SCHEDULER_LEASE_MS,\n        };\n      },\n      drainKey: (key, drainOptions) => runner.drainSession(key, drainOptions),\n    },\n    { ...options, ownerId }\n  );\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/orchestration/backlog-scheduler.ts"],"sourcesContent":["/**\n * Daemon-owned extraction backlog scheduler.\n *\n * ONE bounded in-process loop that owns ALL persisted extraction backlog:\n * at startup (existing drain claims + buffered sessions), on every poll tick\n * (new persisted work), and by retrying keys that are still pending — with\n * bounded memory (per-key COUNTS only; candidate scans never retain turn\n * payloads) and bounded outstanding work (the extraction queue's own\n * maxConcurrency gates submissions, so live foreground work keeps its share\n * of the queue).\n *\n * Claim authority: an existing claim — including an EMPTY ack tombstone — is\n * authoritative over the live buffer's in-memory copy. A tombstoned key is\n * never re-claimed or counted as work; new ingress consumes the tombstone\n * through the native save handover, which is what makes the key a candidate\n * again. Claim creation is fenced: the key is reserved synchronously on the\n * extraction queue BEFORE the async claim decision, so a queued live task for\n * the same key cannot start past the claimed-session gate until the decision\n * settles; live capture continues via the native merge-into-claim protocol.\n *\n * Failed, deferred, or policy-denied outcomes keep their turns durable in the\n * claim and re-submit after backoff (exponential from `retryBaseMs` to\n * `retryMaxMs`, reset by progress; denials wait the full max) — never a busy\n * retry. `stop()` aborts in-flight drains at their chunk boundary and leaves\n * every claim retryable; a restarted daemon's scheduler adopts them.\n */\n\nimport { hostname } from \"node:os\";\nimport { log } from \"../logger.js\";\nimport type { Orchestrator } from \"../orchestrator.js\";\nimport type { BufferDrainClaims, DrainLease } from \"../storage/buffer-drain-claims.js\";\nimport { BufferDrainRunner } from \"./buffer-drain-runner.js\";\nimport type { DrainRunnerEvent, DrainSessionOutcome } from \"./buffer-drain-runner.js\";\nimport type { ExtractionQueueCoordinator } from \"./extraction-queue-coordinator.js\";\nimport type { ProviderBreakerSnapshot } from \"./provider-breaker.js\";\n\n/** What the scheduler needs from its host (structurally satisfied by the\n *  orchestrator wiring); injectable so tests drive ticks deterministically. */\nexport interface BacklogSchedulerDeps {\n  queue: Pick<ExtractionQueueCoordinator, \"tryReserveKey\" | \"releaseKeyReservation\" | \"maxConcurrency\">;\n  claims: Pick<BufferDrainClaims, \"list\" | \"listPage\" | \"claimFromSessionFile\" | \"isClaimed\">;\n  /** Live per-key pending counts (counts only — never turn payloads). May be\n   *  async: hosts with a lazily-loaded buffer load it here (idempotent). */\n  liveBufferCounts():\n    | Map<string, { turns: number; retainedTurns: number }>\n    | Promise<Map<string, { turns: number; retainedTurns: number }>>;\n  /** A fresh lease for claims this scheduler takes. */\n  lease(): DrainLease;\n  /** Drain one key to quiescence (BufferDrainRunner.drainSession). */\n  drainKey(\n    key: string,\n    options: { ownerId: string; signal: AbortSignal; onEvent?: (event: DrainRunnerEvent) => void }\n  ): Promise<DrainSessionOutcome>;\n  /** Shared provider circuit-breaker snapshot (the same instance the run\n   *  coordinator gates attempts on). While OPEN inside its cooldown window\n   *  the scheduler skips submission entirely — claims stay durable, and the\n   *  breaker's single half-open probe (one attempt through once the window\n   *  lapses) keeps recovery automatic. Optional: hosts without a breaker\n   *  never skip. */\n  breakerSnapshot?(): ProviderBreakerSnapshot;\n  /** Test seam: monotonic-ish clock for backoff windows. */\n  now?(): number;\n}\n\nexport interface BacklogSchedulerOptions {\n  ownerId?: string;\n  /** Scan cadence in ms (startup + new-work + retry checks). */\n  pollMs?: number;\n  retryBaseMs?: number;\n  retryMaxMs?: number;\n  now?: () => number;\n}\n\nexport interface BacklogSchedulerCounters {\n  /** Keys submitted to the drain (claimed or adopted) this process lifetime. */\n  claimed: number;\n  /** Outcomes with genuinely empty claims (durable outputs preceded ack). */\n  processed: number;\n  /** Sum of durable outputs (memories + entities) across processed drains. */\n  durableOutputs: number;\n  /** Re-submissions after a failed/deferred/denied outcome. */\n  retried: number;\n  denied: { keys: number; turns: number };\n  failed: number;\n}\n\nexport type BacklogKeyState = \"inflight\" | \"backoff\" | \"denied\";\n\nexport interface BacklogKeySnapshot {\n  key: string;\n  state: BacklogKeyState;\n  turnsRemaining?: number;\n  reason?: string;\n}\n\nexport interface BacklogSchedulerSnapshot {\n  counters: BacklogSchedulerCounters;\n  inFlight: string[];\n  reservedKeys: string[];\n  keys: BacklogKeySnapshot[];\n}\n\ninterface KeyState {\n  state: BacklogKeyState;\n  nextAttemptMs: number;\n  /** Last observed remaining turns; progress resets the backoff exponent. */\n  turnsRemaining: number;\n  reason?: string;\n  backoffExponent: number;\n}\n\nconst DEFAULT_POLL_MS = 15_000;\nconst DEFAULT_RETRY_BASE_MS = 30_000;\nconst DEFAULT_RETRY_MAX_MS = 15 * 60_000;\n\nexport class BacklogScheduler {\n  private readonly deps: BacklogSchedulerDeps;\n  private readonly options: Required<Omit<BacklogSchedulerOptions, \"now\">> & Pick<BacklogSchedulerOptions, \"now\">;\n  private readonly keys = new Map<string, KeyState>();\n  private readonly inFlight = new Map<string, { controller: AbortController; settled: Promise<void> }>();\n  private readonly reserved = new Set<string>();\n  private readonly counters: BacklogSchedulerCounters = {\n    claimed: 0,\n    processed: 0,\n    durableOutputs: 0,\n    retried: 0,\n    denied: { keys: 0, turns: 0 },\n    failed: 0,\n  };\n  private claimCursor: string | undefined;\n  private timer: ReturnType<typeof setInterval> | undefined;\n  private ticking = false;\n  private stopped = true;\n\n  constructor(deps: BacklogSchedulerDeps, options: BacklogSchedulerOptions = {}) {\n    this.deps = deps;\n    this.options = {\n      ownerId: options.ownerId ?? `daemon-drain-${process.pid}`,\n      pollMs: options.pollMs ?? DEFAULT_POLL_MS,\n      retryBaseMs: options.retryBaseMs ?? DEFAULT_RETRY_BASE_MS,\n      retryMaxMs: options.retryMaxMs ?? DEFAULT_RETRY_MAX_MS,\n      now: options.now,\n    };\n  }\n\n  /** Idempotent. Starts the poll timer (unref'd) and runs an initial tick. */\n  start(): void {\n    if (!this.stopped) return;\n    this.stopped = false;\n    this.timer = setInterval(() => void this.tick(), this.options.pollMs);\n    this.timer.unref?.();\n    void this.tick();\n  }\n\n  /** Idempotent. Stops the timer, aborts in-flight drains (their claims stay\n   *  retryable) and waits for them to settle. */\n  async stop(): Promise<void> {\n    if (this.stopped) return;\n    this.stopped = true;\n    if (this.timer) {\n      clearInterval(this.timer);\n      this.timer = undefined;\n    }\n    const aborts: Promise<void>[] = [];\n    for (const entry of this.inFlight.values()) {\n      entry.controller.abort(new Error(\"backlog scheduler stopping\"));\n      aborts.push(entry.settled);\n    }\n    await Promise.allSettled(aborts);\n  }\n\n  /** Bounded snapshot for ops/watchers: counters + per-key states + live sets. */\n  snapshot(): BacklogSchedulerSnapshot {\n    return {\n      counters: {\n        claimed: this.counters.claimed,\n        processed: this.counters.processed,\n        durableOutputs: this.counters.durableOutputs,\n        retried: this.counters.retried,\n        denied: { ...this.counters.denied },\n        failed: this.counters.failed,\n      },\n      inFlight: [...this.inFlight.keys()],\n      reservedKeys: [...this.reserved],\n      keys: [...this.keys.entries()].map(([key, state]) => ({\n        key,\n        state: state.state,\n        turnsRemaining: state.turnsRemaining,\n        reason: state.reason,\n      })),\n    };\n  }\n\n  /** One scan+submit pass (tests drive this instead of the timer). Waits out\n   *  any in-progress tick first so the pass always actually scans. */\n  async tickForTest(): Promise<void> {\n    // setImmediate: yields to the event loop so pending I/O (a slow first\n    // scan) can finish; a microtask spin would starve it.\n    while (this.ticking) await new Promise((resolve) => setImmediate(resolve));\n    await this.tick();\n  }\n\n  /** Await the settle (slot release) of everything currently in flight,\n   *  optionally excluding one still-gated key (tests). */\n  async settleForTest(exclude?: string): Promise<void> {\n    for (;;) {\n      const pending = [...this.inFlight.entries()].filter(([key]) => key !== exclude).map(([, entry]) => entry.settled);\n      if (pending.length === 0) return;\n      await Promise.allSettled(pending);\n    }\n  }\n\n  private now(): number {\n    return this.options.now?.() ?? Date.now();\n  }\n\n  private async tick(): Promise<void> {\n    if (this.ticking || this.stopped) return;\n    this.ticking = true;\n    const cursorBeforeTick = this.claimCursor;\n    try {\n      // Fast bail: a breaker already open must not pay discovery I/O\n      // (listPage reads and parses claim bodies on every poll). The\n      // submitCandidates guard below still catches a breaker that opens\n      // while discovery awaits.\n      const breakerBeforeDiscovery = this.deps.breakerSnapshot?.();\n      if (\n        breakerBeforeDiscovery &&\n        breakerBeforeDiscovery.state === \"open\" &&\n        this.now() < breakerBeforeDiscovery.openUntilMs\n      ) {\n        return;\n      }\n      // stop() may land while discovery's I/O is pending: re-check before\n      // submitting anything, and again per candidate.\n      // A discovery failure (EACCES/EIO on the claims dir) must not reject\n      // into a detached timer callback: it would be an unhandled rejection\n      // that terminates the server. Log, skip this pass, retry next poll.\n      let candidates: { key: string; needsClaim: boolean }[];\n      try {\n        candidates = await this.discoverCandidates();\n      } catch (err) {\n        // Discovery may have listed a page before it failed: the page cursor\n        // already moved, so restore it — otherwise those claims wait for the\n        // cursor to wrap instead of the next poll.\n        this.claimCursor = cursorBeforeTick;\n        log.warn(\n          `backlog drain: discovery failed; retrying next poll: ${err instanceof Error ? err.message : String(err)}`\n        );\n        return;\n      }\n      if (this.stopped) return;\n      const dropped = this.submitCandidates(candidates);\n      // The concurrency bound stopped submission mid-page: rewind the page\n      // cursor so the unsubmitted claims are re-listed on the next tick\n      // (already-submitted ones are gated by inFlight and key backoff).\n      if (dropped) this.claimCursor = cursorBeforeTick;\n    } finally {\n      this.ticking = false;\n    }\n  }\n\n  /** Bounded discovery: ONE page of existing claims with pending turns */\n  private async discoverCandidates(): Promise<{ key: string; needsClaim: boolean }[]> {\n    const out: { key: string; needsClaim: boolean }[] = [];\n    const seen = new Set<string>();\n    const pageLimit = Math.max(this.submissionLimit() * 4, 16);\n    const page = await this.deps.claims.listPage(this.claimCursor, pageLimit);\n    for (const listed of page.entries) {\n      seen.add(listed.key);\n      out.push({ key: listed.key, needsClaim: false });\n    }\n    this.claimCursor = page.nextCursor;\n    for (const [key, counts] of await this.deps.liveBufferCounts()) {\n      if (counts.turns + counts.retainedTurns <= 0) continue;\n      if (seen.has(key) || this.deps.claims.isClaimed(key)) continue;\n      seen.add(key);\n      out.push({ key, needsClaim: true });\n    }\n    return out;\n  }\n\n  /** Submission bound: the queue's own concurrency limit, read with the\n   *  documented \"0 disables\" contract — a zero limit submits nothing. */\n  private submissionLimit(): number {\n    if (this.deps.queue.maxConcurrency <= 0) return 0;\n    return this.deps.queue.maxConcurrency;\n  }\n\n  /** Submit discovery candidates within the queue's concurrency bound. */\n  private submitCandidates(candidates: { key: string; needsClaim: boolean }[]): boolean {\n    // Breaker-open churn guard: a full attempt reads the claim, rebuilds the\n    // buffer/coordinator and re-renders chunks before the breaker fails it\n    // fast — pure heap pressure per poll during a provider stall. Skip while\n    // the window is open; once it lapses, submissions resume and the\n    // breaker's half-open probe runs as usual.\n    const breaker = this.deps.breakerSnapshot?.();\n    if (breaker && breaker.state === \"open\" && this.now() < breaker.openUntilMs) {\n      return true;\n    }\n    let dropped = false;\n    for (const candidate of candidates) {\n      if (this.stopped || this.inFlight.size >= this.submissionLimit()) {\n        dropped = true;\n        break;\n      }\n      if (!this.candidateEligible(candidate)) continue;\n      // Fence the claim decision: reserve the key synchronously BEFORE the\n      // async rename so no queued task for it can pass the claimed gate in\n      // the meantime. Release happens when the decision settles.\n      if (candidate.needsClaim) {\n        if (!this.deps.queue.tryReserveKey(candidate.key)) continue;\n        this.reserved.add(candidate.key);\n      }\n      void this.submit(candidate.key, candidate.needsClaim);\n    }\n    return dropped;\n  }\n\n  /** inFlight is the authority for \"already submitted\" — key state only\n   *  exists once an outcome landed (backoff/denied gating below). */\n  private candidateEligible(candidate: { key: string; needsClaim: boolean }): boolean {\n    if (this.stopped || this.inFlight.size >= this.submissionLimit()) return false;\n    if (this.inFlight.has(candidate.key)) return false;\n    const state = this.keys.get(candidate.key);\n    return !(state && this.now() < state.nextAttemptMs);\n  }\n\n  /** Claim (when needed), then drain one key; the reservation spans the async\n   *  claim decision, the queue entry carries the key afterwards. */\n  private async submit(key: string, needsClaim: boolean): Promise<void> {\n    const controller = new AbortController();\n    const { promise: settled, resolve: settle } = Promise.withResolvers<void>();\n    this.inFlight.set(key, { controller, settled });\n    try {\n      if (!(await this.claimForSubmit(key, needsClaim))) return;\n      // Stopped between the claim decision and the task: leave the claim\n      // with its lease (it expires; the next start adopts) — never drain.\n      if (this.stopped) return;\n      await this.drainClaimedKey(key, controller.signal);\n    } catch (err) {\n      // Claim/drain failures are scheduler-level: the claim content is\n      // untouched — count failed and back off (never an unhandled rejection\n      // in the detached submission).\n      this.counters.failed += 1;\n      const message = err instanceof Error ? err.message : String(err);\n      // SAFETY: a thrown non-Error (incl. null) carries no retry hint; the\n      // optional chain reads the hint off Error throws only.\n      this.setBackoff(key, (err as { turnsRemaining?: number } | null | undefined)?.turnsRemaining ?? 0, message);\n      log.warn(`backlog drain: ${key} submission failed: ${message}`);\n    } finally {\n      this.inFlight.delete(key);\n      this.reserved.delete(key);\n      this.deps.queue.releaseKeyReservation(key);\n      settle();\n    }\n  }\n\n  /** after all — the key goes quiet without a task. \"claimed\": ours. */\n  private async claimForSubmit(key: string, needsClaim: boolean): Promise<boolean> {\n    if (!needsClaim) return true;\n    try {\n      const outcome = await this.deps.claims.claimFromSessionFile(key, this.deps.lease());\n      if (outcome === \"empty\") {\n        this.keys.delete(key);\n        return false;\n      }\n      return true;\n    } finally {\n      this.reserved.delete(key);\n      this.deps.queue.releaseKeyReservation(key);\n    }\n  }\n\n  /** Drain one claimed key. drainKey reports failures as outcomes; a thrown\n   *  error still means the claim content is intact — count it failed and\n   *  back off. */\n  private async drainClaimedKey(key: string, signal: AbortSignal): Promise<void> {\n    this.counters.claimed += 1;\n    try {\n      const outcome = await this.deps.drainKey(key, {\n        ownerId: this.options.ownerId,\n        signal,\n      });\n      this.applyOutcome(key, outcome);\n    } catch (err) {\n      this.counters.failed += 1;\n      const message = err instanceof Error ? err.message : String(err);\n      // SAFETY: a thrown non-Error (incl. null) carries no retry hint; the\n      // optional chain reads the hint off Error throws only.\n      this.setBackoff(key, (err as { turnsRemaining?: number } | null | undefined)?.turnsRemaining ?? 0, message);\n      log.warn(`backlog drain: ${key} threw: ${message}`);\n    }\n  }\n\n  private applyOutcome(key: string, outcome: DrainSessionOutcome): void {\n    const deniedTurns = outcome.denied?.reduce((sum, entry) => sum + entry.turns, 0) ?? 0;\n    const previous = this.keys.get(key);\n    const progressed = outcome.turnsRemaining < (previous?.turnsRemaining ?? Number.POSITIVE_INFINITY);\n    if (outcome.status === \"drained\") {\n      // The claim is now an empty tombstone: authoritative, nothing pending.\n      // New ingress consumes it via the native save path and re-candidates.\n      this.keys.delete(key);\n      this.counters.processed += 1;\n      this.counters.durableOutputs += outcome.durableOutputCount;\n      log.info(\n        `backlog drain: ${key} drained (${outcome.turnsAtStart} turn(s), ${outcome.durableOutputCount} durable output(s))`\n      );\n      return;\n    }\n    this.recordNonDrainedCounters(previous, outcome, deniedTurns);\n    const denied = deniedTurns > 0 && outcome.turnsRemaining > 0;\n    this.keys.set(key, this.nextKeyState(previous, outcome, denied, progressed));\n    log.info(\n      `backlog drain: ${key} ${outcome.status} (${outcome.turnsRemaining} turn(s) remaining` +\n        `${denied ? `, denied: ${deniedTurns}` : \"\"}${outcome.reason ? `, ${outcome.reason}` : \"\"})`\n    );\n  }\n\n  /** Denied backlog counters for a non-drained outcome. */\n  private recordNonDrainedCounters(\n    previous: KeyState | undefined,\n    outcome: DrainSessionOutcome,\n    deniedTurns: number\n  ): void {\n    if (deniedTurns > 0) {\n      this.counters.denied.keys += 1;\n      this.counters.denied.turns += deniedTurns;\n    }\n    if (outcome.status === \"failed\") this.counters.failed += 1;\n    else if (previous !== undefined && (previous.state === \"backoff\" || previous.state === \"denied\"))\n      this.counters.retried += 1;\n  }\n\n  /** The post-drain key state: denial waits the full max window (its content\n   *  is valid but currently unauthorized); progress resets the exponent. */\n  private nextKeyState(\n    previous: KeyState | undefined,\n    outcome: DrainSessionOutcome,\n    denied: boolean,\n    progressed: boolean\n  ): KeyState {\n    return {\n      state: denied ? \"denied\" : \"backoff\",\n      nextAttemptMs: this.now() + this.backoffMs(previous, progressed && !denied),\n      turnsRemaining: outcome.turnsRemaining,\n      reason: outcome.reason,\n      backoffExponent: this.nextBackoffExponent(denied, progressed, previous),\n    };\n  }\n\n  private nextBackoffExponent(denied: boolean, progressed: boolean, previous: KeyState | undefined): number {\n    return denied || !progressed ? (previous?.backoffExponent ?? 0) + 1 : 0;\n  }\n\n  private backoffMs(previous: KeyState | undefined, progressed: boolean): number {\n    if (previous?.state === \"denied\") return this.options.retryMaxMs;\n    const exponent = progressed ? 0 : (previous?.backoffExponent ?? 0) + 1;\n    return Math.min(this.options.retryBaseMs * 2 ** exponent, this.options.retryMaxMs);\n  }\n\n  private setBackoff(key: string, turnsRemaining: number, reason: string): void {\n    const previous = this.keys.get(key);\n    this.keys.set(key, {\n      state: \"backoff\",\n      nextAttemptMs: this.now() + this.backoffMs(previous, false),\n      turnsRemaining,\n      reason,\n      backoffExponent: (previous?.backoffExponent ?? 0) + 1,\n    });\n  }\n}\n\n/** Lease lifetime for claims the scheduler takes (matches the runner default). */\nconst SCHEDULER_LEASE_MS = 120_000;\n\n/** Wire the scheduler to an orchestrator's own queue, claim store, live buffer\n *  counts and drain runner — the daemon's single ownership point. */\nexport function wireBacklogScheduler(\n  orchestrator: Orchestrator,\n  options: BacklogSchedulerOptions = {}\n): BacklogScheduler {\n  const ownerId = options.ownerId ?? `daemon-drain-${process.pid}`;\n  const runner = new BufferDrainRunner(orchestrator);\n  return new BacklogScheduler(\n    {\n      queue: orchestrator.extractionQueueCoordinator,\n      claims: orchestrator.storage.bufferDrainClaims(),\n      liveBufferCounts: async () => {\n        // The daemon's buffer may be lazy: ensure the persisted state is in\n        // memory before counting (load is guarded/idempotent).\n        await orchestrator.buffer.load();\n        return orchestrator.buffer.entryCounts();\n      },\n      lease: () => {\n        const now = new Date().toISOString();\n        return {\n          ownerId,\n          pid: process.pid,\n          host: hostname(),\n          acquiredAt: now,\n          heartbeatAt: now,\n          leaseMs: SCHEDULER_LEASE_MS,\n        };\n      },\n      drainKey: (key, drainOptions) => runner.drainSession(key, drainOptions),\n      // The orchestrator's one shared provider breaker (foreground and every\n      // claim-backed drain accumulate toward the same threshold).\n      breakerSnapshot: () => orchestrator.getExtractionResilienceStatus().breaker,\n    },\n    { ...options, ownerId }\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/orchestration/buffer-drain-runner.js

@@ -1,43 +1,43 @@
 import {
   BufferDrainRunner,
   ClaimBufferStorage
-} from "../chunk-HPCWJMMQ.js";
-import "../chunk-Q2QPHGEC.js";
-import "../chunk-5QV6CE6K.js";
-import "../chunk-T64HVBAP.js";
+} from "../chunk-TD5VTVPT.js";
+import "../chunk-HR6NTVYZ.js";
+import "../chunk-B36ACJG7.js";
+import "../chunk-PLGBPFEO.js";
 import "../chunk-5PHOU5QI.js";
-import "../chunk-4SOISEZ3.js";
+import "../chunk-MBENRPMY.js";
 import "../chunk-I74SUMNI.js";
 import "../chunk-ILNPU5W5.js";
-import "../chunk-VWHWWIFS.js";
 import "../chunk-VZAKYDMJ.js";
-import "../chunk-PUP7NTNB.js";
+import "../chunk-4DLZ2ITE.js";
+import "../chunk-IRFQKR4Y.js";
 import "../chunk-666A3MOW.js";
+import "../chunk-RZN4LQ5Y.js";
 import "../chunk-VDC6RZI4.js";
 import "../chunk-UWK5OXUJ.js";
-import "../chunk-ZG4GNPRE.js";
+import "../chunk-PBE7NFB5.js";
+import "../chunk-DDA47TES.js";
 import "../chunk-AQNHEDXP.js";
 import "../chunk-SDL22RRW.js";
 import "../chunk-7N4KAIGN.js";
 import "../chunk-QNN4FYBD.js";
 import "../chunk-UXPUUL3G.js";
-import "../chunk-DDA47TES.js";
+import "../chunk-V5OCT34X.js";
 import "../chunk-TECVW3JP.js";
 import "../chunk-C5JF6EZ7.js";
 import "../chunk-KBL3JJR6.js";
-import "../chunk-RZN4LQ5Y.js";
-import "../chunk-IXBIL5WY.js";
+import "../chunk-LJUQPT5G.js";
 import "../chunk-5KBIOI4G.js";
-import "../chunk-V5OCT34X.js";
-import "../chunk-XV7PJVQO.js";
+import "../chunk-6RPPZL7W.js";
 import "../chunk-47DU4SGJ.js";
 import "../chunk-3Q3XD3NO.js";
+import "../chunk-GCBIXUPT.js";
 import "../chunk-ECZU5BJH.js";
 import "../chunk-KVDUKH5E.js";
 import "../chunk-VHF73MGU.js";
 import "../chunk-4EX5WZ4M.js";
 import "../chunk-YRFAYOFQ.js";
-import "../chunk-GCBIXUPT.js";
 import "../chunk-T67LUYCR.js";
 import "../chunk-LJLGH2DE.js";
 import "../chunk-ODZKV2F7.js";
@@ -45,11 +45,11 @@ import "../chunk-6TCXIRP5.js";
 import "../chunk-XMYWYJM2.js";
 import "../chunk-ZOKZIR5K.js";
 import "../chunk-5IZL4DCV.js";
+import "../chunk-X7XN6YU4.js";
 import "../chunk-X7J56GPG.js";
 import "../chunk-LUDXM7MD.js";
 import "../chunk-2KHIBLO5.js";
-import "../chunk-X7XN6YU4.js";
-import "../chunk-N7NAGECH.js";
+import "../chunk-36B5VPRU.js";
 import "../chunk-DBB5JPSL.js";
 import "../chunk-3D75XIYO.js";
 import "../chunk-G2DF5MI7.js";
@@ -58,10 +58,10 @@ import "../chunk-EURPSF4Y.js";
 import "../chunk-MGN2RQRG.js";
 import "../chunk-EVWDNKQA.js";
 import "../chunk-ROI7BK7H.js";
-import "../chunk-23L3IXFD.js";
-import "../chunk-3GPTTA4J.js";
 import "../chunk-LD72P4YS.js";
+import "../chunk-23L3IXFD.js";
 import "../chunk-573TEZCD.js";
+import "../chunk-3GPTTA4J.js";
 import "../chunk-M4DB6ZNN.js";
 import "../chunk-IBJ6U753.js";
 import "../chunk-APYY5CX3.js";
@@ -72,8 +72,8 @@ import "../chunk-PHRLJFWZ.js";
 import "../chunk-64NJRYU2.js";
 import "../chunk-OH7QLI6W.js";
 import "../chunk-LZIOY7ZU.js";
-import "../chunk-KY3KJUNN.js";
-import "../chunk-EQ6EMJRG.js";
+import "../chunk-XC7OYOQC.js";
+import "../chunk-6Y5ANLDH.js";
 import "../chunk-54V4BZWP.js";
 import "../chunk-2CGLBUW3.js";
 import "../chunk-QT5MGENX.js";
@@ -85,7 +85,7 @@ import "../chunk-QJ2AX6DU.js";
 import "../chunk-JE26AUX6.js";
 import "../chunk-CIIHIAJ2.js";
 import "../chunk-D5SSBCYY.js";
-import "../chunk-TJ5YGCPV.js";
+import "../chunk-GXVK754R.js";
 import "../chunk-BVRZSI7Q.js";
 import "../chunk-77R7BQZ2.js";
 import "../chunk-AIYXVWUH.js";
@@ -102,7 +102,7 @@ import "../chunk-LUPVCGYK.js";
 import "../chunk-BUYVPUEM.js";
 import "../chunk-IAIPNEHD.js";
 import "../chunk-DGFU5MSX.js";
-import "../chunk-V33ETCF6.js";
+import "../chunk-7FFGWIBN.js";
 import "../chunk-S57QBPTA.js";
 import "../chunk-GKUA4MGB.js";
 import "../chunk-WJ6S54ES.js";
@@ -115,15 +115,16 @@ import "../chunk-VEWZZM3H.js";
 import "../chunk-5IIQU4JZ.js";
 import "../chunk-PYIR4SSB.js";
 import "../chunk-7G5NTS7F.js";
-import "../chunk-Y2ZGT4W7.js";
+import "../chunk-HB5TNQMM.js";
 import "../chunk-4NZQ7IID.js";
 import "../chunk-3I4FUAVJ.js";
-import "../chunk-LIGA5KHG.js";
+import "../chunk-SY4AFWUZ.js";
+import "../chunk-MMACM5G2.js";
 import "../chunk-54BGIBCR.js";
 import "../chunk-H4CKS5B2.js";
-import "../chunk-MMACM5G2.js";
 import "../chunk-FXZTL7F7.js";
-import "../chunk-6EKP7BJW.js";
+import "../chunk-UP6MOYCB.js";
+import "../chunk-I4LJJ44E.js";
 import "../chunk-BV2TIZ4F.js";
 import "../chunk-HDDRVXX4.js";
 import "../chunk-PYHOAXTI.js";
@@ -133,14 +134,13 @@ import "../chunk-2DL3OFLD.js";
 import "../chunk-G4IAEX6D.js";
 import "../chunk-2NLLXCJG.js";
 import "../chunk-765K3SAT.js";
-import "../chunk-UP6MOYCB.js";
 import "../chunk-TBUEE7XF.js";
 import "../chunk-FGDKJJZS.js";
 import "../chunk-AJVLDJU6.js";
 import "../chunk-SZDLX763.js";
 import "../chunk-PYIFUBRK.js";
 import "../chunk-EDR6CVWZ.js";
-import "../chunk-KPCTZB3U.js";
+import "../chunk-3MBSD53O.js";
 import "../chunk-WHCD4Z3D.js";
 import "../chunk-YQJCWR4R.js";
 import "../chunk-7IGMKQWK.js";
@@ -148,24 +148,24 @@ import "../chunk-HSSERO3E.js";
 import "../chunk-NOUJNHWG.js";
 import "../chunk-I7TR2OCU.js";
 import "../chunk-2524MOWK.js";
-import "../chunk-G7I2RQ64.js";
+import "../chunk-GCJA5KKT.js";
 import "../chunk-HL4DB7TO.js";
 import "../chunk-WLT6LTQP.js";
 import "../chunk-EOU6V4IN.js";
 import "../chunk-VHSQU3RO.js";
-import "../chunk-KH2HB3OW.js";
-import "../chunk-KWUMXJN7.js";
+import "../chunk-COIQ5N4J.js";
+import "../chunk-X53HJENJ.js";
 import "../chunk-HZNURRDS.js";
 import "../chunk-B2NXOVZN.js";
 import "../chunk-HDN7IVIO.js";
 import "../chunk-ADYP7HXE.js";
+import "../chunk-3T74IZB3.js";
 import "../chunk-2LA3H54D.js";
-import "../chunk-DQVT45LZ.js";
-import "../chunk-WBMT3C6A.js";
+import "../chunk-P7HNMNN2.js";
+import "../chunk-Z3CKK5RR.js";
 import "../chunk-KFY3SGN7.js";
 import "../chunk-CMTINOFS.js";
-import "../chunk-3T74IZB3.js";
-import "../chunk-62O7YWBR.js";
+import "../chunk-HTDXNIO6.js";
 import "../chunk-I6ORDT54.js";
 import "../chunk-BCCG7VWM.js";
 import "../chunk-GGRRF4PZ.js";
@@ -178,19 +178,19 @@ import "../chunk-YNDLCWXS.js";
 import "../chunk-AUDJPF4N.js";
 import "../chunk-44442YCH.js";
 import "../chunk-Y4Z4I6WK.js";
-import "../chunk-DLLQMNYQ.js";
+import "../chunk-F3FNXE7C.js";
 import "../chunk-KJTKLXTH.js";
 import "../chunk-2DQ2XREU.js";
 import "../chunk-OKTXM5H4.js";
 import "../chunk-3ICAWZUU.js";
 import "../chunk-ZAJLJ35W.js";
-import "../chunk-KFZ3A2EA.js";
+import "../chunk-L4QYW2HO.js";
 import "../chunk-5JMAGU26.js";
 import "../chunk-YBPYIAA5.js";
 import "../chunk-HK6KYIF6.js";
 import "../chunk-2GBFKHBZ.js";
 import "../chunk-6TBIWIAG.js";
-import "../chunk-UEY5TPEE.js";
+import "../chunk-T6C3G67T.js";
 import "../chunk-MPDLLLOG.js";
 import "../chunk-YN2DQ2D6.js";
 import "../chunk-MYVPLJOO.js";
@@ -234,41 +234,41 @@ import "../chunk-43HUVDTD.js";
 import "../chunk-4RA3C3EV.js";
 import "../chunk-B32WYRXX.js";
 import "../chunk-3NF4QUNZ.js";
-import "../chunk-LUXVW5UU.js";
+import "../chunk-E22CQZ3H.js";
 import "../chunk-V7IZKJI3.js";
 import "../chunk-TB6CBZ5V.js";
 import "../chunk-XW2T4QAW.js";
-import "../chunk-XTN54NML.js";
+import "../chunk-G3T6YMBO.js";
+import "../chunk-SI36RWC3.js";
 import "../chunk-3JKYQBLC.js";
 import "../chunk-7RKSJVOQ.js";
 import "../chunk-HCAGBFE7.js";
-import "../chunk-SI36RWC3.js";
 import "../chunk-NJAIR57U.js";
 import "../chunk-2TGIKMMZ.js";
 import "../chunk-SDESKFKT.js";
 import "../chunk-3HSRWJTC.js";
-import "../chunk-YIXWY4OZ.js";
-import "../chunk-55NKJDKX.js";
-import "../chunk-2H3SITYD.js";
+import "../chunk-FETPTCQZ.js";
+import "../chunk-SZBZOUHR.js";
+import "../chunk-VEWTHVX2.js";
 import "../chunk-SRT6SHVZ.js";
-import "../chunk-GJOBCNST.js";
+import "../chunk-VEQVXNWR.js";
 import "../chunk-TE6S7KDF.js";
 import "../chunk-EIB4FJVR.js";
 import "../chunk-MZUQVWVC.js";
 import "../chunk-A5KNZSNA.js";
 import "../chunk-HUSTM6PU.js";
 import "../chunk-D24OXEPB.js";
-import "../chunk-STDAR7M7.js";
-import "../chunk-GI47WZWA.js";
-import "../chunk-RQHIN3PY.js";
-import "../chunk-NHTEEGE4.js";
-import "../chunk-OKBGLAAI.js";
-import "../chunk-LC55ZXLR.js";
-import "../chunk-K5Y42U2P.js";
+import "../chunk-IBQ7LGUJ.js";
+import "../chunk-SYDPJUFR.js";
+import "../chunk-ZG57BEUS.js";
+import "../chunk-233S3MXC.js";
+import "../chunk-N6GEGRCT.js";
+import "../chunk-3GGCMRO7.js";
+import "../chunk-VPEMGBTI.js";
 import "../chunk-7T4TOGMS.js";
 import "../chunk-7YQ6ESEA.js";
 import "../chunk-ZXF3O7P4.js";
-import "../chunk-YJX3K5LK.js";
+import "../chunk-RXGFITWS.js";
 import "../chunk-PQM3B54K.js";
 import "../chunk-K36RMINQ.js";
 import "../chunk-2RUTN7PR.js";
@@ -279,15 +279,15 @@ import "../chunk-2FLFJTCI.js";
 import "../chunk-JATHBCAV.js";
 import "../chunk-ZQUVBZI4.js";
 import "../chunk-5R627MYY.js";
-import "../chunk-OFOV6TTZ.js";
-import "../chunk-FU2ZLXVN.js";
+import "../chunk-KNZDGZSY.js";
+import "../chunk-DEGE32C3.js";
 import "../chunk-AB3A7EFH.js";
 import "../chunk-KIUVEMBI.js";
-import "../chunk-CAVXVGYK.js";
+import "../chunk-KAED7IBB.js";
 import "../chunk-2BPPGNAQ.js";
 import "../chunk-DJSJ4ULL.js";
-import "../chunk-DHQLVS7J.js";
-import "../chunk-GO2GCJ7S.js";
+import "../chunk-FP2AT4WL.js";
+import "../chunk-R24RYSQX.js";
 import "../chunk-W4F3C7N7.js";
 import "../chunk-MPC7TYTZ.js";
 import "../chunk-2R7OCBRR.js";
@@ -295,38 +295,38 @@ import "../chunk-IFBSZGW3.js";
 import "../chunk-OGXXGHW6.js";
 import "../chunk-RJWL3RHB.js";
 import "../chunk-VQ7B2Q6M.js";
-import "../chunk-DVDRKCZK.js";
 import "../chunk-BANSBRNX.js";
+import "../chunk-ELUG6NKQ.js";
 import "../chunk-JWX2Q6HS.js";
 import "../chunk-GNVZQ5JN.js";
 import "../chunk-YN2UN7N3.js";
-import "../chunk-MUH7RR6T.js";
+import "../chunk-G5NH3SSX.js";
 import "../chunk-HNOSWPKG.js";
 import "../chunk-WWDO7ZWM.js";
 import "../chunk-5Y43VGYB.js";
 import "../chunk-YUTT4ZTI.js";
-import "../chunk-RZED7FAU.js";
+import "../chunk-3M7YP42P.js";
 import "../chunk-5HFVWYHL.js";
 import "../chunk-MUHGYV2V.js";
+import "../chunk-5KVT6G5U.js";
 import "../chunk-KIW3OOZE.js";
 import "../chunk-KZSGBWOJ.js";
 import "../chunk-YE4JBZO5.js";
 import "../chunk-7O5EW7KX.js";
-import "../chunk-5KVT6G5U.js";
-import "../chunk-VYDGHJIN.js";
-import "../chunk-H7XKCNR6.js";
 import "../chunk-EWJZZDRG.js";
 import "../chunk-SOBJ6NEY.js";
 import "../chunk-7O2MC42R.js";
-import "../chunk-MOJ4UDA3.js";
-import "../chunk-ENPJX3BB.js";
+import "../chunk-VYDGHJIN.js";
+import "../chunk-H7XKCNR6.js";
+import "../chunk-ZZSFRWKD.js";
 import "../chunk-B6SPPYGJ.js";
+import "../chunk-FMFCQRDM.js";
 import "../chunk-UD7UNYRD.js";
 import "../chunk-IISBCCWR.js";
-import "../chunk-BNU5TQLR.js";
-import "../chunk-WGRAB3KB.js";
+import "../chunk-FOQ7TW2T.js";
+import "../chunk-ORVPS4ZW.js";
 import "../chunk-2YA5N2BY.js";
-import "../chunk-5XOCAJHC.js";
+import "../chunk-C44DRDZM.js";
 import "../chunk-HUDPXTXW.js";
 import "../chunk-AZEZSQ5R.js";
 import "../chunk-VPEIWMUT.js";
@@ -335,23 +335,23 @@ import "../chunk-JX3E4XCW.js";
 import "../chunk-QA3Y2O6H.js";
 import "../chunk-V27FK6D6.js";
 import "../chunk-DOWACHYO.js";
-import "../chunk-5MA7ZLPD.js";
+import "../chunk-QNUNAXBE.js";
 import "../chunk-LTHVM4XN.js";
 import "../chunk-RZH5RVJC.js";
 import "../chunk-C37ZRXX7.js";
 import "../chunk-NVKO5YKP.js";
 import "../chunk-3X5OPDPF.js";
-import "../chunk-4RASUAN3.js";
+import "../chunk-HXFIILGF.js";
+import "../chunk-WTWQA7BB.js";
 import "../chunk-VZIAVM72.js";
 import "../chunk-HRATODNO.js";
-import "../chunk-WTWQA7BB.js";
 import "../chunk-LXATZLSC.js";
-import "../chunk-E3NBMTTX.js";
+import "../chunk-TLTBACYX.js";
 import "../chunk-RF2SMMPP.js";
-import "../chunk-A2BH2VE2.js";
-import "../chunk-QYLEE4UQ.js";
-import "../chunk-2WDFLORC.js";
-import "../chunk-CU5N4RDI.js";
+import "../chunk-GWOFCHPN.js";
+import "../chunk-HCFNZWFB.js";
+import "../chunk-BZTA7DR4.js";
+import "../chunk-DANFOVQG.js";
 import "../chunk-UFGFMWAD.js";
 import "../chunk-BFBS7OFQ.js";
 import "../chunk-QGJSBU4R.js";
@@ -360,20 +360,21 @@ import "../chunk-LXY5VVGM.js";
 import "../chunk-GKCXTSFF.js";
 import "../chunk-2LSZVONP.js";
 import "../chunk-ZY2MNJR6.js";
-import "../chunk-BEQU6QGW.js";
+import "../chunk-IVXOYE43.js";
 import "../chunk-3UXOZBHV.js";
 import "../chunk-J6GZ2254.js";
-import "../chunk-DE4U5PTV.js";
-import "../chunk-43FLJLT2.js";
+import "../chunk-P4TEQSIZ.js";
+import "../chunk-Y5HZFIQO.js";
 import "../chunk-CSAKJVXW.js";
 import "../chunk-K2XUWZBM.js";
 import "../chunk-OD4FM2U7.js";
-import "../chunk-5RW247F5.js";
+import "../chunk-AY2UK5XK.js";
+import "../chunk-QEDLJDHP.js";
 import "../chunk-U4LUIE6Y.js";
 import "../chunk-T6OZW2WR.js";
 import "../chunk-5YQXWVCP.js";
-import "../chunk-QEDLJDHP.js";
-import "../chunk-WPPAXTW6.js";
+import "../chunk-MJFL75J6.js";
+import "../chunk-FGUWCE5I.js";
 import "../chunk-X2KO4FK5.js";
 import "../chunk-GZFKCLRC.js";
 import "../chunk-EKUI7I2X.js";
@@ -393,22 +394,22 @@ import "../chunk-ZCUTSMR2.js";
 import "../chunk-QDW3E4RD.js";
 import "../chunk-6L63IN3M.js";
 import "../chunk-ZJP66Q4I.js";
-import "../chunk-45SFSQON.js";
-import "../chunk-QGVCFVX6.js";
+import "../chunk-5IQL4N37.js";
 import "../chunk-UHVXE24Y.js";
+import "../chunk-QGVCFVX6.js";
 import "../chunk-IGOW4TJE.js";
 import "../chunk-G6OFEGUR.js";
 import "../chunk-7PMOCQOL.js";
-import "../chunk-JEX2JL3U.js";
-import "../chunk-U2A56LLF.js";
-import "../chunk-DOJBV6WR.js";
-import "../chunk-PFUXPTBT.js";
-import "../chunk-CYEPCZN5.js";
-import "../chunk-DLZGSZVC.js";
+import "../chunk-SHVLNI4L.js";
+import "../chunk-OBQ2NZAR.js";
 import "../chunk-OVZIYLBZ.js";
-import "../chunk-WNEVEMJ3.js";
 import "../chunk-EXYT52NR.js";
+import "../chunk-YK6SFDP2.js";
+import "../chunk-P3AQ2YSX.js";
+import "../chunk-CYEPCZN5.js";
+import "../chunk-FYQUUIPI.js";
 import "../chunk-Y5NLBXPV.js";
+import "../chunk-WNEVEMJ3.js";
 import "../chunk-TFA6HPOA.js";
 import "../chunk-F4TWWUMP.js";
 import "../chunk-72A4L5JJ.js";
@@ -421,7 +422,7 @@ import "../chunk-S2HLHAZ4.js";
 import "../chunk-DM2T26WE.js";
 import "../chunk-LDXUBPMO.js";
 import "../chunk-FF6N7BXC.js";
-import "../chunk-WXPBDEMW.js";
+import "../chunk-JDQEQE2R.js";
 import "../chunk-AAD2ZS6P.js";
 import "../chunk-BV2BRHD4.js";
 import "../chunk-ZIKENA2C.js";
@@ -453,11 +454,11 @@ import "../chunk-C64XATK7.js";
 import "../chunk-42JKGUFJ.js";
 import "../chunk-23G5P7TA.js";
 import "../chunk-4KLQI3L2.js";
-import "../chunk-AVVCPA7U.js";
+import "../chunk-UCPH56YX.js";
 import "../chunk-I55KAVET.js";
 import "../chunk-L2EXJQJP.js";
 import "../chunk-45GF7Y3V.js";
-import "../chunk-YIJECSIX.js";
+import "../chunk-DJDJBMFX.js";
 import "../chunk-E2AWJ7KQ.js";
 import "../chunk-W5BIQOAJ.js";
 import "../chunk-HADD45AR.js";
@@ -484,13 +485,13 @@ import "../chunk-AQEJKOKI.js";
 import "../chunk-4RNBLLZR.js";
 import "../chunk-WZU5AGO6.js";
 import "../chunk-YLXETSAH.js";
-import "../chunk-5JBVPJCT.js";
+import "../chunk-WIAXVBQH.js";
 import "../chunk-2D7BTSDW.js";
 import "../chunk-353C5UNV.js";
 import "../chunk-JRVMCZE3.js";
 import "../chunk-BT7NVCML.js";
 import "../chunk-IZJQNDGI.js";
-import "../chunk-CIL4GHMD.js";
+import "../chunk-6Q6AQ36B.js";
 import "../chunk-KQAFEZQX.js";
 import "../chunk-WEHSQBFR.js";
 import "../chunk-X7Y7WX73.js";
@@ -501,7 +502,7 @@ import "../chunk-FP2373TW.js";
 import "../chunk-Z2YFLXHU.js";
 import "../chunk-I4WBNM3M.js";
 import "../chunk-SOAU2OE2.js";
-import "../chunk-FDUCIUQ5.js";
+import "../chunk-FJ2VJTGA.js";
 import "../chunk-A7BM2JTH.js";
 import "../chunk-QUMKDRCF.js";
 import "../chunk-TIGYOZBU.js";
@@ -523,15 +524,15 @@ import "../chunk-BTNNL7ZW.js";
 import "../chunk-JDSVLVCG.js";
 import "../chunk-5GKPFL3S.js";
 import "../chunk-JAKIDQB2.js";
-import "../chunk-UIFWZMO7.js";
+import "../chunk-CLVILSBR.js";
 import "../chunk-UI3NYK34.js";
 import "../chunk-XXR4A33N.js";
 import "../chunk-UWMZT2TY.js";
-import "../chunk-F4ZHKDBW.js";
-import "../chunk-WN2DASTS.js";
+import "../chunk-HLWXCDUQ.js";
+import "../chunk-5BE3FLKL.js";
+import "../chunk-63LFM77Z.js";
 import "../chunk-LDWE7OZS.js";
 import "../chunk-GCGJW34D.js";
-import "../chunk-63LFM77Z.js";
 import "../chunk-XZ66U5M3.js";
 import "../chunk-SWRRZNHM.js";
 import "../chunk-JNA7LFMQ.js";

package/dist/orchestration/extraction-queue-coordinator.d.ts

@@ -82,15 +82,10 @@ export declare class ExtractionQueueCoordinator {
     /** How many tasks may run at once (test seam + diagnostics). */
     get maxConcurrency(): number;
     /**
-     * Enqueue a task and start the processor when capacity is free. This is
-     * the production entry point — the orchestrator's `queueBufferedExtraction`
-     * builds each task closure and hands it here with its buffer key.
-     *
-     * Per-key coalescing: a queued-not-started task for key K is superseded by
-     * a newer enqueue for K instead of stacking another full turn snapshot
-     * behind it (extraction reads live state at run time, so the newest
-     * closure is the authoritative one). Keyless tasks are independent work
-     * and never coalesce.
+     * Enqueue a task and start the processor when capacity is free. Each task
+     * keeps its own captured work and settlement; keyed tasks serialize behind
+     * other tasks for that key. A front task may jump the queue but does not
+     * discard queued work.
      */
     enqueue(task: ExtractionQueueTask, options?: ExtractionQueueEnqueueOptions): boolean;
     /**