@remnic/core 9.49.0 → 9.49.1

package/src/orchestration/extraction-persist.ts

@@ -37,6 +37,8 @@ import { semanticChunkContent, type SemanticChunkResult } from "../semantic-chun
 import { isAboveImportanceThreshold, scoreImportance } from "../importance.js";
 import { sanitizeMemoryContent } from "../sanitize.js";
 import {
+  resolveCapabilities,
+  resolveConsolidationCapabilities,
   resolveGraphConstructionCapabilities,
   resolveMemoryLifecycleCapabilities,
   resolvePipelineProcessingCapabilities,
@@ -90,6 +92,7 @@ import {
 import { buildProcedurePersistBody } from "../procedural/procedure-types.js";
 import { stripAttributesSuffix } from "../structured-attributes.js";
 import { LocalLlmClient } from "../local-llm.js";
+import type { ExtractionEngine } from "../extraction.js";
 import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
@@ -117,106 +120,17 @@ import {
   readActiveMemoriesBothTiers,
   shouldPromoteToShared,
 } from "./extraction-persist-promotion.js";
+import type { ExtractionPersistDeps } from "./extraction-persist-deps.js";
 import type { ResolvedScopeProfilePlan } from "../namespaces/scope-profiles.js";
 import {
   buildMemoryPathById,
   appendMemoryToGraphContext,
   resolvePersistedMemoryRelativePath,
 } from "../orchestrator.js";
+import type { HarmonicConstructionInput } from "../harmonic-construction.js";
+import { persistConstructedHarmonicRecords } from "./harmonic-construction-persist.js";
+
 
-export interface ExtractionPersistDeps {
-  config: PluginConfig;
-  getStorageRouter: () => NamespaceStorageRouter;
-  getThreading: () => ThreadingManager;
-  getLocalLlm: () => LocalLlmClient;
-  getQmd: () => SearchBackend;
-  getJudgeVerdictCache: () => Map<string, JudgeVerdict>;
-  getJudgeDeferCounts: () => Map<string, number>;
-  getFaithfulnessCounters: () => FaithfulnessGateCounters;
-  getEmbeddingFallback: () => EmbeddingFallback;
-  setLastPersistExtractionDeferredCount: (value: number) => void;
-  setLastPersistExtractionPendingReviewIds: (ids: string[]) => void;
-  addContentHashDedup: (targetStorage: StorageManager, content: string) => Promise<void>;
-  hasContentHashDedup: (targetStorage: StorageManager, content: string) => Promise<boolean>;
-  backfillTemporalBoundsOnDedupHit: (
-    targetStorage: StorageManager,
-    dedupContent: string,
-    bounds: {
-      invalidAt?: string;
-      validFrom?: string;
-      observedAt?: string;
-      eventTimeSource?: "extracted" | "assumed";
-    },
-    entityRef?: string,
-    sourceConnector?: string,
-  ) => Promise<void>;
-  saveContentHashIndexes: () => Promise<void>;
-  artifactTypeForCategory: (
-    category: string,
-  ) =>
-    | "decision"
-    | "constraint"
-    | "todo"
-    | "definition"
-    | "commitment"
-    | "correction"
-    | "fact";
-  loadRoutingRules: () => Promise<RouteRule[]>;
-  routeEngineOptions: () => RoutingEngineOptions;
-  semanticDedupLookup: (
-    content: string,
-    limit: number,
-    targetStorage: StorageManager,
-  ) => Promise<SemanticDedupHit[]>;
-  checkForContradiction: (
-    content: string,
-    category: string,
-    namespaceScope: string,
-  ) => Promise<{
-    supersededId: string;
-    confidence: number;
-    reason: string;
-    supersededPath: string;
-    supersededCreated: string;
-    supersededTags: string[];
-  } | null>;
-  applyDeferredContradictionResolve: (
-    contradiction: {
-      supersededId: string;
-      reason: string;
-      supersededPath: string;
-      supersededCreated: string;
-      supersededTags: string[];
-    } | null | undefined,
-    storage: StorageManager,
-    newMemoryId: string,
-    postWriteGuard: boolean,
-  ) => Promise<void>;
-  suggestLinksForMemory: (
-    content: string,
-    category: string,
-    namespaceScope: string,
-  ) => Promise<MemoryLink[]>;
-  storageDirNamespace: (storageDir: string) => string;
-  indexPersistedMemory: (storage: StorageManager, memoryId: string) => Promise<void>;
-  buildGraphEdge: (
-    storage: StorageManager,
-    memoryRelPath: string,
-    entityRef: string | undefined,
-    memoryId: string,
-    factContent: string,
-    allMemsForGraph: MemoryFile[] | null | undefined,
-    memoryPathById: Map<string, string>,
-    threadIdForEdge: string | undefined,
-    threadEpisodeIdsForGraph: string[] | undefined,
-    fallbackCausalPredecessor: string | undefined,
-    graphCaps?: GraphConstructionCapabilitySet,
-  ) => Promise<void>;
-  updateTemporalTagIndexes: (
-    storage: StorageManager,
-    persistedIds: string[],
-  ) => Promise<void>;
-}
 
 export class ExtractionPersistCoordinator {
   constructor(
@@ -254,6 +168,20 @@ export class ExtractionPersistCoordinator {
     // ensureFactHashIndexAuthoritative), so a deferred write, crash, or
     // multi-process interleave is safe by construction with no marker to guard.
     const factDedupEnabled = resolveRecallAuxiliaryCapabilities(this.deps.config).factDeduplication;
+    const harmonicConstructionEnabled = resolveCapabilities(this.deps.config).harmonicRetrieval;
+    const harmonicAnchorsEnabled =
+      resolveConsolidationCapabilities(this.deps.config).abstractionAnchors;
+    const harmonicBaseNamespace =
+      baseNamespace ?? this.deps.storageDirNamespace(storage.dir);
+    const harmonicFactsByStorage = new Map<
+      string,
+      {
+        storage: StorageManager;
+        facts: HarmonicConstructionInput["persistedFacts"];
+      }
+    >();
+    const harmonicSourceInsertedAtBase = Date.now();
+    let harmonicSourceOrder = 0;
 
   // Canonicalize stored content for dedup comparison: strip citations
   // (using the same template), sanitize, then normalize whitespace.
@@ -304,6 +232,10 @@ export class ExtractionPersistCoordinator {
         /** #1635: keep this id out of the persisted thread episode set. */
         pendingReview?: boolean;
         category?: MemoryCategory;
+        harmonicFact?: Omit<
+          HarmonicConstructionInput["persistedFacts"][number],
+          "memoryId"
+        >;
       } = {},
     ): void => {
       if (options.includeReturnedIds !== false) {
@@ -319,6 +251,23 @@ export class ExtractionPersistCoordinator {
       } else {
         persistedIdsByStorage.set(key, { storage: targetStorage, ids: [id] });
       }
+      if (
+        harmonicConstructionEnabled &&
+        options.harmonicFact &&
+        !options.pendingReview
+      ) {
+        const harmonicEntry = harmonicFactsByStorage.get(key) ?? {
+          storage: targetStorage,
+          facts: [],
+        };
+        harmonicEntry.facts.push({
+          ...options.harmonicFact,
+          memoryId: id,
+          insertedAt: new Date(harmonicSourceInsertedAtBase + harmonicSourceOrder).toISOString(),
+        });
+        harmonicSourceOrder++;
+        harmonicFactsByStorage.set(key, harmonicEntry);
+      }
       if (options.category && !memoryPathById.has(id)) {
         const relPath = resolvePersistedMemoryRelativePath({ memoryId: id, pathById: memoryPathById, category: options.category });
         memoryPathById.set(id, relPath);
@@ -420,6 +369,10 @@ export class ExtractionPersistCoordinator {
       sources?: ProvenanceSource[];
       provenance?: "verified" | "unverified" | "none";
       toolScoped?: true;
+      harmonicFact?: Omit<
+        HarmonicConstructionInput["persistedFacts"][number],
+        "memoryId"
+      >;
     }): Promise<void> => {
       if (
         !scopeProfileWritePlan ||
@@ -558,6 +511,9 @@ export class ExtractionPersistCoordinator {
                 structuredAttributes: { ...targetSurvivingAttrs },
                 createdAt: supersessionOrderingAt(options.validAt),
                 enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
+                extraction: this.deps.getExtraction(),
+                config: this.config,
+                namespaceScope: this.deps.storageDirNamespace(targetStorage.dir),
               });
             } catch (profileSupersessionErr) {
               log.warn(
@@ -568,7 +524,11 @@ export class ExtractionPersistCoordinator {
           // #1645 TV6: a tombstone-blocked promotion is pending_review (no
           // active copy) — skip catalog/index/behavior like postWriteGuard.
           if (!targetPromotion.tombstoneBlocked) {
-            trackPersistedId(targetStorage, promotedId, { includeReturnedIds: false, category: options.category as MemoryCategory });
+            trackPersistedId(targetStorage, promotedId, {
+              includeReturnedIds: false,
+              category: options.category as MemoryCategory,
+              harmonicFact: options.harmonicFact,
+            });
             await this.deps.indexPersistedMemory(targetStorage, promotedId);
             trackBehaviorSignals(
               targetStorage,
@@ -616,6 +576,10 @@ export class ExtractionPersistCoordinator {
       /** Claim-level provenance spans (issue #1575 PR 2). */
       sources?: ProvenanceSource[];
       provenance?: "verified" | "unverified" | "none";
+      harmonicFact?: Omit<
+        HarmonicConstructionInput["persistedFacts"][number],
+        "memoryId"
+      >;
     }): Promise<void> => {
       const toolScoped = withholdToolScopedFromSharedNamespace(options);
       await promoteMemoryToProfileTargets({
@@ -849,6 +813,9 @@ export class ExtractionPersistCoordinator {
                   createdAt: supersessionOrderingAt(options.validAt),
                   enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
                   useCallerTimestamp: true,
+                  extraction: this.deps.getExtraction(),
+                  config: this.config,
+                  namespaceScope: this.deps.storageDirNamespace(sharedStorage.dir),
                 });
                 // Catalog touch (issue #1499 — codex P2 NElSf): this dedup branch
                 // returns WITHOUT the post-write catalog touch (now at the storage chokepoint #1522),
@@ -971,6 +938,9 @@ export class ExtractionPersistCoordinator {
               structuredAttributes: { ...sharedSurvivingAttrs },
               createdAt: supersessionOrderingAt(options.validAt),
               enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
+              extraction: this.deps.getExtraction(),
+              config: this.config,
+              namespaceScope: this.deps.storageDirNamespace(sharedStorage.dir),
             });
           } catch (sharedSupersessionErr) {
             log.warn(
@@ -992,6 +962,7 @@ export class ExtractionPersistCoordinator {
           trackPersistedId(sharedStorage, promotedId, {
             includeReturnedIds: false,
             category: options.category as MemoryCategory,
+            harmonicFact: options.harmonicFact,
           });
           await this.deps.indexPersistedMemory(sharedStorage, promotedId);
           trackBehaviorSignals(
@@ -1650,6 +1621,17 @@ export class ExtractionPersistCoordinator {
           );
         }
       }
+      const harmonicFact: Omit<
+        HarmonicConstructionInput["persistedFacts"][number],
+        "memoryId"
+      > = {
+        category: writeCategory,
+        content: fact.content,
+        tags: fact.tags,
+        cueAnchors: fact.cueAnchors,
+        entityRef: fact.entityRef,
+        validAt: biTemporal?.validFrom ?? sourceContext?.validAt,
+      };
       // #1669 redaction-rule gate: consult BOTH source and target namespace
       // rules before any write. A never-store pattern registered under the
       // source namespace must survive scope-routing to a different target
@@ -2346,6 +2328,7 @@ export class ExtractionPersistCoordinator {
           trackPersistedId(targetStorage, parentId, {
             pendingReview: postWriteGuard,
             category: writeCategory,
+            harmonicFact,
           });
           // #1576 (cursor Medium): keep pending_review ids out of threadEpisodeIdsForGraph — else later active facts build thread-predecessor edges to an unfaithful memory.
           if (
@@ -2383,6 +2366,9 @@ export class ExtractionPersistCoordinator {
                 // supersede a later active fact (codex P1 on :15534).
                 enabled: lifecycleCaps.temporalSupersession &&
                   !(biTemporal && !biTemporal.validFrom),
+                extraction: this.deps.getExtraction(),
+                config: this.config,
+                namespaceScope: this.deps.storageDirNamespace(targetStorage.dir),
               });
             } catch (err) {
               log.warn(`temporal-supersession (chunked): unexpected error: ${err}`);
@@ -2418,6 +2404,7 @@ export class ExtractionPersistCoordinator {
             ...(fact.procedureSteps && fact.procedureSteps.length ? { procedureSteps: fact.procedureSteps } : {}),
             ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
             ...(fact.provenance ? { provenance: fact.provenance } : {}),
+            harmonicFact,
           });
           // Register chunked content in the target storage hash index too.
           // Thread 3 fix: canonicalize by stripping any pre-existing citation
@@ -2654,6 +2641,9 @@ export class ExtractionPersistCoordinator {
             createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
             enabled: lifecycleCaps.temporalSupersession &&
               !(biTemporal && !biTemporal.validFrom),
+            extraction: this.deps.getExtraction(),
+            config: this.config,
+            namespaceScope: this.deps.storageDirNamespace(targetStorage.dir),
           });
         } catch (err) {
           log.warn(`temporal-supersession: unexpected error: ${err}`);
@@ -2674,6 +2664,7 @@ export class ExtractionPersistCoordinator {
         trackPersistedId(targetStorage, memoryId, {
           pendingReview: postWriteGuard,
           category: writeCategory,
+          harmonicFact,
         });
         if (
           !postWriteGuard &&
@@ -2721,6 +2712,7 @@ export class ExtractionPersistCoordinator {
           ...(fact.procedureSteps && fact.procedureSteps.length ? { procedureSteps: fact.procedureSteps } : {}),
           ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
           ...(fact.provenance ? { provenance: fact.provenance } : {}),
+          harmonicFact,
         });
         // v8.2: graph edge building (fail-open). #1576: skip pending_review facts.
         if (graphCaps.multiGraphMemory && !postWriteGuard) {
@@ -2994,6 +2986,21 @@ export class ExtractionPersistCoordinator {
     log.info(
       `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount} 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
+            : undefined,
+        sessionKey: sourceContext?.sessionKey,
+        validAt: sourceContext?.validAt,
+        episodeTitle: result.episodeTitle,
+        anchorsEnabled: harmonicAnchorsEnabled,
+        entityMentions: entities,
+      });
+    }
     // Update temporal + tag indexes (v8.1) — fire-and-forget, fail-open
     void (async () => {
       if (persistedIdsByStorage.size === 0) {

package/src/orchestration/harmonic-construction-persist.ts

@@ -0,0 +1,86 @@
+import {
+  type HarmonicConstructionInput,
+  deriveHarmonicRecords,
+  harmonicEntityReferenceMatches,
+  harmonicEntitySegment,
+  normalizedHarmonicEntityIdentity,
+  persistHarmonicRecords,
+} from "../harmonic-construction.js";
+import { log } from "../logger.js";
+import type { ExtractionResult } from "../types.js";
+
+export interface HarmonicPersistenceEntry {
+  storage: { dir: string };
+  facts: HarmonicConstructionInput["persistedFacts"];
+}
+
+export function filterHarmonicEntityMentions(
+  facts: HarmonicConstructionInput["persistedFacts"],
+  entityMentions: ExtractionResult["entities"]
+): ExtractionResult["entities"] {
+  const identitiesBySegment = new Map<string, Set<string>>();
+  for (const entity of entityMentions) {
+    const segment = harmonicEntitySegment(entity.name);
+    const identities = identitiesBySegment.get(segment) ?? new Set<string>();
+    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) }] : [];
+  });
+}
+
+export async function persistConstructedHarmonicRecords(options: {
+  entries: Iterable<HarmonicPersistenceEntry>;
+  baseStorageDir: string;
+  abstractionNodeStoreDir?: string;
+  sessionKey?: string;
+  validAt?: string;
+  episodeTitle?: string;
+  anchorsEnabled: boolean;
+  entityMentions: ExtractionResult["entities"];
+}): Promise<void> {
+  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()
+      : new Date().toISOString();
+  const entries = [...options.entries];
+  const sharedEpisodeTitle = entries.length === 1 ? options.episodeTitle : undefined;
+  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 : undefined,
+        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)}`
+      );
+    }
+  }
+}

package/src/orchestration/recall-internal.ts

@@ -1551,6 +1551,7 @@ export class RecallInternalCoordinator {
               maxResults,
               sessionKey,
               anchorsEnabled: resolveConsolidationCapabilities(this.deps.config).abstractionAnchors,
+              temporalExpiredInInjection: this.deps.config.temporalExpiredInInjection,
               abortSignal: harmonicRetrievalAbort.signal,
             }),
           ),

package/src/orchestrator.ts

@@ -784,13 +784,13 @@ export class Orchestrator {
    * its own methods + coordinators.
    */
   private _consolidationRunCoordinator: ConsolidationRunCoordinator | undefined;
-
   private get consolidationRunCoordinator(): ConsolidationRunCoordinator {
     if (!this._consolidationRunCoordinator) {
       this._consolidationRunCoordinator = new ConsolidationRunCoordinator({
         config: this.config,
         getStorage: () => this.storage,
         getStorageRouter: () => this.storageRouter,
+        getNamespaceCatalog: () => this.namespaceCatalog,
         getExtraction: () => this.extraction,
         embeddingFallback: this.embeddingFallback,
         tmtBuilder: this.tmtBuilder,
@@ -825,6 +825,7 @@ export class Orchestrator {
         getStorageRouter: () => this.storageRouter,
         getThreading: () => this.threading,
         getLocalLlm: () => this.localLlm,
+        getExtraction: () => this.extraction,
         getQmd: () => this.qmd,
         getJudgeVerdictCache: () => this.judgeVerdictCache,
         getJudgeDeferCounts: () => this.judgeDeferCounts,

package/src/schemas.ts

@@ -81,6 +81,16 @@ export const ExtractedFactSchema = z.object({
     .optional()
     .nullable()
     .describe("If about an entity, its normalized name (e.g. person-jane-doe)"),
+  cueAnchors: z
+    .array(
+      z.object({
+        type: z.enum(["entity", "file", "tool", "outcome", "constraint", "date"]),
+        value: z.string(),
+      }),
+    )
+    .optional()
+    .nullable()
+    .describe("Up to three short retrieval cues for this fact."),
   promptedByQuestion: z
     .string()
     .optional()
@@ -296,6 +306,11 @@ export const ExtractionResultSchema = z.object({
     .describe(
       "A brief reflection on what you learned about yourself as an agent in this interaction — patterns in your behavior, growth, things you did well or could improve.",
     ),
+  episodeTitle: z
+    .string()
+    .optional()
+    .nullable()
+    .describe("A six-to-eight word title for this conversation segment."),
   relationships: z
     .array(ExtractedRelationshipSchema)
     .optional()

package/src/storage.ts

@@ -365,6 +365,15 @@ function serializeFrontmatter(fm: MemoryFrontmatter): string {
   if (fm.tombstoneBlockTier) lines.push(`tombstoneBlockTier: ${fm.tombstoneBlockTier}`);
   if (fm.supersededBy) lines.push(`supersededBy: ${fm.supersededBy}`);
   if (fm.supersededAt) lines.push(`supersededAt: ${fm.supersededAt}`);
+  if (fm.supersessionCause) {
+    if (fm.supersessionCause !== "direct" && fm.supersessionCause !== "dependency") {
+      throw new Error(
+        `serializeFrontmatter: invalid supersessionCause ${JSON.stringify(fm.supersessionCause)} — expected "direct" | "dependency"`,
+      );
+    }
+    lines.push(`supersessionCause: ${fm.supersessionCause}`);
+  }
+  if (fm.invalidatedBy) lines.push(`invalidatedBy: ${fm.invalidatedBy}`);
   if (fm.archivedAt) lines.push(`archivedAt: ${fm.archivedAt}`);
   // Issue #680 — explicit fact lifecycle.  Emit only when present so legacy
   // memories round-trip unchanged; readers default `valid_at` to `created`.
@@ -893,6 +902,11 @@ export function parseFrontmatter(raw: string): { frontmatter: MemoryFrontmatter;
       supersededBy: fm.supersededBy || undefined,
       supersededAt: fm.supersededAt || undefined,
       archivedAt: fm.archivedAt || undefined,
+      supersessionCause:
+        fm.supersessionCause === "direct" || fm.supersessionCause === "dependency"
+          ? fm.supersessionCause
+          : undefined,
+      invalidatedBy: fm.invalidatedBy || undefined,
       // Issue #680 — explicit fact lifecycle round-trip.
       valid_at: fm.validAt || undefined,
       invalid_at: fm.invalidAt || undefined,

package/src/temporal-supersession.ts

@@ -12,10 +12,12 @@
  * cached `readAllMemories()` path so cost is amortized with the rest of the
  * write pipeline.
  */
-import type { MemoryFile, MemoryFrontmatter } from "./types.js";
+import type { MemoryFile, MemoryFrontmatter, PluginConfig } from "./types.js";
+import type { ExtractionEngine } from "./extraction.js";
 import type { StorageManager } from "./storage.js";
 import { log } from "./logger.js";
 import { effectiveValidAt } from "./temporal-validity.js";
+import { propagateInvalidation } from "./orchestration/dependency-propagation.js";
 
 /**
  * Shared normalization for supersession key components.
@@ -244,6 +246,10 @@ export async function applyTemporalSupersession(args: {
    * stale relative to the incoming promotion event (PR #402 Finding Uyui).
    */
   useCallerTimestamp?: boolean;
+  /** Optional orchestration dependencies for one-hop propagation. */
+  extraction?: ExtractionEngine;
+  config?: PluginConfig;
+  namespaceScope?: string;
 }): Promise<TemporalSupersessionResult> {
   const empty: TemporalSupersessionResult = { supersededIds: [], matchedKeys: [] };
   if (!args.enabled) return empty;
@@ -509,6 +515,28 @@ export async function applyTemporalSupersession(args: {
             );
           }
         }
+        if (args.extraction && args.config && args.namespaceScope) {
+          try {
+            await propagateInvalidation(
+              {
+                storage: args.storage,
+                extraction: args.extraction,
+                config: args.config,
+              },
+              {
+                oldMemory: fresh,
+                replacementId: args.newMemoryId,
+                replacementContent: newMemoryFile?.content ?? null,
+                cause: "temporal_supersession",
+                namespaceScope: args.namespaceScope,
+              },
+            );
+          } catch (propagationErr) {
+            log.warn(
+              `temporal-supersession: dependency propagation failed for ${fresh.frontmatter.id}: ${propagationErr}`,
+            );
+          }
+        }
       }
     } catch (err) {
       log.warn(

package/src/testing/orchestrator-lite.ts

@@ -14,6 +14,7 @@ import os from "node:os";
 import path from "node:path";
 
 import { parseConfig } from "../config.js";
+import { getAbstractionNodeStoreStatus, type AbstractionNodeStoreStatus } from "../abstraction-nodes.js";
 import type { Orchestrator } from "../orchestrator.js";
 import type { ExtractionRunCoordinatorDeps } from "../orchestration/extraction-run.js";
 import type { BufferTurn, ExtractionResult, PluginConfig } from "../types.js";
@@ -25,10 +26,7 @@ import type { BufferTurn, ExtractionResult, PluginConfig } from "../types.js";
  * init gate floored so a recall() that never ran initialize() does not block.
  * Mirrors tests/orchestrator-characterization.test.ts:makeConfig.
  */
-export function makeLifecycleConfig(
-  memoryDir: string,
-  overrides: Record<string, unknown> = {},
-): PluginConfig {
+export function makeLifecycleConfig(memoryDir: string, overrides: Record<string, unknown> = {}): PluginConfig {
   return parseConfig({
     openaiApiKey: "sk-test",
     memoryDir,
@@ -47,6 +45,27 @@ export function makeLifecycleConfig(
   });
 }
 
+/** Enable the production harmonic-construction persistence path for a lifecycle row. */
+export function makeHarmonicLifecycleConfig(memoryDir: string, overrides: Record<string, unknown> = {}): PluginConfig {
+  return makeLifecycleConfig(memoryDir, {
+    harmonicRetrievalEnabled: true,
+    ...overrides,
+  });
+}
+
+/** Read and validate abstraction nodes written by the production store path. */
+export function harmonicNodeStoreStatus(
+  memoryDir: string,
+  abstractionNodeStoreDir?: string
+): Promise<AbstractionNodeStoreStatus> {
+  return getAbstractionNodeStoreStatus({
+    memoryDir,
+    abstractionNodeStoreDir,
+    enabled: true,
+    anchorsEnabled: false,
+  });
+}
+
 /** Create a fresh temp memory dir with a stable `remnic-lifecycle-<label>-` prefix. */
 export function mkTempMemoryDir(label: string): Promise<string> {
   return mkdtemp(path.join(os.tmpdir(), `remnic-lifecycle-${label}-`));
@@ -95,7 +114,7 @@ interface ExtractionClientSeam {
  */
 export function stubExtraction(
   orchestrator: Orchestrator,
-  factory: (turns: BufferTurn[], call: number) => ExtractionResult | Promise<ExtractionResult>,
+  factory: (turns: BufferTurn[], call: number) => ExtractionResult | Promise<ExtractionResult>
 ): BufferTurn[][] {
   const calls: BufferTurn[][] = [];
   // The `extraction` field is private and structurally unexpressible from
@@ -143,7 +162,7 @@ interface PersistExtractionSeam {
  */
 export function stubPersistExtraction(
   orchestrator: Orchestrator,
-  factory?: (args: PersistExtractionArgs, call: number) => string[] | Promise<string[]>,
+  factory?: (args: PersistExtractionArgs, call: number) => string[] | Promise<string[]>
 ): PersistExtractionArgs[] {
   const calls: PersistExtractionArgs[] = [];
   // `persistExtraction` is replaced in place; the named cast keeps the
@@ -191,7 +210,7 @@ export async function seedFactFile(memoryDir: string, id: string, content: strin
       content,
       "",
     ].join("\n"),
-    "utf-8",
+    "utf-8"
   );
   return file;
 }
@@ -222,7 +241,7 @@ export async function memoryFilesContaining(root: string, needle: string): Promi
 export async function eventually<T>(
   probe: () => Promise<T | null | undefined | false>,
   label: string,
-  timeoutMs = 5000,
+  timeoutMs = 5000
 ): Promise<T> {
   const startedAt = Date.now();
   for (;;) {