@remnic/core 10.0.68 → 10.0.70

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/orchestration/buffer-drain-runner.ts"],"sourcesContent":["/**\n * Out-of-process extraction-buffer drain (`remnic buffer drain`).\n *\n * The runner owns ONE claimed session at a time and drives it through the\n * SAME extraction pipeline the daemon uses — the same chunking\n * (`chunkExtractionWindow` + the model's input budget), the same retry /\n * provider-circuit semantics, the same dropped-chunk side-file recovery. It\n * adds no extraction logic of its own.\n *\n * The difference is ownership: the claimed session's turns live in a drain\n * claim (a durable file), not in a live buffer. So the runner wires a\n * claim-backed `SmartBuffer` into the extraction queue instead of the live\n * one. Every chunk that extracts successfully is removed from the claim\n * immediately, which makes the drain resumable: a kill at any instant\n * leaves the un-extracted turns in the claim, and the next run continues\n * from there.\n *\n * Concurrency lives in the CLI (worker processes, one session each at a\n * time): the in-process extraction queue is serial by design, so a single\n * runner never runs two sessions' extractions at once.\n */\n\nimport type { BufferStorage } from \"../buffer-persistence.js\";\nimport { BufferDrainClaims, type DrainLease } from \"../storage/buffer-drain-claims.js\";\nimport type { BufferEntryState, BufferState } from \"../types.js\";\nimport { hostname } from \"node:os\";\nimport { describeError } from \"../buffer-turn-helpers.js\";\nimport { log } from \"../logger.js\";\nimport { selfDeps } from \"./self-deps.js\";\nimport { TurnIngestionCoordinator, type TurnIngestionDeps } from \"./turn-ingestion.js\";\nimport type { ExtractionRunResult } from \"./extraction-run.js\";\nimport type { Orchestrator } from \"../orchestrator.js\";\n\nexport type DrainSessionStatus = \"drained\" | \"deferred\" | \"failed\" | \"skipped\";\n\nexport interface DrainSessionOutcome {\n  key: string;\n  status: DrainSessionStatus;\n  /** Turns the claim held when the drain started. */\n  turnsAtStart: number;\n  /** Turns still in the claim when the drain stopped. */\n  turnsRemaining: number;\n  /** Facts the extraction persisted during this run. */\n  persistedCount: number;\n  /** Durable outputs (memories + entities) the extraction wrote. */\n  durableOutputCount: number;\n  /** Why the session was skipped or deferred (machine-readable). */\n  reason?: string;\n}\n\nexport interface BufferDrainRunnerOptions {\n  /** Identity of this drainer; owns the lease it takes. */\n  ownerId: string;\n  /** Lease lifetime in ms. The heartbeat keeps it alive while draining. */\n  leaseMs?: number;\n  /** Cancels the run at the next chunk boundary. */\n  signal?: AbortSignal;\n  /** Progress callback (per session, and per claim transition). */\n  onEvent?: (event: DrainRunnerEvent) => void;\n}\n\n/** A failed drain run: the reason a chunk or the session could not finish. */\nexport type DrainExtractionError = Error;\n\nexport type DrainRunnerEvent =\n  | { type: \"session_started\"; key: string; turns: number }\n  | { type: \"session_finished\"; key: string; outcome: DrainSessionOutcome };\n\nconst DEFAULT_LEASE_MS = 120_000;\n\n/**\n * A `BufferStorage` view of one drain claim: the claim file IS the buffer.\n * Writes are the drain's progress (what is left to extract), so every\n * successfully extracted chunk is durably removed before the next one runs.\n */\nclass ClaimBufferStorage implements BufferStorage {\n  constructor(\n    private readonly claims: BufferDrainClaims,\n    private readonly key: string,\n    private readonly ownerId: string,\n    private readonly entry: BufferEntryState,\n  ) {}\n\n  async loadBuffer(): Promise<BufferState> {\n    const entries: NonNullable<BufferState[\"entries\"]> = Object.create(null);\n    entries[this.key] = {\n      turns: this.entry.turns,\n      retainedTurns: this.entry.retainedTurns,\n      lastExtractionAt: this.entry.lastExtractionAt,\n      extractionCount: this.entry.extractionCount,\n    };\n    return {\n      turns: this.entry.turns,\n      lastExtractionAt: this.entry.lastExtractionAt,\n      extractionCount: this.entry.extractionCount,\n      entries,\n    };\n  }\n\n  async saveBuffer(state: BufferState): Promise<void> {\n    // Whole-state fallback (the claim covers one session): persist the entry.\n    const entry = state.entries?.[this.key];\n    await this.claims.writeEntry(this.key, this.ownerId, entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 }, this.entry);\n  }\n\n  async saveBufferSession(key: string, entry: BufferEntryState): Promise<void> {\n    await this.claims.writeEntry(key, this.ownerId, entry, key === this.key ? this.entry : undefined);\n  }\n\n  async deleteBufferSession(): Promise<void> {\n    // The claim is removed by the ack path, never by a buffer eviction: the\n    // drain decides when the session is finished.\n  }\n}\n\nexport class BufferDrainRunner {\n  constructor(private readonly orchestrator: Orchestrator) {}\n\n  /** The claim store of this orchestrator's memory root. */\n  get claims(): BufferDrainClaims {\n    return this.orchestrator.storage.bufferDrainClaims();\n  }\n\n  /**\n   * Drain one claimed session. The caller owns the lease (it may have taken\n   * it already); this method verifies ownership before touching content.\n   */\n  async drainSession(key: string, options: BufferDrainRunnerOptions): Promise<DrainSessionOutcome> {\n    const claims = this.claims;\n    const leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;\n    const lease: DrainLease = {\n      ownerId: options.ownerId,\n      pid: process.pid,\n      host: hostname(),\n      acquiredAt: new Date().toISOString(),\n      heartbeatAt: new Date().toISOString(),\n      leaseMs,\n    };\n    const claim = await claims.load(key);\n    if (!claim) {\n      return { key, status: \"skipped\", turnsAtStart: 0, turnsRemaining: 0, persistedCount: 0, durableOutputCount: 0, reason: \"not_claimed\" };\n    }\n    const turnsAtStart = claim.entry.turns.length + (claim.entry.retainedTurns?.length ?? 0);\n    options.onEvent?.({ type: \"session_started\", key, turns: turnsAtStart });\n\n    // Take the lease unless this drainer already holds it.\n    const held = await claims.adopt(key, lease);\n    if (held === \"busy\") {\n      const outcome: DrainSessionOutcome = {\n        key,\n        status: \"skipped\",\n        turnsAtStart,\n        turnsRemaining: turnsAtStart,\n        persistedCount: 0,\n        durableOutputCount: 0,\n        reason: \"claimed_by_another_drain\",\n      };\n      options.onEvent?.({ type: \"session_finished\", key, outcome });\n      return outcome;\n    }\n\n    // The claim is the buffer for this run: every successful chunk is\n    // removed from it, so a kill leaves exactly the un-extracted turns.\n    // The swap covers the whole extraction (its clear path reads the live\n    // buffer), so progress lands in the claim, not in a session file.\n    const claimStorage = new ClaimBufferStorage(claims, key, options.ownerId, claim.entry);\n    const coordinator = new TurnIngestionCoordinator(selfDeps<TurnIngestionDeps>(this.orchestrator));\n\n    // The claim's turns (retained first, like the live buffer's order).\n    const turns = [...(claim.entry.retainedTurns ?? []), ...claim.entry.turns];\n    if (turns.length === 0) {\n      await claims.ack(key, options.ownerId);\n      const outcome: DrainSessionOutcome = {\n        key,\n        status: \"drained\",\n        turnsAtStart,\n        turnsRemaining: 0,\n        persistedCount: 0,\n        durableOutputCount: 0,\n      };\n      options.onEvent?.({ type: \"session_finished\", key, outcome });\n      return outcome;\n    }\n\n    // Keep the lease alive while a long extraction runs; a lost lease means\n    // another drainer took the claim, so this run must stop instead of\n    // writing progress into a claim it no longer owns.\n    const abort = new AbortController();\n    const signal = options.signal ? AbortSignal.any([options.signal, abort.signal]) : abort.signal;\n    const heartbeat = setInterval(() => {\n      void claims\n        .heartbeat(key, options.ownerId, leaseMs)\n        .then((state) => {\n          if (state === \"lost\") abort.abort(new Error(`buffer drain: lease lost for session ${key}`));\n        })\n        .catch((err: Error) => {\n          // A heartbeat that cannot be renewed is a lease that cannot be\n          // held: another drainer may adopt the claim, so stop this run\n          // cleanly at the next chunk boundary (the next run resumes it).\n          abort.abort(new Error(`buffer drain: lease heartbeat failed for session ${key}: ${describeError(err)}`));\n        });\n    }, Math.max(1_000, Math.floor(leaseMs / 3)));\n    heartbeat.unref?.();\n\n    const settledResult = await this.orchestrator.withBufferStorage(claimStorage, async () => {\n      const swapTurns = this.orchestrator.buffer.getTurns(key);\n      const { promise, resolve } = Promise.withResolvers<{ error?: unknown; result?: ExtractionRunResult }>();\n      let settled = false;\n      void coordinator\n        .queueBufferedExtraction(swapTurns, \"trigger_mode\", {\n          bufferKey: key,\n          clearBufferAfterExtraction: true,\n          // The drain owns this session's content: the daemon's own dedupe\n          // gate must not skip it, and the thresholds do not apply to a\n          // backlog.\n          skipDedupeCheck: true,\n          skipCharThreshold: true,\n          skipUserTurnThreshold: true,\n          abortSignal: signal,\n          onTaskSettled: (error, result) => {\n            if (settled) return;\n            settled = true;\n            resolve({ error, result });\n          },\n        })\n        .catch((error: DrainExtractionError) => {\n          if (settled) return;\n          settled = true;\n          resolve({ error });\n        });\n      return await promise;\n    });\n    clearInterval(heartbeat);\n    const remaining = await claims.load(key);\n    const turnsRemaining = remaining\n      ? remaining.entry.turns.length + (remaining.entry.retainedTurns?.length ?? 0)\n      : 0;\n    const result = settledResult.result;\n    const persistedCount = result?.persistedCount ?? 0;\n    const durableOutputCount = result?.durableOutputCount ?? 0;\n\n    let status: DrainSessionStatus;\n    let reason: string | undefined;\n    if (turnsRemaining === 0) {\n      // Everything extracted (or dropped with a recovery side-file): the\n      // claim is finished and the session file is gone for good.\n      await claims.ack(key, options.ownerId);\n      status = \"drained\";\n    } else if (settledResult.error) {\n      // A failed run keeps the remaining turns for the next attempt.\n      await claims.releaseLease(key, options.ownerId);\n      status = \"failed\";\n      reason = describeError(settledResult.error);\n    } else {\n      // Deferred: provider breaker / backoff / a chunk still pending. The\n      // content stays claimed and the next run resumes it.\n      await claims.releaseLease(key, options.ownerId);\n      status = \"deferred\";\n      reason = result?.reason ?? \"deferred\";\n    }\n    log.info(\n      `buffer drain: session ${key} ${status} (${turnsRemaining} turn(s) remaining)`,\n    );\n    const outcome: DrainSessionOutcome = {\n      key,\n      status,\n      turnsAtStart,\n      turnsRemaining,\n      persistedCount,\n      durableOutputCount,\n    };\n    if (reason !== undefined) outcome.reason = reason;\n    options.onEvent?.({ type: \"session_finished\", key, outcome });\n    return outcome;\n  }\n\n  /** Claim a session file for the drain. Returns false when it is not claimable. */\n  async claim(key: string, ownerId: string, leaseMs = DEFAULT_LEASE_MS): Promise<boolean> {\n    const lease: DrainLease = {\n      ownerId,\n      pid: process.pid,\n      host: hostname(),\n      acquiredAt: new Date().toISOString(),\n      heartbeatAt: new Date().toISOString(),\n      leaseMs,\n    };\n    return (await this.claims.claimFromSessionFile(key, lease)) === \"claimed\";\n  }\n\n  /** Sessions with buffered turns, claimed or not (CLI scan). */\n  async scan(): Promise<{ key: string; turns: number; claimed: boolean }[]> {\n    const sessions = await this.orchestrator.storage.loadBuffer();\n    const entries = sessions.entries ?? {};\n    const out: { key: string; turns: number; claimed: boolean }[] = [];\n    const seen = new Set<string>();\n    for (const [key, entry] of Object.entries(entries)) {\n      seen.add(key);\n      const claim = this.claims.isClaimed(key) ? await this.claims.load(key) : null;\n      const turns = claim\n        ? claim.entry.turns.length + (claim.entry.retainedTurns?.length ?? 0)\n        : entry.turns.length + (entry.retainedTurns?.length ?? 0);\n      out.push({ key, turns, claimed: claim !== null });\n    }\n    // Claims the buffer state no longer lists (drained by an earlier run\n    // whose claim file outlived its session file).\n    for (const listed of await this.claims.list()) {\n      if (seen.has(listed.key)) continue;\n      out.push({ key: listed.key, turns: listed.turnCount, claimed: true });\n    }\n    return out;\n  }\n}\n"],"mappings":"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","names":["outcome","result"]}
+{"version":3,"sources":["../../src/orchestration/buffer-drain-runner.ts"],"sourcesContent":["/**\n * Out-of-process extraction-buffer drain (`remnic buffer drain`).\n *\n * The runner owns ONE claimed session at a time and drives it through the\n * SAME extraction pipeline the daemon uses — the same chunking\n * (`chunkExtractionWindow` + the model's input budget), the same retry /\n * provider-circuit semantics, the same dropped-chunk side-file recovery. It\n * adds no extraction logic of its own.\n *\n * The difference is ownership: the claimed session's turns live in a drain\n * claim (a durable file), not in a live buffer. So the runner wires a\n * claim-backed `SmartBuffer` into the extraction queue instead of the live\n * one. Every chunk that extracts successfully is removed from the claim\n * immediately, which makes the drain resumable: a kill at any instant\n * leaves the un-extracted turns in the claim, and the next run continues\n * from there.\n *\n * Concurrency lives in the CLI (worker processes, one session each at a\n * time): the in-process extraction queue is serial by design, so a single\n * runner never runs two sessions' extractions at once.\n */\n\nimport type { BufferStorage } from \"../buffer-persistence.js\";\nimport { BufferDrainClaims, type DrainLease } from \"../storage/buffer-drain-claims.js\";\nimport type { BufferEntryState, BufferState } from \"../types.js\";\nimport { hostname } from \"node:os\";\nimport { describeError } from \"../buffer-turn-helpers.js\";\nimport { log } from \"../logger.js\";\nimport { selfDeps } from \"./self-deps.js\";\nimport { TurnIngestionCoordinator, type TurnIngestionDeps } from \"./turn-ingestion.js\";\nimport type { ExtractionRunResult } from \"./extraction-run.js\";\nimport type { Orchestrator } from \"../orchestrator.js\";\n\nexport type DrainSessionStatus = \"drained\" | \"deferred\" | \"failed\" | \"skipped\";\n\nexport interface DrainSessionOutcome {\n  key: string;\n  status: DrainSessionStatus;\n  /** Turns the claim held when the drain started. */\n  turnsAtStart: number;\n  /** Turns still in the claim when the drain stopped. */\n  turnsRemaining: number;\n  /** Facts the extraction persisted during this run. */\n  persistedCount: number;\n  /** Durable outputs (memories + entities) the extraction wrote. */\n  durableOutputCount: number;\n  /** Why the session was skipped or deferred (machine-readable). */\n  reason?: string;\n}\n\nexport interface BufferDrainRunnerOptions {\n  /** Identity of this drainer; owns the lease it takes. */\n  ownerId: string;\n  /** Lease lifetime in ms. The heartbeat keeps it alive while draining. */\n  leaseMs?: number;\n  /** Cancels the run at the next chunk boundary. */\n  signal?: AbortSignal;\n  /** Progress callback (per session, and per claim transition). */\n  onEvent?: (event: DrainRunnerEvent) => void;\n}\n\n/** A failed drain run: the reason a chunk or the session could not finish. */\nexport type DrainExtractionError = Error;\n\nexport type DrainRunnerEvent =\n  | { type: \"session_started\"; key: string; turns: number }\n  | { type: \"session_finished\"; key: string; outcome: DrainSessionOutcome };\n\nconst DEFAULT_LEASE_MS = 120_000;\n\n/**\n * A `BufferStorage` view of one drain claim: the claim file IS the buffer.\n * Writes are the drain's progress (what is left to extract), so every\n * successfully extracted chunk is durably removed before the next one runs.\n */\nclass ClaimBufferStorage implements BufferStorage {\n  constructor(\n    private readonly claims: BufferDrainClaims,\n    private readonly key: string,\n    private readonly ownerId: string,\n    private readonly entry: BufferEntryState,\n  ) {}\n\n  async loadBuffer(): Promise<BufferState> {\n    const entries: NonNullable<BufferState[\"entries\"]> = Object.create(null);\n    entries[this.key] = {\n      turns: this.entry.turns,\n      retainedTurns: this.entry.retainedTurns,\n      lastExtractionAt: this.entry.lastExtractionAt,\n      extractionCount: this.entry.extractionCount,\n    };\n    return {\n      turns: this.entry.turns,\n      lastExtractionAt: this.entry.lastExtractionAt,\n      extractionCount: this.entry.extractionCount,\n      entries,\n    };\n  }\n\n  async saveBuffer(state: BufferState): Promise<void> {\n    // Whole-state fallback (the claim covers one session): persist the entry.\n    const entry = state.entries?.[this.key];\n    await this.claims.writeEntry(this.key, this.ownerId, entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 }, this.entry);\n  }\n\n  async saveBufferSession(key: string, entry: BufferEntryState): Promise<void> {\n    await this.claims.writeEntry(key, this.ownerId, entry, key === this.key ? this.entry : undefined);\n  }\n\n  async deleteBufferSession(): Promise<void> {\n    // The claim is removed by the ack path, never by a buffer eviction: the\n    // drain decides when the session is finished.\n  }\n}\n\nexport class BufferDrainRunner {\n  constructor(private readonly orchestrator: Orchestrator) {}\n\n  /** The claim store of this orchestrator's memory root. */\n  get claims(): BufferDrainClaims {\n    return this.orchestrator.storage.bufferDrainClaims();\n  }\n\n  /**\n   * Drain one claimed session. The caller owns the lease (it may have taken\n   * it already); this method verifies ownership before touching content.\n   */\n  async drainSession(key: string, options: BufferDrainRunnerOptions): Promise<DrainSessionOutcome> {\n    const claims = this.claims;\n    const leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;\n    const lease: DrainLease = {\n      ownerId: options.ownerId,\n      pid: process.pid,\n      host: hostname(),\n      acquiredAt: new Date().toISOString(),\n      heartbeatAt: new Date().toISOString(),\n      leaseMs,\n    };\n    const claim = await claims.load(key);\n    if (!claim) {\n      return { key, status: \"skipped\", turnsAtStart: 0, turnsRemaining: 0, persistedCount: 0, durableOutputCount: 0, reason: \"not_claimed\" };\n    }\n    const turnsAtStart = claim.entry.turns.length + (claim.entry.retainedTurns?.length ?? 0);\n    options.onEvent?.({ type: \"session_started\", key, turns: turnsAtStart });\n\n    // Take the lease unless this drainer already holds it.\n    const held = await claims.adopt(key, lease);\n    if (held === \"busy\") {\n      const outcome: DrainSessionOutcome = {\n        key,\n        status: \"skipped\",\n        turnsAtStart,\n        turnsRemaining: turnsAtStart,\n        persistedCount: 0,\n        durableOutputCount: 0,\n        reason: \"claimed_by_another_drain\",\n      };\n      options.onEvent?.({ type: \"session_finished\", key, outcome });\n      return outcome;\n    }\n\n    // The claim is the buffer for this run: every successful chunk is\n    // removed from it, so a kill leaves exactly the un-extracted turns.\n    // The swap covers the whole extraction (its clear path reads the live\n    // buffer), so progress lands in the claim, not in a session file.\n    const claimStorage = new ClaimBufferStorage(claims, key, options.ownerId, claim.entry);\n    const coordinator = new TurnIngestionCoordinator(selfDeps<TurnIngestionDeps>(this.orchestrator));\n\n    // The claim's turns (retained first, like the live buffer's order).\n    const turns = [...(claim.entry.retainedTurns ?? []), ...claim.entry.turns];\n    if (turns.length === 0) {\n      await claims.ack(key, options.ownerId);\n      const outcome: DrainSessionOutcome = {\n        key,\n        status: \"drained\",\n        turnsAtStart,\n        turnsRemaining: 0,\n        persistedCount: 0,\n        durableOutputCount: 0,\n      };\n      options.onEvent?.({ type: \"session_finished\", key, outcome });\n      return outcome;\n    }\n\n    // Keep the lease alive while a long extraction runs; a lost lease means\n    // another drainer took the claim, so this run must stop instead of\n    // writing progress into a claim it no longer owns.\n    const abort = new AbortController();\n    const signal = options.signal ? AbortSignal.any([options.signal, abort.signal]) : abort.signal;\n    const heartbeat = setInterval(() => {\n      void claims\n        .heartbeat(key, options.ownerId, leaseMs)\n        .then((state) => {\n          if (state === \"lost\") abort.abort(new Error(`buffer drain: lease lost for session ${key}`));\n        })\n        .catch((err: Error) => {\n          // A heartbeat that cannot be renewed is a lease that cannot be\n          // held: another drainer may adopt the claim, so stop this run\n          // cleanly at the next chunk boundary (the next run resumes it).\n          abort.abort(new Error(`buffer drain: lease heartbeat failed for session ${key}: ${describeError(err)}`));\n        });\n    }, Math.max(1_000, Math.floor(leaseMs / 3)));\n    heartbeat.unref?.();\n\n    const settledResult = await this.orchestrator.withBufferStorage(claimStorage, async () => {\n      const swapTurns = this.orchestrator.buffer.getTurns(key);\n      const { promise, resolve } = Promise.withResolvers<{ error?: unknown; result?: ExtractionRunResult }>();\n      let settled = false;\n      void coordinator\n        .queueBufferedExtraction(swapTurns, \"trigger_mode\", {\n          bufferKey: key,\n          clearBufferAfterExtraction: true,\n          // The drain owns this session's content: the daemon's own dedupe\n          // gate must not skip it, and the thresholds do not apply to a\n          // backlog.\n          skipDedupeCheck: true,\n          skipCharThreshold: true,\n          skipUserTurnThreshold: true,\n          abortSignal: signal,\n          onTaskSettled: (error, result) => {\n            if (settled) return;\n            settled = true;\n            resolve({ error, result });\n          },\n        })\n        .catch((error: DrainExtractionError) => {\n          if (settled) return;\n          settled = true;\n          resolve({ error });\n        });\n      return await promise;\n    });\n    clearInterval(heartbeat);\n    const remaining = await claims.load(key);\n    const turnsRemaining = remaining\n      ? remaining.entry.turns.length + (remaining.entry.retainedTurns?.length ?? 0)\n      : 0;\n    const result = settledResult.result;\n    const persistedCount = result?.persistedCount ?? 0;\n    const durableOutputCount = result?.durableOutputCount ?? 0;\n\n    let status: DrainSessionStatus;\n    let reason: string | undefined;\n    if (turnsRemaining === 0) {\n      // Everything extracted (or dropped with a recovery side-file): the\n      // claim is finished and the session file is gone for good.\n      await claims.ack(key, options.ownerId);\n      status = \"drained\";\n    } else if (settledResult.error) {\n      // A failed run keeps the remaining turns for the next attempt.\n      await claims.releaseLease(key, options.ownerId);\n      status = \"failed\";\n      reason = describeError(settledResult.error);\n    } else {\n      // Deferred: provider breaker / backoff / a chunk still pending. The\n      // content stays claimed and the next run resumes it.\n      await claims.releaseLease(key, options.ownerId);\n      status = \"deferred\";\n      reason = result?.reason ?? \"deferred\";\n    }\n    log.info(\n      `buffer drain: session ${key} ${status} (${turnsRemaining} turn(s) remaining)`,\n    );\n    const outcome: DrainSessionOutcome = {\n      key,\n      status,\n      turnsAtStart,\n      turnsRemaining,\n      persistedCount,\n      durableOutputCount,\n    };\n    if (reason !== undefined) outcome.reason = reason;\n    options.onEvent?.({ type: \"session_finished\", key, outcome });\n    return outcome;\n  }\n\n  /** Claim a session file for the drain. Returns false when it is not claimable. */\n  async claim(key: string, ownerId: string, leaseMs = DEFAULT_LEASE_MS): Promise<boolean> {\n    const lease: DrainLease = {\n      ownerId,\n      pid: process.pid,\n      host: hostname(),\n      acquiredAt: new Date().toISOString(),\n      heartbeatAt: new Date().toISOString(),\n      leaseMs,\n    };\n    return (await this.claims.claimFromSessionFile(key, lease)) === \"claimed\";\n  }\n\n  /** Sessions with buffered turns, claimed or not (CLI scan). */\n  async scan(): Promise<{ key: string; turns: number; claimed: boolean }[]> {\n    const sessions = await this.orchestrator.storage.loadBuffer();\n    const entries = sessions.entries ?? {};\n    const out: { key: string; turns: number; claimed: boolean }[] = [];\n    const seen = new Set<string>();\n    for (const [key, entry] of Object.entries(entries)) {\n      seen.add(key);\n      const claim = this.claims.isClaimed(key) ? await this.claims.load(key) : null;\n      const turns = claim\n        ? claim.entry.turns.length + (claim.entry.retainedTurns?.length ?? 0)\n        : entry.turns.length + (entry.retainedTurns?.length ?? 0);\n      out.push({ key, turns, claimed: claim !== null });\n    }\n    // Claims the buffer state no longer lists (drained by an earlier run\n    // whose claim file outlived its session file).\n    for (const listed of await this.claims.list()) {\n      if (seen.has(listed.key)) continue;\n      out.push({ key: listed.key, turns: listed.turnCount, claimed: true });\n    }\n    return out;\n  }\n}\n"],"mappings":"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","names":["outcome","result"]}

package/dist/orchestration/extraction-persist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extraction-persist.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-persist.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAgBxG,OAAO,EAA6C,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAM7F,OAAO,EAUgE,KAAK,8BAA8B,EACxG,KAAK,4BAA4B,EAClC,MAAM,oBAAoB,CAAC;AAqD5B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF,OAAO,KAAK,EAEV,gBAAgB,EAQjB,MAAM,aAAa,CAAC;AAWrB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAmB1E,6FAA6F;AAC7F,MAAM,WAAW,uBAAuB;IACtC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,CAAC;IACtB,kFAAkF;IAClF,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,qBAAa,4BAA4B;IAErC,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,qBAAqB;IAE9C,OAAO,KAAK,MAAM,GAEjB;IACD,OAAO,KAAK,6BAA6B,GAGxC;IAEK,iBAAiB,CACrB,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,cAAc,EACvB,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,EACrC,aAAa,CAAC,EAAE,uBAAuB,EACvC,aAAa,CAAC,EAAE,MAAM,EACtB,qBAAqB,CAAC,EAAE,wBAAwB,GAAG,IAAI,EACvD,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,GAAE,8BAAuF,EAClG,aAAa,GAAE,4BAAmF,GACjG,OAAO,CAAC,uBAAuB,CAAC;CA0wFpC"}
+{"version":3,"file":"extraction-persist.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-persist.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAiBxG,OAAO,EAA6C,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAM7F,OAAO,EAUgE,KAAK,8BAA8B,EACxG,KAAK,4BAA4B,EAClC,MAAM,oBAAoB,CAAC;AAqD5B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF,OAAO,KAAK,EAEV,gBAAgB,EAQjB,MAAM,aAAa,CAAC;AAWrB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAmB1E,6FAA6F;AAC7F,MAAM,WAAW,uBAAuB;IACtC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,CAAC;IACtB,kFAAkF;IAClF,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,qBAAa,4BAA4B;IAErC,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,qBAAqB;IAE9C,OAAO,KAAK,MAAM,GAEjB;IACD,OAAO,KAAK,6BAA6B,GAGxC;IAEK,iBAAiB,CACrB,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,cAAc,EACvB,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,EACrC,aAAa,CAAC,EAAE,uBAAuB,EACvC,aAAa,CAAC,EAAE,MAAM,EACtB,qBAAqB,CAAC,EAAE,wBAAwB,GAAG,IAAI,EACvD,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,GAAE,8BAAuF,EAClG,aAAa,GAAE,4BAAmF,GACjG,OAAO,CAAC,uBAAuB,CAAC;CA8wFpC"}

package/dist/orchestration/maintenance.js

@@ -1,46 +1,44 @@
 import {
   MaintenanceScheduler
-} from "../chunk-JLGBJ4AX.js";
-import "../chunk-5MGKGEL7.js";
+} from "../chunk-ZYEWTVNQ.js";
+import "../chunk-HNF7IMYQ.js";
+import "../chunk-THFSCUFC.js";
 import "../chunk-666A3MOW.js";
-import "../chunk-O5ZINWW3.js";
-import "../chunk-GHHQLSSY.js";
+import "../chunk-XR4QR3JT.js";
 import "../chunk-5KBIOI4G.js";
-import "../chunk-U2CAGMUD.js";
-import "../chunk-HH73M65H.js";
-import "../chunk-WHROVQ5Q.js";
+import "../chunk-2YPIFJHL.js";
+import "../chunk-MCFI6G7U.js";
+import "../chunk-66PEACZP.js";
 import "../chunk-KJTKLXTH.js";
 import "../chunk-2DQ2XREU.js";
 import "../chunk-J5WI4QRP.js";
 import "../chunk-EWMRFW3F.js";
-import "../chunk-4SOWMA55.js";
-import "../chunk-CI3MAAIY.js";
+import "../chunk-3AASGFR4.js";
+import "../chunk-3F7N4I5I.js";
 import "../chunk-OGXXGHW6.js";
 import "../chunk-YUTT4ZTI.js";
-import "../chunk-5UM4H64E.js";
-import "../chunk-P4TV3TQ2.js";
-import "../chunk-74AY3S7U.js";
-import "../chunk-T6OZW2WR.js";
-import "../chunk-QEDLJDHP.js";
+import "../chunk-5VQSKBNF.js";
+import "../chunk-D3AGBN6G.js";
+import "../chunk-5RW247F5.js";
 import "../chunk-U4LUIE6Y.js";
+import "../chunk-T6OZW2WR.js";
 import "../chunk-5YQXWVCP.js";
-import "../chunk-TBBDFYXW.js";
-import "../chunk-TOTT6S2V.js";
-import "../chunk-NHWDTOBN.js";
-import "../chunk-UHVXE24Y.js";
+import "../chunk-QEDLJDHP.js";
+import "../chunk-ILD7N3XC.js";
 import "../chunk-QGVCFVX6.js";
+import "../chunk-UHVXE24Y.js";
 import "../chunk-IGOW4TJE.js";
 import "../chunk-ZOBYTRBU.js";
 import "../chunk-G6OFEGUR.js";
-import "../chunk-OH55F76C.js";
-import "../chunk-L334PSLW.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-OVZIYLBZ.js";
-import "../chunk-EXYT52NR.js";
-import "../chunk-DOJBV6WR.js";
-import "../chunk-PFUXPTBT.js";
 import "../chunk-WNEVEMJ3.js";
+import "../chunk-EXYT52NR.js";
 import "../chunk-Y5NLBXPV.js";
 import "../chunk-TFA6HPOA.js";
 import "../chunk-F4TWWUMP.js";
@@ -58,14 +56,15 @@ import "../chunk-WXPBDEMW.js";
 import "../chunk-AAD2ZS6P.js";
 import "../chunk-BV2BRHD4.js";
 import "../chunk-ZIKENA2C.js";
+import "../chunk-3ONXXHQO.js";
 import "../chunk-YXZG5TVN.js";
 import "../chunk-3OUGSOJP.js";
 import "../chunk-SCU65EZI.js";
-import "../chunk-3ONXXHQO.js";
-import "../chunk-3WU7XOFN.js";
 import "../chunk-P4GUQSK3.js";
 import "../chunk-4LZ7SVKM.js";
 import "../chunk-YHTG64XV.js";
+import "../chunk-3WU7XOFN.js";
+import "../chunk-G7D6GZ5J.js";
 import "../chunk-ER7XANP3.js";
 import "../chunk-M5GVCJSJ.js";
 import "../chunk-RBOJCG4T.js";
@@ -73,18 +72,17 @@ import "../chunk-IAYUTGF2.js";
 import "../chunk-5WITETWU.js";
 import "../chunk-6CIAGZ6X.js";
 import "../chunk-7CT3AI52.js";
-import "../chunk-G7D6GZ5J.js";
 import "../chunk-7VLBZKNB.js";
 import "../chunk-Y33KJ556.js";
-import "../chunk-ELHJK7LM.js";
-import "../chunk-IUM3VSHI.js";
+import "../chunk-WBN66HPI.js";
 import "../chunk-NWA6IXR3.js";
 import "../chunk-VILPVT4S.js";
 import "../chunk-AF2XMJKD.js";
 import "../chunk-OR42ZI54.js";
-import "../chunk-23G5P7TA.js";
+import "../chunk-IUM3VSHI.js";
 import "../chunk-C64XATK7.js";
 import "../chunk-42JKGUFJ.js";
+import "../chunk-23G5P7TA.js";
 import "../chunk-U7MIMS2Y.js";
 import "../chunk-AVVCPA7U.js";
 import "../chunk-I55KAVET.js";
@@ -92,13 +90,15 @@ import "../chunk-L2EXJQJP.js";
 import "../chunk-45GF7Y3V.js";
 import "../chunk-YIJECSIX.js";
 import "../chunk-E2AWJ7KQ.js";
+import "../chunk-W5BIQOAJ.js";
 import "../chunk-HADD45AR.js";
 import "../chunk-RNFMFC37.js";
 import "../chunk-C5C7IJ4Q.js";
+import "../chunk-TBBDFYXW.js";
 import "../chunk-YCVB7X56.js";
+import "../chunk-TOTT6S2V.js";
 import "../chunk-PQVCH2AE.js";
 import "../chunk-PJKTFXE2.js";
-import "../chunk-W5BIQOAJ.js";
 import "../chunk-V4XE263I.js";
 import "../chunk-YBA52OKG.js";
 import "../chunk-2D7BTSDW.js";
@@ -118,8 +118,8 @@ import "../chunk-7RJUVTVF.js";
 import "../chunk-AL3UYZ5N.js";
 import "../chunk-RL6NEVXT.js";
 import "../chunk-YET735EZ.js";
-import "../chunk-PWPIERBM.js";
 import "../chunk-YO2JEX2Z.js";
+import "../chunk-PWPIERBM.js";
 import "../chunk-KQUSP6LB.js";
 import "../chunk-5FVVY2EB.js";
 import "../chunk-BTNNL7ZW.js";

package/dist/orchestration/promotion-dedup-window.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Promotion destination writes under the fact-dedup commit window (codex P2,
+ * PRRT_kwDORJXyws6zzdG4 / #3311). The persist-time promotion gates run
+ * OUTSIDE the window that serializes source writes, so with
+ * extractionQueueConcurrency > 1 two sessions promoting the same fact from
+ * different source namespaces can both gate-miss and both write the shared
+ * destination — duplicate active copies, because writeMemory mints a fresh id
+ * per write and does not coalesce active duplicates. This module wraps each
+ * promotion destination write in `persistUnderFactDedupWindow` keyed on the
+ * DESTINATION storage dir and rechecks with the same connector/content
+ * predicate the promotion gates confirm with, so a twin promotion committed
+ * between the gate and the write is suppressed instead of duplicated.
+ *
+ * Split out of extraction-persist.ts for the structural ratchet (#1995);
+ * behavior is a verbatim move of the wrapped writes the persist closure
+ * previously inlined.
+ */
+import { type StorageManager } from "../index.js";
+import type { ImportanceScore, MemoryFrontmatter, ProvenanceSource } from "../types.js";
+import type { SealedMemoryEnvelope } from "../write-envelope.js";
+import type { DependencyPropagationDeliveryPort } from "./dependency-propagation-delivery.js";
+import { type FactDedupWindowOutcome } from "./fact-dedup-window.js";
+/**
+ * The promotion fields the windowed write and its suppression-path bounds
+ * backfill read. Structurally satisfied by both promotion closures' options
+ * objects in extraction-persist.ts (profile-target and shared).
+ */
+export interface PromotionDedupWriteFields {
+    category: string;
+    sourceMemoryId: string;
+    importance?: ImportanceScore;
+    intentGoal?: string;
+    intentActionType?: string;
+    intentEntityTypes?: string[];
+    memoryKind?: MemoryFrontmatter["memoryKind"];
+    validAt?: string;
+    invalidAt?: string;
+    observedAt?: string;
+    eventTimeSource?: "extracted" | "assumed";
+    sources?: ProvenanceSource[];
+    provenance?: "verified" | "unverified" | "none";
+    toolScoped?: true;
+}
+export interface PromotionDedupWriteArgs {
+    /** Promotion DESTINATION storage — the commit window is keyed on its dir. */
+    destination: StorageManager;
+    /** Composed sealed envelope for the promoted copy. */
+    envelope: SealedMemoryEnvelope;
+    /** The promotion closure's options (read structurally). */
+    promotion: PromotionDedupWriteFields;
+    /** Fact hash-key content (attrs-suffixed); pre-citation raw for others. */
+    dedupContent: string;
+    rawContent: string;
+    /** promotionWithholdsToolScope() result (shared) / forwarded marker (profile). */
+    toolScoped: boolean;
+    /** Raw source connector: trimmed for the recheck, raw for bounds backfill. */
+    connector: string | undefined;
+    citationEnabled: boolean;
+    citationTemplate: string;
+    /** lifecycleCaps.temporalSupersession on the shared path; false on the
+     *  profile path (its gate predicate has no entity filter). When true AND the
+     *  envelope carries an entityRef with non-empty surviving attrs, the recheck
+     *  additionally requires the same entity (PR #402 Uybg guard parity). */
+    sameEntityGuardEnabled: boolean;
+    /** Envelope-surviving structured attributes (PR #402 Uybg guard input). */
+    survivingAttrs?: Record<string, string> | null;
+    /** When set, the suppression path runs the post-write supersession pass
+     *  against the winning copy (PRRT_kwDORJXyws6z18qb): a suppressed
+     *  later-dated promotion must still retire a conflicting shared fact dated
+     *  between the events, mirroring the gate's hash-dedup-hit pass. */
+    supersession?: {
+        /** Caller's lifecycleCaps.temporalSupersession — without it the pass
+         *  must not run even though the event-time `enabled` gate passes
+         *  (PRRT_kwDORJXyws6z2o1t). */
+        supersessionEnabled: boolean;
+        dependencyPropagationDelivery?: DependencyPropagationDeliveryPort;
+        namespaceScope?: string;
+    };
+    backfillTemporalBoundsOnDedupHit: ExtractionPersistDeps["backfillTemporalBoundsOnDedupHit"];
+}
+type ExtractionPersistDeps = {
+    backfillTemporalBoundsOnDedupHit: (targetStorage: StorageManager, dedupContent: string, bounds: {
+        invalidAt?: string;
+        validFrom?: string;
+        observedAt?: string;
+        eventTimeSource?: "extracted" | "assumed";
+    }, entityRef?: string, sourceConnector?: string) => Promise<void>;
+};
+/**
+ * In-window race confirm for a promotion destination. Authoritative index +
+ * miss is a clean NOT-duplicate answered WITHOUT the corpus scan, mirroring
+ * `confirmActiveFactDuplicate` and the window contract (one corpus confirm +
+ * one write, not a scan-length lock) — PRRT_kwDORJXyws6z18qS. On a hit, a
+ * non-authoritative index, or a probe failure, confirm against the corpus
+ * with the gates' predicate.
+ */
+export declare function confirmPromotionRaceDuplicate(args: {
+    storage: StorageManager;
+    dedupContent: string;
+    category: string;
+    connector: string | undefined;
+    citationEnabled: boolean;
+    citationTemplate: string;
+    entityKeyNorm?: string;
+}): Promise<boolean>;
+/**
+ * Run one promotion destination write inside the destination-dir fact-dedup
+ * commit window: recheck (facts only; the same confirm the persist-time gate
+ * used, now under the lock) and suppress as a duplicate when a concurrent
+ * promotion committed the same content first. A suppressed promotion backfills
+ * temporal bounds onto the winning copy (#1671 parity with the gates' skip
+ * paths) and reports `{ suppressed: true }`. Lock contention throws
+ * fail-closed to the caller — never an unlocked write; the durable source
+ * fact is unaffected.
+ */
+export declare function writePromotionUnderFactDedupWindow(args: PromotionDedupWriteArgs): Promise<FactDedupWindowOutcome<Awaited<ReturnType<StorageManager["writeSealedMemory"]>>>>;
+export {};
+//# sourceMappingURL=promotion-dedup-window.d.ts.map

package/dist/orchestration/promotion-dedup-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promotion-dedup-window.d.ts","sourceRoot":"","sources":["../../src/orchestration/promotion-dedup-window.ts"],"names":[],"mappings":"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"}