@remnic/core 9.69.87 → 9.69.88

package/dist/deep-recall-http-glue.js

@@ -1,12 +1,12 @@
 import {
   respondDeepRecall
-} from "./chunk-6L3PBSAR.js";
+} from "./chunk-YJ7MW627.js";
 import "./chunk-A7AISUJI.js";
 import "./chunk-PQVCH2AE.js";
-import "./chunk-3C3J243X.js";
-import "./chunk-7LCGFUMB.js";
-import "./chunk-X7Y7WX73.js";
+import "./chunk-LW3HKRL7.js";
+import "./chunk-VDX2J7OX.js";
 import "./chunk-WEHSQBFR.js";
+import "./chunk-DQEMWVMT.js";
 import "./chunk-J4EB7DNW.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
@@ -14,16 +14,23 @@ import "./chunk-FP2373TW.js";
 import "./chunk-Z2YFLXHU.js";
 import "./chunk-I4WBNM3M.js";
 import "./chunk-SOAU2OE2.js";
-import "./chunk-WQZZDN5M.js";
+import "./chunk-OCFXVDBZ.js";
 import "./chunk-UI3NYK34.js";
+import "./chunk-ETUZFFPU.js";
+import "./chunk-K6T33R4Q.js";
+import "./chunk-4NSLQ7EU.js";
+import "./chunk-EFHNFTWB.js";
 import "./chunk-GCGJW34D.js";
-import "./chunk-AREGMX2J.js";
-import "./chunk-3BTFBQLO.js";
+import "./chunk-TYT4TEQV.js";
+import "./chunk-75PT4N7Q.js";
+import "./chunk-UCPGOUDZ.js";
 import "./chunk-LQWOFU6L.js";
+import "./chunk-FFAZ2XFU.js";
 import "./chunk-P7FMDTKL.js";
+import "./chunk-P2QRMMVQ.js";
 import "./chunk-3MUKQQ7A.js";
 import "./chunk-BTTPKDIL.js";
-import "./chunk-JN72EPOE.js";
+import "./chunk-MAAL6OZV.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-VS2IYZRU.js";
 import "./chunk-KNA3BXXL.js";

package/dist/embedding-fallback.d.ts

@@ -1,33 +1,7 @@
 import type { PluginConfig } from "./types.js";
-/**
- * Thrown by `EmbeddingFallback.search()` (via `embed()`) when the embedding
- * backend is effectively unavailable on the lookup path — either because the
- * HTTP fetch exceeded its deadline OR because the endpoint returned a non-2xx
- * status code. Callers that need to distinguish a backend outage from "no
- * candidates" can `instanceof`-check against this class.
- *
- * Round 9 fix (Finding UZqB): previously a timeout returned null from embed(),
- * which caused search() to return [] silently. decideSemanticDedup then
- * classified the result as no_candidates instead of backend_unavailable, so
- * the per-batch batchBackendUnavailable short-circuit never activated and
- * batches of N facts each paid a full timeout roundtrip.
- *
- * Round 10 fix (Findings Ui1J + Ui1L): search() now only re-throws this error
- * when the caller explicitly passes `{ throwOnTimeout: true }`. Without that
- * flag search() catches it and returns [] instead, preserving fail-open
- * semantics for recall-path callers (searchEmbeddingFallback) that have no
- * try/catch. Only the semantic-dedup path (semanticDedupLookup) passes the
- * flag so it can still reach decideSemanticDedup's backend_unavailable branch.
- *
- * Round 11 fix (Finding Ur_J): `embed()` now also throws this error from the
- * lookup path when the HTTP response is non-2xx (e.g. 429, 500, 503). Without
- * this, repeated 5xx outages would each return null → [] → no_candidates and
- * subsequent facts in the same batch would all pay full roundtrips instead of
- * tripping the per-batch backend_unavailable short-circuit.
- *
- * The class name is kept for backward compatibility — `EmbeddingTimeoutError`
- * now signals "lookup backend unavailable" rather than strictly "timed out".
- */
+import { EmbeddingIndexStoreIo } from "./embedding-index-storage.js";
+export { EmbeddingIndexCapacityError, EmbeddingIndexStorageError, } from "./embedding-index-storage.js";
+export type { EmbeddingIndexStatusFile, EmbeddingIndexWriteFailure, } from "./embedding-index-storage.js";
 export declare class EmbeddingTimeoutError extends Error {
     readonly name: "EmbeddingTimeoutError";
     constructor(message: string);
@@ -47,10 +21,16 @@ export declare class EmbeddingProviderUnavailableError extends Error {
 export type EmbedMode = "lookup" | "index";
 export declare class EmbeddingFallback {
     private readonly config;
-    private readonly indexPath;
+    private readonly store;
     private loaded;
+    /** True when `loaded` was read from disk rather than started fresh, so identity probes can trust it. */
+    private loadedFromDisk;
     private mutationQueue;
-    constructor(config: PluginConfig);
+    /** The canonical state dir scoping this fallback's generation mutation lock. */
+    private readonly generationStateDir;
+    private readonly generationLockPath;
+    private lockSection;
+    constructor(config: PluginConfig, storeIo?: EmbeddingIndexStoreIo);
     isAvailable(): Promise<boolean>;
     /**
      * Embed an array of texts and return their embedding vectors.
@@ -120,8 +100,38 @@ export declare class EmbeddingFallback {
     private embed;
     private embedWithEffectiveProvider;
     private embedWithHostProvider;
+    /**
+     * Load the authoritative generation for `provider`. STRICT: an unreadable,
+     * malformed, foreign-shaped, or mixed-identity index throws
+     * EmbeddingIndexStorageError instead of ever returning a partial view —
+     * recall catches it at its boundary and fails open uncached; mutations
+     * propagate it and fail closed. This.loaded is only ever assigned a fully
+     * validated generation.
+     */
+    /**
+     * A fence the store calls immediately before destructive writes: reasserts
+     * THIS section's lock ownership after potentially long serialization.
+     * Fail closed when no section is held — persisting unsynchronized would
+     * reintroduce the lost-update race.
+     */
+    private generationFence;
+    /**
+     * Cache-warm path: a normal search serves the in-memory index WITHOUT the
+     * lock (pre-existing staleness semantics: a peer swap between searches is
+     * refreshed by the next cold load). On a cache miss the COMPLETE load runs
+     * under the generation mutation lock so the enumeration + shard reads see
+     * exactly one generation. The identity is re-checked under the lock on the
+     * cold path; the caller has already performed any provider-swap embed
+     * outside the lock.
+     */
+    private loadIndexUnderGenerationLock;
     private loadIndex;
     private readIndexIdentityFromDisk;
+    /**
+     * Persist the index through the file store. On any failure the in-memory
+     * cache is invalidated: entries mutated in the cached map must never be
+     * mistaken for durable state by a retry or a later search.
+     */
     private saveIndex;
 }
 //# sourceMappingURL=embedding-fallback.d.ts.map

package/dist/embedding-fallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embedding-fallback.d.ts","sourceRoot":"","sources":["../src/embedding-fallback.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AA0C/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,SAAkB,IAAI,EAAG,uBAAuB,CAAU;gBAC9C,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,iCAAkC,SAAQ,KAAK;IAC1D,SAAkB,IAAI,EAAG,mCAAmC,CAAU;gBAC1D,OAAO,EAAE,MAAM;CAG5B;AAiED;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE3C,qBAAa,iBAAiB;IAKhB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,aAAa,CAAoC;gBAE5B,MAAM,EAAE,YAAY;IAI3C,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC;;;;;;;;;;;;;OAaG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IA2BtD;;;;;;;;;;;;;;;;;;OAkBG;IACG,MAAM,CACV,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;QACP,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACxC;;;;;;;;;;;;;WAaG;QACH,cAAc,CAAC,EAAE,OAAO,CAAC;KACrB,GACL,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IA+DxD,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoC7E,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCtD,OAAO,CAAC,oBAAoB;YASd,eAAe;YAqCf,uCAAuC;IAcrD,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,mBAAmB;YAsBb,cAAc;YAuBd,KAAK;YASL,0BAA0B;YAgI1B,qBAAqB;YAoBrB,SAAS;YAqCT,yBAAyB;YAyBzB,SAAS;CAgBxB"}
+{"version":3,"file":"embedding-fallback.d.ts","sourceRoot":"","sources":["../src/embedding-fallback.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAO/C,OAAO,EAOL,qBAAqB,EACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,wBAAwB,EACxB,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC;AAyDtC,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,SAAkB,IAAI,EAAG,uBAAuB,CAAU;gBAC9C,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,iCAAkC,SAAQ,KAAK;IAC1D,SAAkB,IAAI,EAAG,mCAAmC,CAAU;gBAC1D,OAAO,EAAE,MAAM;CAG5B;AAiED;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE3C,qBAAa,iBAAiB;IAYhB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAXnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0B;IAChD,OAAO,CAAC,MAAM,CAAmC;IACjD,wGAAwG;IACxG,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,aAAa,CAAoC;IAEzD,gFAAgF;IAChF,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,WAAW,CAA+C;gBAErC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,qBAAqB;IAY5E,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC;;;;;;;;;;;;;OAaG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IA2BtD;;;;;;;;;;;;;;;;;;OAkBG;IACG,MAAM,CACV,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;QACP,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACxC;;;;;;;;;;;;;WAaG;QACH,cAAc,CAAC,EAAE,OAAO,CAAC;KACrB,GACL,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAmGxD,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0C7E,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4CtD,OAAO,CAAC,oBAAoB;YAmDd,eAAe;YAqCf,uCAAuC;IAcrD,OAAO,CAAC,oBAAoB;IAc5B,OAAO,CAAC,mBAAmB;YAsBb,cAAc;YAuBd,KAAK;YASL,0BAA0B;YAgI1B,qBAAqB;IAoBnC;;;;;;;OAOG;IACH;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAYvB;;;;;;;;OAQG;YACW,4BAA4B;YAmB5B,SAAS;YA4DT,yBAAyB;IAUvC;;;;OAIG;YACW,SAAS;CAcxB"}

package/dist/embedding-fallback.js

@@ -2,14 +2,22 @@ import {
   EmbeddingFallback,
   EmbeddingProviderUnavailableError,
   EmbeddingTimeoutError
-} from "./chunk-RB776UH3.js";
+} from "./chunk-C7V3KPKJ.js";
 import "./chunk-3ONXXHQO.js";
+import "./chunk-75PT4N7Q.js";
+import {
+  EmbeddingIndexCapacityError,
+  EmbeddingIndexStorageError
+} from "./chunk-UCPGOUDZ.js";
+import "./chunk-FFAZ2XFU.js";
 import "./chunk-BMXEBWBT.js";
 import "./chunk-P2QRMMVQ.js";
 import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   EmbeddingFallback,
+  EmbeddingIndexCapacityError,
+  EmbeddingIndexStorageError,
   EmbeddingProviderUnavailableError,
   EmbeddingTimeoutError
 };

package/dist/embedding-generation-lock.d.ts

@@ -0,0 +1,49 @@
+import { type HeldFileLockController } from "./utils/serialize-mutations.js";
+/** Control surface handed to a held embedding-generation lock section. */
+export type EmbeddingGenerationLockSection = HeldFileLockController;
+/**
+ * A fence the store calls immediately before a destructive write: reasserts
+ * lock ownership so a peer that stale-broke and replaced the lock aborts
+ * this write instead of clobbering the peer's.
+ */
+export type EmbeddingGenerationFence = () => Promise<void>;
+/**
+ * A held embedding-generation lock section was lost mid-critical-section —
+ * a peer stale-broke and replaced it. Abort; never publish.
+ */
+export declare class EmbeddingGenerationLockLostError extends Error {
+    constructor(lockPath: string);
+}
+/** The generation lock could not be acquired; callers fail closed and report it. */
+export declare class EmbeddingGenerationLockUnavailableError extends Error {
+    constructor(lockPath: string, reason: "timeout" | "error");
+}
+/**
+ * The lock file path for the generation whose canonical state dir is
+ * `absoluteStateDir` (physical path; e.g. `<memoryRoot>/state` or
+ * `<memoryRoot>/namespaces/<ns>/state`). Keyed by the physical directory so
+ * every root convention contends on one lock file per generation.
+ */
+export declare function embeddingGenerationLockPath(absoluteStateDir: string): string;
+/**
+ * Revalidate lock ownership immediately before a destructive publish.
+ * Throws {@link EmbeddingGenerationLockLostError} when the lock was
+ * broken/replaced, so the caller aborts and leaves the peer's write intact.
+ */
+export declare function assertEmbeddingGenerationLockHeld(lockPath: string, section: EmbeddingGenerationLockSection): Promise<void>;
+/**
+ * Run `fn` while holding the embedding-generation mutation lock for the
+ * generation whose state dir is `absoluteStateDir`, handing it the section
+ * controller. `serializeMutations` provides the in-process keyed chain
+ * INSIDE the cross-process advisory lock, so peers serialize against every
+ * section this process runs, one at a time. Times out fail-closed.
+ */
+export declare function withEmbeddingGenerationLock<T>(absoluteStateDir: string, fn: (lock: EmbeddingGenerationLockSection) => Promise<T>): Promise<T>;
+/** Capture a complete bounded digest census under lock, then stream outside
+ * the lock. If any member changes, throw rather than emit a complete subset. */
+export declare function withEmbeddingGenerationLockIter<T extends {
+    path: string;
+    sha256: string;
+    bytes: number;
+}>(absoluteStateDir: string, make: (includeContent: boolean) => AsyncIterable<T>, includeContent: boolean, verify?: () => Promise<void>): AsyncIterable<T>;
+//# sourceMappingURL=embedding-generation-lock.d.ts.map

package/dist/embedding-generation-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-generation-lock.d.ts","sourceRoot":"","sources":["../src/embedding-generation-lock.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,KAAK,sBAAsB,EAAwC,MAAM,gCAAgC,CAAC;AAOnH,0EAA0E;AAC1E,MAAM,MAAM,8BAA8B,GAAG,sBAAsB,CAAC;AAEpE;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAE3D;;;GAGG;AACH,qBAAa,gCAAiC,SAAQ,KAAK;gBAC7C,QAAQ,EAAE,MAAM;CAM7B;AAED,oFAAoF;AACpF,qBAAa,uCAAwC,SAAQ,KAAK;gBACpD,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO;CAI1D;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED;;;;GAIG;AACH,wBAAsB,iCAAiC,CACrD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,IAAI,CAAC,CAEf;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAC3C,gBAAgB,EAAE,MAAM,EACxB,EAAE,EAAE,CAAC,IAAI,EAAE,8BAA8B,KAAK,OAAO,CAAC,CAAC,CAAC,GACvD,OAAO,CAAC,CAAC,CAAC,CAUZ;AAED;gFACgF;AAChF,wBAAuB,+BAA+B,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAC9G,gBAAgB,EAAE,MAAM,EACxB,IAAI,EAAE,CAAC,cAAc,EAAE,OAAO,KAAK,aAAa,CAAC,CAAC,CAAC,EACnD,cAAc,EAAE,OAAO,EACvB,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC3B,aAAa,CAAC,CAAC,CAAC,CAyBlB"}

package/dist/embedding-generation-lock.js

@@ -0,0 +1,19 @@
+import {
+  EmbeddingGenerationLockLostError,
+  EmbeddingGenerationLockUnavailableError,
+  assertEmbeddingGenerationLockHeld,
+  embeddingGenerationLockPath,
+  withEmbeddingGenerationLock,
+  withEmbeddingGenerationLockIter
+} from "./chunk-75PT4N7Q.js";
+import "./chunk-FFAZ2XFU.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  EmbeddingGenerationLockLostError,
+  EmbeddingGenerationLockUnavailableError,
+  assertEmbeddingGenerationLockHeld,
+  embeddingGenerationLockPath,
+  withEmbeddingGenerationLock,
+  withEmbeddingGenerationLockIter
+};
+//# sourceMappingURL=embedding-generation-lock.js.map

package/dist/embedding-index-storage.d.ts

@@ -0,0 +1,276 @@
+import type { EmbeddingGenerationFence } from "./embedding-generation-lock.js";
+export type EmbeddingProviderType = "openai" | "local" | "host";
+export type EmbeddingIndexEntry = {
+    vector: number[];
+    path: string;
+};
+export type EmbeddingIndexFile = {
+    version: 1;
+    provider: EmbeddingProviderType;
+    model: string;
+    entries: Record<string, EmbeddingIndexEntry>;
+};
+export type EmbeddingIndexIdentity = Pick<EmbeddingIndexFile, "provider" | "model">;
+/** Outcome of reading one managed index file (legacy or shard). */
+export type ManagedIndexRead = {
+    outcome: "ok";
+    file: EmbeddingIndexFile;
+} | {
+    outcome: "absent";
+} | {
+    outcome: "foreign";
+} | {
+    outcome: "unreadable";
+    reason: string;
+};
+/** Which generation owns the index right now. */
+export type IndexLayout = "empty" | "legacy" | "sharded";
+/**
+ * Thrown when an embedding index (or one of its shards) cannot be persisted
+ * within the per-file serialization budget. Issue #3146: index files are
+ * materialized as single V8 strings, so a JSON document at or past
+ * `bufferConstants.MAX_STRING_LENGTH` chars makes every read and write throw
+ * `RangeError: Invalid string length`. The index is sharded before that
+ * ceiling; this tagged error is reserved for the residual case where even
+ * one shard cannot hold the payload (e.g. a single entry with an enormous
+ * vector), so callers can classify it as recoverable-with-record instead of
+ * an opaque background failure.
+ */
+export declare class EmbeddingIndexCapacityError extends Error {
+    readonly memoryId?: string | undefined;
+    readonly name: "EmbeddingIndexCapacityError";
+    constructor(message: string, memoryId?: string | undefined);
+}
+/**
+ * Thrown when an index file that should be authoritative cannot be read
+ * (I/O error, over-budget size, unparseable JSON). Mutation paths fail
+ * CLOSED on this: they must not continue with a fresh empty index and
+ * pretend the previous vectors were loaded — the file is left untouched in
+ * place for recovery. Read-only paths (recall) fail open to empty results
+ * and record the reason durably.
+ */
+export declare class EmbeddingIndexStorageError extends Error {
+    readonly name: "EmbeddingIndexStorageError";
+}
+/** Durable diagnostic row describing the last failed embedding-index write. */
+export interface EmbeddingIndexWriteFailure {
+    ts: string;
+    kind: "capacity" | "io";
+    message: string;
+    memoryId?: string;
+}
+/**
+ * Durable embedding-index diagnostics (issue #3146), persisted at
+ * `<memoryDir>/state/embedding-fallback-status.json` and surfaced through
+ * console_state, so background ingestion failures are visible to operators
+ * instead of only ever appearing as log lines.
+ */
+export interface EmbeddingIndexStatusFile {
+    version: 1;
+    /** Cumulative count of failed index writes since the file was created. */
+    failureCount: number;
+    /** Active write failure; cleared by the next successful save. */
+    lastWriteFailure?: EmbeddingIndexWriteFailure;
+    /** Set when an unreadable index file was detected instead of overwritten. */
+    lastReadRecovery?: {
+        ts: string;
+        message: string;
+    };
+    lastSuccessAt?: string;
+}
+export declare function resolveIndexFileCharLimit(): number;
+/**
+ * Stable FNV-1a shard assignment: an entry always hashes to the same shard,
+ * so an update or removal never needs a manifest to find its file.
+ */
+export declare function shardIndexOf(memoryId: string, shardCount: number): number;
+/**
+ * A shard file named `shard-NNNN.json` must only contain ids that hash to
+ * that shard: a misplaced copy would be loaded today and silently resurrect
+ * stale vectors after the computed shard is rewritten (issue #3148, round 6).
+ * Throws the tagged storage error so mutations fail closed and recall fails
+ * open at its boundary.
+ */
+export declare function validateShardMembership(shardName: string, file: EmbeddingIndexFile): void;
+export declare function isInvalidStringLengthError(err: unknown): boolean;
+/**
+ * Parse and FULLY validate one serialized index document (legacy or shard).
+ * The single read boundary shared by disk reads and offline-sync pulls: a
+ * document with a valid header but a malformed body (`entries` not a plain
+ * record, or an entry whose `path` is not a string / whose `vector` is not a
+ * finite-number array) is `unreadable`, not `ok` — recall fails open on the
+ * tagged reason, mutations fail closed, and the bytes are never overwritten
+ * (issue #3148 review, round 4).
+ */
+export declare function parseEmbeddingIndexDocument(raw: string): ManagedIndexRead;
+/**
+ * Group a complete index into per-shard entry records using the stable FNV
+ * assignment. Shared by `persist()` and the offline-sync generation
+ * transaction so a converted generation shards identically everywhere.
+ */
+export declare function shardEntriesForIndex(index: EmbeddingIndexFile): Map<number, Record<string, EmbeddingIndexEntry>>;
+/**
+ * Serialize one shard, translating a ceiling overflow into a tagged,
+ * recoverable capacity error. Exported for the offline-sync generation
+ * transaction, which stages incoming generations through the same budget.
+ */
+export declare function serializeEmbeddingShard(index: EmbeddingIndexFile, shardIndex: number, entries: Record<string, EmbeddingIndexEntry>, limit?: number): string;
+/**
+ * Optional canonical secure-store IO for the daemon. When provided (both
+ * halves), file content is read/written through the SAME
+ * StorageManager-backed contract offline sync uses: canonical-path AAD,
+ * secure-key-aware, atomic. Shard STAGING writes carry the FINAL published
+ * path so the post-publish rename keeps the ciphertext decryptable; dirty
+ * shard, status, and legacy writes are their own canonical final path.
+ * When omitted, the store behaves exactly as before (raw plaintext fs).
+ * The diagnostics status file is intentionally ALWAYS plain: it holds no
+ * memory content (failure strings/counts only) and console_state reads it
+ * without unlocking the store.
+ */
+export interface EmbeddingIndexStoreIo {
+    readUtf8(filePath: string): Promise<string>;
+    writeUtf8(filePath: string, contents: string, opts?: {
+        finalAadFilePath?: string;
+    }): Promise<void>;
+}
+export declare class EmbeddingIndexFileStore {
+    private readonly indexPath;
+    private readonly shardDir;
+    private readonly statusPath;
+    private readonly io?;
+    constructor(indexPath: string, shardDir: string, statusPath: string, io?: EmbeddingIndexStoreIo | undefined);
+    /** Legacy single-file layout path (public for error messages). */
+    get legacyPath(): string;
+    /** Record an unreadable-authoritative-file reason (both read and mutation paths). */
+    recordIndexStatusForLoad(reason: string): Promise<void>;
+    /**
+     * Which generation owns the index right now. The published
+     * `state/embeddings/` directory IS the layout marker: until it exists the
+     * legacy file is authoritative; from the atomic rename onward it never
+     * merges again.
+     */
+    detectLayout(): Promise<IndexLayout>;
+    /**
+     * Roll the fixed transaction backup back into the published position.
+     * Returns true when a rollback happened.
+     */
+    private replacementBackupExists;
+    /**
+     * The fixed transaction backup is a path with well-known semantics; a
+     * planted symlink must never be restored into the published position (it
+     * would point the generation outside the memory dir) nor removed through
+     * as if it were the former generation. Symlinks are rejected outright.
+     */
+    private assertBackupNotSymlink;
+    /**
+     * Mutation-queue entry point: roll the fixed transaction backup back into
+     * the published position after an interrupted replacement. Returns true
+     * when a rollback happened. Only fires in the actual rename gap
+     * (published directory absent); callers must invalidate any cached index
+     * view when this returns true.
+     */
+    recoverIfInterrupted(fence?: EmbeddingGenerationFence): Promise<boolean>;
+    private legacyOrEmptyLayout;
+    /** Header identity of the authoritative generation, read leniently. */
+    identityFromDisk(): Promise<EmbeddingIndexIdentity | null>;
+    /**
+     * Load every readable shard into `merged`. Returns the generation identity.
+     * Unreadable shards record durable diagnostics; `strict` additionally
+     * fails the mutation closed.
+     */
+    readShardGenerationInto(merged: Record<string, EmbeddingIndexEntry>): Promise<EmbeddingIndexIdentity | null>;
+    readLegacy(): Promise<ManagedIndexRead>;
+    /**
+     * Read one managed index file (legacy or shard). The file is never
+     * modified or moved here: an unreadable file stays in place for recovery
+     * and is reported through the returned outcome (mutation paths fail
+     * closed on it; read-only paths fail open and record the reason).
+     */
+    /**
+     * Read/mutation boundary for any generation member or the legacy marker
+     * (codex PRRT_kwDORJXyws6mZ72r): a symlinked member is rejected outright
+     * and its real target must stay inside the canonical state directory —
+     * following a planted link would read or write outside the memory root.
+     * Runs BEFORE the secure IO so storage-backed reads are covered too.
+     */
+    private assertGenerationFileNotSymlinked;
+    readFileAt(filePath: string): Promise<ManagedIndexRead>;
+    private readShardNames;
+    /**
+     * Persist the index. Layout decisions, in order:
+     *   - published generation: rewrite only the shards this mutation touched;
+     *   - legacy/empty generation and the whole index fits one bounded JSON
+     *     string: stay the single `state/embeddings.json` file;
+     *   - over budget: ONE-WAY migration — stage a complete shard set, publish
+     *     it with a single directory rename, then rename the legacy file aside
+     *     as a non-authoritative recovery artifact (issue #3146).
+     */
+    persist(index: EmbeddingIndexFile, opts?: {
+        touchedIds?: readonly string[];
+        memoryId?: string;
+        /** Reasserts mutation-lock ownership immediately before each destructive write (after serialization). */
+        fence?: EmbeddingGenerationFence;
+    }): Promise<void>;
+    /**
+     * Replace a published generation wholesale after a provider/model identity
+     * change (replacement semantics — the former entries are obsolete by
+     * definition). Crash-safe by the same construction as the migration: the
+     * COMPLETE new-identity set is staged and validated first (old bytes are
+     * not touched until staging succeeds), then published atomically through
+     * `publishSwappedGeneration`.
+     */
+    private publishReplacementGeneration;
+    /**
+     * Write a complete shard set into a staging directory. Every shard is
+     * serialized before the first write, so a capacity failure cannot leave a
+     * partial stage behind.
+     */
+    private stageShardSet;
+    /**
+     * Atomically remove the published generation (offline-sync: the remote
+     * deleted the whole index) by publishing an EMPTY staged directory
+     * through the shared swap: the rename is atomic, so the former generation
+     * moves whole into the fixed backup and back — a failure before the
+     * commit rolls the former generation back intact, and a post-commit
+     * backup-cleanup failure is non-fatal (the empty published directory
+     * stays the authoritative one-way layout marker). The fixed backup is
+     * symlink-checked first (round 5).
+     */
+    removePublishedGeneration(fence?: EmbeddingGenerationFence): Promise<void>;
+    /**
+     * Atomically publish a fully staged generation directory as THE published
+     * generation. The former published directory is demoted to the FIXED
+     * transaction backup and the staging dir is renamed in with a single
+     * rename; if the publish rename fails the former generation is rolled
+     * back, and if the process dies in the rename gap `detectLayout()` /
+     * `recoverIfInterrupted()` perform the same rollback on next use.
+     * Shared by the mutation-side migration/replacement and the offline-sync
+     * generation transaction (issue #3148, round 4) so there is exactly one
+     * swap state machine. Staging-dir cleanup stays with the caller.
+     */
+    publishSwappedGeneration(stagingDir: string, fence?: EmbeddingGenerationFence): Promise<void>;
+    /** Remove staging dirs orphaned by crashed migrations. A foreign dir younger than the grace window may belong to a live writer mid-migration, so only older dirs are removed (issue #3148 review, round 3). */
+    private static readonly STAGING_CLEANUP_GRACE_MS;
+    private cleanForeignStagingDirs;
+    /**
+     * Temp-file + rename write. The temp name carries `.tmp-` so offline sync
+     * ignores in-flight files under `state/`. With a wired io, the write goes
+     * through the canonical secure-store contract instead, optionally binding
+     * the ciphertext to the FINAL published path (staged shards).
+     */
+    private writeAtomicFile;
+    /**
+     * Record the outcome of one index mutation durably. This is diagnostics,
+     * NOT recovery: write failures are recorded and then re-thrown by the
+     * caller so the extraction/consolidation task fails explicitly instead of
+     * declaring success over an index that could not be persisted (issue
+     * #3146).
+     */
+    recordIndexWriteOutcome(err: unknown, memoryId?: string): Promise<void>;
+    /**
+     * Merge diagnostic state into `state/embedding-fallback-status.json`.
+     * Best-effort: a diagnostics failure never masks the real outcome.
+     */
+    private recordIndexStatus;
+}
+//# sourceMappingURL=embedding-index-storage.d.ts.map

package/dist/embedding-index-storage.d.ts.map

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

package/dist/embedding-index-storage.js

@@ -0,0 +1,28 @@
+import {
+  EmbeddingIndexCapacityError,
+  EmbeddingIndexFileStore,
+  EmbeddingIndexStorageError,
+  isInvalidStringLengthError,
+  parseEmbeddingIndexDocument,
+  resolveIndexFileCharLimit,
+  serializeEmbeddingShard,
+  shardEntriesForIndex,
+  shardIndexOf,
+  validateShardMembership
+} from "./chunk-UCPGOUDZ.js";
+import "./chunk-P2QRMMVQ.js";
+import "./chunk-3WCASNQZ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  EmbeddingIndexCapacityError,
+  EmbeddingIndexFileStore,
+  EmbeddingIndexStorageError,
+  isInvalidStringLengthError,
+  parseEmbeddingIndexDocument,
+  resolveIndexFileCharLimit,
+  serializeEmbeddingShard,
+  shardEntriesForIndex,
+  shardIndexOf,
+  validateShardMembership
+};
+//# sourceMappingURL=embedding-index-storage.js.map

package/dist/entity-retrieval.js

@@ -3,26 +3,26 @@ import {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-SPSRGEDQ.js";
+} from "./chunk-MXCAJKMA.js";
+import "./chunk-MKYRCCSN.js";
 import "./chunk-GKUA4MGB.js";
 import "./chunk-5AUY5Z5E.js";
 import "./chunk-SVH57F5Z.js";
-import "./chunk-MKYRCCSN.js";
 import "./chunk-2DQ2XREU.js";
 import "./chunk-NVKO5YKP.js";
-import "./chunk-FRCESVV6.js";
+import "./chunk-STEOT4DI.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-46WM6JX2.js";
-import "./chunk-D5F7TKMH.js";
-import "./chunk-RJLV4BKR.js";
-import "./chunk-SLEAJ67D.js";
-import "./chunk-S7LWX2PQ.js";
+import "./chunk-V4JZCTMK.js";
+import "./chunk-LV5H6FTN.js";
+import "./chunk-4OQET73E.js";
 import "./chunk-T2YX56QI.js";
 import "./chunk-CYEPCZN5.js";
 import "./chunk-T3FMRLWQ.js";
 import "./chunk-7VO6E5UD.js";
-import "./chunk-4O6WRBGE.js";
 import "./chunk-Z4TXB4K7.js";
+import "./chunk-S7LWX2PQ.js";
+import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
@@ -31,15 +31,15 @@ import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
-import "./chunk-LDXUBPMO.js";
 import "./chunk-DM2T26WE.js";
+import "./chunk-LDXUBPMO.js";
 import "./chunk-FF6N7BXC.js";
 import "./chunk-2DT7PIDZ.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-DUJYRVUD.js";
+import "./chunk-6O2VUWV6.js";
+import "./chunk-ZIKENA2C.js";
 import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
-import "./chunk-ZIKENA2C.js";
 import "./chunk-345MEMRU.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-5GINB5LC.js";
@@ -70,20 +70,20 @@ import "./chunk-PJKTFXE2.js";
 import "./chunk-W5BIQOAJ.js";
 import "./chunk-Z7L72ZHL.js";
 import "./chunk-4O4TKIXQ.js";
-import "./chunk-GDYU6VF4.js";
+import "./chunk-5AYUHSAU.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-VYCOJKSX.js";
+import "./chunk-PO7NXNGC.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
 import "./chunk-L272A5QW.js";
-import "./chunk-JE334SIA.js";
+import "./chunk-22DYJLFN.js";
 import "./chunk-ZA53AZND.js";
 import "./chunk-7RJUVTVF.js";
 import "./chunk-AL3UYZ5N.js";
 import "./chunk-RL6NEVXT.js";
 import "./chunk-C7HJ3NEI.js";
-import "./chunk-NB3LRY4T.js";
+import "./chunk-N4PYB235.js";
 import "./chunk-AW4QUFQF.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-FFAZ2XFU.js";
@@ -101,7 +101,7 @@ import "./chunk-6KH5NLQS.js";
 import "./chunk-P2QRMMVQ.js";
 import "./chunk-BTTPKDIL.js";
 import "./chunk-FF4KLI5W.js";
-import "./chunk-JN72EPOE.js";
+import "./chunk-MAAL6OZV.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-VS2IYZRU.js";
 import "./chunk-KNA3BXXL.js";