@ponraaj/dimple-sdk 0.0.0-alpha.1 → 0.0.0-alpha.11

package/dist/internal/store/graph/concepts.d.ts

@@ -39,8 +39,8 @@
  * the active model stays 384-dim.
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 import { StoreError } from "../error.ts";
@@ -78,10 +78,13 @@ export declare const farthestPointSeeds: (vectors: readonly Float32Array[], k: n
  * vectors themselves — the initial assignment is nearest-seed, not
  * seed-region).
  */
-export declare const kGroupLloyd: (vectors: readonly Float32Array[], seeds: readonly number[], passes: number) => {
-    groups: Uint32Array;
-    centroids: readonly Float32Array[];
-};
+/** Outcome of the k-means refinement — per-vector group assignment plus
+ * the final centroids. */
+export interface KGroupResult {
+    readonly groups: Uint32Array;
+    readonly centroids: readonly Float32Array[];
+}
+export declare const kGroupLloyd: (vectors: readonly Float32Array[], seeds: readonly number[], passes: number) => KGroupResult;
 /** Result of {@link clusterMembers}: per-vector group assignment + centroids. */
 export interface ClusterResult {
     /** `groups[i]` = the group of `vectors[i]` (caller index space). */
@@ -146,8 +149,14 @@ export interface ConceptClusterHandlerDeps {
     /** Backend captured at registration (see {@link topicSplitHandler}). */
     readonly backend?: DbBackendInterface;
 }
+/** The decoded `concept.cluster` payload — mirrors the queue definition's
+ * schema (`{ modelKey, topicKey? }`); the executor decodes before calling. */
+export interface ConceptClusterPayload {
+    readonly modelKey: string;
+    readonly topicKey?: string;
+}
 /** The `concept.cluster` handler shape (see jobs.ts). */
-export type ConceptClusterHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+export type ConceptClusterHandler = (payload: ConceptClusterPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `concept.cluster` job handler. Two modes, selected by the
  * payload:

package/dist/internal/store/graph/dream.d.ts

@@ -58,8 +58,8 @@
  * Effect Clock (observability only).
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 /** One memory pair judged by the classifier (older first — the direction
@@ -145,8 +145,14 @@ export interface DreamHandlerDeps {
     /** Backend captured at registration (see {@link topicSplitHandler}). */
     readonly backend?: DbBackendInterface;
 }
+/** The decoded `memory.dream` payload — mirrors the queue definition's
+ * schema (`{ modelKey, runId? }`); the executor decodes before calling. */
+export interface DreamPayload {
+    readonly modelKey: string;
+    readonly runId?: string;
+}
 /** The `memory.dream` handler shape (see jobs.ts). */
-export type DreamHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+export type DreamHandler = (payload: DreamPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `memory.dream` job handler. Payload: `{ modelKey }`.
  * Runs the four phases (orient → gather → consolidate → prune) for that

package/dist/internal/store/graph/errors.d.ts

@@ -4,7 +4,7 @@ declare const EdgeNotFound_base: Schema.Class<EdgeNotFound, Schema.TaggedStruct<
 }>, import("effect/Cause").YieldableError>;
 /**
  * Graph error types (mirror of `topics/errors.ts`). Each distinct failure
- * mode gets its own `Schema.TaggedErrorClass` so callers can `catchTag`
+ * mode gets its own `Schema.TaggedError` so callers can `catchTag`
  * precisely; they ride the public `Store` error channel alongside
  * `StoreError`.
  */

package/dist/internal/store/graph/repair.d.ts

@@ -38,8 +38,8 @@
  * simply finds nothing to fix).
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 /** How many rows of each class one repair pass fixed. */
@@ -64,7 +64,13 @@ export interface GraphRepairHandlerDeps {
     readonly expiredGraceMs?: number;
 }
 /** The `graph.repair` handler shape (see jobs.ts). */
-export type GraphRepairHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+/** The decoded `graph.repair` payload — mirrors the queue definition's
+ * schema (`{ modelKey, runId? }`); the executor decodes before calling. */
+export interface RepairPayload {
+    readonly modelKey: string;
+    readonly runId?: string;
+}
+export type GraphRepairHandler = (payload: RepairPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `graph.repair` job handler. Payload: `{ modelKey }`.
  * Validates the model key, then runs the repair transaction: orphaned

package/dist/internal/store/graph/traversal.d.ts

@@ -36,4 +36,4 @@ export interface GraphNeighborRow extends Schema.Schema.Type<typeof GraphNeighbo
  * does not match — the backend owns the query, so a mismatch is a real bug,
  * not a runtime condition.
  */
-export declare const fromNeighborRows: (rows: readonly Record<string, unknown>[]) => readonly GraphNeighborRow[];
+export declare const fromNeighborRows: (rows: readonly unknown[]) => readonly GraphNeighborRow[];

package/dist/internal/store/index.d.ts

@@ -5,6 +5,7 @@ export { topics };
 export { auditWriteHandler, type AuditWriteHandler } from "./audit.ts";
 export { TopicConfig } from "./schema/topics.ts";
 export type { AddEdgeInput, ExplainResult } from "./service.ts";
+export type { ArtifactEdge, EdgeKind, EdgeSource } from "./schema/graph.ts";
 export type { TopicHealth } from "./topics/observability.ts";
 export type { TopicConfig as TopicConfigType } from "./schema/topics.ts";
 export type { RetrievalAuditRow } from "./models.ts";
@@ -27,12 +28,12 @@ export { Service as DbBackend, type DrizzleDB } from "./db-backend.ts";
 export { Service as Store } from "./service.ts";
 export * from "./models.ts";
 export { layer as dbBackendLayer, layerConfig as dbBackendLayerConfig, layerFromConfig as dbBackendLayerFromConfig, } from "./libsql-backend.ts";
-export { layer as storeLayer, layerConfig as storeLayerConfig, layerFromConfig as storeLayerFromConfig, } from "./store.ts";
+export { layer as storeLayer, layerConfig as storeLayerConfig, layerFromConfig as storeLayerFromConfig, configured as storeConfigured, node as storeNode, } from "./store.ts";
 export declare const layer: (url: string, options?: {
     migrationFolder?: string;
-}) => import("effect/Layer").Layer<import("./internal/logger/index.js").Logging | import("./db-backend.ts").Service | import("./service.ts").Service, import("./error.ts").StoreError, import("effect/Scope").Scope>;
+}) => import("effect/Layer").Layer<import("../logger/index.js").Logging | import("./db-backend.ts").Service | import("./service.ts").Service, import("./error.ts").StoreError, never>;
 export declare const layerConfig: (config: Config.Wrap<{
     url: string;
 }>, options?: {
     migrationFolder?: string;
-}) => import("effect/Layer").Layer<import("./internal/logger/index.js").Logging | import("./db-backend.ts").Service | import("./service.ts").Service, Config.ConfigError | import("./error.ts").StoreError, import("effect/Scope").Scope>;
+}) => import("effect/Layer").Layer<import("../logger/index.js").Logging | import("./db-backend.ts").Service | import("./service.ts").Service, Config.ConfigError | import("./error.ts").StoreError, never>;

package/dist/internal/store/libsql-backend.d.ts

@@ -1,7 +1,7 @@
 import { Layer, Config, Scope } from "effect";
 import { StoreError } from "./error.ts";
 import { Service } from "./db-backend.ts";
-import { Service as ConfigService } from "./internal/config/index.js";
+import { Service as ConfigService } from "../config/index.js";
 export declare const layer: (url: string, options?: {
     migrationFolder?: string;
     releaseClient?: boolean;

package/dist/internal/store/models.d.ts

@@ -11,7 +11,7 @@ export declare const MemoryUnit: Schema.Struct<{
     readonly contentType: Schema.String;
     readonly state: Schema.Literals<readonly ["active", "superseded", "archived", "forgotten"]>;
     readonly createdAt: Schema.Number;
-    readonly ttlSecs: Schema.Number;
+    readonly ttlSecs: Schema.NullOr<Schema.Number>;
     readonly namespace: Schema.String;
     readonly metadata: Schema.optional<Schema.String>;
     readonly embedding: Schema.optional<Schema.$Array<Schema.Number>>;
@@ -24,7 +24,7 @@ export declare const WriteMemoryInput: Schema.Struct<{
     readonly content: Schema.String;
     readonly contentType: Schema.optional<Schema.String>;
     readonly namespace: Schema.optional<Schema.String>;
-    readonly ttlSecs: Schema.optional<Schema.Number>;
+    readonly ttlSecs: Schema.optional<Schema.NullOr<Schema.Number>>;
     readonly metadata: Schema.optional<Schema.String>;
     /** Typed overlay merged INTO the raw metadata blob on write (unknown blob
      * keys preserved. Takes precedence over `metadata`. */
@@ -38,6 +38,7 @@ export declare const WriteMemoryInput: Schema.Struct<{
         readonly confidence: Schema.Number;
         readonly affordances: Schema.$Array<Schema.String>;
         readonly language: Schema.optional<Schema.String>;
+        readonly codeVersion: Schema.optional<Schema.String>;
         readonly pinned: Schema.optional<Schema.Boolean>;
     }>>;
 }>;
@@ -51,7 +52,7 @@ export declare const ScoredMemory: Schema.Struct<{
         readonly contentType: Schema.String;
         readonly state: Schema.Literals<readonly ["active", "superseded", "archived", "forgotten"]>;
         readonly createdAt: Schema.Number;
-        readonly ttlSecs: Schema.Number;
+        readonly ttlSecs: Schema.NullOr<Schema.Number>;
         readonly namespace: Schema.String;
         readonly metadata: Schema.optional<Schema.String>;
         readonly embedding: Schema.optional<Schema.$Array<Schema.Number>>;

package/dist/internal/store/schema/graph.d.ts

@@ -74,14 +74,14 @@ export declare const artifactEdges: import("drizzle-orm/sqlite-core").SQLiteTabl
             name: string;
             tableName: "artifact_edges";
             dataType: "string enum";
-            data: "memory_contradicts" | "memory_supersedes" | "memory_supports";
+            data: "code_calls" | "memory_contradicts" | "memory_supersedes" | "memory_supports";
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts"];
+            enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts", "code_calls"];
             baseColumn: never;
             identity: undefined;
             generated: undefined;
@@ -218,7 +218,7 @@ export declare const artifactEdges: import("drizzle-orm/sqlite-core").SQLiteTabl
     dialect: 'sqlite';
 }>;
 /** The memory↔memory edge kinds `artifact_edges` can hold (the only kinds in the lean table). */
-export type EdgeKind = "memory_supports" | "memory_supersedes" | "memory_contradicts";
+export type EdgeKind = "memory_supports" | "memory_supersedes" | "memory_contradicts" | "code_calls";
 /** Writers of edges (provenance on every row). */
 export type EdgeSource = "rule" | "llm" | "agent";
 export declare const ArtifactEdgeInsert: import("drizzle-orm/effect-schema").BuildSchema<"insert", {
@@ -274,14 +274,14 @@ export declare const ArtifactEdgeInsert: import("drizzle-orm/effect-schema").Bui
         name: string;
         tableName: "artifact_edges";
         dataType: "string enum";
-        data: "memory_contradicts" | "memory_supersedes" | "memory_supports";
+        data: "code_calls" | "memory_contradicts" | "memory_supersedes" | "memory_supports";
         driverParam: string;
         notNull: true;
         hasDefault: false;
         isPrimaryKey: false;
         isAutoincrement: false;
         hasRuntimeDefault: false;
-        enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts"];
+        enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts", "code_calls"];
         baseColumn: never;
         identity: undefined;
         generated: undefined;
@@ -468,14 +468,14 @@ export declare const ArtifactEdgeSelect: import("drizzle-orm/effect-schema").Bui
         name: string;
         tableName: "artifact_edges";
         dataType: "string enum";
-        data: "memory_contradicts" | "memory_supersedes" | "memory_supports";
+        data: "code_calls" | "memory_contradicts" | "memory_supersedes" | "memory_supports";
         driverParam: string;
         notNull: true;
         hasDefault: false;
         isPrimaryKey: false;
         isAutoincrement: false;
         hasRuntimeDefault: false;
-        enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts"];
+        enumValues: ["memory_supports", "memory_supersedes", "memory_contradicts", "code_calls"];
         baseColumn: never;
         identity: undefined;
         generated: undefined;

package/dist/internal/store/schema/libsql.d.ts

@@ -104,7 +104,7 @@ export declare const memories: import("drizzle-orm/sqlite-core").SQLiteTableWith
             dataType: "number int53";
             data: number;
             driverParam: number;
-            notNull: true;
+            notNull: false;
             hasDefault: true;
             isPrimaryKey: false;
             isAutoincrement: false;
@@ -847,7 +847,7 @@ export declare const MemoryInsert: import("drizzle-orm/effect-schema").BuildSche
         dataType: "number int53";
         data: number;
         driverParam: number;
-        notNull: true;
+        notNull: false;
         hasDefault: true;
         isPrimaryKey: false;
         isAutoincrement: false;
@@ -1025,7 +1025,7 @@ export declare const MemorySelect: import("drizzle-orm/effect-schema").BuildSche
         dataType: "number int53";
         data: number;
         driverParam: number;
-        notNull: true;
+        notNull: false;
         hasDefault: true;
         isPrimaryKey: false;
         isAutoincrement: false;
@@ -1203,7 +1203,7 @@ export declare const MemoryUpdate: import("drizzle-orm/effect-schema").BuildSche
         dataType: "number int53";
         data: number;
         driverParam: number;
-        notNull: true;
+        notNull: false;
         hasDefault: true;
         isPrimaryKey: false;
         isAutoincrement: false;

package/dist/internal/store/schema/metadata.d.ts

@@ -27,6 +27,9 @@ export declare const MemoryMetadata: Schema.Struct<{
     readonly affordances: Schema.$Array<Schema.String>;
     /** Code-specific: "typescript" | "rust" | ... */
     readonly language: Schema.optional<Schema.String>;
+    /** Code-specific: the repo HEAD at index time (the indexer's
+     * provenance stamp — which commit this unit came from). */
+    readonly codeVersion: Schema.optional<Schema.String>;
     /** Writer-set pin: the memory is deliberately stable — automatic graph
      * lifecycle moves should leave it alone. */
     readonly pinned: Schema.optional<Schema.Boolean>;
@@ -48,4 +51,4 @@ export declare const encodeMetadata: (metadata: MemoryMetadata) => string;
  * does not declare (producer-specific extensions) survives. A malformed
  * existing blob is treated as empty — the merge never throws.
  */
-export declare const mergeMetadataBlob: (existing: string | null | undefined, typed: MemoryMetadata) => string;
+export declare const mergeMetadataBlob: (existing: string | null | undefined, typed: Partial<MemoryMetadata>) => string;

package/dist/internal/store/schema/topics.d.ts

@@ -1,16 +1,4 @@
 import { Schema } from "effect";
-/**
- * Mirrors `Schema.optionalWith(schema, { default })` from newer Effect versions.
- *
- * Effect 4.0.0-beta.99 (the pinned version) does not ship `optionalWith`;
- * `optional` + `withDecodingDefaultType` is semantically identical: the key
- * may be absent or `undefined` on input, the default fills it during
- * decoding, and the decoded type keeps the field required. Curried so the
- * default thunk is contextually typed against the already-fixed schema type.
- */
-export declare const optionalWithDefault: <S extends Schema.Constraint>(schema: S) => (options: {
-    default: () => Schema.Schema.Type<S>;
-}) => Schema.withDecodingDefaultType<Schema.optional<S>>;
 /**
  * The deterministic topic hierarchy. One ACTIVE tree per model;
  * retired trees keep their rows (status `inactive`) so the switch is

package/dist/internal/store/service.d.ts

@@ -1,9 +1,10 @@
 import { Context, Effect } from "effect";
-import type { MemoryUnit, MemoryEvent, WriteMemoryInput, SweepResult, Concept } from "./models.ts";
+import type { MemoryUnit, MemoryEvent, WriteMemoryInput, SweepResult, Concept, ScoredMemory } from "./models.ts";
 import type { StoreError, NotFound, DuplicateActiveKey } from "./error.ts";
+import type { MetadataFilter } from "./db-backend.ts";
 import type { TopicError } from "./topics/errors.ts";
 import type { MaintenanceOutcome, RebalanceOutcome } from "./topics/maintenance.ts";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import type { EmbeddingModelConfig } from "../config/index.js";
 import type { Topic, TopicChangeLog } from "./schema/topics.ts";
 import type { ArtifactEdge, EdgeKind, EdgeSource } from "./schema/graph.ts";
 import type { AugmentedMemory } from "./graph/retrieval-post-pass.ts";
@@ -65,21 +66,84 @@ export interface ExplainResult {
 }
 export interface Interface {
     readonly write: (input: WriteMemoryInput) => Effect.Effect<MemoryUnit, StoreError | DuplicateActiveKey>;
+    /** Bulk write: batch insert in ONE transaction (all-or-nothing; a
+     * duplicate logical key fails the whole batch with DuplicateActiveKey).
+     * The per-write graph candidate scan is NOT part of this — pair with
+     * `updateEmbedding(..., { scanCandidates: false })` for bulk ingest. */
+    readonly writeMany: (inputs: readonly WriteMemoryInput[]) => Effect.Effect<readonly MemoryUnit[], StoreError | DuplicateActiveKey>;
+    /** Upsert for the index path — the identity rule (same logical key ⇒
+     * confirmed `memory_supersedes`) made reachable for ACTIVE keys: demote
+     * the active holder of the key (if any), write the new unit, and link
+     * old → new with a confirmed rule edge, all in ONE transaction. Returns
+     * the new memory plus the superseded id (when a predecessor existed). */
+    readonly writeSuperseding: (input: WriteMemoryInput) => Effect.Effect<{
+        readonly memory: MemoryUnit;
+        readonly supersededId?: string;
+    }, StoreError | DuplicateActiveKey>;
+    /** Index reconciliation — demote every ACTIVE unit under `keyPrefix`
+     * that is (a) INSIDE the walked domain (its file path is under one of
+     * `walkedRoots`, joined against `keyRoot`) and (b) not among `keptKeys`
+     * (this run's unit keys — files AND chunks: a chunk the extractor no
+     * longer emits, e.g. a deleted function inside a surviving file, is
+     * vanished). Demotion is `source_removed` (one transaction). Returns the demoted
+     * rows for the rename-candidate scan. Units outside the walked domain
+     * (subtree runs) and normal (non-index) memories are never touched. */
+    readonly reconcile: (namespace: string, keyPrefix: string, keyRoot: string, walkedRoots: readonly string[], keptKeys: readonly string[]) => Effect.Effect<readonly {
+        readonly id: string;
+        readonly logicalKey: string;
+        readonly embedding: number[] | null;
+    }[], StoreError>;
+    /** Rename/move detection (human-gated): cosine each vanished unit's
+     * stored embedding against this run's new units; ≥ the near-duplicate
+     * band → a PENDING `memory_supersedes` candidate (source rule, never
+     * auto-confirms — a rename is a guess). Returns the new-candidate count. */
+    readonly reconcileRenameCandidates: (vanished: readonly {
+        readonly id: string;
+        readonly embedding: number[] | null;
+    }[], newUnitIds: readonly string[]) => Effect.Effect<number, StoreError>;
     readonly get: (id: string) => Effect.Effect<MemoryUnit, NotFound | StoreError>;
     readonly getByKey: (key: string, namespace: string) => Effect.Effect<MemoryUnit, NotFound | StoreError>;
     readonly recency: (namespace: string, limit: number) => Effect.Effect<ReadonlyArray<AugmentedMemory>, StoreError>;
     readonly searchFts5: (query: string, namespace: string, limit: number, opts?: {
         readonly topicKeys?: ReadonlyArray<string>;
+        /** Content-type filter: one kind or a list (code-vs-message
+         * separation lever at query time). */
+        readonly contentType?: string | ReadonlyArray<string>;
         /** `false` suppresses the per-leg audit row (fused-row callers). */
         readonly audit?: boolean;
+        /** Include the 384-float embedding on results (default false). */
+        readonly includeEmbedding?: boolean;
+        /** `false` skips the per-leg graph augmentation (fused-row callers). */
+        readonly augment?: boolean;
     }) => Effect.Effect<ReadonlyArray<AugmentedMemory>, StoreError>;
     readonly searchVector: (query: ReadonlyArray<number>, namespace: string, limit: number, opts?: {
         readonly topicKeys?: ReadonlyArray<string>;
         /** Restrict to memories annotated with ANY of these concept ids. */
         readonly conceptIds?: ReadonlyArray<string>;
+        /** Content-type filter: one kind or a list (code-vs-message
+         * separation lever at query time). */
+        readonly contentType?: string | ReadonlyArray<string>;
         /** `false` suppresses the per-leg audit row (fused-row callers). */
         readonly audit?: boolean;
+        /** Include the 384-float embedding on results (default false). */
+        readonly includeEmbedding?: boolean;
+        /** `false` skips the per-leg graph augmentation (fused-row callers). */
+        readonly augment?: boolean;
     }) => Effect.Effect<ReadonlyArray<AugmentedMemory>, StoreError>;
+    /** One-pass graph augmentation over an already-ranked result set. The
+     * store exposes it for fused-row callers; the hybrid retriever does not
+     * call it yet, so fused results carry no graph fields. A wired caller
+     * gets one edge fetch + one concept fetch over the fused rows instead of
+     * two of each per leg. */
+    readonly augmentSearchResults: (results: ReadonlyArray<ScoredMemory>) => Effect.Effect<ReadonlyArray<AugmentedMemory>, StoreError>;
+    /** The DB's tables + columns (`dimple db-schema` surface). */
+    readonly listSchema: () => Effect.Effect<ReadonlyArray<{
+        readonly table: string;
+        readonly columns: ReadonlyArray<{
+            readonly name: string;
+            readonly type: string;
+        }>;
+    }>, StoreError>;
     /** One fused retrieval-audit row (the hybrid path's audit contract). */
     readonly logAudit: (input: {
         readonly query: string;
@@ -95,16 +159,32 @@ export interface Interface {
     readonly forget: (id: string) => Effect.Effect<void, NotFound | StoreError>;
     readonly sweep: (namespace: string) => Effect.Effect<SweepResult, StoreError>;
     readonly events: (memoryId: string) => Effect.Effect<readonly MemoryEvent[], StoreError>;
-    readonly updateEmbedding: (id: string, embedding: ReadonlyArray<number>, model: string) => Effect.Effect<void, NotFound | StoreError>;
+    readonly updateEmbedding: (id: string, embedding: ReadonlyArray<number>, model: string, options?: {
+        readonly scanCandidates?: boolean;
+    }) => Effect.Effect<void, NotFound | StoreError>;
+    /** Bulk variant of `updateEmbedding` — the writeMany path. One
+     * transaction for all memory updates + events, batch vector insert,
+     * and `routeInsertMany` (tree read once, all insertions computed in
+     * memory, one transaction). For NEW memories: the idempotent re-embed
+     * decrement is deliberately NOT part of the batch (use
+     * `updateEmbedding` for re-embedding existing routed memories).
+     * `scanCandidates` defaults to false-ish via the config: it runs only
+     * when explicitly requested AND `graph.enabled` is not false. */
+    readonly updateEmbeddingMany: (entries: ReadonlyArray<{
+        readonly id: string;
+        readonly embedding: ReadonlyArray<number>;
+    }>, model: string, options?: {
+        readonly scanCandidates?: boolean;
+    }) => Effect.Effect<void, StoreError>;
     readonly findStale: (model: string) => Effect.Effect<readonly string[], StoreError>;
     readonly createConcept: (name: string, embedding: ReadonlyArray<number>) => Effect.Effect<Concept, StoreError>;
     readonly getConcept: (id: string) => Effect.Effect<Concept, NotFound | StoreError>;
     readonly listConcepts: () => Effect.Effect<readonly Concept[], StoreError>;
     readonly annotateMemory: (memoryId: string, conceptId: string, confidence?: number) => Effect.Effect<void, NotFound | StoreError>;
     readonly getMemoryAnnotations: (memoryId: string) => Effect.Effect<readonly string[], StoreError>;
-    readonly queryByMetadata: (filter: Record<string, unknown>) => Effect.Effect<readonly MemoryUnit[], StoreError>;
+    readonly queryByMetadata: (filter: MetadataFilter) => Effect.Effect<readonly MemoryUnit[], StoreError>;
     readonly getMemoryMetadata: (id: string) => Effect.Effect<MemoryMetadata | undefined, NotFound | StoreError>;
-    readonly setMemoryMetadata: (id: string, metadata: MemoryMetadata) => Effect.Effect<void, NotFound | StoreError>;
+    readonly setMemoryMetadata: (id: string, metadata: Partial<MemoryMetadata>) => Effect.Effect<void, NotFound | StoreError>;
     readonly ensureTopicTree: (modelKey: string) => Effect.Effect<{
         rootKey: string;
         unassignedKey: string;

package/dist/internal/store/store.d.ts

@@ -4,9 +4,9 @@ import type { RetrievalAuditRow } from "./models.ts";
 import { Service as DbBackend } from "./db-backend.ts";
 import { Service } from "./service.ts";
 import { StoreError } from "./error.ts";
-import { Service as ConfigService } from "./internal/config/index.js";
-import { type LogConfig, type Logging } from "./internal/logger/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { Service as ConfigService } from "../config/index.js";
+import { type LogConfig, type Logging } from "../logger/index.js";
+import type { EmbeddingModelConfig } from "../config/index.js";
 import type { TopicConfig as TopicConfigType } from "./schema/topics.ts";
 import { GraphConfig } from "./schema/graph.ts";
 /**
@@ -57,14 +57,33 @@ export declare const layer: (url: string, options?: {
     /** Default TTL for writes that omit `ttlSecs` (the config's
      * `defaultTtlSecs`; default 604800). */
     defaultTtlSecs?: number;
-}) => Layer.Layer<Logging | DbBackend | Service, StoreError, Scope>;
+}) => Layer.Layer<Logging | DbBackend | Service, StoreError, never>;
+/**
+ * OpenCode-style node declaration for {@link layer} (the layer graph module
+ * at `@dimple/shared/effect`).
+ *
+ * `deps` stays empty on purpose: the store's production seams
+ * (`topics.enqueueSplit` / `enqueueMerge` / `enqueueAudit`) are effects
+ * built over `JobRuntime`, so the composition root owns the wiring — a node
+ * cannot own a dependency it is itself configured with. The options type is
+ * read off `layer` (`Parameters<typeof layer>[1]`) so the declaration can
+ * never drift from the layer it wraps.
+ */
+export declare const configured: (url: string, options?: Parameters<typeof layer>[1]) => import("../core/index.js").LayerProvider<Logging | DbBackend | Service, StoreError, undefined>;
+/** The default store node — the local libSQL database under `.dimple/`. */
+export declare const node: import("../core/index.js").LayerProvider<Logging | DbBackend | Service, StoreError, undefined>;
 export declare const layerConfig: (config: Config.Wrap<{
     url: string;
 }>, options?: {
     migrationFolder?: string;
     embeddingModelConfig?: EmbeddingModelConfig;
-}) => Layer.Layer<Logging | DbBackend | Service, Config.ConfigError | StoreError, Scope>;
+}) => Layer.Layer<Logging | DbBackend | Service, Config.ConfigError | StoreError, never>;
 export declare const layerFromConfig: (options?: {
     migrationFolder?: string;
 }) => Layer.Layer<Service | DbBackend | Logging, StoreError, ConfigService | Scope>;
+/** The dimple.jsonc `logging` section, installed unconditionally — a
+ * DISABLED config when the section is absent (silent-by-default: library
+ * logging is opt-in, and every `Effect.log*` in the system routes through
+ * `@dimple/logger` either way). The silent config itself comes from the
+ * logger package, the one source of truth. */
 export declare const loggingFromConfig: Layer.Layer<Logging, never, ConfigService | Scope>;

package/dist/internal/store/topics/errors.d.ts

@@ -4,7 +4,7 @@ declare const TopicNotFound_base: Schema.Class<TopicNotFound, Schema.TaggedStruc
 }>, import("effect/Cause").YieldableError>;
 /**
  * Topic-tree error types. Each distinct failure mode gets its
- * own `Schema.TaggedErrorClass` so callers can `catchTag` precisely.
+ * own `Schema.TaggedError` so callers can `catchTag` precisely.
  * `TopicError` is the tagged union; individual classes are exported for
  * pattern matching.
  */

package/dist/internal/store/topics/jobs.d.ts

@@ -46,8 +46,8 @@
  * (the canonical source — keep both in sync).
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 import { StoreError } from "../error.ts";
@@ -127,8 +127,14 @@ export interface TopicSplitHandlerDeps {
      */
     readonly backend?: DbBackendInterface;
 }
+/** The decoded `topic.split` payload — mirrors the queue definition's
+ * schema (`{ topicId, modelKey }`); the executor decodes before calling. */
+export interface TopicSplitPayload {
+    readonly topicId: string;
+    readonly modelKey: string;
+}
 /** The `topic.split` handler shape — `unknown` success like `JobRegistry.Handler`. */
-export type TopicSplitHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+export type TopicSplitHandler = (payload: TopicSplitPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `topic.split` job handler.
  *

package/dist/internal/store/topics/lifecycle.d.ts

@@ -56,12 +56,12 @@
  * (observability only — never read by routing).
  */
 import { Effect } from "effect";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { TopicConfig } from "../schema/topics.ts";
 import type { TopicError } from "./errors.ts";
 import { NotFound, StoreError } from "../error.ts";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 /** Result of {@link setActiveModel}. */
 export interface SetActiveModelResult {
@@ -112,8 +112,14 @@ export interface MemoryEmbedHandlerDeps {
     /** Backend captured at registration (see {@link topicSplitHandler}). */
     readonly backend?: DbBackendInterface;
 }
+/** The decoded `memory.embed` payload — mirrors the queue definition's
+ * schema (`{ memoryId, modelKey }`); the executor decodes before calling. */
+export interface MemoryEmbedPayload {
+    readonly memoryId: string;
+    readonly modelKey: string;
+}
 /** The `memory.embed` handler shape (see jobs.ts). */
-export type MemoryEmbedHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+export type MemoryEmbedHandler = (payload: MemoryEmbedPayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `memory.embed` job handler: re-embeds one memory with the
  * target model and routes it into that model's tree. The success schema is

package/dist/internal/store/topics/maintenance.d.ts

@@ -31,8 +31,8 @@
  * Effect Clock (captured outside the tx closure) — observability only.
  */
 import { Effect } from "effect";
-import { JobFailure, type Handler, type JobContext } from "./internal/workflow/index.js";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import { JobFailure, type Handler, type JobContext } from "../../workflow/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { Interface as DbBackendInterface } from "../db-backend.ts";
 import { StoreError } from "../error.ts";
@@ -89,8 +89,14 @@ export interface TopicMaintenanceHandlerDeps {
     /** Backend captured at registration (see {@link topicSplitHandler}). */
     readonly backend?: DbBackendInterface;
 }
-/** The `topic.merge` / `topic.rebalance` handler shape (see jobs.ts). */
-export type TopicMaintenanceHandler = (payload: unknown, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
+/** The decoded `topic.merge` / `topic.rebalance` payload — mirrors the
+ * queue definitions' schema (`{ topicId, modelKey }`); the executor
+ * decodes before calling. */
+export interface TopicMaintenancePayload {
+    readonly topicId: string;
+    readonly modelKey: string;
+}
+export type TopicMaintenanceHandler = (payload: TopicMaintenancePayload, ctx: JobContext) => Effect.Effect<unknown, JobFailure, DbBackend>;
 /**
  * Factory for the `topic.merge` job handler: resolves the model, runs
  * {@link mergeOrBorrow}, returns `undefined` (the definition's success

package/dist/internal/store/topics/query.d.ts

@@ -24,7 +24,7 @@
  * ranking still runs in libSQL (`vectorSearch` with `topic_key IN (...)`).
  */
 import { Effect } from "effect";
-import type { EmbeddingModelConfig } from "./internal/config/index.js";
+import type { EmbeddingModelConfig } from "../../config/index.js";
 import { Service as DbBackend } from "../db-backend.ts";
 import type { TopicConfig } from "../schema/topics.ts";
 import type { TopicError } from "./errors.ts";