@remnic/core 10.0.51 → 10.0.52

package/dist/access-cli.js

@@ -1,6 +1,6 @@
 import {
   Orchestrator
-} from "./chunk-SJD334AG.js";
+} from "./chunk-UM3ZLT2X.js";
 import "./chunk-YDIOMDBW.js";
 import "./chunk-V6Z4NAJZ.js";
 import "./chunk-5PHOU5QI.js";

package/dist/{chunk-SJD334AG.js → chunk-UM3ZLT2X.js}

@@ -5199,6 +5199,91 @@ async function readPromotionReceiptStatus(storage, filePath) {
   }
 }
 
+// src/orchestration/harmonic-construction-persist.ts
+function filterHarmonicEntityMentions(facts, entityMentions) {
+  const identitiesBySegment = /* @__PURE__ */ new Map();
+  for (const entity of entityMentions) {
+    const segment = harmonicEntitySegment(entity.name);
+    const identities = identitiesBySegment.get(segment) ?? /* @__PURE__ */ new Set();
+    identities.add(normalizedHarmonicEntityIdentity(entity.name));
+    identitiesBySegment.set(segment, identities);
+  }
+  return entityMentions.flatMap((entity) => {
+    const allowSegmentFallback = identitiesBySegment.get(harmonicEntitySegment(entity.name))?.size === 1;
+    const activeFacts = facts.filter(
+      (fact) => typeof fact.entityRef === "string" && harmonicEntityReferenceMatches(fact.entityRef, entity.name, allowSegmentFallback)
+    );
+    return activeFacts.length > 0 ? [{ ...entity, facts: activeFacts.map((fact) => fact.content) }] : [];
+  });
+}
+async function enqueueMergedTargetForHarmonicConstruction(entries, storage, fact, memoryId, content, insertedAt) {
+  let committed = null;
+  try {
+    committed = await storage.getMemoryByIdIncludingArchived(memoryId);
+  } catch {
+    committed = null;
+  }
+  const derived = committed && committed.content === content ? {
+    ...fact,
+    category: committed.frontmatter.category,
+    tags: [.../* @__PURE__ */ new Set([...committed.frontmatter.tags ?? [], ...fact.tags])],
+    entityRef: committed.frontmatter.entityRef ?? fact.entityRef,
+    validAt: committed.frontmatter.valid_at ?? fact.validAt
+  } : fact;
+  const entry = entries.get(storage.dir) ?? { storage, facts: [] };
+  const prior = entry.facts.findIndex((existing) => existing.memoryId === memoryId);
+  if (prior !== -1) {
+    entry.facts[prior] = {
+      ...derived,
+      content,
+      memoryId,
+      insertedAt,
+      cueAnchors: [
+        ...entry.facts[prior].cueAnchors ?? [],
+        ...derived.cueAnchors ?? []
+      ]
+    };
+  } else {
+    entry.facts.push({ ...derived, content, memoryId, insertedAt });
+  }
+  entries.set(storage.dir, entry);
+}
+async function persistConstructedHarmonicRecords(options) {
+  const sessionKey = options.sessionKey?.trim();
+  if (!sessionKey) {
+    log.warn("harmonic construction skipped: extraction session key is missing");
+    return;
+  }
+  const recordedAt = options.validAt && Number.isFinite(Date.parse(options.validAt)) ? new Date(options.validAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  const entries = [...options.entries];
+  const sharedEpisodeTitle = entries.length === 1 ? options.episodeTitle : void 0;
+  for (const entry of entries) {
+    try {
+      const records = deriveHarmonicRecords({
+        sessionKey,
+        recordedAt,
+        episodeTitle: sharedEpisodeTitle,
+        persistedFacts: entry.facts,
+        entityMentions: filterHarmonicEntityMentions(entry.facts, options.entityMentions).map((entity) => ({
+          name: entity.name,
+          type: entity.type,
+          facts: entity.facts
+        }))
+      });
+      await persistHarmonicRecords({
+        memoryDir: entry.storage.dir,
+        abstractionNodeStoreDir: entry.storage.dir === options.baseStorageDir ? options.abstractionNodeStoreDir : void 0,
+        nodes: records.nodes,
+        anchors: options.anchorsEnabled ? records.anchors : []
+      });
+    } catch (error) {
+      log.warn(
+        `harmonic construction failed open for namespace ${entry.storage.dir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+
 // src/orchestration/extraction-persist-promotion.ts
 var confidenceTierOrder = [
   "explicit",
@@ -5246,11 +5331,57 @@ async function readActiveMemoriesBothTiers(storage) {
   ]);
   return coldMems.length === 0 ? hotMems : [...hotMems, ...coldMems];
 }
-async function flushDeferredFactHashOnFailure(saveContentHashIndexes, deferred) {
-  if (!deferred) return;
-  await saveContentHashIndexes().catch(
-    (err) => log.warn(`content-hash flush after post-write failure failed: ${err}`)
+async function finalizeExtractionCommittedWrites(options) {
+  await options.saveContentHashIndexes().catch((err) => {
+    log.warn(`content-hash index save failed: ${err}`);
+  });
+  const behaviorEntries = [...options.behaviorSignalsByStorage];
+  for (const { storage: targetStorage, events } of behaviorEntries) {
+    const dedupedSignals = dedupeBehaviorSignalsByMemoryAndHash(events);
+    if (dedupedSignals.length === 0) continue;
+    await targetStorage.appendBehaviorSignals(dedupedSignals).catch(
+      (err) => log.warn(`appendBehaviorSignals failed (non-fatal): ${err}`)
+    );
+  }
+  const harmonic = options.harmonic;
+  let harmonicEntryCount = 0;
+  if (harmonic?.enabled) {
+    const entries = [...harmonic.entries];
+    harmonicEntryCount = entries.length;
+    if (entries.length > 0) {
+      await persistConstructedHarmonicRecords({
+        entries,
+        baseStorageDir: harmonic.baseStorageDir,
+        abstractionNodeStoreDir: harmonic.abstractionNodeStoreDir,
+        sessionKey: harmonic.sessionKey,
+        validAt: harmonic.validAt,
+        episodeTitle: harmonic.episodeTitle,
+        anchorsEnabled: harmonic.anchorsEnabled,
+        entityMentions: harmonic.entityMentions
+      });
+    }
+  }
+  void (async () => {
+    if (options.persistedIdsByStorage.size === 0) {
+      await options.updateTemporalTagIndexes(options.fallbackStorage, []);
+      return;
+    }
+    for (const entry of options.persistedIdsByStorage.values()) {
+      await options.updateTemporalTagIndexes(entry.storage, entry.ids);
+    }
+  })().catch(
+    (err) => log.debug(`temporal-index update error (non-fatal): ${err}`)
   );
+  if (!options.scheduleQmd || !options.requestQmdMaintenance) return;
+  const hasCommitted = options.persistedIdsByStorage.size > 0 || behaviorEntries.length > 0 || harmonicEntryCount > 0;
+  if (!hasCommitted) return;
+  try {
+    options.requestQmdMaintenance();
+  } catch (err) {
+    log.warn(
+      `QMD maintenance schedule after partial persist failed (non-fatal): ${err}`
+    );
+  }
 }
 function promotionWithholdsToolScope(options) {
   return options.toolScoped === true || withholdToolScopedFromSharedNamespace(options);
@@ -5427,91 +5558,6 @@ async function retireStaleMergedTargetPromotionCopies(args) {
   return retired;
 }
 
-// src/orchestration/harmonic-construction-persist.ts
-function filterHarmonicEntityMentions(facts, entityMentions) {
-  const identitiesBySegment = /* @__PURE__ */ new Map();
-  for (const entity of entityMentions) {
-    const segment = harmonicEntitySegment(entity.name);
-    const identities = identitiesBySegment.get(segment) ?? /* @__PURE__ */ new Set();
-    identities.add(normalizedHarmonicEntityIdentity(entity.name));
-    identitiesBySegment.set(segment, identities);
-  }
-  return entityMentions.flatMap((entity) => {
-    const allowSegmentFallback = identitiesBySegment.get(harmonicEntitySegment(entity.name))?.size === 1;
-    const activeFacts = facts.filter(
-      (fact) => typeof fact.entityRef === "string" && harmonicEntityReferenceMatches(fact.entityRef, entity.name, allowSegmentFallback)
-    );
-    return activeFacts.length > 0 ? [{ ...entity, facts: activeFacts.map((fact) => fact.content) }] : [];
-  });
-}
-async function enqueueMergedTargetForHarmonicConstruction(entries, storage, fact, memoryId, content, insertedAt) {
-  let committed = null;
-  try {
-    committed = await storage.getMemoryByIdIncludingArchived(memoryId);
-  } catch {
-    committed = null;
-  }
-  const derived = committed && committed.content === content ? {
-    ...fact,
-    category: committed.frontmatter.category,
-    tags: [.../* @__PURE__ */ new Set([...committed.frontmatter.tags ?? [], ...fact.tags])],
-    entityRef: committed.frontmatter.entityRef ?? fact.entityRef,
-    validAt: committed.frontmatter.valid_at ?? fact.validAt
-  } : fact;
-  const entry = entries.get(storage.dir) ?? { storage, facts: [] };
-  const prior = entry.facts.findIndex((existing) => existing.memoryId === memoryId);
-  if (prior !== -1) {
-    entry.facts[prior] = {
-      ...derived,
-      content,
-      memoryId,
-      insertedAt,
-      cueAnchors: [
-        ...entry.facts[prior].cueAnchors ?? [],
-        ...derived.cueAnchors ?? []
-      ]
-    };
-  } else {
-    entry.facts.push({ ...derived, content, memoryId, insertedAt });
-  }
-  entries.set(storage.dir, entry);
-}
-async function persistConstructedHarmonicRecords(options) {
-  const sessionKey = options.sessionKey?.trim();
-  if (!sessionKey) {
-    log.warn("harmonic construction skipped: extraction session key is missing");
-    return;
-  }
-  const recordedAt = options.validAt && Number.isFinite(Date.parse(options.validAt)) ? new Date(options.validAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
-  const entries = [...options.entries];
-  const sharedEpisodeTitle = entries.length === 1 ? options.episodeTitle : void 0;
-  for (const entry of entries) {
-    try {
-      const records = deriveHarmonicRecords({
-        sessionKey,
-        recordedAt,
-        episodeTitle: sharedEpisodeTitle,
-        persistedFacts: entry.facts,
-        entityMentions: filterHarmonicEntityMentions(entry.facts, options.entityMentions).map((entity) => ({
-          name: entity.name,
-          type: entity.type,
-          facts: entity.facts
-        }))
-      });
-      await persistHarmonicRecords({
-        memoryDir: entry.storage.dir,
-        abstractionNodeStoreDir: entry.storage.dir === options.baseStorageDir ? options.abstractionNodeStoreDir : void 0,
-        nodes: records.nodes,
-        anchors: options.anchorsEnabled ? records.anchors : []
-      });
-    } catch (error) {
-      log.warn(
-        `harmonic construction failed open for namespace ${entry.storage.dir}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-}
-
 // src/orchestration/semantic-merge-persist.ts
 import path5 from "path";
 
@@ -6925,6 +6971,28 @@ var ExtractionPersistCoordinator = class {
       0,
       this.deps.config.extractionMaxProfileUpdatesPerRun
     );
+    const finalizeCommittedWrites = async (scheduleQmd) => {
+      await finalizeExtractionCommittedWrites({
+        saveContentHashIndexes: () => this.deps.saveContentHashIndexes(),
+        behaviorSignalsByStorage: behaviorSignalsByStorage.values(),
+        harmonic: {
+          enabled: harmonicConstructionEnabled,
+          entries: harmonicFactsByStorage.values(),
+          baseStorageDir: storage.dir,
+          abstractionNodeStoreDir: !scopeProfileWritePlan && harmonicBaseNamespace === this.deps.config.defaultNamespace ? this.deps.config.abstractionNodeStoreDir : void 0,
+          sessionKey: sourceContext?.sessionKey,
+          validAt: sourceContext?.validAt,
+          episodeTitle: result.episodeTitle,
+          anchorsEnabled: harmonicAnchorsEnabled,
+          entityMentions: entities
+        },
+        updateTemporalTagIndexes: (target, ids) => this.deps.updateTemporalTagIndexes(target, ids),
+        fallbackStorage: storage,
+        persistedIdsByStorage,
+        requestQmdMaintenance: () => this.deps.requestQmdMaintenance(),
+        scheduleQmd
+      });
+    };
     if (facts.length < result.facts.length || entities.length < result.entities.length || questions.length < result.questions.length || profileUpdates.length < result.profileUpdates.length) {
       log.warn(
         `persistExtraction: capped extraction payload to guardrails (facts ${facts.length}/${result.facts.length}, entities ${entities.length}/${result.entities.length}, questions ${questions.length}/${result.questions.length}, profile ${profileUpdates.length}/${result.profileUpdates.length})`
@@ -7860,6 +7928,22 @@ var ExtractionPersistCoordinator = class {
       const memoryId = factWrite.id;
       const tombstoneBlocked = factWrite.tombstoneBlocked;
       const postWriteGuard = faithfulnessEnforceStatus === "pending_review" || tombstoneBlocked;
+      trackBehaviorSignals(
+        targetStorage,
+        buildBehaviorSignalsForMemory({
+          memoryId,
+          category: writeCategory,
+          content: fact.content,
+          namespace: this.deps.storageDirNamespace(targetStorage.dir),
+          confidence: fact.confidence,
+          source: "extraction"
+        })
+      );
+      trackPersistedId(targetStorage, memoryId, {
+        pendingReview: postWriteGuard,
+        category: writeCategory,
+        harmonicFact
+      });
       try {
         const contradictionOutcome = await this.deps.applyDeferredContradictionResolve(
           contradiction,
@@ -7871,7 +7955,9 @@ var ExtractionPersistCoordinator = class {
           await anchorSnapshots.remove(targetStorage, contradiction.supersededId);
         }
       } catch (err) {
-        await flushDeferredFactHashOnFailure(() => this.deps.saveContentHashIndexes(), factDedupEnabled);
+        await finalizeCommittedWrites(true).catch(
+          (finalizeErr) => log.warn(`committed-write finalization after post-write failure failed: ${finalizeErr}`)
+        );
         throw err;
       }
       if (routedRuleId) {
@@ -7899,22 +7985,6 @@ var ExtractionPersistCoordinator = class {
         }
       }
       try {
-        trackBehaviorSignals(
-          targetStorage,
-          buildBehaviorSignalsForMemory({
-            memoryId,
-            category: writeCategory,
-            content: fact.content,
-            namespace: this.deps.storageDirNamespace(targetStorage.dir),
-            confidence: fact.confidence,
-            source: "extraction"
-          })
-        );
-        trackPersistedId(targetStorage, memoryId, {
-          pendingReview: postWriteGuard,
-          category: writeCategory,
-          harmonicFact
-        });
         await anchorSnapshots.replace(targetStorage, memoryId, writeCategory, memoryPathById);
         if (!postWriteGuard && threadEpisodeIdsForGraph && !threadEpisodeIdsForGraph.includes(memoryId)) {
           threadEpisodeIdsForGraph.push(memoryId);
@@ -8015,7 +8085,9 @@ var ExtractionPersistCoordinator = class {
           );
         }
       } catch (err) {
-        await flushDeferredFactHashOnFailure(() => this.deps.saveContentHashIndexes(), factDedupEnabled);
+        await finalizeCommittedWrites(true).catch(
+          (finalizeErr) => log.warn(`committed-write finalization after post-write failure failed: ${finalizeErr}`)
+        );
         throw err;
       }
     }
@@ -8051,7 +8123,10 @@ var ExtractionPersistCoordinator = class {
           recordDurableNonFactWrite();
         }
       } catch (err) {
-        log.warn(`persistExtraction: entity write failed: ${err}`);
+        await finalizeCommittedWrites(true).catch(
+          (finalizeErr) => log.warn(`committed-write finalization after entity failure failed: ${finalizeErr}`)
+        );
+        throw err;
       }
     }
     if (resolveRecallEnhancementCapabilities(this.deps.config).entityRelationships && Array.isArray(result.relationships)) {
@@ -8131,19 +8206,7 @@ ${q.context ?? ""}`], entityScreenOn, entityScreenProfile);
     if (durableNonFactWritten) {
       touchBaseNonFactNamespace();
     }
-    await this.deps.saveContentHashIndexes().catch((err) => {
-      log.warn(`content-hash index save failed: ${err}`);
-    });
-    for (const {
-      storage: targetStorage,
-      events
-    } of behaviorSignalsByStorage.values()) {
-      const dedupedSignals = dedupeBehaviorSignalsByMemoryAndHash(events);
-      if (dedupedSignals.length === 0) continue;
-      await targetStorage.appendBehaviorSignals(dedupedSignals).catch(
-        (err) => log.warn(`appendBehaviorSignals failed (non-fatal): ${err}`)
-      );
-    }
+    await finalizeCommittedWrites(false);
     const dedupSuffix = `${dedupedCount > 0 ? ` (${dedupedCount} deduped)` : ""}${semanticMergedCount > 0 ? ` (${semanticMergedCount} merged)` : ""}`;
     const gatedSuffix = importanceGatedCount > 0 ? ` (${importanceGatedCount} gated)` : "";
     const judgeSuffix = judgeGatedCount > 0 ? ` (${judgeGatedCount} judge-rejected)` : "";
@@ -8151,29 +8214,6 @@ ${q.context ?? ""}`], entityScreenOn, entityScreenProfile);
     log.info(
       `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount - semanticMergedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}${redactionSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
     );
-    if (harmonicConstructionEnabled && harmonicFactsByStorage.size > 0) {
-      await persistConstructedHarmonicRecords({
-        entries: harmonicFactsByStorage.values(),
-        baseStorageDir: storage.dir,
-        abstractionNodeStoreDir: !scopeProfileWritePlan && harmonicBaseNamespace === this.deps.config.defaultNamespace ? this.deps.config.abstractionNodeStoreDir : void 0,
-        sessionKey: sourceContext?.sessionKey,
-        validAt: sourceContext?.validAt,
-        episodeTitle: result.episodeTitle,
-        anchorsEnabled: harmonicAnchorsEnabled,
-        entityMentions: entities
-      });
-    }
-    void (async () => {
-      if (persistedIdsByStorage.size === 0) {
-        await this.deps.updateTemporalTagIndexes(storage, []);
-        return;
-      }
-      for (const entry of persistedIdsByStorage.values()) {
-        await this.deps.updateTemporalTagIndexes(entry.storage, entry.ids);
-      }
-    })().catch(
-      (err) => log.debug(`temporal-index update error (non-fatal): ${err}`)
-    );
     this.deps.setLastPersistExtractionPendingReviewIds(pendingReviewPersistedIds);
     return { persistedIds, memoryPathById };
   }
@@ -22023,7 +22063,8 @@ var Orchestrator = class {
         indexPersistedMemory: (storage, memoryId) => this.indexPersistedMemory(storage, memoryId),
         buildGraphEdge: (storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps) => this.buildGraphEdge(storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps),
         invalidateGraphEdgeCache: (storage) => this.graphIndexFor(storage).invalidateEdgeCache(),
-        updateTemporalTagIndexes: (storage, persistedIds) => this.updateTemporalTagIndexes(storage, persistedIds)
+        updateTemporalTagIndexes: (storage, persistedIds) => this.updateTemporalTagIndexes(storage, persistedIds),
+        requestQmdMaintenance: () => this.requestQmdMaintenance()
       });
     }
     return this._extractionPersistCoordinator;
@@ -31573,4 +31614,4 @@ export {
   qmdStartupCollectionChecksWithTimeout,
   Orchestrator
 };
-//# sourceMappingURL=chunk-SJD334AG.js.map
+//# sourceMappingURL=chunk-UM3ZLT2X.js.map