@remnic/core 9.3.699 → 9.3.701

package/dist/search/remote-backend.d.ts

@@ -1,5 +1,5 @@
 import { SearchBackend, SearchQueryOptions, SearchExecutionOptions, SearchResult } from './port.js';
-import '../types-CeZYSC-E.js';
+import '../types-PuiPZ9iE.js';
 import '../types-ByK7T3L6.js';
 import '../index-DJ9QWMw-.js';
 

package/dist/{semantic-consolidation-CgREi9E0.d.ts → semantic-consolidation-BtUfv-AL.d.ts}

@@ -1,4 +1,4 @@
-import { P as PluginConfig, g as MemoryFile } from './types-CeZYSC-E.js';
+import { P as PluginConfig, g as MemoryFile } from './types-PuiPZ9iE.js';
 import { RolloutSummaryInput, MaterializeResult } from './connectors/codex-materialize.js';
 import { LoggerBackend } from './logger.js';
 import { SemanticConsolidationLlmOperator } from './consolidation-operator.js';

package/dist/semantic-consolidation.d.ts

@@ -1,6 +1,6 @@
-import './types-CeZYSC-E.js';
+import './types-PuiPZ9iE.js';
 import './connectors/codex-materialize.js';
-export { C as ConsolidationCluster, O as OperatorAwareConsolidationResult, S as SemanticConsolidationResult, a as buildConsolidationPrompt, b as buildExtensionsBlockForConsolidation, c as buildOperatorAwareConsolidationPrompt, e as chooseConsolidationOperator, f as findSimilarClusters, m as materializeAfterSemanticConsolidation, p as parseConsolidationResponse, g as parseOperatorAwareConsolidationResponse, r as resolveExtensionsRoot } from './semantic-consolidation-CgREi9E0.js';
+export { C as ConsolidationCluster, O as OperatorAwareConsolidationResult, S as SemanticConsolidationResult, a as buildConsolidationPrompt, b as buildExtensionsBlockForConsolidation, c as buildOperatorAwareConsolidationPrompt, e as chooseConsolidationOperator, f as findSimilarClusters, m as materializeAfterSemanticConsolidation, p as parseConsolidationResponse, g as parseOperatorAwareConsolidationResponse, r as resolveExtensionsRoot } from './semantic-consolidation-BtUfv-AL.js';
 export { CONSOLIDATION_OPERATORS, ConsolidationOperator, SemanticConsolidationLlmOperator, isConsolidationOperator, isSemanticConsolidationLlmOperator, isValidDerivedFromEntry } from './consolidation-operator.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';

package/dist/semantic-consolidation.js

@@ -7,20 +7,24 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-SJQ4HY3E.js";
-import "./chunk-2ULWWAQH.js";
+} from "./chunk-JO3E5VGS.js";
+import "./chunk-ISLJ5WIM.js";
 import "./chunk-UUH4YQOF.js";
 import {
   resolveExtensionsRoot
 } from "./chunk-JLNBQWZ2.js";
 import "./chunk-3UXOZBHV.js";
-import "./chunk-RIC5U67B.js";
+import "./chunk-SFMRLXIV.js";
+import "./chunk-3JJWNZTT.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import "./chunk-OMNTQPZO.js";
+import "./chunk-IREVVFTM.js";
 import "./chunk-SVOZFLIQ.js";
+import "./chunk-LTJAMRGI.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-ZXUOAFUG.js";
+import "./chunk-IKNQAGBV.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-MB5RSUW6.js";
 import "./chunk-6KYMPV2O.js";

package/dist/semantic-rule-promotion.js

@@ -1,14 +1,18 @@
 import {
   promoteSemanticRuleFromMemory,
   setSemanticRulePromotionTestHooks
-} from "./chunk-2KJG6ZZK.js";
-import "./chunk-RIC5U67B.js";
+} from "./chunk-IYOPIG3E.js";
+import "./chunk-SFMRLXIV.js";
+import "./chunk-3JJWNZTT.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import "./chunk-OMNTQPZO.js";
+import "./chunk-IREVVFTM.js";
 import "./chunk-SVOZFLIQ.js";
+import "./chunk-LTJAMRGI.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-ZXUOAFUG.js";
+import "./chunk-IKNQAGBV.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-MB5RSUW6.js";
 import "./chunk-6KYMPV2O.js";

package/dist/semantic-rule-verifier.d.ts

@@ -1,4 +1,4 @@
-import { g as MemoryFile } from './types-CeZYSC-E.js';
+import { g as MemoryFile } from './types-PuiPZ9iE.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 

package/dist/semantic-rule-verifier.js

@@ -1,14 +1,18 @@
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-N55RJT4N.js";
-import "./chunk-RIC5U67B.js";
+} from "./chunk-QP37KL5H.js";
+import "./chunk-SFMRLXIV.js";
+import "./chunk-3JJWNZTT.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import "./chunk-OMNTQPZO.js";
+import "./chunk-IREVVFTM.js";
 import "./chunk-SVOZFLIQ.js";
+import "./chunk-LTJAMRGI.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-ZXUOAFUG.js";
+import "./chunk-IKNQAGBV.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-MB5RSUW6.js";
 import "./chunk-6KYMPV2O.js";

package/dist/session-observer-bands.d.ts

@@ -1,4 +1,4 @@
-import { a2 as SessionObserverBandConfig } from './types-CeZYSC-E.js';
+import { S as SessionObserverBandConfig } from './types-PuiPZ9iE.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 

package/dist/session-observer-state.d.ts

@@ -1,4 +1,4 @@
-import { a2 as SessionObserverBandConfig } from './types-CeZYSC-E.js';
+import { S as SessionObserverBandConfig } from './types-PuiPZ9iE.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 

package/dist/shared-context/manager.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { P as PluginConfig } from '../types-CeZYSC-E.js';
+import { P as PluginConfig } from '../types-PuiPZ9iE.js';
 import '../types-ByK7T3L6.js';
 import '../index-DJ9QWMw-.js';
 

package/dist/signal.d.ts

@@ -1,4 +1,4 @@
-import { au as SignalScanResult } from './types-CeZYSC-E.js';
+import { al as SignalScanResult } from './types-PuiPZ9iE.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 

package/dist/storage.d.ts

@@ -1,4 +1,4 @@
-import { P as PluginConfig, h as MemoryStatus, M as MemoryCategory, I as ImportanceScore, i as MemoryLink, j as MemoryFrontmatter, F as FaithfulnessFrontmatter, g as MemoryFile, E as EntityStructuredSection, k as BufferState, l as MetaState, m as MemoryActionEvent, n as MemoryLifecycleEvent, o as BufferSurpriseEvent, B as BehaviorSignalEvent, C as CompressionGuidelineOptimizerState, p as ContinuityIncidentOpenInput, q as ContinuityIncidentRecord, r as ContinuityIncidentCloseInput, s as ContinuityImprovementLoop, t as ContinuityLoopUpsertInput, u as ContinuityLoopReviewInput, v as FileHygieneConfig, w as EntityRelationship, x as EntityActivityEntry, y as EntityFile, z as AccessTrackingEntry, D as MemoryProjectionCurrentState, H as MemorySummary, T as TopicScore } from './types-CeZYSC-E.js';
+import { P as PluginConfig, h as MemoryStatus, M as MemoryCategory, a9 as ImportanceScore, ao as MemoryLink, k as MemoryFrontmatter, F as FaithfulnessFrontmatter, g as MemoryFile, $ as EntityStructuredSection, ap as BufferState, aq as MetaState, W as MemoryActionEvent, m as MemoryLifecycleEvent, z as BufferSurpriseEvent, B as BehaviorSignalEvent, X as CompressionGuidelineOptimizerState, a5 as ContinuityIncidentOpenInput, a3 as ContinuityIncidentRecord, a4 as ContinuityIncidentCloseInput, a6 as ContinuityImprovementLoop, a8 as ContinuityLoopUpsertInput, a7 as ContinuityLoopReviewInput, ar as FileHygieneConfig, as as EntityRelationship, at as EntityActivityEntry, E as EntityFile, au as AccessTrackingEntry, l as MemoryProjectionCurrentState, av as MemorySummary, an as TopicScore } from './types-PuiPZ9iE.js';
 import { VersioningConfig } from './page-versioning.js';
 import { ConsolidationOperator } from './consolidation-operator.js';
 import { ProjectedMemoryBrowseOptions, ProjectedMemoryBrowsePage, readProjectedGovernanceRecord } from './memory-projection-store.js';
@@ -9,6 +9,233 @@ import './maintenance/memory-governance.js';
 import './runtime/better-sqlite.js';
 import 'better-sqlite3';
 
+/** Why a tombstone was emitted. */
+type TombstoneReason = "correction" | "supersession" | "retraction" | "contradiction_resolution";
+/** Who emitted the tombstone. */
+type TombstoneCreatedBy = "user_correction" | "contradiction_resolution" | "supersession" | "chat";
+/** Tier that matched on lookup. */
+type TombstoneMatchTier = "exact" | "normalized" | "keyed" | "semantic";
+/**
+ * A single append-only tombstone log entry.
+ *
+ * `kind: "tombstone"` blocks; `kind: "revocation"` re-allows. The log is
+ * never rewritten — the NEWEST matching entry wins at lookup (rule 25).
+ */
+interface TombstoneEntry {
+    /** Stable tombstone id (`tomb-<ts>-<rand>`). */
+    id: string;
+    kind: "tombstone" | "revocation";
+    reason: TombstoneReason;
+    /** The memory that was retired. */
+    sourceMemoryId: string;
+    /** sha256 of the retired memory's rawContent (rule 23). */
+    contentHash: string;
+    /** `ContentHashIndex.normalizeContent(rawContent)` — the pre-hash form. */
+    normalizedText: string;
+    entityRef?: string;
+    /** Structured-attribute supersession key when one existed. */
+    supersessionKey?: string;
+    /** Namespace scope (rule 42). */
+    namespace: string;
+    createdAt: string;
+    createdBy: TombstoneCreatedBy;
+    /** For `kind: "revocation"`: the tombstone id being revoked. */
+    revokes?: string;
+}
+/** A positive block decision returned by `TombstoneStore.lookup`. */
+interface TombstoneMatch {
+    tombstoneId: string;
+    matchedTier: TombstoneMatchTier;
+    reason: TombstoneReason;
+}
+/** Inputs to a lookup. At least one discriminator must be present.
+ *
+ * Issue #1579 thread Ociag/Oci-W: `supersessionKeys` (plural) lets the write
+ * chokepoint check EVERY derived key, not just the first. Emitters register
+ * one tombstone per matched key (temporal-supersession, rebuild), so a block
+ * can live on any later key; querying only `supersessionKeys[0]` missed it
+ * and the retired fact resurrected as active. `supersessionKey` (singular)
+ * remains for direct/unit callers; `lookup` checks the union of both. */
+interface TombstoneLookupQuery {
+    contentHash?: string;
+    normalizedText?: string;
+    entityRef?: string;
+    /** Single supersession key (direct/unit callers). */
+    supersessionKey?: string;
+    /** All derived supersession keys (write chokepoint). The keyed tier is
+     *  checked for each; the first active match wins. */
+    supersessionKeys?: string[];
+    namespace: string;
+}
+/** Configuration for a tombstone store instance. */
+interface TombstoneStoreOptions {
+    enabled: boolean;
+    semanticMatch: boolean;
+    semanticThreshold: number;
+    /** sha256 of raw content — wired to `ContentHashIndex.computeHash`. */
+    hashContent: (raw: string) => string;
+    /** Normalize raw content — wired to `ContentHashIndex.normalizeContent`. */
+    normalizeText: (raw: string) => string;
+    /**
+     * Optional cosine similarity in [0, 1] for the semantic tier. When
+     * undefined or when `semanticMatch` is false, the semantic tier is
+     * skipped entirely.
+     */
+    semanticSimilarity?: (a: string, b: string) => number;
+}
+/** Injected file I/O — the StorageManager wires its secure-store-aware
+ * implementations so tombstones are encrypted at rest alongside other state.
+ * `stat` is optional; when provided the store tracks the file mtime itself and
+ * runs a cross-process staleness probe on each access (#1579). */
+interface TombstoneFileIo {
+    read: (filePath: string) => Promise<string>;
+    append: (filePath: string, content: string) => Promise<void>;
+    write: (filePath: string, content: string) => Promise<void>;
+    stat?: (filePath: string) => {
+        mtimeMs: number;
+    };
+}
+/** Aggregate stats for `remnic doctor`. */
+interface TombstoneStats {
+    count: number;
+    revoked: number;
+    lastAppendAt: string | null;
+    corruptedLines: number;
+    /** Whether the in-memory index matches the on-disk file (rebuild check). */
+    loaded: boolean;
+}
+/**
+ * The instance-scoped tombstone store. One per StorageManager (rule 11),
+ * namespace-scoped via `namespace` + the on-disk path (rule 42).
+ *
+ * The in-memory index is built lazily on first access and invalidated on
+ * append + by the StorageManager's cache-invalidation chokepoint (rule 25).
+ */
+declare class TombstoneStore {
+    private readonly filePath;
+    private readonly namespace;
+    private readonly options;
+    private readonly io;
+    private entries;
+    /** contentHash → tombstone id (newest) — exact tier. */
+    private readonly byHash;
+    /** normalizedText → tombstone id (newest) — normalized tier. */
+    private readonly byNormalized;
+    /** entityRef\0supersessionKey → tombstone id (newest) — keyed tier. */
+    private readonly byKey;
+    /** Tombstone ids that have a later revocation entry. */
+    private readonly revokedIds;
+    /** id → entry index (newest only, for revocation lookups). */
+    private readonly byId;
+    private loaded;
+    private loadPromise;
+    private corruptedLines;
+    private lastAppendAt;
+    /**
+     * Last-seen mtime of the JSONL file (cross-process staleness probe, #1579).
+     * Tracked inside the store so the StorageManager wiring stays thin. When the
+     * file's mtime advances past this value between accesses, the in-memory index
+     * is stale (a peer process appended) and is reloaded before the next lookup.
+     */
+    private fileMtimeMs;
+    constructor(filePath: string, namespace: string, options: TombstoneStoreOptions, io: TombstoneFileIo);
+    /** Lazy load + build the in-memory index. Idempotent. */
+    load(): Promise<void>;
+    private loadInternal;
+    private resetIndex;
+    /**
+     * Index an entry. Later entries (higher array index = newer createdAt)
+     * OVERRIDE earlier ones at each tier key — the newest matching entry wins
+     * (rule 25). Revocation entries mark their target as revoked.
+     */
+    private indexEntry;
+    /** Invalidate the in-memory cache (rule 25). The next access reloads. */
+    invalidate(): void;
+    /**
+     * Cross-process staleness probe (#1579). If the file's mtime advanced since
+     * the last load/own-write, a peer process appended and our in-memory index is
+     * stale — invalidate AND reload in place so the next lookup sees the new
+     * entries. Best-effort: a stat error is swallowed (the loaded index is
+     * retained rather than crashing the write path). No-op when no `stat` was
+     * injected or when the mtime is unchanged. After our own append/revoke/rebuild
+     * `markWritten` records the new mtime, so this probe does not fire for our
+     * own writes (only for peer-process appends).
+     */
+    ensureFreshAgainstDisk(): Promise<void>;
+    /**
+     * Record the file mtime after THIS process writes (append / revoke / rebuild)
+     * so `ensureFreshAgainstDisk` does not treat our own write as a peer append
+     * and throw away the just-updated in-memory index (#1579 — avoids a needless
+     * invalidate+reload in the hot write path).
+     */
+    private markWritten;
+    private recordFileMtime;
+    /**
+     * Append a tombstone entry. Serialized via `serializeMutations` keyed by
+     * file path so concurrent appends do not interleave, with rejection recovery
+     * (rule 40 — a single failed append never poisons the chain). The in-memory
+     * index is updated AFTER the durable append succeeds.
+     *
+     * Returns the new tombstone id.
+     */
+    appendTombstone(input: {
+        reason: TombstoneReason;
+        createdBy: TombstoneCreatedBy;
+        sourceMemoryId: string;
+        rawContent: string;
+        entityRef?: string;
+        supersessionKey?: string;
+        createdAt?: string;
+        /**
+         * Pre-computed canonical contentHash from the retired memory's frontmatter.
+         * When provided, used directly so the tombstone's exact tier matches the
+         * hash writeMemory computes on re-extraction (issue #1579 review: cited
+         * facts must not slip past the chokepoint because the emitter hashed the
+         * citation-annotated body instead of the canonical source).
+         */
+        contentHash?: string;
+    }): Promise<string>;
+    /**
+     * Append a revocation entry referencing `tombstoneId`. The log is
+     * append-only; lookup treats a revoked tombstone as re-allowed (rule 25).
+     */
+    revoke(tombstoneId: string, createdBy: TombstoneCreatedBy): Promise<string>;
+    private serializeAppend;
+    /**
+     * Look up whether `query` is blocked by an active (non-revoked) tombstone.
+     * Tiers are checked in order: exact (contentHash) → normalized → keyed →
+     * semantic (off by default). Returns the first active match, or `null`.
+     *
+     * Namespace isolation (rule 42): only entries with `namespace === query.namespace`
+     * match. The store is per-namespace, so this is belt-and-suspenders.
+     */
+    lookup(query: TombstoneLookupQuery): TombstoneMatch | null;
+    /** Aggregate stats for the doctor / x-ray surfaces. */
+    stats(): TombstoneStats;
+    /** Read-only snapshot of all entries (for rebuild + tests). */
+    snapshot(): readonly TombstoneEntry[];
+    /**
+     * Rebuild the in-memory index + JSONL from the supplied retired-memory
+     * records + existing entries (preserving revocations). Byte-stable: entries
+     * are sorted by (createdAt, id) before write (rule 38).
+     *
+     * Returns the count of tombstone entries written.
+     */
+    rebuild(retiredMemories: ReadonlyArray<RetiredMemoryRecord>): Promise<number>;
+}
+/** A retired memory projected into the shape `TombstoneStore.rebuild` consumes. */
+interface RetiredMemoryRecord {
+    memoryId: string;
+    rawContent: string;
+    entityRef?: string;
+    supersessionKey?: string;
+    reason: TombstoneReason;
+    createdBy: TombstoneCreatedBy;
+    createdAt: string;
+    /** Canonical contentHash from the retired memory's frontmatter (#1579). */
+    contentHash?: string;
+}
+
 interface ReextractJobRequest {
     memoryId: string;
     model: string;
@@ -132,6 +359,9 @@ declare class StorageManager {
     /** Post-write catalog hook (#1522). Installed by the namespace router; fire-and-forget. */
     onCatalogWrite?: () => void;
     private notifyCatalogWrite;
+    private tombstoneStore;
+    private tombstoneStoreLoadPromise;
+    private tombstonesConfig;
     /** Page-versioning configuration.  Set by the orchestrator after construction. */
     private _versioningConfig;
     /** Set the page-versioning configuration.  When `enabled` is false (default), all versioning calls are no-ops. */
@@ -255,7 +485,10 @@ declare class StorageManager {
      * Promote a pending_review wearable memory to active in place,
      * merging updated trust evidence into structuredAttributes. Returns
      * false when the memory is missing or no longer pending_review (a
-     * concurrent review decision wins).
+     * concurrent review decision wins), or when the row is tombstone-blocked
+     * (`blockedBy` — issue #1579 threads OcuDx/Ocu1l): writeMemoryFrontmatter
+     * bypasses the writeMemory chokepoint, so a blocked row must first be
+     * cleared via revokeTombstone before promotion can proceed.
      */
     promoteWearableMemory(id: string, attributeUpdates: Record<string, string>, confidence?: number): Promise<boolean>;
     /**
@@ -300,6 +533,66 @@ declare class StorageManager {
     private get offlineSyncDigestCachePath();
     private get entitySynthesisQueuePath();
     private get factHashIndexReadyPath();
+    /**
+     * The on-disk tombstone log path. Lives under `<stateDir>/tombstones.jsonl`
+     * so it is co-located with the fact-hash index and encrypted at rest when
+     * the secure-store is enabled (the StorageManager's secure read/write
+     * helpers are injected into the store).
+     */
+    private get tombstonesPath();
+    /**
+     * Configure the tombstone invariant for this storage instance. Installed
+     * by the orchestrator after construction (same pattern as
+     * `setVersioningConfig` / `citationTemplate`). When `enabled` is false
+     * (default until the orchestrator wires config), the chokepoint check is a
+     * no-op — pre-feature behavior for rollback safety (rule 30).
+     */
+    setTombstonesConfig(config: {
+        enabled: boolean;
+        semanticMatch: boolean;
+        semanticThreshold: number;
+        namespace: string;
+    }): void;
+    private buildTombstoneStore;
+    /**
+     * Lazily load the tombstone store. Mirrors the fact-hash-index lazy-load
+     * pattern: a single in-flight load promise dedups concurrent first-access.
+     * The cross-process staleness probe lives inside the store now (#1579): on
+     * each cached access it stats its own file and invalidates if a peer process
+     * appended, so the next lookup reloads from disk. If the probe just
+     * invalidated the store, fall through to the reload branch — returning null
+     * here was the original regression (the chokepoint threw and failed OPEN).
+     */
+    getTombstoneStore(): Promise<TombstoneStore>;
+    /**
+     * Append a tombstone for a retired memory (issue #1579 emitters).
+     * Best-effort: a tombstone append failure MUST NOT fail the supersession /
+     * correction that triggered it (gotcha #13 / rule 34). The memory is
+     * already retired on disk; the tombstone is the non-resurrection guard.
+     */
+    appendTombstone(input: {
+        reason: TombstoneReason;
+        createdBy: TombstoneCreatedBy;
+        sourceMemoryId: string;
+        rawContent: string;
+        entityRef?: string;
+        supersessionKey?: string;
+        createdAt?: string;
+        /** Canonical contentHash from the retired memory's frontmatter (#1579). */
+        contentHash?: string;
+    }): Promise<string | null>;
+    /**
+     * Revoke a tombstone (re-allow the content). Used by the review-queue
+     * approval path when an operator approves a blocked memory.
+     */
+    revokeTombstone(tombstoneId: string, createdBy: TombstoneCreatedBy): Promise<string | null>;
+    /** Aggregate tombstone stats for `remnic doctor`. */
+    getTombstoneStats(): Promise<TombstoneStats | null>;
+    /**
+     * Rebuild the tombstone log from retired memories on disk. Exposed for
+     * `remnic doctor --rebuild-tombstones` and tests.
+     */
+    rebuildTombstonesFromFiles(): Promise<number>;
     private getFactHashIndex;
     private ensureFactHashIndexAuthoritative;
     private get questionsDir();
@@ -422,6 +715,17 @@ declare class StorageManager {
     hasFactContentHash(content: string): Promise<boolean>;
     private factContentHashForRemoval;
     private addActiveFactContentHash;
+    /**
+     * Re-register a fact's contentHash in the dedup index after a tombstone
+     * block is lifted on approval (issue #1579 thread ObnTy). `writeMemory`
+     * skips hash-index registration for tombstone-blocked facts (rule 44); when
+     * the review queue later promotes such a fact back to `status: active`, the
+     * hash must enter the index or the next extraction of the same content
+     * creates a second active fact. Reads the memory by id so the caller (the
+     * review CLI) does not need to re-parse the file. No-op for non-facts or
+     * facts that are not active.
+     */
+    restoreFactHashAfterApproval(memoryId: string): Promise<void>;
     private syncFactHashIndexAfterRewrite;
     removeFactContentHashesForMemories(memories: MemoryFile[]): Promise<void>;
     isFactContentHashAuthoritative(): Promise<boolean>;

package/dist/storage.js

@@ -8,15 +8,19 @@ import {
   normalizeEntityName,
   parseEntityFile,
   serializeEntityFile
-} from "./chunk-RIC5U67B.js";
+} from "./chunk-SFMRLXIV.js";
+import "./chunk-3JJWNZTT.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import "./chunk-OMNTQPZO.js";
+import "./chunk-IREVVFTM.js";
 import {
   stripAttributesSuffix
 } from "./chunk-SVOZFLIQ.js";
+import "./chunk-LTJAMRGI.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-ZXUOAFUG.js";
+import "./chunk-IKNQAGBV.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-MB5RSUW6.js";
 import "./chunk-6KYMPV2O.js";

package/dist/summarizer.d.ts

@@ -1,5 +1,5 @@
 import { ModelRegistry } from './model-registry.js';
-import { P as PluginConfig, G as GatewayConfig, $ as TranscriptEntry, a1 as HourlySummary } from './types-CeZYSC-E.js';
+import { P as PluginConfig, G as GatewayConfig, T as TranscriptEntry, H as HourlySummary } from './types-PuiPZ9iE.js';
 import { TranscriptManager } from './transcript.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';

package/dist/summarizer.js

@@ -1,12 +1,13 @@
 import {
   HourlySummarizer
-} from "./chunk-RC3CNIPK.js";
-import "./chunk-XJNBEDFE.js";
+} from "./chunk-IO5NQEGZ.js";
+import "./chunk-3FAMU5TX.js";
 import "./chunk-PWFWCGOO.js";
 import "./chunk-24D66MMN.js";
 import "./chunk-S4DDLTPX.js";
 import "./chunk-FF4KLI5W.js";
 import "./chunk-O75CRYGF.js";
+import "./chunk-LTJAMRGI.js";
 import "./chunk-5J4OL7TJ.js";
 import "./chunk-IQVQJJL7.js";
 import "./chunk-VL7DP3OW.js";

package/dist/summary-snapshot.d.ts

@@ -1,4 +1,4 @@
-import { a1 as HourlySummary } from './types-CeZYSC-E.js';
+import { H as HourlySummary } from './types-PuiPZ9iE.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 

package/dist/summary-snapshot.js

@@ -3,8 +3,9 @@ import {
   summarySnapshotPath,
   upsertSummarySnapshot,
   writeSummarySnapshot
-} from "./chunk-XJNBEDFE.js";
+} from "./chunk-3FAMU5TX.js";
 import "./chunk-FF4KLI5W.js";
+import "./chunk-LTJAMRGI.js";
 import "./chunk-PZ5AY32C.js";
 export {
   readSummarySnapshot,

package/dist/temporal-supersession.d.ts

@@ -1,4 +1,4 @@
-import { j as MemoryFrontmatter } from './types-CeZYSC-E.js';
+import { k as MemoryFrontmatter } from './types-PuiPZ9iE.js';
 import { StorageManager } from './storage.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';

package/dist/temporal-supersession.js

@@ -6,7 +6,7 @@ import {
   shouldFilterSupersededFromRecall,
   shouldSupersedeExisting,
   supersessionKeysForFact
-} from "./chunk-MRFVMSTR.js";
+} from "./chunk-OMNTQPZO.js";
 import "./chunk-IREVVFTM.js";
 import "./chunk-NU3CSQ4H.js";
 import "./chunk-PZ5AY32C.js";

package/dist/temporal-validity.d.ts

@@ -1,4 +1,4 @@
-import { j as MemoryFrontmatter } from './types-CeZYSC-E.js';
+import { k as MemoryFrontmatter } from './types-PuiPZ9iE.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 

package/dist/threading.d.ts

@@ -1,4 +1,4 @@
-import { _ as BufferTurn, av as ConversationThread } from './types-CeZYSC-E.js';
+import { u as BufferTurn, am as ConversationThread } from './types-PuiPZ9iE.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 

package/dist/tier-migration.d.ts

@@ -1,4 +1,4 @@
-import { g as MemoryFile } from './types-CeZYSC-E.js';
+import { g as MemoryFile } from './types-PuiPZ9iE.js';
 import { StorageManager } from './storage.js';
 import { MemoryTier } from './tier-routing.js';
 import { SearchBackend } from './search/port.js';

package/dist/tier-routing.d.ts

@@ -1,4 +1,4 @@
-import { g as MemoryFile } from './types-CeZYSC-E.js';
+import { g as MemoryFile } from './types-PuiPZ9iE.js';
 import { LifecycleSignals } from './lifecycle.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';

package/dist/topics.d.ts

@@ -1,4 +1,4 @@
-import { g as MemoryFile, T as TopicScore } from './types-CeZYSC-E.js';
+import { g as MemoryFile, an as TopicScore } from './types-PuiPZ9iE.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 

package/dist/transcript.d.ts

@@ -1,4 +1,4 @@
-import { P as PluginConfig, $ as TranscriptEntry, a0 as Checkpoint } from './types-CeZYSC-E.js';
+import { P as PluginConfig, T as TranscriptEntry, v as Checkpoint } from './types-PuiPZ9iE.js';
 import { SessionIntegrityReport } from './session-integrity.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';