mnemocyte 0.2.0 → 0.4.0

package/dist/{types-DXEGcc47.d.mts → types-DH0inEay.d.mts}

@@ -29,6 +29,17 @@ type ImportanceLevel = "low" | "normal" | "high" | "critical";
  * @defaultValue `"markdown"`
  */
 type ContextFormat = "markdown" | "plain" | "xml";
+/**
+ * A value that can be persisted losslessly as JSON.
+ *
+ * Metadata rejects unsupported runtime values such as `undefined`, functions,
+ * symbols, bigints, non-finite numbers, class instances, and cyclic objects.
+ */
+type JsonValue = string | number | boolean | null | JsonObject | JsonValue[];
+/** A JSON-compatible object used for persisted memory and audit metadata. */
+interface JsonObject {
+  [key: string]: JsonValue;
+}
 /**
  * Identifies which backend a {@link MnemocyteClient} is using.
  *
@@ -100,17 +111,25 @@ interface ProviderResilienceConfig {
   /**
    * Maximum time, in milliseconds, that a single provider attempt may
    * run before a {@link MnemocyteError} with code `"TIMEOUT"` is thrown.
-   * Defaults to `0` which disables the timeout.
+   * Must be a non-negative finite number. Defaults to `0` which disables the
+   * timeout.
    */
   timeoutMs?: number;
   /**
-   * Maximum number of retry attempts after the initial call. `0`
-   * disables retries (default).
+   * Maximum number of retry attempts after the initial call. Must be a
+   * non-negative integer. `0` disables retries (default).
    */
   retries?: number;
-  /** Base backoff delay (ms) used before the first retry. Defaults to `100`. */
+  /**
+   * Base backoff delay (ms) used before the first retry. Must be a
+   * non-negative finite number. Defaults to `100`.
+   */
   baseDelayMs?: number;
-  /** Maximum backoff delay (ms) used between retries. Defaults to `2000`. */
+  /**
+   * Maximum backoff delay (ms) used between retries. Must be a non-negative
+   * finite number. Values below `baseDelayMs` are normalized up to the base
+   * delay. Defaults to `2000`.
+   */
   maxDelayMs?: number;
   /**
    * Optional predicate deciding whether `error` should trigger a retry.
@@ -129,7 +148,9 @@ interface MnemocyteConfig {
   /**
    * Postgres connection string. When set, the client uses the Postgres
    * backend (requires the `pgvector` extension and a rendered migration
-   * with `mnemocyte_meta.embedding_dimensions` matching the embedder).
+   * with `mnemocyte_meta.embedding_dimensions` matching the embedder and
+   * `embedding_model` metadata available). Must use the `postgres:` or
+   * `postgresql:` protocol.
    * When omitted, an in-memory backend is used.
    */
   databaseUrl?: string;
@@ -180,8 +201,9 @@ interface AuditConfig {
  * (e.g. OpenAI, Cohere, a local model) in a small interface.
  *
  * Mnemocyte records {@link Embedder.model} and {@link Embedder.dimensions}
- * on every stored memory and uses them to detect incompatible vectors
- * (e.g. when the model is swapped).
+ * on every stored memory. The Postgres backend also records both values as
+ * installation metadata and rejects embedding-dependent operations when the
+ * configured embedder is incompatible.
  */
 interface Embedder {
   /** Stable identifier for the underlying model (e.g. `"text-embedding-3-small"`). */
@@ -190,13 +212,15 @@ interface Embedder {
   readonly dimensions: number;
   /**
    * Embed one or more texts. Implementations MUST return one vector per
-   * input, in the same order, each of length {@link Embedder.dimensions}.
+   * input, in the same order, each of length {@link Embedder.dimensions} and
+   * containing only finite numeric values.
    *
    * The optional `options.signal` is forwarded by Mnemocyte when the
-   * caller passes a `signal` on a {@link RememberInput} / {@link RecallInput}
-   * / {@link BuildContextInput}, or when Mnemocyte's own provider timeout
-   * fires. Implementations that integrate with `fetch` should forward
-   * the signal to it so requests can be cancelled promptly.
+   * caller passes a `signal` on a {@link RememberInput} /
+   * {@link RememberManyInput} / {@link RecallInput} /
+   * {@link BuildContextInput}, or when Mnemocyte's own provider timeout fires.
+   * Implementations that integrate with `fetch` should forward the signal to
+   * it so requests can be cancelled promptly.
    */
   embed(texts: readonly string[], options?: {
     signal?: AbortSignal;
@@ -223,8 +247,8 @@ interface Memory {
   tags: string[];
   /** Optional human-readable source attribution (e.g. `"chat:2024-04-12"`). */
   source: string | null;
-  /** Arbitrary user-provided metadata persisted alongside the memory. */
-  metadata: Record<string, unknown>;
+  /** JSON-compatible metadata persisted by value alongside the memory. */
+  metadata: JsonObject;
   /** Confidence in `[0, 1]`. Used in retrieval ranking. */
   confidence: number;
   /** {@link Embedder.model} value at write time. */
@@ -272,21 +296,22 @@ interface RetrievalScores {
 }
 /**
  * Optional overrides for the per-component retrieval weights. Missing keys
- * fall back to library defaults. Weights need not sum to 1; the final
- * score is computed as a weighted sum of {@link RetrievalScores}.
+ * fall back to library defaults. Weights must be finite and non-negative, and
+ * their effective total must be greater than zero. They need not sum to 1;
+ * the final score is computed as a weighted sum of {@link RetrievalScores}.
  */
 interface RetrievalScoreWeights {
-  /** Weight applied to {@link RetrievalScores.vector}. */
+  /** Non-negative finite weight applied to {@link RetrievalScores.vector}. */
   vector?: number;
-  /** Weight applied to {@link RetrievalScores.lexical}. */
+  /** Non-negative finite weight applied to {@link RetrievalScores.lexical}. */
   lexical?: number;
-  /** Weight applied to {@link RetrievalScores.recency}. */
+  /** Non-negative finite weight applied to {@link RetrievalScores.recency}. */
   recency?: number;
-  /** Weight applied to {@link RetrievalScores.confidence}. */
+  /** Non-negative finite weight applied to {@link RetrievalScores.confidence}. */
   confidence?: number;
-  /** Weight applied to {@link RetrievalScores.access}. */
+  /** Non-negative finite weight applied to {@link RetrievalScores.access}. */
   access?: number;
-  /** Weight applied to {@link RetrievalScores.importance}. */
+  /** Non-negative finite weight applied to {@link RetrievalScores.importance}. */
   importance?: number;
 }
 /**
@@ -296,13 +321,14 @@ interface RetrievalScoreWeights {
 interface RetrievalConfig {
   /** Per-component score weights. See {@link RetrievalScoreWeights}. */
   weights?: RetrievalScoreWeights;
-  /** Half-life (days) for the time-decay recency component. */
+  /** Positive finite half-life (days) for the time-decay recency component. */
   recencyHalfLifeDays?: number;
-  /** Access count at which the access score is considered saturated. */
+  /** Positive finite access count at which the access score is saturated. */
   accessSaturation?: number;
   /**
    * Multiplier applied to {@link RecallInput.limit} to determine how many
    * candidates are fetched from the underlying store before re-ranking.
+   * Must be an integer greater than or equal to 1.
    */
   candidateMultiplier?: number;
 }
@@ -363,8 +389,8 @@ interface RememberInput {
   tags?: string[];
   /** Optional human-readable source attribution. */
   source?: string;
-  /** Arbitrary metadata persisted alongside the memory. */
-  metadata?: Record<string, unknown>;
+  /** JSON-compatible metadata persisted by value alongside the memory. */
+  metadata?: JsonObject;
   /** Confidence in `[0, 1]`. @defaultValue `1` */
   confidence?: number;
   /** Optional expiry; expired memories are filtered out by default. */
@@ -376,6 +402,18 @@ interface RememberInput {
    */
   signal?: AbortSignal;
 }
+/**
+ * Batch-level input for {@link MnemocyteClient.rememberMany}.
+ *
+ * Cancellation belongs to the whole batch. Individual items accept every
+ * {@link RememberInput} field except `signal`.
+ */
+interface RememberManyInput {
+  /** Memories to persist in order. */
+  inputs: readonly Omit<RememberInput, "signal">[];
+  /** Optional cancellation signal for the entire batch. */
+  signal?: AbortSignal;
+}
 /**
  * Input for {@link MnemocyteClient.recall}.
  */
@@ -412,8 +450,8 @@ interface RecallInput {
 /**
  * Pluggable token counter used by {@link MnemocyteClient.buildContext} to
  * enforce {@link BuildContextInput.maxTokens}. Plug in your model's real
- * tokenizer (e.g. `tiktoken`) for accurate budgeting; a simple word-based
- * heuristic is used when omitted.
+ * tokenizer (e.g. `tiktoken`) for accurate budgeting; a simple character-count
+ * heuristic (approximately one token per four characters) is used when omitted.
  */
 interface TokenCounter {
   /** Return the number of tokens in `text`. */
@@ -430,7 +468,7 @@ interface BuildContextInput {
   query: string;
   /** Output format. @defaultValue `"markdown"` */
   format?: ContextFormat;
-  /** Optional token budget; memories are dropped from the tail until the budget fits. */
+  /** Optional positive-integer token budget; omission uses the default path. */
   maxTokens?: number;
   /** Maximum number of memories to consider. */
   limit?: number;
@@ -457,7 +495,10 @@ interface BuildContextInput {
  * Input for {@link MnemocyteClient.prune}. All fields are optional, but
  * at least one selector must be set; calling `prune({})` is rejected with
  * a `"VALIDATION"` {@link MnemocyteError} so memories cannot be deleted
- * accidentally. Specified filters are combined with AND semantics.
+ * accidentally. Runtime values are validated before storage access; malformed
+ * dates, enums, arrays, booleans, and signals are rejected. `false` selector
+ * flags and empty selector arrays do not count as effective selectors after
+ * normalization. Specified filters are combined with AND semantics.
  */
 interface PruneInput {
   /** Restrict pruning to a single entity. */
@@ -491,7 +532,11 @@ interface PruneInput {
    * @defaultValue `false`
    */
   dryRun?: boolean;
-  /** Optional cancellation signal. */
+  /**
+   * Optional cancellation signal. A pre-aborted signal prevents storage work.
+   * In-flight Postgres pruning requests server-query cancellation, but a
+   * deletion that has already committed cannot be undone.
+   */
   signal?: AbortSignal;
 }
 /**
@@ -539,7 +584,10 @@ interface FindDuplicatesInput {
   includeSuperseded?: boolean;
   /** Include expired memories in the scan. @defaultValue `false` */
   includeExpired?: boolean;
-  /** Optional cancellation signal. */
+  /**
+   * Optional cancellation signal. In-memory scans check it cooperatively;
+   * Postgres requests cancellation of the active duplicate-search query.
+   */
   signal?: AbortSignal;
 }
 /**
@@ -574,11 +622,22 @@ interface AuditEvent {
    * `"entity.cleared"`.
    */
   description: string;
-  /** Free-form structured details about the change. */
-  metadata: Record<string, unknown>;
+  /** JSON-compatible structured details persisted by value with the change. */
+  metadata: JsonObject;
   /** When the change was recorded. */
   timestamp: Date;
 }
+/**
+ * Stable composite position for deterministic audit-log pagination.
+ *
+ * @experimental Part of Phase 6 (consolidation tooling). Shape may change.
+ */
+interface AuditLogCursor {
+  /** Event timestamp at the page boundary. */
+  timestamp: Date;
+  /** Event ID used to break timestamp ties. */
+  id: string;
+}
 /**
  * Input for {@link MnemocyteClient.listAuditLog}.
  *
@@ -592,11 +651,32 @@ interface ListAuditLogInput {
    * @defaultValue `50`
    */
   limit?: number;
-  /** Only return entries strictly before this timestamp. */
+  /**
+   * Only return entries strictly before this timestamp. This is a filter, not
+   * a complete pagination cursor: events sharing the timestamp are excluded.
+   */
   before?: Date;
-  /** Only return entries strictly after this timestamp. */
+  /**
+   * Only return entries strictly after this timestamp. This is a filter, not
+   * a complete pagination cursor: events sharing the timestamp are excluded.
+   */
   after?: Date;
-  /** Optional cancellation signal. */
+  /**
+   * Return entries strictly older than this stable `(timestamp, id)` position.
+   *
+   * @experimental Prefer this over `before` for complete pagination.
+   */
+  beforeCursor?: AuditLogCursor;
+  /**
+   * Return entries strictly newer than this stable `(timestamp, id)` position.
+   *
+   * @experimental Prefer this over `after` for complete pagination.
+   */
+  afterCursor?: AuditLogCursor;
+  /**
+   * Optional cancellation signal. In-memory scans check it cooperatively;
+   * Postgres requests cancellation of the active audit-log query.
+   */
   signal?: AbortSignal;
 }
 /**
@@ -614,9 +694,10 @@ interface ConsolidateInput {
   /** Memory that should win the merge. Must not itself be superseded. */
   survivorId: string;
   /**
-   * Memories to mark as superseded by the survivor. Already-superseded
-   * entries in this list are skipped silently for idempotency. Must
-   * not contain {@link ConsolidateInput.survivorId}.
+   * Memories to mark as superseded by the survivor. Entries already
+   * superseded by this same survivor are skipped for idempotency. If any
+   * entry points to a different survivor, the entire call rejects with
+   * `"CONFLICT"`. Must not contain {@link ConsolidateInput.survivorId}.
    */
   supersededIds: readonly string[];
   /**
@@ -625,7 +706,13 @@ interface ConsolidateInput {
    * @defaultValue `true`
    */
   mergeTags?: boolean;
-  /** Optional cancellation signal. */
+  /**
+   * Optional cancellation signal. Postgres checks it between transaction
+   * steps and immediately before the transaction callback returns. A
+   * statement already in flight may finish before the next check rolls the
+   * transaction back. An abort after the final check, including while commit
+   * is in flight, may still leave the consolidation committed.
+   */
   signal?: AbortSignal;
 }
 /**
@@ -638,7 +725,7 @@ interface ConsolidateResult {
   survivorId: string;
   /**
    * Number of memories actually marked as superseded. Excludes entries
-   * that were already superseded (idempotent skip).
+   * that already pointed to this survivor (idempotent skip).
    */
   supersededCount: number;
   /** The IDs that were newly superseded during this call. */
@@ -692,7 +779,14 @@ interface MnemocyteClient {
   remember(input: RememberInput): Promise<Memory>;
   /**
    * Persist multiple memories in one round-trip. Returns the stored records
-   * in the same order as `inputs`.
+   * in the same order as `input.inputs`; `input.signal` cancels the batch.
+   */
+  rememberMany(input: RememberManyInput): Promise<Memory[]>;
+  /**
+   * Positional compatibility overload retained during pre-v1. The first
+   * item's `signal`, when present, acts as the batch signal.
+   *
+   * @deprecated Use `rememberMany({ inputs, signal })`.
    */
   rememberMany(inputs: readonly RememberInput[]): Promise<Memory[]>;
   /**
@@ -710,12 +804,20 @@ interface MnemocyteClient {
    *
    * @throws {MnemocyteError} `"NOT_FOUND"` if the memory does not exist
    * or does not belong to `entityId`.
+   * @throws {MnemocyteError} `"CONFLICT"` if another memory still
+   * references this memory as its consolidation survivor.
    */
   forget(input: {
     entityId: string;
     memoryId: string;
   }): Promise<void>;
-  /** Delete every memory belonging to `entityId`. */
+  /**
+   * Delete every memory belonging to `entityId`.
+   *
+   * @throws {MnemocyteError} `"CONFLICT"` if any selected memory is still
+   * referenced as a consolidation survivor, including by another selected
+   * memory.
+   */
   forgetAll(input: {
     entityId: string;
   }): Promise<void>;
@@ -726,6 +828,10 @@ interface MnemocyteClient {
    * `"VALIDATION"` {@link MnemocyteError} to avoid accidental full
    * deletion. Pass `dryRun: true` to count without deleting.
    *
+   * @throws {MnemocyteError} `"CONFLICT"` when a non-dry-run prune selects
+   * a memory that still has consolidation dependents. The prune deletes
+   * nothing in that case.
+   *
    * @example Evict expired or stale memories for an entity
    * ```ts
    * await client.prune({
@@ -798,7 +904,10 @@ interface MnemocyteClient {
   }): Promise<EntityStats | GlobalStats>;
   /**
    * Release any underlying resources (e.g. the Postgres connection pool).
-   * Safe to call multiple times. The client must not be used afterward.
+   * New operations are rejected once closing starts. The returned promise
+   * waits for operations that already started, then closes the store. Safe to
+   * call multiple times; concurrent calls share the same close operation.
+   * If closing the store fails, the client reopens so callers may retry.
    */
   close(): Promise<void>;
 }
@@ -812,11 +921,13 @@ interface ExperimentalMnemocyteClient {
   /**
    * Consolidate likely-duplicate memories into a single survivor by
    * marking the others as superseded. Optionally unions their tags
-   * onto the survivor. Idempotent for memories that are already
-   * superseded.
+   * onto the survivor. Idempotent when every already-superseded loser
+   * points to the requested survivor.
    *
    * Emits one `"memory.superseded"` audit event per newly superseded
    * memory when {@link MnemocyteConfig.audit}.`enabled` is `true`.
+   * A survivor cannot later be deleted while any superseded memory still
+   * references it; deletion attempts fail with `"CONFLICT"`.
    *
    * @experimental Part of Phase 6 (consolidation tooling). API may change.
    *
@@ -824,8 +935,11 @@ interface ExperimentalMnemocyteClient {
    * a `survivorId` that also appears in `supersededIds`, or a survivor
    * that is itself already superseded.
    * @throws {MnemocyteError} `"NOT_FOUND"` if the survivor or any
-   * non-already-superseded memory in `supersededIds` does not belong
-   * to `entityId`.
+   * memory in `supersededIds` does not belong to `entityId`.
+   * @throws {MnemocyteError} `"CONFLICT"` if any memory in
+   * `supersededIds` already points to a different survivor. The whole
+   * call is rejected before any loser, survivor tags, or audit events
+   * are changed.
    *
    * @example
    * ```ts
@@ -842,5 +956,5 @@ interface ExperimentalMnemocyteClient {
   consolidate(input: ConsolidateInput): Promise<ConsolidateResult>;
 }
 //#endregion
-export { RetrievalConfig as A, MnemocyteOperation as C, PruneResult as D, PruneInput as E, RetrievalScoreWeights as M, RetrievalScores as N, RecallInput as O, TokenCounter as P, MnemocyteObservationPhase as S, ProviderResilienceConfig as T, MemoryWithScore as _, ConsolidateResult as a, MnemocyteConfig as b, Embedder as c, FindDuplicatesInput as d, GlobalStats as f, MemoryType as g, Memory as h, ConsolidateInput as i, RetrievalExplanation as j, RememberInput as k, EntityStats as l, ListAuditLogInput as m, AuditEvent as n, ContextFormat as o, ImportanceLevel as p, BuildContextInput as r, DuplicatePair as s, AuditConfig as t, ExperimentalMnemocyteClient as u, MnemocyteBackend as v, ObservabilityConfig as w, MnemocyteObservation as x, MnemocyteClient as y };
-//# sourceMappingURL=types-DXEGcc47.d.mts.map
+export { PruneResult as A, MnemocyteConfig as C, ObservabilityConfig as D, MnemocyteOperation as E, RetrievalExplanation as F, RetrievalScoreWeights as I, RetrievalScores as L, RememberInput as M, RememberManyInput as N, ProviderResilienceConfig as O, RetrievalConfig as P, TokenCounter as R, MnemocyteClient as S, MnemocyteObservationPhase as T, ListAuditLogInput as _, ConsolidateInput as a, MemoryWithScore as b, DuplicatePair as c, ExperimentalMnemocyteClient as d, FindDuplicatesInput as f, JsonValue as g, JsonObject as h, BuildContextInput as i, RecallInput as j, PruneInput as k, Embedder as l, ImportanceLevel as m, AuditEvent as n, ConsolidateResult as o, GlobalStats as p, AuditLogCursor as r, ContextFormat as s, AuditConfig as t, EntityStats as u, Memory as v, MnemocyteObservation as w, MnemocyteBackend as x, MemoryType as y };
+//# sourceMappingURL=types-DH0inEay.d.mts.map

package/dist/types-DH0inEay.d.mts.map

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

package/migrations/0000_initial.sql.template

@@ -8,7 +8,8 @@ CREATE TABLE "mnemocyte_events" (
 --> statement-breakpoint
 CREATE TABLE "mnemocyte_meta" (
 	"key" text PRIMARY KEY NOT NULL,
-	"embedding_dimensions" integer NOT NULL
+	"embedding_dimensions" integer NOT NULL,
+	"embedding_model" text
 );
 --> statement-breakpoint
 INSERT INTO "mnemocyte_meta" ("key", "embedding_dimensions") VALUES ('installation', {{EMBEDDING_DIMENSIONS}});

package/migrations/0002_add_embedding_model.sql

@@ -0,0 +1,15 @@
+ALTER TABLE "mnemocyte_meta" ADD COLUMN "embedding_model" text;
+--> statement-breakpoint
+UPDATE "mnemocyte_meta"
+SET "embedding_model" = (
+	SELECT min("embedding_model")
+	FROM "mnemocyte_memories"
+	HAVING count(DISTINCT "embedding_model") = 1
+)
+WHERE
+	"key" = 'installation'
+	AND "embedding_model" IS NULL
+	AND (
+		SELECT count(DISTINCT "embedding_model")
+		FROM "mnemocyte_memories"
+	) = 1;