@remnic/core 10.0.91 → 10.0.93

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 { randomUUID } from \"node:crypto\";\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  /** Create a fresh lease for a unique owner token. */\n  lease(ownerId: string): 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  /** Optional label prefix; each scheduler instance adds a unique token. */\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\"}-${randomUUID()}`,\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, this.options.ownerId))) 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, this.options.ownerId);\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, ownerId: string): Promise<boolean> {\n    if (!needsClaim) return true;\n    try {\n      const outcome = await this.deps.claims.claimFromSessionFile(key, this.deps.lease(ownerId));\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, ownerId: string): Promise<void> {\n    this.counters.claimed += 1;\n    try {\n      const outcome = await this.deps.drainKey(key, {\n        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 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: (ownerId) => {\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\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 { randomUUID } from \"node:crypto\";\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  /** Create a fresh lease for a unique owner token. */\n  lease(ownerId: string): 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  /** Optional label prefix; each scheduler instance adds a unique token. */\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\"}-${randomUUID()}`,\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, this.options.ownerId))) 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, this.options.ownerId);\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, ownerId: string): Promise<boolean> {\n    if (!needsClaim) return true;\n    try {\n      const outcome = await this.deps.claims.claimFromSessionFile(key, this.deps.lease(ownerId));\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, ownerId: string): Promise<void> {\n    this.counters.claimed += 1;\n    try {\n      const outcome = await this.deps.drainKey(key, {\n        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 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: (ownerId) => {\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\n  );\n}\n"],"mappings":"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","names":[]}