@remnic/core 10.0.70 → 10.0.72

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

@@ -1,15 +1,17 @@
 import {
-  TurnIngestionCoordinator
-} from "../chunk-OAQO5AZJ.js";
+  BufferDrainRunner,
+  ClaimBufferStorage
+} from "../chunk-ZODKV27J.js";
+import "../chunk-DSSTOV5M.js";
 import "../chunk-5QV6CE6K.js";
-import "../chunk-YRMSHA7H.js";
-import "../chunk-ZYEWTVNQ.js";
+import "../chunk-LN7CWLAU.js";
+import "../chunk-5PHOU5QI.js";
+import "../chunk-XPZM7GP6.js";
 import "../chunk-I74SUMNI.js";
 import "../chunk-ILNPU5W5.js";
-import "../chunk-5PHOU5QI.js";
-import "../chunk-HNF7IMYQ.js";
+import "../chunk-J72ZY7NU.js";
 import "../chunk-VZAKYDMJ.js";
-import "../chunk-THFSCUFC.js";
+import "../chunk-VSJ3ARFS.js";
 import "../chunk-666A3MOW.js";
 import "../chunk-VDC6RZI4.js";
 import "../chunk-UWK5OXUJ.js";
@@ -24,10 +26,10 @@ import "../chunk-TECVW3JP.js";
 import "../chunk-C5JF6EZ7.js";
 import "../chunk-KBL3JJR6.js";
 import "../chunk-RZN4LQ5Y.js";
-import "../chunk-XR4QR3JT.js";
+import "../chunk-LYOCAUI6.js";
 import "../chunk-5KBIOI4G.js";
 import "../chunk-V5OCT34X.js";
-import "../chunk-4BOBW6H4.js";
+import "../chunk-W4V7P5HP.js";
 import "../chunk-47DU4SGJ.js";
 import "../chunk-3Q3XD3NO.js";
 import "../chunk-ECZU5BJH.js";
@@ -69,9 +71,9 @@ import "../chunk-XXSOVESA.js";
 import "../chunk-PHRLJFWZ.js";
 import "../chunk-64NJRYU2.js";
 import "../chunk-OH7QLI6W.js";
-import "../chunk-VA3GNAWQ.js";
-import "../chunk-UJ2FP2RV.js";
-import "../chunk-FM6UKZAE.js";
+import "../chunk-LZIOY7ZU.js";
+import "../chunk-KY3KJUNN.js";
+import "../chunk-EQ6EMJRG.js";
 import "../chunk-54V4BZWP.js";
 import "../chunk-2CGLBUW3.js";
 import "../chunk-QT5MGENX.js";
@@ -100,7 +102,7 @@ import "../chunk-LUPVCGYK.js";
 import "../chunk-BUYVPUEM.js";
 import "../chunk-IAIPNEHD.js";
 import "../chunk-DGFU5MSX.js";
-import "../chunk-2BBMCMJS.js";
+import "../chunk-YPYSC3TX.js";
 import "../chunk-S57QBPTA.js";
 import "../chunk-GKUA4MGB.js";
 import "../chunk-WJ6S54ES.js";
@@ -113,15 +115,15 @@ import "../chunk-VEWZZM3H.js";
 import "../chunk-5IIQU4JZ.js";
 import "../chunk-PYIR4SSB.js";
 import "../chunk-7G5NTS7F.js";
-import "../chunk-TSZP7GGJ.js";
+import "../chunk-FGGLVCHI.js";
 import "../chunk-4NZQ7IID.js";
 import "../chunk-3I4FUAVJ.js";
-import "../chunk-OAKOAOEG.js";
+import "../chunk-QUPTDKSX.js";
+import "../chunk-54BGIBCR.js";
 import "../chunk-H4CKS5B2.js";
 import "../chunk-MMACM5G2.js";
-import "../chunk-54BGIBCR.js";
 import "../chunk-FXZTL7F7.js";
-import "../chunk-LYTKNK5O.js";
+import "../chunk-S37O4S6E.js";
 import "../chunk-BV2TIZ4F.js";
 import "../chunk-HDDRVXX4.js";
 import "../chunk-PYHOAXTI.js";
@@ -130,15 +132,15 @@ import "../chunk-OZKVVUJB.js";
 import "../chunk-2DL3OFLD.js";
 import "../chunk-G4IAEX6D.js";
 import "../chunk-2NLLXCJG.js";
-import "../chunk-UP6MOYCB.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-2YPIFJHL.js";
+import "../chunk-ICBUTKLL.js";
 import "../chunk-WHCD4Z3D.js";
 import "../chunk-YQJCWR4R.js";
 import "../chunk-7IGMKQWK.js";
@@ -146,24 +148,24 @@ import "../chunk-HSSERO3E.js";
 import "../chunk-NOUJNHWG.js";
 import "../chunk-I7TR2OCU.js";
 import "../chunk-2524MOWK.js";
-import "../chunk-ZS5LREUZ.js";
+import "../chunk-DC3DWF2M.js";
 import "../chunk-HL4DB7TO.js";
 import "../chunk-WLT6LTQP.js";
 import "../chunk-EOU6V4IN.js";
 import "../chunk-VHSQU3RO.js";
-import "../chunk-XDUP6SWG.js";
-import "../chunk-EIZ4MK33.js";
+import "../chunk-OGQGDOYK.js";
+import "../chunk-BTU77RB5.js";
 import "../chunk-HZNURRDS.js";
 import "../chunk-B2NXOVZN.js";
 import "../chunk-HDN7IVIO.js";
 import "../chunk-ADYP7HXE.js";
 import "../chunk-2LA3H54D.js";
-import "../chunk-MKMIY3E7.js";
-import "../chunk-MCFI6G7U.js";
+import "../chunk-UE5JYPU6.js";
+import "../chunk-QVZZE6VH.js";
 import "../chunk-KFY3SGN7.js";
 import "../chunk-CMTINOFS.js";
 import "../chunk-3T74IZB3.js";
-import "../chunk-3W37NITP.js";
+import "../chunk-IQXQ3KWR.js";
 import "../chunk-I6ORDT54.js";
 import "../chunk-BCCG7VWM.js";
 import "../chunk-GGRRF4PZ.js";
@@ -176,19 +178,19 @@ import "../chunk-YNDLCWXS.js";
 import "../chunk-AUDJPF4N.js";
 import "../chunk-44442YCH.js";
 import "../chunk-Y4Z4I6WK.js";
-import "../chunk-66PEACZP.js";
+import "../chunk-X4DHAXFO.js";
 import "../chunk-KJTKLXTH.js";
 import "../chunk-2DQ2XREU.js";
 import "../chunk-OKTXM5H4.js";
 import "../chunk-3ICAWZUU.js";
 import "../chunk-ZAJLJ35W.js";
-import "../chunk-MK7HXGM6.js";
+import "../chunk-6KBCUIZP.js";
 import "../chunk-5JMAGU26.js";
 import "../chunk-YBPYIAA5.js";
 import "../chunk-HK6KYIF6.js";
 import "../chunk-2GBFKHBZ.js";
 import "../chunk-6TBIWIAG.js";
-import "../chunk-VDYRXI3E.js";
+import "../chunk-EGKDONTC.js";
 import "../chunk-MPDLLLOG.js";
 import "../chunk-YN2DQ2D6.js";
 import "../chunk-MYVPLJOO.js";
@@ -232,7 +234,7 @@ import "../chunk-43HUVDTD.js";
 import "../chunk-4RA3C3EV.js";
 import "../chunk-B32WYRXX.js";
 import "../chunk-3NF4QUNZ.js";
-import "../chunk-64U42JL5.js";
+import "../chunk-LHMCZ6VW.js";
 import "../chunk-V7IZKJI3.js";
 import "../chunk-TB6CBZ5V.js";
 import "../chunk-XW2T4QAW.js";
@@ -246,29 +248,29 @@ import "../chunk-2TGIKMMZ.js";
 import "../chunk-SDESKFKT.js";
 import "../chunk-3HSRWJTC.js";
 import "../chunk-YIXWY4OZ.js";
-import "../chunk-I6HRHJRA.js";
-import "../chunk-YLMTFRZR.js";
+import "../chunk-QIOQI7QZ.js";
+import "../chunk-AGRMXXVA.js";
 import "../chunk-SRT6SHVZ.js";
-import "../chunk-SQO5SEKA.js";
+import "../chunk-PJAMFIDE.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-K47G2CBP.js";
-import "../chunk-2GV24KFD.js";
-import "../chunk-WIW4LOZL.js";
-import "../chunk-3AASGFR4.js";
-import "../chunk-YIG4HPY4.js";
-import "../chunk-J5TVHCDG.js";
-import "../chunk-DM3UZUCN.js";
+import "../chunk-USX5YIKB.js";
+import "../chunk-H2X32F2K.js";
+import "../chunk-AZNE2H6D.js";
+import "../chunk-7WFY2L5J.js";
+import "../chunk-VK5HKVQ7.js";
+import "../chunk-5ORJHH43.js";
+import "../chunk-WNQ3B3Q5.js";
 import "../chunk-7T4TOGMS.js";
 import "../chunk-7YQ6ESEA.js";
 import "../chunk-ZXF3O7P4.js";
-import "../chunk-MFKBYXBY.js";
-import "../chunk-K36RMINQ.js";
+import "../chunk-WYOHQJKC.js";
 import "../chunk-PQM3B54K.js";
+import "../chunk-K36RMINQ.js";
 import "../chunk-2RUTN7PR.js";
 import "../chunk-CEN6DW6X.js";
 import "../chunk-E4RMZGRS.js";
@@ -277,15 +279,15 @@ import "../chunk-2FLFJTCI.js";
 import "../chunk-JATHBCAV.js";
 import "../chunk-ZQUVBZI4.js";
 import "../chunk-5R627MYY.js";
-import "../chunk-5FMGPV34.js";
-import "../chunk-3F7N4I5I.js";
+import "../chunk-OWZXDBV4.js";
+import "../chunk-2R44BBPK.js";
 import "../chunk-AB3A7EFH.js";
 import "../chunk-KIUVEMBI.js";
-import "../chunk-BW33YTF3.js";
+import "../chunk-2WPWEVAH.js";
 import "../chunk-2BPPGNAQ.js";
 import "../chunk-DJSJ4ULL.js";
-import "../chunk-EF3HNVL4.js";
-import "../chunk-B7YAIHAV.js";
+import "../chunk-4PMFSYH7.js";
+import "../chunk-23BA3USG.js";
 import "../chunk-W4F3C7N7.js";
 import "../chunk-MPC7TYTZ.js";
 import "../chunk-2R7OCBRR.js";
@@ -293,7 +295,7 @@ import "../chunk-IFBSZGW3.js";
 import "../chunk-OGXXGHW6.js";
 import "../chunk-RJWL3RHB.js";
 import "../chunk-VQ7B2Q6M.js";
-import "../chunk-6QS5NQJH.js";
+import "../chunk-JGLZ46JS.js";
 import "../chunk-BANSBRNX.js";
 import "../chunk-JWX2Q6HS.js";
 import "../chunk-GNVZQ5JN.js";
@@ -316,7 +318,7 @@ import "../chunk-H7XKCNR6.js";
 import "../chunk-EWJZZDRG.js";
 import "../chunk-SOBJ6NEY.js";
 import "../chunk-7O2MC42R.js";
-import "../chunk-OX6GY22Q.js";
+import "../chunk-7P5VBRBS.js";
 import "../chunk-ENPJX3BB.js";
 import "../chunk-B6SPPYGJ.js";
 import "../chunk-UD7UNYRD.js";
@@ -324,7 +326,7 @@ import "../chunk-IISBCCWR.js";
 import "../chunk-BNU5TQLR.js";
 import "../chunk-WGRAB3KB.js";
 import "../chunk-2YA5N2BY.js";
-import "../chunk-MRN2MKB7.js";
+import "../chunk-JY4LXMZR.js";
 import "../chunk-HUDPXTXW.js";
 import "../chunk-AZEZSQ5R.js";
 import "../chunk-VPEIWMUT.js";
@@ -346,10 +348,10 @@ import "../chunk-WTWQA7BB.js";
 import "../chunk-LXATZLSC.js";
 import "../chunk-E3NBMTTX.js";
 import "../chunk-RF2SMMPP.js";
-import "../chunk-5VQSKBNF.js";
-import "../chunk-K7LLGCPH.js";
-import "../chunk-JGQEF33K.js";
-import "../chunk-D3AGBN6G.js";
+import "../chunk-U6IL4724.js";
+import "../chunk-GXAZ4Q2S.js";
+import "../chunk-ZBET3W26.js";
+import "../chunk-UAOJVQXC.js";
 import "../chunk-UFGFMWAD.js";
 import "../chunk-BFBS7OFQ.js";
 import "../chunk-QGJSBU4R.js";
@@ -358,10 +360,10 @@ import "../chunk-LXY5VVGM.js";
 import "../chunk-GKCXTSFF.js";
 import "../chunk-2LSZVONP.js";
 import "../chunk-ZY2MNJR6.js";
-import "../chunk-GT4G2S2Y.js";
+import "../chunk-BCBY5GYZ.js";
 import "../chunk-3UXOZBHV.js";
 import "../chunk-J6GZ2254.js";
-import "../chunk-LTST4R7U.js";
+import "../chunk-DE4U5PTV.js";
 import "../chunk-43FLJLT2.js";
 import "../chunk-CSAKJVXW.js";
 import "../chunk-K2XUWZBM.js";
@@ -371,7 +373,7 @@ import "../chunk-U4LUIE6Y.js";
 import "../chunk-T6OZW2WR.js";
 import "../chunk-5YQXWVCP.js";
 import "../chunk-QEDLJDHP.js";
-import "../chunk-GMSRLDVR.js";
+import "../chunk-N2Y6COEM.js";
 import "../chunk-X2KO4FK5.js";
 import "../chunk-GZFKCLRC.js";
 import "../chunk-EKUI7I2X.js";
@@ -391,14 +393,12 @@ import "../chunk-ZCUTSMR2.js";
 import "../chunk-QDW3E4RD.js";
 import "../chunk-6L63IN3M.js";
 import "../chunk-ZJP66Q4I.js";
-import {
-  selfDeps
-} from "../chunk-ILD7N3XC.js";
+import "../chunk-S73ZVU37.js";
 import "../chunk-QGVCFVX6.js";
 import "../chunk-UHVXE24Y.js";
 import "../chunk-IGOW4TJE.js";
-import "../chunk-ZOBYTRBU.js";
 import "../chunk-G6OFEGUR.js";
+import "../chunk-VNTQU6KB.js";
 import "../chunk-JEX2JL3U.js";
 import "../chunk-U2A56LLF.js";
 import "../chunk-DOJBV6WR.js";
@@ -452,9 +452,7 @@ import "../chunk-IUM3VSHI.js";
 import "../chunk-C64XATK7.js";
 import "../chunk-42JKGUFJ.js";
 import "../chunk-23G5P7TA.js";
-import {
-  describeError
-} from "../chunk-U7MIMS2Y.js";
+import "../chunk-OUBEJWVI.js";
 import "../chunk-AVVCPA7U.js";
 import "../chunk-I55KAVET.js";
 import "../chunk-L2EXJQJP.js";
@@ -571,213 +569,10 @@ import "../chunk-C7HJ3NEI.js";
 import "../chunk-VS2IYZRU.js";
 import "../chunk-KNA3BXXL.js";
 import "../chunk-NINSR6LX.js";
-import {
-  log
-} from "../chunk-3WCASNQZ.js";
+import "../chunk-3WCASNQZ.js";
 import "../chunk-PZ5AY32C.js";
-
-// src/orchestration/buffer-drain-runner.ts
-import { hostname } from "os";
-var DEFAULT_LEASE_MS = 12e4;
-var ClaimBufferStorage = class {
-  constructor(claims, key, ownerId, entry) {
-    this.claims = claims;
-    this.key = key;
-    this.ownerId = ownerId;
-    this.entry = entry;
-  }
-  claims;
-  key;
-  ownerId;
-  entry;
-  async loadBuffer() {
-    const entries = /* @__PURE__ */ Object.create(null);
-    entries[this.key] = {
-      turns: this.entry.turns,
-      retainedTurns: this.entry.retainedTurns,
-      lastExtractionAt: this.entry.lastExtractionAt,
-      extractionCount: this.entry.extractionCount
-    };
-    return {
-      turns: this.entry.turns,
-      lastExtractionAt: this.entry.lastExtractionAt,
-      extractionCount: this.entry.extractionCount,
-      entries
-    };
-  }
-  async saveBuffer(state) {
-    const entry = state.entries?.[this.key];
-    await this.claims.writeEntry(this.key, this.ownerId, entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 }, this.entry);
-  }
-  async saveBufferSession(key, entry) {
-    await this.claims.writeEntry(key, this.ownerId, entry, key === this.key ? this.entry : void 0);
-  }
-  async deleteBufferSession() {
-  }
-};
-var BufferDrainRunner = class {
-  constructor(orchestrator) {
-    this.orchestrator = orchestrator;
-  }
-  orchestrator;
-  /** The claim store of this orchestrator's memory root. */
-  get claims() {
-    return this.orchestrator.storage.bufferDrainClaims();
-  }
-  /**
-   * Drain one claimed session. The caller owns the lease (it may have taken
-   * it already); this method verifies ownership before touching content.
-   */
-  async drainSession(key, options) {
-    const claims = this.claims;
-    const leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
-    const lease = {
-      ownerId: options.ownerId,
-      pid: process.pid,
-      host: hostname(),
-      acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      heartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
-      leaseMs
-    };
-    const claim = await claims.load(key);
-    if (!claim) {
-      return { key, status: "skipped", turnsAtStart: 0, turnsRemaining: 0, persistedCount: 0, durableOutputCount: 0, reason: "not_claimed" };
-    }
-    const turnsAtStart = claim.entry.turns.length + (claim.entry.retainedTurns?.length ?? 0);
-    options.onEvent?.({ type: "session_started", key, turns: turnsAtStart });
-    const held = await claims.adopt(key, lease);
-    if (held === "busy") {
-      const outcome2 = {
-        key,
-        status: "skipped",
-        turnsAtStart,
-        turnsRemaining: turnsAtStart,
-        persistedCount: 0,
-        durableOutputCount: 0,
-        reason: "claimed_by_another_drain"
-      };
-      options.onEvent?.({ type: "session_finished", key, outcome: outcome2 });
-      return outcome2;
-    }
-    const claimStorage = new ClaimBufferStorage(claims, key, options.ownerId, claim.entry);
-    const coordinator = new TurnIngestionCoordinator(selfDeps(this.orchestrator));
-    const turns = [...claim.entry.retainedTurns ?? [], ...claim.entry.turns];
-    if (turns.length === 0) {
-      await claims.ack(key, options.ownerId);
-      const outcome2 = {
-        key,
-        status: "drained",
-        turnsAtStart,
-        turnsRemaining: 0,
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
-      options.onEvent?.({ type: "session_finished", key, outcome: outcome2 });
-      return outcome2;
-    }
-    const abort = new AbortController();
-    const signal = options.signal ? AbortSignal.any([options.signal, abort.signal]) : abort.signal;
-    const heartbeat = setInterval(() => {
-      void claims.heartbeat(key, options.ownerId, leaseMs).then((state) => {
-        if (state === "lost") abort.abort(new Error(`buffer drain: lease lost for session ${key}`));
-      }).catch((err) => {
-        abort.abort(new Error(`buffer drain: lease heartbeat failed for session ${key}: ${describeError(err)}`));
-      });
-    }, Math.max(1e3, Math.floor(leaseMs / 3)));
-    heartbeat.unref?.();
-    const settledResult = await this.orchestrator.withBufferStorage(claimStorage, async () => {
-      const swapTurns = this.orchestrator.buffer.getTurns(key);
-      const { promise, resolve } = Promise.withResolvers();
-      let settled = false;
-      void coordinator.queueBufferedExtraction(swapTurns, "trigger_mode", {
-        bufferKey: key,
-        clearBufferAfterExtraction: true,
-        // The drain owns this session's content: the daemon's own dedupe
-        // gate must not skip it, and the thresholds do not apply to a
-        // backlog.
-        skipDedupeCheck: true,
-        skipCharThreshold: true,
-        skipUserTurnThreshold: true,
-        abortSignal: signal,
-        onTaskSettled: (error, result2) => {
-          if (settled) return;
-          settled = true;
-          resolve({ error, result: result2 });
-        }
-      }).catch((error) => {
-        if (settled) return;
-        settled = true;
-        resolve({ error });
-      });
-      return await promise;
-    });
-    clearInterval(heartbeat);
-    const remaining = await claims.load(key);
-    const turnsRemaining = remaining ? remaining.entry.turns.length + (remaining.entry.retainedTurns?.length ?? 0) : 0;
-    const result = settledResult.result;
-    const persistedCount = result?.persistedCount ?? 0;
-    const durableOutputCount = result?.durableOutputCount ?? 0;
-    let status;
-    let reason;
-    if (turnsRemaining === 0) {
-      await claims.ack(key, options.ownerId);
-      status = "drained";
-    } else if (settledResult.error) {
-      await claims.releaseLease(key, options.ownerId);
-      status = "failed";
-      reason = describeError(settledResult.error);
-    } else {
-      await claims.releaseLease(key, options.ownerId);
-      status = "deferred";
-      reason = result?.reason ?? "deferred";
-    }
-    log.info(
-      `buffer drain: session ${key} ${status} (${turnsRemaining} turn(s) remaining)`
-    );
-    const outcome = {
-      key,
-      status,
-      turnsAtStart,
-      turnsRemaining,
-      persistedCount,
-      durableOutputCount
-    };
-    if (reason !== void 0) outcome.reason = reason;
-    options.onEvent?.({ type: "session_finished", key, outcome });
-    return outcome;
-  }
-  /** Claim a session file for the drain. Returns false when it is not claimable. */
-  async claim(key, ownerId, leaseMs = DEFAULT_LEASE_MS) {
-    const lease = {
-      ownerId,
-      pid: process.pid,
-      host: hostname(),
-      acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      heartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
-      leaseMs
-    };
-    return await this.claims.claimFromSessionFile(key, lease) === "claimed";
-  }
-  /** Sessions with buffered turns, claimed or not (CLI scan). */
-  async scan() {
-    const sessions = await this.orchestrator.storage.loadBuffer();
-    const entries = sessions.entries ?? {};
-    const out = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const [key, entry] of Object.entries(entries)) {
-      seen.add(key);
-      const claim = this.claims.isClaimed(key) ? await this.claims.load(key) : null;
-      const turns = claim ? claim.entry.turns.length + (claim.entry.retainedTurns?.length ?? 0) : entry.turns.length + (entry.retainedTurns?.length ?? 0);
-      out.push({ key, turns, claimed: claim !== null });
-    }
-    for (const listed of await this.claims.list()) {
-      if (seen.has(listed.key)) continue;
-      out.push({ key: listed.key, turns: listed.turnCount, claimed: true });
-    }
-    return out;
-  }
-};
 export {
-  BufferDrainRunner
+  BufferDrainRunner,
+  ClaimBufferStorage
 };
 //# sourceMappingURL=buffer-drain-runner.js.map

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":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/orchestration/extraction-drain.d.ts

@@ -1,11 +1,4 @@
-/**
- * Chunked trigger-drain for the extraction pipeline.
- *
- * Split out of `turn-ingestion.ts`: that file is at the structural ratchet's
- * line cap (issue #1995), and the drain is a self-contained unit — it only
- * needs the host's `runExtraction`, the buffer drop, the storage side-file
- * copy and the preemption hook.
- */
+/** Chunked trigger-drain for the extraction pipeline. */
 import type { BufferTurn } from "../types.js";
 import type { ExtractionPreemptHandle } from "./extraction-queue-coordinator.js";
 import type { ExtractionRunCoordinator, ExtractionRunResult } from "./extraction-run.js";
@@ -27,6 +20,8 @@ export interface ExtractionDrainDeps {
         extractionChunkDropAfterFailures: number;
     };
     extractionWindowBudgetChars?(): number;
+    /** Rendered-size oracle: the exact character count the extraction renderer */
+    measureRenderedTurns?(turns: readonly BufferTurn[]): number;
     runExtraction(turns: BufferTurn[], options: RunOptions): Promise<ExtractionRunResult>;
     getStorage(): Promise<{
         saveDroppedExtractionChunk(bufferKey: string, reason: string, turns: readonly BufferTurn[]): Promise<string>;
@@ -38,14 +33,7 @@ export interface ExtractionDrainDeps {
     };
 }
 export declare class ExtractionDrain {
-    private readonly deps;
-    /**
-     * Consecutive failed attempts on the head chunk, per buffer key. In memory on
-     * purpose (a restart re-counts from zero). Bound to the chunk's content: a
-     * count recorded for one chunk never applies to a different one, so a force
-     * flush that clears a failing chunk cannot make unrelated content inherit its
-     * failures.
-     */
+    /** Consecutive failed attempts on the head chunk, per buffer key. In memory on */
     private readonly failures;
     /**
      * Buffer key to the first turn of the chunk a qualified window stopped on.
@@ -55,7 +43,12 @@ export declare class ExtractionDrain {
      * window drains; one entry per key.
      */
     private readonly qualified;
-    constructor(deps: ExtractionDrainDeps);
+    /** The claim drain runs with `dropFailedChunks: false`: a chunk that keeps */
+    private readonly dropFailedChunks;
+    private readonly deps;
+    constructor(deps: ExtractionDrainDeps, options?: {
+        dropFailedChunks?: boolean;
+    });
     /** Characters the coordinator would count for this window: user/assistant text, trimmed and capped per turn, context-only turns left out. */
     private windowChars;
     private failureCount;
@@ -82,9 +75,49 @@ export declare class ExtractionDrain {
      * concurrent automatic extractions cannot clobber each other's registration).
      */
     run(turns: BufferTurn[], runOptions: DrainRunOptions, preemptable?: boolean, preemptHandle?: ExtractionPreemptHandle): Promise<ExtractionRunResult>;
+    /** Chunking plan for one trigger-drain window. Accepted-capture groups */
+    private chunkPlan;
+    /** Automatic chunking needs a clearable window, no fail-closed/forced
+     *  caller, and a real budget to chunk against. */
+    private chunkable;
+    /** A native group clears its turns by identity (a pinned capture can sit
+     *  in front); a drop must find them the same way. */
+    private identityCleared;
+    /** Eligibility (minimum user turns and characters) belongs to the whole
+     *  window: a window that never qualified keeps the single-run path, which
+     *  judges it exactly as before. */
+    private windowBelowThreshold;
+    /** The window qualified as a whole; its chunks must not be re-judged one by
+     *  one (an assistant-only or short chunk would be cleared unextracted). */
+    private runChunked;
+    /** retention replaces theirs (retained turns do not pile up across chunks) */
+    private chunkOptionsFor;
+    /** A chunk-local abort controller so a fail-closed flush can abort the
+     *  next chunk instead of waiting behind the whole window. */
+    private armChunkPreempt;
+    /** An abort error is rethrown (the chunk-local abort leaves the outer
+     *  signal untouched, so the host gets the preemption reason it looks for,
+     *  as it does for the first chunk). */
+    private rethrowChunkAbort;
+    /** A chunk whose extraction THREW: count the failure; below the drop
+     *  threshold (or on a no-drop drain) rethrow so the window is retained;
+     *  at the threshold a chunk that keeps throwing is dropped like one that
+     *  keeps failing, so later chunks are not stuck behind it. */
+    private settleThrownChunk;
+    /** Map one chunk result to the drain-loop action: drained chunks continue
+     *  to the next chunk; breaker/backoff retention and provider faults keep
+     *  everything for retry without counting a chunk failure. */
+    private settleVerdict;
+    /** (live drains, recovery copy first) or keep it as durable retryable */
+    private settleFailedChunk;
+    /** Greedy chunking sized by the RENDERED conversation (the oracle the model */
+    private chunkByRenderedSize;
     /** Side-file copy first (content survives a failed drop), then remove the failing chunk from the buffer. Never throws:
      *  the drop must not fail the extraction task that already settled its result. */
     private dropFailedChunk;
+    /** The recovery side-file copy for a dropped chunk. null = the copy could
+     *  not be written — the caller must keep the only buffered copy. */
+    private saveRecoveryCopy;
 }
 export {};
 //# sourceMappingURL=extraction-drain.d.ts.map