@remnic/core 10.0.38 → 10.0.39

package/dist/{chunk-WCBLPKG3.js → chunk-5KZNWERU.js}

@@ -22,7 +22,7 @@ import {
 } from "./chunk-VY6BD5KB.js";
 import {
   normalizeQmdResultPath
-} from "./chunk-LHBOFROT.js";
+} from "./chunk-V2XMG7GM.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
@@ -40,9 +40,6 @@ import {
 import {
   createMemorySnapshot
 } from "./chunk-S2HLHAZ4.js";
-import {
-  rotateMarkdownFileToArchive
-} from "./chunk-DM2T26WE.js";
 import {
   closeContinuityIncidentRecord,
   createContinuityIncidentRecord,
@@ -52,6 +49,9 @@ import {
   serializeContinuityIncident,
   upsertContinuityLoopInMarkdown
 } from "./chunk-LDXUBPMO.js";
+import {
+  rotateMarkdownFileToArchive
+} from "./chunk-DM2T26WE.js";
 import {
   parseProvenanceSources,
   parseProvenanceTag,
@@ -69,7 +69,7 @@ import {
   invalidationCommitFingerprint,
   parseTombstoneBlockedOfflineSyncMemory,
   withCasCommitReceipt
-} from "./chunk-YQ6SLFNZ.js";
+} from "./chunk-MPJDQC4G.js";
 import {
   matchEntitySchemaSection,
   normalizeEntityStructuredSection,
@@ -163,12 +163,12 @@ import {
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-UFM3PJDT.js";
+} from "./chunk-PARM6OYL.js";
 import {
   composeMemoryEnvelope,
   isSealedMemoryEnvelope,
   sealedWriteToLegacyArgs
-} from "./chunk-TDCR6PQL.js";
+} from "./chunk-TWRPWJJT.js";
 import {
   DEFAULT_CITATION_FORMAT,
   hasCitationForTemplate,
@@ -189,7 +189,7 @@ import {
   readMemoryActionEventRowsFromLines,
   readProjectionRebuiltAt,
   serializeLifecycleAppendPayload
-} from "./chunk-UJDTXWMT.js";
+} from "./chunk-QIMGULGN.js";
 import {
   assertMemoryFrontmatterId,
   warnProjectionFallback
@@ -214,7 +214,7 @@ import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex,
   FactHashIndexNotAuthoritativeError
-} from "./chunk-UBN5AOLT.js";
+} from "./chunk-W5EO4USJ.js";
 import {
   computeLegacyContentHash
 } from "./chunk-5FVVY2EB.js";
@@ -257,7 +257,7 @@ import {
   readMaybeEncryptedFile,
   readMaybeEncryptedFileBuffer,
   writeMaybeEncryptedFile
-} from "./chunk-TYGLV6ZG.js";
+} from "./chunk-EYGOM6AI.js";
 import {
   assertPathInsideRoot,
   pathIsInside
@@ -283,7 +283,7 @@ import {
   realpath as realpath3,
   stat as stat3,
   writeFile,
-  mkdir,
+  mkdir as mkdir2,
   unlink as unlink4,
   appendFile,
   open
@@ -313,7 +313,7 @@ function parseDriftProvenance(fm) {
 }
 
 // src/storage.ts
-import path13 from "path";
+import path14 from "path";
 
 // src/storage/tombstone-migration-sources.ts
 import { statSync } from "fs";
@@ -5118,6 +5118,20 @@ Reason: ${reason}`;
   }
 }
 
+// src/storage/dropped-extraction-chunk.ts
+import { randomUUID } from "crypto";
+import { mkdir } from "fs/promises";
+import path13 from "path";
+async function saveDroppedExtractionChunk(stateDir, writeSecureFile, bufferKey, reason, turns) {
+  const droppedDir = path13.join(stateDir, "dropped");
+  await mkdir(droppedDir, { recursive: true });
+  const safeKey = bufferKey.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 80) || "default";
+  const filePath = path13.join(droppedDir, `${Date.now()}-${randomUUID().slice(0, 8)}-${safeKey}.json`);
+  const payload = { bufferKey, reason, droppedAt: (/* @__PURE__ */ new Date()).toISOString(), turns };
+  await writeSecureFile(filePath, JSON.stringify(payload, null, 2));
+  return filePath;
+}
+
 // src/storage/entity-timeline.ts
 import { createHash as createHash5 } from "crypto";
 var ENTITY_TIMELINE_METADATA_MARKER = "remnic-meta-v1";
@@ -6118,17 +6132,17 @@ function inferEntityTypeFromContent(content) {
 }
 var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set(["company", "other", "person", "place", "project", "tool", "topic"]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path13.basename(pathRel, ".md").toLowerCase();
+  const basename = path14.basename(pathRel, ".md").toLowerCase();
   const separator = basename.indexOf("-");
   if (separator <= 0) return void 0;
   const candidate = basename.slice(0, separator);
   return KNOWN_ENTITY_FILENAME_PREFIXES.has(candidate) ? candidate : void 0;
 }
 function normalizeFrontmatterForPath(frontmatter, pathRel, content = "") {
-  const normalizedPath = pathRel.split(path13.sep).join("/");
+  const normalizedPath = pathRel.split(path14.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path13.basename(pathRel, ".md");
+    const basename = path14.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -6601,9 +6615,9 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.entitySchemas = entitySchemas;
     this.deletionRevisionStore = new DeletionRevisionStore({
       baseDir,
-      deletionRevisionMetadataPath: path13.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
-      invalidationCommitMetadataPath: path13.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
-      deletionRevisionLockPath: path13.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
+      deletionRevisionMetadataPath: path14.join(baseDir, ".offline-sync", "deletion-revisions.v1.json"),
+      invalidationCommitMetadataPath: path14.join(baseDir, ".offline-sync", "invalidation-commits.v1.json"),
+      deletionRevisionLockPath: path14.join(baseDir, ".offline-sync", "deletion-revisions.v1.json.lock"),
       assertManagedStoragePath: (filePath, method) => this.assertManagedStoragePath(filePath, method)
     });
     this.casRevisions = new CasRevisionHost(baseDir);
@@ -6789,8 +6803,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   /** Whether `filePath` resolves to `stateDir` itself or a path contained in it. */
   isStateFilePath(filePath) {
-    const rel = path13.relative(this.stateDir, path13.resolve(filePath));
-    return rel === "" || !rel.startsWith("..") && !path13.isAbsolute(rel);
+    const rel = path14.relative(this.stateDir, path14.resolve(filePath));
+    return rel === "" || !rel.startsWith("..") && !path14.isAbsolute(rel);
   }
   // ── Tombstone store (issue #1579) ───────────────────────────────────────
   // Instance-scoped (rule 11) + namespace-scoped (rule 42) tombstone index.
@@ -6905,8 +6919,8 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
    */
   isColdOrArchiveTierPath(p) {
-    const rel = path13.relative(this.baseDir, p);
-    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path13.sep}`) || rel.startsWith(`archive${path13.sep}`);
+    const rel = path14.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path14.sep}`) || rel.startsWith(`archive${path14.sep}`);
   }
   /**
    * Mark the secure-store as required for this storage instance.
@@ -6993,7 +7007,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
         void 0,
         this.baseDir
       );
-      const rel = path13.relative(this.baseDir, filePath).split(path13.sep).join("/");
+      const rel = path14.relative(this.baseDir, filePath).split(path14.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -7038,10 +7052,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     _StorageManager.okfConformanceByDir.set(memoryDir, enabled !== false);
   }
   okfConformanceEnabled() {
-    for (let dir = this.baseDir; ; dir = path13.dirname(dir)) {
+    for (let dir = this.baseDir; ; dir = path14.dirname(dir)) {
       const registered = _StorageManager.okfConformanceByDir.get(dir);
       if (registered !== void 0) return registered;
-      if (dir === path13.dirname(dir)) return true;
+      if (dir === path14.dirname(dir)) return true;
     }
   }
   /**
@@ -7085,12 +7099,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path13.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path14.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path13.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path14.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    return path13.join(this.stateDir, `.${kind}-version.log`);
+    return path14.join(this.stateDir, `.${kind}-version.log`);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -7197,7 +7211,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path13.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path14.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -7213,7 +7227,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid wearable transcript date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    return path13.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path14.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -7327,25 +7341,25 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   get factsDir() {
-    return path13.join(this.baseDir, "facts");
+    return path14.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path13.join(this.baseDir, "corrections");
+    return path14.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path13.join(this.baseDir, "procedures");
+    return path14.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path13.join(this.baseDir, "reasoning-traces");
+    return path14.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path13.join(this.baseDir, "entities");
+    return path14.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path13.resolve(this.entitiesDir, `${name}.md`);
-    const relative2 = path13.relative(this.entitiesDir, filePath);
-    if (relative2 === "" || relative2.startsWith("..") || path13.isAbsolute(relative2)) {
+    const filePath = path14.resolve(this.entitiesDir, `${name}.md`);
+    const relative2 = path14.relative(this.entitiesDir, filePath);
+    if (relative2 === "" || relative2.startsWith("..") || path14.isAbsolute(relative2)) {
       return null;
     }
     return filePath;
@@ -7356,7 +7370,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async readDependencyPropagationQueueFile(filePath) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path13.relative(
+      path14.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.readDependencyPropagationQueueFile")
       )
@@ -7366,7 +7380,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async writeDependencyPropagationQueueFile(filePath, content) {
     const target = await resolveSafeStoragePath(
       this.baseDir,
-      path13.relative(
+      path14.relative(
         this.baseDir,
         this.assertManagedStoragePath(filePath, "storage.writeDependencyPropagationQueueFile")
       )
@@ -7381,10 +7395,10 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     });
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path13.resolve(filePath);
-    const base = path13.resolve(this.baseDir);
-    const rel = path13.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path13.sep}`) || path13.isAbsolute(rel)) {
+    const resolved = path14.resolve(filePath);
+    const base = path14.resolve(this.baseDir);
+    const rel = path14.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path14.sep}`) || path14.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -7421,7 +7435,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat3(target);
-    const relPath = path13.relative(this.baseDir, target).split(path13.sep).join("/");
+    const relPath = path14.relative(this.baseDir, target).split(path14.sep).join("/");
     const cache = await this.loadOfflineSyncDigestCache();
     const cached = cache.get(relPath);
     if (cached && cached.statBytes === st.size && cached.mtimeMs === st.mtimeMs && cached.ctimeMs === st.ctimeMs && !cached.encrypted) {
@@ -7506,7 +7520,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
       const cache = this.offlineSyncDigestCache;
       if (!cache) return;
       const entries = [...cache.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([entryPath, entry]) => ({ path: entryPath, ...entry }));
-      await mkdir(path13.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir2(path14.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
 `, "utf-8");
     }).catch((err) => {
@@ -7607,7 +7621,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir(path13.dirname(filePath), { recursive: true });
+    await mkdir2(path14.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (await this.isEncryptedFileHeader(filePath)) {
@@ -7633,13 +7647,13 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.notifyCatalogWriteForPath(filePath);
   }
   get stateDir() {
-    return path13.join(this.baseDir, "state");
+    return path14.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path13.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path14.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path13.join(this.stateDir, "entity-synthesis-queue.json");
+    return path14.join(this.stateDir, "entity-synthesis-queue.json");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -7649,7 +7663,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path13.join(this.stateDir, "tombstones.jsonl");
+    return path14.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -7962,55 +7976,55 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return legacyMatches.length > 0 ? [...new Set(legacyMatches.map((content) => ContentHashIndex.computeHash(content)))] : [persistedHash];
   }
   get questionsDir() {
-    return path13.join(this.baseDir, "questions");
+    return path14.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path13.join(this.baseDir, "artifacts");
+    return path14.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path13.join(this.baseDir, "identity");
+    return path14.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path13.join(this.identityDir, "identity-anchor.md");
+    return path14.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path13.join(this.identityDir, "incidents");
+    return path14.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path13.join(this.identityDir, "audits", "weekly");
+    return path14.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path13.join(this.identityDir, "audits", "monthly");
+    return path14.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path13.join(this.identityDir, "improvement-loops.md");
+    return path14.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path13.join(this.identityDir, "reflections.md");
+    return path14.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path13.join(this.baseDir, "profile.md");
+    return path14.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path13.join(this.stateDir, "memory-actions.jsonl");
+    return path14.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path13.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path14.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path13.join(this.stateDir, "compression-guidelines.md");
+    return path14.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path13.join(this.stateDir, "compression-guidelines.draft.md");
+    return path14.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path13.join(this.stateDir, "compression-guideline-state.json");
+    return path14.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path13.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path14.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path13.join(this.stateDir, "behavior-signals.jsonl");
+    return path14.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * In-memory dedup key set for behavior-signals appends (issue #1909),
@@ -8042,7 +8056,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path13.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path14.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -8105,7 +8119,7 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path13.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path14.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     const raw = readEntityAliasConfigSync(this.baseDir);
     if (raw === void 0) return;
@@ -8140,22 +8154,22 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
     return completionFingerprint;
   }
   async ensureDirectories(options = {}) {
-    await mkdir(this.baseDir, { recursive: true });
+    await mkdir2(this.baseDir, { recursive: true });
     await validateRoots(this.baseDir, this.entitiesDir, this.stateDir, this.archiveDir);
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir(path13.join(this.factsDir, today), { recursive: true });
-    await mkdir(path13.join(this.proceduresDir, today), { recursive: true });
-    await mkdir(path13.join(this.reasoningTracesDir, today), { recursive: true });
-    await mkdir(this.correctionsDir, { recursive: true });
-    await mkdir(this.entitiesDir, { recursive: true });
-    await mkdir(this.stateDir, { recursive: true });
-    await mkdir(this.questionsDir, { recursive: true });
-    await mkdir(this.artifactsDir, { recursive: true });
-    await mkdir(this.identityDir, { recursive: true });
-    await mkdir(this.identityIncidentsDir, { recursive: true });
-    await mkdir(this.identityAuditsWeeklyDir, { recursive: true });
-    await mkdir(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir(path13.join(this.baseDir, "config"), { recursive: true });
+    await mkdir2(path14.join(this.factsDir, today), { recursive: true });
+    await mkdir2(path14.join(this.proceduresDir, today), { recursive: true });
+    await mkdir2(path14.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir2(this.correctionsDir, { recursive: true });
+    await mkdir2(this.entitiesDir, { recursive: true });
+    await mkdir2(this.stateDir, { recursive: true });
+    await mkdir2(this.questionsDir, { recursive: true });
+    await mkdir2(this.artifactsDir, { recursive: true });
+    await mkdir2(this.identityDir, { recursive: true });
+    await mkdir2(this.identityIncidentsDir, { recursive: true });
+    await mkdir2(this.identityAuditsWeeklyDir, { recursive: true });
+    await mkdir2(this.identityAuditsMonthlyDir, { recursive: true });
+    await mkdir2(path14.join(this.baseDir, "config"), { recursive: true });
     await this.entityCanonicalIdMigration.begin(options.waitForEntityMigration !== false, this.entitiesDir);
     if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
       this.bumpMemoryCorpusVersion();
@@ -8177,12 +8191,12 @@ var StorageManager3 = class _StorageManager extends TombstoneBlockedCaptureIndex
    */
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
-      await mkdir(this.correctionsDir, { recursive: true });
-      return path13.join(this.correctionsDir, `${id}.md`);
+      await mkdir2(this.correctionsDir, { recursive: true });
+      return path14.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path13.join(getCategoryDir(this.baseDir, category), today);
-    await mkdir(datedDir, { recursive: true });
-    return path13.join(datedDir, `${id}.md`);
+    const datedDir = path14.join(getCategoryDir(this.baseDir, category), today);
+    await mkdir2(datedDir, { recursive: true });
+    return path14.join(datedDir, `${id}.md`);
   }
   async findExistingTombstoneBlockedMemory(content, category, sourceConnector) {
     const identity = buildExplicitCaptureDedupKey(content, category, sourceConnector);
@@ -8561,8 +8575,8 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path13.join(this.artifactsDir, day);
-    await mkdir(dir, { recursive: true });
+    const dir = path14.join(this.artifactsDir, day);
+    await mkdir2(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
       id,
@@ -8588,7 +8602,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path13.join(dir, `${id}.md`);
+    const filePath = path14.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(this.withOkfType(fm))}
 
 ${sanitized.text}
@@ -8882,7 +8896,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path13.join(this.baseDir, "cold");
+    const coldRoot = path14.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -9000,7 +9014,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path13.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path14.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -9066,7 +9080,7 @@ ${sanitized.text}
         const entries = (await readdir6(dir, { withFileTypes: true })).filter((e) => !isMacOsReplicationJunkBasename(e.name));
         for (const entry of entries) {
           checkCorpusReadAbort(options);
-          const fullPath = path13.join(dir, entry.name);
+          const fullPath = path14.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -9106,7 +9120,7 @@ ${sanitized.text}
     return this.rememberMemorySnapshot(await this.memoryReadStore.readMemoryByPath(filePath));
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path13.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path14.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -9121,13 +9135,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path13.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path14.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path13.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path14.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path13.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path14.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     assertNotOkfReservedBasename(targetPath);
@@ -9206,8 +9220,8 @@ ${memory.content}
               memory.frontmatter.entityRef = current.frontmatter.entityRef;
             }
             durable = true;
-            const sourcePath = path13.resolve(current.path);
-            const destPath = path13.resolve(targetPath);
+            const sourcePath = path14.resolve(current.path);
+            const destPath = path14.resolve(targetPath);
             if (sourcePath !== destPath) {
               await recordArchiveDelete2(this.baseDir, current.path, () => this.deleteManagedStorageFile(current.path));
               this.invalidateAllMemoriesCache();
@@ -9231,8 +9245,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path13.resolve(memory.path);
-    const destPath = path13.resolve(targetPath);
+    const sourcePath = path14.resolve(memory.path);
+    const destPath = path14.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -9242,7 +9256,7 @@ ${memory.content}
     return { changed, targetPath };
   }
   get archiveDir() {
-    return path13.join(this.baseDir, "archive");
+    return path14.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -9255,8 +9269,8 @@ ${memory.content}
       try {
         const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
         const today = now.toISOString().slice(0, 10);
-        const destDir = path13.join(this.archiveDir, today);
-        await mkdir(destDir, { recursive: true });
+        const destDir = path14.join(this.archiveDir, today);
+        await mkdir2(destDir, { recursive: true });
         const refIdsAtWrite = this.currentHistoricalIds();
         const updatedFm = canonicalizeEntityRefOption(
           {
@@ -9271,7 +9285,7 @@ ${memory.content}
 
 ${current.content}
 `;
-        const destPath = path13.join(destDir, path13.basename(current.path));
+        const destPath = path14.join(destDir, path14.basename(current.path));
         const priorDest = await this.readStorageSecureFile(destPath).catch(() => null);
         await recordArchiveWrite(this.baseDir, destPath, () => this.writeStorageSecureFile(destPath, fileContent));
         if (typeof current.frontmatter.entityRef === "string") {
@@ -9505,7 +9519,7 @@ ${memory.content}
 `;
     await this.writeTombstoneBlockedFrontmatter(memory, fileContent, updated, async () => {
       this.invalidateAllMemoriesCache();
-      if (memory.path.includes(`${path13.sep}cold${path13.sep}`)) {
+      if (memory.path.includes(`${path14.sep}cold${path14.sep}`)) {
         this.invalidateColdMemoriesCache();
       }
     });
@@ -9517,7 +9531,7 @@ ${memory.content}
     }
     if (mentionReentry && !entityMentionEpoch.neutral(memory.frontmatter, updated)) entityMentionEpoch.bump(this.baseDir);
     await this.patchHotMemoriesCache({ addedPath: memory.path });
-    if (memory.path.includes(`${path13.sep}cold${path13.sep}`)) {
+    if (memory.path.includes(`${path14.sep}cold${path14.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -9615,8 +9629,11 @@ ${memory.content}
   async deleteBufferSession(key) {
     await this.bufferSessionFiles().remove(key);
   }
+  saveDroppedExtractionChunk(bufferKey, reason, turns) {
+    return saveDroppedExtractionChunk(this.stateDir, (file, content) => this.writeStorageSecureFile(file, content), bufferKey, reason, turns);
+  }
   async loadMeta() {
-    const metaPath = path13.join(this.stateDir, "meta.json");
+    const metaPath = path14.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -9649,8 +9666,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path13.join(this.stateDir, "meta.json");
-    await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
+    await this.writeStorageSecureFile(path14.join(this.stateDir, "meta.json"), JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
     if (events.length === 0) return 0;
@@ -9719,7 +9735,7 @@ ${memory.content}
       },
       (payload) => this.appendStorageSecureFile(target, payload),
       async () => {
-        await mkdir(path13.dirname(target), { recursive: true });
+        await mkdir2(path14.dirname(target), { recursive: true });
       }
     );
   }
@@ -9817,7 +9833,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path13.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path14.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -9830,7 +9846,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path13.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path14.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -10048,7 +10064,7 @@ ${memory.content}
     return `${prefix}-${ts}-${rand}`;
   }
   async writeQuestion(question, context, priority) {
-    await mkdir(this.questionsDir, { recursive: true });
+    await mkdir2(this.questionsDir, { recursive: true });
     const id = this.generateId("q");
     const frontmatter = {
       id,
@@ -10065,7 +10081,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path13.join(this.questionsDir, `${id}.md`);
+    const filePath = path14.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -10124,11 +10140,11 @@ ${question}
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path13.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path14.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path13.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path14.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -10180,7 +10196,7 @@ ${reflection}
     }
   }
   async writeIdentityReflections(content) {
-    await mkdir(this.identityDir, { recursive: true });
+    await mkdir2(this.identityDir, { recursive: true });
     await this.writeStorageSecureFile(this.identityReflectionsPath, content);
   }
   async appendIdentityReflection(reflection) {
@@ -10212,7 +10228,7 @@ ${reflection}
 
 ${reflection}
 `;
-    await mkdir(this.identityDir, { recursive: true });
+    await mkdir2(this.identityDir, { recursive: true });
     await this.writeStorageSecureFile(this.identityReflectionsPath, `${existing.trimEnd()}${section}`);
     log.debug(`appended namespace-local reflection to ${this.identityReflectionsPath}`);
   }
@@ -10268,7 +10284,7 @@ ${reflection}
       const rightTs = latestEntityTimelineTimestamp(right.entity) ?? "";
       return compareEntityTimestamps(rightTs, leftTs);
     }).map(({ entityName }) => entityName);
-    await mkdir(this.stateDir, { recursive: true });
+    await mkdir2(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       this.entitySynthesisQueuePath,
       JSON.stringify(
@@ -10288,7 +10304,7 @@ ${reflection}
     if (queue.length === 0) return;
     const removals = new Set(entityNames);
     const nextQueue = queue.filter((name) => !removals.has(name));
-    await mkdir(this.stateDir, { recursive: true });
+    await mkdir2(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       this.entitySynthesisQueuePath,
       JSON.stringify(
@@ -10388,7 +10404,7 @@ ${reflection}
     if (entries.length === 0) return 0;
     const memories = await this.readAllMemories();
     const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
-    const memoryPathMap = new Map(memories.map((m) => [path13.resolve(m.path), m]));
+    const memoryPathMap = new Map(memories.map((m) => [path14.resolve(m.path), m]));
     let updated = 0;
     const prevVersion = this.getMemoryCorpusVersion();
     let entityRefMoved = false;
@@ -10396,7 +10412,7 @@ ${reflection}
     const warm = this.hotMemoriesCacheEnabled && getCachedMemories(this.baseDir, prevVersion, keyId, this.hotCacheTtlMs()) !== null;
     const appliedPatches = /* @__PURE__ */ new Map();
     for (const entry of entries) {
-      const memory = entry.memoryPath ? memoryPathMap.get(path13.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
+      const memory = entry.memoryPath ? memoryPathMap.get(path14.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
       if (!memory) continue;
       try {
         const applied = await this.withTombstoneBlockedMemoryPathLock(memory.path, async (current) => {
@@ -10428,7 +10444,7 @@ ${current.content}
         if (warm) {
           updateCacheOnWrite(this.baseDir, { ...applied.current, frontmatter: applied.newFm }, keyId);
         }
-        appliedPatches.set(path13.resolve(memory.path), {
+        appliedPatches.set(path14.resolve(memory.path), {
           accessCount: entry.newCount,
           lastAccessed: entry.lastAccessed
         });
@@ -10446,7 +10462,7 @@ ${current.content}
         const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
         if (cur) {
           const reapplied = cur.map((m) => {
-            const patch = appliedPatches.get(path13.resolve(m.path));
+            const patch = appliedPatches.get(path14.resolve(m.path));
             return patch ? {
               ...m,
               frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed }
@@ -10476,7 +10492,7 @@ ${current.content}
     const pathsById = /* @__PURE__ */ new Map();
     const filePathsById = /* @__PURE__ */ new Map();
     for (const filePath of filePaths) {
-      const memoryId = path13.basename(filePath, ".md");
+      const memoryId = path14.basename(filePath, ".md");
       if (!wantedIds.has(memoryId)) continue;
       const paths = filePathsById.get(memoryId) ?? [];
       paths.push(filePath);
@@ -10488,7 +10504,7 @@ ${current.content}
       const preferredMatches = [];
       for (const preferredPath of preferred) {
         const directCandidates = new Set(qmdResultPathCandidates(this.baseDir, preferredPath));
-        const directMatch = existingPaths.find((filePath) => directCandidates.has(path13.resolve(filePath)));
+        const directMatch = existingPaths.find((filePath) => directCandidates.has(path14.resolve(filePath)));
         if (directMatch) {
           preferredMatches.push(directMatch);
           continue;
@@ -10500,7 +10516,7 @@ ${current.content}
             candidates.add(candidate);
           }
         }
-        const match = existingPaths.find((filePath) => candidates.has(path13.resolve(filePath)));
+        const match = existingPaths.find((filePath) => candidates.has(path14.resolve(filePath)));
         if (match) preferredMatches.push(match);
       }
       if (preferredMatches.length > 0) {
@@ -10822,11 +10838,11 @@ ${current.content}
     }
   }
   get summariesDir() {
-    return path13.join(this.baseDir, "summaries");
+    return path14.join(this.baseDir, "summaries");
   }
   async writeSummary(summary) {
-    await mkdir(this.summariesDir, { recursive: true });
-    const filePath = path13.join(this.summariesDir, `${summary.id}.json`);
+    await mkdir2(this.summariesDir, { recursive: true });
+    const filePath = path14.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
@@ -10836,7 +10852,7 @@ ${current.content}
       const summaries = [];
       for (const file of files) {
         if (isMacOsReplicationJunkBasename(file) || !file.endsWith(".json")) continue;
-        const filePath = path13.join(this.summariesDir, file);
+        const filePath = path14.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -10906,16 +10922,13 @@ ${current.content}
     return archived;
   }
   async saveTopics(topics) {
-    const metaPath = path13.join(this.stateDir, "topics.json");
-    await mkdir(this.stateDir, { recursive: true });
-    await this.writeStorageSecureFile(
-      metaPath,
-      JSON.stringify({ topics, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
-    );
+    const metaPath = path14.join(this.stateDir, "topics.json");
+    await mkdir2(this.stateDir, { recursive: true });
+    await this.writeStorageSecureFile(metaPath, JSON.stringify({ topics, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
     log.debug(`saved ${topics.length} topic scores`);
   }
   async loadTopics() {
-    const metaPath = path13.join(this.stateDir, "topics.json");
+    const metaPath = path14.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -11034,4 +11047,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-WCBLPKG3.js.map
+//# sourceMappingURL=chunk-5KZNWERU.js.map