@remnic/core 10.0.69 → 10.0.71

package/dist/chunk-ZODKV27J.js

@@ -0,0 +1,443 @@
+import {
+  ExtractionDrain,
+  TurnIngestionCoordinator
+} from "./chunk-DSSTOV5M.js";
+import {
+  headerConnector,
+  renderExtractionConversation,
+  resolveSourceConnector
+} from "./chunk-EQ6EMJRG.js";
+import {
+  SmartBuffer
+} from "./chunk-EGKDONTC.js";
+import {
+  shouldSkipImplicitExtraction
+} from "./chunk-RZH5RVJC.js";
+import {
+  selfDeps
+} from "./chunk-S73ZVU37.js";
+import {
+  describeError,
+  groupTurnsByExtractionScope
+} from "./chunk-OUBEJWVI.js";
+import {
+  resolveMemoryLifecycleCapabilities
+} from "./chunk-C5LWPYS3.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/orchestration/buffer-drain-runner.ts
+import { hostname } from "os";
+var DENIED_SCOPE_REASONS = /* @__PURE__ */ new Set([
+  "pinned_namespace_unavailable",
+  "namespace_write_revoked",
+  "scope_profile_revoked",
+  // The resolved profile has no writable layer: the same current-policy
+  // refusal family, surfaced from inside the shared runExtraction gate.
+  "scope_profile_no_writable_layer",
+  // captureMode=explicit: ordinary buffered conversation turns never create
+  // memories; only deliberately accepted captures drain.
+  "capture_mode_explicit"
+]);
+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() {
+  }
+};
+function pendingTurnCount(entry) {
+  if (!entry) return 0;
+  return entry.turns.length + (entry.retainedTurns?.length ?? 0);
+}
+async function loadClaimedSession(claims, key) {
+  const claim = await claims.load(key);
+  if (!claim) {
+    return {
+      kind: "notClaimed",
+      notClaimed: {
+        key,
+        status: "skipped",
+        turnsAtStart: 0,
+        turnsRemaining: 0,
+        persistedCount: 0,
+        durableOutputCount: 0,
+        reason: "not_claimed"
+      }
+    };
+  }
+  return { kind: "claimed", claim, turnsAtStart: pendingTurnCount(claim.entry) };
+}
+function busyLeaseOutcome(key, turnsAtStart) {
+  return {
+    key,
+    status: "skipped",
+    turnsAtStart,
+    turnsRemaining: turnsAtStart,
+    persistedCount: 0,
+    durableOutputCount: 0,
+    reason: "claimed_by_another_drain"
+  };
+}
+async function adoptLease(claims, key, ownerId, leaseMs) {
+  const held = await claims.adopt(key, {
+    ownerId,
+    pid: process.pid,
+    host: hostname(),
+    acquiredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    heartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+    leaseMs
+  });
+  return held === "busy" ? busyLeaseOutcome(key, pendingTurnCount((await claims.load(key))?.entry)) : null;
+}
+function assembleOutcome(key, turnsAtStart, verdict, counts, denied) {
+  const outcome = {
+    key,
+    status: verdict.status,
+    turnsAtStart,
+    turnsRemaining: verdict.turnsRemaining,
+    persistedCount: counts.persistedCount,
+    durableOutputCount: counts.durableOutputCount
+  };
+  if (denied.size > 0) outcome.denied = [...denied].map(([deniedReason, turns]) => ({ reason: deniedReason, turns }));
+  if (verdict.reason !== void 0) outcome.reason = verdict.reason;
+  return outcome;
+}
+async function ackEmptyClaim(claims, key, ownerId, turnsAtStart) {
+  const ackOutcome = await claims.ack(key, ownerId);
+  if (ackOutcome !== "acked") {
+    const reloaded = await claims.load(key);
+    const turnsRemaining = pendingTurnCount(reloaded?.entry);
+    await claims.releaseLease(key, ownerId);
+    return {
+      key,
+      status: "deferred",
+      turnsAtStart,
+      turnsRemaining,
+      persistedCount: 0,
+      durableOutputCount: 0,
+      reason: ackOutcome === "not_empty" ? "ack_not_empty" : "ack_not_owner"
+    };
+  }
+  return { key, status: "drained", turnsAtStart, turnsRemaining: 0, persistedCount: 0, durableOutputCount: 0 };
+}
+function startLeaseHeartbeat(claims, key, ownerId, leaseMs, abort) {
+  const heartbeat = setInterval(
+    () => {
+      void claims.heartbeat(key, 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?.();
+  return heartbeat;
+}
+function buildClaimExecution(orchestrator, claims, key, ownerId, claim) {
+  const claimBuffer = new SmartBuffer(orchestrator.config, new ClaimBufferStorage(claims, key, ownerId, claim.entry));
+  const isolatedRun = orchestrator.extractionRunCoordinatorForBuffer(claimBuffer);
+  const coordinator = new TurnIngestionCoordinator(selfDeps(orchestrator));
+  const config = orchestrator.config;
+  const ingestionDeps = selfDeps(orchestrator);
+  const executionDrain = new ExtractionDrain(
+    {
+      config: {
+        extractionMinUserTurns: config.extractionMinUserTurns,
+        extractionMinChars: config.extractionMinChars,
+        extractionMaxTurnChars: config.extractionMaxTurnChars,
+        extractionChunkDropAfterFailures: config.extractionChunkDropAfterFailures
+      },
+      extractionWindowBudgetChars: () => ingestionDeps.extractionWindowBudgetChars?.() ?? Number.POSITIVE_INFINITY,
+      // Render-exact chunk sizing: the model clamp bounds the CONVERSATION
+      // (truncateLocalExtractionConversation), so measure exactly that —
+      // with the SAME source-classification gate extract() applies when it
+      // prepends the connector header (header margin included when the
+      // engine would render it).
+      measureRenderedTurns: (turns) => {
+        const sourceConnector = resolveMemoryLifecycleCapabilities(config).extractionScopeClassification ? resolveSourceConnector(turns) : void 0;
+        return renderExtractionConversation(
+          turns.map((turn) => ({ ...turn, content: turn.content.trim().slice(0, config.extractionMaxTurnChars) })),
+          headerConnector(sourceConnector)
+        ).conversation.length;
+      },
+      runExtraction: (turns, runOptions) => isolatedRun.runExtraction(turns, runOptions),
+      getStorage: () => ingestionDeps.getStorage(),
+      buffer: claimBuffer
+    },
+    { dropFailedChunks: false }
+  );
+  return { claimBuffer, coordinator, executionDrain };
+}
+function planOptionForGroup(group) {
+  if (group.scopeProfileWritePlan !== void 0) return { scopeProfileWritePlan: group.scopeProfileWritePlan };
+  if (group.turns.some((turn) => turn.acceptedCapture === true)) return { scopeProfileWritePlan: null };
+  return {};
+}
+function explicitModeDenied(group, config) {
+  return shouldSkipImplicitExtraction(config) && !group.turns.some((turn) => turn.acceptedCapture === true);
+}
+async function drainScopeGroups(ctx) {
+  const groupOutcomes = [];
+  let groupError;
+  for (const group of groupTurnsByExtractionScope(ctx.turns)) {
+    if (ctx.signal.aborted) break;
+    if (explicitModeDenied(group, ctx.config)) {
+      log.warn(
+        `buffer drain: session ${ctx.key} denied capture_mode_explicit (${group.turns.length} ordinary turn(s) retained)`
+      );
+      groupOutcomes.push({
+        turns: group.turns.length,
+        result: { status: "skipped", reason: "capture_mode_explicit", persistedCount: 0, durableOutputCount: 0 }
+      });
+      continue;
+    }
+    const settleGate = Promise.withResolvers();
+    let done = false;
+    const onSettle = (cause, result) => {
+      if (done) return;
+      done = true;
+      settleGate.resolve({ cause, result });
+    };
+    const exited = Promise.withResolvers();
+    void ctx.coordinator.queueBufferedExtraction(group.turns, "trigger_mode", {
+      bufferKey: ctx.key,
+      clearBufferAfterExtraction: true,
+      clearMatchingTurns: true,
+      skipDedupeCheck: true,
+      skipCharThreshold: true,
+      skipUserTurnThreshold: true,
+      // Automatic background work yields to fail-closed foreground flushes
+      // (preemptRunning), same as the live trigger path.
+      preemptable: true,
+      abortSignal: ctx.signal,
+      writeNamespaceOverride: group.writeNamespaceOverride,
+      principalOverride: group.principalOverride,
+      ...planOptionForGroup(group),
+      execution: { buffer: ctx.claimBuffer, drain: ctx.executionDrain },
+      onTaskSettled: (error, result) => settleGate.resolve({ cause: error, result }),
+      onTaskExit: () => exited.resolve()
+    }).catch((cause) => onSettle(cause));
+    const [verdict] = await Promise.all([settleGate.promise, exited.promise]);
+    const settled = verdict;
+    if (settled.cause !== void 0) {
+      groupError = settled.cause;
+      break;
+    }
+    groupOutcomes.push({ turns: group.turns.length, result: settled.result });
+  }
+  return { groupOutcomes, groupError };
+}
+function deniedByReason(groupOutcomes) {
+  const denied = /* @__PURE__ */ new Map();
+  for (const entry of groupOutcomes) {
+    if (entry.result?.status !== "skipped" || !DENIED_SCOPE_REASONS.has(entry.result.reason ?? "")) continue;
+    denied.set(entry.result.reason, (denied.get(entry.result.reason) ?? 0) + entry.turns);
+  }
+  return denied;
+}
+function lastGroupReason(groupOutcomes) {
+  for (let index = groupOutcomes.length - 1; index >= 0; index -= 1) {
+    const reason = groupOutcomes[index]?.result?.reason;
+    if (reason !== void 0) return reason;
+  }
+  return void 0;
+}
+async function settleDrainVerdict(claims, key, ownerId, groupOutcomes, groupError, turnsRemaining) {
+  if (turnsRemaining === 0) return await ackOrReload(claims, key, ownerId);
+  if (groupError) {
+    await claims.releaseLease(key, ownerId);
+    return { status: "failed", reason: describeError(groupError), turnsRemaining };
+  }
+  await claims.releaseLease(key, ownerId);
+  const reason = groupOutcomes.find((entry) => entry.result?.reason !== void 0 && DENIED_SCOPE_REASONS.has(entry.result.reason))?.result?.reason ?? lastGroupReason(groupOutcomes) ?? "deferred";
+  return { status: "deferred", reason, turnsRemaining };
+}
+async function ackOrReload(claims, key, ownerId) {
+  const ackOutcome = await claims.ack(key, ownerId);
+  if (ackOutcome === "acked") return { status: "drained", turnsRemaining: 0 };
+  const reloaded = await claims.load(key);
+  const turnsRemaining = pendingTurnCount(reloaded?.entry);
+  await claims.releaseLease(key, ownerId);
+  return { status: "deferred", reason: ackOutcome === "not_empty" ? "ack_not_empty" : "ack_not_owner", turnsRemaining };
+}
+function groupCounts(groupOutcomes) {
+  return {
+    persistedCount: groupOutcomes.reduce((sum, entry) => sum + (entry.result?.persistedCount ?? 0), 0),
+    durableOutputCount: groupOutcomes.reduce((sum, entry) => sum + (entry.result?.durableOutputCount ?? 0), 0)
+  };
+}
+async function bufferSessionListings(claims, entries) {
+  const listings = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, entry] of Object.entries(entries)) {
+    seen.add(key);
+    const claim = claims.isClaimed(key) ? await claims.load(key) : null;
+    listings.push({
+      key,
+      turns: claim ? pendingTurnCount(claim.entry) : pendingTurnCount(entry),
+      claimed: claim !== null
+    });
+  }
+  return { listings, seen };
+}
+async function orphanClaimListings(claims, seen) {
+  const out = [];
+  for (const listed of await claims.list()) {
+    if (seen.has(listed.key)) continue;
+    out.push({ key: listed.key, turns: listed.turnCount, claimed: true });
+  }
+  return out;
+}
+function drainAbortSignal(callerSignal, abort) {
+  return callerSignal ? AbortSignal.any([callerSignal, abort.signal]) : abort.signal;
+}
+async function runClaimDrain(ctx, options, heartbeat) {
+  if (ctx.turns.length === 0) {
+    const outcome2 = await ackEmptyClaim(ctx.claims, ctx.key, ctx.ownerId, ctx.turnsAtStart);
+    options.onEvent?.({ type: "session_finished", key: ctx.key, outcome: outcome2 });
+    return outcome2;
+  }
+  const { groupOutcomes, groupError } = await drainScopeGroups(ctx);
+  const remaining = await ctx.claims.load(ctx.key);
+  const { status, reason, turnsRemaining } = await settleDrainVerdict(
+    ctx.claims,
+    ctx.key,
+    ctx.ownerId,
+    groupOutcomes,
+    groupError,
+    pendingTurnCount(remaining?.entry)
+  );
+  const outcome = assembleOutcome(
+    ctx.key,
+    ctx.turnsAtStart,
+    { status, reason, turnsRemaining },
+    groupCounts(groupOutcomes),
+    deniedByReason(groupOutcomes)
+  );
+  log.info(`buffer drain: session ${ctx.key} ${status} (${outcome.turnsRemaining} turn(s) remaining)`);
+  options.onEvent?.({ type: "session_finished", key: ctx.key, outcome });
+  return outcome;
+}
+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 claimed = await loadClaimedSession(claims, key);
+    if (claimed.kind === "notClaimed") return claimed.notClaimed;
+    const { claim, turnsAtStart } = claimed;
+    options.onEvent?.({ type: "session_started", key, turns: turnsAtStart });
+    const busy = await adoptLease(claims, key, options.ownerId, leaseMs);
+    if (busy !== null) {
+      const outcome = busy;
+      options.onEvent?.({ type: "session_finished", key, outcome });
+      return outcome;
+    }
+    const { claimBuffer, coordinator, executionDrain } = buildClaimExecution(
+      this.orchestrator,
+      claims,
+      key,
+      options.ownerId,
+      claim
+    );
+    await claimBuffer.load();
+    const turns = [...claim.entry.retainedTurns ?? [], ...claim.entry.turns];
+    const abort = new AbortController();
+    const signal = drainAbortSignal(options.signal, abort);
+    const heartbeat = startLeaseHeartbeat(claims, key, options.ownerId, leaseMs, abort);
+    try {
+      return await runClaimDrain(
+        {
+          orchestrator: this.orchestrator,
+          claims,
+          key,
+          ownerId: options.ownerId,
+          claimBuffer,
+          coordinator,
+          executionDrain,
+          turns,
+          turnsAtStart,
+          config: this.orchestrator.config,
+          signal
+        },
+        options,
+        heartbeat
+      );
+    } finally {
+      clearInterval(heartbeat);
+    }
+  }
+  /** 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 { listings, seen } = await bufferSessionListings(this.claims, sessions.entries ?? {});
+    return [...listings, ...await orphanClaimListings(this.claims, seen)];
+  }
+};
+
+export {
+  ClaimBufferStorage,
+  BufferDrainRunner
+};
+//# sourceMappingURL=chunk-ZODKV27J.js.map

package/dist/chunk-ZODKV27J.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/orchestration/buffer-drain-runner.ts"],"sourcesContent":["/** Claim-backed extraction-buffer drain (`remnic buffer drain` worker AND the */\n\nimport { hostname } from \"node:os\";\nimport type { BufferStorage } from \"../buffer-persistence.js\";\nimport { type ExtractionScopeGroup, describeError, groupTurnsByExtractionScope } from \"../buffer-turn-helpers.js\";\nimport { SmartBuffer } from \"../buffer.js\";\nimport { resolveMemoryLifecycleCapabilities } from \"../capabilities.js\";\nimport { shouldSkipImplicitExtraction } from \"../explicit-capture.js\";\nimport { log } from \"../logger.js\";\nimport type { ResolvedScopeProfilePlan } from \"../namespaces/scope-profiles.js\";\nimport type { Orchestrator } from \"../orchestrator.js\";\nimport { headerConnector, renderExtractionConversation, resolveSourceConnector } from \"../source-agent-qualifier.js\";\nimport type { BufferDrainClaims, DrainLease } from \"../storage/buffer-drain-claims.js\";\nimport type { BufferEntryState, BufferState, BufferTurn, PluginConfig } from \"../types.js\";\nimport { ExtractionDrain } from \"./extraction-drain.js\";\nimport type { ExtractionRunResult } from \"./extraction-run.js\";\nimport { selfDeps } from \"./self-deps.js\";\nimport { TurnIngestionCoordinator, type TurnIngestionDeps } from \"./turn-ingestion.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  /** Current-policy denials: scope groups whose authorization no longer holds. */\n  denied?: { reason: string; turns: number }[];\n}\n\n/** Extraction results that mean \"current policy refuses this scope\": the\n * turns are valid backlog whose captured scope is no longer writable. */\nconst DENIED_SCOPE_REASONS: ReadonlySet<string> = new Set([\n  \"pinned_namespace_unavailable\",\n  \"namespace_write_revoked\",\n  \"scope_profile_revoked\",\n  // The resolved profile has no writable layer: the same current-policy\n  // refusal family, surfaced from inside the shared runExtraction gate.\n  \"scope_profile_no_writable_layer\",\n  // captureMode=explicit: ordinary buffered conversation turns never create\n  // memories; only deliberately accepted captures drain.\n  \"capture_mode_explicit\",\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 */\nexport class 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(\n      this.key,\n      this.ownerId,\n      entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 },\n      this.entry\n    );\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\n/** Per-invocation isolated execution context for one claim drain. */\ninterface ClaimDrainExecution {\n  claimBuffer: SmartBuffer;\n  coordinator: TurnIngestionCoordinator;\n  executionDrain: ExtractionDrain;\n}\n\n/** The scopeProfileWritePlan option a scope group forwards to the queue. */\ninterface GroupPlanOption {\n  scopeProfileWritePlan?: ResolvedScopeProfilePlan | null;\n}\n\n/** Durable counters a drain pass contributed. */\ninterface GroupCounts {\n  persistedCount: number;\n  durableOutputCount: number;\n}\n\n/** Pending turns across canonical + retained copies (the honest backlog count). */\nfunction pendingTurnCount(entry: BufferEntryState | undefined): number {\n  if (!entry) return 0;\n  return entry.turns.length + (entry.retainedTurns?.length ?? 0);\n}\n\n/** Load one claimed session. An unclaimed key is nothing to drain. */\nasync function loadClaimedSession(\n  claims: BufferDrainClaims,\n  key: string\n): Promise<\n  | { kind: \"notClaimed\"; notClaimed: DrainSessionOutcome }\n  | { kind: \"claimed\"; claim: { entry: BufferEntryState }; turnsAtStart: number }\n> {\n  const claim = await claims.load(key);\n  if (!claim) {\n    return {\n      kind: \"notClaimed\",\n      notClaimed: {\n        key,\n        status: \"skipped\",\n        turnsAtStart: 0,\n        turnsRemaining: 0,\n        persistedCount: 0,\n        durableOutputCount: 0,\n        reason: \"not_claimed\",\n      },\n    };\n  }\n  return { kind: \"claimed\", claim, turnsAtStart: pendingTurnCount(claim.entry) };\n}\n\nfunction busyLeaseOutcome(key: string, turnsAtStart: number): DrainSessionOutcome {\n  return {\n    key,\n    status: \"skipped\",\n    turnsAtStart,\n    turnsRemaining: turnsAtStart,\n    persistedCount: 0,\n    durableOutputCount: 0,\n    reason: \"claimed_by_another_drain\",\n  };\n}\n\n/** Take the lease unless this drainer already holds it. A busy lease means\n *  another drainer owns the claim — skip without touching content. */\nasync function adoptLease(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  leaseMs: number\n): Promise<DrainSessionOutcome | null> {\n  const held = await claims.adopt(key, {\n    ownerId,\n    pid: process.pid,\n    host: hostname(),\n    acquiredAt: new Date().toISOString(),\n    heartbeatAt: new Date().toISOString(),\n    leaseMs,\n  });\n  return held === \"busy\" ? busyLeaseOutcome(key, pendingTurnCount((await claims.load(key))?.entry)) : null;\n}\n\nfunction assembleOutcome(\n  key: string,\n  turnsAtStart: number,\n  verdict: { status: DrainSessionStatus; reason?: string; turnsRemaining: number },\n  counts: { persistedCount: number; durableOutputCount: number },\n  denied: Map<string, number>\n): DrainSessionOutcome {\n  const outcome: DrainSessionOutcome = {\n    key,\n    status: verdict.status,\n    turnsAtStart,\n    turnsRemaining: verdict.turnsRemaining,\n    persistedCount: counts.persistedCount,\n    durableOutputCount: counts.durableOutputCount,\n  };\n  if (denied.size > 0) outcome.denied = [...denied].map(([deniedReason, turns]) => ({ reason: deniedReason, turns }));\n  if (verdict.reason !== undefined) outcome.reason = verdict.reason;\n  return outcome;\n}\n\n/** Ack an EMPTY claim. The ack verdict is the truth: live ingress can merge\n *  between the empty read and the ack — a not_empty ack means pending work\n *  exists; reload it, release OUR lease, report deferred, never a false\n *  drained. */\nasync function ackEmptyClaim(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  turnsAtStart: number\n): Promise<DrainSessionOutcome> {\n  const ackOutcome = await claims.ack(key, ownerId);\n  if (ackOutcome !== \"acked\") {\n    const reloaded = await claims.load(key);\n    const turnsRemaining = pendingTurnCount(reloaded?.entry);\n    await claims.releaseLease(key, ownerId);\n    return {\n      key,\n      status: \"deferred\",\n      turnsAtStart,\n      turnsRemaining,\n      persistedCount: 0,\n      durableOutputCount: 0,\n      reason: ackOutcome === \"not_empty\" ? \"ack_not_empty\" : \"ack_not_owner\",\n    };\n  }\n  return { key, status: \"drained\", turnsAtStart, turnsRemaining: 0, persistedCount: 0, durableOutputCount: 0 };\n}\n\n/** another drainer took the claim, so this run must stop instead of writing */\nfunction startLeaseHeartbeat(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  leaseMs: number,\n  abort: AbortController\n): NodeJS.Timeout {\n  const heartbeat = setInterval(\n    () => {\n      void claims\n        .heartbeat(key, 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 held:\n          // stop this run cleanly at the next chunk boundary (the next run\n          // resumes it).\n          abort.abort(new Error(`buffer drain: lease heartbeat failed for session ${key}: ${describeError(err)}`));\n        });\n    },\n    Math.max(1_000, Math.floor(leaseMs / 3))\n  );\n  heartbeat.unref?.();\n  return heartbeat;\n}\n\n/** coordinator bound to it, and the no-drop chunked drain. Built per */\nfunction buildClaimExecution(\n  orchestrator: Orchestrator,\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  claim: { entry: BufferEntryState }\n): ClaimDrainExecution {\n  const claimBuffer = new SmartBuffer(orchestrator.config, new ClaimBufferStorage(claims, key, ownerId, claim.entry));\n  const isolatedRun = orchestrator.extractionRunCoordinatorForBuffer(claimBuffer);\n  const coordinator = new TurnIngestionCoordinator(selfDeps<TurnIngestionDeps>(orchestrator));\n  const config = orchestrator.config;\n  const ingestionDeps = selfDeps<TurnIngestionDeps>(orchestrator);\n  // No-drop: a repeatedly failing chunk stays in the claim as durable\n  // retryable backlog — never side-filed, never counted as processed.\n  const executionDrain = new ExtractionDrain(\n    {\n      config: {\n        extractionMinUserTurns: config.extractionMinUserTurns,\n        extractionMinChars: config.extractionMinChars,\n        extractionMaxTurnChars: config.extractionMaxTurnChars,\n        extractionChunkDropAfterFailures: config.extractionChunkDropAfterFailures,\n      },\n      extractionWindowBudgetChars: () => ingestionDeps.extractionWindowBudgetChars?.() ?? Number.POSITIVE_INFINITY,\n      // Render-exact chunk sizing: the model clamp bounds the CONVERSATION\n      // (truncateLocalExtractionConversation), so measure exactly that —\n      // with the SAME source-classification gate extract() applies when it\n      // prepends the connector header (header margin included when the\n      // engine would render it).\n      measureRenderedTurns: (turns) => {\n        const sourceConnector = resolveMemoryLifecycleCapabilities(config).extractionScopeClassification\n          ? resolveSourceConnector(turns)\n          : undefined;\n        return renderExtractionConversation(\n          turns.map((turn) => ({ ...turn, content: turn.content.trim().slice(0, config.extractionMaxTurnChars) })),\n          headerConnector(sourceConnector)\n        ).conversation.length;\n      },\n      runExtraction: (turns, runOptions) => isolatedRun.runExtraction(turns, runOptions),\n      getStorage: () => ingestionDeps.getStorage(),\n      buffer: claimBuffer,\n    },\n    { dropFailedChunks: false }\n  );\n  return { claimBuffer, coordinator, executionDrain };\n}\n\n/** Plan semantics for one scope group: a pinned plan forwards as-is; a\n *  planless ACCEPTED group pins null (existing flush behavior); unpinned\n *  legacy groups pass NO option so runExtraction resolves the CURRENT\n *  profile. */\nfunction planOptionForGroup(group: ExtractionScopeGroup): GroupPlanOption {\n  if (group.scopeProfileWritePlan !== undefined) return { scopeProfileWritePlan: group.scopeProfileWritePlan };\n  if (group.turns.some((turn) => turn.acceptedCapture === true)) return { scopeProfileWritePlan: null };\n  return {};\n}\n\n/** captureMode=explicit: ordinary buffered conversation turns never create\n *  memories — only deliberately accepted captures drain. */\nfunction explicitModeDenied(group: ExtractionScopeGroup, config: PluginConfig): boolean {\n  return shouldSkipImplicitExtraction(config) && !group.turns.some((turn) => turn.acceptedCapture === true);\n}\n\ninterface GroupOutcome {\n  turns: number;\n  result?: ExtractionRunResult;\n}\n\ninterface ScopeDrainContext {\n  config: PluginConfig;\n  key: string;\n  signal: AbortSignal;\n  claimBuffer: SmartBuffer;\n  coordinator: TurnIngestionCoordinator;\n  executionDrain: ExtractionDrain;\n  turns: BufferTurn[];\n}\n\n/** Drain a claimed session's turns ONE captured-scope group at a time: each\n *  group keeps its own namespace/principal/plan pins, and the shared\n *  extraction boundary re-applies CURRENT authorization from the turn's\n *  ORIGINAL coding binding before any write. Groups run sequentially (FIFO\n *  per key — the queue's same-key exclusion would serialize them anyway); a\n *  denied group never blocks or clears the other groups. */\nasync function drainScopeGroups(\n  ctx: ScopeDrainContext\n): Promise<{ groupOutcomes: GroupOutcome[]; groupError?: DrainExtractionError }> {\n  const groupOutcomes: GroupOutcome[] = [];\n  let groupError: DrainExtractionError | undefined;\n  for (const group of groupTurnsByExtractionScope(ctx.turns)) {\n    if (ctx.signal.aborted) break;\n    if (explicitModeDenied(group, ctx.config)) {\n      log.warn(\n        `buffer drain: session ${ctx.key} denied capture_mode_explicit (${group.turns.length} ordinary turn(s) retained)`\n      );\n      groupOutcomes.push({\n        turns: group.turns.length,\n        result: { status: \"skipped\", reason: \"capture_mode_explicit\", persistedCount: 0, durableOutputCount: 0 },\n      });\n      continue;\n    }\n    const settleGate = Promise.withResolvers<{ cause?: unknown; result?: ExtractionRunResult }>();\n    let done = false;\n    const onSettle = (cause: unknown, result?: ExtractionRunResult): void => {\n      if (done) return;\n      done = true;\n      settleGate.resolve({ cause, result });\n    };\n    // Settlement and callback EXIT are tracked separately: the lease is\n    // released only after BOTH the queued closure settled and fully exited\n    // (an abort settles through its listener while the closure may still be\n    // persisting).\n    const exited = Promise.withResolvers<void>();\n    void ctx.coordinator\n      .queueBufferedExtraction(group.turns, \"trigger_mode\", {\n        bufferKey: ctx.key,\n        clearBufferAfterExtraction: true,\n        clearMatchingTurns: true,\n        skipDedupeCheck: true,\n        skipCharThreshold: true,\n        skipUserTurnThreshold: true,\n        // Automatic background work yields to fail-closed foreground flushes\n        // (preemptRunning), same as the live trigger path.\n        preemptable: true,\n        abortSignal: ctx.signal,\n        writeNamespaceOverride: group.writeNamespaceOverride,\n        principalOverride: group.principalOverride,\n        ...planOptionForGroup(group),\n        execution: { buffer: ctx.claimBuffer, drain: ctx.executionDrain },\n        onTaskSettled: (error, result) => settleGate.resolve({ cause: error, result }),\n        onTaskExit: () => exited.resolve(),\n      })\n      .catch((cause: DrainExtractionError) => onSettle(cause));\n    const [verdict] = await Promise.all([settleGate.promise, exited.promise]);\n    const settled = verdict;\n    if (settled.cause !== undefined) {\n      // SAFETY: settle captures whatever the queued closure rejected with;\n      // every drain rejection site throws Error values, and a rejection is\n      // always a DrainExtractionError in this path.\n      groupError = settled.cause as Error;\n      break;\n    }\n    groupOutcomes.push({ turns: group.turns.length, result: settled.result });\n  }\n  return { groupOutcomes, groupError };\n}\n\n/** Denied scope groups: policy refusals leave their turns pending (the group\n *  result's turns were NOT cleared), aggregated per reason so a drain is\n *  never reported complete while denied backlog remains. */\nfunction deniedByReason(groupOutcomes: readonly GroupOutcome[]): Map<string, number> {\n  const denied = new Map<string, number>();\n  for (const entry of groupOutcomes) {\n    if (entry.result?.status !== \"skipped\" || !DENIED_SCOPE_REASONS.has(entry.result.reason ?? \"\")) continue;\n    denied.set(entry.result.reason!, (denied.get(entry.result.reason!) ?? 0) + entry.turns);\n  }\n  return denied;\n}\n\nfunction lastGroupReason(groupOutcomes: readonly GroupOutcome[]): string | undefined {\n  for (let index = groupOutcomes.length - 1; index >= 0; index -= 1) {\n    const reason = groupOutcomes[index]?.result?.reason;\n    if (reason !== undefined) return reason;\n  }\n  return undefined;\n}\n\n/** the session file is gone for good — but the ack verdict is the truth (live */\nasync function settleDrainVerdict(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  groupOutcomes: readonly GroupOutcome[],\n  groupError: DrainExtractionError | undefined,\n  turnsRemaining: number\n): Promise<{ status: DrainSessionStatus; reason?: string; turnsRemaining: number }> {\n  if (turnsRemaining === 0) return await ackOrReload(claims, key, ownerId);\n  if (groupError) {\n    await claims.releaseLease(key, ownerId);\n    return { status: \"failed\", reason: describeError(groupError), turnsRemaining };\n  }\n  await claims.releaseLease(key, ownerId);\n  const reason =\n    groupOutcomes.find((entry) => entry.result?.reason !== undefined && DENIED_SCOPE_REASONS.has(entry.result.reason!))\n      ?.result?.reason ??\n    lastGroupReason(groupOutcomes) ??\n    \"deferred\";\n  return { status: \"deferred\", reason, turnsRemaining };\n}\n\n/** Ack an emptied claim; a not-acked verdict means live ingress merged (or\n *  the lease moved) — reload the honest pending count and release OUR lease,\n *  keeping the source. */\nasync function ackOrReload(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string\n): Promise<{ status: DrainSessionStatus; reason?: string; turnsRemaining: number }> {\n  const ackOutcome = await claims.ack(key, ownerId);\n  if (ackOutcome === \"acked\") return { status: \"drained\", turnsRemaining: 0 };\n  const reloaded = await claims.load(key);\n  const turnsRemaining = pendingTurnCount(reloaded?.entry);\n  await claims.releaseLease(key, ownerId);\n  return { status: \"deferred\", reason: ackOutcome === \"not_empty\" ? \"ack_not_empty\" : \"ack_not_owner\", turnsRemaining };\n}\n\nfunction groupCounts(groupOutcomes: readonly GroupOutcome[]): GroupCounts {\n  return {\n    persistedCount: groupOutcomes.reduce((sum, entry) => sum + (entry.result?.persistedCount ?? 0), 0),\n    durableOutputCount: groupOutcomes.reduce((sum, entry) => sum + (entry.result?.durableOutputCount ?? 0), 0),\n  };\n}\n\nexport interface DrainScanEntry {\n  key: string;\n  turns: number;\n  claimed: boolean;\n}\n\n/** Session-buffer listings: a claimed session reports its CLAIM's pending\n *  count (the live buffer copy may lag the claim), an unclaimed one its\n *  buffer entry. */\nasync function bufferSessionListings(\n  claims: BufferDrainClaims,\n  entries: Record<string, BufferEntryState>\n): Promise<{ listings: DrainScanEntry[]; seen: Set<string> }> {\n  const listings: DrainScanEntry[] = [];\n  const seen = new Set<string>();\n  for (const [key, entry] of Object.entries(entries)) {\n    seen.add(key);\n    const claim = claims.isClaimed(key) ? await claims.load(key) : null;\n    listings.push({\n      key,\n      turns: claim ? pendingTurnCount(claim.entry) : pendingTurnCount(entry),\n      claimed: claim !== null,\n    });\n  }\n  return { listings, seen };\n}\n\n/** Claims the buffer state no longer lists (drained by an earlier run whose\n *  claim file outlived its session file). */\nasync function orphanClaimListings(claims: BufferDrainClaims, seen: Set<string>): Promise<DrainScanEntry[]> {\n  const out: DrainScanEntry[] = [];\n  for (const listed of await 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/** The drain runs on the caller's abort signal combined with this run's own\n *  lease-loss controller. */\nfunction drainAbortSignal(callerSignal: AbortSignal | undefined, abort: AbortController): AbortSignal {\n  return callerSignal ? AbortSignal.any([callerSignal, abort.signal]) : abort.signal;\n}\n\n/** One heartbeat-protected claim drain: run every scope group, settle the\n *  verdict against the claim store, and assemble the honest outcome. The\n *  heartbeat is cleared by the caller on every exit path. */\nasync function runClaimDrain(\n  ctx: {\n    orchestrator: Orchestrator;\n    claims: BufferDrainClaims;\n    key: string;\n    ownerId: string;\n    claimBuffer: SmartBuffer;\n    coordinator: TurnIngestionCoordinator;\n    executionDrain: ExtractionDrain;\n    turns: BufferTurn[];\n    turnsAtStart: number;\n    config: PluginConfig;\n    signal: AbortSignal;\n  },\n  options: BufferDrainRunnerOptions,\n  heartbeat: NodeJS.Timeout\n): Promise<DrainSessionOutcome> {\n  // An emptied claim acks here: the ack verdict is the truth (drained), or\n  // live ingress merged between the read and the ack — deferred, source kept.\n  if (ctx.turns.length === 0) {\n    const outcome = await ackEmptyClaim(ctx.claims, ctx.key, ctx.ownerId, ctx.turnsAtStart);\n    options.onEvent?.({ type: \"session_finished\", key: ctx.key, outcome });\n    return outcome;\n  }\n  const { groupOutcomes, groupError } = await drainScopeGroups(ctx);\n  // Heartbeat cleared on EVERY exit path: a rejected drain must not keep\n  // renewing the lease forever (cleared in the caller's finally).\n  const remaining = await ctx.claims.load(ctx.key);\n  const { status, reason, turnsRemaining } = await settleDrainVerdict(\n    ctx.claims,\n    ctx.key,\n    ctx.ownerId,\n    groupOutcomes,\n    groupError,\n    pendingTurnCount(remaining?.entry)\n  );\n  const outcome = assembleOutcome(\n    ctx.key,\n    ctx.turnsAtStart,\n    { status, reason, turnsRemaining },\n    groupCounts(groupOutcomes),\n    deniedByReason(groupOutcomes)\n  );\n  log.info(`buffer drain: session ${ctx.key} ${status} (${outcome.turnsRemaining} turn(s) remaining)`);\n  options.onEvent?.({ type: \"session_finished\", key: ctx.key, outcome });\n  return outcome;\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 claimed = await loadClaimedSession(claims, key);\n    if (claimed.kind === \"notClaimed\") return claimed.notClaimed;\n    const { claim, turnsAtStart } = claimed;\n    options.onEvent?.({ type: \"session_started\", key, turns: turnsAtStart });\n\n    // Take the lease unless this drainer already holds it.\n    const busy = await adoptLease(claims, key, options.ownerId, leaseMs);\n    if (busy !== null) {\n      const outcome = busy;\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 removed\n    // from it, so a kill leaves exactly the un-extracted turns.\n    const { claimBuffer, coordinator, executionDrain } = buildClaimExecution(\n      this.orchestrator,\n      claims,\n      key,\n      options.ownerId,\n      claim\n    );\n    await claimBuffer.load();\n\n    // The claim's turns (retained first, like the live buffer's order).\n    const turns = [...(claim.entry.retainedTurns ?? []), ...claim.entry.turns];\n\n    // A lost lease means another drainer took the claim: stop instead of\n    // writing progress into a claim this run no longer owns.\n    const abort = new AbortController();\n    const signal = drainAbortSignal(options.signal, abort);\n    const heartbeat = startLeaseHeartbeat(claims, key, options.ownerId, leaseMs, abort);\n    try {\n      return await runClaimDrain(\n        {\n          orchestrator: this.orchestrator,\n          claims,\n          key,\n          ownerId: options.ownerId,\n          claimBuffer,\n          coordinator,\n          executionDrain,\n          turns,\n          turnsAtStart,\n          config: this.orchestrator.config,\n          signal,\n        },\n        options,\n        heartbeat\n      );\n    } finally {\n      clearInterval(heartbeat);\n    }\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<DrainScanEntry[]> {\n    const sessions = await this.orchestrator.storage.loadBuffer();\n    const { listings, seen } = await bufferSessionListings(this.claims, sessions.entries ?? {});\n    return [...listings, ...(await orphanClaimListings(this.claims, seen))];\n  }\n}\n"],"mappings":"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","names":["outcome"]}