@remnic/core 9.4.2 → 9.6.0

package/dist/storage-C1maCNbc.d.ts

@@ -0,0 +1,1591 @@
+import { M as MemoryFile, P as PluginConfig, u as MemoryStatus, t as MemoryCategory, ae as ImportanceScore, ar as MemoryLink, p as MemoryFrontmatter, F as FaithfulnessFrontmatter, J as ProvenanceSource, a7 as EntityStructuredSection, as as BufferState, at as MetaState, a2 as MemoryActionEvent, w as MemoryLifecycleEvent, X as BufferSurpriseEvent, B as BehaviorSignalEvent, a3 as CompressionGuidelineOptimizerState, aa as ContinuityIncidentOpenInput, a8 as ContinuityIncidentRecord, a9 as ContinuityIncidentCloseInput, ab as ContinuityImprovementLoop, ad as ContinuityLoopUpsertInput, ac as ContinuityLoopReviewInput, au as FileHygieneConfig, av as EntityRelationship, aw as EntityActivityEntry, E as EntityFile, ax as AccessTrackingEntry, v as MemoryProjectionCurrentState, ay as MemorySummary, ap as TopicScore, az as EntityTimelineEntry } from './types-CGgcNWCG.js';
+import { VersioningConfig } from './page-versioning.js';
+import { ConsolidationOperator } from './consolidation-operator.js';
+import { ProjectedMemoryBrowseOptions, ProjectedMemoryBrowsePage, readProjectedGovernanceRecord } from './memory-projection-store.js';
+import './structured-attributes.js';
+
+/**
+ * Wearable cross-source fusion — shared types (issue #1810).
+ *
+ * Fusion merges same-day conversations from multiple enabled wearable
+ * sources into `FusedWearableConversation` artifacts: one reconciled
+ * timeline per real-world conversation, with per-segment source
+ * provenance and unresolved conflicts surfaced as `disagreements[]`.
+ *
+ * Everything in this module is DETERMINISTIC — no LLM calls. LLM-assisted
+ * reconciliation, memory-extraction over fused artifacts, and full
+ * segment-level alignment are deferred follow-ups (see PR body).
+ */
+/**
+ * One normalized segment fed into fusion. Speaker labels are already
+ * resolved through the speaker registry (`resolveSpeaker`), and text is
+ * post-cleanup + post-redaction — fusion consumes the same material day
+ * transcripts store, never raw provider output.
+ */
+interface FusionSegmentInput {
+    /** Resolved speaker label (e.g. "Jane", "Me (you)", "Speaker 0"). */
+    speaker: string;
+    /** Whether this speaker is the wearer. */
+    isSelf: boolean;
+    /** Utterance text. */
+    text: string;
+    /** ISO 8601 start, when known. */
+    startIso?: string;
+    /** ISO 8601 end, when known. */
+    endIso?: string;
+}
+/** One normalized conversation fed into fusion. */
+interface FusionConversationInput {
+    /** Source id this conversation came from. */
+    source: string;
+    /** Provider-stable conversation id within that source. */
+    conversationId: string;
+    /** Provider title, when available. */
+    title?: string;
+    /** Provider summary, when available. */
+    summary?: string;
+    /** ISO 8601 conversation start. */
+    startIso: string;
+    /** ISO 8601 conversation end, when known. */
+    endIso?: string;
+    /** Ordered normalized segments. */
+    segments: FusionSegmentInput[];
+}
+/** Why a particular source's text was chosen for a fused segment. */
+type SegmentPickReason = "only-source" | "higher-trust" | "more-complete" | "tie-break";
+/** Kind of unresolved conflict surfaced during reconciliation. */
+type DisagreementKind = "asr-text" | "speaker" | "timestamp";
+/** Per-segment record of where the chosen text came from and what else was considered. */
+interface FusedSegmentProvenance {
+    /** Source id the chosen text came from. */
+    source: string;
+    /** Conversation id within that source. */
+    conversationId: string;
+    /** Trust weight of the chosen source at reconciliation time (0..1). */
+    sourceTrust: number;
+    /** Why this source won the pick. */
+    reason: SegmentPickReason;
+    /** Other sources that offered a candidate text for this window/speaker. */
+    alternatives: Array<{
+        source: string;
+        text: string;
+    }>;
+    /** The chosen source's ORIGINAL start time (ISO), when known. The fused
+     * segment is emitted on the group/window ANCHOR timeline position so
+     * pre-sorted chronology stays valid even when the higher-trust source's
+     * clock is later than the anchor; this preserves WHERE the chosen text
+     * was actually recorded for provenance/traceability. */
+    sourceStartIso?: string;
+    /** The chosen source's ORIGINAL end time (ISO), when known (see sourceStartIso). */
+    sourceEndIso?: string;
+}
+/** One reconciled utterance in a fused conversation. */
+interface FusedSegment {
+    /** Reconciled speaker label. */
+    speaker: string;
+    /** Whether this speaker is the wearer. */
+    isSelf: boolean;
+    /** Reconciled utterance text. */
+    text: string;
+    /** Window start (ISO), when known. */
+    startIso?: string;
+    /** Window end (ISO), when known. */
+    endIso?: string;
+    /** 0..1 confidence in this segment's text + attribution. */
+    confidence: number;
+    provenance: FusedSegmentProvenance;
+}
+/** An unresolved conflict that reconciliation could not settle deterministically. */
+interface FusedDisagreement {
+    kind: DisagreementKind;
+    /**
+     * What the disagreement concerns — an ISO window anchor, a speaker
+     * label, or "(no timestamp)" for un-timestamped windows.
+     */
+    subject: string;
+    /** The conflicting candidates that could not be auto-resolved. */
+    candidates: Array<{
+        source: string;
+        value: string;
+    }>;
+    /** Best-effort provisional winner; marked uncertain, NOT authoritative. */
+    provisional?: {
+        source: string;
+        value: string;
+    };
+}
+/** A reconciled speaker that appears in the fused conversation. */
+interface FusedSpeaker {
+    /** Display label. */
+    label: string;
+    /** Whether this speaker is the wearer. */
+    isSelf: boolean;
+    /**
+     * 0..1 — lowered when a speaker could not be confidently matched
+     * across sources (e.g. a generic diarization label seen in one
+     * source only).
+     */
+    confidence: number;
+    /** Source ids that produced this speaker. */
+    sources: string[];
+}
+/** Record of one source conversation that fed a fused conversation. */
+interface FusedContribution {
+    source: string;
+    conversationId: string;
+    startIso: string;
+    endIso?: string;
+    segmentCount: number;
+}
+/** How a fused conversation was assembled. */
+interface FusedConversationProvenance {
+    /** Source conversations that fed this cluster. */
+    contributions: FusedContribution[];
+    /** Max gap (ms) two conversations could span and still merge. */
+    proximityGapMs: number;
+    /** Max drift (ms) for two segments to align across sources. */
+    windowToleranceMs: number;
+    /** Clustering method (deterministic, time-proximity based). */
+    method: "time-proximity";
+}
+/**
+ * A real-world conversation reconstructed from one or more wearable
+ * sources recording at the same time. The fused artifact.
+ */
+interface FusedWearableConversation {
+    /** Stable content-hash id (deterministic from inputs; idempotent). */
+    id: string;
+    /** YYYY-MM-DD the conversation was recorded. */
+    date: string;
+    /** Earliest start across contributing sources. */
+    startIso: string;
+    /** Latest end across contributing sources, when known. */
+    endIso?: string;
+    /** Source ids that contributed at least one conversation. */
+    sources: string[];
+    /** Reconciled speakers (deduped across sources). */
+    speakers: FusedSpeaker[];
+    /** Provider title, when any source supplied one. */
+    title?: string;
+    /** Provider summary, when any source supplied one. */
+    summary?: string;
+    /** Aligned, reconciled segments in chronological order. */
+    segments: FusedSegment[];
+    /** Unresolved conflicts surfaced during reconciliation. */
+    disagreements: FusedDisagreement[];
+    provenance: FusedConversationProvenance;
+}
+/** Options for a fusion pass. */
+interface FusionOptions {
+    /** Max gap (ms) between conversations to merge into one cluster. */
+    proximityGapMs?: number;
+    /** Max drift (ms) for two segments to align across sources. */
+    windowToleranceMs?: number;
+    /** Per-source trust weights (unknown sources default to 0.8). */
+    sourceTrust?: Record<string, number>;
+}
+/** Result of fusing one day across all sources. */
+interface FusionDayResult {
+    date: string;
+    conversations: FusedWearableConversation[];
+    /** Distinct source ids that contributed any conversation. */
+    sources: string[];
+    /** SHA-256 over the canonical input serialization + effective fusion config (idempotency key). */
+    contentHash: string;
+}
+/** Frontmatter persisted on a fused-day derived file. */
+interface FusedDayMeta {
+    kind: "wearable-fusion";
+    date: string;
+    sourceCount: number;
+    conversationCount: number;
+    contentHash: string;
+    /**
+     * SHA-256 over the canonical serialized body (`hashFusionBody`). Stored
+     * so the skip-unchanged path can detect a body whose bytes drifted from
+     * the recomputed artifact even when `contentHash` + conversation count
+     * still match — forcing a self-repair rewrite on body-level corruption.
+     */
+    bodyHash: string;
+    fusedAt: string;
+}
+/** A parsed fused-day derived file. */
+interface FusedDayFile {
+    meta: FusedDayMeta;
+    conversations: FusedWearableConversation[];
+    /**
+     * False when the JSON body failed to parse (truncated/corrupt). A
+     * legitimately empty (`[]`) body parses fine — parseOk stays true — so
+     * callers can distinguish "nothing to fuse" from a broken file and force
+     * a self-repair rewrite even when the frontmatter hash matches and the
+     * parsed conversation count is also zero.
+     */
+    parseOk: boolean;
+}
+
+/**
+ * Wearable cross-source fusion — derived-day file serialization.
+ *
+ * One derived file per fused day, stored ALONGSIDE raw source transcripts
+ * (under the wearables tree) but never overwriting them. Format mirrors
+ * the day-transcript convention: YAML frontmatter (`kind:
+ * wearable-fusion`) + a JSON body carrying the structured
+ * `FusedWearableConversation[]`. The frontmatter `contentHash` is the
+ * idempotency key derived from inputs plus the effective fusion config,
+ * so an unchanged re-run (same inputs AND config) produces a
+ * byte-identical file.
+ */
+
+declare const FUSION_KIND: "wearable-fusion";
+/** Hash the canonical JSON body for idempotent skip-unchanged checks. */
+declare function hashFusionBody(conversations: readonly FusedWearableConversation[]): string;
+declare function composeFusionDayMeta(date: string, conversations: readonly FusedWearableConversation[], sources: readonly string[], contentHash: string, fusedAt: string): FusedDayMeta;
+/** Serialize meta + conversations into the persisted file format. */
+declare function serializeFusionDay(meta: FusedDayMeta, conversations: readonly FusedWearableConversation[]): string;
+/**
+ * Parse a persisted fused-day file. Returns null when the content does
+ * not look like a fusion artifact (wrong kind / missing frontmatter) so
+ * callers can distinguish "not fused" from a malformed file. A non-null
+ * result carries `parseOk`: false when the JSON body failed to parse, was
+ * not an array, or held a malformed element (conversations is empty in
+ * that case), true for a well-formed (incl. legitimately-empty `[]`)
+ * body — so the skip-unchanged path can force a self-repair rewrite
+ * regardless of the recomputed conversation count or body hash.
+ */
+declare function parseFusionDay(raw: string): FusedDayFile | null;
+/**
+ * Encrypted-at-rest + atomic file IO the fusion artifact store needs.
+ * Satisfied by StorageManager (which owns the secure-store key + atomic
+ * write path) and injected so this module performs NO direct fs — the
+ * derived files inherit the same encrypted-at-rest + atomic-write
+ * semantics as raw day transcripts without this module knowing the key.
+ */
+interface FusionFileIo {
+    writeFile(filePath: string, content: string): Promise<void>;
+    /** Read a file; rejects with ENOENT when it is absent. */
+    readFile(filePath: string): Promise<string>;
+    /** Directory entries; rejects with ENOENT when the directory is absent. */
+    readDir(dirPath: string): Promise<string[]>;
+    /** Remove a file; rejects with ENOENT when it is absent. */
+    deleteFile(filePath: string): Promise<void>;
+    /**
+     * Resolve a path through symlinks (node:fs/promises realpath); rejects
+     * with ENOENT when the path is absent. Used by the symlink-containment
+     * guard so a symlinked `_fusion` dir (or a symlinked wearables root)
+     * that resolves outside the memory dir is rejected before any
+     * read/write/delete (AGENTS.md #3).
+     */
+    realpath(filePath: string): Promise<string>;
+    /**
+     * Stat a path WITHOUT following a trailing symlink
+     * (node:fs/promises lstat); rejects with ENOENT when the path is
+     * absent. Used to detect a pre-existing symlink at the fusion
+     * artifact directory itself, which is rejected even when its
+     * target resolves inside the memory dir (issue #1849).
+     */
+    lstat(filePath: string): Promise<{
+        isSymbolicLink: boolean;
+    }>;
+}
+/**
+ * Owns the derived fused-day artifact files under
+ * `<wearablesDir>/_fusion/<YYYY-MM-DD>.md`. Path construction, date
+ * validation, and newest-first listing live here (relocated out of the
+ * root storage module — issue #1810 ratchet); the bytes flow through the
+ * injected secure IO.
+ */
+declare class FusionArtifactStore {
+    private readonly wearablesDir;
+    private readonly memoryDir;
+    private readonly io;
+    constructor(wearablesDir: string, memoryDir: string, io: FusionFileIo);
+    fusedDayPath(date: string): string;
+    writeFusedDay(date: string, serialized: string): Promise<void>;
+    /** Read a stored fused-day artifact; null when absent. */
+    readFusedDay(date: string): Promise<string | null>;
+    /**
+     * Remove a stored fused-day artifact. Idempotent: a no-op when the
+     * artifact is already absent. Used to clear a now-stale derived file
+     * before a fusion run that deliberately refuses to fuse (e.g. a day
+     * whose sources later conflict on timezone) so fusedConversations()
+     * does not keep serving a stale view (issue #1849).
+     */
+    deleteFusedDay(date: string): Promise<void>;
+    /** List dates with stored fused artifacts, newest first. */
+    listFusedDays(): Promise<string[]>;
+    /**
+     * Reject a symlinked/traversing fusion artifact path before any IO. The
+     * fusion dir (`<wearablesDir>/_fusion`) and its parents are followed
+     * directly by the secure IO; a symlink placed there (attacker-writable
+     * or a malformed memory dir) would otherwise be followed and
+     * read/write/delete outside the allowed root (AGENTS.md pattern #3).
+     *
+     * Containment is anchored to the real MEMORY-DIR root, not the
+     * wearables dir, AND the wearables root is checked explicitly: if
+     * `wearablesDir` itself is a symlink that resolves outside memoryDir, a
+     * leaf candidate like `<wearablesDir>/_fusion/<date>.md` may not yet
+     * exist (so its realpath ENOENT-skips) and the write would silently
+     * create the file inside the symlinked escape target. Checking
+     * `wearablesDir` itself — which resolves through the symlink when it
+     * exists — closes that gap, while the per-leaf checks catch a nested
+     * `_fusion` or per-file symlink. Absent paths are allowed (a fresh
+     * write creates them lexically under the root; only a path that
+     * resolves to an existing target can redirect IO). Mirrors
+     * `assertPathInsideRoot` in the storage walkers.
+     */
+    private assertPathContained;
+    /**
+     * Refuse a pre-existing symbolic link at the `<wearablesDir>/_fusion`
+     * directory. Unlike `assertNoEscape` (which follows the link and only
+     * rejects when the target lands outside the memory dir), this catches a
+     * fusion root that aliases an in-bounds path — e.g. a `_fusion` link
+     * pointed at a raw source transcript — so fusion IO never writes
+     * through it and overwrites the aliased file. Absent dirs are allowed
+     * (a fresh write creates a real directory lexically under the root).
+     */
+    private assertFusionDirNotSymlinked;
+    /**
+     * Refuse a candidate whose realpath escapes the memory root. Absent
+     * candidates are allowed: a missing path cannot yet redirect IO, and
+     * the secure write creates it lexically under the root.
+     */
+    private assertNoEscape;
+}
+
+/** 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;
+    /**
+     * Cross-process write-lock timings for the tombstone JSONL mutation lock
+     * (issue #1639). The secure-store append is a read-merge-write (read
+     * encrypted → decrypt → concat → re-encrypt → atomic rename), so two
+     * Remnic processes appending concurrently can each read the same contents
+     * and the last writer drops the other's entry — breaking the
+     * non-resurrection invariant. The lock serializes the mutation across
+     * processes. When omitted, defaults that fit the short tombstone critical
+     * section (mirroring the summary-snapshot lock): staleMs 30s, maxWaitMs 5s,
+     * heartbeatMs floor(staleMs/3).
+     */
+    readonly lockStaleMs?: number;
+    readonly lockMaxWaitMs?: number;
+    readonly lockHeartbeatMs?: 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);
+    /**
+     * Resolved cross-process write-lock timings (issue #1639). Defaults mirror
+     * the summary-snapshot lock: a tombstone append critical section is
+     * sub-second, so a stale lock older than 30s is a crashed holder; bounded
+     * acquisition gives up after 5s and strict-fails rather than clobbering a
+     * concurrent writer (which would reintroduce the lost-write race this lock
+     * closes).
+     */
+    private readonly lockStaleMs;
+    private readonly lockMaxWaitMs;
+    private readonly lockHeartbeatMs;
+    /**
+     * Sibling advisory lockfile: `<tombstones>.jsonl` → `<tombstones>.lock`.
+     * Shared by append, revoke, and rebuild so every JSONL mutation serializes
+     * against the others across processes (issue #1639: "shared with rebuilds").
+     */
+    private get lockPath();
+    /** 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;
+    /**
+     * Acquire the cross-process tombstone write lock and run `task` under it
+     * (issue #1639). Strict-fail on acquisition timeout: the secure-store append
+     * is a read-merge-write, so a best-effort unlocked run would clobber a
+     * concurrent writer — reintroducing the lost-write race this lock closes.
+     * The thrown error surfaces to the caller (rule 34: never silently drop);
+     * rebuild recovers the tombstone on the next maintenance cycle.
+     *
+     * In-process callers are already serialized by serializeMutations (one key
+     * for append/revoke/rebuild), so this lock only contends across processes —
+     * the single-process daemon (default deployment) acquires it immediately.
+     */
+    private withWriteLock;
+    /**
+     * 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;
+    requestedAt: string;
+    source: "cli-migrate";
+}
+interface MemoryLifecycleEventWriteOptions {
+    at?: Date;
+    actor?: string;
+    reasonCode?: string;
+    ruleVersion?: string;
+    relatedMemoryIds?: string[];
+    correlationId?: string;
+}
+declare function parseFrontmatterStringValue(rawValue: string | undefined): string | undefined;
+declare function parseFrontmatter(raw: string): {
+    frontmatter: MemoryFrontmatter;
+    content: string;
+} | null;
+declare function normalizeFrontmatterForPath(frontmatter: MemoryFrontmatter, pathRel: string, content?: string): MemoryFrontmatter;
+/**
+ * Normalize an entity name to a canonical form.
+ * Strips non-alphanumeric chars, collapses hyphens, removes type prefix duplication.
+ * e.g. "My Project" → "my-project"
+ *
+ * Checks caller-provided user aliases first, then built-in aliases. Alias
+ * tables are instance state on StorageManager (issue #1534) — use
+ * `storageManager.normalizeEntityName(raw, type)` when normalizing within a
+ * store, or pass `storageManager.entityAliases` explicitly. Without an
+ * aliases argument only the built-in structural aliases apply.
+ */
+declare function normalizeEntityName(raw: string, type: string, aliases?: Readonly<Record<string, string>>): string;
+/**
+ * Content-hash dedup index for facts.
+ * Normalizes content (lowercase, strip punctuation, collapse whitespace),
+ * computes SHA-256, and stores hashes in a line-delimited file.
+ * Prevents writing semantically identical facts.
+ */
+declare class ContentHashIndex {
+    private hashes;
+    private dirty;
+    private readonly filePath;
+    private readonly secureStoreKeyProvider;
+    private readonly secureStoreWriteKeyProvider;
+    private readonly memoryDir;
+    constructor(stateDir: string, secureStoreKeyProvider?: () => Buffer | null, secureStoreWriteKeyProvider?: () => Buffer | null, memoryDir?: string);
+    /** Load existing hashes from disk. Safe to call multiple times. */
+    load(): Promise<void>;
+    /** Check if content already exists in the index. */
+    has(content: string): boolean;
+    /** Add content hash to the index. */
+    add(content: string): void;
+    get size(): number;
+    /** Clear all loaded hashes so the next save rewrites the index from scratch. */
+    clear(): void;
+    /** Persist index to disk if changed. */
+    save(): Promise<void>;
+    /** Remove a hash from the index (used when archiving/deleting). */
+    remove(content: string): void;
+    /**
+     * Remove a pre-computed SHA-256 hash directly from the index without
+     * re-hashing.  Use this when the caller already holds the stored hash
+     * (e.g. `memory.frontmatter.contentHash`) to avoid the double-hash bug
+     * where `remove(hash)` would compute `hash(hash)` and never match the
+     * entry.
+     */
+    removeByHash(hash: string): void;
+    /**
+     * Add a pre-computed SHA-256 hash directly to the index without re-hashing.
+     * Use this when the caller already holds the stored hash
+     * (e.g. `memory.frontmatter.contentHash`) so that the index records the raw
+     * content hash rather than re-hashing the citation-annotated body.
+     *
+     * @internal Only called from `StorageManager.ensureFactHashIndexAuthoritative`.
+     * Not part of the public API — prefer `add(content)` for external callers.
+     */
+    addByHash(hash: string): void;
+    /** Normalize content (delegates to content-hash.ts for a single source of truth). */
+    static normalizeContent(content: string): string;
+    /** Compute SHA-256 hash (delegates to content-hash.ts for a single source of truth). */
+    static computeHash(content: string): string;
+}
+
+declare function normalizeAttributePairs(pairs: Record<string, string>): string;
+declare function normalizeStructuredSectionFacts(facts: string[]): string[];
+declare function compileEntityFacts(timeline: EntityTimelineEntry[], structuredSections: EntityStructuredSection[]): string[];
+declare function compareEntityTimestamps(left?: string, right?: string): number;
+declare function countEntityStructuredFacts(entity: EntityFile): number;
+declare function fingerprintEntityStructuredFacts(entity: Pick<EntityFile, "structuredSections">): string | undefined;
+declare function isEntitySynthesisStale(entity: EntityFile): boolean;
+/**
+ * Parse an entity markdown file into a structured EntityFile.
+ * Backward compatible: old files without new sections get empty arrays.
+ */
+declare function parseEntityFile(content: string, entitySchemas?: PluginConfig["entitySchemas"]): EntityFile;
+/**
+ * Serialize an EntityFile back to markdown.
+ * Writes the compiled-truth + timeline format while remaining parse-compatible
+ * with the legacy in-memory `summary` and `facts` fields.
+ */
+declare function serializeEntityFile(entity: EntityFile, entitySchemas?: PluginConfig["entitySchemas"]): string;
+declare function buildEntitySchemaCacheKey(entitySchemas?: PluginConfig["entitySchemas"]): string;
+/**
+ * Full-schema type guard for a `BUFFER_SURPRISE` telemetry row
+ * (issue #563 PR 3).
+ *
+ * The reader applies `limit` over the count of VALID rows, so
+ * applying only a partial check (e.g. "has a finite surpriseScore")
+ * and then deferring the rest of validation to
+ * `reportBufferSurpriseDistribution` would silently count
+ * schema-incomplete rows toward the limit, pushing genuinely-valid
+ * earlier rows out of the report window. Validate everything the
+ * downstream report requires at read time so the limit semantics and
+ * the distribution semantics stay consistent.
+ */
+declare function isValidBufferSurpriseEvent(value: unknown): value is BufferSurpriseEvent;
+/** Result of {@link StorageManager.writeMemory} (issue #1645). Carries the
+ * persisted id PLUS the non-resurrection tombstone-block outcome (#1579) so
+ * post-write callers can observe it — NEVER a silent no-op (rule 34). */
+interface MemoryWriteResult {
+    /** The persisted memory id. */
+    id: string;
+    /** True when the #1579 tombstone chokepoint downgraded this write to
+     * `pending_review` + `blockedBy`. Callers gate active post-write work on this. */
+    tombstoneBlocked: boolean;
+    /** The tombstone id that blocked the write, when `tombstoneBlocked`. */
+    blockedBy?: string;
+}
+declare class StorageManager {
+    private readonly baseDir;
+    private readonly entitySchemas?;
+    private knowledgeIndexCache;
+    private artifactIndexCache;
+    /** Read by storage/entity-store.ts (decomposition), hence not `private`. */
+    static readonly KNOWLEDGE_INDEX_CACHE_TTL_MS = 600000;
+    /** Read by storage/memory-read-store.ts (decomposition). */
+    static readonly ARTIFACT_INDEX_CACHE_TTL_MS = 60000;
+    private static readonly artifactWriteVersionByDir;
+    private static readonly memoryStatusVersionByDir;
+    private static readonly secureStoreEntityCacheKeyIds;
+    private static nextSecureStoreEntityCacheKeyId;
+    private static readonly coldWriteVersionByDir;
+    private static readonly allMemoriesInFlight;
+    /** Read by storage/memory-read-store.ts (decomposition). */
+    static readonly COLD_SCAN_CACHE_TTL_MS = 30000;
+    /** Read by storage/memory-read-store.ts (decomposition). */
+    static readonly coldMemoriesCache: Map<string, {
+        memories: MemoryFile[];
+        loadedAt: number;
+        coldVersion: number;
+    }>;
+    /** Read by storage/memory-read-store.ts (decomposition). */
+    static readonly QUESTIONS_CACHE_TTL_MS = 60000;
+    /** Read by storage/memory-read-store.ts (decomposition). */
+    static readonly questionsCache: Map<string, {
+        questions: Array<{
+            id: string;
+            question: string;
+            context: string;
+            priority: number;
+            resolved: boolean;
+            created: string;
+            filePath: string;
+        }>;
+        loadedAt: number;
+    }>;
+    private factHashIndex;
+    private factHashIndexLoadPromise;
+    private factHashIndexAuthoritative;
+    private factHashIndexAuthoritativePromise;
+    private readonly secureAppendChains;
+    private offlineSyncDigestCache;
+    private offlineSyncDigestCacheLoadPromise;
+    private offlineSyncDigestCacheWriteChain;
+    private offlineSyncDigestCacheWriteTimer;
+    /** Optional: set by the orchestrator after construction to enable template-aware citation stripping during legacy hash rebuild. */
+    citationTemplate: string;
+    /** 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. */
+    setVersioningConfig(config: VersioningConfig): void;
+    /**
+     * At-rest encryption key (issue #690 PR 3/4).
+     *
+     * When non-null, every memory file read is decrypted and every write
+     * is encrypted using the secure-fs layer.  When null, the storage
+     * layer operates in plain-text mode (legacy/unencrypted store).
+     *
+     * Set by the orchestrator after init/unlock; cleared on lock.
+     * The key buffer is NEVER logged or serialized.
+     */
+    private _secureStoreKey;
+    /**
+     * When true (and `_secureStoreKey` is non-null), new writes are
+     * encrypted.  Set to false to pause encryption of new writes while
+     * still decrypting existing files.
+     */
+    private _secureStoreEncryptOnWrite;
+    /**
+     * When true, the secure-store is configured as required — writes
+     * MUST be encrypted and a locked store MUST reject writes rather
+     * than silently falling back to plaintext.  Set by the orchestrator
+     * from `resolveRecallAuxiliaryCapabilities(config).secureStore`.
+     */
+    private _secureStoreRequired;
+    /**
+     * Set or clear the at-rest encryption key.
+     *
+     * Pass a 32-byte Buffer to enable encryption; pass null to clear
+     * (lock) the store.  The caller is responsible for key lifecycle —
+     * this method does not zero the buffer on replacement; the keyring
+     * module (`keyring.ts`) owns zeroization.
+     */
+    setSecureStoreKey(key: Buffer | null, encryptOnWrite?: boolean): void;
+    private getEntityCacheSecureStoreKey;
+    /**
+     * Mark the secure-store as required for this storage instance.
+     * When required and locked, writes throw SecureStoreLockedError
+     * rather than silently writing plaintext.
+     */
+    setSecureStoreRequired(required: boolean): void;
+    /** Return true iff the secure-store key is currently set (store is unlocked). */
+    isSecureStoreUnlocked(): boolean;
+    /**
+     * Resolve the effective write key.
+     *
+     * - If `_secureStoreEncryptOnWrite` is false: returns null (plain write).
+     * - If `_secureStoreEncryptOnWrite` is true AND key is set: returns key.
+     * - If `_secureStoreEncryptOnWrite` is true AND key is null AND
+     *   `_secureStoreRequired` is true: throws SecureStoreLockedError so the
+     *   write fails loudly rather than silently writing plaintext (P1 finding
+     *   from Cursor review of PR #767).
+     * - If `_secureStoreEncryptOnWrite` is true AND key is null AND
+     *   `_secureStoreRequired` is false: returns null (unencrypted store).
+     */
+    private resolveWriteKey;
+    /**
+     * Snapshot the current content of a page before overwriting.
+     * No-op when versioning is disabled or the file does not yet exist.
+     */
+    private snapshotBeforeWrite;
+    /**
+     * Consolidation provenance helper (issue #561 PR 2).
+     *
+     * Captures the current on-disk content of a source memory as a
+     * page-version snapshot so the downstream consolidated write can record a
+     * `derived_from` pointer that actually resolves.  Returns the
+     * `"<relative-path>:<versionId>"` entry expected by the `derived_from`
+     * frontmatter field.
+     *
+     * Returns `null` when versioning is disabled (snapshots would not be
+     * created), when the file does not exist (nothing to snapshot), or when
+     * the snapshot write itself fails (best-effort — callers skip the entry
+     * rather than block the consolidation).
+     */
+    snapshotForProvenance(filePath: string): Promise<string | null>;
+    constructor(baseDir: string, entitySchemas?: PluginConfig["entitySchemas"]);
+    /**
+     * The LIVE class object of this instance (issue #1809 review of the
+     * storage decomposition): extracted store modules must read/write the
+     * shared static caches (questionsCache, coldMemoriesCache, ...) through
+     * the SAME class binding the host methods use. Referencing the imported
+     * `StorageManager` symbol from a split bundle chunk can yield a second
+     * class copy with its own statics, split-braining the caches
+     * (resolveQuestion clears copy A while readQuestions reads copy B).
+     */
+    get storageManagerClass(): typeof StorageManager;
+    /** The root directory of this storage instance. */
+    /** MemoryReadStore (storage.ts decomposition). Lazy; selfDeps live wiring. */
+    private _memoryReadStore;
+    private get memoryReadStore();
+    /** EntityStore (storage.ts decomposition). Lazy; selfDeps live wiring. */
+    private _entityStore;
+    private get entityStore();
+    /** IdentityContinuityStore (storage.ts decomposition). Lazy; selfDeps live wiring. */
+    private _identityContinuityStore;
+    private get identityContinuityStore();
+    get dir(): string;
+    private identityFilePath;
+    private versionFilePath;
+    private bumpSharedVersion;
+    private readSharedVersion;
+    private bumpMemoryStatusVersion;
+    getMemoryStatusVersion(): number;
+    private bumpArtifactWriteVersion;
+    private getArtifactWriteVersion;
+    private get wearablesDir();
+    /**
+     * Resolve the on-disk path for a source/day transcript. Throws on
+     * malformed inputs — source ids and dates reach this from CLI/MCP/HTTP
+     * surfaces and must never become path traversal.
+     */
+    wearableTranscriptPath(sourceId: string, date: string): string;
+    writeWearableDayTranscript(sourceId: string, date: string, serialized: string): Promise<void>;
+    /** Read a stored day transcript; null when the day has no file. */
+    readWearableDayTranscript(sourceId: string, date: string): Promise<string | null>;
+    listWearableTranscriptDays(sourceId?: string): Promise<Array<{
+        source: string;
+        date: string;
+    }>>;
+    private _fusionStore?;
+    /** Derived fusion-day IO; file IO lives in wearables/fusion (#1810). */
+    fusionArtifactStore(): FusionArtifactStore;
+    /**
+     * Locate a wearable-sourced memory by exact (trimmed) content,
+     * ignoring the "[Attributes: ...]" suffix writeMemory appends for
+     * structuredAttributes — callers pass the raw fact text. Used by the
+     * smart trust pipeline to find an earlier borderline write when the
+     * same fact re-extracts with stronger evidence.
+     */
+    findWearableMemoryByContent(content: string): Promise<{
+        id: string;
+        status: MemoryStatus | undefined;
+    } | null>;
+    /**
+     * 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), 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>;
+    /**
+     * Demote a pending_review wearable memory to rejected when a re-pass
+     * produced an explicit judge-reject verdict, merging the evidence.
+     * Returns false when the memory is missing or no longer
+     * pending_review — active rows are NEVER auto-demoted (operator
+     * approvals and accrued recall signals win; contradiction scans and
+     * supersession own active-row retirement).
+     */
+    demoteWearableMemory(id: string, attributeUpdates: Record<string, string>): Promise<boolean>;
+    private get factsDir();
+    private get correctionsDir();
+    private get proceduresDir();
+    private get reasoningTracesDir();
+    private get entitiesDir();
+    private resolveEntityFilePath;
+    private readStorageSecureFile;
+    private writeStorageSecureFile;
+    private writeStorageSecureFileChunks;
+    private assertManagedStoragePath;
+    readOfflineSyncFile(filePath: string): Promise<Buffer>;
+    digestOfflineSyncFile(filePath: string): Promise<{
+        sha256: string;
+        bytes: number;
+    }>;
+    private loadOfflineSyncDigestCache;
+    private readOfflineSyncDigestCache;
+    private rememberOfflineSyncDigest;
+    private scheduleOfflineSyncDigestCacheWrite;
+    private queueOfflineSyncDigestCacheWrite;
+    private offlineSyncFileIsEncrypted;
+    writeOfflineSyncFile(filePath: string, content: Buffer): Promise<void>;
+    writeOfflineSyncStagingFile(filePath: string, content: Buffer): Promise<void>;
+    writeOfflineSyncFileChunks(filePath: string, chunks: AsyncIterable<Buffer>): Promise<void>;
+    deleteOfflineSyncFile(filePath: string): Promise<void>;
+    private invalidateAfterOfflineSyncMutation;
+    createContentHashIndex(): ContentHashIndex;
+    private appendStorageSecureFile;
+    private appendStorageSecureFileUnlocked;
+    private get stateDir();
+    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>;
+    /**
+     * Whether tombstones are enabled on this storage. Callers that need to
+     * distinguish "tombstones disabled" (null return is expected) from
+     * "persistence failed" (appendTombstone swallows store errors and also
+     * returns null) use this to fail closed when enabled (#1580 review OgIqp).
+     */
+    isTombstonesEnabled(): boolean;
+    /**
+     * 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();
+    private get artifactsDir();
+    private get identityDir();
+    private get identityAnchorPath();
+    private get identityIncidentsDir();
+    private get identityAuditsWeeklyDir();
+    private get identityAuditsMonthlyDir();
+    private get identityImprovementLoopsPath();
+    private get identityReflectionsPath();
+    private get profilePath();
+    private get memoryActionsPath();
+    private get memoryLifecycleLedgerPath();
+    private get compressionGuidelinesPath();
+    private get compressionGuidelineDraftPath();
+    private get compressionGuidelineStatePath();
+    private get compressionGuidelineDraftStatePath();
+    private get behaviorSignalsPath();
+    /**
+     * Buffer surprise telemetry ledger (issue #563 PR 3).
+     *
+     * Append-only JSONL of per-turn `BUFFER_SURPRISE` events emitted by
+     * `SmartBuffer` when `bufferSurpriseTriggerEnabled` is on. Each row
+     * captures the score, the threshold in force at the time, whether the
+     * turn caused an extract_now upgrade, and the buffer size. Kept in
+     * `state/` alongside the other append-only ledgers so cleanup and
+     * governance sweeps can treat it uniformly.
+     */
+    private get bufferSurpriseLedgerPath();
+    /**
+     * Entity alias table loaded from THIS store's config/aliases.json.
+     * Instance-scoped on purpose (issue #1534): multiple StorageManager
+     * instances in one process (namespaces, hosted profiles, tenants) must
+     * never share alias state — the previous module-level table let whichever
+     * store loaded last rewrite every other store's canonical entity ids.
+     */
+    private userAliases;
+    normalizeEntityName(raw: string, type: string): string;
+    /**
+     * Read-only view of this store's user alias table, for call sites that
+     * normalize outside the manager (pass it to the free `normalizeEntityName`).
+     */
+    get entityAliases(): Readonly<Record<string, string>>;
+    /**
+     * Reload user-defined entity aliases from config/aliases.json in the memory
+     * store. File format: { "variant": "canonical", ... }. The constructor
+     * already loads aliases, so this is only needed to pick up file changes
+     * (e.g. orchestrator.initialize() re-running on a live instance).
+     * Non-object payloads and non-string or empty alias values are ignored.
+     */
+    loadAliases(): Promise<void>;
+    private loadAliasesSync;
+    ensureDirectories(): Promise<void>;
+    /**
+     * Resolve the on-disk write path for a memory of the given category, creating
+     * the target directory. Category routing goes through the shared
+     * `getCategoryDir()` chokepoint (utils/category-dir.ts → CATEGORY_DIR_MAP) so
+     * decision/preference/moment/etc. outputs land in their dedicated dirs
+     * (`decisions/`, `preferences/`, ...) instead of collapsing into `facts/`
+     * (issue #1546; CLAUDE.md rule 39). `correction` keeps its historical flat
+     * layout (no `<date>` subdir) as the corrections pipeline expects; every other
+     * category — including `fact`/`entity`, which fall back to `facts/` — is dated
+     * as `<dir>/<date>/`. Read/scan/reindex already iterate every category dir
+     * (RECALL_FALLBACK_DIRS; QMD scans baseDir recursively), so writes stay found.
+     */
+    private resolveCategoryWritePath;
+    writeMemory(category: MemoryCategory, content: string, options?: {
+        actor?: string;
+        confidence?: number;
+        tags?: string[];
+        entityRef?: string;
+        source?: string;
+        supersedes?: string;
+        lineage?: string[];
+        importance?: ImportanceScore;
+        links?: MemoryLink[];
+        intentGoal?: string;
+        intentActionType?: string;
+        intentEntityTypes?: string[];
+        artifactType?: MemoryFrontmatter["artifactType"];
+        sourceMemoryId?: string;
+        sourceTurnId?: string;
+        memoryKind?: MemoryFrontmatter["memoryKind"];
+        expiresAt?: string;
+        validAt?: string;
+        observedAt?: string;
+        eventTimeSource?: "extracted" | "assumed";
+        invalidAt?: string;
+        structuredAttributes?: Record<string, string>;
+        /**
+         * When provided, this string is used as the source for the fact-content
+         * dedup hash index instead of the persisted body (`content`).
+         *
+         * Use this when the persisted body differs from the canonical fact text
+         * — for example when `content` is a citation-annotated variant of a raw
+         * fact. Passing the raw fact as `contentHashSource` ensures that
+         * `hasFactContentHash(rawFact)` returns `true` after the write, so
+         * subsequent extractions of the same logical fact are correctly deduped
+         * even when their citation timestamp differs.
+         */
+        contentHashSource?: string;
+        status?: MemoryStatus;
+        /**
+         * Consolidation provenance (issue #561 PR 2).  When the caller is a
+         * consolidation / supersession / dedup-merge path, these fields wire
+         * the page-version snapshots the new memory was derived from and the
+         * operator that produced it.  Persisted onto frontmatter as
+         * `derived_from` + `derived_via`; validated at serialize time.
+         */
+        derivedFrom?: string[];
+        derivedVia?: ConsolidationOperator;
+        /**
+         * Faithfulness gate verdict (issue #1576). When provided, persisted to
+         * frontmatter so downstream readers (TrustScore #1577, review queue)
+         * can consume it. Absent = gate was off or fact predates #1576.
+         */
+        faithfulness?: FaithfulnessFrontmatter;
+        /**
+         * Claim-level provenance spans (issue #1575 PR 2). When provided,
+         * persisted to frontmatter so downstream readers (memory_get, x-ray,
+         * faithfulness gate #1576) can consume them. Absent = fact predates
+         * #1575 or provenance was disabled.
+         */
+        sources?: ProvenanceSource[];
+        provenance?: "verified" | "unverified" | "none";
+    }): Promise<MemoryWriteResult>;
+    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>;
+    writeArtifact(quote: string, options?: {
+        actor?: string;
+        tags?: string[];
+        confidence?: number;
+        artifactType?: MemoryFrontmatter["artifactType"];
+        sourceMemoryId?: string;
+        sourceTurnId?: string;
+        intentGoal?: string;
+        intentActionType?: string;
+        intentEntityTypes?: string[];
+    }): Promise<string>;
+    private readAllArtifactsCached;
+    searchArtifacts(query: string, maxResults: number): Promise<MemoryFile[]>;
+    writeEntity(name: string, type: string, facts: string[], options?: {
+        timestamp?: string;
+        source?: string;
+        sessionKey?: string;
+        principal?: string;
+        structuredSections?: EntityStructuredSection[];
+    }): Promise<string>;
+    readProfile(): Promise<string>;
+    writeProfile(content: string): Promise<void>;
+    /**
+     * Normalize a string for fuzzy profile dedup: lowercase, strip punctuation, collapse whitespace.
+     */
+    private static normalizeForDedup;
+    /**
+     * Check if a new bullet is a fuzzy duplicate of any existing bullet.
+     * Returns true if the new bullet should be skipped.
+     */
+    private static isFuzzyDuplicate;
+    appendToProfile(updates: string[]): Promise<void>;
+    /** Check if profile.md exceeds the max line cap and needs LLM consolidation */
+    profileNeedsConsolidation(triggerLines?: number): Promise<boolean>;
+    readAllMemories(): Promise<MemoryFile[]>;
+    /** Invalidate the readAllMemories() cache after writes that add/remove memories. */
+    /** Public cache invalidation for callers that need authoritative disk reads
+     *  (e.g. projection verify/rebuild). */
+    invalidateAllMemoriesCacheForDir(): void;
+    /** Invalidate only the cache layers affected by direct tier file deletes. */
+    invalidateMemoryCachesForTiers(tiers: Iterable<"hot" | "cold" | "archive">): void;
+    /** Clear ALL static caches. Use in tests that write files directly
+     *  (bypassing StorageManager.writeMemory) to avoid stale reads. */
+    static clearAllStaticCaches(): void;
+    /** Cancel any in-flight concurrent read so the next readAllMemories()
+     *  starts a fresh disk scan and sees the just-written data.
+     *
+     *  Finding UvBq (PR #402 round-11): this method intentionally does NOT
+     *  invalidate the cold-scan cache.  Ordinary hot-tier writes (writeMemory)
+     *  do not change cold-tier content, so evicting the cold cache on every hot
+     *  write was defeating the burst-dedup optimisation — the cold cache was
+     *  cleared before applyTemporalSupersession ran, causing a full cold-tree
+     *  disk scan on every write in a burst.  Cold cache invalidation is handled
+     *  exclusively by invalidateColdMemoriesCache(), which is called only when
+     *  cold content actually changes (hot→cold demotions, writeMemoryFileAtomic
+     *  inside cold/, archiveMemory, etc.). */
+    private invalidateAllMemoriesCache;
+    /**
+     * Invalidate the cold-scan cache for this storage root and bump the
+     * on-disk cold-version sentinel so that other processes (gateway, CLI) see
+     * the change immediately on their next readAllColdMemories() call.
+     *
+     * Must be called whenever a memory is written INTO the cold tier — hot→cold
+     * demotion, atomic writes inside cold/, archiving a cold memory, etc.
+     * NOT called on ordinary hot-tier writes (those don't change cold contents).
+     *
+     * Finding UvUy (PR #402 round-11): bumping the sentinel here makes the
+     * per-process in-memory cache safe across process boundaries.
+     */
+    private invalidateColdMemoriesCache;
+    /** Return the current cold-write version counter for this storage root.
+     *  Reads the on-disk sentinel (state/cold-write.log) so it reflects writes
+     *  made by other processes. */
+    private readColdWriteVersion;
+    /** Bump the on-disk cold-write version sentinel and update the in-process
+     *  fallback map.  Called by invalidateColdMemoriesCache(). */
+    private bumpColdWriteVersion;
+    private normalizeMemoryReadBatchSize;
+    private collectActiveMemoryPaths;
+    private readParsedMemoriesFromPaths;
+    private readWindowUpdatedMs;
+    private filterWindowPathsByUpdatedAfter;
+    private orderWindowPaths;
+    private readWindowBoundedBatch;
+    readMemoriesWindow(options?: {
+        maxMemories?: number;
+        batchSize?: number;
+        updatedAfter?: Date;
+    }): Promise<{
+        memories: MemoryFile[];
+        filePaths: string[];
+    }>;
+    private _readAllMemoriesFromDisk;
+    readAllColdMemories(): Promise<MemoryFile[]>;
+    /**
+     * Read archived memory markdown files under archive/.
+     * Used by long-term recall fallback when hot recall has no hits.
+     */
+    readArchivedMemories(): Promise<MemoryFile[]>;
+    readMemoryByPath(filePath: string): Promise<MemoryFile | null>;
+    private resolveTierRootDir;
+    private resolveMemoryDateDir;
+    private isArtifactMemory;
+    buildTierMemoryPath(memory: MemoryFile, tier: "hot" | "cold"): string;
+    private writeMemoryFileAtomic;
+    moveMemoryToPath(memory: MemoryFile, targetPath: string): Promise<void>;
+    migrateMemoryToTier(memory: MemoryFile, targetTier: "hot" | "cold"): Promise<{
+        changed: boolean;
+        targetPath: string;
+    }>;
+    private get archiveDir();
+    /**
+     * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
+     * Updates frontmatter with archived status before moving.
+     * Returns the new file path on success, null on failure.
+     */
+    archiveMemory(memory: MemoryFile, lifecycle?: MemoryLifecycleEventWriteOptions): Promise<string | null>;
+    readEntities(): Promise<string[]>;
+    readEntity(name: string): Promise<string>;
+    listEntityNames(): Promise<string[]>;
+    /**
+     * Find an existing entity that fuzzy-matches the proposed name.
+     * Returns the existing entity filename (without .md) or null if no match.
+     *
+     * Matching priority:
+     * 1. Exact normalized match (handled by normalizeEntityName already)
+     * 2. Dehyphenated match: "jane-doe" vs "janedoe"
+     * 3. Substring containment: "handle-janedoe" contains "janedoe"
+     * 4. Levenshtein ≤ 2 on dehyphenated names
+     */
+    findMatchingEntity(proposedName: string, type: string): Promise<string | null>;
+    invalidateMemory(id: string): Promise<boolean>;
+    updateMemory(id: string, newContent: string, options?: {
+        supersedes?: string;
+        lineage?: string[];
+        actor?: string;
+    }): Promise<boolean>;
+    /**
+     * Update frontmatter fields without changing memory content.
+     * Returns false when the memory is not found.
+     */
+    writeMemoryFrontmatter(memory: MemoryFile, patch: Partial<MemoryFrontmatter>, lifecycle?: MemoryLifecycleEventWriteOptions): Promise<boolean>;
+    /**
+     * Update frontmatter by memory ID.
+     * Prefer writeMemoryFrontmatter(memory, patch) in batch loops to avoid full-corpus rescans.
+     */
+    updateMemoryFrontmatter(id: string, patch: Partial<MemoryFrontmatter>): Promise<boolean>;
+    /** Remove memories past their TTL expiresAt date */
+    cleanExpiredTTL(): Promise<MemoryFile[]>;
+    loadBuffer(): Promise<BufferState>;
+    saveBuffer(state: BufferState): Promise<void>;
+    loadMeta(): Promise<MetaState>;
+    saveMeta(state: MetaState): Promise<void>;
+    appendMemoryActionEvents(events: MemoryActionEvent[]): Promise<number>;
+    appendMemoryLifecycleEvents(events: MemoryLifecycleEvent[]): Promise<number>;
+    appendBufferSurpriseEvents(events: BufferSurpriseEvent[]): Promise<number>;
+    readBufferSurpriseEvents(options?: {
+        limit?: number;
+    }): Promise<BufferSurpriseEvent[]>;
+    appendBehaviorSignals(events: BehaviorSignalEvent[]): Promise<number>;
+    appendReextractJobs(events: ReextractJobRequest[]): Promise<number>;
+    readReextractJobs(limit?: number): Promise<ReextractJobRequest[]>;
+    readBehaviorSignals(limit?: number): Promise<BehaviorSignalEvent[]>;
+    readMemoryActionEvents(limit?: number): Promise<MemoryActionEvent[]>;
+    readMemoryActionEventRows(limit?: number): Promise<Array<{
+        line: number;
+        event: MemoryActionEvent;
+    }>>;
+    readAllMemoryLifecycleEvents(): Promise<MemoryLifecycleEvent[]>;
+    readMemoryLifecycleEvents(limit?: number): Promise<MemoryLifecycleEvent[]>;
+    writeCompressionGuidelines(content: string): Promise<void>;
+    readCompressionGuidelines(): Promise<string | null>;
+    writeCompressionGuidelineDraft(content: string): Promise<void>;
+    readCompressionGuidelineDraft(): Promise<string | null>;
+    writeCompressionGuidelineOptimizerState(state: CompressionGuidelineOptimizerState): Promise<void>;
+    writeCompressionGuidelineDraftState(state: CompressionGuidelineOptimizerState): Promise<void>;
+    readCompressionGuidelineOptimizerState(): Promise<CompressionGuidelineOptimizerState | null>;
+    readCompressionGuidelineDraftState(): Promise<CompressionGuidelineOptimizerState | null>;
+    activateCompressionGuidelineDraft(options?: {
+        expectedContentHash?: string;
+        expectedGuidelineVersion?: number;
+    }): Promise<boolean>;
+    private readCompressionGuidelineStateFile;
+    writeIdentityAnchor(content: string): Promise<void>;
+    readIdentityAnchor(): Promise<string | null>;
+    appendContinuityIncident(input: ContinuityIncidentOpenInput): Promise<ContinuityIncidentRecord>;
+    readContinuityIncidents(limit?: number, state?: "open" | "closed" | "all"): Promise<ContinuityIncidentRecord[]>;
+    closeContinuityIncident(id: string, closure: ContinuityIncidentCloseInput): Promise<ContinuityIncidentRecord | null>;
+    writeIdentityAudit(period: "weekly" | "monthly", key: string, content: string): Promise<string>;
+    readIdentityAudit(period: "weekly" | "monthly", key: string): Promise<string | null>;
+    writeIdentityImprovementLoops(content: string): Promise<void>;
+    readIdentityImprovementLoops(): Promise<string | null>;
+    readIdentityImprovementLoopRegister(): Promise<ContinuityImprovementLoop[]>;
+    upsertIdentityImprovementLoop(input: ContinuityLoopUpsertInput): Promise<ContinuityImprovementLoop>;
+    reviewIdentityImprovementLoop(id: string, input: ContinuityLoopReviewInput): Promise<ContinuityImprovementLoop | null>;
+    private generateId;
+    writeQuestion(question: string, context: string, priority: number): Promise<string>;
+    readQuestions(opts?: {
+        unresolvedOnly?: boolean;
+    }): Promise<Array<{
+        id: string;
+        question: string;
+        context: string;
+        priority: number;
+        resolved: boolean;
+        created: string;
+        filePath: string;
+    }>>;
+    /** Invalidate the questions cache (call after writing a question). */
+    invalidateQuestionsCache(): void;
+    private parseQuestionFile;
+    private extractFrontmatterValue;
+    resolveQuestion(id: string): Promise<boolean>;
+    readIdentity(workspaceDir: string, namespace?: string): Promise<string>;
+    writeIdentity(workspaceDir: string, content: string, namespace?: string): Promise<void>;
+    /** Max size for IDENTITY.md before we stop appending reflections (15KB leaves room under 20KB gateway limit) */
+    private static readonly IDENTITY_MAX_BYTES;
+    /** Minimum interval between reflections (1 hour) */
+    private static readonly REFLECTION_COOLDOWN_MS;
+    appendToIdentity(workspaceDir: string, reflection: string, opts?: {
+        hygiene?: FileHygieneConfig;
+        namespace?: string;
+    }): Promise<void>;
+    readIdentityReflections(): Promise<string | null>;
+    writeIdentityReflections(content: string): Promise<void>;
+    appendIdentityReflection(reflection: string): Promise<void>;
+    /**
+     * Add a relationship to an entity file.
+     * Deduplicates by target+label.
+     */
+    addEntityRelationship(name: string, rel: EntityRelationship): Promise<void>;
+    /**
+     * Add an activity entry to an entity file.
+     * Prepends to the beginning, prunes oldest entries beyond maxEntries.
+     */
+    addEntityActivity(name: string, entry: EntityActivityEntry, maxEntries: number): Promise<void>;
+    /**
+     * Add an alias to an entity file. Deduplicates.
+     */
+    addEntityAlias(name: string, alias: string): Promise<void>;
+    updateEntitySynthesis(name: string, synthesis: string, options?: {
+        entityUpdatedAt?: string;
+        synthesisStructuredFactCount?: number;
+        synthesisStructuredFactDigest?: string;
+        synthesisTimelineCount?: number;
+        updatedAt?: string;
+        incrementVersion?: boolean;
+    }): Promise<void>;
+    /**
+     * Backward-compatible alias for legacy callers/tests.
+     */
+    updateEntitySummary(name: string, summary: string): Promise<void>;
+    readEntitySynthesisQueue(): Promise<string[]>;
+    refreshEntitySynthesisQueue(): Promise<string[]>;
+    removeEntitySynthesisQueueEntries(entityNames: string[]): Promise<void>;
+    migrateEntityFilesToCompiledTruthTimeline(): Promise<{
+        total: number;
+        migrated: number;
+    }>;
+    readAllEntityFiles(): Promise<EntityFile[]>;
+    /**
+     * Score an entity based on recency, frequency, activity, type priority,
+     * and relationship density.
+     *
+     * score = recency*0.40 + frequency*0.25 + activity*0.15 + typePriority*0.10 + relationshipDensity*0.10
+     */
+    static scoreEntity(entity: EntityFile, now: Date): number;
+    buildKnowledgeIndex(config: PluginConfig, overrides?: {
+        maxEntities?: number;
+        maxChars?: number;
+    }): Promise<{
+        result: string;
+        cached: boolean;
+    }>;
+    /** Invalidate the Knowledge Index cache (call after entity mutations). */
+    invalidateKnowledgeIndexCache(): void;
+    /** Max lines for profile.md before LLM consolidation triggers */
+    private static readonly PROFILE_MAX_LINES;
+    mergeFragmentedEntities(): Promise<number>;
+    cleanExpiredCommitments(decayDays: number): Promise<MemoryFile[]>;
+    /**
+     * Flush batched access tracking updates to disk.
+     * Called during consolidation or when buffer exceeds max size.
+     */
+    flushAccessTracking(entries: AccessTrackingEntry[]): Promise<number>;
+    /**
+     * Get a memory by its ID.
+     */
+    getMemoryById(id: string): Promise<MemoryFile | null>;
+    /**
+     * Check which of the given memory IDs actually exist on disk.
+     *
+     * Uses a lightweight directory scan (collectActiveMemoryPaths) that reads
+     * file names without parsing frontmatter — much cheaper than readAllMemories()
+     * for simple existence checks like citation usage tracking.
+     *
+     * Returns the subset of `ids` that correspond to real memory files.
+     */
+    filterExistingMemoryIds(ids: string[]): Promise<Set<string>>;
+    getProjectedMemoryState(id: string): Promise<MemoryProjectionCurrentState | null>;
+    browseProjectedMemories(options: ProjectedMemoryBrowseOptions): Promise<ProjectedMemoryBrowsePage | null>;
+    getProjectedGovernanceRecord(): Promise<ReturnType<typeof readProjectedGovernanceRecord>>;
+    private toProjectedCurrentState;
+    getMemoryTimeline(memoryId: string, limit?: number): Promise<MemoryLifecycleEvent[]>;
+    /**
+     * Write a memory chunk with parent reference.
+     * Chunk IDs follow format: {parentId}-chunk-{index}
+     */
+    writeChunk(parentId: string, chunkIndex: number, chunkTotal: number, category: MemoryCategory, content: string, options?: {
+        confidence?: number;
+        tags?: string[];
+        entityRef?: string;
+        source?: string;
+        importance?: ImportanceScore;
+        intentGoal?: string;
+        intentActionType?: string;
+        intentEntityTypes?: string[];
+        memoryKind?: MemoryFrontmatter["memoryKind"];
+        validAt?: string;
+        /** Lifecycle status (issue #1576): pending_review chunks stay out of active recall. */
+        status?: MemoryStatus;
+        /**
+         * Tombstone block provenance (issue #1645): when the parent fact was
+         * tombstone-blocked, propagate the tombstone id onto each chunk so an
+         * independently-surfaced chunk (memory_get/x-ray/doctor) reveals the block
+         * and the chunk stays pending_review, never an active resurrection.
+         */
+        blockedBy?: string;
+        /** Faithfulness gate verdict (issue #1576), propagated from the parent fact. */
+        faithfulness?: FaithfulnessFrontmatter;
+        /** Claim-level provenance spans (issue #1575 PR 2), propagated from the parent fact so a chunk surfaced independently (memory_get/x-ray) preserves them (chatgpt-codex-connector thread Ocvmo). */
+        sources?: ProvenanceSource[];
+        /** Coarse provenance tag (issue #1575 PR 2), propagated from the parent. */
+        provenance?: "verified" | "unverified" | "none";
+        invalidAt?: string;
+        observedAt?: string;
+        eventTimeSource?: "extracted" | "assumed";
+    }): Promise<string>;
+    /**
+     * Get all chunks for a given parent memory ID.
+     * Returns chunks sorted by chunkIndex.
+     */
+    getChunksForParent(parentId: string): Promise<MemoryFile[]>;
+    /**
+     * Mark a memory as superseded by another.
+     * Updates the old memory's status and adds the supersededBy link.
+     */
+    supersedeMemory(oldMemoryId: string, newMemoryId: string, reason: string): Promise<boolean>;
+    private get summariesDir();
+    /**
+     * Write a memory summary.
+     */
+    writeSummary(summary: MemorySummary): Promise<void>;
+    /**
+     * Get all summaries.
+     */
+    readSummaries(): Promise<MemorySummary[]>;
+    /**
+     * Archive memories (mark as archived, not delete).
+     */
+    archiveMemories(memoryIds: string[], summaryId: string): Promise<number>;
+    /**
+     * Save topic scores to meta.json.
+     */
+    saveTopics(topics: TopicScore[]): Promise<void>;
+    /**
+     * Load topic scores from meta.json.
+     */
+    loadTopics(): Promise<{
+        topics: TopicScore[];
+        updatedAt: string | null;
+    }>;
+    /**
+     * Add links to an existing memory.
+     */
+    addLinksToMemory(memoryId: string, links: MemoryLink[], lifecycle?: MemoryLifecycleEventWriteOptions): Promise<boolean>;
+    private summarizeLifecycleState;
+    private frontmatterPatchEventType;
+    private appendGeneratedMemoryLifecycleEvent;
+    private appendGeneratedMemoryLifecycleEventFailOpen;
+}
+
+export { countEntityStructuredFacts as A, fingerprintEntityStructuredFacts as B, ContentHashIndex as C, type DisagreementKind as D, isEntitySynthesisStale as E, FusionArtifactStore as F, isValidBufferSurpriseEvent as G, normalizeEntityName as H, normalizeFrontmatterForPath as I, normalizeStructuredSectionFacts as J, parseFrontmatter as K, parseFrontmatterStringValue as L, type MemoryWriteResult as M, type ReextractJobRequest as R, StorageManager as S, type FusedWearableConversation as a, type FusionConversationInput as b, type FusedSpeaker as c, type FusedSegment as d, type FusedDisagreement as e, type FusionOptions as f, type FusionDayResult as g, FUSION_KIND as h, type FusedContribution as i, type FusedConversationProvenance as j, type FusedDayFile as k, type FusedDayMeta as l, type FusedSegmentProvenance as m, type FusionSegmentInput as n, type SegmentPickReason as o, composeFusionDayMeta as p, hashFusionBody as q, normalizeAttributePairs as r, parseEntityFile as s, parseFusionDay as t, serializeEntityFile as u, serializeFusionDay as v, type MemoryLifecycleEventWriteOptions as w, buildEntitySchemaCacheKey as x, compareEntityTimestamps as y, compileEntityFacts as z };