@remnic/core 9.4.2 → 9.6.0

package/dist/storage.d.ts

@@ -1,1245 +1,11 @@
-import { M as MemoryFile, P as PluginConfig, u as MemoryStatus, h as MemoryCategory, ae as ImportanceScore, aq as MemoryLink, q as MemoryFrontmatter, F as FaithfulnessFrontmatter, J as ProvenanceSource, a7 as EntityStructuredSection, ar as BufferState, as 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, at as FileHygieneConfig, au as EntityRelationship, av as EntityActivityEntry, E as EntityFile, aw as AccessTrackingEntry, v as MemoryProjectionCurrentState, ax as MemorySummary, ap as TopicScore, ay as EntityTimelineEntry } from './types-ljkd82rn.js';
-import { VersioningConfig } from './page-versioning.js';
-import { ConsolidationOperator } from './consolidation-operator.js';
-import { ProjectedMemoryBrowseOptions, ProjectedMemoryBrowsePage, readProjectedGovernanceRecord } from './memory-projection-store.js';
+import './types-CGgcNWCG.js';
+import './page-versioning.js';
+export { C as ContentHashIndex, w as MemoryLifecycleEventWriteOptions, M as MemoryWriteResult, R as ReextractJobRequest, S as StorageManager, x as buildEntitySchemaCacheKey, y as compareEntityTimestamps, z as compileEntityFacts, A as countEntityStructuredFacts, B as fingerprintEntityStructuredFacts, E as isEntitySynthesisStale, G as isValidBufferSurpriseEvent, r as normalizeAttributePairs, H as normalizeEntityName, I as normalizeFrontmatterForPath, J as normalizeStructuredSectionFacts, s as parseEntityFile, K as parseFrontmatter, L as parseFrontmatterStringValue, u as serializeEntityFile } from './storage-C1maCNbc.js';
+import './consolidation-operator.js';
+import './memory-projection-store.js';
 export { stripAttributesSuffix } from './structured-attributes.js';
 import './types-gb_SNtjR.js';
 import './message-parts/index.js';
 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;
-    /**
-     * 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;
-    }>>;
-    /**
-     * 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 { ContentHashIndex, type MemoryLifecycleEventWriteOptions, type MemoryWriteResult, type ReextractJobRequest, StorageManager, buildEntitySchemaCacheKey, compareEntityTimestamps, compileEntityFacts, countEntityStructuredFacts, fingerprintEntityStructuredFacts, isEntitySynthesisStale, isValidBufferSurpriseEvent, normalizeAttributePairs, normalizeEntityName, normalizeFrontmatterForPath, normalizeStructuredSectionFacts, parseEntityFile, parseFrontmatter, parseFrontmatterStringValue, serializeEntityFile };