@remnic/core 9.69.56 → 9.69.58

package/dist/storage/entity-canonical-id-references.d.ts

@@ -0,0 +1,173 @@
+export declare const ENTITY_CANONICAL_ID_MIGRATION_FILE = "entity-canonical-id-migration-v1.json";
+export declare function loadHistoricalEntityCanonicalIds(stateDir: string): Readonly<Record<string, string>>;
+/**
+ * Append a tombstone with its identity canonicalized against the CURRENT
+ * journal, then recheck: a peer publishing a mapping inside the
+ * resolve-to-append window would leave the guard under the legacy id while
+ * lookups canonicalize. Each identity change appends the replacement FIRST
+ * (AGENTS.md §14 — the retired fact must never be without an active guard),
+ * then revokes the superseded one — a park makes the prior canonical
+ * claimant a distinct entity, and a stale keyed guard under it would
+ * suppress that entity's facts. When the journal will not settle, one final
+ * replacement runs under the entity MUTATION lock (parks publish under it).
+ */
+export declare function appendCanonicalizedTombstone(stateDir: string, input: {
+    entityRef?: string;
+    supersessionKey?: string;
+}, currentIds: () => Readonly<Record<string, string>>, append: (identity: TombstoneIdentity) => Promise<string | null>, revoke: (tombstoneId: string) => Promise<unknown>, label: string): Promise<string | null>;
+/**
+ * Journal mapping table keyed by the journal FILE's identity, so a long-lived
+ * StorageManager never canonicalizes against a stale snapshot after ANY other
+ * writer changes the journal — a peer process completing a migration, or
+ * `pruneBlocked()` parking a contested mapping (which rewrites the journal
+ * without bumping any shared version). `writeState` publishes via
+ * temp-file-plus-rename, so every journal write swaps the inode and the key
+ * always moves — the identity is taken from the fstat of the SAME opened
+ * inode the content is read from (no stat→read window). Reload cost is one
+ * open per lookup and one journal parse per actual change.
+ *
+ * Failure semantics: last-known data is served ONLY for the SAME state dir
+ * (module-level instances can face several stores — another store's table
+ * must never leak in), and a failed read/parse never commits the journal's
+ * identity, so the next lookup retries instead of caching an empty table
+ * under a valid key.
+ */
+export declare class HistoricalEntityCanonicalIdCache {
+    private mappings;
+    private key;
+    private stateDir;
+    get(stateDir: string): Readonly<Record<string, string>>;
+}
+export declare function resolveHistoricalEntityCanonicalId(normalized: string, mappings: Readonly<Record<string, string>>): string;
+/**
+ * Canonicalize the `entityRef` a memory-write caller supplied (issue #2213).
+ *
+ * Extraction and capture callers pass whatever id the LLM or user produced,
+ * which can name a legacy id this migration already renamed. Resolving at the
+ * WRITE boundary means store-mediated writes can never re-introduce legacy
+ * references — which is what let the completed migration retire its recurring
+ * full-corpus reference rewrite. It also keeps write-time tombstone lookups on
+ * the same id space as migrated tombstones. Unknown ids pass through verbatim.
+ */
+export declare function canonicalizeEntityRefOption<T extends {
+    entityRef?: string;
+}>(options: T, mappings: Readonly<Record<string, string>>): T;
+/**
+ * Canonicalize the effective `entityRef:` line inside a raw memory record's
+ * leading frontmatter block (issue #2213). Bulk writers that persist record
+ * bytes verbatim — capsule import/merge — are a write boundary too: a capsule
+ * can carry pre-migration memories whose refs the target's completed journal
+ * already renamed, and no later reconciliation pass exists to absorb them.
+ *
+ * Line selection mirrors the frontmatter parser and the migration's own
+ * serializer: the LAST `entityRef` key wins (indentation tolerated), its
+ * indent is preserved, and CRLF records keep their line endings. The closing
+ * delimiter must be a standalone `---` line. Non-frontmatter content, records
+ * without an `entityRef` line, and ids the journal does not map all pass
+ * through byte-identical.
+ */
+export declare function canonicalizeEntityRefFrontmatter(content: string, mappings: Readonly<Record<string, string>>): string;
+/** The raw `entityRef` value in a record's leading frontmatter, or null. */
+export declare function readEntityRefFromFrontmatter(content: string): string | null;
+/**
+ * Reconcile-pending marker (issue #2213). Raw-byte memory writers that CANNOT
+ * canonicalize inline — offline-sync file replication (opaque, possibly
+ * encrypted buffers), consolidation-undo restores, governance-run restores —
+ * touch this marker instead. The next migration invocation honors it by
+ * running ONE bounded reference-reconciliation pass over the completed
+ * journal's retained mappings, then clears it. This replaces the retired
+ * every-run corpus rewrite with a signal that fires only when a raw writer
+ * actually landed unvetted bytes.
+ */
+export declare const ENTITY_CANONICAL_ID_RECONCILE_MARKER = "entity-canonical-id-reconcile.pending";
+/** The generation a migration run renamed aside for consumption; a crash can strand it. */
+export declare const ENTITY_CANONICAL_ID_RECONCILE_CONSUMING_MARKER = "entity-canonical-id-reconcile.pending.consuming";
+export declare function requestEntityCanonicalIdReconcileSync(stateDir: string): void;
+export declare function requestEntityCanonicalIdReconcile(stateDir: string): Promise<void>;
+/**
+ * Post-persist TOCTOU guard (issue #2213). A writer resolves `entityRef`
+ * against one journal generation, then awaits (snapshots, locks, fsyncs)
+ * before its bytes land — a peer migration can publish AND finish its final
+ * reference scan inside that window, leaving the just-written file behind.
+ * Callers pass the mapping table captured at resolve time plus a fresh cache
+ * read taken AFTER the write: the cache returns the identical object while
+ * the journal file is unchanged, so an identity mismatch means the journal
+ * moved mid-write and one bounded reconcile pass is requested.
+ */
+export declare function reconcileIfJournalMovedSync(stateDir: string, idsAtResolve: Readonly<Record<string, string>>, idsAfterWrite: Readonly<Record<string, string>>): void;
+export declare function reconcileIfJournalMoved(stateDir: string, idsAtResolve: Readonly<Record<string, string>>, idsAfterWrite: Readonly<Record<string, string>>): Promise<void>;
+/**
+ * Classify a raw write target for entity-reference handling (issue #2213):
+ * - `"memory"` — hot recall / cold / archive record whose FRONTMATTER
+ *   `entityRef` the writer must canonicalize at the write (and repair after).
+ * - `"entity"` — an `entities/` page. Its migrated surface is relationship
+ *   TARGETS in the body, which only `rewriteRelationshipTargets` understands;
+ *   raw writers persist bytes faithfully and request the bounded reconcile
+ *   pass instead of attempting a frontmatter rewrite.
+ * - `"outside"` — transcripts, profiles, runtime state, and every other file
+ *   outside the migration's scan scope: write byte-identical, no marker.
+ */
+export type EntityRefWritePathKind = "memory" | "entity" | "outside";
+export declare function classifyEntityRefWritePath(baseDir: string, filePath: string): EntityRefWritePathKind;
+/** True when `filePath` is in the migration's scan scope at all. */
+export declare function pathMayCarryEntityRefs(baseDir: string, filePath: string): boolean;
+/**
+ * Canonicalize a tombstone's identity fields at the append chokepoint
+ * (issue #2213): emitters (forget, temporal supersession, pattern
+ * reinforcement, supersede) build inputs from records that may have been
+ * read before a peer migration completed. The supersession key embeds the
+ * NORMALIZED entity segment (`entity::attr`), so it is re-prefixed when the
+ * ref moved — otherwise the keyed guard lands in the legacy id space while
+ * write-time lookups canonicalize, and a paraphrase resurrects.
+ */
+export interface TombstoneIdentity {
+    entityRef: string | undefined;
+    supersessionKey: string | undefined;
+}
+export declare function canonicalizeTombstoneIdentity(entityRef: string | undefined, supersessionKey: string | undefined, refIds: Readonly<Record<string, string>>): TombstoneIdentity;
+/**
+ * Post-persist repair (issue #2213): when the journal moved across a persist,
+ * re-resolve the caller's ORIGINAL ref against the fresh table and rewrite
+ * the file in place (bounded). When the journal will not settle, take the
+ * entity MUTATION lock — parks/removals (the direction the reconcile pass
+ * cannot repair, because the removed mapping is gone from the table) publish
+ * under it — settle once, then request the marker for additive moves only.
+ */
+export declare function repairEntityRefAfterJournalMove(options: {
+    stateDir: string;
+    currentIds: () => Readonly<Record<string, string>>;
+    idsAtResolve: Readonly<Record<string, string>>;
+    rawRef: string;
+    frontmatter: {
+        entityRef?: string;
+    };
+    rewrite: () => Promise<void>;
+}): Promise<void>;
+/**
+ * Content-form counterpart of {@link repairEntityRefAfterJournalMove} for
+ * async writers that persist raw record bytes (capsule import/merge,
+ * binary-lifecycle redirects): same bounded loop, same locked settle.
+ */
+export declare function repairContentAfterJournalMove(options: {
+    stateDir: string;
+    cache: HistoricalEntityCanonicalIdCache;
+    idsAtWrite: Readonly<Record<string, string>>;
+    rawContent: string;
+    lastWritten: string;
+    rewrite: (content: string) => Promise<void>;
+}): Promise<void>;
+/**
+ * Sync variant (space promotion, curation, review actions). Sync callers
+ * cannot take the async mutation lock, so exhaustion surfaces a retryable
+ * error after requesting the marker — a silent return could leave the bytes
+ * on a parked canonical claimant the reconcile pass cannot restore.
+ */
+export declare function repairContentAfterJournalMoveSync(options: {
+    stateDir: string;
+    cache: HistoricalEntityCanonicalIdCache;
+    idsAtWrite: Readonly<Record<string, string>>;
+    rawContent: string;
+    lastWritten: string;
+    rewrite: (content: string) => void;
+}): void;
+//# sourceMappingURL=entity-canonical-id-references.d.ts.map

package/dist/storage/entity-canonical-id-references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-canonical-id-references.d.ts","sourceRoot":"","sources":["../../src/storage/entity-canonical-id-references.ts"],"names":[],"mappings":"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"}

package/dist/storage/entity-id-safety.d.ts

@@ -0,0 +1,2 @@
+export declare function assertSafeEntityId(entityId: string): void;
+//# sourceMappingURL=entity-id-safety.d.ts.map

package/dist/storage/entity-id-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-id-safety.d.ts","sourceRoot":"","sources":["../../src/storage/entity-id-safety.ts"],"names":[],"mappings":"AAEA,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAIzD"}

package/dist/storage/entity-ref-repair.d.ts

@@ -0,0 +1,45 @@
+import type { MemoryFile, MemoryFrontmatter } from "../types.js";
+import { type TombstoneMatch, type TombstoneStore } from "../lifecycle/tombstones.js";
+export interface EntityRefRepairDeps {
+    readonly stateDir: string;
+    readonly baseDir: string;
+    currentHistoricalIds(): Readonly<Record<string, string>>;
+    serializeFrontmatter(fm: MemoryFrontmatter): string;
+    writeTombstoneBlockedMemory(pathname: string, fileContent: string, frontmatter: MemoryFrontmatter, content: string): Promise<void>;
+    invalidateAllMemoriesCache(): void;
+    getTombstoneStore(): Promise<TombstoneStore>;
+    tombstonesEnabled(): boolean;
+    tombstonesNamespace(): string;
+}
+export interface EntityRefRepairOptions {
+    /** Re-run the add-only resurrection gate under the FINAL ref before the
+     * rewrite (chunk writes, where `body` IS the hash source). */
+    regateFact?: boolean;
+    /** Rollback: rewrite this pre-mutation record on repair failure. */
+    onFailRestore?: MemoryFile;
+    /** Rollback: unlink a file this mutation created on repair failure. */
+    onFailRemove?: string;
+}
+export declare class EntityRefRepair {
+    private readonly deps;
+    constructor(deps: EntityRefRepairDeps);
+    /**
+     * Shared lookup+apply core for the write-time resurrection gate (#1579 /
+     * #2213): fail-open, add-only; writeMemory's gate + chunk-repair re-gate
+     * consult this one implementation (rule 43).
+     */
+    gate(fm: MemoryFrontmatter, canonicalBody: string, structuredAttributes?: Record<string, string>): Promise<TombstoneMatch | null>;
+    /** Post-persist repair delegate — see the references module for semantics. */
+    repair(filePath: string, fm: MemoryFrontmatter, rawRef: string, refIds: Readonly<Record<string, string>>, body: string, opts?: EntityRefRepairOptions): Promise<void>;
+    /**
+     * Restore a record's pre-mutation bytes through the blocked-capture
+     * surface when a post-persist repair fails (§14).
+     */
+    restore(before: MemoryFile): Promise<void>;
+    /**
+     * Projection rows written under the pre-repair claimant cannot be restored
+     * once the mapping is parked (Codex P1). Fail-open: projection is rebuildable.
+     */
+    syncProjection(memoryId: string, refBefore: string | undefined, refAfter: string | undefined): Promise<void>;
+}
+//# sourceMappingURL=entity-ref-repair.d.ts.map

package/dist/storage/entity-ref-repair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-ref-repair.d.ts","sourceRoot":"","sources":["../../src/storage/entity-ref-repair.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,4BAA4B,CAAC;AAKpC,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oBAAoB,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACzD,oBAAoB,CAAC,EAAE,EAAE,iBAAiB,GAAG,MAAM,CAAC;IACpD,2BAA2B,CACzB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,iBAAiB,EAC9B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,0BAA0B,IAAI,IAAI,CAAC;IACnC,iBAAiB,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC;IAC7C,iBAAiB,IAAI,OAAO,CAAC;IAC7B,mBAAmB,IAAI,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,sBAAsB;IACrC;kEAC8D;IAC9D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oEAAoE;IACpE,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,mBAAmB;IAEtD;;;;OAIG;IACG,IAAI,CACR,EAAE,EAAE,iBAAiB,EACrB,aAAa,EAAE,MAAM,EACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5C,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IA4BjC,8EAA8E;IACxE,MAAM,CACV,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,iBAAiB,EACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACxC,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,sBAA2B,GAChC,OAAO,CAAC,IAAI,CAAC;IAoChB;;;OAGG;IACG,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAchD;;;OAGG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,OAAO,CAAC,IAAI,CAAC;CAQjB"}

package/dist/storage/entity-store.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Entity store (extracted from storage.ts StorageManager; god-file
+ * decomposition, #1526 playbook: verbatim move + live selfDeps wiring so
+ * Object.create(prototype) fakes and instance stubs keep working).
+ *
+ * Owns the entity file subsystem:
+ *   - entity name normalization (alias table aware)
+ *   - entity read/write (incl. schema-validated structured sections)
+ *   - entity synthesis updates and knowledge-index construction
+ *   - fragmented-entity merge (consolidation)
+ */
+import { type CorpusReadOptions } from "../corpus-read-cancellation.js";
+import type { VersionTrigger } from "../page-versioning.js";
+import type { EntityActivityEntry, EntityFile, EntityRelationship, EntityStructuredSection, PluginConfig } from "../types.js";
+import { StorageManager } from "../storage.js";
+export { parseEntityFile } from "../storage.js";
+export interface EntityStoreDeps {
+    /** Live class object of the host instance — shared static caches (see storage.ts storageManagerClass). */
+    readonly storageManagerClass: typeof StorageManager;
+    readonly baseDir: string;
+    bumpMemoryStatusVersion(): void;
+    /** Entity-mutation sentinel for the migration fingerprint (issue #2213). */
+    bumpEntityMutationVersion(): void;
+    ensureDirectories(): Promise<void>;
+    readonly entitiesDir: string;
+    readonly entitySchemas: PluginConfig["entitySchemas"] | undefined;
+    currentHistoricalIds(): Readonly<Record<string, string>>;
+    findMatchingEntity(proposedName: string, type: string): Promise<string | null>;
+    getEntityCacheSecureStoreKey(): string;
+    getEntityMutationVersion(): number;
+    getMemoryStatusVersion(): number;
+    invalidateKnowledgeIndexCache(): void;
+    knowledgeIndexCache: {
+        result: string;
+        builtAt: number;
+    } | null;
+    okfConformanceEnabled(): boolean;
+    normalizeEntityName(raw: string, type: string): string;
+    readAllEntityFiles(): Promise<EntityFile[]>;
+    readStorageSecureFile(filePath: string): Promise<string>;
+    removeEntitySynthesisQueueEntries(entityNames: string[]): Promise<void>;
+    resolveEntityFilePath(name: string): string | null;
+    snapshotBeforeWrite(filePath: string, trigger: VersionTrigger): Promise<void>;
+    readonly userAliases: Record<string, string>;
+    writeStorageSecureFile(filePath: string, content: string | Buffer): Promise<void>;
+}
+export declare class EntityStore {
+    private readonly deps;
+    constructor(deps: EntityStoreDeps);
+    /** Normalize an entity name using this store's alias table. */
+    normalizeEntityName(raw: string, type: string): string;
+    /**
+     * Read an entity file by id, resolving through the migration journal with a
+     * fallback to the caller's original id (issue #2213): mid-migration, the
+     * journal maps legacy → canonical BEFORE the file moves — writing the
+     * still-existing legacy file is safe (the rename retry carries it), while
+     * resolving only the canonical path silently drops the mutation.
+     */
+    private readEntityForMutation;
+    /**
+     * Locked read-modify-write for the entity-file mutators (issue #2213):
+     * holding the entity-mutation lock keeps `migrateEntityFilePair` (which
+     * takes the same lock) from moving the file between the fallback read and
+     * this write — an unlocked write could recreate a just-renamed legacy file.
+     * The journal itself is NOT serialized by this lock (`pruneBlocked` can
+     * park a mapping mid-mutation), so the journal identity is REVALIDATED
+     * just before committing — a moved journal restarts resolution against the
+     * fresh table instead of writing into a since-contested claimant — and
+     * checked once more after the write for a move across the write itself.
+     * `mutate` returns false to skip the write. Resolves true when written.
+     */
+    private mutateEntityFile;
+    /** 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; prunes oldest beyond maxEntries. */
+    addEntityActivity(name: string, entry: EntityActivityEntry, maxEntries: number): Promise<void>;
+    addEntityAlias(name: string, alias: string): Promise<void>;
+    writeEntity(name: string, type: string, facts: string[], options?: {
+        timestamp?: string;
+        source?: string;
+        sessionKey?: string;
+        principal?: string;
+        origin?: string;
+        structuredSections?: EntityStructuredSection[];
+    }): Promise<string>;
+    private writeEntityUnlocked;
+    readEntity(name: string): Promise<string>;
+    /** Return sorted list of entity filenames (without .md extension) */
+    listEntityNames(): Promise<string[]>;
+    /** Re-serialize every entity file into the compiled-truth timeline shape. */
+    migrateEntityFilesToCompiledTruthTimeline(): Promise<{
+        total: number;
+        migrated: number;
+    }>;
+    /**
+     * Set or rewrite the synthesis layer of an entity file.
+     */
+    updateEntitySynthesis(name: string, synthesis: string, options?: {
+        entityUpdatedAt?: string;
+        synthesisStructuredFactCount?: number;
+        synthesisStructuredFactDigest?: string;
+        synthesisTimelineCount?: number;
+        updatedAt?: string;
+        incrementVersion?: boolean;
+    }): Promise<void>;
+    private updateEntitySynthesisUnlocked;
+    /**
+     * Read all entity files and return lightweight EntityFile objects.
+     * Parsing is fast (~50-100ms for ~1,800 files) since entity files are small.
+     */
+    readAllEntityFiles(options?: CorpusReadOptions): Promise<EntityFile[]>;
+    /**
+     * Build the Knowledge Index: a compact markdown table of top-scored entities.
+     * Respects maxEntities and maxChars limits from config.
+     */
+    buildKnowledgeIndex(config: PluginConfig, overrides?: {
+        maxEntities?: number;
+        maxChars?: number;
+    }): Promise<{
+        result: string;
+        cached: boolean;
+    }>;
+    /**
+     * Merge fragmented entity files that resolve to the same canonical name.
+     * Preserves relationships, activity, aliases, and summary from all fragments.
+     * Returns count of files merged.
+     */
+    mergeFragmentedEntities(): Promise<number>;
+    private mergeFragmentedEntitiesUnlocked;
+}
+//# sourceMappingURL=entity-store.d.ts.map

package/dist/storage/entity-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-store.d.ts","sourceRoot":"","sources":["../../src/storage/entity-store.ts"],"names":[],"mappings":"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"}

package/dist/storage/entity-timeline.d.ts

@@ -0,0 +1,34 @@
+import type { EntityFile, EntityStructuredSection, EntityTimelineEntry, PluginConfig } from "../types.js";
+export declare const ENTITY_TIMELINE_METADATA_MARKER = "remnic-meta-v1";
+export declare function parseEntityTimelineBullet(bullet: string, fallbackTimestamp: string): EntityTimelineEntry | null;
+export declare function isEntitySynthesisTimelinePromotionBullet(bullet: string): boolean;
+export declare function looksLikeEntityTimelineTimestamp(token: string): boolean;
+export declare function isManagedEntityTimelineSource(source: string): boolean;
+export declare function findEntityTimelineTokenEnd(input: string): number;
+export declare function escapeEntityTimelineMetadataValue(value: string): string;
+export declare function unescapeEntityTimelineMetadataValue(value: string): string;
+export declare function escapeEntityTimelineText(value: string): string;
+export declare function unescapeEntityTimelineText(value: string): string;
+export declare function serializeEntityTimelineEntry(entry: EntityTimelineEntry): string;
+export declare function dedupeEntityTimelineFacts(timeline: EntityTimelineEntry[]): string[];
+export declare function normalizeEntitySectionFact(value: string): string;
+export declare function normalizeStructuredSectionFactsWithOrigins(facts: string[], factOrigins?: Array<string | undefined>, defaultOrigin?: string): Pick<EntityStructuredSection, "facts" | "factOrigins">;
+export declare function normalizeStructuredSectionFacts(facts: string[]): string[];
+export declare function collectStructuredSectionFacts(structuredSections: EntityStructuredSection[]): string[];
+export declare function compileEntityFacts(timeline: EntityTimelineEntry[], structuredSections: EntityStructuredSection[]): string[];
+export declare function partitionEntityStructuredSections(entityType: string, extraSections: Array<{
+    title: string;
+    lines: string[];
+}>, entitySchemas?: PluginConfig["entitySchemas"]): {
+    structuredSections: EntityStructuredSection[];
+    remainingExtraSections: Array<{
+        title: string;
+        lines: string[];
+    }>;
+};
+export declare function latestEntityTimelineTimestamp(entity: EntityFile): string | undefined;
+export declare function compareEntityTimestamps(left?: string, right?: string): number;
+export declare function countEntityStructuredFacts(entity: EntityFile): number;
+export declare function fingerprintEntityStructuredFacts(entity: Pick<EntityFile, "structuredSections">): string | undefined;
+export declare function isEntitySynthesisStale(entity: EntityFile): boolean;
+//# sourceMappingURL=entity-timeline.d.ts.map

package/dist/storage/entity-timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-timeline.d.ts","sourceRoot":"","sources":["../../src/storage/entity-timeline.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC1G,eAAO,MAAM,+BAA+B,mBAAmB,CAAC;AAEhE,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAuG/G;AAED,wBAAgB,wCAAwC,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAShF;AAED,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGvE;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CA0BrE;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAehE;AAED,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA8BvE;AAED,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAgDzE;AACD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,CAqB/E;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAEnF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wBAAgB,0CAA0C,CACxD,KAAK,EAAE,MAAM,EAAE,EACf,WAAW,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,EACvC,aAAa,CAAC,EAAE,MAAM,GACrB,IAAI,CAAC,uBAAuB,EAAE,OAAO,GAAG,aAAa,CAAC,CAqBxD;AACD,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAEzE;AAED,wBAAgB,6BAA6B,CAAC,kBAAkB,EAAE,uBAAuB,EAAE,GAAG,MAAM,EAAE,CAUrG;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,kBAAkB,EAAE,uBAAuB,EAAE,GAC5C,MAAM,EAAE,CAcV;AAwDD,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,EACxD,aAAa,CAAC,EAAE,YAAY,CAAC,eAAe,CAAC,GAC5C;IACD,kBAAkB,EAAE,uBAAuB,EAAE,CAAC;IAC9C,sBAAsB,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;CACnE,CAiDA;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAUpF;AAED,wBAAgB,uBAAuB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAoB7E;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAErE;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,oBAAoB,CAAC,GAAG,MAAM,GAAG,SAAS,CAkBnH;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAyBlE"}

package/dist/storage/identity-continuity-store.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Identity-continuity persistence extracted from StorageManager.
+ *
+ * The host keeps the public API while this store owns anchors, incidents,
+ * audits, and improvement-loop files. Dependencies stay live through
+ * `selfDeps`, preserving secure-store and catalog-write behavior.
+ */
+import type { ContinuityImprovementLoop, ContinuityIncidentCloseInput, ContinuityIncidentOpenInput, ContinuityIncidentRecord, ContinuityLoopReviewInput, ContinuityLoopUpsertInput } from "../types.js";
+export interface IdentityContinuityStoreDeps {
+    ensureDirectories(): Promise<void>;
+    generateId(prefix?: string): string;
+    readonly identityAnchorPath: string;
+    readonly identityIncidentsDir: string;
+    readonly identityAuditsWeeklyDir: string;
+    readonly identityAuditsMonthlyDir: string;
+    readonly identityImprovementLoopsPath: string;
+    readStorageSecureFile(filePath: string): Promise<string>;
+    writeStorageSecureFile(filePath: string, content: string | Buffer): Promise<void>;
+}
+export declare class IdentityContinuityStore {
+    private readonly deps;
+    constructor(deps: IdentityContinuityStoreDeps);
+    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 readContinuityIncidentFileNames;
+    private readContinuityIncidentFile;
+    private findContinuityIncidentFilePathById;
+    private sanitizeIdentityAuditKey;
+}
+//# sourceMappingURL=identity-continuity-store.d.ts.map

package/dist/storage/identity-continuity-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-continuity-store.d.ts","sourceRoot":"","sources":["../../src/storage/identity-continuity-store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAcH,OAAO,KAAK,EACV,yBAAyB,EACzB,4BAA4B,EAC5B,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,2BAA2B;IAC1C,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACpC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;IAC1C,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAC9C,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACzD,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnF;AAED,qBAAa,uBAAuB;IACtB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,2BAA2B;IAExD,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnD,kBAAkB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAS5C,wBAAwB,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAY/F,uBAAuB,CAC3B,KAAK,SAAM,EACX,KAAK,GAAE,MAAM,GAAG,QAAQ,GAAG,KAAa,GACvC,OAAO,CAAC,wBAAwB,EAAE,CAAC;IA+BhC,uBAAuB,CAC3B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,wBAAwB,GAAG,IAAI,CAAC;IAWrC,kBAAkB,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAS/F,iBAAiB,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAYpF,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7D,4BAA4B,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAStD,mCAAmC,IAAI,OAAO,CAAC,yBAAyB,EAAE,CAAC;IAM3E,6BAA6B,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAQnG,6BAA6B,CACjC,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,yBAAyB,GAC/B,OAAO,CAAC,yBAAyB,GAAG,IAAI,CAAC;YAQ9B,+BAA+B;YAQ/B,0BAA0B;YAW1B,kCAAkC;IAiBhD,OAAO,CAAC,wBAAwB;CAOjC"}

package/dist/storage/memory-frontmatter-metadata.d.ts

@@ -0,0 +1,4 @@
+export type RawFrontmatterOwner = object;
+export declare function rememberRawFrontmatter<T extends RawFrontmatterOwner>(owner: T, raw: string): T;
+export declare function readRawMemoryDocument(owner: RawFrontmatterOwner): string | undefined;
+//# sourceMappingURL=memory-frontmatter-metadata.d.ts.map

package/dist/storage/memory-frontmatter-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-frontmatter-metadata.d.ts","sourceRoot":"","sources":["../../src/storage/memory-frontmatter-metadata.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC;AAIzC,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,mBAAmB,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,CAG9F;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,GAAG,SAAS,CAEpF"}