@remnic/core 10.0.69 → 10.0.71

package/dist/{chunk-PRKNAIGZ.js → chunk-T6T2RMWW.js}

@@ -15,7 +15,7 @@ import {
   PRE_ACTION_GATE_DEFAULT_TIMEOUT_MS,
   normalizeActionIntent,
   sanitizePayloadString
-} from "./chunk-CIEEYVUB.js";
+} from "./chunk-TPX7XXY4.js";
 import {
   parseSubjectRuntimeConfig
 } from "./chunk-KQLBXUUQ.js";
@@ -81,12 +81,12 @@ import {
 import {
   parseSecurityConfig
 } from "./chunk-G2XTGEGL.js";
-import {
-  parseBackgroundGeneration
-} from "./chunk-27NO2KVB.js";
 import {
   parseBoundedJsonlStateConfig
 } from "./chunk-KFZY2OFH.js";
+import {
+  parseBackgroundGeneration
+} from "./chunk-27NO2KVB.js";
 import {
   parseActiveContextFields
 } from "./chunk-B32WYRXX.js";
@@ -5504,4 +5504,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-PRKNAIGZ.js.map
+//# sourceMappingURL=chunk-T6T2RMWW.js.map

package/dist/{chunk-CIEEYVUB.js → chunk-TPX7XXY4.js}

@@ -2,7 +2,7 @@ import {
   readCausalTrajectoryRecordsStrict,
   readCausalTrajectoryRevisionToken,
   resolveCausalTrajectoryStoreDir
-} from "./chunk-GKL6QYZO.js";
+} from "./chunk-6L63IN3M.js";
 
 // src/coding/pre-action-gate.ts
 import { createHash } from "crypto";
@@ -221,4 +221,4 @@ export {
   normalizeActionIntent,
   PreActionFailureGate
 };
-//# sourceMappingURL=chunk-CIEEYVUB.js.map
+//# sourceMappingURL=chunk-TPX7XXY4.js.map

package/dist/{chunk-L334PSLW.js → chunk-U2A56LLF.js}

@@ -1,3 +1,9 @@
+import {
+  LanceDbBackend
+} from "./chunk-DOJBV6WR.js";
+import {
+  MeilisearchBackend
+} from "./chunk-PFUXPTBT.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -10,12 +16,6 @@ import {
 import {
   EmbedHelper
 } from "./chunk-EXYT52NR.js";
-import {
-  LanceDbBackend
-} from "./chunk-DOJBV6WR.js";
-import {
-  MeilisearchBackend
-} from "./chunk-PFUXPTBT.js";
 import {
   createConversationIndexBackend
 } from "./chunk-TFA6HPOA.js";
@@ -24,7 +24,7 @@ import {
 } from "./chunk-F4TWWUMP.js";
 import {
   QmdClient
-} from "./chunk-ELHJK7LM.js";
+} from "./chunk-WBN66HPI.js";
 import {
   resolveIndexingCapabilities,
   resolvePipelineProcessingCapabilities,
@@ -179,4 +179,4 @@ export {
   createConversationSearchBackend,
   createConversationIndexRuntime
 };
-//# sourceMappingURL=chunk-L334PSLW.js.map
+//# sourceMappingURL=chunk-U2A56LLF.js.map

package/dist/{chunk-P4TV3TQ2.js → chunk-U6IL4724.js}

@@ -1,15 +1,15 @@
-import {
-  decideLifecycleTransition
-} from "./chunk-TBBDFYXW.js";
 import {
   StorageManager
-} from "./chunk-NHWDTOBN.js";
+} from "./chunk-S73ZVU37.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-M5GVCJSJ.js";
 import {
   requestEntityCanonicalIdReconcile
 } from "./chunk-IAYUTGF2.js";
+import {
+  decideLifecycleTransition
+} from "./chunk-TBBDFYXW.js";
 import {
   excludeSupportPassportPrivateMemories
 } from "./chunk-PWPIERBM.js";
@@ -769,4 +769,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-P4TV3TQ2.js.map
+//# sourceMappingURL=chunk-U6IL4724.js.map

package/dist/{chunk-5UM4H64E.js → chunk-UAOJVQXC.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-NHWDTOBN.js";
+} from "./chunk-S73ZVU37.js";
 import {
   keyring_exports,
   secureStoreDir
@@ -416,4 +416,4 @@ export {
   resolveNamespaceStorageRoot,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-5UM4H64E.js.map
+//# sourceMappingURL=chunk-UAOJVQXC.js.map

package/dist/{chunk-MOIJWWNA.js → chunk-UE5JYPU6.js}

@@ -3,7 +3,7 @@ import {
   readNamespaceMaintenanceLastRanStatuses,
   readNamespaceMaintenanceStatuses,
   runNamespaceMaintenancePlan
-} from "./chunk-HH73M65H.js";
+} from "./chunk-QVZZE6VH.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -14,7 +14,7 @@ import {
 } from "./chunk-CMTINOFS.js";
 import {
   summarizeCorpusAndReplica
-} from "./chunk-B4DXREWC.js";
+} from "./chunk-IQXQ3KWR.js";
 import {
   readJudgeVerdictStats
 } from "./chunk-OZKOPQCM.js";
@@ -32,32 +32,32 @@ import {
 } from "./chunk-2DQ2XREU.js";
 import {
   runConsolidationProvenanceCheck
-} from "./chunk-PLCYKAWH.js";
+} from "./chunk-3ICAWZUU.js";
 import {
   reportBufferSurpriseDistribution
 } from "./chunk-YBPYIAA5.js";
 import {
   parseConfig
-} from "./chunk-PRKNAIGZ.js";
+} from "./chunk-T6T2RMWW.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-OPFVXM2D.js";
-import {
-  listNamespaces
-} from "./chunk-AVGDYYMA.js";
+} from "./chunk-7P5VBRBS.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-P4TV3TQ2.js";
+} from "./chunk-U6IL4724.js";
+import {
+  listNamespaces
+} from "./chunk-ZBET3W26.js";
 import {
   analyzeGraphHealth
-} from "./chunk-M4IEZGCK.js";
+} from "./chunk-BFBS7OFQ.js";
 import {
   summarizeExtractionLiveness
 } from "./chunk-AWD36R4D.js";
 import {
   StorageManager
-} from "./chunk-NHWDTOBN.js";
+} from "./chunk-S73ZVU37.js";
 import {
   lintWorkspaceFiles
 } from "./chunk-DM2T26WE.js";
@@ -1069,7 +1069,7 @@ async function summarizeBufferSurpriseDistribution(storage, config) {
   }
 }
 async function summarizeGraphEdgeDecayStatus(config) {
-  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-OEX5OGMI.js");
+  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-CXTNJ7IQ.js");
   const { graphEdgeDecayEnabled } = config;
   const enabled = graphEdgeDecayEnabled === true;
   if (!enabled) {
@@ -1683,4 +1683,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-MOIJWWNA.js.map
+//# sourceMappingURL=chunk-UE5JYPU6.js.map

package/dist/{chunk-TGQW3AMK.js → chunk-UIFWZMO7.js}

@@ -9,24 +9,6 @@ import {
   writeOfflineUploadChunk,
   writeSafeFileFromUpload
 } from "./chunk-XXR4A33N.js";
-import {
-  applyChangesetEmbeddingGenerations,
-  normalizeChangesetGenerations
-} from "./chunk-63A2BU2B.js";
-import {
-  advanceEmbeddingGenerationMarker,
-  applyIncomingEmbeddingGenerations,
-  assertEmbeddingGenerationStillIncluded,
-  computeOmittedEmbeddingGenerationPaths,
-  divergedEmbeddingGenerationDeferrals,
-  embeddingGenerationMembership,
-  isEmbeddingGenerationDirPath,
-  isPathInOmittedEmbeddingGeneration
-} from "./chunk-5KDDAQ6K.js";
-import {
-  isEmbeddingGenerationMarkerPath,
-  matchesOfflineSyncDefaultExclude
-} from "./chunk-63LFM77Z.js";
 import {
   OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS,
   OfflineSyncCensusRaceError,
@@ -42,6 +24,25 @@ import {
   sha256OfflineSyncFile,
   shouldExcludeOfflineSyncFile
 } from "./chunk-UWMZT2TY.js";
+import {
+  applyChangesetEmbeddingGenerations,
+  normalizeChangesetGenerations
+} from "./chunk-F4ZHKDBW.js";
+import {
+  advanceEmbeddingGenerationMarker,
+  applyIncomingEmbeddingGenerations,
+  assertEmbeddingGenerationStillIncluded,
+  computeOmittedEmbeddingGenerationPaths,
+  divergedEmbeddingGenerationDeferrals,
+  embeddingGenerationMembership,
+  isEmbeddingGenerationDirPath,
+  isPathInOmittedEmbeddingGeneration
+} from "./chunk-WN2DASTS.js";
+import {
+  isCanonicalRuntimeStatePath,
+  shouldDeleteAbsentIncomingOfflineRuntimeFile,
+  shouldPreferIncomingOfflineRuntimeFile
+} from "./chunk-LDWE7OZS.js";
 import {
   prepareSafeArchiveRoot,
   resolveSafeArchiveTarget,
@@ -49,10 +50,9 @@ import {
   validateArchiveRelativePath
 } from "./chunk-GCGJW34D.js";
 import {
-  isCanonicalRuntimeStatePath,
-  shouldDeleteAbsentIncomingOfflineRuntimeFile,
-  shouldPreferIncomingOfflineRuntimeFile
-} from "./chunk-LDWE7OZS.js";
+  isEmbeddingGenerationMarkerPath,
+  matchesOfflineSyncDefaultExclude
+} from "./chunk-63LFM77Z.js";
 import {
   withEmbeddingGenerationLock,
   withEmbeddingGenerationLockIter
@@ -1847,4 +1847,4 @@ export {
   normalizeOfflineSyncState,
   fileStatesFromSnapshot
 };
-//# sourceMappingURL=chunk-TGQW3AMK.js.map
+//# sourceMappingURL=chunk-UIFWZMO7.js.map

package/dist/{chunk-UW6LBFYN.js → chunk-USX5YIKB.js}

@@ -1,7 +1,7 @@
 import {
   buildStandup,
   parseStandupDate
-} from "./chunk-UVVFPCPX.js";
+} from "./chunk-H2X32F2K.js";
 import {
   backfillMemoryStorage,
   runLocationBackfill,
@@ -9,23 +9,23 @@ import {
   runLocationDay,
   runLocationStatus,
   runLocationSync
-} from "./chunk-4SOWMA55.js";
+} from "./chunk-7WFY2L5J.js";
 import {
   externalWikiSearchOperation
-} from "./chunk-IG3EZ3TF.js";
+} from "./chunk-WNQ3B3Q5.js";
 import {
   DECISION_SUBCOMMANDS,
   DELTA_SUBCOMMANDS,
   defineOperation,
   isCodegraphToolName
-} from "./chunk-6WKWL53V.js";
+} from "./chunk-23BA3USG.js";
 import {
   CorrectionContractError
 } from "./chunk-ETSJD5IV.js";
 import {
   memoryStoreRequestSchema,
   retainedCategoryAlias
-} from "./chunk-H6VJSITJ.js";
+} from "./chunk-CIL4GHMD.js";
 import {
   serializeMutations,
   withHeldFileLock
@@ -1916,4 +1916,4 @@ export {
   codegraphIngestTracesOperation,
   REGISTERED_OPERATIONS
 };
-//# sourceMappingURL=chunk-UW6LBFYN.js.map
+//# sourceMappingURL=chunk-USX5YIKB.js.map

package/dist/{chunk-QGFR73SN.js → chunk-VK5HKVQ7.js}

@@ -1,6 +1,6 @@
 import {
   defineOperation
-} from "./chunk-6WKWL53V.js";
+} from "./chunk-23BA3USG.js";
 import {
   EngramAccessInputError
 } from "./chunk-LGEH473S.js";
@@ -92,4 +92,4 @@ defineOperation({
     };
   }
 });
-//# sourceMappingURL=chunk-QGFR73SN.js.map
+//# sourceMappingURL=chunk-VK5HKVQ7.js.map

package/dist/{chunk-ZOBYTRBU.js → chunk-VNTQU6KB.js}

@@ -1,7 +1,7 @@
 import {
   bufferTurnsEqual,
   subtractBufferTurns
-} from "./chunk-U7MIMS2Y.js";
+} from "./chunk-OUBEJWVI.js";
 import {
   withHeldFileLock
 } from "./chunk-EBV6VXKF.js";
@@ -362,6 +362,7 @@ function parseLease(raw) {
     leaseMs: lease.leaseMs
   };
 }
+var LIST_PAGE_SCAN_FACTOR = 8;
 var BufferDrainClaims = class {
   constructor(stateDir, io) {
     this.stateDir = stateDir;
@@ -655,6 +656,50 @@ var BufferDrainClaims = class {
     }
     return out;
   }
+  /**
+   * Paged listing for bounded periodic scans: at most `limit` claims with
+   * pending turns, starting AFTER `afterName` (a raw entry name returned as
+   * `nextCursor` by a previous page — file-name order is stable, so a
+   * rotating cursor visits every claim fairly without ever materializing
+   * the whole directory's bodies). Empty tombstones never count toward the
+   * limit; the number of bodies read per call is bounded separately
+   * (`LIST_PAGE_SCAN_FACTOR` per requested entry), and the cursor advances
+   * past every scanned name so a long tombstone run is crossed over several
+   * pages instead of starving the pending claims behind it.
+   */
+  async listPage(afterName, limit) {
+    let names;
+    try {
+      names = (await readdir2(this.dir)).filter((name) => name.endsWith(".json") && !name.endsWith(".lease.json")).sort();
+    } catch (err) {
+      const errno = err?.code;
+      if (errno === "ENOENT") return { entries: [] };
+      throw err;
+    }
+    const start = afterName === void 0 ? 0 : names.findIndex((name) => name > afterName);
+    const out = [];
+    let cursor;
+    const scanBudget = Math.max(limit, 1) * LIST_PAGE_SCAN_FACTOR;
+    let scanned = 0;
+    for (let index = start < 0 ? names.length : start; index < names.length; index += 1) {
+      if (out.length >= limit || scanned >= scanBudget) break;
+      const name = names[index];
+      scanned += 1;
+      cursor = name;
+      const claim = await this.readClaimBodyByKey(name);
+      if (!claim) continue;
+      const turnCount = claim.entry.turns.length + (claim.entry.retainedTurns?.length ?? 0);
+      if (turnCount <= 0) continue;
+      const lease = await this.readLease(claim.key);
+      out.push({
+        key: claim.key,
+        turnCount,
+        leased: lease !== null,
+        leaseExpired: lease !== null ? isLeaseExpired(lease) : true
+      });
+    }
+    return { entries: out, nextCursor: cursor };
+  }
   async readClaimBodyByKey(name) {
     try {
       return parseBody(await this.io.read(path2.join(this.dir, name)));
@@ -671,4 +716,4 @@ export {
   legacyStateToEntries,
   BufferSessionFiles
 };
-//# sourceMappingURL=chunk-ZOBYTRBU.js.map
+//# sourceMappingURL=chunk-VNTQU6KB.js.map

package/dist/chunk-VNTQU6KB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/buffer-drain-claims.ts","../src/storage/buffer-session-files.ts"],"sourcesContent":["/**\n * Durable drain claims for the extraction buffer (`remnic buffer drain`).\n *\n * A claim is the atomic handover of one session's buffered turns from the\n * live buffer (daemon or CLI process) to a drain worker, so extraction can\n * run out of process without a live buffer owner resurrecting or losing the\n * turns. Files under `<stateDir>/buffer/drain/`:\n *\n *   s-<sha256(key)>.json        claim content: { key, entry, claimedAt }\n *                               — the turns NOT yet extracted. Renamed into\n *                               place from the session file (atomic on one\n *                               filesystem), rewritten atomically as chunks\n *                               drain.\n *   s-<sha256(key)>.lease.json  { ownerId, pid, acquiredAt, heartbeatAt,\n *                               leaseMs } — created with exclusive-create so\n *                               exactly one drainer holds a key.\n *\n * Invariants (see the buffer-drain PR for the full protocol):\n *   - At every instant the claim content file holds exactly the turns whose\n *     extraction is not durably finished, so a kill at any point loses\n *     nothing and the next run resumes.\n *   - A live buffer owner that must persist a claimed session hands its\n *     in-memory entry INTO the claim (merge, identity-deduped) instead of\n *     writing a session file — it can never resurrect claimed turns.\n *   - Claims are idempotent: re-claiming, double-draining, and two\n *     concurrent drainers are all safe (per-key mutation lock + exclusive\n *     lease; the lock also fences lease takeover and progress writes).\n *\n * All content reads/writes go through the storage's secure file I/O\n * (`BufferFileIo`); only lease/existence checks touch raw paths, and claim\n * rewrites serialize on a cross-process held file lock.\n */\n\nimport { hostname } from \"node:os\";\nimport { z } from \"zod\";\nimport { existsSync } from \"node:fs\";\nimport { mkdir, readdir, rename, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\nimport { bufferSessionFileName, type BufferFileIo } from \"./buffer-session-files.js\";\nimport { bufferTurnsEqual, subtractBufferTurns } from \"../buffer-turn-helpers.js\";\nimport { log } from \"../logger.js\";\nimport { withHeldFileLock } from \"../utils/serialize-mutations.js\";\nimport type { BufferEntryState, BufferTurn } from \"../types.js\";\n\n/** Result of persisting one session's entry. */\nexport interface BufferSessionSaveOutcome {\n  /** \"saved\": the session file holds the entry. \"handed_over\": the entry moved into a drain claim. */\n  status: \"saved\" | \"handed_over\";\n  /** Turns a drain already extracted (claim tombstone): the owner subtracts them from its copy. */\n  drainedTurns?: BufferTurn[];\n}\n\nexport interface DrainLease {\n  ownerId: string;\n  pid: number;\n  /** Host the owner runs on: a takeover may only judge liveness on that host. */\n  host: string;\n  acquiredAt: string;\n  heartbeatAt: string;\n  leaseMs: number;\n}\n\nexport interface DrainClaimFile {\n  key: string;\n  entry: BufferEntryState;\n  claimedAt: string;\n  /**\n   * Turns the drain already extracted. Non-empty means the session was\n   * drained and the claim is a TOMBSTONE: a live buffer owner subtracts\n   * these from its (possibly stale) copy instead of writing them back, so\n   * drained turns can never be resurrected.\n   */\n  drained?: BufferTurn[];\n  /** Same tombstone for turns the drain extracted from `retainedTurns`. */\n  drainedRetained?: BufferTurn[];\n}\n\nexport type ClaimFromSessionOutcome = \"claimed\" | \"empty\" | \"already_claimed\";\nexport type AdoptOutcome = \"adopted\" | \"busy\";\nexport type AckOutcome = \"acked\" | \"not_empty\" | \"busy\";\n\nexport interface DrainClaimListing {\n  key: string;\n  turnCount: number;\n  leased: boolean;\n  leaseExpired: boolean;\n}\n\n/** Lock while a claim is read-modify-written; released on settle. */\nconst CLAIM_LOCK_STALE_MS = 120_000;\nconst CLAIM_LOCK_MAX_WAIT_MS = 120_000;\n\nfunction emptyEntry(): BufferEntryState {\n  return { turns: [], lastExtractionAt: null, extractionCount: 0 };\n}\n\n/** Identity-dedupe `incoming` turns into `existing` (they are the same turns a\n * live owner still held after claiming; only genuinely NEW turns append). */\nfunction mergeTurns<T>(existing: T[], incoming: readonly T[], isEqual: (a: T, b: T) => boolean): T[] {\n  const merged = [...existing];\n  for (const turn of incoming) {\n    if (merged.some((kept) => isEqual(kept, turn))) continue;\n    merged.push(turn);\n  }\n  return merged;\n}\n\nfunction mergeEntries(claim: DrainClaimFile, incoming: BufferEntryState): DrainClaimFile {\n  const entry = emptyEntry();\n  // Turns already extracted stay out of the pending entry even when the\n  // owner's incoming copy is stale and still carries them (either tombstone\n  // list counts — a turn in either one left the claim for good).\n  const gone = [...(claim.drained ?? []), ...(claim.drainedRetained ?? [])];\n  entry.turns = mergeTurns(\n    subtractBufferTurns(claim.entry.turns, gone),\n    subtractBufferTurns(incoming.turns, gone),\n    bufferTurnsEqual,\n  );\n  const retained = [\n    ...subtractBufferTurns(claim.entry.retainedTurns ?? [], gone),\n    ...subtractBufferTurns(incoming.retainedTurns ?? [], gone),\n  ];\n  // SAFETY: an empty accumulator of the same element type.\n  const dedupedRetained = mergeTurns([] as typeof retained, retained, bufferTurnsEqual);\n  if (dedupedRetained.length > 0) entry.retainedTurns = dedupedRetained;\n  const stamps = [claim.entry.lastExtractionAt, incoming.lastExtractionAt].filter(\n    (value): value is string => value !== null && value !== undefined,\n  );\n  entry.lastExtractionAt = stamps.sort().at(-1) ?? null;\n  entry.extractionCount = Math.max(claim.entry.extractionCount, incoming.extractionCount);\n  return { ...claim, entry };\n}\n\n/**\n * Is the lease owner still running? Only decidable on the owner's host; a\n * lease from another host counts as alive (its expiry decides).\n */\nfunction isOwnerAlive(lease: DrainLease): boolean {\n  if (lease.host !== hostname()) return true;\n  if (!Number.isInteger(lease.pid) || lease.pid <= 0) return true;\n  try {\n    process.kill(lease.pid, 0);\n    return true;\n  } catch (err) {\n    // EPERM: the process exists but belongs to another user.\n    // SAFETY: the value comes from this module's own write path; the shape is checked above.\n    return (err as NodeJS.ErrnoException)?.code === \"EPERM\";\n  }\n}\n\nfunction isLeaseExpired(lease: DrainLease, now = Date.now()): boolean {\n  const heartbeat = Date.parse(lease.heartbeatAt);\n  return !Number.isFinite(heartbeat) || now - heartbeat > lease.leaseMs;\n}\n\nconst claimBodySchema = z.object({\n  key: z.string().min(1),\n  entry: z.object({\n    turns: z.array(z.unknown()),\n    retainedTurns: z.array(z.unknown()).optional(),\n    lastExtractionAt: z.string().nullable().optional(),\n    extractionCount: z.number().optional(),\n  }).optional(),\n  turns: z.array(z.unknown()).optional(),\n  retainedTurns: z.array(z.unknown()).optional(),\n  lastExtractionAt: z.string().nullable().optional(),\n  extractionCount: z.number().optional(),\n  claimedAt: z.string().optional(),\n  drained: z.array(z.unknown()).optional(),\n  drainedRetained: z.array(z.unknown()).optional(),\n});\n\nfunction parseBody(raw: string): DrainClaimFile | null {\n  let body: z.infer<typeof claimBodySchema>;\n  try {\n    body = claimBodySchema.parse(JSON.parse(raw));\n  } catch {\n    return null;\n  }\n  // Two on-disk shapes, one format: a claim born from rename keeps the flat\n  // session-file shape ({key, turns, ...}) until its first rewrite, which\n  // nests under `entry`. Accept both.\n  const source = body.entry && Array.isArray(body.entry.turns) ? body.entry : body;\n  if (!Array.isArray(source.turns)) return null;\n  const entry = emptyEntry();\n  // SAFETY: the schema parsed these as an array of unknown; the claim file\n  // is written only by this module (BufferSessionFiles.save), so the entries\n  // are BufferTurn values.\n  // SAFETY: the claim file is written only by this module, so the parsed\n  // turn arrays hold BufferTurn values.\n  // SAFETY: the value comes from this module's own write path; the shape is checked above.\n  entry.turns = source.turns as BufferTurn[];\n  if (source.retainedTurns) {\n    // SAFETY: same boundary as the turns above (this module writes the file).\n    entry.retainedTurns = source.retainedTurns as BufferTurn[];\n  }\n  entry.lastExtractionAt = source.lastExtractionAt ?? null;\n  entry.extractionCount = Number.isFinite(source.extractionCount) ? Number(source.extractionCount) : 0;\n  const claim: DrainClaimFile = {\n    key: body.key,\n    entry,\n    claimedAt: body.claimedAt ?? new Date().toISOString(),\n  };\n  if (Array.isArray(body.drained)) {\n    // SAFETY: same boundary as the turns above (this module writes the file).\n    claim.drained = body.drained as BufferTurn[];\n  }\n  if (Array.isArray(body.drainedRetained)) {\n    // SAFETY: same boundary as the turns above (this module writes the file).\n    claim.drainedRetained = body.drainedRetained as BufferTurn[];\n  }\n  return claim;\n}\n\nconst leaseSchema = z.object({\n  ownerId: z.string().min(1),\n  pid: z.number().optional(),\n  host: z.string().optional(),\n  acquiredAt: z.string().optional(),\n  heartbeatAt: z.string(),\n  leaseMs: z.number(),\n});\n\nfunction parseLease(raw: string): DrainLease | null {\n  let lease: z.infer<typeof leaseSchema>;\n  try {\n    lease = leaseSchema.parse(JSON.parse(raw));\n  } catch {\n    return null;\n  }\n  return {\n    ownerId: lease.ownerId,\n    pid: lease.pid ?? 0,\n    host: lease.host ?? \"\",\n    acquiredAt: lease.acquiredAt ?? lease.heartbeatAt,\n    heartbeatAt: lease.heartbeatAt,\n    leaseMs: lease.leaseMs,\n  };\n}\n\n/** Claim bodies `listPage` may read per requested entry: bounds one scan's\n *  I/O even when the directory is mostly empty tombstones. */\nconst LIST_PAGE_SCAN_FACTOR = 8;\n\nexport class BufferDrainClaims {\n  constructor(\n    private readonly stateDir: string,\n    private readonly io: BufferFileIo,\n  ) {}\n\n  private get dir(): string {\n    return path.join(this.stateDir, \"buffer\", \"drain\");\n  }\n\n  private fileFor(key: string): string {\n    return path.join(this.dir, bufferSessionFileName(key));\n  }\n\n  private leaseFileFor(key: string): string {\n    return `${this.fileFor(key)}.lease.json`;\n  }\n\n  private lockFileFor(key: string): string {\n    return `${this.fileFor(key)}.lock`;\n  }\n\n  /** Sync existence check for hot-path gates (`SmartBuffer.isSessionClaimed`). */\n  isClaimed(key: string): boolean {\n    return existsSync(this.fileFor(key));\n  }\n\n  /** Test + CLI seam: the lease file path for direct inspection. */\n  leasePathForTest(key: string): string {\n    return this.leaseFileFor(key);\n  }\n\n  private async readClaimBody(key: string): Promise<DrainClaimFile | null> {\n    try {\n      return parseBody(await this.io.read(this.fileFor(key)));\n    } catch {\n      return null;\n    }\n  }\n\n  /** The claim content for `key`, or null when the key is not claimed. */\n  load(key: string): Promise<DrainClaimFile | null> {\n    return this.readClaimBody(key);\n  }\n\n  private async writeClaimBody(key: string, claim: DrainClaimFile): Promise<void> {\n    await mkdir(this.dir, { recursive: true });\n    await this.io.write(this.fileFor(key), JSON.stringify({ ...claim, key }));\n  }\n\n  private async readLease(key: string): Promise<DrainLease | null> {\n    try {\n      return parseLease(await this.io.read(this.leaseFileFor(key)));\n    } catch {\n      return null;\n    }\n  }\n\n  private async writeLease(key: string, lease: DrainLease): Promise<void> {\n    await mkdir(this.dir, { recursive: true });\n    await this.io.write(this.leaseFileFor(key), JSON.stringify(lease));\n  }\n\n  /**\n   * Atomically move a session's persisted file into a claim. The rename is\n   * the handover: after it settles the turns exist ONLY as a claim, so no\n   * crash window can lose them or leave them in both places. Callers that\n   * lose the race (`already_claimed`) simply skip the key.\n   *\n   * The whole handover runs under the claim's mutation lock, so a claim\n   * create can never land on top of an existing claim (POSIX rename would\n   * silently replace it) and the lease write cannot race an adopter.\n   */\n  async claimFromSessionFile(key: string, lease: DrainLease): Promise<ClaimFromSessionOutcome> {\n    await mkdir(this.dir, { recursive: true });\n    const sessionPath = path.join(this.stateDir, \"buffer\", bufferSessionFileName(key));\n    if (existsSync(sessionPath)) {\n      // Advisory pre-read: an empty live session belongs to its owner, not\n      // the drain. A turn landing between this read and the rename is fine —\n      // the rename moves whatever is there and the claim drains it.\n      try {\n        const seeded = parseBody(await this.io.read(sessionPath));\n        if (seeded && seeded.entry.turns.length === 0 && (seeded.entry.retainedTurns?.length ?? 0) === 0) {\n          return \"empty\";\n        }\n      } catch {\n        // Unreadable live file: proceed with the rename and let the claim\n        // path report it loudly, like the loader skips corrupt files.\n      }\n    }\n    return await withHeldFileLock(\n      this.lockFileFor(key),\n      { staleMs: CLAIM_LOCK_STALE_MS, maxWaitMs: CLAIM_LOCK_MAX_WAIT_MS },\n      async (acquired) => {\n        if (!acquired) return \"already_claimed\";\n        // Under the lock the claim check is authoritative: an existing claim\n        // keeps its content and its lease; the session file stays with its\n        // owner (their next save merges into the claim).\n        if (this.isClaimed(key)) return \"already_claimed\";\n        try {\n          await rename(sessionPath, this.fileFor(key));\n        } catch (err) {\n          // The session file is gone: either it never existed, or another\n          // drainer claimed it first.\n          if (!existsSync(sessionPath)) {\n            if (this.isClaimed(key)) return \"already_claimed\";\n            return \"empty\";\n          }\n          throw err;\n        }\n        const claim = await this.readClaimBody(key);\n        if (!claim || (claim.entry.turns.length === 0 && (claim.entry.retainedTurns?.length ?? 0) === 0)) {\n          // Empty content: nothing to drain. Delete the moved file so the\n          // empty entry keeps living with its owner, not as a stale claim.\n          await unlink(this.fileFor(key)).catch(() => {});\n          return \"empty\";\n        }\n        await this.writeLease(key, lease);\n        return \"claimed\";\n      },\n    );\n  }\n\n  /**\n   * Take over a claim whose lease is missing, expired, or whose owner died.\n   * The whole judgement runs under the claim's mutation lock and re-reads\n   * the lease inside it, so exactly one concurrent adopter wins: the loser\n   * re-reads the winner's fresh lease and reports \"busy\" instead of\n   * unlinking it. A lease whose owner died is taken over in the same call.\n   */\n  async adopt(key: string, lease: DrainLease): Promise<AdoptOutcome> {\n    if (!this.isClaimed(key)) return \"busy\";\n    return await withHeldFileLock(\n      this.lockFileFor(key),\n      { staleMs: CLAIM_LOCK_STALE_MS, maxWaitMs: CLAIM_LOCK_MAX_WAIT_MS },\n      async (acquired) => {\n        if (!acquired) return \"busy\";\n        const existing = await this.readLease(key);\n        if (existing && !isLeaseExpired(existing)) {\n          if (existing.ownerId === lease.ownerId) {\n            // The same drainer already holds it: renew the lease.\n            await this.writeLease(key, { ...existing, heartbeatAt: new Date().toISOString(), leaseMs: lease.leaseMs });\n            return \"adopted\";\n          }\n          if (isOwnerAlive(existing)) return \"busy\";\n          // The owner died without releasing the claim (killed worker):\n          // take it over now instead of waiting for the lease to expire.\n          await unlink(this.leaseFileFor(key)).catch(() => {});\n        } else if (existing) {\n          // Expired lease: clear it before the exclusive create. We hold the\n          // lock, so no concurrent adopter can interleave its own\n          // unlink/create between these steps.\n          await unlink(this.leaseFileFor(key)).catch(() => {});\n        }\n        try {\n          await writeFile(this.leaseFileFor(key), JSON.stringify(lease), { flag: \"wx\" });\n        } catch (err) {\n          // The lease file exists: another drainer took it first.\n          if (existsSync(this.leaseFileFor(key))) return \"busy\";\n          throw err;\n        }\n        return \"adopted\";\n      },\n    );\n  }\n\n  /**\n   * Merge a live owner's in-memory entry INTO the claim (the handover path a\n   * buffer owner takes instead of persisting a claimed session). Serialized\n   * against drainer progress writes on the same lock.\n   */\n  async mergeIntoClaim(key: string, incoming: BufferEntryState): Promise<void> {\n    await withHeldFileLock(this.lockFileFor(key), { staleMs: CLAIM_LOCK_STALE_MS, maxWaitMs: CLAIM_LOCK_MAX_WAIT_MS }, async (acquired) => {\n      if (!acquired) {\n        // Never fall back to a session-file write behind a held claim lock:\n        // that would resurrect claimed turns. Fail so the owner's save stays\n        // pending and retries (SmartBuffer keeps pending state on failure).\n        throw new Error(`buffer drain claim for ${key} is busy; retrying the save later`);\n      }\n      const claim = await this.readClaimBody(key);\n      if (!claim) {\n        // The claim vanished (acked between the isClaimed check and now):\n        // nothing to hand over; the drain already owns everything.\n        return;\n      }\n      await this.writeClaimBody(key, mergeEntries(claim, incoming));\n    });\n  }\n\n  /** Drainer progress: replace the claim content with what is left to do.\n   *\n   * Fenced: `ownerId` must still match the claim's lease (checked under the\n   * same lock), so a drainer that lost its lease cannot write progress that\n   * would restore turns the new owner already extracted.\n   *\n   * `seen` is the entry the drainer LOADED (its snapshot of the claim). Only\n   * turns that were in that snapshot and are absent from BOTH of the\n   * drainer's lists were actually extracted and move to the tombstones — a\n   * turn the drainer moved into `entry.retainedTurns` is retained for retry,\n   * not extracted. Turns a live owner merged into the claim afterwards stay\n   * pending. Without `seen` the pre-existing behavior is kept (every claim\n   * turn missing from `entry` counts as extracted).\n   */\n  async writeEntry(key: string, ownerId: string, entry: BufferEntryState, seen?: BufferEntryState): Promise<void> {\n    await withHeldFileLock(this.lockFileFor(key), { staleMs: CLAIM_LOCK_STALE_MS, maxWaitMs: CLAIM_LOCK_MAX_WAIT_MS }, async (acquired) => {\n      if (!acquired) throw new Error(`buffer drain claim for ${key} is busy; progress write skipped`);\n      const lease = await this.readLease(key);\n      if (!lease || lease.ownerId !== ownerId) {\n        throw new Error(`buffer drain claim for ${key} is no longer owned by ${ownerId}; progress write skipped`);\n      }\n      const claim = await this.readClaimBody(key);\n      if (!claim) return;\n      const seenTurns = seen?.turns ?? claim.entry.turns;\n      const seenRetained = seen?.retainedTurns ?? claim.entry.retainedTurns ?? [];\n      const entryRetained = entry.retainedTurns ?? [];\n      // Still held by the drainer: in its remaining turns OR retained for retry.\n      const kept = (turn: BufferTurn): boolean =>\n        entry.turns.some((held) => bufferTurnsEqual(held, turn)) || entryRetained.some((held) => bufferTurnsEqual(held, turn));\n      // Progress: the snapshot turns that vanished from the entry were extracted.\n      const drained = [...(claim.drained ?? [])];\n      for (const turn of claim.entry.turns) {\n        const extracted =\n          seenTurns.some((snapshot) => bufferTurnsEqual(snapshot, turn)) && !kept(turn);\n        if (!extracted) continue;\n        if (drained.some((gone) => bufferTurnsEqual(gone, turn))) continue;\n        drained.push(turn);\n      }\n      const drainedRetained = [...(claim.drainedRetained ?? [])];\n      for (const turn of claim.entry.retainedTurns ?? []) {\n        const extracted =\n          seenRetained.some((snapshot) => bufferTurnsEqual(snapshot, turn)) && !kept(turn);\n        if (!extracted) continue;\n        if (drained.some((gone) => bufferTurnsEqual(gone, turn)) || drainedRetained.some((gone) => bufferTurnsEqual(gone, turn))) continue;\n        drainedRetained.push(turn);\n      }\n      // Turns merged in after the drainer loaded stay pending, in extraction\n      // order behind the drainer's own remainder.\n      const late = claim.entry.turns.filter(\n        (turn) =>\n          !seenTurns.some((snapshot) => bufferTurnsEqual(snapshot, turn)) && !kept(turn),\n      );\n      const next: BufferEntryState = { ...entry, turns: [...entry.turns, ...late] };\n      const lateRetained = (claim.entry.retainedTurns ?? []).filter(\n        (turn) =>\n          !seenRetained.some((snapshot) => bufferTurnsEqual(snapshot, turn)) && !kept(turn),\n      );\n      if (lateRetained.length > 0) next.retainedTurns = mergeTurns(entryRetained, lateRetained, bufferTurnsEqual);\n      await this.writeClaimBody(key, { ...claim, entry: next, drained, drainedRetained });\n    });\n  }\n\n  /** Extend the lease. \"lost\" means another drainer took the claim over.\n   * Serialized on the claim lock so a stale heartbeat can never overwrite a\n   * new owner's lease mid-takeover; a contended lock just skips this tick\n   * (usually the drainer's own progress write holds it). */\n  async heartbeat(key: string, ownerId: string, leaseMs: number): Promise<\"ok\" | \"lost\"> {\n    return await withHeldFileLock(this.lockFileFor(key), { staleMs: CLAIM_LOCK_STALE_MS, maxWaitMs: CLAIM_LOCK_MAX_WAIT_MS }, async (acquired) => {\n      if (!acquired) return \"ok\";\n      const lease = await this.readLease(key);\n      if (!lease || lease.ownerId !== ownerId) return \"lost\";\n      await this.writeLease(key, { ...lease, heartbeatAt: new Date().toISOString(), leaseMs });\n      return \"ok\";\n    });\n  }\n\n  /** Give the key back (content stays; the next run resumes it). */\n  async releaseLease(key: string, ownerId: string): Promise<void> {\n    const lease = await this.readLease(key);\n    if (!lease || lease.ownerId !== ownerId) return;\n    await unlink(this.leaseFileFor(key)).catch(() => {});\n  }\n\n  /**\n   * Finish a claim: only its owner may ack, and only when nothing is left to\n   * extract. Non-empty claims stay (deferred content is never dropped here).\n   */\n  async ack(key: string, ownerId: string): Promise<AckOutcome> {\n    const lease = await this.readLease(key);\n    if (!lease || lease.ownerId !== ownerId) return \"busy\";\n    const claim = await this.readClaimBody(key);\n    if (!claim) {\n      await unlink(this.leaseFileFor(key)).catch(() => {});\n      return \"acked\";\n    }\n    if (claim.entry.turns.length > 0 || (claim.entry.retainedTurns?.length ?? 0) > 0) return \"not_empty\";\n    // Keep the (empty) claim file as a TOMBSTONE: a live buffer owner that\n    // still holds a stale copy subtracts the drained turns instead of\n    // writing them back. The owner consumes the tombstone on its next save.\n    await unlink(this.leaseFileFor(key)).catch(() => {});\n    return \"acked\";\n  }\n\n  /** The turns a drain already extracted for `key` (tombstone content). */\n  async drainedTurns(key: string): Promise<BufferTurn[]> {\n    const claim = await this.readClaimBody(key);\n    return claim?.drained ?? [];\n  }\n\n  /**\n   * Is the drain for `key` FINISHED (acked): the claim holds extracted turns\n   * and nothing pending, and the drainer dropped its lease. A claim with\n   * partial progress or a live lease is still being drained — its owner must\n   * merge into it, never release it.\n   */\n  async isDrained(key: string): Promise<boolean> {\n    const claim = await this.readClaimBody(key);\n    if (!claim) return false;\n    if ((claim.drained?.length ?? 0) === 0 && (claim.drainedRetained?.length ?? 0) === 0) return false;\n    if (claim.entry.turns.length > 0 || (claim.entry.retainedTurns?.length ?? 0) > 0) return false;\n    return (await this.readLease(key)) === null;\n  }\n\n  /** Drop the claim file entirely (its owner consumed the tombstone). */\n  async release(key: string): Promise<void> {\n    await unlink(this.fileFor(key)).catch(() => {});\n    await unlink(this.leaseFileFor(key)).catch(() => {});\n  }\n\n  /** Every claim with its lease state (CLI scan + summaries). */\n  async list(): Promise<DrainClaimListing[]> {\n    let names: string[];\n    try {\n      names = (await readdir(this.dir)).filter((name) => name.endsWith(\".json\") && !name.endsWith(\".lease.json\"));\n    } catch (err) {\n      // SAFETY: the value comes from this module's own write path; the shape is checked above.\n      if ((err as NodeJS.ErrnoException)?.code === \"ENOENT\") return [];\n      throw err;\n    }\n    const out: DrainClaimListing[] = [];\n    for (const name of names) {\n      const claim = await this.readClaimBodyByKey(name);\n      if (!claim) continue;\n      const lease = await this.readLease(claim.key);\n      out.push({\n        key: claim.key,\n        turnCount: claim.entry.turns.length + (claim.entry.retainedTurns?.length ?? 0),\n        leased: lease !== null,\n        leaseExpired: lease !== null ? isLeaseExpired(lease) : true,\n      });\n    }\n    return out;\n  }\n\n  /**\n   * Paged listing for bounded periodic scans: at most `limit` claims with\n   * pending turns, starting AFTER `afterName` (a raw entry name returned as\n   * `nextCursor` by a previous page — file-name order is stable, so a\n   * rotating cursor visits every claim fairly without ever materializing\n   * the whole directory's bodies). Empty tombstones never count toward the\n   * limit; the number of bodies read per call is bounded separately\n   * (`LIST_PAGE_SCAN_FACTOR` per requested entry), and the cursor advances\n   * past every scanned name so a long tombstone run is crossed over several\n   * pages instead of starving the pending claims behind it.\n   */\n  async listPage(afterName: string | undefined, limit: number): Promise<{ entries: DrainClaimListing[]; nextCursor?: string }> {\n    let names: string[];\n    try {\n      names = (await readdir(this.dir)).filter((name) => name.endsWith(\".json\") && !name.endsWith(\".lease.json\")).sort();\n    } catch (err) {\n      // SAFETY: readdir rejects with NodeJS system errors; only the ENOENT\n      // (no claims directory yet) case maps to an empty listing.\n      const errno = (err as NodeJS.ErrnoException | undefined)?.code;\n      if (errno === \"ENOENT\") return { entries: [] };\n      throw err;\n    }\n    const start = afterName === undefined ? 0 : names.findIndex((name) => name > afterName);\n    const out: DrainClaimListing[] = [];\n    // The cursor is the LAST CONSUMED entry name: the next page starts\n    // strictly after it, so the first unconsumed name is never skipped.\n    // Returning the first unconsumed name instead would make every page\n    // boundary permanently skip one claim.\n    let cursor: string | undefined;\n    const scanBudget = Math.max(limit, 1) * LIST_PAGE_SCAN_FACTOR;\n    let scanned = 0;\n    for (let index = start < 0 ? names.length : start; index < names.length; index += 1) {\n      if (out.length >= limit || scanned >= scanBudget) break;\n      const name = names[index]!;\n      scanned += 1;\n      cursor = name;\n      const claim = await this.readClaimBodyByKey(name);\n      if (!claim) continue;\n      const turnCount = claim.entry.turns.length + (claim.entry.retainedTurns?.length ?? 0);\n      if (turnCount <= 0) continue;\n      const lease = await this.readLease(claim.key);\n      out.push({\n        key: claim.key,\n        turnCount,\n        leased: lease !== null,\n        leaseExpired: lease !== null ? isLeaseExpired(lease) : true,\n      });\n    }\n    return { entries: out, nextCursor: cursor };\n  }\n\n  private async readClaimBodyByKey(name: string): Promise<DrainClaimFile | null> {\n    try {\n      return parseBody(await this.io.read(path.join(this.dir, name)));\n    } catch (err) {\n      log.debug(`buffer drain: skipping unreadable claim file ${name}: ${err instanceof Error ? err.message : String(err)}`);\n      return null;\n    }\n  }\n}\n","import { BufferDrainClaims, type BufferSessionSaveOutcome } from \"./buffer-drain-claims.js\";\nimport { createHash } from \"node:crypto\";\nimport type { Stats } from \"node:fs\";\nimport { lstat, readdir, unlink } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { subtractBufferTurns } from \"../buffer-turn-helpers.js\";\nimport { log } from \"../logger.js\";\nimport { SecureStoreDecryptError, SecureStoreLockedError } from \"../secure-store/secure-fs.js\";\nimport type { BufferEntryState, BufferState, BufferTurn } from \"../types.js\";\n\n/** The secure-store file I/O the owning StorageManager already provides. */\nexport interface BufferFileIo {\n  read(filePath: string): Promise<string>;\n  write(filePath: string, content: string): Promise<void>;\n}\n\ntype FsError = NodeJS.ErrnoException;\n\nfunction isMissing(err: FsError | null): boolean {\n  return err?.code === \"ENOENT\";\n}\n\nfunction asFsError(err: Error): FsError {\n  return err;\n}\n\n/**\n * Case-independent, collision-free file name for a buffer key: the lowercase\n * hex SHA-256 of the key under a fixed prefix. Hex has no case and no path\n * characters, so `Session-A` and `session-a` get different names even on\n * case-insensitive filesystems, every key (short or long) lives in the same\n * naming domain, and the key itself is stored inside the file (loading never\n * inverts the hash).\n */\nexport function bufferSessionFileName(key: string): string {\n  return `s-${createHash(\"sha256\").update(key).digest(\"hex\")}.json`;\n}\n\n/** Flatten a legacy BufferState into per-session entries (top-level fields\n * are the legacy mirror of the \"default\" entry). */\nexport function legacyStateToEntries(state: BufferState): Map<string, BufferEntryState> {\n  const entries = new Map<string, BufferEntryState>();\n  for (const [key, value] of Object.entries(state.entries ?? {})) {\n    if (value && Array.isArray(value.turns)) entries.set(key, value);\n  }\n  if (!entries.has(\"default\")) {\n    entries.set(\"default\", {\n      turns: Array.isArray(state.turns) ? state.turns : [],\n      lastExtractionAt: state.lastExtractionAt ?? null,\n      extractionCount: Number.isFinite(state.extractionCount) ? state.extractionCount : 0,\n    });\n  }\n  return entries;\n}\n\n/** What a per-session file contains once parsed (written only by this module). */\ninterface SessionFileBody {\n  key?: string;\n  turns?: BufferTurn[];\n  retainedTurns?: BufferTurn[];\n  lastExtractionAt?: string | null;\n  extractionCount?: number;\n}\n\nfunction entryFromBody(body: SessionFileBody): { key: string; entry: BufferEntryState } | null {\n  if (!body || !Array.isArray(body.turns) || (body.key?.length ?? 0) === 0) return null;\n  const entry: BufferEntryState = {\n    turns: body.turns,\n    lastExtractionAt: body.lastExtractionAt ?? null,\n    extractionCount: Number.isFinite(body.extractionCount) ? Number(body.extractionCount) : 0,\n  };\n  if (Array.isArray(body.retainedTurns)) entry.retainedTurns = body.retainedTurns;\n  return { key: String(body.key), entry };\n}\n\n/**\n * One file per buffer session under `<stateDir>/buffer/`, so the observe hot\n * path persists only the session that changed. All writes happen under\n * SmartBuffer's serialized mutation chain (one writer per process).\n *\n * Sessions claimed by `remnic buffer drain` (see buffer-drain-claims.ts) are\n * owned by the drain: `save` hands the in-memory entry INTO the claim\n * (identity-deduped merge) instead of writing a session file, so a live\n * buffer owner can never resurrect claimed turns.\n */\nexport class BufferSessionFiles {\n  private dirVerified = false;\n  private readonly claimsStore: BufferDrainClaims;\n\n  constructor(\n    private readonly stateDir: string,\n    private readonly io: BufferFileIo,\n  ) {\n    this.claimsStore = new BufferDrainClaims(stateDir, io);\n  }\n\n  /** The drain-claim store for this state dir (CLI scan + claim ops). */\n  get claims(): BufferDrainClaims {\n    return this.claimsStore;\n  }\n\n  /** Sync gate check: is this session claimed by a buffer drain? */\n  isClaimed(key: string): boolean {\n    return this.claimsStore.isClaimed(key);\n  }\n\n  private get dir(): string {\n    return path.join(this.stateDir, \"buffer\");\n  }\n\n  private fileFor(key: string): string {\n    return path.join(this.dir, bufferSessionFileName(key));\n  }\n\n  /**\n   * Refuse a symlinked buffer directory: following it would send buffered\n   * conversation data (and deletions) outside the memory root. One lstat of\n   * one directory, cached after it passes, so the observe path pays nothing\n   * per write; the cache is dropped on any failure.\n   */\n  private async assertDirSafe(): Promise<void> {\n    if (this.dirVerified) return;\n    let stat: Stats | null = null;\n    try {\n      stat = await lstat(this.dir);\n    } catch (err) {\n      if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;\n    }\n    if (stat && (stat.isSymbolicLink() || !stat.isDirectory())) {\n      throw new Error(`buffer session directory must be a real directory, not a symlink or file: ${this.dir}`);\n    }\n    this.dirVerified = stat !== null;\n  }\n\n  /** Persist ONE session atomically. Compact JSON: machine-read state, and\n   * pretty-printing a large buffer costs CPU and bytes on every observe.\n   * A drain-claimed session is handed over instead (see class doc). */\n  async save(key: string, entry: BufferEntryState): Promise<BufferSessionSaveOutcome> {\n    if (this.isClaimed(key)) {\n      // Consume the tombstone ONLY when the drain finished (acked: extracted\n      // turns recorded, nothing pending, no lease). Partial `drained` just\n      // means chunks completed — the drainer may still be running, and\n      // releasing here would unlink its claim and turn its later writes into\n      // no-ops.\n      if (await this.claimsStore.isDrained(key)) {\n        const drained = await this.claimsStore.drainedTurns(key);\n        // The drain finished this session: the claim is a tombstone. Write\n        // the owner's fresh remainder back as a session file (the drained\n        // turns are subtracted here too, so a caller that did not subtract\n        // them cannot resurrect them) and release the tombstone.\n        const fresh: BufferEntryState = { ...entry, turns: subtractBufferTurns(entry.turns, drained) };\n        if (entry.retainedTurns && entry.retainedTurns.length > 0) {\n          fresh.retainedTurns = subtractBufferTurns(entry.retainedTurns, drained);\n          if (fresh.retainedTurns.length === 0) delete fresh.retainedTurns;\n        }\n        await this.assertDirSafe();\n        await this.io.write(this.fileFor(key), JSON.stringify({ key, ...fresh }));\n        await this.claimsStore.release(key);\n        return { status: \"saved\", drainedTurns: drained };\n      }\n      await this.claimsStore.mergeIntoClaim(key, entry);\n      return { status: \"handed_over\" };\n    }\n    await this.assertDirSafe();\n    await this.io.write(this.fileFor(key), JSON.stringify({ key, ...entry }));\n    return { status: \"saved\" };\n  }\n\n  /** Remove one session's file. Idempotent: an absent file is fine. */\n  async remove(key: string): Promise<void> {\n    await this.assertDirSafe();\n    try {\n      await unlink(this.fileFor(key));\n    } catch (err) {\n      if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;\n    }\n  }\n\n  private async listFiles(): Promise<string[]> {\n    await this.assertDirSafe();\n    try {\n      const dirents = await readdir(this.dir, { withFileTypes: true });\n      // Regular files only: a symlink inside the directory is never followed.\n      return dirents.filter((d) => d.isFile() && d.name.endsWith(\".json\")).map((d) => d.name);\n    } catch (err) {\n      if (err instanceof Error && isMissing(asFsError(err))) return [];\n      throw err;\n    }\n  }\n\n  /** Read every per-session file. Corrupt files are skipped (and logged) so\n   * one bad file cannot nuke the other sessions' buffered turns. */\n  private async readAll(): Promise<{ entries: Map<string, BufferEntryState>; fileCount: number }> {\n    const names = await this.listFiles();\n    const entries = new Map<string, BufferEntryState>();\n    for (const name of names) {\n      try {\n        const body: SessionFileBody = JSON.parse(await this.io.read(path.join(this.dir, name)));\n        const parsed = entryFromBody(body);\n        if (!parsed) throw new Error(\"invalid buffer session file shape\");\n        if (entries.has(parsed.key)) {\n          log.warn(`buffer: duplicate session file for key ${parsed.key} (${name}); keeping the first`);\n          continue;\n        }\n        entries.set(parsed.key, parsed.entry);\n      } catch (err) {\n        // A locked store or a wrong key is not a corrupt file: reading it as empty would let\n        // later saves replace the real encrypted session.\n        if (err instanceof SecureStoreLockedError || err instanceof SecureStoreDecryptError) throw err;\n        log.warn(`buffer: skipping unreadable per-session buffer file ${name}: ${err instanceof Error ? err.message : String(err)}`);\n      }\n    }\n    return { entries, fileCount: names.length };\n  }\n\n  /**\n   * Read the legacy single-file buffer.json for migration. Null when absent,\n   * or unreadable while session files exist (they are authoritative; a\n   * corrupt leftover must not block startup). With no session files a corrupt\n   * legacy file THROWS, preserving the old contract so callers can reset it.\n   */\n  private async readLegacy(hasSessionFiles: boolean): Promise<BufferState | null> {\n    let raw: string;\n    try {\n      raw = await this.io.read(path.join(this.stateDir, \"buffer.json\"));\n    } catch (err) {\n      if (err instanceof SecureStoreLockedError) throw err;\n      if (err instanceof Error && isMissing(asFsError(err))) return null;\n      throw err;\n    }\n    try {\n      const legacy: BufferState = JSON.parse(raw);\n      return legacy;\n    } catch (err) {\n      if (!hasSessionFiles) throw err;\n      log.warn(\n        `buffer: legacy buffer.json is unreadable but per-session buffer files exist; ` +\n          `ignoring the legacy file (${err instanceof Error ? err.message : String(err)})`,\n      );\n      return null;\n    }\n  }\n\n  /**\n   * Load the whole buffer, migrating a legacy buffer.json once. A per-session\n   * file that parsed wins over the legacy snapshot (a crash mid-migration\n   * leaves exactly that pair); legacy entries without a usable file are\n   * written out, then the legacy file is retired. Both steps are idempotent.\n   */\n  async load(): Promise<BufferState> {\n    const { entries, fileCount } = await this.readAll();\n    const legacy = await this.readLegacy(fileCount > 0);\n    if (legacy !== null) {\n      for (const [key, entry] of legacyStateToEntries(legacy)) {\n        if (entries.has(key)) continue;\n        entries.set(key, entry);\n        await this.save(key, entry);\n      }\n      try {\n        await unlink(path.join(this.stateDir, \"buffer.json\"));\n      } catch (err) {\n        if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;\n      }\n    }\n    const out: NonNullable<BufferState[\"entries\"]> = Object.create(null);\n    for (const [key, entry] of entries) out[key] = entry;\n    const def = entries.get(\"default\");\n    return {\n      turns: def?.turns ?? [],\n      lastExtractionAt: def?.lastExtractionAt ?? null,\n      extractionCount: def?.extractionCount ?? 0,\n      entries: out,\n    };\n  }\n\n  /**\n   * Reconcile the files with a WHOLE buffer state: write every entry, then\n   * delete files for keys no longer present. Writes first, deletes last: a\n   * crash leaves stale extra files (removed by the next reconcile) but never\n   * loses sessions the state says exist. Not on the observe hot path.\n   */\n  async reconcile(state: BufferState): Promise<void> {\n    const entries = legacyStateToEntries(state);\n    const existing = await this.listFiles();\n    for (const [key, entry] of entries) await this.save(key, entry);\n    const live = new Set([...entries.keys()].map((key) => bufferSessionFileName(key)));\n    for (const name of existing) {\n      if (live.has(name)) continue;\n      try {\n        await unlink(path.join(this.dir, name));\n      } catch (err) {\n        if (!(err instanceof Error) || !isMissing(asFsError(err))) throw err;\n      }\n    }\n  }\n}\n"],"mappings":"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","names":["readdir","unlink","path","path","unlink","readdir"]}

package/dist/{chunk-IHCXMYSE.js → chunk-VPEIWMUT.js}

@@ -1,6 +1,6 @@
 import {
   readAllEdges
-} from "./chunk-M4IEZGCK.js";
+} from "./chunk-BFBS7OFQ.js";
 import {
   readEdgeConfidence
 } from "./chunk-2LSZVONP.js";
@@ -162,4 +162,4 @@ export {
   parseGraphSnapshotSince,
   buildGraphSnapshot
 };
-//# sourceMappingURL=chunk-IHCXMYSE.js.map
+//# sourceMappingURL=chunk-VPEIWMUT.js.map

package/dist/{chunk-O5ZINWW3.js → chunk-VSJ3ARFS.js}

@@ -1,6 +1,6 @@
 import {
   runLocationSync
-} from "./chunk-4SOWMA55.js";
+} from "./chunk-7WFY2L5J.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -58,4 +58,4 @@ export {
   LOCATION_SYNC_DEFAULT_INTERVAL_MS,
   startLocationAutoSync
 };
-//# sourceMappingURL=chunk-O5ZINWW3.js.map
+//# sourceMappingURL=chunk-VSJ3ARFS.js.map

package/dist/{chunk-RLVI2M5Q.js → chunk-W4V7P5HP.js}

@@ -2,7 +2,7 @@ import {
   WHO_KNOWS_DEFAULT_LIMIT,
   WHO_KNOWS_MAX_LIMIT,
   validateWhoKnowsInput
-} from "./chunk-Y3XPSGNF.js";
+} from "./chunk-JGLZ46JS.js";
 
 // src/who-knows-cli.ts
 function extractWhoKnowsRawArgs(rest) {
@@ -74,4 +74,4 @@ export {
   renderWhoKnowsText,
   renderWhoKnows
 };
-//# sourceMappingURL=chunk-RLVI2M5Q.js.map
+//# sourceMappingURL=chunk-W4V7P5HP.js.map

package/dist/{chunk-ELHJK7LM.js → chunk-WBN66HPI.js}

@@ -1,8 +1,3 @@
-import {
-  EMPTY_QMD_STATUS,
-  embedQmdFiles,
-  fetchQmdStatus
-} from "./chunk-IUM3VSHI.js";
 import {
   resolveEnsureCollectionArgs
 } from "./chunk-NWA6IXR3.js";
@@ -25,6 +20,11 @@ import {
   qmdVersionToString,
   resolveQmdCapabilities
 } from "./chunk-OR42ZI54.js";
+import {
+  EMPTY_QMD_STATUS,
+  embedQmdFiles,
+  fetchQmdStatus
+} from "./chunk-IUM3VSHI.js";
 import {
   clearQmdResultCaches,
   getCachedQmdSearch,
@@ -2030,4 +2030,4 @@ export {
   sharedDaemonSessionCountForTest,
   QmdClient
 };
-//# sourceMappingURL=chunk-ELHJK7LM.js.map
+//# sourceMappingURL=chunk-WBN66HPI.js.map

package/dist/{chunk-BJLCV2P3.js → chunk-WGRAB3KB.js}

@@ -3,7 +3,7 @@ import {
   isArtifactMemoryPath,
   isLocationDayPath,
   isMeetingRecordPath
-} from "./chunk-R4ZHF4K2.js";
+} from "./chunk-43FLJLT2.js";
 import {
   isExternalWikiCollectionName
 } from "./chunk-JV3C2MNQ.js";
@@ -228,4 +228,4 @@ export {
   isGenericRecallExcludedPath,
   filterRecallCandidates
 };
-//# sourceMappingURL=chunk-BJLCV2P3.js.map
+//# sourceMappingURL=chunk-WGRAB3KB.js.map