@ponraaj/dimple-sdk 0.0.0-alpha.7 → 0.0.0-alpha.9

package/dist/index.js

@@ -16,7 +16,7 @@ var __export = (target, all) => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/make.ts
-import { Effect as Effect50, Exit as Exit7, Layer as Layer26, ManagedRuntime, Scope as Scope5 } from "effect";
+import { Effect as Effect51, Exit as Exit8, Layer as Layer26, ManagedRuntime, Scope as Scope5 } from "effect";
 
 // ../core/src/core.ts
 import { Context, Schema } from "effect";
@@ -29,10 +29,10 @@ class CoreConfigError extends Schema.TaggedErrorClass()("core.ConfigError", {
 class Service extends Context.Service()("@dimple/core/Core") {
 }
 // ../core/src/layer.ts
-import { Effect as Effect39, Layer as Layer15, Schema as Schema24 } from "effect";
+import { Effect as Effect40, Layer as Layer15, Schema as Schema24 } from "effect";
 
 // ../store/src/store.ts
-import { Config as Config4, Effect as Effect26, Layer as Layer10, Schema as Schema19 } from "effect";
+import { Config as Config4, Effect as Effect27, Layer as Layer10, Schema as Schema19 } from "effect";
 import { eq as eq8, and as and8, desc as desc2, asc as asc5, inArray as inArray4, ne as ne4, or, isNull as isNull2, like, sql as sql7 } from "drizzle-orm";
 
 // ../store/src/db-backend.ts
@@ -113,6 +113,11 @@ var EMBEDDED_MIGRATIONS = [
     name: "20260807074034_ttl_secs_nullable",
     hash: "be3a8d0e64b0224021d869c1c7e217e40b6eb868615cc4c86a6717f5b7211721",
     sql: "PRAGMA foreign_keys=OFF;--> statement-breakpoint\nCREATE TABLE `__new_memories` (\n\t`id` text PRIMARY KEY,\n\t`logical_key` text NOT NULL,\n\t`content` text NOT NULL,\n\t`content_type` text DEFAULT 'text/plain' NOT NULL,\n\t`state` text DEFAULT 'active' NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`ttl_secs` integer DEFAULT 604800,\n\t`namespace` text DEFAULT 'default' NOT NULL,\n\t`metadata` text,\n\t`embedding` F32_BLOB(384),\n\t`embedding_model` text\n);\n--> statement-breakpoint\nINSERT INTO `__new_memories`(`id`, `logical_key`, `content`, `content_type`, `state`, `created_at`, `ttl_secs`, `namespace`, `metadata`, `embedding`, `embedding_model`) SELECT `id`, `logical_key`, `content`, `content_type`, `state`, `created_at`, `ttl_secs`, `namespace`, `metadata`, `embedding`, `embedding_model` FROM `memories`;--> statement-breakpoint\nDROP TABLE `memories`;--> statement-breakpoint\nALTER TABLE `__new_memories` RENAME TO `memories`;--> statement-breakpoint\nPRAGMA foreign_keys=ON;--> statement-breakpoint\nCREATE INDEX `idx_memories_ns_created` ON `memories` (`namespace`,`created_at`);--> statement-breakpoint\nCREATE INDEX `idx_memories_state_created` ON `memories` (`state`,`created_at`);--> statement-breakpoint\nCREATE UNIQUE INDEX `idx_memories_active_key` ON `memories` (`namespace`,`logical_key`) WHERE state = 'active';"
+  },
+  {
+    name: "20260812122840_perf_indexes",
+    hash: "cc45ad830f7101fae454e9d5b43cfdfb922dbee7a5e5b7d9b9b81ec610d21d8e",
+    sql: "CREATE INDEX `idx_memories_created` ON `memories` (`created_at`);--> statement-breakpoint\nCREATE INDEX `ae_status_source` ON `artifact_edges` (`status`,`source`,`expired_at`,`created_at`);"
   }
 ];
 
@@ -160,6 +165,7 @@ var memories = sqliteTable("memories", {
 }, (table) => [
   index("idx_memories_ns_created").on(table.namespace, table.createdAt),
   index("idx_memories_state_created").on(table.state, table.createdAt),
+  index("idx_memories_created").on(table.createdAt),
   uniqueIndex("idx_memories_active_key").on(table.namespace, table.logicalKey).where(sql`state = 'active'`)
 ]);
 var memoryEvents = sqliteTable("memory_events", {
@@ -343,7 +349,8 @@ var artifactEdges = sqliteTable3("artifact_edges", {
 }, (t) => [
   primaryKey3({ columns: [t.fromMemoryId, t.toMemoryId, t.edgeKind] }),
   index3("ae_from").on(t.fromMemoryId, t.status),
-  index3("ae_to").on(t.toMemoryId, t.status)
+  index3("ae_to").on(t.toMemoryId, t.status),
+  index3("ae_status_source").on(t.status, t.source, t.expiredAt, t.createdAt)
 ]);
 var ArtifactEdgeInsert = createInsertSchema3(artifactEdges);
 var ArtifactEdgeSelect = createSelectSchema3(artifactEdges);
@@ -766,6 +773,7 @@ import { Effect as Effect7, Schema as Schema7 } from "effect";
 import { parse, parseTree, printParseErrorCode } from "jsonc-parser";
 var CONFIG_FILE_NAMES = ["dimple.jsonc", "dimple.json"];
 var GLOBAL_DIR = ".config/dimple";
+var resolveCwd = () => process.env["DIMPLE_CWD"] ?? process.cwd();
 var defaults = {
   storeUrl: "file:./.dimple/dimple.db",
   defaultK: 60,
@@ -871,7 +879,7 @@ var loadFs = () => Effect7.tryPromise(() => import("node:fs"));
 var findProjectConfig = () => Effect7.gen(function* () {
   const fs = yield* loadFs();
   const path = yield* Effect7.tryPromise(() => import("node:path"));
-  let dir = process.cwd();
+  let dir = resolveCwd();
   for (let i = 0;i < 20; i++) {
     for (const name of CONFIG_FILE_NAMES) {
       const p = path.join(dir, name);
@@ -940,6 +948,23 @@ var resolveEnvVars = (value) => {
   }
   return value;
 };
+var resolveCwdUrls = (value) => {
+  const cwd = process.env["DIMPLE_CWD"];
+  if (cwd === undefined)
+    return value;
+  if (typeof value === "string" && value.startsWith("file:./")) {
+    return `file:${cwd}${cwd.endsWith("/") ? "" : "/"}${value.slice("file:./".length)}`;
+  }
+  if (Array.isArray(value))
+    return value.map(resolveCwdUrls);
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value))
+      result[k] = resolveCwdUrls(v);
+    return result;
+  }
+  return value;
+};
 var deepMerge = (base, over) => {
   const out = { ...base };
   for (const [key, value] of Object.entries(over)) {
@@ -957,7 +982,7 @@ var loadConfigFromFile = (path) => Effect7.gen(function* () {
   const parsed = yield* parseJsoncEffect(content, (cause) => new Error(`config parse ${path}: ${cause.message}`));
   const merged = deepMerge(defaults, parsed);
   const resolved = resolveEnvVars(merged);
-  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolved).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
+  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolveCwdUrls(resolved)).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
 });
 var loadConfig = (overrides) => Effect7.gen(function* () {
   const fileParts = yield* loadFromFiles();
@@ -970,7 +995,7 @@ var loadConfig = (overrides) => Effect7.gen(function* () {
   if (overrides)
     merged = deepMerge(merged, overrides);
   const resolved = resolveEnvVars(merged);
-  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolved).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
+  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolveCwdUrls(resolved)).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
 });
 
 // ../config/src/service.ts
@@ -1065,7 +1090,14 @@ var runEmbeddedMigrations = async (client) => {
 var makeClientDb = (url) => {
   const client = createClient({ url });
   const db = drizzle({ client });
+  const rawExecute = client.execute.bind(client);
+  const rawExecuteMultiple = client.executeMultiple.bind(client);
+  const rawBatch = client.batch.bind(client);
   const rawTransaction = client.transaction.bind(client);
+  const local = url.startsWith("file:");
+  if (local) {
+    rawExecute("PRAGMA busy_timeout=5000");
+  }
   let txTail = Promise.resolve();
   let releaseSlot;
   const acquire = () => {
@@ -1082,14 +1114,18 @@ var makeClientDb = (url) => {
     releaseSlot?.();
     releaseSlot = undefined;
   };
-  const rawExecute = client.execute.bind(client);
-  const rawExecuteMultiple = client.executeMultiple.bind(client);
-  const rawBatch = client.batch.bind(client);
   const chained = (run) => {
     const prev = acquire();
     return prev.then(run, run).finally(release);
   };
-  client.execute = (...args) => chained(() => rawExecute(...args));
+  const WRITE_RE = /^\s*(INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|REPLACE|PRAGMA|BEGIN|COMMIT|ROLLBACK|VACUUM|REINDEX|ANALYZE|ATTACH|DETACH)\b/i;
+  const isWrite = (sql3) => WRITE_RE.test(sql3);
+  client.execute = (...args) => {
+    const statement = args[0];
+    const sql3 = typeof statement === "string" ? statement : statement.sql ?? "";
+    const run = () => rawExecute(...args);
+    return local && !isWrite(sql3) ? run() : chained(run);
+  };
   client.executeMultiple = (sql3) => chained(() => rawExecuteMultiple(sql3));
   client.batch = (statements, mode) => chained(() => rawBatch(statements, mode));
   client.transaction = async (mode) => {
@@ -1227,16 +1263,16 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     topics,
     artifactEdges
   },
-  ftsSearch: (query, namespace, limit, topicKeys, modelKey, contentType) => Effect9.tryPromise({
+  ftsSearch: (query, namespace, limit, topicKeys, modelKey, contentType, includeEmbedding) => Effect9.tryPromise({
     try: () => client.execute({
-      sql: `SELECT m.*, f.rank
+      sql: `SELECT m.id, m.logical_key, m.content, m.content_type, m.state, m.created_at, m.ttl_secs, m.namespace, m.metadata, m.embedding_model${includeEmbedding ? ", m.embedding" : ""}, f.rank
                FROM memories_fts f
                JOIN memories m ON m.rowid = f.rowid
                WHERE f.content MATCH ? AND m.namespace = ? AND m.state = 'active'${topicFilter(topicKeys)}${contentTypeFilter(contentType)}
                ORDER BY f.rank
                LIMIT ?`,
       args: [
-        `"${query.replaceAll('"', '""')}"`,
+        query.split(/\s+/).filter((token) => token.length > 0).map((token) => `"${token.replaceAll('"', '""')}"`).join(" "),
         namespace,
         ...topicKeys && topicKeys.length > 0 ? [...topicKeys, modelKey ?? ""] : [],
         ...typeof contentType === "string" ? [contentType] : contentType ?? [],
@@ -1245,7 +1281,7 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     }).then((rs) => rs.rows),
     catch: (cause) => new StoreError({ message: `DbBackend.ftsSearch: ${cause}` })
   }),
-  vectorSearch: (query, namespace, limit, model, topicKeys, contentType) => Effect9.gen(function* () {
+  vectorSearch: (query, namespace, limit, model, topicKeys, contentType, includeEmbedding) => Effect9.gen(function* () {
     for (const n of query) {
       if (!Number.isFinite(n)) {
         yield* new StoreError({
@@ -1256,26 +1292,50 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     const tableName = vectorTableName(model);
     const vecJson = JSON.stringify([...query]);
     const convertFn = VECTOR_CONVERT_FNS[model.vectorType ?? "float32"] ?? "vector32";
-    const args = [
-      vecJson,
+    const whereClause = `WHERE m.namespace = ? AND m.state = 'active'${topicFilter(topicKeys)}${contentTypeFilter(contentType)}`;
+    const selectColumns = `m.id, m.logical_key, m.content, m.content_type, m.state, m.created_at, m.ttl_secs, m.namespace, m.metadata, m.embedding_model${includeEmbedding ? ", m.embedding" : ""}`;
+    const baseArgs = [
       namespace,
       ...topicKeys && topicKeys.length > 0 ? [...topicKeys, model.id] : [],
-      ...typeof contentType === "string" ? [contentType] : contentType ?? [],
-      limit
+      ...typeof contentType === "string" ? [contentType] : contentType ?? []
     ];
+    const indexName = `idx_${tableName}_vec`;
+    const annSql = `
+        SELECT ${selectColumns},
+               vector_distance_cos(v.embedding, ${convertFn}(?)) AS distance
+        FROM vector_top_k(?, ${convertFn}(?), ?) AS k
+        JOIN ${tableName} v ON v.rowid = k.id
+        JOIN memories m ON m.id = v.memory_id
+        ${whereClause}
+        ORDER BY distance, m.id
+        LIMIT ?
+      `;
+    const scanSql = `
+        SELECT ${selectColumns},
+               vector_distance_cos(v.embedding, ${convertFn}(?)) AS distance
+        FROM memories m
+        JOIN ${tableName} v ON v.memory_id = m.id
+        ${whereClause}
+        ORDER BY distance, m.id
+        LIMIT ?
+      `;
+    const annK = Math.max(limit * 16, 64);
+    const runAnn = () => client.execute({
+      sql: annSql,
+      args: [vecJson, indexName, vecJson, annK, ...baseArgs, limit]
+    }).then((rs) => rs.rows);
+    const runScan = () => client.execute({
+      sql: scanSql,
+      args: [vecJson, ...baseArgs, limit]
+    }).then((rs) => rs.rows);
     const rows = yield* Effect9.tryPromise({
-      try: () => client.execute({
-        sql: `
-              SELECT m.id, m.logical_key, m.content, m.content_type, m.state, m.created_at, m.ttl_secs, m.namespace, m.metadata, m.embedding_model, m.embedding,
-                     vector_distance_cos(v.embedding, ${convertFn}(?)) AS distance
-              FROM memories m
-              JOIN ${tableName} v ON v.memory_id = m.id
-              WHERE m.namespace = ? AND m.state = 'active'${topicFilter(topicKeys)}${contentTypeFilter(contentType)}
-              ORDER BY distance
-              LIMIT ?
-            `,
-        args
-      }).then((rs) => rs.rows),
+      try: () => runAnn().catch((cause) => {
+        const message = String(cause.message ?? cause);
+        const absent = message.includes("no such table") || message.includes("no such index") || message.includes("vector_top_k");
+        if (absent)
+          return runScan();
+        throw cause;
+      }),
       catch: (cause) => new StoreError({ message: `DbBackend.vectorSearch: ${cause}` })
     }).pipe(Effect9.catchTag("Store.StoreError", (error) => error.message.includes("no such table") ? Effect9.succeed([]) : Effect9.fail(error)));
     return rows;
@@ -1455,7 +1515,7 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     return results;
   }),
   ensureVectorTable: (model) => Effect9.tryPromise({
-    try: () => {
+    try: async () => {
       const tableName = vectorTableName(model);
       const vecType = model.vectorType ?? "float32";
       const sqlType = VECTOR_SQL_TYPES[vecType] ?? "F32_BLOB";
@@ -1467,7 +1527,12 @@ var makeBackend = (url, client, db, migrationFolder) => ({
             model_id TEXT NOT NULL
           );
         `;
-      return client.executeMultiple(sql3);
+      await client.executeMultiple(sql3);
+      if (vecType === "float32") {
+        try {
+          await client.execute(`CREATE INDEX IF NOT EXISTS idx_${tableName}_vec ON ${tableName}(libsql_vector_idx(embedding))`);
+        } catch {}
+      }
     },
     catch: (cause) => new StoreError({ message: `DbBackend.ensureVectorTable: ${cause}` })
   }),
@@ -1483,6 +1548,24 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     },
     catch: (cause) => new StoreError({ message: `DbBackend.insertVector: ${cause}` })
   }),
+  insertVectors: (entries, model) => Effect9.tryPromise({
+    try: async () => {
+      if (entries.length === 0)
+        return;
+      const tableName = vectorTableName(model);
+      const convertFn = VECTOR_CONVERT_FNS[model.vectorType ?? "float32"] ?? "vector32";
+      const values = entries.map(() => `(?, ${convertFn}(?), ?)`).join(", ");
+      const args = [];
+      for (const entry of entries) {
+        args.push(entry.memoryId, JSON.stringify([...entry.vector]), model.id);
+      }
+      return client.execute({
+        sql: `INSERT INTO ${tableName} (memory_id, embedding, model_id) VALUES ${values} ON CONFLICT(memory_id) DO UPDATE SET embedding = excluded.embedding, model_id = excluded.model_id`,
+        args
+      });
+    },
+    catch: (cause) => new StoreError({ message: `DbBackend.insertVectors: ${cause}` })
+  }),
   deleteVector: () => Effect9.succeed(undefined),
   ensureTopicVectorTable: (model) => Effect9.tryPromise({
     try: () => {
@@ -1510,6 +1593,23 @@ var makeBackend = (url, client, db, migrationFolder) => ({
     },
     catch: (cause) => new StoreError({ message: `DbBackend.upsertTopicVector: ${cause}` })
   }),
+  upsertTopicVectors: (entries, model) => Effect9.tryPromise({
+    try: async () => {
+      if (entries.length === 0)
+        return;
+      const tableName = topicVectorTableName(model);
+      const values = entries.map((e) => "(?, vector32(?), ?)").join(", ");
+      const args = [];
+      for (const entry of entries) {
+        args.push(entry.topicKey, JSON.stringify([...entry.sumVector]), model.id);
+      }
+      return client.execute({
+        sql: `INSERT OR REPLACE INTO ${tableName} (topic_key, sum_vector, model_key) VALUES ${values}`,
+        args
+      });
+    },
+    catch: (cause) => new StoreError({ message: `DbBackend.upsertTopicVectors: ${cause}` })
+  }),
   deleteTopicVectors: (model) => Effect9.tryPromise({
     try: () => {
       const tableName = topicVectorTableName(model);
@@ -1531,6 +1631,20 @@ var makeBackend = (url, client, db, migrationFolder) => ({
       sumVector: decodeVectorBlob(row.sum_vector)
     }));
   }),
+  fetchTopicVector: (topicKey, model) => Effect9.gen(function* () {
+    const tableName = topicVectorTableName(model);
+    const rows = yield* Effect9.tryPromise({
+      try: () => client.execute({
+        sql: `SELECT topic_key, sum_vector FROM ${tableName} WHERE topic_key = ?`,
+        args: [topicKey]
+      }).then((rs) => rs.rows),
+      catch: (cause) => new StoreError({ message: `DbBackend.fetchTopicVector: ${cause}` })
+    });
+    const row = rows[0];
+    if (!row)
+      return;
+    return { topicKey: row.topic_key, sumVector: decodeVectorBlob(row.sum_vector) };
+  }),
   fetchMemoryVectors: (memoryIds, model) => Effect9.gen(function* () {
     if (memoryIds.length === 0)
       return [];
@@ -2124,6 +2238,131 @@ var routeInsert = Effect11.fn("topics.routeInsert")(function* (memoryId, vector,
   }
   return { topicKey, overflow: leafCf.count > (config.maxLeafItems ?? 128) };
 });
+var routeInsertMany = Effect11.fn("topics.routeInsertMany")(function* (entries, model, config) {
+  const violations = validateConfig(config);
+  if (violations.length > 0) {
+    return yield* new InvariantViolation({ topicKey: ROOT_TOPIC_KEY, violations });
+  }
+  for (const entry of entries) {
+    if (entry.vector.length !== model.dimensions) {
+      return yield* new ModelMismatch({
+        expected: `${model.id} (${model.dimensions} dims)`,
+        actual: `${entry.vector.length} dims`
+      });
+    }
+  }
+  if (entries.length === 0)
+    return [];
+  const backend = yield* Service2;
+  const db = backend.db;
+  const now = yield* Clock.currentTimeMillis;
+  const maxLeafItems = config.maxLeafItems ?? 128;
+  const rootRows = yield* Effect11.tryPromise({
+    try: () => db.select({ topicKey: topics.topicKey }).from(topics).where(and(eq(topics.topicKey, ROOT_TOPIC_KEY), eq(topics.modelKey, model.id))).limit(1),
+    catch: (cause) => cause
+  }).pipe(routingFailure("topics.routeInsertMany"));
+  if (rootRows.length === 0) {
+    return yield* new TopicNotFound({ topicKey: ROOT_TOPIC_KEY });
+  }
+  const vectorRows = yield* backend.fetchTopicVectors(model).pipe(routingFailure("topics.routeInsertMany"));
+  const sumByTopic = new Map(vectorRows.map((r) => [r.topicKey, new Float32Array(r.sumVector)]));
+  const zeros = new Float32Array(model.dimensions);
+  const sumOf = (topicKey) => sumByTopic.get(topicKey) ?? zeros;
+  const result = yield* Effect11.tryPromise({
+    try: () => db.transaction(async (tx) => {
+      const topicRows = await tx.select({
+        topicKey: topics.topicKey,
+        kind: topics.kind,
+        status: topics.status,
+        depth: topics.depth,
+        memberCount: topics.memberCount,
+        sumSquares: topics.sumSquares
+      }).from(topics).where(eq(topics.modelKey, model.id)).orderBy(asc(topics.topicKey));
+      const relations = await tx.select({
+        parentKey: topicRelations.parentKey,
+        childKey: topicRelations.childKey
+      }).from(topicRelations).where(and(eq(topicRelations.modelKey, model.id), eq(topicRelations.relationKind, "parent_child")));
+      const topicByKey = new Map(topicRows.map((r) => [r.topicKey, r]));
+      const childrenByParent = new Map;
+      const parentOf = new Map;
+      for (const rel of relations) {
+        const list = childrenByParent.get(rel.parentKey);
+        if (list)
+          list.push(rel.childKey);
+        else
+          childrenByParent.set(rel.parentKey, [rel.childKey]);
+        parentOf.set(rel.childKey, rel.parentKey);
+      }
+      for (const children of childrenByParent.values()) {
+        children.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+      }
+      const membershipRows = [];
+      const topicDelta = new Map;
+      const outcomes = [];
+      for (const entry of entries) {
+        const x = new Float32Array(entry.vector);
+        const descent = descendTree(topicByKey, childrenByParent, sumOf, x, config);
+        if (!descent.ok)
+          return Promise.reject(descent.error);
+        const topicKey = descent.topicKey;
+        const leafRow = topicByKey.get(topicKey);
+        if (!leafRow) {
+          return Promise.reject(new Error(`topics.routeInsertMany: topic row missing for ${topicKey}`));
+        }
+        const currentSum = sumOf(topicKey);
+        const leafCf = cfInsert({ count: leafRow.memberCount, ls: currentSum, ss: leafRow.sumSquares }, x);
+        leafRow.memberCount = leafCf.count;
+        leafRow.sumSquares = leafCf.ss;
+        sumByTopic.set(topicKey, leafCf.ls);
+        membershipRows.push({
+          topicKey,
+          memoryId: entry.memoryId,
+          modelKey: model.id,
+          updatedAt: now
+        });
+        const acc = topicDelta.get(topicKey);
+        if (acc) {
+          acc.count += 1;
+          acc.ss = leafCf.ss;
+        } else {
+          topicDelta.set(topicKey, { count: 1, ss: leafCf.ss });
+        }
+        let ancestorKey = parentOf.get(topicKey);
+        while (ancestorKey !== undefined) {
+          const row = topicByKey.get(ancestorKey);
+          if (!row) {
+            return Promise.reject(new Error(`topics.routeInsertMany: ancestor row missing for ${ancestorKey}`));
+          }
+          row.memberCount += 1;
+          const ancestorSum = addToSum(sumOf(ancestorKey), x);
+          sumByTopic.set(ancestorKey, ancestorSum);
+          const accA = topicDelta.get(ancestorKey);
+          if (accA)
+            accA.count += 1;
+          else
+            topicDelta.set(ancestorKey, { count: 1, ss: row.sumSquares });
+          ancestorKey = parentOf.get(ancestorKey);
+        }
+        outcomes.push({
+          memoryId: entry.memoryId,
+          topicKey,
+          overflow: leafCf.count > maxLeafItems
+        });
+      }
+      await tx.insert(topicMemberships).values(membershipRows);
+      for (const [key, delta] of topicDelta) {
+        await tx.update(topics).set({ memberCount: delta.count, sumSquares: delta.ss, updatedAt: now }).where(and(eq(topics.topicKey, key), eq(topics.modelKey, model.id)));
+      }
+      return { outcomes, topicDelta };
+    }),
+    catch: (cause) => cause
+  }).pipe(routingFailure("topics.routeInsertMany"));
+  yield* backend.upsertTopicVectors(Array.from(result.topicDelta, ([topicKey]) => ({
+    topicKey,
+    sumVector: Array.from(sumByTopic.get(topicKey) ?? zeros)
+  })), model).pipe(routingFailure("topics.routeInsertMany"));
+  return result.outcomes;
+});
 
 // ../store/src/topics/query.ts
 var DEFAULT_BEAM_WIDTH = 3;
@@ -2219,7 +2458,7 @@ var resolveTopics = Effect12.fn("topics.resolveTopics")(function* (queryVector,
 });
 
 // ../store/src/topics/lifecycle.ts
-import { Clock as Clock3, Effect as Effect21 } from "effect";
+import { Clock as Clock3, Effect as Effect22 } from "effect";
 import { and as and3, eq as eq3, inArray, ne } from "drizzle-orm";
 
 // ../workflow/src/queue.ts
@@ -2368,7 +2607,18 @@ var queues = [
   AuditWrite
 ];
 // ../workflow/src/runtime.ts
-import { Cause as Cause2, Clock as Clock2, Context as Context7, Duration as Duration2, Effect as Effect18, Exit as Exit5, Layer as Layer7, Option as Option5, Schema as Schema14 } from "effect";
+import {
+  Cause as Cause2,
+  Clock as Clock2,
+  Context as Context7,
+  Deferred as Deferred2,
+  Duration as Duration2,
+  Effect as Effect19,
+  Exit as Exit6,
+  Layer as Layer7,
+  Option as Option5,
+  Schema as Schema14
+} from "effect";
 import { WorkflowEngine as WorkflowEngine3 } from "effect/unstable/workflow";
 import { PersistedQueue as PersistedQueue3, Persistence as PersistenceNamespace3 } from "effect/unstable/persistence";
 
@@ -2458,8 +2708,37 @@ var readWorkflowResult = (store, workflow, executionId) => Effect14.gen(function
   return Option2.none();
 });
 
+// ../workflow/src/signals.ts
+import { Deferred, Effect as Effect15, Exit as Exit2 } from "effect";
+var listeners = new Map;
+var onExecutionDone = (executionId, deferred) => {
+  let set = listeners.get(executionId);
+  if (set === undefined) {
+    set = new Set;
+    listeners.set(executionId, set);
+  }
+  set.add(deferred);
+};
+var offExecutionDone = (executionId, deferred) => {
+  const set = listeners.get(executionId);
+  if (set === undefined)
+    return;
+  set.delete(deferred);
+  if (set.size === 0)
+    listeners.delete(executionId);
+};
+var notifyExecutionDone = (executionId) => {
+  const set = listeners.get(executionId);
+  if (set === undefined)
+    return;
+  listeners.delete(executionId);
+  for (const deferred of set) {
+    Effect15.runFork(Deferred.done(deferred, Exit2.void));
+  }
+};
+
 // ../workflow/src/engine.ts
-import { Effect as Effect17, Exit as Exit4, Fiber, FiberMap, Layer as Layer6, Option as Option4, Schema as Schema13 } from "effect";
+import { Effect as Effect18, Exit as Exit5, Fiber, FiberMap, Layer as Layer6, Option as Option4, Schema as Schema13 } from "effect";
 import { Workflow as Workflow3, WorkflowEngine as WorkflowEngine2 } from "effect/unstable/workflow";
 import { Persistence as PersistenceNamespace2, PersistedQueue as PersistedQueue2 } from "effect/unstable/persistence";
 
@@ -2468,8 +2747,8 @@ import {
   Cause,
   Data,
   Duration,
-  Effect as Effect15,
-  Exit as Exit2,
+  Effect as Effect16,
+  Exit as Exit3,
   Latch,
   Layer as Layer4,
   MutableRef,
@@ -2482,7 +2761,7 @@ import { SqlClient } from "effect/unstable/sql";
 
 class QueueKey extends Data.Class {
 }
-var makeStore = Effect15.fnUntraced(function* (options) {
+var makeStore = Effect16.fnUntraced(function* (options) {
   const sql3 = (yield* SqlClient.SqlClient).withoutTransforms();
   const tableName = options?.tableName ?? "effect_queue";
   const tableNameSql = sql3(tableName);
@@ -2515,16 +2794,16 @@ var makeStore = Effect15.fnUntraced(function* (options) {
       VALUES (${id}, ${name}, ${element}, FALSE, 0, ${sqlNow}, ${sqlNow})
     `;
   const elementIds = new Set;
-  const refreshLocks = Effect15.suspend(() => {
+  const refreshLocks = Effect16.suspend(() => {
     if (elementIds.size === 0)
-      return Effect15.void;
+      return Effect16.void;
     const ids = Array.from(elementIds);
     return sql3`
       UPDATE ${tableNameSql}
       SET acquired_at = ${sqlNow}
       WHERE sequence IN (${sql3.literal(ids.join(","))})
       AND acquired_by = ${workerIdSql}
-    `.pipe(Effect15.asVoid);
+    `.pipe(Effect16.asVoid);
   });
   const complete = (sequence, attempts) => {
     elementIds.delete(sequence);
@@ -2533,7 +2812,7 @@ var makeStore = Effect15.fnUntraced(function* (options) {
       SET acquired_at = NULL, acquired_by = NULL, updated_at = ${sqlNow}, completed = ${sqlTrue}, attempts = ${attempts}
       WHERE sequence = ${sequence}
       AND acquired_by = ${workerIdSql}
-    `.pipe(Effect15.retry({ times: 5, schedule: Schedule.exponential(100, 1.5) }), Effect15.orDie);
+    `.pipe(Effect16.retry({ times: 5, schedule: Schedule.exponential(100, 1.5) }), Effect16.orDie);
   };
   const retry = (sequence, attempts, cause) => {
     elementIds.delete(sequence);
@@ -2542,33 +2821,33 @@ var makeStore = Effect15.fnUntraced(function* (options) {
       SET acquired_at = NULL, acquired_by = NULL, updated_at = ${sqlNow}, attempts = ${attempts}, last_failure = ${Cause.pretty(cause)}
       WHERE sequence = ${sequence}
       AND acquired_by = ${workerIdSql}
-    `.pipe(Effect15.retry({ times: 5, schedule: Schedule.exponential(100, 1.5) }), Effect15.orDie);
+    `.pipe(Effect16.retry({ times: 5, schedule: Schedule.exponential(100, 1.5) }), Effect16.orDie);
   };
   const interrupt = (ids) => {
     for (const id of ids)
       elementIds.delete(id);
     if (ids.length === 0)
-      return Effect15.void;
+      return Effect16.void;
     return sql3`
       UPDATE ${tableNameSql}
       SET acquired_at = NULL, acquired_by = NULL
       WHERE sequence IN (${sql3.literal(ids.join(","))})
       AND acquired_by = ${workerIdSql}
-    `.pipe(Effect15.retry({ times: 5, schedule: Schedule.exponential(100, 1.5) }), Effect15.orDie);
+    `.pipe(Effect16.retry({ times: 5, schedule: Schedule.exponential(100, 1.5) }), Effect16.orDie);
   };
-  yield* refreshLocks.pipe(Effect15.tapCause(Effect15.logWarning), Effect15.retry(Schedule.spaced(500)), Effect15.schedule(Schedule.fixed(lockRefreshInterval)), Effect15.annotateLogs({
+  yield* refreshLocks.pipe(Effect16.tapCause(Effect16.logWarning), Effect16.retry(Schedule.spaced(500)), Effect16.schedule(Schedule.fixed(lockRefreshInterval)), Effect16.annotateLogs({
     package: "@dimple/workflow",
     module: "QueueStore",
     fiber: "refreshLocks"
-  }), Effect15.forkScoped);
+  }), Effect16.forkScoped);
   const mailboxes = yield* RcMap.make({
-    lookup: Effect15.fnUntraced(function* ({ maxAttempts, name }) {
+    lookup: Effect16.fnUntraced(function* ({ maxAttempts, name }) {
       const queue = yield* Queue.make();
       const takers = MutableRef.make(0);
       const pollLatch = Latch.makeUnsafe();
       const takenLatch = Latch.makeUnsafe();
-      yield* Effect15.addFinalizer(() => Effect15.flatMap(Queue.clear(queue), (elements) => elements.length === 0 ? Effect15.void : interrupt(Array.from(elements, (e) => e.sequence))));
-      const poll = (size) => Effect15.suspend(() => sql3`
+      yield* Effect16.addFinalizer(() => Effect16.flatMap(Queue.clear(queue), (elements) => elements.length === 0 ? Effect16.void : interrupt(Array.from(elements, (e) => e.sequence))));
+      const poll = (size) => Effect16.suspend(() => sql3`
           UPDATE ${tableNameSql}
           SET acquired_at = ${sqlNow}, acquired_by = ${workerIdSql}
           WHERE queue_name = ${name}
@@ -2576,14 +2855,14 @@ var makeStore = Effect15.fnUntraced(function* (options) {
           AND attempts < ${maxAttempts}
           AND (acquired_at IS NULL OR acquired_at < ${expiresAt})
           RETURNING sequence, id, queue_name, element, attempts
-        `.pipe(Effect15.map((rows) => rows)));
-      yield* Effect15.gen(function* () {
+        `.pipe(Effect16.map((rows) => rows)));
+      yield* Effect16.gen(function* () {
         while (true) {
           yield* pollLatch.await;
-          yield* Effect15.yieldNow;
+          yield* Effect16.yieldNow;
           const results = takers.current === 0 ? [] : yield* poll(takers.current);
           if (results.length === 0) {
-            yield* Effect15.sleep(pollInterval);
+            yield* Effect16.sleep(pollInterval);
             continue;
           }
           takenLatch.closeUnsafe();
@@ -2592,24 +2871,24 @@ var makeStore = Effect15.fnUntraced(function* (options) {
           }
           yield* Queue.offerAll(queue, results);
           yield* takenLatch.await;
-          yield* Effect15.yieldNow;
+          yield* Effect16.yieldNow;
         }
-      }).pipe(Effect15.sandbox, Effect15.retry(Schedule.spaced(500)), Effect15.forkScoped, Effect15.interruptible);
+      }).pipe(Effect16.sandbox, Effect16.retry(Schedule.spaced(500)), Effect16.forkScoped, Effect16.interruptible);
       return { queue, takers, pollLatch, takenLatch };
     }),
     idleTimeToLive: Duration.seconds(30)
   });
   return PersistedQueue.PersistedQueueStore.of({
-    offer: ({ element, id, name }) => Effect15.catchCause(Effect15.suspend(() => offer(id, name, JSON.stringify(element))), (cause) => Effect15.fail(new PersistedQueue.PersistedQueueError({
+    offer: ({ element, id, name }) => Effect16.catchCause(Effect16.suspend(() => offer(id, name, JSON.stringify(element))), (cause) => Effect16.fail(new PersistedQueue.PersistedQueueError({
       message: "Failed to offer element to persisted queue",
       cause
     }))),
-    take: ({ maxAttempts, name }) => Effect15.uninterruptibleMask((restore) => RcMap.get(mailboxes, new QueueKey({ name, maxAttempts })).pipe(Effect15.flatMap(({ pollLatch, queue, takenLatch, takers }) => {
+    take: ({ maxAttempts, name }) => Effect16.uninterruptibleMask((restore) => RcMap.get(mailboxes, new QueueKey({ name, maxAttempts })).pipe(Effect16.flatMap(({ pollLatch, queue, takenLatch, takers }) => {
       takers.current++;
       if (takers.current === 1) {
         pollLatch.openUnsafe();
       }
-      return Effect15.tap(restore(Queue.take(queue)), () => Effect15.sync(() => {
+      return Effect16.tap(restore(Queue.take(queue)), () => Effect16.sync(() => {
         takers.current--;
         if (takers.current === 0) {
           pollLatch.closeUnsafe();
@@ -2618,10 +2897,10 @@ var makeStore = Effect15.fnUntraced(function* (options) {
           takenLatch.openUnsafe();
         }
       }));
-    }), Effect15.scoped, restore, Effect15.tap((element) => Effect15.addFinalizer(Exit2.match({
+    }), Effect16.scoped, restore, Effect16.tap((element) => Effect16.addFinalizer(Exit3.match({
       onFailure: (cause) => Cause.hasInterruptsOnly(cause) ? interrupt([element.sequence]) : retry(element.sequence, element.attempts + 1, cause),
       onSuccess: () => complete(element.sequence, element.attempts + 1)
-    }))), Effect15.map((element) => ({ ...element, element: JSON.parse(element.element) }))))
+    }))), Effect16.map((element) => ({ ...element, element: JSON.parse(element.element) }))))
   });
 });
 var storeSqliteLayer = Layer4.effect(PersistedQueue.PersistedQueueStore, makeStore());
@@ -2638,8 +2917,8 @@ __export(exports_LibsqlClient, {
 import * as Libsql from "@libsql/client";
 import * as Config3 from "effect/Config";
 import * as Context6 from "effect/Context";
-import * as Effect16 from "effect/Effect";
-import * as Exit3 from "effect/Exit";
+import * as Effect17 from "effect/Effect";
+import * as Exit4 from "effect/Exit";
 import * as Layer5 from "effect/Layer";
 import * as Option3 from "effect/Option";
 import * as Redacted from "effect/Redacted";
@@ -2658,7 +2937,7 @@ var classifyError = (cause, message, operation) => classifySqliteError(cause, {
 var TypeId = "~@effect/sql-libsql/LibsqlClient";
 var LibsqlClient = /* @__PURE__ */ Context6.Service("@effect/sql-libsql/LibsqlClient");
 var LibsqlTransaction = /* @__PURE__ */ Context6.Service("@effect/sql-libsql/LibsqlClient/LibsqlTransaction");
-var make4 = (options) => Effect16.gen(function* () {
+var make4 = (options) => Effect17.gen(function* () {
   const compiler = Statement.makeCompilerSqlite(options.transformQueryNames);
   const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames).array : undefined;
   const spanAttributes = [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]];
@@ -2669,7 +2948,7 @@ var make4 = (options) => Effect16.gen(function* () {
       this.sdk = sdk;
     }
     run(sql3, params = []) {
-      return Effect16.map(Effect16.tryPromise({
+      return Effect17.map(Effect17.tryPromise({
         try: () => this.sdk.execute({
           sql: sql3,
           args: params
@@ -2680,7 +2959,7 @@ var make4 = (options) => Effect16.gen(function* () {
       }), (results) => results.rows);
     }
     runRaw(sql3, params = []) {
-      return Effect16.tryPromise({
+      return Effect17.tryPromise({
         try: () => this.sdk.execute({
           sql: sql3,
           args: params
@@ -2691,13 +2970,13 @@ var make4 = (options) => Effect16.gen(function* () {
       });
     }
     execute(sql3, params, transformRows2) {
-      return transformRows2 ? Effect16.map(this.run(sql3, params), transformRows2) : this.run(sql3, params);
+      return transformRows2 ? Effect17.map(this.run(sql3, params), transformRows2) : this.run(sql3, params);
     }
     executeRaw(sql3, params) {
       return this.runRaw(sql3, params);
     }
     executeValues(sql3, params) {
-      return Effect16.map(this.run(sql3, params), (rows) => rows.map((row) => Array.from(row)));
+      return Effect17.map(this.run(sql3, params), (rows) => rows.map((row) => Array.from(row)));
     }
     executeValuesUnprepared(sql3, params) {
       return this.executeValues(sql3, params);
@@ -2709,7 +2988,7 @@ var make4 = (options) => Effect16.gen(function* () {
       return Stream.die("executeStream not implemented");
     }
     get beginTransaction() {
-      return Effect16.map(Effect16.tryPromise({
+      return Effect17.map(Effect17.tryPromise({
         try: () => this.sdk.transaction("write"),
         catch: (cause) => new SqlError2({
           reason: classifyError(cause, "Failed to begin transaction", "beginTransaction")
@@ -2717,7 +2996,7 @@ var make4 = (options) => Effect16.gen(function* () {
       }), (tx) => new LibsqlConnectionImpl(tx));
     }
     get commit() {
-      return Effect16.tryPromise({
+      return Effect17.tryPromise({
         try: () => this.sdk.commit(),
         catch: (cause) => new SqlError2({
           reason: classifyError(cause, "Failed to commit transaction", "commitTransaction")
@@ -2725,7 +3004,7 @@ var make4 = (options) => Effect16.gen(function* () {
       });
     }
     get rollback() {
-      return Effect16.tryPromise({
+      return Effect17.tryPromise({
         try: () => this.sdk.rollback(),
         catch: (cause) => new SqlError2({
           reason: classifyError(cause, "Failed to rollback transaction", "rollbackTransaction")
@@ -2733,33 +3012,33 @@ var make4 = (options) => Effect16.gen(function* () {
       });
     }
   }
-  const connection = "liveClient" in options ? new LibsqlConnectionImpl(options.liveClient) : yield* Effect16.map(Effect16.acquireRelease(Effect16.sync(() => Libsql.createClient({
+  const connection = "liveClient" in options ? new LibsqlConnectionImpl(options.liveClient) : yield* Effect17.map(Effect17.acquireRelease(Effect17.sync(() => Libsql.createClient({
     ...options,
     authToken: Redacted.isRedacted(options.authToken) ? Redacted.value(options.authToken) : options.authToken,
     encryptionKey: Redacted.isRedacted(options.encryptionKey) ? Redacted.value(options.encryptionKey) : options.encryptionKey,
     url: options.url.toString(),
     syncUrl: options.syncUrl?.toString()
-  })), (sdk) => Effect16.sync(() => sdk.close())), (sdk) => new LibsqlConnectionImpl(sdk));
+  })), (sdk) => Effect17.sync(() => sdk.close())), (sdk) => new LibsqlConnectionImpl(sdk));
   const semaphore = yield* Semaphore.make(1);
   const withTransaction = Client.makeWithTransaction({
     transactionService: LibsqlTransaction,
     spanAttributes,
-    acquireConnection: Effect16.uninterruptibleMask(Effect16.fnUntraced(function* (restore) {
+    acquireConnection: Effect17.uninterruptibleMask(Effect17.fnUntraced(function* (restore) {
       const scope = Scope3.makeUnsafe();
       yield* restore(semaphore.take(1));
       yield* Scope3.addFinalizer(scope, semaphore.release(1));
-      const conn = yield* connection.beginTransaction.pipe(Effect16.tapCause((cause) => Scope3.close(scope, Exit3.failCause(cause))));
+      const conn = yield* connection.beginTransaction.pipe(Effect17.tapCause((cause) => Scope3.close(scope, Exit4.failCause(cause))));
       return [scope, conn];
     })),
-    begin: () => Effect16.void,
+    begin: () => Effect17.void,
     savepoint: (conn, id) => conn.executeRaw(`SAVEPOINT effect_sql_${id};`, []),
     commit: (conn) => conn.commit,
     rollback: (conn) => conn.rollback,
     rollbackSavepoint: (conn, id) => conn.executeRaw(`ROLLBACK TO SAVEPOINT effect_sql_${id};`, [])
   });
-  const acquirer = Effect16.flatMap(Effect16.serviceOption(LibsqlTransaction), Option3.match({
-    onNone: () => semaphore.withPermits(1)(Effect16.succeed(connection)),
-    onSome: ([conn]) => Effect16.succeed(conn)
+  const acquirer = Effect17.flatMap(Effect17.serviceOption(LibsqlTransaction), Option3.match({
+    onNone: () => semaphore.withPermits(1)(Effect17.succeed(connection)),
+    onSome: ([conn]) => Effect17.succeed(conn)
   }));
   return Object.assign(yield* Client.make({
     acquirer,
@@ -2773,21 +3052,21 @@ var make4 = (options) => Effect16.gen(function* () {
     sdk: connection.sdk
   });
 });
-var layerConfig2 = (config) => Layer5.effectContext(Config3.unwrap(config).pipe(Effect16.flatMap(make4), Effect16.map((client) => Context6.make(LibsqlClient, client).pipe(Context6.add(Client.SqlClient, client))))).pipe(Layer5.provide(Reactivity.layer));
-var layer5 = (config) => Layer5.effectContext(Effect16.map(make4(config), (client) => Context6.make(LibsqlClient, client).pipe(Context6.add(Client.SqlClient, client)))).pipe(Layer5.provide(Reactivity.layer));
+var layerConfig2 = (config) => Layer5.effectContext(Config3.unwrap(config).pipe(Effect17.flatMap(make4), Effect17.map((client) => Context6.make(LibsqlClient, client).pipe(Context6.add(Client.SqlClient, client))))).pipe(Layer5.provide(Reactivity.layer));
+var layer5 = (config) => Layer5.effectContext(Effect17.map(make4(config), (client) => Context6.make(LibsqlClient, client).pipe(Context6.add(Client.SqlClient, client)))).pipe(Layer5.provide(Reactivity.layer));
 // ../workflow/src/engine.ts
 var Persistence = PersistenceNamespace2.Persistence;
 var PersistedQueueFactory = PersistedQueue2.PersistedQueueFactory;
-var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect17.gen(function* () {
+var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect18.gen(function* () {
   const persistence = yield* Persistence;
   const queueFactory = yield* PersistedQueueFactory;
-  const scope = yield* Effect17.scope;
+  const scope = yield* Effect18.scope;
   const store = yield* persistence.make({ storeId: STORE_ID });
   const resumeQueue = yield* queueFactory.make({ name: RESUME_QUEUE, schema: ResumeSignal });
   const workflows = new Map;
   const executions = new Map;
   const clocks = yield* FiberMap.make();
-  const resume = (state) => Effect17.gen(function* () {
+  const resume = (state) => Effect18.gen(function* () {
     const exit = state.fiber?.pollUnsafe();
     if (exit && exit._tag === "Success" && exit.value._tag === "Complete")
       return;
@@ -2799,31 +3078,32 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect17.gen(fu
     const instance = WorkflowEngine2.WorkflowInstance.initial(state.instance.workflow, state.instance.executionId);
     instance.interrupted = state.instance.interrupted;
     state.instance = instance;
-    state.fiber = yield* state.execute(state.payload, state.instance.executionId).pipe(Effect17.onExit(() => {
+    state.fiber = yield* state.execute(state.payload, state.instance.executionId).pipe(Effect18.onExit(() => {
       if (!instance.interrupted)
-        return Effect17.void;
+        return Effect18.void;
       instance.suspended = false;
-      return Effect17.withFiber((fiber) => Effect17.interruptible(Fiber.interrupt(fiber)));
-    }), Workflow3.intoResult, Effect17.provideService(WorkflowEngine2.WorkflowInstance, instance), Effect17.provideService(WorkflowEngine2.WorkflowEngine, engine), Effect17.tap((result) => {
+      return Effect18.withFiber((fiber) => Effect18.interruptible(Fiber.interrupt(fiber)));
+    }), Workflow3.intoResult, Effect18.provideService(WorkflowEngine2.WorkflowInstance, instance), Effect18.provideService(WorkflowEngine2.WorkflowEngine, engine), Effect18.tap((result) => {
       if (result._tag !== "Complete")
-        return Effect17.void;
-      return Effect17.gen(function* () {
+        return Effect18.void;
+      return Effect18.gen(function* () {
         const entry2 = workflows.get(state.instance.workflow._tag);
         if (!entry2)
           return;
-        const encoded = yield* Effect17.orDie(Schema13.encodeEffect(resultCodecFor(entry2.workflow))(result));
-        yield* setEncodedExit(store, resultKey(state.instance.executionId), Exit4.succeed(encoded));
+        const encoded = yield* Effect18.orDie(Schema13.encodeEffect(resultCodecFor(entry2.workflow))(result));
+        yield* setEncodedExit(store, resultKey(state.instance.executionId), Exit5.succeed(encoded));
+        notifyExecutionDone(state.instance.executionId);
       });
-    }), Effect17.tap((result) => {
+    }), Effect18.tap((result) => {
       if (!state.parent || result._tag !== "Complete")
-        return Effect17.void;
+        return Effect18.void;
       const parent = executions.get(state.parent);
       if (parent)
-        return Effect17.forkIn(resume(parent), scope);
-      return Effect17.void;
-    }), Effect17.forkIn(entry.scope));
+        return Effect18.forkIn(resume(parent), scope);
+      return Effect18.void;
+    }), Effect18.forkIn(entry.scope));
   });
-  const resumeExecution = (executionId) => Effect17.gen(function* () {
+  const resumeExecution = (executionId) => Effect18.gen(function* () {
     const state = executions.get(executionId);
     if (state) {
       yield* resume(state);
@@ -2846,22 +3126,22 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect17.gen(fu
     }
   });
   const engine = WorkflowEngine2.makeUnsafe({
-    register: Effect17.fnUntraced(function* (workflow, execute) {
+    register: Effect18.fnUntraced(function* (workflow, execute) {
       workflows.set(workflow._tag, {
         workflow,
         execute,
-        scope: yield* Effect17.scope
+        scope: yield* Effect18.scope
       });
     }),
     execute: executeEncoded(workflows, executions, store, resume),
-    interrupt: Effect17.fnUntraced(function* (_workflow, executionId) {
+    interrupt: Effect18.fnUntraced(function* (_workflow, executionId) {
       const state = executions.get(executionId);
       if (!state)
         return;
       state.instance.interrupted = true;
       yield* resume(state);
     }),
-    interruptUnsafe: Effect17.fnUntraced(function* (_workflow, executionId) {
+    interruptUnsafe: Effect18.fnUntraced(function* (_workflow, executionId) {
       const state = executions.get(executionId);
       if (!state)
         return;
@@ -2871,36 +3151,36 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect17.gen(fu
       }
     }),
     resume: (_workflow, executionId) => resumeExecution(executionId),
-    activityExecute: Effect17.fnUntraced(function* (activity, attempt) {
+    activityExecute: Effect18.fnUntraced(function* (activity, attempt) {
       const instance = yield* WorkflowEngine2.WorkflowInstance;
       const key = activityKey(instance.executionId, activity.name, attempt);
       const persisted = yield* getEncodedExit(store, key);
-      if (persisted && Exit4.isSuccess(persisted)) {
+      if (persisted && Exit5.isSuccess(persisted)) {
         const entry = workflows.get(instance.workflow._tag);
         if (!entry)
-          return yield* Effect17.die(`activity replay: unknown workflow ${instance.workflow._tag}`);
-        return yield* Effect17.orDie(Schema13.decodeUnknownEffect(resultCodecFor(entry.workflow))(persisted.value));
+          return yield* Effect18.die(`activity replay: unknown workflow ${instance.workflow._tag}`);
+        return yield* Effect18.orDie(Schema13.decodeUnknownEffect(resultCodecFor(entry.workflow))(persisted.value));
       }
       const activityInstance = WorkflowEngine2.WorkflowInstance.initial(instance.workflow, instance.executionId);
       activityInstance.interrupted = instance.interrupted;
-      const result = yield* activity.executeEncoded.pipe(Workflow3.intoResult, Effect17.provideService(WorkflowEngine2.WorkflowInstance, activityInstance), Effect17.exit);
+      const result = yield* activity.executeEncoded.pipe(Workflow3.intoResult, Effect18.provideService(WorkflowEngine2.WorkflowInstance, activityInstance), Effect18.exit);
       if (result._tag === "Success" && result.value._tag !== "Suspended") {
         const entry = workflows.get(instance.workflow._tag);
         if (entry) {
-          const encoded = yield* Effect17.orDie(Schema13.encodeEffect(resultCodecFor(entry.workflow))(result.value));
-          yield* setEncodedExit(store, key, Exit4.succeed(encoded));
+          const encoded = yield* Effect18.orDie(Schema13.encodeEffect(resultCodecFor(entry.workflow))(result.value));
+          yield* setEncodedExit(store, key, Exit5.succeed(encoded));
         }
       }
       return yield* result;
     }),
-    poll: (_workflow, executionId) => Effect17.gen(function* () {
+    poll: (_workflow, executionId) => Effect18.gen(function* () {
       const state = executions.get(executionId);
       if (!state) {
         const persisted = yield* getEncodedExit(store, resultKey(executionId));
-        if (persisted && Exit4.isSuccess(persisted)) {
+        if (persisted && Exit5.isSuccess(persisted)) {
           const workflow = yield* workflowTagFor(workflows, store, executionId);
           if (workflow) {
-            return Option4.some(yield* Effect17.orDie(Schema13.decodeUnknownEffect(resultCodecFor(workflow))(persisted.value)));
+            return Option4.some(yield* Effect18.orDie(Schema13.decodeUnknownEffect(resultCodecFor(workflow))(persisted.value)));
           }
         }
         return Option4.none();
@@ -2910,9 +3190,9 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect17.gen(fu
         return Option4.none();
       if (exit._tag === "Success")
         return Option4.some(exit.value);
-      return yield* Effect17.die(exit.cause);
+      return yield* Effect18.die(exit.cause);
     }),
-    deferredResult: Effect17.fnUntraced(function* (deferred) {
+    deferredResult: Effect18.fnUntraced(function* (deferred) {
       const instance = yield* WorkflowEngine2.WorkflowInstance;
       const persisted = yield* getEncodedExit(store, deferredKey(instance.executionId, deferred.name));
       if (persisted) {
@@ -2920,26 +3200,26 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect17.gen(fu
       }
       return Option4.none();
     }),
-    deferredDone: (options) => Effect17.gen(function* () {
+    deferredDone: (options) => Effect18.gen(function* () {
       yield* setEncodedExit(store, deferredKey(options.executionId, options.deferredName), options.exit);
-      yield* resumeQueue.offer({ executionId: options.executionId }, { id: options.executionId }).pipe(Effect17.orDie);
+      yield* resumeQueue.offer({ executionId: options.executionId }, { id: options.executionId }).pipe(Effect18.orDie);
       yield* resumeExecution(options.executionId);
     }),
     scheduleClock: (workflow, options) => engine.deferredDone(options.clock.deferred, {
       workflowName: workflow._tag,
       executionId: options.executionId,
       deferredName: options.clock.deferred.name,
-      exit: Exit4.void
-    }).pipe(Effect17.delay(options.clock.duration), FiberMap.run(clocks, `${options.executionId}/${options.clock.name}`, {
+      exit: Exit5.void
+    }).pipe(Effect18.delay(options.clock.duration), FiberMap.run(clocks, `${options.executionId}/${options.clock.name}`, {
       onlyIfMissing: true
-    }), Effect17.asVoid)
+    }), Effect18.asVoid)
   });
   return engine;
 }));
-var executeEncoded = (workflows, executions, store, resume) => Effect17.fnUntraced(function* (workflow, options) {
+var executeEncoded = (workflows, executions, store, resume) => Effect18.fnUntraced(function* (workflow, options) {
   const entry = workflows.get(workflow._tag);
   if (!entry) {
-    return yield* Effect17.orDie(Effect17.fail(`Workflow ${workflow._tag} is not registered`));
+    return yield* Effect18.orDie(Effect18.fail(`Workflow ${workflow._tag} is not registered`));
   }
   let state = executions.get(options.executionId);
   if (!state) {
@@ -2951,24 +3231,24 @@ var executeEncoded = (workflows, executions, store, resume) => Effect17.fnUntrac
       parent: options.parent?.executionId
     };
     executions.set(options.executionId, state);
-    yield* setEncodedExit(store, recordKey(options.executionId), Exit4.succeed({ workflowTag: workflow._tag, payload: options.payload }));
+    yield* setEncodedExit(store, recordKey(options.executionId), Exit5.succeed({ workflowTag: workflow._tag, payload: options.payload }));
     yield* resume(state);
   }
   if (options.discard)
-    return yield* Effect17.void;
+    return yield* Effect18.void;
   if (!state.fiber) {
-    return yield* Effect17.orDie(Effect17.fail(`Workflow ${workflow._tag}: execution ${options.executionId} has no fiber`));
+    return yield* Effect18.orDie(Effect18.fail(`Workflow ${workflow._tag}: execution ${options.executionId} has no fiber`));
   }
   return yield* Fiber.join(state.fiber);
 });
-var loadRecord = (store, executionId) => Effect17.gen(function* () {
+var loadRecord = (store, executionId) => Effect18.gen(function* () {
   const persisted = yield* getEncodedExit(store, recordKey(executionId));
-  if (persisted && Exit4.isSuccess(persisted)) {
-    return yield* Effect17.orDie(Schema13.decodeUnknownEffect(ExecutionRecord)(persisted.value));
+  if (persisted && Exit5.isSuccess(persisted)) {
+    return yield* Effect18.orDie(Schema13.decodeUnknownEffect(ExecutionRecord)(persisted.value));
   }
   return;
 });
-var workflowTagFor = (workflows, store, executionId) => Effect17.gen(function* () {
+var workflowTagFor = (workflows, store, executionId) => Effect18.gen(function* () {
   const record = yield* loadRecord(store, executionId);
   if (!record)
     return;
@@ -2977,10 +3257,10 @@ var workflowTagFor = (workflows, store, executionId) => Effect17.gen(function* (
 var ensureDbDir = (url) => url.startsWith("file:") ? import("node:fs").then((fs) => import("node:path").then(({ dirname }) => {
   fs.mkdirSync(dirname(url.slice("file:".length)), { recursive: true });
 })) : Promise.resolve();
-var libsqlStack = (options) => Layer6.unwrap(Effect17.tryPromise({
+var libsqlStack = (options) => Layer6.unwrap(Effect18.tryPromise({
   try: () => ensureDbDir(options.url),
   catch: (cause) => new Error(String(cause))
-}).pipe(Effect17.catch(() => Effect17.void), Effect17.map(() => Layer6.mergeAll(PersistenceNamespace2.layerSql, PersistedQueue2.layer.pipe(Layer6.provide(storeSqliteLayer))).pipe(Layer6.provide(exports_LibsqlClient.layer(options))))));
+}).pipe(Effect18.catch(() => Effect18.void), Effect18.map(() => Layer6.mergeAll(PersistenceNamespace2.layerSql, PersistedQueue2.layer.pipe(Layer6.provide(storeSqliteLayer))).pipe(Layer6.provide(exports_LibsqlClient.layer(options))))));
 var layerDurableLibsql = (options) => layerDurable.pipe(Layer6.provide(libsqlStack(options)));
 
 // ../workflow/src/runtime.ts
@@ -2999,7 +3279,7 @@ var jobsError = (jobId, e) => {
     return e;
   return new QueueError({ message: e instanceof Error ? e.message : String(e) });
 };
-var layer6 = (defs) => Layer7.effect(Service7, Effect18.gen(function* () {
+var layer6 = (defs) => Layer7.effect(Service7, Effect19.gen(function* () {
   const engine = yield* WorkflowEngine3.WorkflowEngine;
   const persistence = yield* Persistence2;
   const queueFactory = yield* PersistedQueueFactory2;
@@ -3007,51 +3287,57 @@ var layer6 = (defs) => Layer7.effect(Service7, Effect18.gen(function* () {
   for (const def of defs) {
     yield* def.register(engine);
   }
-  const enqueue = Effect18.fn("JobRuntime.enqueue")(function* (def, payload) {
-    const decoded = yield* Schema14.decodeUnknownEffect(def.payloadSchema)(payload).pipe(Effect18.mapError((e) => new QueueError({ message: `invalid payload: ${e.message}` })));
+  const enqueue = Effect19.fn("JobRuntime.enqueue")(function* (def, payload) {
+    const decoded = yield* Schema14.decodeUnknownEffect(def.payloadSchema)(payload).pipe(Effect19.mapError((e) => new QueueError({ message: `invalid payload: ${e.message}` })));
     const token = def.idempotencyKey(decoded);
     const envelope = { token, payload: decoded, traceId: "" };
-    const jobId = yield* def.workflow.executionId(envelope).pipe(Effect18.provideService(WorkflowEngine3.WorkflowEngine, engine), Effect18.mapError((e) => new QueueError({ message: e instanceof Error ? e.message : String(e) })));
-    yield* def.workflow.execute(envelope, { discard: true }).pipe(Effect18.provideService(WorkflowEngine3.WorkflowEngine, engine), Effect18.mapError((e) => jobsError(jobId, e)));
+    const jobId = yield* def.workflow.executionId(envelope).pipe(Effect19.provideService(WorkflowEngine3.WorkflowEngine, engine), Effect19.mapError((e) => new QueueError({ message: e instanceof Error ? e.message : String(e) })));
+    yield* def.workflow.execute(envelope, { discard: true }).pipe(Effect19.provideService(WorkflowEngine3.WorkflowEngine, engine), Effect19.mapError((e) => jobsError(jobId, e)));
     return jobId;
   });
-  const wait = Effect18.fn("JobRuntime.wait")(function* (jobId, options) {
+  const wait = Effect19.fn("JobRuntime.wait")(function* (jobId, options) {
     const timeout = Duration2.fromInput(options?.timeout ?? DEFAULT_TIMEOUT).pipe(Option5.getOrElse(() => Duration2.minutes(5)));
     const pollInterval = Duration2.fromInput(options?.pollInterval ?? DEFAULT_POLL_INTERVAL).pipe(Option5.getOrElse(() => Duration2.millis(250)));
-    const deadline = yield* Clock2.currentTimeMillis.pipe(Effect18.map((now) => now + Duration2.toMillis(timeout)));
-    while (true) {
-      if (yield* readMarker(store, jobId, CANCELLED)) {
-        return yield* Effect18.fail(new JobCancelled({ jobId }));
-      }
-      const def = yield* findDef(defs, jobId, store);
-      if (def) {
-        const result = yield* readWorkflowResult(store, def.workflow, jobId);
-        if (Option5.isSome(result)) {
-          const r = result.value;
-          if (r._tag === "Complete") {
-            if (Exit5.isSuccess(r.exit))
-              return r.exit.value;
-            const failure = Exit5.getCause(r.exit).pipe(Option5.flatMap(Cause2.findErrorOption), Option5.map((e) => typeof e === "string" ? e : String(e)));
-            return yield* Effect18.fail(new JobFailed({
-              jobId,
-              message: Option5.getOrElse(failure, () => "workflow failed")
-            }));
+    const deadline = yield* Clock2.currentTimeMillis.pipe(Effect19.map((now) => now + Duration2.toMillis(timeout)));
+    const completionSignal = yield* Deferred2.make();
+    onExecutionDone(jobId, completionSignal);
+    try {
+      while (true) {
+        if (yield* readMarker(store, jobId, CANCELLED)) {
+          return yield* Effect19.fail(new JobCancelled({ jobId }));
+        }
+        const def = yield* findDef(defs, jobId, store);
+        if (def) {
+          const result = yield* readWorkflowResult(store, def.workflow, jobId);
+          if (Option5.isSome(result)) {
+            const r = result.value;
+            if (r._tag === "Complete") {
+              if (Exit6.isSuccess(r.exit))
+                return r.exit.value;
+              const failure = Exit6.getCause(r.exit).pipe(Option5.flatMap(Cause2.findErrorOption), Option5.map((e) => typeof e === "string" ? e : String(e)));
+              return yield* Effect19.fail(new JobFailed({
+                jobId,
+                message: Option5.getOrElse(failure, () => "workflow failed")
+              }));
+            }
           }
         }
+        const now = yield* Clock2.currentTimeMillis;
+        if (now >= deadline) {
+          yield* writeMarker(store, jobId, TIMED_OUT);
+          return yield* Effect19.fail(new JobTimeout({ jobId, timeout }));
+        }
+        yield* Effect19.race(Deferred2.await(completionSignal).pipe(Effect19.asVoid), Effect19.sleep(pollInterval));
       }
-      const now = yield* Clock2.currentTimeMillis;
-      if (now >= deadline) {
-        yield* writeMarker(store, jobId, TIMED_OUT);
-        return yield* Effect18.fail(new JobTimeout({ jobId, timeout }));
-      }
-      yield* Effect18.sleep(pollInterval);
+    } finally {
+      offExecutionDone(jobId, completionSignal);
     }
   });
-  const submit = Effect18.fn("JobRuntime.submit")(function* (def, payload) {
+  const submit = Effect19.fn("JobRuntime.submit")(function* (def, payload) {
     const jobId = yield* enqueue(def, payload);
     return yield* wait(jobId);
   });
-  const status = Effect18.fn("JobRuntime.status")(function* (jobId) {
+  const status = Effect19.fn("JobRuntime.status")(function* (jobId) {
     if (yield* readMarker(store, jobId, CANCELLED))
       return "cancelled";
     if (yield* readMarker(store, jobId, TIMED_OUT))
@@ -3062,35 +3348,35 @@ var layer6 = (defs) => Layer7.effect(Service7, Effect18.gen(function* () {
       if (Option5.isSome(result)) {
         const r = result.value;
         if (r._tag === "Complete") {
-          return Exit5.isSuccess(r.exit) ? "succeeded" : "failed";
+          return Exit6.isSuccess(r.exit) ? "succeeded" : "failed";
         }
       }
     }
     return "pending";
   });
-  const cancel = Effect18.fn("JobRuntime.cancel")(function* (jobId) {
+  const cancel = Effect19.fn("JobRuntime.cancel")(function* (jobId) {
     yield* writeMarker(store, jobId, CANCELLED);
     return true;
   });
-  const processPending = Effect18.fn("JobRuntime.processPending")(function* (options) {
+  const processPending = Effect19.fn("JobRuntime.processPending")(function* (options) {
     const resumeQueue = yield* queueFactory.make({ name: RESUME_QUEUE, schema: ResumeSignal });
     const window = Duration2.toMillis(Duration2.fromInput(options?.window ?? PROCESS_WINDOW).pipe(Option5.getOrElse(() => Duration2.seconds(30))));
-    const deadline = yield* Clock2.currentTimeMillis.pipe(Effect18.map((now) => now + window));
+    const deadline = yield* Clock2.currentTimeMillis.pipe(Effect19.map((now) => now + window));
     let processed = 0;
     while (true) {
       const now = yield* Clock2.currentTimeMillis;
       if (now >= deadline)
         break;
-      const signal = yield* resumeQueue.take((value2, _meta) => Effect18.succeed(Option5.some(value2)), { maxAttempts: 1 }).pipe(Effect18.mapError((e) => new QueueError({ message: e instanceof Error ? e.message : String(e) })), Effect18.timeoutOrElse({
+      const signal = yield* resumeQueue.take((value2, _meta) => Effect19.succeed(Option5.some(value2)), { maxAttempts: 1 }).pipe(Effect19.mapError((e) => new QueueError({ message: e instanceof Error ? e.message : String(e) })), Effect19.timeoutOrElse({
         duration: Duration2.millis(100),
-        orElse: () => Effect18.succeed(Option5.none())
+        orElse: () => Effect19.succeed(Option5.none())
       }));
       if (Option5.isNone(signal))
         continue;
       const executionId = signal.value.executionId;
       const def = yield* findDef(defs, executionId, store);
       if (def) {
-        yield* engine.resume(def.workflow, executionId).pipe(Effect18.orDie);
+        yield* engine.resume(def.workflow, executionId).pipe(Effect19.orDie);
         processed++;
       }
     }
@@ -3098,16 +3384,16 @@ var layer6 = (defs) => Layer7.effect(Service7, Effect18.gen(function* () {
   });
   return Service7.of({ enqueue, wait, submit, status, cancel, processPending });
 }));
-var findDef = (defs, executionId, store) => Effect18.gen(function* () {
+var findDef = (defs, executionId, store) => Effect19.gen(function* () {
   const persisted = yield* getEncodedExit(store, `${executionId}/record`);
-  if (!persisted || !Exit5.isSuccess(persisted))
+  if (!persisted || !Exit6.isSuccess(persisted))
     return;
-  const record = yield* Effect18.orDie(Schema14.decodeUnknownEffect(ExecutionRecord)(persisted.value));
+  const record = yield* Effect19.orDie(Schema14.decodeUnknownEffect(ExecutionRecord)(persisted.value));
   return defs.find((d) => d.workflow._tag === record.workflowTag);
 });
 var layerLibsql = (defs, options) => layer6(defs).pipe(Layer7.provideMerge(Layer7.mergeAll(layerDurableLibsql(options), libsqlStack(options))));
 // ../workflow/src/registry.ts
-import { Context as Context8, Effect as Effect19, Layer as Layer8, Option as Option6, Ref, Schema as Schema15 } from "effect";
+import { Context as Context8, Effect as Effect20, Layer as Layer8, Option as Option6, Ref, Schema as Schema15 } from "effect";
 class JobFailure extends Schema15.TaggedErrorClass()("JobFailure", {
   jobId: Schema15.String,
   message: Schema15.String
@@ -3116,9 +3402,9 @@ class JobFailure extends Schema15.TaggedErrorClass()("JobFailure", {
 
 class Service8 extends Context8.Service()("@dimple/workflow/JobRegistry") {
 }
-var layer7 = Layer8.effect(Service8, Effect19.gen(function* () {
+var layer7 = Layer8.effect(Service8, Effect20.gen(function* () {
   const handlers = yield* Ref.make(new Map);
-  const register = Effect19.fn("JobRegistry.register")(function* (type, handler) {
+  const register = Effect20.fn("JobRegistry.register")(function* (type, handler) {
     const existed = yield* Ref.modify(handlers, (map2) => {
       if (map2.has(type)) {
         return [true, map2];
@@ -3126,46 +3412,46 @@ var layer7 = Layer8.effect(Service8, Effect19.gen(function* () {
       return [false, new Map(map2).set(type, handler)];
     });
     if (existed) {
-      return yield* Effect19.fail(new RegistryError({ type, message: `Job type already registered: ${type}` }));
+      return yield* Effect20.fail(new RegistryError({ type, message: `Job type already registered: ${type}` }));
     }
   });
-  const resolve = Effect19.fn("JobRegistry.resolve")(function* (type) {
-    const handler = yield* Ref.get(handlers).pipe(Effect19.map((map2) => Option6.fromNullishOr(map2.get(type))));
+  const resolve = Effect20.fn("JobRegistry.resolve")(function* (type) {
+    const handler = yield* Ref.get(handlers).pipe(Effect20.map((map2) => Option6.fromNullishOr(map2.get(type))));
     if (Option6.isNone(handler)) {
-      return yield* Effect19.fail(new UnknownJobType({ type }));
+      return yield* Effect20.fail(new UnknownJobType({ type }));
     }
     return handler.value;
   });
   return Service8.of({ register, resolve });
 }));
 // ../workflow/src/executor.ts
-import { Cause as Cause3, Duration as Duration3, Effect as Effect20, Layer as Layer9, Schedule as Schedule2 } from "effect";
+import { Cause as Cause3, Duration as Duration3, Effect as Effect21, Layer as Layer9, Schedule as Schedule2 } from "effect";
 import { DurableQueue as DurableQueue2, WorkflowEngine as WorkflowEngine4 } from "effect/unstable/workflow";
-var runHandler = (def, payload, jobId, maxAttempts) => Effect20.gen(function* () {
+var runHandler = (def, payload, jobId, maxAttempts) => Effect21.gen(function* () {
   const registry = yield* Service8;
   const handler = yield* registry.resolve(def.name);
-  yield* Effect20.logInfo("job.started").pipe(Effect20.annotateLogs({
+  yield* Effect21.logInfo("job.started").pipe(Effect21.annotateLogs({
     scope: "@dimple/workflow",
     event: "job.started",
     job: def.name,
     idempotencyKey: jobId
   }));
   const run = () => handler(payload, { jobId });
-  const outcome = yield* (maxAttempts > 1 ? run().pipe(Effect20.retry({
+  const outcome = yield* (maxAttempts > 1 ? run().pipe(Effect21.retry({
     times: maxAttempts - 1,
     schedule: Schedule2.spaced(Duration3.millis(250)).pipe(Schedule2.jittered)
-  })) : run()).pipe(Effect20.exit);
+  })) : run()).pipe(Effect21.exit);
   if (outcome._tag === "Failure") {
-    yield* Effect20.logError("job.failed").pipe(Effect20.annotateLogs({
+    yield* Effect21.logError("job.failed").pipe(Effect21.annotateLogs({
       scope: "@dimple/workflow",
       event: "job.failed",
       job: def.name,
       idempotencyKey: jobId,
       error: Cause3.pretty(outcome.cause)
     }));
-    return yield* Effect20.failCause(outcome.cause).pipe(Effect20.mapError((e) => e.message));
+    return yield* Effect21.failCause(outcome.cause).pipe(Effect21.mapError((e) => e.message));
   }
-  yield* Effect20.logInfo("job.completed").pipe(Effect20.annotateLogs({
+  yield* Effect21.logInfo("job.completed").pipe(Effect21.annotateLogs({
     scope: "@dimple/workflow",
     event: "job.completed",
     job: def.name,
@@ -3198,17 +3484,17 @@ var JobsConfig2 = Schema16.Struct({
   pollIntervalMs: Schema16.optional(Schema16.Number)
 });
 // ../store/src/topics/lifecycle.ts
-var routingFailure3 = (tag) => (effect) => effect.pipe(Effect21.mapError((cause) => new RoutingFailure({ cause: { operation: tag, cause } })));
-var isActive = Effect21.fn("topics.isActive")(function* (modelKey) {
+var routingFailure3 = (tag) => (effect) => effect.pipe(Effect22.mapError((cause) => new RoutingFailure({ cause: { operation: tag, cause } })));
+var isActive = Effect22.fn("topics.isActive")(function* (modelKey) {
   const backend = yield* Service2;
   const db = backend.db;
-  const rows = yield* Effect21.tryPromise({
+  const rows = yield* Effect22.tryPromise({
     try: () => db.select({ topicKey: topics.topicKey }).from(topics).where(and3(eq3(topics.modelKey, modelKey), eq3(topics.status, "active"))).limit(1),
     catch: (cause) => cause
   }).pipe(routingFailure3("topics.isActive"));
   return rows.length > 0;
 });
-var setActiveModel = Effect21.fn("topics.setActiveModel")(function* (model, config) {
+var setActiveModel = Effect22.fn("topics.setActiveModel")(function* (model, config) {
   const backend = yield* Service2;
   const db = backend.db;
   yield* ensureTopicTree(model, config).pipe(routingFailure3("topics.setActiveModel.seed"));
@@ -3216,14 +3502,14 @@ var setActiveModel = Effect21.fn("topics.setActiveModel")(function* (model, conf
   let routed = 0;
   let alreadyInTree = 0;
   if (memoryIds.length > 0) {
-    const topicRows = yield* Effect21.tryPromise({
+    const topicRows = yield* Effect22.tryPromise({
       try: () => db.select({ topicKey: topics.topicKey }).from(topics).where(eq3(topics.modelKey, model.id)),
       catch: (cause) => cause
     }).pipe(routingFailure3("topics.setActiveModel.topics"));
     const modelTopicKeys = topicRows.map((r) => r.topicKey);
     if (modelTopicKeys.length > 0) {
       for (const memoryId of memoryIds) {
-        const existing = yield* Effect21.tryPromise({
+        const existing = yield* Effect22.tryPromise({
           try: () => db.select({ topicKey: topicMemberships.topicKey }).from(topicMemberships).where(and3(eq3(topicMemberships.memoryId, memoryId), eq3(topicMemberships.modelKey, model.id), inArray(topicMemberships.topicKey, modelTopicKeys))).limit(1),
           catch: (cause) => cause
         }).pipe(routingFailure3("topics.setActiveModel.membership"));
@@ -3241,7 +3527,7 @@ var setActiveModel = Effect21.fn("topics.setActiveModel")(function* (model, conf
     }
   }
   const auditTimestamp = yield* Clock3.currentTimeMillis;
-  const deactivated = yield* Effect21.tryPromise({
+  const deactivated = yield* Effect22.tryPromise({
     try: () => db.transaction(async (tx) => {
       const others = await tx.selectDistinct({ modelKey: topics.modelKey }).from(topics).where(and3(ne(topics.modelKey, model.id), ne(topics.status, "inactive")));
       const affected = others.map((r) => r.modelKey).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
@@ -3265,18 +3551,18 @@ var setActiveModel = Effect21.fn("topics.setActiveModel")(function* (model, conf
   return { routed, alreadyInTree, deactivated };
 });
 function memoryEmbedHandler(deps) {
-  const run = (payload, ctx) => Effect21.gen(function* () {
+  const run = (payload, ctx) => Effect22.gen(function* () {
     const envelope = payload;
     const model = deps.getModelConfig(envelope.modelKey);
     if (!model) {
-      return yield* Effect21.fail(new JobFailure({
+      return yield* Effect22.fail(new JobFailure({
         jobId: ctx.jobId,
         message: `memory.embed: unknown model "${envelope.modelKey}"`
       }));
     }
-    const content = yield* deps.getMemoryContent(envelope.memoryId).pipe(Effect21.catchTag("Store.NotFound", () => Effect21.succeed(undefined)), Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: load content: ${e}` })));
+    const content = yield* deps.getMemoryContent(envelope.memoryId).pipe(Effect22.catchTag("Store.NotFound", () => Effect22.succeed(undefined)), Effect22.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: load content: ${e}` })));
     if (content === undefined) {
-      yield* Effect21.logDebug("embed.stale-reoffer").pipe(Effect21.annotateLogs({
+      yield* Effect22.logDebug("embed.stale-reoffer").pipe(Effect22.annotateLogs({
         scope: "@dimple/store",
         event: "embed.stale-reoffer",
         memoryId: envelope.memoryId,
@@ -3284,20 +3570,20 @@ function memoryEmbedHandler(deps) {
       }));
       return;
     }
-    const vector = yield* deps.embedOne(content, model).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: embed: ${e}` })));
+    const vector = yield* deps.embedOne(content, model).pipe(Effect22.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: embed: ${e}` })));
     const backend = yield* Service2;
     const db = backend.db;
-    const existing = yield* Effect21.tryPromise({
+    const existing = yield* Effect22.tryPromise({
       try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(and3(eq3(topicMemberships.memoryId, envelope.memoryId), eq3(topicMemberships.modelKey, model.id))),
       catch: (cause) => new StoreError({ message: `memory.embed: membership check: ${cause}` })
-    }).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: membership check: ${e}` })));
-    yield* ensureTopicTree(model, deps.config).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: seed tree: ${e}` })));
-    yield* backend.ensureVectorTable(model).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: vector table: ${e}` })));
-    yield* backend.insertVector(envelope.memoryId, [...vector], model).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: insert vector: ${e}` })));
+    }).pipe(Effect22.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: membership check: ${e}` })));
+    yield* ensureTopicTree(model, deps.config).pipe(Effect22.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: seed tree: ${e}` })));
+    yield* backend.ensureVectorTable(model).pipe(Effect22.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: vector table: ${e}` })));
+    yield* backend.insertVector(envelope.memoryId, [...vector], model).pipe(Effect22.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: insert vector: ${e}` })));
     if (existing.length === 0) {
-      yield* routeInsert(envelope.memoryId, [...vector], model, deps.config).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: route: ${e}` })));
+      yield* routeInsert(envelope.memoryId, [...vector], model, deps.config).pipe(Effect22.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: route: ${e}` })));
     }
-    yield* Effect21.logInfo("embed.completed").pipe(Effect21.annotateLogs({
+    yield* Effect22.logInfo("embed.completed").pipe(Effect22.annotateLogs({
       scope: "@dimple/store",
       event: "embed.completed",
       memoryId: envelope.memoryId,
@@ -3306,11 +3592,11 @@ function memoryEmbedHandler(deps) {
     }));
     return;
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect21.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect22.provideService(Service2, deps.backend)) : run;
 }
 
 // ../store/src/topics/jobs.ts
-import { Clock as Clock4, Effect as Effect22 } from "effect";
+import { Clock as Clock4, Effect as Effect23 } from "effect";
 import { and as and4, asc as asc3, eq as eq4, inArray as inArray2, sql as sql4 } from "drizzle-orm";
 
 // ../store/src/topics/topic-vectors.ts
@@ -3334,23 +3620,28 @@ var DEFAULT_SPLIT_DEFERRED_HARD_LIMIT = 512;
 var shouldSplit = (leafMemberCount, config) => leafMemberCount > (config.maxLeafItems ?? DEFAULT_MAX_LEAF_ITEMS);
 var childBaseKey = (parent, vectors) => {
   const dims = vectors.length > 0 ? vectors[0].length : 0;
-  const parts = [];
+  let hash = 2166136261;
+  const step = (byte) => {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619);
+  };
+  for (let i = 0;i < parent.length; i++)
+    step(parent.charCodeAt(i) & 255);
+  step(255);
   for (const v of vectors) {
-    const bytes = [];
-    for (let i = 0;i < dims; i++) {
-      bytes.push(String(v[i]));
-    }
-    parts.push(bytes.join(","));
+    const bytes = new Uint8Array(v.buffer, v.byteOffset, dims * 4);
+    for (let i = 0;i < bytes.length; i++)
+      step(bytes[i]);
   }
-  return `t_${fnv1a32(JSON.stringify({ parent, members: parts })).toString(16).padStart(8, "0")}`;
+  return `t_${(hash >>> 0).toString(16).padStart(8, "0")}`;
 };
-var splitTopic = Effect22.fn("TopicSplit.splitTopic")(function* (topicKey, model, config) {
+var splitTopic = Effect23.fn("TopicSplit.splitTopic")(function* (topicKey, model, config) {
   const backend = yield* Service2;
   const db = backend.db;
   yield* backend.ensureTopicVectorTable(model);
   const maxLeafItems = config.maxLeafItems ?? DEFAULT_MAX_LEAF_ITEMS;
   const hardLimit = config.splitDeferredHardLimit ?? DEFAULT_SPLIT_DEFERRED_HARD_LIMIT;
-  const leafRows = yield* Effect22.tryPromise({
+  const leafRows = yield* Effect23.tryPromise({
     try: () => db.select().from(topics).where(and4(eq4(topics.topicKey, topicKey), eq4(topics.modelKey, model.id))),
     catch: (cause) => new StoreError({ message: `splitTopic: load topic: ${cause}` })
   });
@@ -3361,13 +3652,13 @@ var splitTopic = Effect22.fn("TopicSplit.splitTopic")(function* (topicKey, model
   if (leaf.modelKey !== model.id) {
     return yield* new ModelMismatch({ expected: model.id, actual: leaf.modelKey });
   }
-  const memberRows = yield* Effect22.tryPromise({
+  const memberRows = yield* Effect23.tryPromise({
     try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(and4(eq4(topicMemberships.topicKey, topicKey), eq4(topicMemberships.modelKey, model.id))).orderBy(asc3(topicMemberships.memoryId)),
     catch: (cause) => new StoreError({ message: `splitTopic: load members: ${cause}` })
   });
   const memberIds = memberRows.map((r) => r.memoryId);
   const memberCount = memberIds.length;
-  const growthRows = yield* Effect22.tryPromise({
+  const growthRows = yield* Effect23.tryPromise({
     try: () => db.select().from(topicGrowthState).where(and4(eq4(topicGrowthState.topicKey, topicKey), eq4(topicGrowthState.modelKey, model.id))),
     catch: (cause) => new StoreError({ message: `splitTopic: load growth state: ${cause}` })
   });
@@ -3399,7 +3690,7 @@ var splitTopic = Effect22.fn("TopicSplit.splitTopic")(function* (topicKey, model
   const forced = memberCount > hardLimit;
   if (!plan.accepted && !forced) {
     const now2 = yield* Clock4.currentTimeMillis;
-    yield* Effect22.tryPromise({
+    yield* Effect23.tryPromise({
       try: () => db.transaction(async (tx) => {
         await tx.insert(topicGrowthState).values({
           topicKey,
@@ -3432,7 +3723,7 @@ var splitTopic = Effect22.fn("TopicSplit.splitTopic")(function* (topicKey, model
     };
   }
   const now = yield* Clock4.currentTimeMillis;
-  const children = yield* Effect22.tryPromise({
+  const children = yield* Effect23.tryPromise({
     try: () => db.transaction(async (tx) => {
       const child0Cf = cfFromVectors(groupVectors(0));
       const child1Cf = cfFromVectors(groupVectors(1));
@@ -3553,34 +3844,34 @@ var splitTopic = Effect22.fn("TopicSplit.splitTopic")(function* (topicKey, model
   });
   return { accepted: true, children: children.keys, childCounts: children.counts };
 });
-var staleSplitNoOp = (notFound, model) => Effect22.gen(function* () {
+var staleSplitNoOp = (notFound, model) => Effect23.gen(function* () {
   const backend = yield* Service2;
   const db = backend.db;
-  const rows = yield* Effect22.tryPromise({
+  const rows = yield* Effect23.tryPromise({
     try: () => db.select({ topicKey: topics.topicKey }).from(topics).where(and4(eq4(topics.topicKey, notFound.topicKey), eq4(topics.modelKey, model.id))),
     catch: (cause) => new StoreError({ message: `topic.split: stale check: ${cause}` })
   });
   if (rows.length > 0) {
     return { accepted: false, reason: "no-improvement" };
   }
-  return yield* Effect22.fail(notFound);
+  return yield* Effect23.fail(notFound);
 });
 function topicSplitHandler(deps) {
-  const run = (payload, ctx) => Effect22.gen(function* () {
+  const run = (payload, ctx) => Effect23.gen(function* () {
     const envelope = payload;
     const model = deps.getModelConfig(envelope.modelKey);
     if (!model) {
-      return yield* Effect22.fail(new JobFailure({
+      return yield* Effect23.fail(new JobFailure({
         jobId: ctx.jobId,
         message: `topic.split: unknown model "${envelope.modelKey}"`
       }));
     }
-    const outcome = yield* splitTopic(envelope.topicId, model, deps.config).pipe(Effect22.catchIf((error) => error._tag === "topics.TopicNotFound", (notFound) => staleSplitNoOp(notFound, model)), Effect22.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `${error}` })));
+    const outcome = yield* splitTopic(envelope.topicId, model, deps.config).pipe(Effect23.catchIf((error) => error._tag === "topics.TopicNotFound", (notFound) => staleSplitNoOp(notFound, model)), Effect23.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `${error}` })));
     if (outcome.accepted && deps.onUnevenSplit) {
       const [n0, n1] = outcome.childCounts;
       const [k0] = outcome.children;
       if (Math.max(n0, n1) > 2 * Math.min(n0, n1)) {
-        yield* deps.onUnevenSplit(k0, envelope.modelKey).pipe(Effect22.mapError((error) => new JobFailure({
+        yield* deps.onUnevenSplit(k0, envelope.modelKey).pipe(Effect23.mapError((error) => new JobFailure({
           jobId: ctx.jobId,
           message: `topic.split: enqueue rebalance: ${error}`
         })));
@@ -3590,14 +3881,14 @@ function topicSplitHandler(deps) {
       const maxLeafItems = deps.config.maxLeafItems ?? DEFAULT_MAX_LEAF_ITEMS;
       for (let i = 0;i < outcome.children.length; i++) {
         if (outcome.childCounts[i] > maxLeafItems) {
-          yield* deps.onChildOverflow(outcome.children[i], envelope.modelKey).pipe(Effect22.mapError((error) => new JobFailure({
+          yield* deps.onChildOverflow(outcome.children[i], envelope.modelKey).pipe(Effect23.mapError((error) => new JobFailure({
             jobId: ctx.jobId,
             message: `topic.split: enqueue child split: ${error}`
           })));
         }
       }
     }
-    yield* Effect22.logInfo("split.completed").pipe(Effect22.annotateLogs({
+    yield* Effect23.logInfo("split.completed").pipe(Effect23.annotateLogs({
       scope: "@dimple/store",
       event: "split.completed",
       topicId: envelope.topicId,
@@ -3607,16 +3898,16 @@ function topicSplitHandler(deps) {
     }));
     return;
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect22.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect23.provideService(Service2, deps.backend)) : run;
 }
 
 // ../store/src/topics/maintenance.ts
-import { Clock as Clock5, Effect as Effect23 } from "effect";
+import { Clock as Clock5, Effect as Effect24 } from "effect";
 import { and as and5, asc as asc4, eq as eq5, ne as ne2 } from "drizzle-orm";
 var DEFAULT_MIN_LEAF_ITEMS = 32;
 var DEFAULT_MAX_LEAF_ITEMS2 = 128;
 var DEFAULT_REBALANCE_COOLDOWN_MS = 60000;
-var maintenanceError = (tag) => (effect) => effect.pipe(Effect23.mapError((cause) => new StoreError({ message: `${tag}: ${cause}` })));
+var maintenanceError = (tag) => (effect) => effect.pipe(Effect24.mapError((cause) => new StoreError({ message: `${tag}: ${cause}` })));
 var dot2 = (a, b) => {
   let sum = 0;
   for (let i = 0;i < a.length; i++)
@@ -3634,12 +3925,12 @@ var resolvedConfig2 = (config) => ({
   maxLeafItems: config.maxLeafItems ?? DEFAULT_MAX_LEAF_ITEMS2,
   rebalanceCooldownMs: config.rebalanceCooldownMs ?? DEFAULT_REBALANCE_COOLDOWN_MS
 });
-var mergeOrBorrow = Effect23.fn("topics.mergeOrBorrow")(function* (topicKey, model, config) {
+var mergeOrBorrow = Effect24.fn("topics.mergeOrBorrow")(function* (topicKey, model, config) {
   const backend = yield* Service2;
   const db = backend.db;
   const { minLeafItems, maxLeafItems } = resolvedConfig2(config);
   const now = yield* Clock5.currentTimeMillis;
-  const leafRows = yield* Effect23.tryPromise({
+  const leafRows = yield* Effect24.tryPromise({
     try: () => db.select().from(topics).where(and5(eq5(topics.topicKey, topicKey), eq5(topics.modelKey, model.id))),
     catch: (cause) => new StoreError({ message: `mergeOrBorrow: load topic: ${cause}` })
   });
@@ -3652,7 +3943,7 @@ var mergeOrBorrow = Effect23.fn("topics.mergeOrBorrow")(function* (topicKey, mod
   }
   if (leaf.memberCount >= minLeafItems)
     return { action: "none" };
-  const parentRows = yield* Effect23.tryPromise({
+  const parentRows = yield* Effect24.tryPromise({
     try: () => db.select({ parentKey: topicRelations.parentKey }).from(topicRelations).where(and5(eq5(topicRelations.childKey, topicKey), eq5(topicRelations.modelKey, model.id), eq5(topicRelations.relationKind, "parent_child"))).orderBy(asc4(topicRelations.parentKey)),
     catch: (cause) => new StoreError({ message: `mergeOrBorrow: load parent: ${cause}` })
   });
@@ -3660,16 +3951,16 @@ var mergeOrBorrow = Effect23.fn("topics.mergeOrBorrow")(function* (topicKey, mod
     return yield* logUnderfilled(db, topicKey, model, now, "no-borrowable");
   }
   const parentKey = parentRows[0].parentKey;
-  const parentRowRows = yield* Effect23.tryPromise({
+  const parentRowRows = yield* Effect24.tryPromise({
     try: () => db.select({ childCount: topics.childCount }).from(topics).where(and5(eq5(topics.topicKey, parentKey), eq5(topics.modelKey, model.id))),
     catch: (cause) => new StoreError({ message: `mergeOrBorrow: load parent row: ${cause}` })
   });
   const parentRow = parentRowRows[0];
-  const siblingRows = yield* Effect23.tryPromise({
+  const siblingRows = yield* Effect24.tryPromise({
     try: () => db.select().from(topics).where(and5(eq5(topics.modelKey, model.id), eq5(topics.kind, "leaf"), ne2(topics.status, "inactive"))).orderBy(asc4(topics.topicKey)),
     catch: (cause) => new StoreError({ message: `mergeOrBorrow: load siblings: ${cause}` })
   });
-  const relationRows = yield* Effect23.tryPromise({
+  const relationRows = yield* Effect24.tryPromise({
     try: () => db.select({ childKey: topicRelations.childKey }).from(topicRelations).where(and5(eq5(topicRelations.parentKey, parentKey), eq5(topicRelations.modelKey, model.id), eq5(topicRelations.relationKind, "parent_child"))).orderBy(asc4(topicRelations.childKey)),
     catch: (cause) => new StoreError({ message: `mergeOrBorrow: load relations: ${cause}` })
   });
@@ -3691,7 +3982,7 @@ var mergeOrBorrow = Effect23.fn("topics.mergeOrBorrow")(function* (topicKey, mod
   const membersByTopic = new Map;
   const vecById = new Map;
   for (const sibling of siblingsOf) {
-    const members = yield* Effect23.tryPromise({
+    const members = yield* Effect24.tryPromise({
       try: () => db.select({
         memoryId: topicMemberships.memoryId,
         manualLock: topicMemberships.manualLock
@@ -3704,7 +3995,7 @@ var mergeOrBorrow = Effect23.fn("topics.mergeOrBorrow")(function* (topicKey, mod
       vecById.set(row.memoryId, new Float32Array(row.vector));
   }
   const movedIds = new Set;
-  const outcome = yield* Effect23.tryPromise({
+  const outcome = yield* Effect24.tryPromise({
     try: () => db.transaction(async (tx) => {
       const leafCf0 = cfOf(leaf);
       let leafCf = leafCf0;
@@ -3820,7 +4111,36 @@ var mergeOrBorrow = Effect23.fn("topics.mergeOrBorrow")(function* (topicKey, mod
       await tx.delete(topicRelations).where(and5(eq5(topicRelations.parentKey, parentKey), eq5(topicRelations.childKey, sibling.topicKey), eq5(topicRelations.modelKey, model.id)));
       await deleteTopicVectorRow(tx, model, sibling.topicKey);
       await writeTopicVector(tx, model, topicKey, mergedCf.ls);
-      await tx.update(topics).set({ childCount: Math.max(0, (parentRow?.childCount ?? 1) - 1), updatedAt: now }).where(and5(eq5(topics.topicKey, parentKey), eq5(topics.modelKey, model.id)));
+      const remainingChildren = Math.max(0, (parentRow?.childCount ?? 1) - 1);
+      await tx.update(topics).set({ childCount: remainingChildren, updatedAt: now }).where(and5(eq5(topics.topicKey, parentKey), eq5(topics.modelKey, model.id)));
+      if (remainingChildren === 1) {
+        const grandparentRows = await tx.select({ parentKey: topicRelations.parentKey }).from(topicRelations).where(and5(eq5(topicRelations.childKey, parentKey), eq5(topicRelations.modelKey, model.id), eq5(topicRelations.relationKind, "parent_child"))).limit(1);
+        const grandparentKey = grandparentRows[0]?.parentKey;
+        if (grandparentKey !== undefined) {
+          await tx.delete(topicRelations).where(and5(eq5(topicRelations.parentKey, parentKey), eq5(topicRelations.childKey, topicKey), eq5(topicRelations.modelKey, model.id)));
+          await tx.delete(topicRelations).where(and5(eq5(topicRelations.parentKey, grandparentKey), eq5(topicRelations.childKey, parentKey), eq5(topicRelations.modelKey, model.id)));
+          await tx.insert(topicRelations).values({
+            parentKey: grandparentKey,
+            childKey: topicKey,
+            modelKey: model.id,
+            relationKind: "parent_child",
+            updatedAt: now
+          });
+          await tx.update(topics).set({
+            status: "inactive",
+            memberCount: 0,
+            sumSquares: 0,
+            childCount: 0,
+            updatedAt: now
+          }).where(and5(eq5(topics.topicKey, parentKey), eq5(topics.modelKey, model.id)));
+          await deleteTopicVectorRow(tx, model, parentKey);
+          const grandparentDepthRows = await tx.select({ depth: topics.depth }).from(topics).where(and5(eq5(topics.topicKey, grandparentKey), eq5(topics.modelKey, model.id))).limit(1);
+          await tx.update(topics).set({
+            depth: (grandparentDepthRows[0]?.depth ?? 0) + 1,
+            updatedAt: now
+          }).where(and5(eq5(topics.topicKey, topicKey), eq5(topics.modelKey, model.id)));
+        }
+      }
       await tx.insert(topicGrowthState).values({
         topicKey,
         modelKey: model.id,
@@ -3844,12 +4164,12 @@ var mergeOrBorrow = Effect23.fn("topics.mergeOrBorrow")(function* (topicKey, mod
   });
   return outcome;
 });
-var rebalanceSiblings = Effect23.fn("topics.rebalanceSiblings")(function* (topicKey, model, config) {
+var rebalanceSiblings = Effect24.fn("topics.rebalanceSiblings")(function* (topicKey, model, config) {
   const backend = yield* Service2;
   const db = backend.db;
   const { rebalanceCooldownMs } = resolvedConfig2(config);
   const now = yield* Clock5.currentTimeMillis;
-  const rows = yield* Effect23.tryPromise({
+  const rows = yield* Effect24.tryPromise({
     try: () => db.select().from(topics).where(and5(eq5(topics.topicKey, topicKey), eq5(topics.modelKey, model.id))),
     catch: (cause) => new StoreError({ message: `rebalanceSiblings: load topic: ${cause}` })
   });
@@ -3858,19 +4178,19 @@ var rebalanceSiblings = Effect23.fn("topics.rebalanceSiblings")(function* (topic
     return yield* new TopicNotFound({ topicKey });
   if (row.modelKey !== model.id)
     return yield* new ModelMismatch({ expected: model.id, actual: row.modelKey });
-  const parentRows = yield* Effect23.tryPromise({
+  const parentRows = yield* Effect24.tryPromise({
     try: () => db.select({ parentKey: topicRelations.parentKey }).from(topicRelations).where(and5(eq5(topicRelations.childKey, topicKey), eq5(topicRelations.modelKey, model.id), eq5(topicRelations.relationKind, "parent_child"))).orderBy(asc4(topicRelations.parentKey)),
     catch: (cause) => new StoreError({ message: `rebalanceSiblings: load parent: ${cause}` })
   });
   if (parentRows.length === 0)
     return { action: "none", reason: "balanced" };
   const parentKey = parentRows[0].parentKey;
-  const relationRows = yield* Effect23.tryPromise({
+  const relationRows = yield* Effect24.tryPromise({
     try: () => db.select({ childKey: topicRelations.childKey }).from(topicRelations).where(and5(eq5(topicRelations.parentKey, parentKey), eq5(topicRelations.modelKey, model.id), eq5(topicRelations.relationKind, "parent_child"))).orderBy(asc4(topicRelations.childKey)),
     catch: (cause) => new StoreError({ message: `rebalanceSiblings: load relations: ${cause}` })
   });
   const siblingKeys = relationRows.map((r) => r.childKey);
-  const topicRows = yield* Effect23.tryPromise({
+  const topicRows = yield* Effect24.tryPromise({
     try: () => db.select().from(topics).where(and5(eq5(topics.modelKey, model.id), eq5(topics.kind, "leaf"), ne2(topics.status, "inactive"))),
     catch: (cause) => new StoreError({ message: `rebalanceSiblings: load siblings: ${cause}` })
   });
@@ -3878,7 +4198,7 @@ var rebalanceSiblings = Effect23.fn("topics.rebalanceSiblings")(function* (topic
   const siblings = siblingKeys.map((k) => map2.get(k)).filter(Boolean);
   if (siblings.length < 2)
     return { action: "none", reason: "balanced" };
-  const growthRows = yield* Effect23.tryPromise({
+  const growthRows = yield* Effect24.tryPromise({
     try: () => db.select().from(topicGrowthState).where(and5(eq5(topicGrowthState.topicKey, topicKey), eq5(topicGrowthState.modelKey, model.id))),
     catch: (cause) => new StoreError({ message: `rebalanceSiblings: load growth: ${cause}` })
   });
@@ -3903,7 +4223,7 @@ var rebalanceSiblings = Effect23.fn("topics.rebalanceSiblings")(function* (topic
   const membersByTopic = new Map;
   const vecById = new Map;
   for (const sibling of siblings) {
-    const members = yield* Effect23.tryPromise({
+    const members = yield* Effect24.tryPromise({
       try: () => db.select({
         memoryId: topicMemberships.memoryId,
         manualLock: topicMemberships.manualLock
@@ -3916,7 +4236,7 @@ var rebalanceSiblings = Effect23.fn("topics.rebalanceSiblings")(function* (topic
       vecById.set(row2.memoryId, new Float32Array(row2.vector));
   }
   const movedIds = new Set;
-  const outcome = yield* Effect23.tryPromise({
+  const outcome = yield* Effect24.tryPromise({
     try: () => db.transaction(async (tx) => {
       const liveCfs = new Map(siblings.map((s) => [s.topicKey, cfOf(s)]));
       const liveList = () => [...liveCfs.entries()].map(([topicKey2, cf]) => ({ topicKey: topicKey2, cf })).sort((a, b) => b.cf.count - a.cf.count || (a.topicKey < b.topicKey ? -1 : 1));
@@ -4003,7 +4323,7 @@ var loadMembers = async (tx, topicKey, modelKey) => {
   const rows = await tx.select({ memoryId: topicMemberships.memoryId, manualLock: topicMemberships.manualLock }).from(topicMemberships).where(and5(eq5(topicMemberships.topicKey, topicKey), eq5(topicMemberships.modelKey, modelKey))).orderBy(asc4(topicMemberships.memoryId));
   return rows;
 };
-var logUnderfilled = (db, topicKey, model, now, reason) => Effect23.tryPromise({
+var logUnderfilled = (db, topicKey, model, now, reason) => Effect24.tryPromise({
   try: () => db.insert(topicChangeLog).values({
     topicKey,
     operation: "merge",
@@ -4013,7 +4333,7 @@ var logUnderfilled = (db, topicKey, model, now, reason) => Effect23.tryPromise({
     createdAt: now
   }),
   catch: (cause) => new StoreError({ message: `mergeOrBorrow: log underfilled: ${cause}` })
-}).pipe(Effect23.map(() => ({ action: "underfilled", reason })));
+}).pipe(Effect24.map(() => ({ action: "underfilled", reason })));
 var logUnderfilledTx = async (tx, topicKey, model, now, reason) => {
   await tx.insert(topicChangeLog).values({
     topicKey,
@@ -4026,61 +4346,61 @@ var logUnderfilledTx = async (tx, topicKey, model, now, reason) => {
   return { action: "underfilled", reason };
 };
 function topicMergeHandler(deps) {
-  const run = (payload, ctx) => Effect23.gen(function* () {
+  const run = (payload, ctx) => Effect24.gen(function* () {
     const envelope = payload;
     const model = deps.getModelConfig(envelope.modelKey);
     if (!model) {
-      return yield* Effect23.fail(new JobFailure({
+      return yield* Effect24.fail(new JobFailure({
         jobId: ctx.jobId,
         message: `topic.merge: unknown model "${envelope.modelKey}"`
       }));
     }
-    yield* mergeOrBorrow(envelope.topicId, model, deps.config).pipe(Effect23.catchIf((error) => error._tag === "topics.TopicNotFound", (notFound) => staleNoOp(notFound, model)), Effect23.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `${error}` })));
+    yield* mergeOrBorrow(envelope.topicId, model, deps.config).pipe(Effect24.catchIf((error) => error._tag === "topics.TopicNotFound", (notFound) => staleNoOp(notFound, model)), Effect24.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `${error}` })));
     return;
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect23.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect24.provideService(Service2, deps.backend)) : run;
 }
 function topicRebalanceHandler(deps) {
-  const run = (payload, ctx) => Effect23.gen(function* () {
+  const run = (payload, ctx) => Effect24.gen(function* () {
     const envelope = payload;
     const model = deps.getModelConfig(envelope.modelKey);
     if (!model) {
-      return yield* Effect23.fail(new JobFailure({
+      return yield* Effect24.fail(new JobFailure({
         jobId: ctx.jobId,
         message: `topic.rebalance: unknown model "${envelope.modelKey}"`
       }));
     }
-    yield* rebalanceSiblings(envelope.topicId, model, deps.config).pipe(Effect23.catchIf((error) => error._tag === "topics.TopicNotFound", (notFound) => staleNoOp(notFound, model)), Effect23.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `${error}` })));
+    yield* rebalanceSiblings(envelope.topicId, model, deps.config).pipe(Effect24.catchIf((error) => error._tag === "topics.TopicNotFound", (notFound) => staleNoOp(notFound, model)), Effect24.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `${error}` })));
     return;
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect23.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect24.provideService(Service2, deps.backend)) : run;
 }
-var staleNoOp = (notFound, model) => Effect23.gen(function* () {
+var staleNoOp = (notFound, model) => Effect24.gen(function* () {
   const backend = yield* Service2;
   const db = backend.db;
-  const rows = yield* Effect23.tryPromise({
+  const rows = yield* Effect24.tryPromise({
     try: () => db.select({ topicKey: topics.topicKey }).from(topics).where(and5(eq5(topics.topicKey, notFound.topicKey), eq5(topics.modelKey, model.id))),
     catch: (cause) => new StoreError({ message: `maintenance: stale check: ${cause}` })
   });
   if (rows.length > 0) {
     return;
   }
-  return yield* Effect23.fail(new JobFailure({ jobId: notFound.topicKey, message: `topic missing: ${notFound.topicKey}` }));
-}).pipe(Effect23.mapError((error) => error instanceof JobFailure ? error : new JobFailure({ jobId: notFound.topicKey, message: `${error}` })));
+  return yield* Effect24.fail(new JobFailure({ jobId: notFound.topicKey, message: `topic missing: ${notFound.topicKey}` }));
+}).pipe(Effect24.mapError((error) => error instanceof JobFailure ? error : new JobFailure({ jobId: notFound.topicKey, message: `${error}` })));
 
 // ../store/src/topics/observability.ts
-import { Effect as Effect24 } from "effect";
+import { Effect as Effect25 } from "effect";
 import { and as and6, desc, eq as eq6, inArray as inArray3, ne as ne3, sql as sql5 } from "drizzle-orm";
 var DEFAULT_MAX_LEAF_ITEMS3 = 128;
 var DEFAULT_SPLIT_DEFERRED_HARD_LIMIT2 = 512;
 var DEFAULT_CHANGE_LOG_LIMIT = 50;
-var routingFailure4 = (tag) => (effect) => effect.pipe(Effect24.mapError((cause) => new RoutingFailure({ cause: { operation: tag, cause } })));
+var routingFailure4 = (tag) => (effect) => effect.pipe(Effect25.mapError((cause) => new RoutingFailure({ cause: { operation: tag, cause } })));
 var modelTopicKeys = (db, modelKey) => db.select({ topicKey: topics.topicKey }).from(topics).where(eq6(topics.modelKey, modelKey));
-var topicMetrics = Effect24.fn("topics.topicMetrics")(function* (modelKey, config) {
+var topicMetrics = Effect25.fn("topics.topicMetrics")(function* (modelKey, config) {
   const backend = yield* Service2;
   const db = backend.db;
   const maxLeafItems = config.maxLeafItems ?? DEFAULT_MAX_LEAF_ITEMS3;
-  const rows = yield* Effect24.tryPromise({
+  const rows = yield* Effect25.tryPromise({
     try: () => db.select({
       topicKey: topics.topicKey,
       kind: topics.kind,
@@ -4113,12 +4433,12 @@ var topicMetrics = Effect24.fn("topics.topicMetrics")(function* (modelKey, confi
       deferredLeaves++;
   }
   leafMemberCounts.sort((a, b) => a - b);
-  const growth = yield* Effect24.tryPromise({
+  const growth = yield* Effect25.tryPromise({
     try: () => db.select({ total: sql5`coalesce(sum(${topicGrowthState.splitRejectedCount}), 0)` }).from(topicGrowthState).where(eq6(topicGrowthState.modelKey, modelKey)),
     catch: (cause) => cause
   }).pipe(routingFailure4("topics.topicMetrics.growth"));
   const splitRejectedTotal = Number(growth[0]?.total ?? 0);
-  const lastLog = yield* Effect24.tryPromise({
+  const lastLog = yield* Effect25.tryPromise({
     try: () => db.select({
       operation: topicChangeLog.operation,
       createdAt: topicChangeLog.createdAt
@@ -4138,11 +4458,11 @@ var topicMetrics = Effect24.fn("topics.topicMetrics")(function* (modelKey, confi
     lastOperation
   };
 });
-var topicChangeLog2 = Effect24.fn("topics.topicChangeLog")(function* (modelKey, opts) {
+var topicChangeLog2 = Effect25.fn("topics.topicChangeLog")(function* (modelKey, opts) {
   const backend = yield* Service2;
   const db = backend.db;
   const limit = opts?.limit ?? DEFAULT_CHANGE_LOG_LIMIT;
-  const rows = yield* Effect24.tryPromise({
+  const rows = yield* Effect25.tryPromise({
     try: () => {
       const scoped = inArray3(topicChangeLog.topicKey, modelTopicKeys(db, modelKey));
       const filtered = opts?.operation ? and6(scoped, eq6(topicChangeLog.operation, opts.operation)) : scoped;
@@ -4152,14 +4472,14 @@ var topicChangeLog2 = Effect24.fn("topics.topicChangeLog")(function* (modelKey,
   }).pipe(routingFailure4("topics.topicChangeLog"));
   return rows;
 });
-var topicHealth = Effect24.fn("topics.topicHealth")(function* (modelKey, config) {
+var topicHealth = Effect25.fn("topics.topicHealth")(function* (modelKey, config) {
   const backend = yield* Service2;
   const db = backend.db;
   const maxLeafItems = config.maxLeafItems ?? DEFAULT_MAX_LEAF_ITEMS3;
   const hardLimit = config.splitDeferredHardLimit ?? DEFAULT_SPLIT_DEFERRED_HARD_LIMIT2;
   const slack = Math.max(2, Math.ceil(hardLimit / 2) - maxLeafItems);
   const leafLimit = maxLeafItems + slack;
-  const rows = yield* Effect24.tryPromise({
+  const rows = yield* Effect25.tryPromise({
     try: () => db.select({
       topicKey: topics.topicKey,
       kind: topics.kind,
@@ -4169,7 +4489,7 @@ var topicHealth = Effect24.fn("topics.topicHealth")(function* (modelKey, config)
     }).from(topics).where(and6(eq6(topics.modelKey, modelKey), ne3(topics.status, "inactive"))),
     catch: (cause) => cause
   }).pipe(routingFailure4("topics.topicHealth.topics"));
-  const countRows = yield* Effect24.tryPromise({
+  const countRows = yield* Effect25.tryPromise({
     try: () => db.select({ topicKey: topicMemberships.topicKey, count: sql5`count(*)` }).from(topicMemberships).where(eq6(topicMemberships.modelKey, modelKey)).groupBy(topicMemberships.topicKey),
     catch: (cause) => cause
   }).pipe(routingFailure4("topics.topicHealth.memberships"));
@@ -4194,30 +4514,30 @@ var topicHealth = Effect24.fn("topics.topicHealth")(function* (modelKey, config)
 });
 
 // ../store/src/graph/observability.ts
-import { Effect as Effect25 } from "effect";
+import { Effect as Effect26 } from "effect";
 import { and as and7, eq as eq7, isNull, sql as sql6 } from "drizzle-orm";
-var graphCoverage = Effect25.fn("GraphCoverage.run")(function* (modelKey) {
+var graphCoverage = Effect26.fn("GraphCoverage.run")(function* (modelKey) {
   const backend = yield* Service2;
   const db = backend.db;
-  const totalRows = yield* Effect25.tryPromise({
+  const totalRows = yield* Effect26.tryPromise({
     try: () => db.select({ id: memories.id }).from(memories).where(and7(eq7(memories.state, "active"), eq7(memories.embeddingModel, modelKey))),
     catch: (cause) => new StoreError({ message: `graphCoverage: total: ${cause}` })
   });
   const totalMemories = totalRows.length;
-  const isolatedRows = yield* backend.listIsolatedMemories(0, modelKey).pipe(Effect25.mapError((cause) => new StoreError({ message: `graphCoverage: isolated: ${cause}` })));
+  const isolatedRows = yield* backend.listIsolatedMemories(0, modelKey).pipe(Effect26.mapError((cause) => new StoreError({ message: `graphCoverage: isolated: ${cause}` })));
   const isolatedMemories = isolatedRows.length;
   const coveredMemories = totalMemories - isolatedMemories;
   const coveragePercent = totalMemories === 0 ? 0 : Math.round(coveredMemories / totalMemories * 1000) / 10;
-  const pendingRows = yield* Effect25.tryPromise({
+  const pendingRows = yield* Effect26.tryPromise({
     try: () => db.select({ count: sql6`count(*)` }).from(artifactEdges).where(and7(eq7(artifactEdges.status, "pending"), isNull(artifactEdges.expiredAt))),
     catch: (cause) => new StoreError({ message: `graphCoverage: pending: ${cause}` })
   });
   const pendingCandidates = totalMemories === 0 ? 0 : Number(pendingRows[0]?.count ?? 0);
-  const conceptCount = totalMemories === 0 ? 0 : (yield* Effect25.tryPromise({
+  const conceptCount = totalMemories === 0 ? 0 : (yield* Effect26.tryPromise({
     try: () => db.select({ id: concepts.id }).from(concepts),
     catch: (cause) => new StoreError({ message: `graphCoverage: concepts: ${cause}` })
   })).length;
-  const annotatedMemories = totalMemories === 0 ? 0 : new Set((yield* Effect25.tryPromise({
+  const annotatedMemories = totalMemories === 0 ? 0 : new Set((yield* Effect26.tryPromise({
     try: () => db.select({ memoryId: memoryConcepts.memoryId }).from(memoryConcepts),
     catch: (cause) => new StoreError({ message: `graphCoverage: annotations: ${cause}` })
   })).map((row) => row.memoryId)).size;
@@ -4447,27 +4767,25 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
   const db = backend.db;
   const topicsConfig = topicsOptions?.config ?? Schema19.decodeUnknownSync(TopicConfig)({});
   const topicsEnabled = topicsOptions?.enabled ?? false;
-  const updateTopicVectorForget = (backendImpl, model, topicKey, x) => Effect26.gen(function* () {
-    const rows = yield* backendImpl.fetchTopicVectors(model).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.forget: load vectors: ${cause}` })));
-    const current = rows.find((r) => r.topicKey === topicKey);
+  const updateTopicVectorForget = (backendImpl, model, topicKey, x) => Effect27.gen(function* () {
+    const current = yield* backendImpl.fetchTopicVector(topicKey, model).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.forget: load vector: ${cause}` })));
     const ls = current ? new Float32Array(current.sumVector) : new Float32Array(model.dimensions);
     for (let i = 0;i < ls.length; i++)
       ls[i] = ls[i] - x[i];
-    yield* backendImpl.upsertTopicVector(topicKey, Array.from(ls), model).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.forget: write vector: ${cause}` })));
-    const relRows = yield* Effect26.tryPromise({
+    yield* backendImpl.upsertTopicVector(topicKey, Array.from(ls), model).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.forget: write vector: ${cause}` })));
+    const relRows = yield* Effect27.tryPromise({
       try: () => db.select({ parentKey: topicRelations.parentKey }).from(topicRelations).where(and8(eq8(topicRelations.childKey, topicKey), eq8(topicRelations.modelKey, model.id), eq8(topicRelations.relationKind, "parent_child"))),
       catch: (cause) => new StoreError({ message: `Store.forget: load ancestor: ${cause}` })
     });
     let ancestorKey = relRows[0]?.parentKey;
     while (ancestorKey !== undefined) {
       const key = ancestorKey;
-      const aRows = yield* backendImpl.fetchTopicVectors(model).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.forget: load vectors: ${cause}` })));
-      const a = aRows.find((r) => r.topicKey === key);
+      const a = yield* backendImpl.fetchTopicVector(key, model).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.forget: load vector: ${cause}` })));
       const als = a ? new Float32Array(a.sumVector) : new Float32Array(model.dimensions);
       for (let i = 0;i < als.length; i++)
         als[i] = als[i] - x[i];
-      yield* backendImpl.upsertTopicVector(key, Array.from(als), model).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.forget: write vector: ${cause}` })));
-      const up = yield* Effect26.tryPromise({
+      yield* backendImpl.upsertTopicVector(key, Array.from(als), model).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.forget: write vector: ${cause}` })));
+      const up = yield* Effect27.tryPromise({
         try: () => db.select({ parentKey: topicRelations.parentKey }).from(topicRelations).where(and8(eq8(topicRelations.childKey, key), eq8(topicRelations.modelKey, model.id), eq8(topicRelations.relationKind, "parent_child"))),
         catch: (cause) => new StoreError({ message: `Store.forget: load ancestor: ${cause}` })
       });
@@ -4517,18 +4835,18 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     };
     const seam = auditOptions?.enqueueAudit;
     if (seam !== undefined) {
-      return propagateSeam ? seam(row).pipe(Effect26.mapError((cause) => new StoreError({ message: `audit.enqueue-failed: ${cause}` }))) : seam(row).pipe(Effect26.catch((cause) => Effect26.logError("audit.enqueue-failed").pipe(Effect26.annotateLogs({
+      return propagateSeam ? seam(row).pipe(Effect27.mapError((cause) => new StoreError({ message: `audit.enqueue-failed: ${cause}` }))) : seam(row).pipe(Effect27.catch((cause) => Effect27.logError("audit.enqueue-failed").pipe(Effect27.annotateLogs({
         scope: "@dimple/store",
         event: "audit.enqueue-failed",
         mode,
         cause: String(cause)
       }))));
     }
-    return Effect26.sync(() => {
+    return Effect27.sync(() => {
       db.insert(retrievalLog2).values(row).catch(() => {});
     });
   };
-  const logAudit = Effect26.fn("Store.logAudit")(function* (input) {
+  const logAudit = Effect27.fn("Store.logAudit")(function* (input) {
     return yield* logRetrieval(input.query, input.namespace, input.mode, input.resultCount, input.startTime, input.queryProfile, input.sources, input.hashSeed, true);
   });
   const GRAPH_SUPERSEDE_DEMOTION = graphConfig?.supersedeDemotion ?? 0.5;
@@ -4536,9 +4854,10 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     nearDuplicate: 0.9,
     conflictLow: 0.6
   };
+  const graphEnabled = graphConfig?.enabled !== false;
   const GRAPH_CANDIDATE_LIMIT_MAX = 200;
   const GRAPH_ISOLATED_EXAMPLES = 10;
-  const fetchResultEdges = (ids) => Effect26.tryPromise({
+  const fetchResultEdges = (ids) => Effect27.tryPromise({
     try: () => db.select({
       fromMemoryId: artifactEdges.fromMemoryId,
       toMemoryId: artifactEdges.toMemoryId,
@@ -4547,11 +4866,11 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     }).from(artifactEdges).where(and8(or(inArray4(artifactEdges.fromMemoryId, ids), inArray4(artifactEdges.toMemoryId, ids)), ne4(artifactEdges.status, "rejected"), isNull2(artifactEdges.expiredAt))),
     catch: (cause) => new StoreError({ message: `Store.retrieval post-pass: edges: ${cause}` })
   });
-  const fetchResultConcepts = (ids) => Effect26.tryPromise({
+  const fetchResultConcepts = (ids) => Effect27.tryPromise({
     try: () => db.select({ memoryId: memoryConcepts2.memoryId, conceptId: memoryConcepts2.conceptId }).from(memoryConcepts2).where(inArray4(memoryConcepts2.memoryId, ids)),
     catch: (cause) => new StoreError({ message: `Store.retrieval post-pass: concepts: ${cause}` })
   });
-  const augmentRetrieval = (results) => Effect26.gen(function* () {
+  const augmentRetrieval = (results) => Effect27.gen(function* () {
     if (results.length === 0)
       return results;
     const ids = results.map((r) => r.memory.id);
@@ -4561,6 +4880,9 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       supersedeDemotion: GRAPH_SUPERSEDE_DEMOTION
     });
   });
+  const augmentSearchResults = Effect27.fn("Store.augmentSearchResults")(function* (results) {
+    return yield* augmentRetrieval(results);
+  });
   const EDGE_KINDS = [
     "memory_supports",
     "memory_supersedes",
@@ -4568,7 +4890,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     "code_calls"
   ];
   const EDGE_SOURCES = ["rule", "llm", "agent"];
-  const write = Effect26.fn("Store.write")(function* (input) {
+  const write = Effect27.fn("Store.write")(function* (input) {
     if (input.content.includes("\x00")) {
       return yield* new StoreError({
         message: "Store.write: content contains a NUL byte (libSQL would silently truncate it)"
@@ -4577,7 +4899,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     const id = crypto.randomUUID();
     const now = Date.now();
     const metadataBlob = input.typedMetadata !== undefined ? mergeMetadataBlob(input.metadata, input.typedMetadata) : input.metadata ?? null;
-    yield* Effect26.tryPromise({
+    yield* Effect27.tryPromise({
       try: () => db.transaction(async (tx) => {
         await tx.insert(memories2).values({
           id,
@@ -4610,8 +4932,60 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       embeddingModel: undefined
     };
   });
-  const get = Effect26.fn("Store.get")(function* (id) {
-    const rows = yield* Effect26.tryPromise({
+  const writeMany = Effect27.fn("Store.writeMany")(function* (inputs) {
+    if (inputs.length === 0)
+      return [];
+    for (const input of inputs) {
+      if (input.content.includes("\x00")) {
+        return yield* new StoreError({
+          message: "Store.writeMany: content contains a NUL byte (libSQL would silently truncate it)"
+        });
+      }
+    }
+    const now = Date.now();
+    const rows = inputs.map((input) => {
+      const metadataBlob = input.typedMetadata !== undefined ? mergeMetadataBlob(input.metadata, input.typedMetadata) : input.metadata ?? null;
+      return {
+        id: crypto.randomUUID(),
+        logicalKey: input.logicalKey,
+        content: input.content,
+        contentType: input.contentType ?? "text/plain",
+        createdAt: now,
+        ttlSecs: input.ttlSecs === null ? null : input.ttlSecs ?? defaultTtlSecs,
+        namespace: input.namespace ?? "default",
+        metadata: metadataBlob
+      };
+    });
+    yield* Effect27.tryPromise({
+      try: () => db.transaction(async (tx) => {
+        await tx.insert(memories2).values(rows);
+        await tx.insert(memoryEvents2).values(rows.map((row) => ({
+          memoryId: row.id,
+          eventType: "created",
+          createdAt: now
+        })));
+      }),
+      catch: (cause) => backend.isUniqueViolation(cause) ? new DuplicateActiveKey({
+        logicalKey: inputs[0].logicalKey,
+        namespace: inputs[0].namespace ?? "default"
+      }) : new StoreError({ message: `Store.writeMany: ${cause}` })
+    });
+    return rows.map((row) => ({
+      id: row.id,
+      logicalKey: row.logicalKey,
+      content: row.content,
+      contentType: row.contentType,
+      state: "active",
+      createdAt: row.createdAt,
+      ttlSecs: row.ttlSecs,
+      namespace: row.namespace,
+      metadata: row.metadata ?? undefined,
+      embedding: undefined,
+      embeddingModel: undefined
+    }));
+  });
+  const get = Effect27.fn("Store.get")(function* (id) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select(memoryFields).from(memories2).where(eq8(memories2.id, id)).limit(1),
       catch: (cause) => new StoreError({ message: `Store.get: ${cause}` })
     });
@@ -4620,8 +4994,8 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       return yield* new NotFound({ id });
     return fromMemoryRow(row);
   });
-  const getByKey = Effect26.fn("Store.getByKey")(function* (key, namespace) {
-    const rows = yield* Effect26.tryPromise({
+  const getByKey = Effect27.fn("Store.getByKey")(function* (key, namespace) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select(memoryFields).from(memories2).where(and8(eq8(memories2.logicalKey, key), eq8(memories2.namespace, namespace), eq8(memories2.state, "active"))).orderBy(desc2(memories2.createdAt)).limit(1),
       catch: (cause) => new StoreError({ message: `Store.getByKey: ${cause}` })
     });
@@ -4630,9 +5004,9 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       return yield* new NotFound({ id: key });
     return fromMemoryRow(row);
   });
-  const recency = Effect26.fn("Store.recency")(function* (namespace, limit) {
+  const recency = Effect27.fn("Store.recency")(function* (namespace, limit) {
     const start = Date.now();
-    const rows = yield* Effect26.tryPromise({
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select(memoryFields).from(memories2).where(and8(eq8(memories2.namespace, namespace), eq8(memories2.state, "active"))).orderBy(desc2(memories2.createdAt)).limit(limit),
       catch: (cause) => new StoreError({ message: `Store.recency: ${cause}` })
     });
@@ -4645,9 +5019,9 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     yield* logRetrieval(namespace, namespace, "recency", results.length, start);
     return yield* augmentRetrieval(results);
   });
-  const searchFts5 = Effect26.fn("Store.searchFts5")(function* (query, namespace, limit, opts) {
+  const searchFts5 = Effect27.fn("Store.searchFts5")(function* (query, namespace, limit, opts) {
     const start = Date.now();
-    const rows = yield* backend.ftsSearch(query, namespace, limit, opts?.topicKeys, modelConfig?.id, opts?.contentType);
+    const rows = yield* backend.ftsSearch(query, namespace, limit, opts?.topicKeys, modelConfig?.id, opts?.contentType, opts?.includeEmbedding === true);
     if (opts?.audit !== false) {
       yield* logRetrieval(query, namespace, "fts", rows.length, start);
     }
@@ -4664,7 +5038,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
           ttlSecs: r.ttl_secs,
           namespace: r.namespace,
           metadata: r.metadata ?? undefined,
-          embedding: decodeBlobVector(r.embedding),
+          embedding: opts?.includeEmbedding === true ? decodeBlobVector(r.embedding) : undefined,
           embeddingModel: r.embedding_model ?? undefined
         },
         score: -r.rank,
@@ -4672,9 +5046,11 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         source: "fts5"
       };
     });
+    if (opts?.augment === false)
+      return results;
     return yield* augmentRetrieval(results);
   });
-  const searchVector = Effect26.fn("Store.searchVector")(function* (query, namespace, limit, opts) {
+  const searchVector = Effect27.fn("Store.searchVector")(function* (query, namespace, limit, opts) {
     if (!modelConfig) {
       return yield* new StoreError({
         message: "Store.searchVector: no embedding model configured"
@@ -4684,13 +5060,13 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     let allowedMemoryIds;
     const conceptIds = opts?.conceptIds;
     if (conceptIds !== undefined && conceptIds.length > 0) {
-      const conceptRows = yield* Effect26.tryPromise({
+      const conceptRows = yield* Effect27.tryPromise({
         try: () => db.select({ memoryId: memoryConcepts2.memoryId }).from(memoryConcepts2).where(inArray4(memoryConcepts2.conceptId, conceptIds)),
         catch: (cause) => new StoreError({ message: `Store.searchVector: concepts: ${cause}` })
       });
       allowedMemoryIds = new Set(conceptRows.map((r) => r.memoryId));
     }
-    const rows = yield* backend.vectorSearch(query, namespace, limit, modelConfig, opts?.topicKeys, opts?.contentType);
+    const rows = yield* backend.vectorSearch(query, namespace, limit, modelConfig, opts?.topicKeys, opts?.contentType, opts?.includeEmbedding === true);
     const allowed = allowedMemoryIds;
     const scopedRows = allowed !== undefined ? rows.filter((row) => allowed.has(row.id)) : rows;
     if (opts?.audit !== false) {
@@ -4709,7 +5085,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
           ttlSecs: r.ttl_secs,
           namespace: r.namespace,
           metadata: r.metadata ?? undefined,
-          embedding: decodeBlobVector(r.embedding),
+          embedding: opts?.includeEmbedding === true ? decodeBlobVector(r.embedding) : undefined,
           embeddingModel: r.embedding_model ?? undefined
         },
         score: 1 - r.distance,
@@ -4717,11 +5093,13 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         source: "vector"
       };
     });
+    if (opts?.augment === false)
+      return results;
     return yield* augmentRetrieval(results);
   });
-  const supersede = Effect26.fn("Store.supersede")(function* (key, namespace) {
+  const supersede = Effect27.fn("Store.supersede")(function* (key, namespace) {
     const now = Date.now();
-    const result = yield* Effect26.tryPromise({
+    const result = yield* Effect27.tryPromise({
       try: () => db.transaction(async (tx) => {
         const active = await tx.select({ id: memories2.id }).from(memories2).where(and8(eq8(memories2.logicalKey, key), eq8(memories2.namespace, namespace), eq8(memories2.state, "active"))).limit(1);
         if (active.length === 0)
@@ -4733,7 +5111,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     if (!result)
       return yield* new NotFound({ id: key });
   });
-  const decrementTreeCf = (model, membership, x) => Effect26.tryPromise({
+  const decrementTreeCf = (model, membership, x) => Effect27.tryPromise({
     try: () => db.transaction(async (tx) => {
       const leafRows = await tx.select({
         topicKey: topics.topicKey,
@@ -4763,10 +5141,10 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     }),
     catch: (cause) => new StoreError({ message: `Store: tree CF decrement: ${cause}` })
   });
-  const forget = Effect26.fn("Store.forget")(function* (id) {
+  const forget = Effect27.fn("Store.forget")(function* (id) {
     let membership;
     if (topicsEnabled) {
-      const memberRows = yield* Effect26.tryPromise({
+      const memberRows = yield* Effect27.tryPromise({
         try: () => db.select({ topicKey: topicMemberships.topicKey, modelKey: topicMemberships.modelKey }).from(topicMemberships).where(eq8(topicMemberships.memoryId, id)),
         catch: (cause) => new StoreError({ message: `Store.forget: load membership: ${cause}` })
       });
@@ -4781,14 +5159,14 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         }
       }
     }
-    const rs = yield* Effect26.tryPromise({
+    const rs = yield* Effect27.tryPromise({
       try: () => db.delete(memories2).where(eq8(memories2.id, id)),
       catch: (cause) => new StoreError({ message: `Store.forget: ${cause}` })
     });
     if (rs.rowsAffected === 0)
       return yield* new NotFound({ id });
     if (topicsEnabled && membership && modelConfig && modelConfig.id === membership.modelKey) {
-      const leafRows = yield* Effect26.tryPromise({
+      const leafRows = yield* Effect27.tryPromise({
         try: () => db.select({ memberCount: topics.memberCount }).from(topics).where(and8(eq8(topics.topicKey, membership.topicKey), eq8(topics.modelKey, membership.modelKey))),
         catch: (cause) => new StoreError({ message: `Store.forget: load leaf: ${cause}` })
       });
@@ -4796,18 +5174,18 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       if (liveCount < (topicsConfig.minLeafItems ?? 32)) {
         const enqueueMerge = topicsOptions?.enqueueMerge;
         if (enqueueMerge) {
-          yield* enqueueMerge(membership.topicKey, membership.modelKey).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.forget enqueueMerge: ${cause}` })));
+          yield* enqueueMerge(membership.topicKey, membership.modelKey).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.forget enqueueMerge: ${cause}` })));
         } else {
-          yield* mergeOrBorrow(membership.topicKey, modelConfig, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.forget mergeOrBorrow: ${cause}` })));
+          yield* mergeOrBorrow(membership.topicKey, modelConfig, topicsConfig).pipe(Effect27.provideService(Service2, backend), Effect27.mapError((cause) => new StoreError({ message: `Store.forget mergeOrBorrow: ${cause}` })));
         }
       }
     }
   });
-  const sweep = Effect26.fn("Store.sweep")(function* (namespace) {
+  const sweep = Effect27.fn("Store.sweep")(function* (namespace) {
     return yield* backend.sweep(namespace);
   });
-  const events = Effect26.fn("Store.events")(function* (memoryId) {
-    const rows = yield* Effect26.tryPromise({
+  const events = Effect27.fn("Store.events")(function* (memoryId) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select().from(memoryEvents2).where(eq8(memoryEvents2.memoryId, memoryId)).orderBy(asc5(memoryEvents2.createdAt)),
       catch: (cause) => new StoreError({ message: `Store.events: ${cause}` })
     });
@@ -4822,7 +5200,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     }));
   });
   const resolveModel = (modelKey) => modelConfig?.id === modelKey ? modelConfig : undefined;
-  const ensureTopicTree2 = Effect26.fn("Store.ensureTopicTree")(function* (modelKey) {
+  const ensureTopicTree2 = Effect27.fn("Store.ensureTopicTree")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -4830,33 +5208,33 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         actual: modelKey
       });
     }
-    return yield* ensureTopicTree(model, topicsConfig).pipe(Effect26.provideService(Service2, backend));
+    return yield* ensureTopicTree(model, topicsConfig).pipe(Effect27.provideService(Service2, backend));
   });
-  const resolveTopics2 = Effect26.fn("Store.resolveTopics")(function* (queryVector, opts) {
+  const resolveTopics2 = Effect27.fn("Store.resolveTopics")(function* (queryVector, opts) {
     if (!modelConfig) {
       return yield* new ModelMismatch({
         expected: "a configured embedding model",
         actual: "(none)"
       });
     }
-    return yield* resolveTopics(queryVector, modelConfig, topicsConfig, opts).pipe(Effect26.provideService(Service2, backend));
+    return yield* resolveTopics(queryVector, modelConfig, topicsConfig, opts).pipe(Effect27.provideService(Service2, backend));
   });
-  const topicMembers = Effect26.fn("Store.topicMembers")(function* (topicKey) {
-    const rows = yield* Effect26.tryPromise({
+  const topicMembers = Effect27.fn("Store.topicMembers")(function* (topicKey) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(eq8(topicMemberships.topicKey, topicKey)).orderBy(asc5(topicMemberships.memoryId)),
       catch: (cause) => new StoreError({ message: `Store.topicMembers: ${cause}` })
     });
     return rows;
   });
-  const listTopics = Effect26.fn("Store.listTopics")(function* (modelKey) {
-    const rows = yield* Effect26.tryPromise({
+  const listTopics = Effect27.fn("Store.listTopics")(function* (modelKey) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select().from(topics).where(eq8(topics.modelKey, modelKey)).orderBy(asc5(topics.topicKey)),
       catch: (cause) => new StoreError({ message: `Store.listTopics: ${cause}` })
     });
     return rows;
   });
-  const topicStats = Effect26.fn("Store.topicStats")(function* (modelKey) {
-    const rows = yield* Effect26.tryPromise({
+  const topicStats = Effect27.fn("Store.topicStats")(function* (modelKey) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select({ kind: topics.kind, depth: topics.depth }).from(topics).where(eq8(topics.modelKey, modelKey)),
       catch: (cause) => new StoreError({ message: `Store.topicStats: ${cause}` })
     });
@@ -4873,7 +5251,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     }
     return { depth, leafCount, internalCount, totalTopics: rows.length };
   });
-  const deleteTree = Effect26.fn("Store.deleteTree")(function* (modelKey) {
+  const deleteTree = Effect27.fn("Store.deleteTree")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -4882,7 +5260,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       });
     }
     yield* backend.deleteTopicVectors(model);
-    yield* Effect26.tryPromise({
+    yield* Effect27.tryPromise({
       try: () => db.transaction(async (tx) => {
         const modelTopicKeys2 = tx.select({ topicKey: topics.topicKey }).from(topics).where(eq8(topics.modelKey, modelKey));
         await tx.delete(topicChangeLog).where(inArray4(topicChangeLog.topicKey, modelTopicKeys2));
@@ -4894,7 +5272,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       catch: (cause) => new StoreError({ message: `Store.deleteTree: ${cause}` })
     });
   });
-  const processSplits = Effect26.fn("Store.processSplits")(function* (modelKey) {
+  const processSplits = Effect27.fn("Store.processSplits")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -4904,19 +5282,19 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     }
     let processed = 0;
     for (let iteration = 0;iteration < 100; iteration++) {
-      const leaves = yield* Effect26.tryPromise({
+      const leaves = yield* Effect27.tryPromise({
         try: () => db.select({ topicKey: topics.topicKey, memberCount: topics.memberCount }).from(topics).where(and8(eq8(topics.modelKey, modelKey), eq8(topics.kind, "leaf"), ne4(topics.status, "inactive"))).orderBy(asc5(topics.topicKey)),
         catch: (cause) => new StoreError({ message: `Store.processSplits: ${cause}` })
       });
       const candidate = leaves.find((leaf) => shouldSplit(leaf.memberCount, topicsConfig));
       if (!candidate)
         break;
-      yield* splitTopic(candidate.topicKey, model, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.processSplits: ${cause}` })));
+      yield* splitTopic(candidate.topicKey, model, topicsConfig).pipe(Effect27.provideService(Service2, backend), Effect27.mapError((cause) => new StoreError({ message: `Store.processSplits: ${cause}` })));
       processed++;
     }
     return processed;
   });
-  const mergeOrBorrow2 = Effect26.fn("Store.mergeOrBorrow")(function* (modelKey, topicKey) {
+  const mergeOrBorrow2 = Effect27.fn("Store.mergeOrBorrow")(function* (modelKey, topicKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -4924,9 +5302,9 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         actual: modelKey
       });
     }
-    return yield* mergeOrBorrow(topicKey, model, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.mergeOrBorrow: ${cause}` })));
+    return yield* mergeOrBorrow(topicKey, model, topicsConfig).pipe(Effect27.provideService(Service2, backend), Effect27.mapError((cause) => new StoreError({ message: `Store.mergeOrBorrow: ${cause}` })));
   });
-  const rebalanceSiblings2 = Effect26.fn("Store.rebalanceSiblings")(function* (modelKey, topicKey) {
+  const rebalanceSiblings2 = Effect27.fn("Store.rebalanceSiblings")(function* (modelKey, topicKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -4934,15 +5312,15 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         actual: modelKey
       });
     }
-    return yield* rebalanceSiblings(topicKey, model, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.rebalanceSiblings: ${cause}` })));
+    return yield* rebalanceSiblings(topicKey, model, topicsConfig).pipe(Effect27.provideService(Service2, backend), Effect27.mapError((cause) => new StoreError({ message: `Store.rebalanceSiblings: ${cause}` })));
   });
-  const setActiveModel2 = Effect26.fn("Store.setActiveModel")(function* (model) {
-    return yield* setActiveModel(model, topicsConfig).pipe(Effect26.provideService(Service2, backend));
+  const setActiveModel2 = Effect27.fn("Store.setActiveModel")(function* (model) {
+    return yield* setActiveModel(model, topicsConfig).pipe(Effect27.provideService(Service2, backend));
   });
-  const isActive2 = Effect26.fn("Store.isActive")(function* (modelKey) {
-    return yield* isActive(modelKey).pipe(Effect26.provideService(Service2, backend));
+  const isActive2 = Effect27.fn("Store.isActive")(function* (modelKey) {
+    return yield* isActive(modelKey).pipe(Effect27.provideService(Service2, backend));
   });
-  const topicMetrics2 = Effect26.fn("Store.topicMetrics")(function* (modelKey) {
+  const topicMetrics2 = Effect27.fn("Store.topicMetrics")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -4950,9 +5328,9 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         actual: modelKey
       });
     }
-    return yield* topicMetrics(modelKey, topicsConfig).pipe(Effect26.provideService(Service2, backend));
+    return yield* topicMetrics(modelKey, topicsConfig).pipe(Effect27.provideService(Service2, backend));
   });
-  const topicChangeLog3 = Effect26.fn("Store.topicChangeLog")(function* (modelKey, opts) {
+  const topicChangeLog3 = Effect27.fn("Store.topicChangeLog")(function* (modelKey, opts) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -4960,9 +5338,9 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         actual: modelKey
       });
     }
-    return yield* topicChangeLog2(modelKey, opts).pipe(Effect26.provideService(Service2, backend));
+    return yield* topicChangeLog2(modelKey, opts).pipe(Effect27.provideService(Service2, backend));
   });
-  const topicHealth2 = Effect26.fn("Store.topicHealth")(function* (modelKey) {
+  const topicHealth2 = Effect27.fn("Store.topicHealth")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -4970,11 +5348,11 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         actual: modelKey
       });
     }
-    return yield* topicHealth(modelKey, topicsConfig).pipe(Effect26.provideService(Service2, backend));
+    return yield* topicHealth(modelKey, topicsConfig).pipe(Effect27.provideService(Service2, backend));
   });
-  const updateEmbedding = Effect26.fn("Store.updateEmbedding")(function* (id, embedding, modelName) {
+  const updateEmbedding = Effect27.fn("Store.updateEmbedding")(function* (id, embedding, modelName, options) {
     const now = Date.now();
-    const affected = yield* Effect26.tryPromise({
+    const affected = yield* Effect27.tryPromise({
       try: () => db.transaction(async (tx) => {
         const rs = await tx.update(memories2).set({ embedding: [...embedding], embeddingModel: modelName }).where(eq8(memories2.id, id));
         if (rs.rowsAffected === 0)
@@ -5004,7 +5382,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     if (modelConfig && modelConfig.id === modelName) {
       yield* backend.ensureVectorTable(modelConfig);
       if (topicsEnabled) {
-        const memberRows = yield* Effect26.tryPromise({
+        const memberRows = yield* Effect27.tryPromise({
           try: () => db.select({
             topicKey: topicMemberships.topicKey,
             modelKey: topicMemberships.modelKey
@@ -5019,7 +5397,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
             yield* decrementTreeCf(modelConfig, mem, x);
             yield* updateTopicVectorForget(backend, modelConfig, mem.topicKey, x);
           }
-          yield* Effect26.tryPromise({
+          yield* Effect27.tryPromise({
             try: () => db.delete(topicMemberships).where(and8(eq8(topicMemberships.memoryId, id), eq8(topicMemberships.modelKey, modelName))),
             catch: (cause) => new StoreError({ message: `Store.updateEmbedding: delete membership: ${cause}` })
           });
@@ -5027,21 +5405,76 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       }
       yield* backend.insertVector(id, embedding, modelConfig);
       if (topicsEnabled) {
-        const routed = yield* routeInsert(id, embedding, modelConfig, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbedding topic route: ${cause}` })));
-        yield* scanLeafCandidates(id, embedding, routed.topicKey, modelConfig);
+        const routed = yield* routeInsert(id, embedding, modelConfig, topicsConfig).pipe(Effect27.provideService(Service2, backend), Effect27.mapError((cause) => new StoreError({ message: `Store.updateEmbedding topic route: ${cause}` })));
+        if (options?.scanCandidates !== false && graphEnabled) {
+          yield* scanLeafCandidates(id, embedding, routed.topicKey, modelConfig);
+        }
         if (routed.overflow) {
           const enqueueSplit = topicsOptions?.enqueueSplit;
           if (enqueueSplit) {
-            yield* enqueueSplit(routed.topicKey, modelConfig.id).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbedding enqueueSplit: ${cause}` })));
+            yield* enqueueSplit(routed.topicKey, modelConfig.id).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.updateEmbedding enqueueSplit: ${cause}` })));
           } else {
-            yield* processSplits(modelConfig.id).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbedding processSplits: ${cause}` })));
+            yield* processSplits(modelConfig.id).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.updateEmbedding processSplits: ${cause}` })));
           }
         }
       }
     }
   });
-  const findStale = Effect26.fn("Store.findStale")(function* (model) {
-    const rows = yield* Effect26.tryPromise({
+  const updateEmbeddingMany = Effect27.fn("Store.updateEmbeddingMany")(function* (entries, modelName, options) {
+    if (entries.length === 0)
+      return;
+    const now = Date.now();
+    yield* Effect27.tryPromise({
+      try: () => db.transaction(async (tx) => {
+        await tx.run(sql7`UPDATE ${memories2} SET embedding = CASE id ${sql7.join(entries.map((entry) => sql7`WHEN ${entry.id} THEN ${new Float32Array(entry.embedding).buffer}`), sql7` `)} END, embedding_model = ${modelName} WHERE id IN (${sql7.join(entries.map((entry) => entry.id), sql7`, `)})`);
+        await tx.insert(memoryEvents2).values(entries.map((entry) => ({
+          memoryId: entry.id,
+          eventType: "embedding_updated",
+          reason: modelName,
+          createdAt: now
+        })));
+      }),
+      catch: (cause) => {
+        let chain = "";
+        let c = cause;
+        let i = 0;
+        while (c && i < 6) {
+          chain += " | " + String(c.message ?? c);
+          c = c.cause;
+          i++;
+        }
+        return new StoreError({ message: `Store.updateEmbeddingMany: ${cause}` + chain });
+      }
+    });
+    if (modelConfig && modelConfig.id === modelName) {
+      yield* backend.ensureVectorTable(modelConfig);
+      yield* backend.insertVectors(entries.map((entry) => ({ memoryId: entry.id, vector: entry.embedding })), modelConfig);
+      if (topicsEnabled) {
+        const routed = yield* routeInsertMany(entries.map((entry) => ({ memoryId: entry.id, vector: entry.embedding })), modelConfig, topicsConfig).pipe(Effect27.provideService(Service2, backend), Effect27.mapError((cause) => new StoreError({ message: `Store.updateEmbeddingMany route: ${cause}` })));
+        if (options?.scanCandidates === true && graphEnabled) {
+          for (const routedEntry of routed) {
+            const entry = entries.find((e) => e.id === routedEntry.memoryId);
+            if (entry) {
+              yield* scanLeafCandidates(routedEntry.memoryId, entry.embedding, routedEntry.topicKey, modelConfig);
+            }
+          }
+        }
+        const overflowed = [...new Set(routed.filter((r) => r.overflow).map((r) => r.topicKey))];
+        if (overflowed.length > 0) {
+          const enqueueSplit = topicsOptions?.enqueueSplit;
+          if (enqueueSplit) {
+            for (const topicKey of overflowed) {
+              yield* enqueueSplit(topicKey, modelConfig.id).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.updateEmbeddingMany enqueueSplit: ${cause}` })));
+            }
+          } else {
+            yield* processSplits(modelConfig.id).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.updateEmbeddingMany processSplits: ${cause}` })));
+          }
+        }
+      }
+    }
+  });
+  const findStale = Effect27.fn("Store.findStale")(function* (model) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select({ id: memories2.id }).from(memories2).where(and8(eq8(memories2.state, "active"), sql7`(embedding IS NULL OR embedding_model IS NULL OR embedding_model != ${model})`)),
       catch: (cause) => new StoreError({ message: `Store.findStale: ${cause}` })
     });
@@ -5061,14 +5494,14 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     });
     return memoryId;
   };
-  const reconcile = Effect26.fn("Store.reconcile")(function* (namespace, keyPrefix, keyRoot, walkedRoots, keptKeys) {
+  const reconcile = Effect27.fn("Store.reconcile")(function* (namespace, keyPrefix, keyRoot, walkedRoots, keptKeys) {
     const inDomain = (key) => {
       const rel = key.slice(keyPrefix.length).split("#")[0];
       const filePath = keyRoot === "/" ? `/${rel}` : `${keyRoot}/${rel}`;
       return walkedRoots.some((root) => filePath === root || filePath.startsWith(`${root}/`));
     };
     const owned = (key) => keptKeys.includes(key);
-    const rows = yield* Effect26.tryPromise({
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select({
         id: memories2.id,
         logicalKey: memories2.logicalKey,
@@ -5079,7 +5512,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     const vanished = rows.filter((r) => inDomain(r.logicalKey) && !owned(r.logicalKey));
     if (vanished.length > 0) {
       const now = Date.now();
-      yield* Effect26.tryPromise({
+      yield* Effect27.tryPromise({
         try: () => db.transaction(async (tx) => {
           for (const row of vanished) {
             await flipToSupersededById(tx, row.id, now, "source_removed");
@@ -5090,7 +5523,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     }
     return vanished;
   });
-  const writeSuperseding = Effect26.fn("Store.writeSuperseding")(function* (input) {
+  const writeSuperseding = Effect27.fn("Store.writeSuperseding")(function* (input) {
     if (input.content.includes("\x00")) {
       return yield* new StoreError({
         message: "Store.writeSuperseding: content contains a NUL byte (libSQL would silently truncate it)"
@@ -5101,7 +5534,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     const metadataBlob = input.typedMetadata !== undefined ? mergeMetadataBlob(input.metadata, input.typedMetadata) : input.metadata ?? null;
     const namespace = input.namespace ?? "default";
     let supersededId;
-    yield* Effect26.tryPromise({
+    yield* Effect27.tryPromise({
       try: () => db.transaction(async (tx) => {
         const existing = await tx.select({ id: memories2.id }).from(memories2).where(and8(eq8(memories2.logicalKey, input.logicalKey), eq8(memories2.namespace, namespace), eq8(memories2.state, "active"))).limit(1);
         const old = existing[0];
@@ -5156,7 +5589,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       ...supersededId !== undefined ? { supersededId } : {}
     };
   });
-  const addEdge = Effect26.fn("Store.addEdge")(function* (input) {
+  const addEdge = Effect27.fn("Store.addEdge")(function* (input) {
     if (input.fromMemoryId === input.toMemoryId) {
       return yield* new StoreError({ message: "Store.addEdge: self-loops are not allowed" });
     }
@@ -5182,7 +5615,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
         message: `Store.addEdge: confidence must be a finite number in [0,1] (got ${String(confidence)})`
       });
     }
-    const endpoints = yield* Effect26.tryPromise({
+    const endpoints = yield* Effect27.tryPromise({
       try: () => db.select({ id: memories2.id }).from(memories2).where(inArray4(memories2.id, [input.fromMemoryId, input.toMemoryId])),
       catch: (cause) => new StoreError({ message: `Store.addEdge: endpoints: ${cause}` })
     });
@@ -5207,7 +5640,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       createdAt: now,
       updatedAt: now
     };
-    yield* Effect26.tryPromise({
+    yield* Effect27.tryPromise({
       try: () => db.transaction(async (tx) => {
         await tx.insert(artifactEdges).values(row);
         if (input.confirmed && input.edgeKind === "memory_supersedes") {
@@ -5227,17 +5660,17 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     });
     return row;
   });
-  const expireEdge = Effect26.fn("Store.expireEdge")(function* (id) {
-    const rs = yield* Effect26.tryPromise({
+  const expireEdge = Effect27.fn("Store.expireEdge")(function* (id) {
+    const rs = yield* Effect27.tryPromise({
       try: () => db.update(artifactEdges).set({ expiredAt: Date.now(), updatedAt: Date.now() }).where(eq8(artifactEdges.id, id)),
       catch: (cause) => new StoreError({ message: `Store.expireEdge: ${cause}` })
     });
     if (rs.rowsAffected === 0)
       return yield* new EdgeNotFound({ id });
   });
-  const confirmEdge = Effect26.fn("Store.confirmEdge")(function* (id) {
+  const confirmEdge = Effect27.fn("Store.confirmEdge")(function* (id) {
     const now = Date.now();
-    const found = yield* Effect26.tryPromise({
+    const found = yield* Effect27.tryPromise({
       try: () => db.transaction(async (tx) => {
         const rows = await tx.select().from(artifactEdges).where(eq8(artifactEdges.id, id)).limit(1);
         const edge = rows[0];
@@ -5254,15 +5687,15 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     if (!found)
       return yield* new EdgeNotFound({ id });
   });
-  const rejectEdge = Effect26.fn("Store.rejectEdge")(function* (id) {
-    const rs = yield* Effect26.tryPromise({
+  const rejectEdge = Effect27.fn("Store.rejectEdge")(function* (id) {
+    const rs = yield* Effect27.tryPromise({
       try: () => db.update(artifactEdges).set({ status: "rejected", updatedAt: Date.now() }).where(eq8(artifactEdges.id, id)),
       catch: (cause) => new StoreError({ message: `Store.rejectEdge: ${cause}` })
     });
     if (rs.rowsAffected === 0)
       return yield* new EdgeNotFound({ id });
   });
-  const listEdges = Effect26.fn("Store.listEdges")(function* (opts) {
+  const listEdges = Effect27.fn("Store.listEdges")(function* (opts) {
     const conditions = [];
     if (!opts?.includeExpired)
       conditions.push(isNull2(artifactEdges.expiredAt));
@@ -5273,7 +5706,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       conditions.push(eq8(artifactEdges.edgeKind, opts.edgeKind));
     if (opts?.status)
       conditions.push(eq8(artifactEdges.status, opts.status));
-    const rows = yield* Effect26.tryPromise({
+    const rows = yield* Effect27.tryPromise({
       try: () => {
         const base = db.select().from(artifactEdges);
         return (conditions.length === 0 ? base : base.where(and8(...conditions))).orderBy(desc2(artifactEdges.createdAt));
@@ -5282,7 +5715,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     });
     return rows;
   });
-  const explain = Effect26.fn("Store.explain")(function* (node, opts) {
+  const explain = Effect27.fn("Store.explain")(function* (node, opts) {
     if (node.kind !== "memory" && node.kind !== "topic" && node.kind !== "concept") {
       return yield* new StoreError({
         message: `Store.explain: unknown kind "${String(node.kind)}"`
@@ -5326,37 +5759,41 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       pendingConflicts: pending
     };
   });
-  const writeCandidateEdge = (candidate, now) => Effect26.tryPromise({
+  const writeCandidateEdges = (candidates, now) => Effect27.tryPromise({
     try: () => db.transaction(async (tx) => {
-      const existing = await tx.select({ id: artifactEdges.id }).from(artifactEdges).where(and8(eq8(artifactEdges.fromMemoryId, candidate.fromMemoryId), eq8(artifactEdges.toMemoryId, candidate.toMemoryId), eq8(artifactEdges.edgeKind, candidate.edgeKind))).limit(1);
-      if (existing.length > 0)
-        return false;
-      await tx.insert(artifactEdges).values({
-        id: crypto.randomUUID(),
-        fromMemoryId: candidate.fromMemoryId,
-        toMemoryId: candidate.toMemoryId,
-        edgeKind: candidate.edgeKind,
-        weight: 1,
-        status: candidate.status,
-        source: candidate.source,
-        confidence: candidate.confidence,
-        validAt: candidate.status === "confirmed" ? now : null,
-        expiredAt: null,
-        createdAt: now,
-        updatedAt: now
-      });
-      if (candidate.status === "confirmed") {
-        await flipToSupersededById(tx, candidate.fromMemoryId, now);
+      let inserted = 0;
+      for (const candidate of candidates) {
+        const existing = await tx.select({ id: artifactEdges.id }).from(artifactEdges).where(and8(eq8(artifactEdges.fromMemoryId, candidate.fromMemoryId), eq8(artifactEdges.toMemoryId, candidate.toMemoryId), eq8(artifactEdges.edgeKind, candidate.edgeKind))).limit(1);
+        if (existing.length > 0)
+          continue;
+        await tx.insert(artifactEdges).values({
+          id: crypto.randomUUID(),
+          fromMemoryId: candidate.fromMemoryId,
+          toMemoryId: candidate.toMemoryId,
+          edgeKind: candidate.edgeKind,
+          weight: 1,
+          status: candidate.status,
+          source: candidate.source,
+          confidence: candidate.confidence,
+          validAt: candidate.status === "confirmed" ? now : null,
+          expiredAt: null,
+          createdAt: now,
+          updatedAt: now
+        });
+        if (candidate.status === "confirmed") {
+          await flipToSupersededById(tx, candidate.fromMemoryId, now);
+        }
+        inserted += 1;
       }
-      return true;
+      return inserted;
     }),
-    catch: (cause) => new StoreError({ message: `Store.writeCandidateEdge: ${cause}` })
+    catch: (cause) => new StoreError({ message: `Store.writeCandidateEdges: ${cause}` })
   });
-  const reconcileRenameCandidates = Effect26.fn("Store.reconcileRenameCandidates")(function* (vanished, newUnitIds) {
+  const reconcileRenameCandidates = Effect27.fn("Store.reconcileRenameCandidates")(function* (vanished, newUnitIds) {
     const withVectors = vanished.filter((v) => v.embedding !== null);
     if (withVectors.length === 0 || newUnitIds.length === 0)
       return 0;
-    const newRows = yield* Effect26.tryPromise({
+    const newRows = yield* Effect27.tryPromise({
       try: () => db.select({ id: memories2.id, embedding: memories2.embedding }).from(memories2).where(and8(inArray4(memories2.id, newUnitIds))),
       catch: (cause) => new StoreError({ message: `Store.reconcileRenameCandidates: ${cause}` })
     });
@@ -5365,6 +5802,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       return 0;
     const now = Date.now();
     let inserted = 0;
+    const batch = [];
     for (const v of withVectors) {
       const vVec = Float32Array.from(v.embedding);
       for (const n of newWithVectors) {
@@ -5372,7 +5810,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
           continue;
         const cosine = cosineSimilarity(vVec, Float32Array.from(n.embedding));
         if (cosine >= GRAPH_CONFLICT_BANDS.nearDuplicate) {
-          const ok = yield* writeCandidateEdge({
+          batch.push({
             fromMemoryId: v.id,
             toMemoryId: n.id,
             edgeKind: "memory_supersedes",
@@ -5380,24 +5818,23 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
             status: "pending",
             confidence: cosine,
             reason: "rename"
-          }, now);
-          if (ok)
-            inserted += 1;
+          });
         }
       }
     }
+    inserted = yield* writeCandidateEdges(batch, now);
     return inserted;
   });
-  const scanLeafCandidates = (memoryId, vector, topicKey, model) => Effect26.gen(function* () {
-    const memberRows = yield* Effect26.tryPromise({
+  const scanLeafCandidates = (memoryId, vector, topicKey, model) => Effect27.gen(function* () {
+    const memberRows = yield* Effect27.tryPromise({
       try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(and8(eq8(topicMemberships.topicKey, topicKey), eq8(topicMemberships.modelKey, model.id))).orderBy(asc5(topicMemberships.memoryId)),
       catch: (cause) => new StoreError({ message: `Store.updateEmbedding candidates: members: ${cause}` })
     });
     const memberIds = memberRows.map((r) => r.memoryId);
     if (memberIds.length === 0)
       return;
-    const vectorRows = yield* backend.fetchMemoryVectors(memberIds, model).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbedding candidates: vectors: ${cause}` })));
-    const memoryRows = yield* Effect26.tryPromise({
+    const vectorRows = yield* backend.fetchMemoryVectors(memberIds, model).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.updateEmbedding candidates: vectors: ${cause}` })));
+    const memoryRows = yield* Effect27.tryPromise({
       try: () => db.select({
         id: memories2.id,
         logicalKey: memories2.logicalKey,
@@ -5406,7 +5843,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       }).from(memories2).where(and8(inArray4(memories2.id, memberIds), eq8(memories2.state, "active"))),
       catch: (cause) => new StoreError({ message: `Store.updateEmbedding candidates: memories: ${cause}` })
     });
-    const selfRows = yield* Effect26.tryPromise({
+    const selfRows = yield* Effect27.tryPromise({
       try: () => db.select({
         logicalKey: memories2.logicalKey,
         createdAt: memories2.createdAt,
@@ -5432,13 +5869,11 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     });
     const candidates = leafLocalCandidates(memoryId, new Float32Array(vector), self.createdAt, self.logicalKey, self.metadata, members, GRAPH_CONFLICT_BANDS);
     const now = Date.now();
-    for (const candidate of candidates) {
-      yield* writeCandidateEdge(candidate, now);
-    }
+    yield* writeCandidateEdges(candidates, now);
   });
-  const graphCandidates = Effect26.fn("Store.graphCandidates")(function* (opts) {
+  const graphCandidates = Effect27.fn("Store.graphCandidates")(function* (opts) {
     const limit = Math.max(1, Math.min(opts?.limit ?? 50, GRAPH_CANDIDATE_LIMIT_MAX));
-    const rows = yield* Effect26.tryPromise({
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select({
         id: artifactEdges.id,
         fromMemoryId: artifactEdges.fromMemoryId,
@@ -5450,7 +5885,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       }).from(artifactEdges).where(and8(eq8(artifactEdges.status, "pending"), isNull2(artifactEdges.expiredAt))).orderBy(desc2(artifactEdges.createdAt), asc5(artifactEdges.id)).limit(limit),
       catch: (cause) => new StoreError({ message: `Store.graphCandidates: pending: ${cause}` })
     });
-    const isolatedRows = yield* backend.listIsolatedMemories(0).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.graphCandidates: isolated: ${cause}` })));
+    const isolatedRows = yield* backend.listIsolatedMemories(0).pipe(Effect27.mapError((cause) => new StoreError({ message: `Store.graphCandidates: isolated: ${cause}` })));
     const isolated = isolatedRows.map((row) => ({
       id: String(row.id),
       createdAt: Number(row.createdAt)
@@ -5469,13 +5904,13 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       oldestIsolated: isolated.slice(0, GRAPH_ISOLATED_EXAMPLES)
     };
   });
-  const graphCoverage2 = Effect26.fn("Store.graphCoverage")(function* (modelKey) {
-    return yield* graphCoverage(modelKey).pipe(Effect26.provideService(Service2, backend));
+  const graphCoverage2 = Effect27.fn("Store.graphCoverage")(function* (modelKey) {
+    return yield* graphCoverage(modelKey).pipe(Effect27.provideService(Service2, backend));
   });
-  const createConcept = Effect26.fn("Store.createConcept")(function* (name, embedding) {
+  const createConcept = Effect27.fn("Store.createConcept")(function* (name, embedding) {
     const id = crypto.randomUUID();
     const now = Date.now();
-    yield* Effect26.tryPromise({
+    yield* Effect27.tryPromise({
       try: () => db.insert(concepts2).values({
         id,
         name,
@@ -5495,8 +5930,8 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       lastSeen: now
     };
   });
-  const getConcept = Effect26.fn("Store.getConcept")(function* (id) {
-    const rows = yield* Effect26.tryPromise({
+  const getConcept = Effect27.fn("Store.getConcept")(function* (id) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select().from(concepts2).where(eq8(concepts2.id, id)).limit(1),
       catch: (cause) => new StoreError({ message: `Store.getConcept: ${cause}` })
     });
@@ -5512,8 +5947,8 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       lastSeen: row.lastSeen
     };
   });
-  const listConcepts = Effect26.fn("Store.listConcepts")(function* () {
-    const rows = yield* Effect26.tryPromise({
+  const listConcepts = Effect27.fn("Store.listConcepts")(function* () {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select().from(concepts2),
       catch: (cause) => new StoreError({ message: `Store.listConcepts: ${cause}` })
     });
@@ -5526,8 +5961,8 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       lastSeen: row.lastSeen
     }));
   });
-  const annotateMemory = Effect26.fn("Store.annotateMemory")(function* (memoryId, conceptId, confidence) {
-    yield* Effect26.tryPromise({
+  const annotateMemory = Effect27.fn("Store.annotateMemory")(function* (memoryId, conceptId, confidence) {
+    yield* Effect27.tryPromise({
       try: () => db.insert(memoryConcepts2).values({
         conceptId,
         memoryId,
@@ -5537,14 +5972,14 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       catch: (cause) => new StoreError({ message: `Store.annotateMemory: ${cause}` })
     });
   });
-  const getMemoryAnnotations = Effect26.fn("Store.getMemoryAnnotations")(function* (memoryId) {
-    const rows = yield* Effect26.tryPromise({
+  const getMemoryAnnotations = Effect27.fn("Store.getMemoryAnnotations")(function* (memoryId) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select({ conceptId: memoryConcepts2.conceptId }).from(memoryConcepts2).where(eq8(memoryConcepts2.memoryId, memoryId)),
       catch: (cause) => new StoreError({ message: `Store.getMemoryAnnotations: ${cause}` })
     });
     return rows.map((r) => r.conceptId);
   });
-  const queryByMetadata = Effect26.fn("Store.queryByMetadata")(function* (filter) {
+  const queryByMetadata = Effect27.fn("Store.queryByMetadata")(function* (filter) {
     const rows = yield* backend.queryByMetadata(filter);
     const typed = rows;
     return typed.map((row) => fromMemoryRow({
@@ -5561,8 +5996,8 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       embeddingModel: row.embedding_model
     }));
   });
-  const getMemoryMetadata = Effect26.fn("Store.getMemoryMetadata")(function* (id) {
-    const rows = yield* Effect26.tryPromise({
+  const getMemoryMetadata = Effect27.fn("Store.getMemoryMetadata")(function* (id) {
+    const rows = yield* Effect27.tryPromise({
       try: () => db.select({ metadata: memories2.metadata }).from(memories2).where(eq8(memories2.id, id)).limit(1),
       catch: (cause) => new StoreError({ message: `Store.getMemoryMetadata: ${cause}` })
     });
@@ -5571,8 +6006,8 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       return yield* new NotFound({ id });
     return parseMetadata(row.metadata);
   });
-  const setMemoryMetadata = Effect26.fn("Store.setMemoryMetadata")(function* (id, metadata) {
-    const updated = yield* Effect26.tryPromise({
+  const setMemoryMetadata = Effect27.fn("Store.setMemoryMetadata")(function* (id, metadata) {
+    const updated = yield* Effect27.tryPromise({
       try: () => db.transaction(async (tx) => {
         const rows = await tx.select({ metadata: memories2.metadata }).from(memories2).where(eq8(memories2.id, id)).limit(1);
         const row = rows[0];
@@ -5588,6 +6023,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
   });
   return {
     write,
+    writeMany,
     writeSuperseding,
     reconcile,
     reconcileRenameCandidates,
@@ -5596,6 +6032,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     recency,
     searchFts5,
     searchVector,
+    augmentSearchResults,
     logAudit,
     listSchema: () => backend.listSchema(),
     supersede,
@@ -5603,6 +6040,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     sweep,
     events,
     updateEmbedding,
+    updateEmbeddingMany,
     findStale,
     createConcept,
     getConcept,
@@ -5637,7 +6075,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
   };
 };
 var layer8 = (url, options) => {
-  const base = Layer10.effect(Service5, Effect26.gen(function* () {
+  const base = Layer10.effect(Service5, Effect27.gen(function* () {
     const backend = yield* Service2;
     return Service5.of(makeStore2(backend, options?.embeddingModelConfig, options?.topics, options?.graphConfig, options?.enqueueAudit !== undefined ? { enqueueAudit: options.enqueueAudit } : undefined, options?.defaultTtlSecs));
   })).pipe(Layer10.provideMerge(layer3(url, options)));
@@ -5650,7 +6088,7 @@ var DISABLED_LOGGING = {
   format: "jsonl",
   ringSize: 4096
 };
-var loggingFromConfig = Layer10.unwrap(Effect26.map(Effect26.service(Service4), (cfg) => layer(cfg.config.logging ?? DISABLED_LOGGING)));
+var loggingFromConfig = Layer10.unwrap(Effect27.map(Effect27.service(Service4), (cfg) => layer(cfg.config.logging ?? DISABLED_LOGGING)));
 // ../store/src/topics/index.ts
 var exports_topics = {};
 __export(exports_topics, {
@@ -5671,6 +6109,7 @@ __export(exports_topics, {
   shouldSplit: () => shouldSplit,
   setActiveModel: () => setActiveModel,
   scoreChildren: () => scoreChildren,
+  routeInsertMany: () => routeInsertMany,
   routeInsert: () => routeInsert,
   resolveTopics: () => resolveTopics,
   rebalanceSiblings: () => rebalanceSiblings,
@@ -5708,15 +6147,15 @@ __export(exports_topics, {
 });
 
 // ../store/src/audit.ts
-import { Effect as Effect27 } from "effect";
+import { Effect as Effect28 } from "effect";
 function auditWriteHandler(deps = {}) {
-  const run = (payload, ctx) => Effect27.gen(function* () {
+  const run = (payload, ctx) => Effect28.gen(function* () {
     const envelope = payload;
     const backend = yield* Service2;
-    yield* backend.writeAuditRows(envelope.rows).pipe(Effect27.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `audit.write: ${error}` })));
+    yield* backend.writeAuditRows(envelope.rows).pipe(Effect28.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `audit.write: ${error}` })));
     return;
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect27.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect28.provideService(Service2, deps.backend)) : run;
 }
 // ../store/src/graph/index.ts
 var exports_graph = {};
@@ -5751,7 +6190,7 @@ __export(exports_graph, {
 });
 
 // ../store/src/graph/concepts.ts
-import { Clock as Clock6, Effect as Effect28 } from "effect";
+import { Clock as Clock6, Effect as Effect29 } from "effect";
 import { and as and9, asc as asc6, eq as eq9, isNotNull, sql as sql8 } from "drizzle-orm";
 var DEFAULT_CLUSTER_K = 8;
 var DEFAULT_CLUSTER_MIN_SIZE = 3;
@@ -5874,11 +6313,11 @@ var conceptConfidence = (vector, centroid) => {
     return 0;
   return Math.min(1, Math.max(0, dot3(vector, centroid) / Math.sqrt(norm)));
 };
-var clusterLeaf = Effect28.fn("ConceptCluster.clusterLeaf")(function* (topicKey, model, config) {
+var clusterLeaf = Effect29.fn("ConceptCluster.clusterLeaf")(function* (topicKey, model, config) {
   const backend = yield* Service2;
   const db = backend.db;
   const now = yield* Clock6.currentTimeMillis;
-  const memberRows = yield* Effect28.tryPromise({
+  const memberRows = yield* Effect29.tryPromise({
     try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(and9(eq9(topicMemberships.topicKey, topicKey), eq9(topicMemberships.modelKey, model.id))).orderBy(asc6(topicMemberships.memoryId)),
     catch: (cause) => new StoreError({ message: `clusterLeaf: load members: ${cause}` })
   });
@@ -5897,11 +6336,11 @@ var clusterLeaf = Effect28.fn("ConceptCluster.clusterLeaf")(function* (topicKey,
     return { concepts: 0, annotated: 0 };
   return yield* persistClusters(db, members, config, now);
 });
-var clusterCorpus = Effect28.fn("ConceptCluster.clusterCorpus")(function* (model, config) {
+var clusterCorpus = Effect29.fn("ConceptCluster.clusterCorpus")(function* (model, config) {
   const backend = yield* Service2;
   const db = backend.db;
   const now = yield* Clock6.currentTimeMillis;
-  const rows = yield* Effect28.tryPromise({
+  const rows = yield* Effect29.tryPromise({
     try: () => db.select({ id: memories.id, embedding: memories.embedding }).from(memories).where(and9(eq9(memories.state, "active"), isNotNull(memories.embedding))).orderBy(asc6(memories.id)),
     catch: (cause) => new StoreError({ message: `clusterCorpus: load memories: ${cause}` })
   });
@@ -5918,7 +6357,7 @@ var clusterCorpus = Effect28.fn("ConceptCluster.clusterCorpus")(function* (model
     return { concepts: 0, annotated: 0 };
   return yield* persistClusters(db, members, config, now);
 });
-var persistClusters = (db, members, config, now) => Effect28.tryPromise({
+var persistClusters = (db, members, config, now) => Effect29.tryPromise({
   try: () => db.transaction(async (tx) => {
     const { k, minClusterSize } = resolvedClusterConfig(config);
     const vectors = members.map((m) => m.vector);
@@ -5949,18 +6388,18 @@ var persistClusters = (db, members, config, now) => Effect28.tryPromise({
           lastSeen: now
         }
       });
-      for (const i of memberIndices) {
+      await tx.insert(memoryConcepts).values(memberIndices.map((i) => {
         const member = members[i];
-        await tx.insert(memoryConcepts).values({
+        return {
           conceptId: id,
           memoryId: member.id,
           confidence: conceptConfidence(member.vector, centroid),
           assignedAt: now
-        }).onConflictDoUpdate({
-          target: [memoryConcepts.conceptId, memoryConcepts.memoryId],
-          set: { confidence: conceptConfidence(member.vector, centroid), assignedAt: now }
-        });
-      }
+        };
+      })).onConflictDoUpdate({
+        target: [memoryConcepts.conceptId, memoryConcepts.memoryId],
+        set: { confidence: sql8`excluded.confidence`, assignedAt: now }
+      });
       conceptCount++;
       annotated += memberIndices.length;
     }
@@ -5969,21 +6408,21 @@ var persistClusters = (db, members, config, now) => Effect28.tryPromise({
   catch: (cause) => new StoreError({ message: `concept cluster: persist: ${cause}` })
 });
 function conceptClusterHandler(deps) {
-  const run = (payload, ctx) => Effect28.gen(function* () {
+  const run = (payload, ctx) => Effect29.gen(function* () {
     const envelope = payload;
     const model = deps.getModelConfig(envelope.modelKey);
     if (!model) {
-      return yield* Effect28.fail(new JobFailure({
+      return yield* Effect29.fail(new JobFailure({
         jobId: ctx.jobId,
         message: `concept.cluster: unknown model "${envelope.modelKey}"`
       }));
     }
     if (envelope.topicKey !== undefined) {
-      yield* clusterLeaf(envelope.topicKey, model, deps.config).pipe(Effect28.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `concept.cluster: ${error}` })));
+      yield* clusterLeaf(envelope.topicKey, model, deps.config).pipe(Effect29.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `concept.cluster: ${error}` })));
     } else {
-      yield* clusterCorpus(model, deps.config).pipe(Effect28.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `concept.cluster: ${error}` })));
+      yield* clusterCorpus(model, deps.config).pipe(Effect29.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `concept.cluster: ${error}` })));
     }
-    yield* Effect28.logInfo("concepts.clustered").pipe(Effect28.annotateLogs({
+    yield* Effect29.logInfo("concepts.clustered").pipe(Effect29.annotateLogs({
       scope: "@dimple/store",
       event: "concepts.clustered",
       modelKey: envelope.modelKey,
@@ -5991,10 +6430,10 @@ function conceptClusterHandler(deps) {
     }));
     return;
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect28.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect29.provideService(Service2, deps.backend)) : run;
 }
 // ../store/src/graph/dream.ts
-import { Clock as Clock7, Effect as Effect29 } from "effect";
+import { Clock as Clock7, Effect as Effect30 } from "effect";
 import { and as and10, asc as asc7, eq as eq10, gt, inArray as inArray5, isNull as isNull3, sql as sql9 } from "drizzle-orm";
 var dreamStateDefaults = {
   minHours: 24,
@@ -6024,110 +6463,99 @@ var flipToSuperseded = async (tx, memoryId, now) => {
   });
   return true;
 };
-var writeRelationEdge = (db, relation, now) => Effect29.tryPromise({
-  try: () => db.transaction(async (tx) => {
-    const existing = await tx.select({ id: artifactEdges.id, status: artifactEdges.status }).from(artifactEdges).where(and10(eq10(artifactEdges.fromMemoryId, relation.fromMemoryId), eq10(artifactEdges.toMemoryId, relation.toMemoryId), eq10(artifactEdges.edgeKind, relation.edgeKind))).limit(1);
-    const confirmed = relation.edgeKind === "memory_supersedes" && relation.confidence >= SUPERSEDE_CONFIRM_BAR;
-    if (existing.length > 0) {
-      const row = existing[0];
-      if (row.status !== "pending")
-        return { inserted: false, flipped: false };
-      if (confirmed) {
-        await tx.update(artifactEdges).set({
-          status: "confirmed",
-          validAt: now,
-          confidence: relation.confidence,
-          updatedAt: now
-        }).where(eq10(artifactEdges.id, row.id));
-        const flipped2 = await flipToSuperseded(tx, relation.fromMemoryId, now);
-        return { inserted: false, flipped: flipped2 };
-      }
+var writeRelationEdgeTx = async (tx, relation, now) => {
+  const existing = await tx.select({ id: artifactEdges.id, status: artifactEdges.status }).from(artifactEdges).where(and10(eq10(artifactEdges.fromMemoryId, relation.fromMemoryId), eq10(artifactEdges.toMemoryId, relation.toMemoryId), eq10(artifactEdges.edgeKind, relation.edgeKind))).limit(1);
+  const confirmed = relation.edgeKind === "memory_supersedes" && relation.confidence >= SUPERSEDE_CONFIRM_BAR;
+  if (existing.length > 0) {
+    const row = existing[0];
+    if (row.status !== "pending")
       return { inserted: false, flipped: false };
-    }
+    if (confirmed) {
+      await tx.update(artifactEdges).set({
+        status: "confirmed",
+        validAt: now,
+        confidence: relation.confidence,
+        updatedAt: now
+      }).where(eq10(artifactEdges.id, row.id));
+      const flipped2 = await flipToSuperseded(tx, relation.fromMemoryId, now);
+      return { inserted: false, flipped: flipped2 };
+    }
+    return { inserted: false, flipped: false };
+  }
+  await tx.insert(artifactEdges).values({
+    id: crypto.randomUUID(),
+    fromMemoryId: relation.fromMemoryId,
+    toMemoryId: relation.toMemoryId,
+    edgeKind: relation.edgeKind,
+    weight: 1,
+    status: confirmed ? "confirmed" : "pending",
+    source: "llm",
+    confidence: relation.confidence,
+    validAt: confirmed ? now : null,
+    expiredAt: null,
+    createdAt: now,
+    updatedAt: now
+  });
+  const flipped = confirmed ? await flipToSuperseded(tx, relation.fromMemoryId, now) : false;
+  return { inserted: true, flipped };
+};
+var writeDerivedMemoryTx = async (tx, content, sources, now) => {
+  const logicalKey = derivedKey(content);
+  const existing = await tx.select({ id: memories.id }).from(memories).where(and10(eq10(memories.logicalKey, logicalKey), eq10(memories.namespace, DERIVED_NAMESPACE), eq10(memories.state, "active"))).limit(1);
+  const memoryId = existing[0]?.id ?? crypto.randomUUID();
+  let inserted = false;
+  if (existing.length === 0) {
+    await tx.insert(memories).values({
+      id: memoryId,
+      logicalKey,
+      content,
+      contentType: "text/plain",
+      state: "active",
+      createdAt: now,
+      ttlSecs: DERIVED_TTL_SECS,
+      namespace: DERIVED_NAMESPACE,
+      metadata: JSON.stringify({ sources })
+    });
+    await tx.insert(memoryEvents).values({
+      memoryId,
+      eventType: "created",
+      createdAt: now
+    });
+    inserted = true;
+  }
+  for (const sourceId of sources) {
+    const edge = await tx.select({ id: artifactEdges.id }).from(artifactEdges).where(and10(eq10(artifactEdges.fromMemoryId, sourceId), eq10(artifactEdges.toMemoryId, memoryId), eq10(artifactEdges.edgeKind, "memory_supports"))).limit(1);
+    if (edge.length > 0)
+      continue;
     await tx.insert(artifactEdges).values({
       id: crypto.randomUUID(),
-      fromMemoryId: relation.fromMemoryId,
-      toMemoryId: relation.toMemoryId,
-      edgeKind: relation.edgeKind,
+      fromMemoryId: sourceId,
+      toMemoryId: memoryId,
+      edgeKind: "memory_supports",
       weight: 1,
-      status: confirmed ? "confirmed" : "pending",
+      status: "pending",
       source: "llm",
-      confidence: relation.confidence,
-      validAt: confirmed ? now : null,
+      confidence: null,
+      validAt: null,
       expiredAt: null,
       createdAt: now,
       updatedAt: now
     });
-    const flipped = confirmed ? await flipToSuperseded(tx, relation.fromMemoryId, now) : false;
-    return { inserted: true, flipped };
-  }),
-  catch: (cause) => new StoreError({ message: `memory.dream: write relation: ${cause}` })
-});
-var writeDerivedMemory = (db, content, sources, now) => Effect29.tryPromise({
-  try: () => db.transaction(async (tx) => {
-    const logicalKey = derivedKey(content);
-    const existing = await tx.select({ id: memories.id }).from(memories).where(and10(eq10(memories.logicalKey, logicalKey), eq10(memories.namespace, DERIVED_NAMESPACE), eq10(memories.state, "active"))).limit(1);
-    const memoryId = existing[0]?.id ?? crypto.randomUUID();
-    let inserted = false;
-    if (existing.length === 0) {
-      await tx.insert(memories).values({
-        id: memoryId,
-        logicalKey,
-        content,
-        contentType: "text/plain",
-        state: "active",
-        createdAt: now,
-        ttlSecs: DERIVED_TTL_SECS,
-        namespace: DERIVED_NAMESPACE,
-        metadata: JSON.stringify({ sources })
-      });
-      await tx.insert(memoryEvents).values({
-        memoryId,
-        eventType: "created",
-        createdAt: now
-      });
-      inserted = true;
-    }
-    for (const sourceId of sources) {
-      const edge = await tx.select({ id: artifactEdges.id }).from(artifactEdges).where(and10(eq10(artifactEdges.fromMemoryId, sourceId), eq10(artifactEdges.toMemoryId, memoryId), eq10(artifactEdges.edgeKind, "memory_supports"))).limit(1);
-      if (edge.length > 0)
-        continue;
-      await tx.insert(artifactEdges).values({
-        id: crypto.randomUUID(),
-        fromMemoryId: sourceId,
-        toMemoryId: memoryId,
-        edgeKind: "memory_supports",
-        weight: 1,
-        status: "pending",
-        source: "llm",
-        confidence: null,
-        validAt: null,
-        expiredAt: null,
-        createdAt: now,
-        updatedAt: now
-      });
-    }
-    return { inserted };
-  }),
-  catch: (cause) => new StoreError({ message: `memory.dream: write derived: ${cause}` })
-});
-var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
+  }
+  return { inserted };
+};
+var runDream = Effect30.fn("MemoryDream.run")(function* (model, classify) {
   const backend = yield* Service2;
   const db = backend.db;
   const now = yield* Clock7.currentTimeMillis;
   const { minHours, minNewMemories, maxPairs, maxDerived } = dreamStateDefaults;
-  const stateRows = yield* Effect29.tryPromise({
+  const stateRows = yield* Effect30.tryPromise({
     try: () => db.select().from(dreamState).where(eq10(dreamState.modelKey, model.id)),
     catch: (cause) => new StoreError({ message: `memory.dream: load state: ${cause}` })
   });
   const lastDreamAt = stateRows[0]?.lastDreamAt ?? 0;
-  const sinceCountRows = yield* Effect29.tryPromise({
-    try: () => db.select({ count: sql9`count(*)` }).from(memories).where(gt(memories.createdAt, lastDreamAt)),
-    catch: (cause) => new StoreError({ message: `memory.dream: count new: ${cause}` })
-  });
-  const memoriesSinceWatermark = Number(sinceCountRows[0]?.count ?? 0);
   if (now - lastDreamAt < minHours * 3600000) {
-    yield* Effect29.logDebug("dream.skipped").pipe(Effect29.annotateLogs({ scope: "@dimple/store", event: "dream.skipped", reason: "cooldown" }));
+    yield* Effect30.logDebug("dream.skipped").pipe(Effect30.annotateLogs({ scope: "@dimple/store", event: "dream.skipped", reason: "cooldown" }));
     return {
       skipped: true,
       reason: "cooldown",
@@ -6136,8 +6564,13 @@ var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
       superseded: 0
     };
   }
+  const sinceCountRows = yield* Effect30.tryPromise({
+    try: () => db.select({ count: sql9`count(*)` }).from(memories).where(gt(memories.createdAt, lastDreamAt)),
+    catch: (cause) => new StoreError({ message: `memory.dream: count new: ${cause}` })
+  });
+  const memoriesSinceWatermark = Number(sinceCountRows[0]?.count ?? 0);
   if (memoriesSinceWatermark < minNewMemories) {
-    yield* Effect29.logDebug("dream.skipped").pipe(Effect29.annotateLogs({
+    yield* Effect30.logDebug("dream.skipped").pipe(Effect30.annotateLogs({
       scope: "@dimple/store",
       event: "dream.skipped",
       reason: "insufficient-new-memories",
@@ -6151,7 +6584,7 @@ var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
       superseded: 0
     };
   }
-  const pendingRows = yield* Effect29.tryPromise({
+  const pendingRows = yield* Effect30.tryPromise({
     try: () => db.select({
       fromMemoryId: artifactEdges.fromMemoryId,
       toMemoryId: artifactEdges.toMemoryId
@@ -6164,7 +6597,7 @@ var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
   };
   for (const row of pendingRows)
     addPair(row.fromMemoryId, row.toMemoryId);
-  const sinceRows = yield* Effect29.tryPromise({
+  const sinceRows = yield* Effect30.tryPromise({
     try: () => db.select({
       id: memories.id,
       logicalKey: memories.logicalKey,
@@ -6175,19 +6608,19 @@ var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
   });
   if (sinceRows.length > 0) {
     const sinceIds = sinceRows.map((r) => r.id);
-    const membershipRows = yield* Effect29.tryPromise({
+    const membershipRows = yield* Effect30.tryPromise({
       try: () => db.select({ memoryId: topicMemberships.memoryId, topicKey: topicMemberships.topicKey }).from(topicMemberships).where(and10(eq10(topicMemberships.modelKey, model.id), inArray5(topicMemberships.memoryId, sinceIds))),
       catch: (cause) => new StoreError({ message: `memory.dream: scan memberships: ${cause}` })
     });
     const leafKeys = [...new Set(membershipRows.map((m) => m.topicKey))];
     if (leafKeys.length > 0) {
-      const mateRows = yield* Effect29.tryPromise({
+      const mateRows = yield* Effect30.tryPromise({
         try: () => db.select({ memoryId: topicMemberships.memoryId, topicKey: topicMemberships.topicKey }).from(topicMemberships).where(and10(eq10(topicMemberships.modelKey, model.id), inArray5(topicMemberships.topicKey, leafKeys))),
         catch: (cause) => new StoreError({ message: `memory.dream: scan mates: ${cause}` })
       });
       const memberIds = [...new Set([...sinceIds, ...mateRows.map((m) => m.memoryId)])];
-      const vectorRows = yield* backend.fetchMemoryVectors(memberIds, model).pipe(Effect29.mapError((cause) => new StoreError({ message: `memory.dream: scan vectors: ${cause}` })));
-      const memoryRows = yield* Effect29.tryPromise({
+      const vectorRows = yield* backend.fetchMemoryVectors(memberIds, model).pipe(Effect30.mapError((cause) => new StoreError({ message: `memory.dream: scan vectors: ${cause}` })));
+      const memoryRows = yield* Effect30.tryPromise({
         try: () => db.select({
           id: memories.id,
           logicalKey: memories.logicalKey,
@@ -6244,7 +6677,7 @@ var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
   }
   const orderedPairs = [...pairSet.values()].sort((a, b) => cmp3(a.toMemoryId, b.toMemoryId) || cmp3(a.fromMemoryId, b.fromMemoryId)).slice(0, maxPairs);
   const endpointIds = [...new Set(orderedPairs.flatMap((p) => [p.fromMemoryId, p.toMemoryId]))];
-  const contentRows = endpointIds.length > 0 ? yield* Effect29.tryPromise({
+  const contentRows = endpointIds.length > 0 ? yield* Effect30.tryPromise({
     try: () => db.select({ id: memories.id, content: memories.content }).from(memories).where(inArray5(memories.id, endpointIds)),
     catch: (cause) => new StoreError({ message: `memory.dream: pair contents: ${cause}` })
   }) : [];
@@ -6264,17 +6697,17 @@ var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
   }
   let classification = { relations: [], derived: [] };
   if (dreamPairs.length > 0) {
-    classification = yield* classify.classify(dreamPairs, { maxDerived }).pipe(Effect29.mapError((error) => new StoreError({ message: `memory.dream: classify: ${error}` })));
+    classification = yield* classify.classify(dreamPairs, { maxDerived }).pipe(Effect30.mapError((error) => new StoreError({ message: `memory.dream: classify: ${error}` })));
   }
   const endpointIdsOf = [
     ...new Set(classification.relations.flatMap((r) => [r.fromMemoryId, r.toMemoryId]))
   ];
-  const endpointRows = endpointIdsOf.length > 0 ? yield* Effect29.tryPromise({
+  const endpointRows = endpointIdsOf.length > 0 ? yield* Effect30.tryPromise({
     try: () => db.select({ id: memories.id, metadata: memories.metadata }).from(memories).where(inArray5(memories.id, endpointIdsOf)),
     catch: (cause) => new StoreError({ message: `memory.dream: endpoints: ${cause}` })
   }) : [];
   const metadataById = new Map(endpointRows.map((r) => [r.id, r.metadata]));
-  let superseded = 0;
+  const acceptedRelations = [];
   for (const relation of classification.relations) {
     const fromMetadata = metadataById.get(relation.fromMemoryId);
     const toMetadata = metadataById.get(relation.toMemoryId);
@@ -6283,13 +6716,11 @@ var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
     if (parseMetadata(fromMetadata)?.pinned === true || parseMetadata(toMetadata)?.pinned === true) {
       continue;
     }
-    const result = yield* writeRelationEdge(db, relation, now);
-    if (result.flipped)
-      superseded++;
+    acceptedRelations.push(relation);
   }
-  let created = 0;
+  const acceptedDerived = [];
   for (const derived of classification.derived) {
-    const sourceRows = derived.sources.length > 0 ? yield* Effect29.tryPromise({
+    const sourceRows = derived.sources.length > 0 ? yield* Effect30.tryPromise({
       try: () => db.select({ id: memories.id }).from(memories).where(inArray5(memories.id, derived.sources)),
       catch: (cause) => new StoreError({ message: `memory.dream: derived sources: ${cause}` })
     }) : [];
@@ -6297,27 +6728,36 @@ var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
     const survivingSources = derived.sources.filter((id) => survivingIds.has(id));
     if (survivingSources.length === 0)
       continue;
-    const outcome = yield* writeDerivedMemory(db, derived.content, survivingSources, now);
-    if (outcome.inserted)
-      created++;
-  }
-  const countRows = yield* Effect29.tryPromise({
-    try: () => db.select({ count: sql9`count(*)` }).from(memories),
-    catch: (cause) => new StoreError({ message: `memory.dream: total count: ${cause}` })
-  });
-  const totalMemories = Number(countRows[0]?.count ?? 0);
-  yield* Effect29.tryPromise({
-    try: () => db.insert(dreamState).values({
-      modelKey: model.id,
-      lastDreamAt: now,
-      lastDreamMemoryCount: totalMemories
-    }).onConflictDoUpdate({
-      target: dreamState.modelKey,
-      set: { lastDreamAt: now, lastDreamMemoryCount: totalMemories }
+    acceptedDerived.push({ content: derived.content, sources: survivingSources });
+  }
+  let superseded = 0;
+  let created = 0;
+  yield* Effect30.tryPromise({
+    try: () => db.transaction(async (tx) => {
+      for (const relation of acceptedRelations) {
+        const result = await writeRelationEdgeTx(tx, relation, now);
+        if (result.flipped)
+          superseded++;
+      }
+      for (const derived of acceptedDerived) {
+        const outcome = await writeDerivedMemoryTx(tx, derived.content, derived.sources, now);
+        if (outcome.inserted)
+          created++;
+      }
+      const countRows = await tx.select({ count: sql9`count(*)` }).from(memories);
+      const totalMemories = Number(countRows[0]?.count ?? 0);
+      await tx.insert(dreamState).values({
+        modelKey: model.id,
+        lastDreamAt: now,
+        lastDreamMemoryCount: totalMemories
+      }).onConflictDoUpdate({
+        target: dreamState.modelKey,
+        set: { lastDreamAt: now, lastDreamMemoryCount: totalMemories }
+      });
     }),
-    catch: (cause) => new StoreError({ message: `memory.dream: advance watermark: ${cause}` })
+    catch: (cause) => new StoreError({ message: `memory.dream: persist: ${cause}` })
   });
-  yield* Effect29.logInfo("dream.completed").pipe(Effect29.annotateLogs({
+  yield* Effect30.logInfo("dream.completed").pipe(Effect30.annotateLogs({
     scope: "@dimple/store",
     event: "dream.completed",
     modelKey: model.id,
@@ -6328,24 +6768,24 @@ var runDream = Effect29.fn("MemoryDream.run")(function* (model, classify) {
   return { skipped: false, classified: dreamPairs.length, created, superseded };
 });
 function graphDreamHandler(deps) {
-  const run = (payload, ctx) => Effect29.gen(function* () {
+  const run = (payload, ctx) => Effect30.gen(function* () {
     const envelope = payload;
     const model = deps.getModelConfig(envelope.modelKey);
     if (!model) {
-      return yield* Effect29.fail(new JobFailure({
+      return yield* Effect30.fail(new JobFailure({
         jobId: ctx.jobId,
         message: `memory.dream: unknown model "${envelope.modelKey}"`
       }));
     }
-    return yield* runDream(model, deps.classify).pipe(Effect29.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `memory.dream: ${error}` })));
+    return yield* runDream(model, deps.classify).pipe(Effect30.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `memory.dream: ${error}` })));
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect29.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect30.provideService(Service2, deps.backend)) : run;
 }
 // ../store/src/graph/repair.ts
-import { Clock as Clock8, Effect as Effect30 } from "effect";
+import { Clock as Clock8, Effect as Effect31 } from "effect";
 import { and as and11, eq as eq11, isNotNull as isNotNull2, lt, or as or2, sql as sql10 } from "drizzle-orm";
 var DEFAULT_EXPIRED_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
-var runRepair = (db, includePurgeExpired, expiredGraceMs, now) => Effect30.tryPromise({
+var runRepair = (db, includePurgeExpired, expiredGraceMs, now) => Effect31.tryPromise({
   try: () => db.transaction(async (tx) => {
     let orphanedEdges = 0;
     let staleAnnotations = 0;
@@ -6439,10 +6879,10 @@ var runRepair = (db, includePurgeExpired, expiredGraceMs, now) => Effect30.tryPr
   catch: (cause) => new StoreError({ message: `graph.repair: ${cause}` })
 });
 function graphRepairHandler(deps) {
-  const run = (payload, ctx) => Effect30.gen(function* () {
+  const run = (payload, ctx) => Effect31.gen(function* () {
     const envelope = payload;
     if (!deps.getModelConfig(envelope.modelKey)) {
-      return yield* Effect30.fail(new JobFailure({
+      return yield* Effect31.fail(new JobFailure({
         jobId: ctx.jobId,
         message: `graph.repair: unknown model "${envelope.modelKey}"`
       }));
@@ -6450,8 +6890,8 @@ function graphRepairHandler(deps) {
     const backend = yield* Service2;
     const db = backend.db;
     const now = yield* Clock8.currentTimeMillis;
-    const result = yield* runRepair(db, deps.includePurgeExpired ?? false, deps.expiredGraceMs ?? DEFAULT_EXPIRED_GRACE_MS, now).pipe(Effect30.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `graph.repair: ${error}` })));
-    yield* Effect30.logInfo("repair.completed").pipe(Effect30.annotateLogs({
+    const result = yield* runRepair(db, deps.includePurgeExpired ?? false, deps.expiredGraceMs ?? DEFAULT_EXPIRED_GRACE_MS, now).pipe(Effect31.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `graph.repair: ${error}` })));
+    yield* Effect31.logInfo("repair.completed").pipe(Effect31.annotateLogs({
       scope: "@dimple/store",
       event: "repair.completed",
       modelKey: envelope.modelKey,
@@ -6461,7 +6901,7 @@ function graphRepairHandler(deps) {
     }));
     return result;
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect30.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect31.provideService(Service2, deps.backend)) : run;
 }
 // ../store/src/models.ts
 import { Schema as Schema20 } from "effect";
@@ -6548,15 +6988,21 @@ class EmbeddingError extends Schema21.TaggedErrorClass()("EmbeddingProvider.Embe
 class Service9 extends Context9.Service()("@dimple/embedder/EmbeddingModelRegistry") {
 }
 // ../embedder/src/transformers.ts
-import { Config as Config5, Effect as Effect32, Layer as Layer11 } from "effect";
+import { Config as Config5, Effect as Effect33, Layer as Layer11 } from "effect";
 import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { join as join2 } from "node:path";
 import { pathToFileURL } from "node:url";
 
-// ../embedder/src/auto-install.ts
-import { execFile } from "node:child_process";
+// ../installer/src/index.ts
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+
+class InstallerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InstallerError";
+  }
+}
 var detectPackageManager = (cwd) => {
   let dir = cwd;
   while (true) {
@@ -6571,38 +7017,74 @@ var detectPackageManager = (cwd) => {
       return { pm: "npm", root: dir };
     const parent = join(dir, "..");
     if (parent === dir)
-      return { pm: "bun", root: cwd };
+      return { pm: "npm", root: cwd };
     dir = parent;
   }
 };
-var installCommand = (pm) => {
-  switch (pm) {
-    case "bun":
-      return ["bun", "add", "@huggingface/transformers"];
-    case "npm":
-      return [
-        "npm",
-        "install",
-        "@huggingface/transformers",
-        "--ignore-scripts",
-        "--no-audit",
-        "--no-fund"
-      ];
-    case "pnpm":
-      return ["pnpm", "add", "@huggingface/transformers", "--ignore-scripts"];
-    case "yarn":
-      return ["yarn", "add", "@huggingface/transformers", "--ignore-scripts"];
-  }
+var resolveExecutable = (pm, platform = process.platform) => platform === "win32" && pm !== "bun" ? `${pm}.cmd` : pm;
+var installArgs = (pm, packages, root) => {
+  const argv = [pm === "npm" ? "install" : "add", ...packages];
+  if (pm !== "bun")
+    argv.push("--ignore-scripts");
+  if (pm === "npm")
+    argv.push("--no-audit", "--no-fund");
+  if (pm === "pnpm" && existsSync(join(root, "pnpm-workspace.yaml")))
+    argv.push("-w");
+  return argv;
+};
+var installOnce = async (target, packages, opts) => {
+  const { spawn } = await import("node:child_process");
+  return new Promise((resolve, reject) => {
+    const timeoutMs = opts.timeoutMs ?? 300000;
+    const cmd = resolveExecutable(target.pm, opts.platform);
+    const args = installArgs(target.pm, packages, target.root);
+    const manual = `${cmd} ${args.join(" ")}`;
+    const child = spawn(cmd, args, { cwd: target.root, stdio: "ignore" });
+    let settled = false;
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      if (settled)
+        return;
+      settled = true;
+      reject(new InstallerError(`auto-install timed out after ${timeoutMs} ms — the child was killed; run it manually: ${manual}`));
+    }, timeoutMs);
+    child.on("error", (cause) => {
+      clearTimeout(timer);
+      if (settled)
+        return;
+      settled = true;
+      reject(new InstallerError(`auto-install failed to start (${manual}): ${cause.message} — run it manually`));
+    });
+    child.on("exit", (code, signal) => {
+      clearTimeout(timer);
+      if (settled)
+        return;
+      settled = true;
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new InstallerError(`auto-install failed (${manual} exited ${signal !== null ? `with ${signal}` : `code ${code ?? "?"}`}) — run it manually`));
+    });
+  });
 };
-var installTransformers = (cwd) => new Promise((resolve, reject) => {
+var inflight = new Map;
+var installOptionalPeers = (packages, opts) => {
+  const cwd = opts?.cwd ?? process.cwd();
   const target = detectPackageManager(cwd);
-  const [cmd, ...args] = installCommand(target.pm);
-  execFile(cmd, args, { cwd: target.root, encoding: "utf8" }, (error) => {
-    if (error) {
-      reject(new Error(`auto-install of @huggingface/transformers failed (${target.pm} add …): ${error.message} — ` + "run it manually or set `autoInstall: false` and configure a hosted embedding provider"));
-      return;
-    }
-    resolve();
+  const key = `${target.root}\x00${packages.join(",")}`;
+  const existing = inflight.get(key);
+  if (existing !== undefined)
+    return existing;
+  const run = installOnce(target, packages, opts ?? {});
+  inflight.set(key, run);
+  run.then(() => inflight.delete(key), () => inflight.delete(key));
+  return run;
+};
+// ../embedder/src/auto-install.ts
+var installTransformers = (cwd) => installOptionalPeers(["@huggingface/transformers"], { cwd, timeoutMs: 300000 }).catch((cause) => {
+  throw new EmbeddingError({
+    message: cause instanceof InstallerError ? `${cause.message} — or set \`autoInstall: false\` and configure a hosted embedding provider` : `auto-install of @huggingface/transformers failed: ${String(cause)} — run it manually ` + "or set `autoInstall: false` and configure a hosted embedding provider"
   });
 });
 
@@ -6653,44 +7135,59 @@ var defaults2 = {
   pooling: "mean",
   normalize: true
 };
+var outputVectors = (result) => {
+  const { data, dims } = result;
+  const stride = dims.length > 0 ? dims[dims.length - 1] : data.length;
+  if (stride > 0 && data.length % stride === 0) {
+    const vectors = [];
+    for (let offset = 0;offset < data.length; offset += stride) {
+      vectors.push(data.subarray(offset, offset + stride));
+    }
+    return vectors;
+  }
+  return result.tolist().map((v) => new Float32Array(v));
+};
 var make5 = (options) => {
   let pipe = null;
-  const getPipeline = Effect32.fnUntraced(function* () {
+  const getPipeline = Effect33.fnUntraced(function* () {
     if (pipe)
       return pipe;
-    const loadModule = () => Effect32.tryPromise(() => import("@huggingface/transformers"));
-    let transformers = yield* loadModule().pipe(Effect32.catch(() => {
+    const loadModule = () => Effect33.tryPromise(() => import("@huggingface/transformers"));
+    let transformers = yield* loadModule().pipe(Effect33.catch(() => {
       if (options.autoInstall === false) {
-        return Effect32.fail(new EmbeddingError({
+        return Effect33.fail(new EmbeddingError({
           message: "@huggingface/transformers is not installed — run `bun add @huggingface/transformers` " + "to use local embeddings (or configure a hosted embedding provider)"
         }));
       }
-      return Effect32.gen(function* () {
-        yield* Effect32.logInfo("auto-installing @huggingface/transformers (first local-embed use — scripts skipped)").pipe(Effect32.annotateLogs({ scope: "@dimple/embedder", event: "embedder.auto-install" }));
-        yield* Effect32.tryPromise(() => installTransformers(process.cwd())).pipe(Effect32.timeout("5 minutes"), Effect32.catch((cause) => Effect32.fail(new EmbeddingError({
-          message: cause._tag === "TimeoutError" ? "auto-install of @huggingface/transformers timed out (5 minutes) — run " + "`bun add @huggingface/transformers` manually" : cause.cause instanceof Error ? cause.cause.message : cause instanceof Error ? cause.message : `auto-install failed: ${String(cause)}`
-        }))));
-        return yield* Effect32.tryPromise(importFromDisk).pipe(Effect32.mapError(() => new EmbeddingError({
+      return Effect33.gen(function* () {
+        yield* Effect33.logInfo("auto-installing @huggingface/transformers (first local-embed use — scripts skipped)").pipe(Effect33.annotateLogs({ scope: "@dimple/embedder", event: "embedder.auto-install" }));
+        yield* Effect33.tryPromise(() => installTransformers(process.cwd())).pipe(Effect33.catch((cause) => {
+          const inner = cause.cause;
+          return Effect33.fail(inner instanceof EmbeddingError ? inner : new EmbeddingError({
+            message: `auto-install failed: ${inner instanceof Error ? inner.message : String(cause)}`
+          }));
+        }));
+        return yield* Effect33.tryPromise(importFromDisk).pipe(Effect33.mapError(() => new EmbeddingError({
           message: "@huggingface/transformers still unavailable after auto-install — run `bun add " + "@huggingface/transformers` manually (or set `autoInstall: false` and configure a hosted embedding provider)"
         })));
       });
     }));
     if (options.cacheDir)
       transformers.env.cacheDir = options.cacheDir;
-    pipe = yield* Effect32.tryPromise(() => transformers.pipeline("feature-extraction", options.modelId ?? defaults2.modelId, {
+    pipe = yield* Effect33.tryPromise(() => transformers.pipeline("feature-extraction", options.modelId ?? defaults2.modelId, {
       device: options.device ?? defaults2.device,
       dtype: options.dtype ?? defaults2.dtype
-    })).pipe(Effect32.mapError((cause) => new EmbeddingError({ message: `load model: ${cause}` })));
+    })).pipe(Effect33.mapError((cause) => new EmbeddingError({ message: `load model: ${cause}` })));
     return pipe;
   });
-  const embed = Effect32.fn("TransformersEmbedding.embed")(function* (texts) {
+  const embed = Effect33.fn("TransformersEmbedding.embed")(function* (texts) {
     const started = Date.now();
     const p = yield* getPipeline();
-    const result = yield* Effect32.promise(() => p(texts, {
+    const result = yield* Effect33.promise(() => p(texts, {
       pooling: options.pooling ?? defaults2.pooling,
       normalize: options.normalize ?? defaults2.normalize
-    })).pipe(Effect32.mapError((cause) => new EmbeddingError({ message: `embed: ${cause}` })));
-    const vectors = result.tolist().map((v) => new Float32Array(v));
+    })).pipe(Effect33.mapError((cause) => new EmbeddingError({ message: `embed: ${cause}` })));
+    const vectors = outputVectors(result);
     for (const vector of vectors) {
       if (options.dimensions !== undefined && vector.length !== options.dimensions) {
         return yield* new EmbeddingError({
@@ -6698,7 +7195,7 @@ var make5 = (options) => {
         });
       }
     }
-    yield* Effect32.logDebug("embedder.embed").pipe(Effect32.annotateLogs({
+    yield* Effect33.logDebug("embedder.embed").pipe(Effect33.annotateLogs({
       scope: "@dimple/embedder",
       event: "embedder.embed",
       count: texts.length,
@@ -6706,13 +7203,13 @@ var make5 = (options) => {
     }));
     return vectors;
   });
-  const embedSingle = Effect32.fn("TransformersEmbedding.embedSingle")(function* (text4) {
+  const embedSingle = Effect33.fn("TransformersEmbedding.embedSingle")(function* (text4) {
     const p = yield* getPipeline();
-    const result = yield* Effect32.promise(() => p(text4, {
+    const result = yield* Effect33.promise(() => p(text4, {
       pooling: options.pooling ?? defaults2.pooling,
       normalize: options.normalize ?? defaults2.normalize
-    })).pipe(Effect32.mapError((cause) => new EmbeddingError({ message: `embedSingle: ${cause}` })));
-    const vector = new Float32Array(result.tolist()[0]);
+    })).pipe(Effect33.mapError((cause) => new EmbeddingError({ message: `embedSingle: ${cause}` })));
+    const vector = outputVectors(result)[0] ?? new Float32Array(0);
     if (options.dimensions !== undefined && vector.length !== options.dimensions) {
       return yield* new EmbeddingError({
         message: `embedder dimension mismatch: model outputs ${vector.length} dims but config declares ${String(options.dimensions)}`
@@ -6733,14 +7230,14 @@ var makeTransformersModel = (options = {}) => {
   };
 };
 // ../embedder/src/registry.ts
-import { Effect as Effect33, Layer as Layer12 } from "effect";
+import { Effect as Effect34, Layer as Layer12 } from "effect";
 // ../core/src/hosted-embedding.ts
 import { embedMany } from "ai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { createCohere } from "@ai-sdk/cohere";
 import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
-import { Effect as Effect34 } from "effect";
+import { Effect as Effect35 } from "effect";
 var makeHostedEmbeddingModel = (options) => {
   const provider = options.provider ?? "openai";
   const model = provider === "google" ? createGoogleGenerativeAI({
@@ -6771,8 +7268,8 @@ var makeHostedEmbeddingModel = (options) => {
         return { openaiCompatible: { dimensions: options.dimensions } };
     }
   })();
-  const embed = Effect34.fn("HostedEmbedding.embed")(function* (texts) {
-    const result = yield* Effect34.tryPromise({
+  const embed = Effect35.fn("HostedEmbedding.embed")(function* (texts) {
+    const result = yield* Effect35.tryPromise({
       try: () => embedMany({ model, values: [...texts], providerOptions }),
       catch: (cause) => new EmbeddingError({ message: `hosted embedMany: ${cause}` })
     });
@@ -6785,7 +7282,7 @@ var makeHostedEmbeddingModel = (options) => {
     }
     return result.embeddings.map((e) => new Float32Array(e));
   });
-  const embedSingle = Effect34.fn("HostedEmbedding.embedSingle")(function* (text4) {
+  const embedSingle = Effect35.fn("HostedEmbedding.embedSingle")(function* (text4) {
     const results = yield* embed([text4]);
     return results[0];
   });
@@ -6799,7 +7296,7 @@ var makeHostedEmbeddingModel = (options) => {
 };
 
 // ../retriever/src/hybrid.ts
-import { Context as Context10, Effect as Effect35, Layer as Layer13, Schema as Schema22 } from "effect";
+import { Context as Context10, Effect as Effect36, Layer as Layer13, Schema as Schema22 } from "effect";
 
 // ../retriever/src/rrf.ts
 function fuse(denseRanks, fts5Ranks, k, limit) {
@@ -6842,15 +7339,15 @@ class HybridError extends Schema22.TaggedErrorClass()("HybridRetrieval.HybridErr
 
 class Service10 extends Context10.Service()("@dimple/retriever/HybridRetrieval") {
 }
-var wrapError = (tag) => (effect) => effect.pipe(Effect35.mapError((cause) => new HybridError({ message: `${tag}: ${cause}` })));
-var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
+var wrapError = (tag) => (effect) => effect.pipe(Effect36.mapError((cause) => new HybridError({ message: `${tag}: ${cause}` })));
+var layer11 = (options) => Layer13.effect(Service10, Effect36.gen(function* () {
   const store = yield* Service5;
   const registry = yield* Service9;
   const defaultId = yield* registry.defaultModelId.pipe(wrapError("defaultModelId"));
   const defaultModel = yield* registry.getModel(defaultId).pipe(wrapError("getModel"));
   const defaultK = options?.defaultK ?? 60;
   const defaultLimit = options?.defaultLimit ?? 10;
-  const hybrid = Effect35.fn("HybridRetrieval.hybrid")(function* (query2, options2) {
+  const hybrid = Effect36.fn("HybridRetrieval.hybrid")(function* (query2, options2) {
     const namespace = options2?.namespace ?? "default";
     const limit = options2?.limit ?? defaultLimit;
     const k = options2?.k ?? defaultK;
@@ -6867,12 +7364,16 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
     const vectorResults = yield* store.searchVector([...embedding], namespace, limit * fetchMultiplier, {
       ...vectorOpts,
       ...options2?.contentType !== undefined ? { contentType: options2.contentType } : {},
-      audit: false
+      audit: false,
+      augment: false,
+      includeEmbedding: options2?.includeEmbedding === true
     }).pipe(wrapError("searchVector"));
     const fts5Results = yield* store.searchFts5(query2, namespace, limit * fetchMultiplier, {
       ...topicKeys !== undefined ? { topicKeys } : {},
       ...options2?.contentType !== undefined ? { contentType: options2.contentType } : {},
-      audit: false
+      audit: false,
+      augment: false,
+      includeEmbedding: options2?.includeEmbedding === true
     }).pipe(wrapError("searchFts5"));
     const vWeight = profile.modeWeights?.vector ?? 1;
     const fWeight = profile.modeWeights?.fts ?? 1;
@@ -6908,25 +7409,15 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
     const now = Date.now();
     const DAY_MS = 86400000;
     const recencyBoost = profile.recencyBoost ?? 0;
-    const augmentedById = new Map;
-    for (const sm of vectorResults)
-      augmentedById.set(sm.memory.id, sm);
-    for (const sm of fts5Results)
-      if (!augmentedById.has(sm.memory.id))
-        augmentedById.set(sm.memory.id, sm);
     const boosted = fused.map((r) => {
       const memory = memoryMap.get(r.memoryId);
       const ageDays = (now - memory.createdAt) / DAY_MS;
       const recencyFactor = 1 / (1 + ageDays);
       const score = r.rrfScore * (1 + recencyBoost * recencyFactor);
-      const aug = augmentedById.get(r.memoryId);
       return {
         memory,
         score,
-        source: "hybrid",
-        ...aug?.supersededBy !== undefined ? { supersededBy: aug.supersededBy } : {},
-        ...aug?.conflicts !== undefined ? { conflicts: aug.conflicts } : {},
-        ...aug?.supportedBy !== undefined ? { supportedBy: aug.supportedBy } : {}
+        source: "hybrid"
       };
     });
     boosted.sort((a, b) => b.score - a.score);
@@ -6959,7 +7450,7 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
         fts: fts5Results.map((s) => s.memory.id)
       })
     }).pipe(wrapError("logAudit"));
-    yield* Effect35.logInfo("hybrid.search").pipe(Effect35.annotateLogs({
+    yield* Effect36.logInfo("hybrid.search").pipe(Effect36.annotateLogs({
       scope: "@dimple/retriever",
       event: "hybrid.search",
       mode,
@@ -6973,7 +7464,7 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
 }));
 var hybridRetrievalLayer = layer11();
 // ../llm/src/llm.ts
-import { Cause as Cause4, Effect as Effect36, Schema as Schema23 } from "effect";
+import { Cause as Cause4, Effect as Effect37, Schema as Schema23 } from "effect";
 import {
   generateText as generateTextCall,
   NoSuchToolError,
@@ -7027,9 +7518,9 @@ var makeLLM = (model, defaults3 = {}) => {
       ...reasoningEffort !== undefined ? { providerOptions: { openaiCompatible: { reasoningEffort } } } : {}
     };
   };
-  const generateText = Effect36.fn("LLM.generateText")(function* (input) {
+  const generateText = Effect37.fn("LLM.generateText")(function* (input) {
     const started = Date.now();
-    const text4 = yield* Effect36.tryPromise({
+    const text4 = yield* Effect37.tryPromise({
       try: () => generateTextCall({
         model,
         prompt: input.prompt,
@@ -7038,16 +7529,16 @@ var makeLLM = (model, defaults3 = {}) => {
       }).then((result) => result.text),
       catch: (cause) => new LLMError({ message: "LLM text generation failed", cause: Cause4.die(cause) })
     });
-    yield* Effect36.logDebug("llm.generate-text").pipe(Effect36.annotateLogs({
+    yield* Effect37.logDebug("llm.generate-text").pipe(Effect37.annotateLogs({
       scope: "@dimple/llm",
       event: "llm.generate-text",
       latencyMs: Date.now() - started
     }));
     return text4;
   });
-  const generateObject = Effect36.fn("LLM.generateObject")(function* (input) {
+  const generateObject = Effect37.fn("LLM.generateObject")(function* (input) {
     const started = Date.now();
-    const result = yield* Effect36.tryPromise({
+    const result = yield* Effect37.tryPromise({
       try: async () => {
         try {
           const result3 = await generateTextCall({
@@ -7090,7 +7581,7 @@ ${schemaJson}`,
       },
       catch: (cause) => new LLMError({ message: "LLM structured generation failed", cause: Cause4.die(cause) })
     });
-    yield* Effect36.logDebug("llm.generate-object").pipe(Effect36.annotateLogs({
+    yield* Effect37.logDebug("llm.generate-object").pipe(Effect37.annotateLogs({
       scope: "@dimple/llm",
       event: "llm.generate-object",
       latencyMs: Date.now() - started
@@ -7110,7 +7601,7 @@ var openAICompatible = (options) => {
   return provider.languageModel(options.modelId ?? "default");
 };
 // ../llm/src/dream-classifier.ts
-import { Effect as Effect37 } from "effect";
+import { Effect as Effect38 } from "effect";
 import { z as z2 } from "zod";
 var EDGE_KINDS = ["memory_supersedes", "memory_contradicts", "memory_supports"];
 var EDGE_KIND_SET = new Set(EDGE_KINDS);
@@ -7157,7 +7648,7 @@ var buildPrompt = (pairs, maxDerived) => [
 ].join(`
 `);
 var makeDreamClassifier = (deps) => {
-  const classify = Effect37.fn("DreamClassifier.classify")(function* (pairs, opts) {
+  const classify = Effect38.fn("DreamClassifier.classify")(function* (pairs, opts) {
     const system = deps.modelId === undefined ? SYSTEM_PROMPT : `${SYSTEM_PROMPT}
 Judging for model: ${deps.modelId}`;
     const judged = yield* deps.llm.generateObject({
@@ -7187,7 +7678,7 @@ Judging for model: ${deps.modelId}`;
   return { classify };
 };
 // ../llm/src/service.ts
-import { Config as Config6, Context as Context11, Effect as Effect38, Layer as Layer14 } from "effect";
+import { Config as Config6, Context as Context11, Effect as Effect39, Layer as Layer14 } from "effect";
 class Service11 extends Context11.Service()("@dimple/LLM") {
 }
 // ../core/src/layer.ts
@@ -7197,7 +7688,7 @@ var DISABLED_LOGGING2 = {
   format: "jsonl",
   ringSize: 4096
 };
-var embedderFromConfig = (model) => model.provider === "transformers" ? Effect39.succeed(makeTransformersModel({
+var embedderFromConfig = (model) => model.provider === "transformers" ? Effect40.succeed(makeTransformersModel({
   modelId: model.model,
   dimensions: model.dimensions,
   ...model.device !== undefined ? { device: model.device } : {},
@@ -7206,14 +7697,14 @@ var embedderFromConfig = (model) => model.provider === "transformers" ? Effect39
   ...model.normalize !== undefined ? { normalize: model.normalize } : {},
   ...model.cacheDir !== undefined ? { cacheDir: model.cacheDir } : {},
   ...model.autoInstall !== undefined ? { autoInstall: model.autoInstall } : {}
-})) : model.provider === "openai" ? model.apiKey === undefined ? Effect39.fail(new EmbeddingError({ message: `OpenAI model ${model.id} requires an apiKey` })) : Effect39.succeed(makeHostedEmbeddingModel({
+})) : model.provider === "openai" ? model.apiKey === undefined ? Effect40.fail(new EmbeddingError({ message: `OpenAI model ${model.id} requires an apiKey` })) : Effect40.succeed(makeHostedEmbeddingModel({
   modelId: model.id,
   model: model.model,
   dimensions: model.dimensions,
   apiKey: model.apiKey,
   ...model.provider !== "openai" ? { provider: model.provider } : {},
   ...model.baseURL !== undefined ? { baseURL: model.baseURL } : {}
-})) : Effect39.fail(new EmbeddingError({ message: `Unknown provider: ${model.provider}` }));
+})) : Effect40.fail(new EmbeddingError({ message: `Unknown provider: ${model.provider}` }));
 var layer13 = (options) => {
   const topicConfig = Schema24.decodeUnknownSync(TopicConfig)(options.topics?.config ?? {});
   const graphConfig = Schema24.decodeUnknownSync(exports_graph.GraphConfig)(options.graph ?? {});
@@ -7221,11 +7712,31 @@ var layer13 = (options) => {
   const defaultModel = models2.get(options.defaultModelId);
   const loggingConfig = options.logging ?? DISABLED_LOGGING2;
   const getModelConfig = (key) => models2.get(key);
-  const storeWithSeams = Layer15.unwrap(Effect39.gen(function* () {
+  const storeWithSeams = Layer15.unwrap(Effect40.gen(function* () {
     const rt = yield* Service7;
-    const enqueueSplit = (topicKey, modelKey) => rt.enqueue(TopicSplit, { topicId: topicKey, modelKey }).pipe(Effect39.asVoid);
-    const enqueueMerge = (topicKey, modelKey) => rt.enqueue(TopicMerge, { topicId: topicKey, modelKey }).pipe(Effect39.asVoid);
-    const enqueueAudit = (row) => rt.enqueue(AuditWrite, { rows: [row] }).pipe(Effect39.asVoid);
+    const enqueueSplit = (topicKey, modelKey) => rt.enqueue(TopicSplit, { topicId: topicKey, modelKey }).pipe(Effect40.asVoid);
+    const enqueueMerge = (topicKey, modelKey) => rt.enqueue(TopicMerge, { topicId: topicKey, modelKey }).pipe(Effect40.asVoid);
+    const auditBuffer = [];
+    let auditTimer;
+    const flushAudit = () => Effect40.gen(function* () {
+      auditTimer = undefined;
+      if (auditBuffer.length === 0)
+        return;
+      const rows = auditBuffer.splice(0, auditBuffer.length);
+      yield* rt.enqueue(AuditWrite, { rows }).pipe(Effect40.asVoid);
+    });
+    const enqueueAudit = (row) => Effect40.gen(function* () {
+      auditBuffer.push(row);
+      if (auditTimer === undefined) {
+        auditTimer = setTimeout(() => {
+          Effect40.runPromise(flushAudit()).catch(() => {});
+        }, 1000);
+        auditTimer.unref?.();
+      }
+      if (auditBuffer.length >= 50) {
+        yield* flushAudit();
+      }
+    });
     return layer8(options.storeUrl, {
       ...options.defaultTtlSecs !== undefined ? { defaultTtlSecs: options.defaultTtlSecs } : {},
       ...options.migrationFolder !== undefined ? { migrationFolder: options.migrationFolder } : {},
@@ -7244,15 +7755,15 @@ var layer13 = (options) => {
       ...options.audit === false ? {} : { enqueueAudit }
     });
   }));
-  const embedderRegistry = Layer15.effect(Service9, Effect39.sync(() => Service9.of({
+  const embedderRegistry = Layer15.effect(Service9, Effect40.sync(() => Service9.of({
     getModel: (id) => {
       const model = models2.get(id);
-      return model !== undefined ? options.embedderFor(model) : Effect39.fail(new EmbeddingError({ message: `Unknown model: ${id}` }));
+      return model !== undefined ? options.embedderFor(model) : Effect40.fail(new EmbeddingError({ message: `Unknown model: ${id}` }));
     },
-    defaultModelId: Effect39.succeed(options.defaultModelId),
-    registerModel: () => Effect39.void
+    defaultModelId: Effect40.succeed(options.defaultModelId),
+    registerModel: () => Effect40.void
   })));
-  const coreService = Layer15.effect(Service, Effect39.gen(function* () {
+  const coreService = Layer15.effect(Service, Effect40.gen(function* () {
     if (defaultModel === undefined) {
       return yield* new CoreConfigError({
         message: `@dimple/core: unknown defaultModelId "${options.defaultModelId}"`
@@ -7265,20 +7776,20 @@ var layer13 = (options) => {
     const hybrid = yield* Service10;
     const logging = yield* Service3;
     const extraByName = new Map((options.extraHandlers ?? []).map((h) => [h.name, h.handler]));
-    const register = (name, handler) => extraByName.has(name) ? Effect39.void : registry.register(name, handler);
+    const register = (name, handler) => extraByName.has(name) ? Effect40.void : registry.register(name, handler);
     yield* register("topic.split", exports_topics.topicSplitHandler({
       getModelConfig,
       config: topicConfig,
       backend,
-      onUnevenSplit: (childKey, modelKey) => rt.enqueue(TopicRebalance, { topicId: childKey, modelKey }).pipe(Effect39.asVoid),
-      onChildOverflow: (childKey, modelKey) => rt.enqueue(TopicSplit, { topicId: childKey, modelKey }).pipe(Effect39.asVoid)
+      onUnevenSplit: (childKey, modelKey) => rt.enqueue(TopicRebalance, { topicId: childKey, modelKey }).pipe(Effect40.asVoid),
+      onChildOverflow: (childKey, modelKey) => rt.enqueue(TopicSplit, { topicId: childKey, modelKey }).pipe(Effect40.asVoid)
     }));
     yield* register("topic.merge", exports_topics.topicMergeHandler({ getModelConfig, config: topicConfig, backend }));
     yield* register("topic.rebalance", exports_topics.topicRebalanceHandler({ getModelConfig, config: topicConfig, backend }));
     yield* register("memory.embed", exports_topics.memoryEmbedHandler({
       getModelConfig,
-      embedOne: (text4, model) => options.embedderFor(model).pipe(Effect39.flatMap((m) => m.embedSingle(text4))),
-      getMemoryContent: (memoryId) => store.get(memoryId).pipe(Effect39.map((m) => m.content)),
+      embedOne: (text4, model) => options.embedderFor(model).pipe(Effect40.flatMap((m) => m.embedSingle(text4))),
+      getMemoryContent: (memoryId) => store.get(memoryId).pipe(Effect40.map((m) => m.content)),
       config: topicConfig,
       backend
     }));
@@ -7293,12 +7804,12 @@ var layer13 = (options) => {
       yield* register("memory.dream", (payload, ctx) => {
         const envelope = payload;
         if (getModelConfig(envelope.modelKey) === undefined) {
-          return Effect39.fail(new JobFailure({
+          return Effect40.fail(new JobFailure({
             jobId: ctx.jobId,
             message: `memory.dream: unknown model "${envelope.modelKey}"`
           }));
         }
-        return Effect39.fail(new JobFailure({
+        return Effect40.fail(new JobFailure({
           jobId: ctx.jobId,
           message: "memory.dream: LLM not configured — provide `llm` to @dimple/core"
         }));
@@ -7333,7 +7844,7 @@ var layer13 = (options) => {
     ...options.defaultLimit !== undefined ? { defaultLimit: options.defaultLimit } : {}
   })), Layer15.provideMerge(embedderRegistry), Layer15.provideMerge(storeWithSeams), Layer15.provideMerge(Layer15.mergeAll(jobStack, layer7, layer(loggingConfig))));
 };
-var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
+var layerConfig7 = (options) => Layer15.unwrap(Effect40.gen(function* () {
   const cfg = yield* Service4;
   const embedding = cfg.config.embedding;
   if (embedding === undefined || embedding.models.length === 0) {
@@ -7367,7 +7878,7 @@ var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
   });
 }));
 // ../extractor/src/code-extractor.ts
-import { Context as Context12, Effect as Effect40, Layer as Layer16 } from "effect";
+import { Context as Context12, Effect as Effect41, Layer as Layer16 } from "effect";
 
 // ../extractor/src/models/extraction.ts
 import { Schema as Schema25 } from "effect";
@@ -7813,9 +8324,9 @@ function extract3(filePath, tree2) {
 // ../extractor/src/code-extractor.ts
 class Service12 extends Context12.Service()("@dimple/extractor/CodeExtractor") {
 }
-var layer14 = Layer16.effect(Service12, Effect40.succeed(Service12.of({
-  extract: Effect40.fn("CodeExtractor.extract")(function* (request) {
-    const result = yield* Effect40.try({
+var layer14 = Layer16.effect(Service12, Effect41.succeed(Service12.of({
+  extract: Effect41.fn("CodeExtractor.extract")(function* (request) {
+    const result = yield* Effect41.try({
       try: () => extract3(request.filePath, request.tree),
       catch: (cause) => new ExtractionError({ message: `Extraction failed for ${request.filePath}`, cause })
     });
@@ -7848,14 +8359,14 @@ var layer15 = Layer17.succeed(Service13, Service13.of({
   extractText: (content) => content
 }));
 // ../parser/src/code-parser.ts
-import { Context as Context19, Effect as Effect47, Layer as Layer24 } from "effect";
+import { Context as Context19, Effect as Effect48, Layer as Layer24 } from "effect";
 import { Parser as Parser2 } from "web-tree-sitter";
 
 // ../parser/src/language-store.ts
-import { Cache, Context as Context18, Effect as Effect46, Layer as Layer23 } from "effect";
+import { Cache, Context as Context18, Effect as Effect47, Layer as Layer23 } from "effect";
 
 // ../wasm/src/wasm-registry.ts
-import { Context as Context14, Effect as Effect41, Layer as Layer18, Schema as Schema30 } from "effect";
+import { Context as Context14, Effect as Effect42, Layer as Layer18, Schema as Schema30 } from "effect";
 
 // ../shared/src/errors/wasm.ts
 import { Schema as Schema27 } from "effect";
@@ -7957,7 +8468,7 @@ for (const grammar of grammars.grammars) {
 
 class Service14 extends Context14.Service()("@dimple/wasm/TreeSitterRegistry") {
   static layer = Layer18.succeed(Service14, Service14.of({
-    resolve: Effect41.fn("TreeSitterRegistry.resolve")(function* (lang) {
+    resolve: Effect42.fn("TreeSitterRegistry.resolve")(function* (lang) {
       const found = registryMap.get(lang);
       if (found === undefined) {
         return yield* new RegistryError2({ message: `Language not found in registry: ${lang}` });
@@ -7967,11 +8478,11 @@ class Service14 extends Context14.Service()("@dimple/wasm/TreeSitterRegistry") {
   }));
 }
 // ../wasm/src/wasm-downloader.ts
-import { Context as Context15, Effect as Effect42, Layer as Layer19 } from "effect";
+import { Context as Context15, Effect as Effect43, Layer as Layer19 } from "effect";
 class Service15 extends Context15.Service()("@dimple/wasm/WasmDownloader") {
-  static layer = Layer19.effect(Service15, Effect42.succeed(Service15.of({
-    download: Effect42.fn("WasmDownloader.download")(function* (url) {
-      const response = yield* Effect42.tryPromise({
+  static layer = Layer19.effect(Service15, Effect43.succeed(Service15.of({
+    download: Effect43.fn("WasmDownloader.download")(function* (url) {
+      const response = yield* Effect43.tryPromise({
         try: () => fetch(url),
         catch: (cause) => new WasmDownloadError({
           message: `Failed to fetch from ${url}`,
@@ -7985,7 +8496,7 @@ class Service15 extends Context15.Service()("@dimple/wasm/WasmDownloader") {
           url
         });
       }
-      const arrayBuffer = yield* Effect42.tryPromise({
+      const arrayBuffer = yield* Effect43.tryPromise({
         try: () => response.arrayBuffer(),
         catch: (cause) => new WasmDownloadError({
           message: `Failed to read response from ${url}`,
@@ -7998,7 +8509,7 @@ class Service15 extends Context15.Service()("@dimple/wasm/WasmDownloader") {
   })));
 }
 // ../wasm/src/wasm-cache.ts
-import { Context as Context16, Effect as Effect43, Layer as Layer20 } from "effect";
+import { Context as Context16, Effect as Effect44, Layer as Layer20 } from "effect";
 import { existsSync as existsSync3, mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { join as join3 } from "node:path";
 
@@ -8095,35 +8606,35 @@ var paths = envPaths("dimple");
 
 class Service16 extends Context16.Service()("@dimple/wasm/WasmCache") {
 }
-var layer16 = Layer20.effect(Service16, Effect43.succeed(Service16.of({
-  ensure: Effect43.fn("WasmCache.ensure")(function* (lang, version, download) {
+var layer16 = Layer20.effect(Service16, Effect44.succeed(Service16.of({
+  ensure: Effect44.fn("WasmCache.ensure")(function* (lang, version, download) {
     const versionDir = join3(paths.cache, "tree-sitter", lang, version);
     const finalPath = join3(versionDir, "parser.wasm");
-    const exists = yield* Effect43.try({
+    const exists = yield* Effect44.try({
       try: () => existsSync3(finalPath),
       catch: (cause) => new WasmCacheError({ message: `Failed to stat ${finalPath}`, cause })
     });
     if (exists)
       return finalPath;
-    yield* Effect43.try({
+    yield* Effect44.try({
       try: () => mkdirSync(versionDir, { recursive: true }),
       catch: (cause) => new WasmCacheError({ message: `Failed to create ${versionDir}`, cause })
     });
     const tempPath = join3(versionDir, `.tmp-${process.pid}`);
     const wasm = yield* download;
-    yield* Effect43.try({
+    yield* Effect44.try({
       try: () => writeFileSync(tempPath, wasm),
       catch: (cause) => new WasmCacheError({ message: `Failed to write ${tempPath}`, cause })
     });
-    const renamed = yield* Effect43.try({
+    const renamed = yield* Effect44.try({
       try: () => {
         renameSync(tempPath, finalPath);
         return true;
       },
       catch: (cause) => new WasmCacheError({ message: `Failed to rename ${tempPath}`, cause })
-    }).pipe(Effect43.catchCause(() => Effect43.succeed(false)));
+    }).pipe(Effect44.catchCause(() => Effect44.succeed(false)));
     if (!renamed) {
-      const existsAfter = yield* Effect43.try({
+      const existsAfter = yield* Effect44.try({
         try: () => existsSync3(finalPath),
         catch: (cause) => new WasmCacheError({ message: `Failed to stat ${finalPath}`, cause })
       });
@@ -8137,25 +8648,25 @@ var layer16 = Layer20.effect(Service16, Effect43.succeed(Service16.of({
   })
 })));
 // ../wasm/src/grammar-store.ts
-import { Context as Context17, Effect as Effect44, Layer as Layer21 } from "effect";
+import { Context as Context17, Effect as Effect45, Layer as Layer21 } from "effect";
 class Service17 extends Context17.Service()("@dimple/wasm/GrammarStore") {
 }
-var layer17 = Layer21.effect(Service17, Effect44.gen(function* () {
+var layer17 = Layer21.effect(Service17, Effect45.gen(function* () {
   const registry = yield* Service14;
   const downloader = yield* Service15;
   const cache = yield* Service16;
-  const ensure = Effect44.fn("GrammarStore.ensure")(function* (lang) {
-    const metadata = yield* registry.resolve(lang).pipe(Effect44.mapError((cause) => new GrammarProvisionError({
+  const ensure = Effect45.fn("GrammarStore.ensure")(function* (lang) {
+    const metadata = yield* registry.resolve(lang).pipe(Effect45.mapError((cause) => new GrammarProvisionError({
       language: lang,
       message: `Failed to resolve grammar metadata for: ${lang}`,
       cause
     })));
-    const wasmBytes = yield* downloader.download(metadata.url).pipe(Effect44.mapError((cause) => new GrammarProvisionError({
+    const wasmBytes = yield* downloader.download(metadata.url).pipe(Effect45.mapError((cause) => new GrammarProvisionError({
       language: lang,
       message: `Failed to download grammar for: ${lang}`,
       cause
     })));
-    const path2 = yield* cache.ensure(lang, metadata.version, Effect44.succeed(wasmBytes)).pipe(Effect44.mapError((cause) => new GrammarProvisionError({
+    const path2 = yield* cache.ensure(lang, metadata.version, Effect45.succeed(wasmBytes)).pipe(Effect45.mapError((cause) => new GrammarProvisionError({
       language: lang,
       message: `Failed to provision grammar for: ${lang}`,
       cause
@@ -8169,9 +8680,9 @@ var allLive = layer17.pipe(Layer21.provideMerge(Layer21.mergeAll(Service14.layer
 import { Language } from "web-tree-sitter";
 
 // ../parser/src/tree-sitter-engine.ts
-import { Effect as Effect45, Layer as Layer22 } from "effect";
+import { Effect as Effect46, Layer as Layer22 } from "effect";
 import { Parser } from "web-tree-sitter";
-var layer18 = Layer22.effectDiscard(Effect45.tryPromise({
+var layer18 = Layer22.effectDiscard(Effect46.tryPromise({
   try: () => Parser.init(),
   catch: (cause) => new ParserInitError({ message: "Failed to initialize tree sitter", cause })
 }));
@@ -8179,20 +8690,20 @@ var layer18 = Layer22.effectDiscard(Effect45.tryPromise({
 // ../parser/src/language-store.ts
 class Service18 extends Context18.Service()("@dimple/parser/LanguageStore") {
 }
-var layer19 = Layer23.effect(Service18, Effect46.gen(function* () {
+var layer19 = Layer23.effect(Service18, Effect47.gen(function* () {
   const grammarStore = yield* Service17;
   const resolveLang = (lang) => lang === "jsx" ? "javascript" : lang;
   const cache = yield* Cache.make({
     capacity: 100,
     timeToLive: Infinity,
-    lookup: (lang) => Effect46.gen(function* () {
+    lookup: (lang) => Effect47.gen(function* () {
       const grammarLang = resolveLang(lang);
-      const wasmPath = yield* grammarStore.ensure(grammarLang).pipe(Effect46.mapError((e) => new LanguageLoadError({
+      const wasmPath = yield* grammarStore.ensure(grammarLang).pipe(Effect47.mapError((e) => new LanguageLoadError({
         lang,
         message: `Failed to provision grammar for ${lang}`,
         cause: e
       })));
-      return yield* Effect46.tryPromise({
+      return yield* Effect47.tryPromise({
         try: () => Language.load(wasmPath),
         catch: (cause) => new LanguageLoadError({ lang, message: `Failed to load language: ${lang}`, cause })
       });
@@ -8215,15 +8726,20 @@ var TreeHandle = Schema31.Struct({
 // ../parser/src/code-parser.ts
 class Service19 extends Context19.Service()("@dimple/parser/CodeParser") {
 }
-var layer20 = Layer24.effect(Service19, Effect47.gen(function* () {
+var layer20 = Layer24.effect(Service19, Effect48.gen(function* () {
   const languageStore = yield* Service18;
-  const parse2 = Effect47.fn("CodeParser.parse")(function* (request) {
-    const language = yield* languageStore.get(request.lang).pipe(Effect47.mapError((cause) => new ParseError({
+  const parserByLanguage = new Map;
+  const parse2 = Effect48.fn("CodeParser.parse")(function* (request) {
+    const language = yield* languageStore.get(request.lang).pipe(Effect48.mapError((cause) => new ParseError({
       message: `Failed to load language '${request.lang}' for parsing`,
       cause
     })));
-    const parser = new Parser2;
-    parser.setLanguage(language);
+    let parser = parserByLanguage.get(request.lang);
+    if (parser === undefined) {
+      parser = new Parser2;
+      parser.setLanguage(language);
+      parserByLanguage.set(request.lang, parser);
+    }
     const tree2 = parser.parse(request.source);
     if (!tree2) {
       return yield* new ParseError({ message: "Failed to parse source" });
@@ -8239,7 +8755,7 @@ var ParseRequest = Schema32.Struct({
   source: Schema32.String
 });
 // src/config.ts
-import { Effect as Effect48, Layer as Layer25 } from "effect";
+import { Effect as Effect49, Layer as Layer25 } from "effect";
 
 // src/errors.ts
 import { Schema as Schema33 } from "effect";
@@ -8363,13 +8879,13 @@ var remapError = (error) => {
 };
 
 // src/config.ts
-var resolveConfigInput = Effect48.fn("Sdk.resolveConfigInput")(function* (input) {
-  return yield* (typeof input === "string" ? loadConfigFromFile(input) : loadConfig(input)).pipe(Effect48.mapError((error) => new ConfigError({ message: error.message })));
+var resolveConfigInput = Effect49.fn("Sdk.resolveConfigInput")(function* (input) {
+  return yield* (typeof input === "string" ? loadConfigFromFile(input) : loadConfig(input)).pipe(Effect49.mapError((error) => new ConfigError({ message: error.message })));
 });
-var configLayerFromInput = (input) => Layer25.effect(Service4, resolveConfigInput(input).pipe(Effect48.map((config) => Service4.of({ config }))));
+var configLayerFromInput = (input) => Layer25.effect(Service4, resolveConfigInput(input).pipe(Effect49.map((config) => Service4.of({ config }))));
 
 // src/dimple.ts
-import { Cause as Cause5, Effect as Effect49, Exit as Exit6 } from "effect";
+import { Cause as Cause5, Effect as Effect50, Exit as Exit7 } from "effect";
 
 // src/indexer.ts
 import { execFileSync } from "node:child_process";
@@ -8417,8 +8933,8 @@ var walkFiles = (paths2, extensions) => {
   const files = [];
   const errors3 = [];
   let unsupported = 0;
-  const resolved = paths2.map((p) => resolve(p));
-  const root = commonRoot([...resolved, process.cwd()]);
+  const resolved = paths2.map((p) => resolve(process.env["DIMPLE_CWD"] ?? process.cwd(), p));
+  const root = commonRoot([...resolved, process.env["DIMPLE_CWD"] ?? process.cwd()]);
   const visit = (path2) => {
     let stat;
     try {
@@ -8609,7 +9125,7 @@ var makeFacade = (state, reload, dispose) => {
     }
     return;
   };
-  const runQuery = (text4, options) => run(Effect49.gen(function* () {
+  const runQuery = (text4, options) => run(Effect50.gen(function* () {
     if (typeof text4 !== "string") {
       return yield* new InputError({ message: "query: text must be a string" });
     }
@@ -8622,7 +9138,7 @@ var makeFacade = (state, reload, dispose) => {
     let rows = yield* core().hybrid.hybrid(text4, {
       ...rest,
       ...capLimit !== undefined ? { limit: capLimit } : {}
-    }).pipe(Effect49.map((r) => [...r]));
+    }).pipe(Effect50.map((r) => [...r]));
     let truncated = false;
     if (budget?.maxChars !== undefined && budget.maxChars > 0) {
       let used = 0;
@@ -8712,7 +9228,7 @@ var makeFacade = (state, reload, dispose) => {
     }
     return;
   };
-  const writeUnit = (input, embed) => Effect49.gen(function* () {
+  const writeUnit = (input, embed) => Effect50.gen(function* () {
     const mem = yield* core().store.write(input);
     if (embed) {
       yield* core().store.ensureTopicTree(core().defaultModel.id);
@@ -8722,8 +9238,8 @@ var makeFacade = (state, reload, dispose) => {
     }
     return mem;
   });
-  const upsertUnit = (input, embed) => Effect49.gen(function* () {
-    const existing = yield* core().store.getByKey(input.logicalKey, input.namespace ?? "default").pipe(Effect49.catchTag("Store.NotFound", () => Effect49.succeed(undefined)));
+  const upsertUnit = (input, embed) => Effect50.gen(function* () {
+    const existing = yield* core().store.getByKey(input.logicalKey, input.namespace ?? "default").pipe(Effect50.catchTag("Store.NotFound", () => Effect50.succeed(undefined)));
     if (existing !== undefined && existing.content === input.content) {
       const stamp = codeVersionOf(input.metadata);
       if (stamp !== undefined && codeVersionOf(existing.metadata) === undefined) {
@@ -8788,7 +9304,7 @@ var makeFacade = (state, reload, dispose) => {
     return;
   };
   const messageOf3 = (cause) => cause instanceof Error ? cause.message : String(cause);
-  const resolveMemory = (idOrKey) => core().store.get(idOrKey).pipe(Effect49.catchTag("Store.NotFound", () => core().store.getByKey(idOrKey, "default").pipe(Effect49.catchTag("Store.NotFound", () => Effect49.fail(new NotFoundError({ id: idOrKey, message: `Memory not found: ${idOrKey}` }))))));
+  const resolveMemory = (idOrKey) => core().store.get(idOrKey).pipe(Effect50.catchTag("Store.NotFound", () => core().store.getByKey(idOrKey, "default").pipe(Effect50.catchTag("Store.NotFound", () => Effect50.fail(new NotFoundError({ id: idOrKey, message: `Memory not found: ${idOrKey}` }))))));
   const codeVersionOf = (blob) => {
     if (blob === undefined || blob === null)
       return;
@@ -8805,16 +9321,42 @@ var makeFacade = (state, reload, dispose) => {
     get defaultModelId() {
       return core().defaultModel.id;
     },
-    write: (input, options) => run(Effect49.gen(function* () {
+    write: (input, options) => run(Effect50.gen(function* () {
       const invalid = validateWriteInput(input);
       if (invalid !== undefined)
         return yield* invalid;
       return yield* writeUnit(input, options?.embed !== false);
     })),
+    writeMany: (units, options) => run(Effect50.gen(function* () {
+      if (!Array.isArray(units)) {
+        return yield* new InputError({ message: "writeMany: units must be an array" });
+      }
+      for (const input of units) {
+        const invalid = validateWriteInput(input);
+        if (invalid !== undefined)
+          return yield* invalid;
+      }
+      const mems = yield* core().store.writeMany(units);
+      if (options?.embed !== false) {
+        yield* core().store.ensureTopicTree(core().defaultModel.id);
+        const EMBED_CHUNK = 64;
+        const vectors = [];
+        for (let i = 0;i < mems.length; i += EMBED_CHUNK) {
+          const chunk = mems.slice(i, i + EMBED_CHUNK).map((m) => m.content);
+          const vs = yield* core().defaultEmbedder.embed(chunk);
+          vectors.push(...vs);
+        }
+        yield* core().store.updateEmbeddingMany(mems.map((mem, i) => ({ id: mem.id, embedding: [...vectors[i]] })), core().defaultModel.id);
+        return yield* Effect50.forEach(mems, (mem) => core().store.get(mem.id), {
+          discard: false
+        });
+      }
+      return mems;
+    })),
     get: (id) => run(resolveMemory(id)),
     query: runQuery,
-    forget: (id) => run(resolveMemory(id).pipe(Effect49.flatMap((memory) => core().store.forget(memory.id)))),
-    index: (options) => run(Effect49.gen(function* () {
+    forget: (id) => run(resolveMemory(id).pipe(Effect50.flatMap((memory) => core().store.forget(memory.id)))),
+    index: (options) => run(Effect50.gen(function* () {
       const invalid = validateIndexOptions(options);
       if (invalid !== undefined)
         return yield* invalid;
@@ -8824,7 +9366,7 @@ var makeFacade = (state, reload, dispose) => {
       const maxFileBytes = options.maxFileBytes ?? 64 * 1024;
       const maxChunkBytes = options.maxChunkBytes ?? 8 * 1024;
       const extensions = [...options.extensions ?? INDEXABLE_EXTENSIONS];
-      const walk = yield* Effect49.try({
+      const walk = yield* Effect50.try({
         try: () => walkFiles([...options.paths], extensions),
         catch: (cause) => new InputError({
           message: `index: failed to walk paths: ${messageOf3(cause)}`
@@ -8854,8 +9396,8 @@ var makeFacade = (state, reload, dispose) => {
         if (language === undefined)
           continue;
         const chunkKeyOf = (chunkId) => `${keyPrefix}${relative}#${stableChunkId(chunkId)}`;
-        const exit = yield* Effect49.exit(Effect49.gen(function* () {
-          const source = yield* Effect49.try({
+        const exit = yield* Effect50.exit(Effect50.gen(function* () {
+          const source = yield* Effect50.try({
             try: () => readCapped(filePath, maxFileBytes),
             catch: (cause) => new InputError({ message: `read failed: ${messageOf3(cause)}` })
           });
@@ -8937,13 +9479,14 @@ var makeFacade = (state, reload, dispose) => {
               }
             }
           }
-          for (const target of resolveImports(filePath, (extracted.imports ?? []).map((imp) => imp.source), extensions)) {
+          const importTargets = resolveImports(filePath, (extracted.imports ?? []).map((imp) => imp.source), extensions);
+          for (const target of importTargets) {
             pendingEdges.push({
               from: `${keyPrefix}${keyForPath(walk.root, target)}`,
               to: fileKey
             });
           }
-          const importRels = resolveImports(filePath, (extracted.imports ?? []).map((imp) => imp.source), extensions).map((target) => keyForPath(walk.root, target));
+          const importRels = importTargets.map((target) => keyForPath(walk.root, target));
           for (const chunk of extracted.chunks) {
             const callerKey = chunkKeyOf(chunk.id);
             if (!unitIds.has(callerKey))
@@ -8961,7 +9504,7 @@ var makeFacade = (state, reload, dispose) => {
           }
           return { units, upd, dups };
         }));
-        if (Exit6.isFailure(exit)) {
+        if (Exit7.isFailure(exit)) {
           failed.push({ filePath, message: Cause5.pretty(exit.cause) });
         } else {
           indexed += exit.value.units;
@@ -8975,14 +9518,14 @@ var makeFacade = (state, reload, dispose) => {
       const resolveKey = (key) => {
         const fromMap = unitIds.get(key);
         if (fromMap !== undefined)
-          return Effect49.succeed(fromMap);
-        return core().store.getByKey(key, namespace ?? "default").pipe(Effect49.map((m) => m.id), Effect49.catchTag("Store.NotFound", () => Effect49.succeed(undefined)));
+          return Effect50.succeed(fromMap);
+        return core().store.getByKey(key, namespace ?? "default").pipe(Effect50.map((m) => m.id), Effect50.catchTag("Store.NotFound", () => Effect50.succeed(undefined)));
       };
-      const edgeEffect = (edge) => Effect49.gen(function* () {
-        const [from, to] = yield* Effect49.all([resolveKey(edge.from), resolveKey(edge.to)]);
+      const edgeEffect = (edge) => Effect50.gen(function* () {
+        const [from, to] = yield* Effect50.all([resolveKey(edge.from), resolveKey(edge.to)]);
         if (from === undefined || to === undefined || from === to)
           return;
-        yield* Effect49.exit(core().store.addEdge({
+        yield* Effect50.exit(core().store.addEdge({
           fromMemoryId: from,
           toMemoryId: to,
           edgeKind: edge.edgeKind,
@@ -8992,10 +9535,10 @@ var makeFacade = (state, reload, dispose) => {
         }));
       });
       for (const edge of pendingEdges) {
-        yield* Effect49.exit(edgeEffect({ ...edge, edgeKind: "memory_supports" }));
+        yield* Effect50.exit(edgeEffect({ ...edge, edgeKind: "memory_supports" }));
       }
       for (const edge of pendingCallEdges) {
-        yield* Effect49.exit(edgeEffect({ ...edge, edgeKind: "code_calls" }));
+        yield* Effect50.exit(edgeEffect({ ...edge, edgeKind: "code_calls" }));
       }
       return {
         files: walk.files.length,
@@ -9008,7 +9551,7 @@ var makeFacade = (state, reload, dispose) => {
         failed
       };
     })),
-    updateEmbedding: (id, embedding, modelKey) => run(Effect49.gen(function* () {
+    updateEmbedding: (id, embedding, modelKey) => run(Effect50.gen(function* () {
       if (!Array.isArray(embedding) || embedding.length === 0 || embedding.some((v) => typeof v !== "number" || !Number.isFinite(v))) {
         return yield* new InputError({
           message: "updateEmbedding: embedding must be a non-empty array of finite numbers"
@@ -9019,10 +9562,10 @@ var makeFacade = (state, reload, dispose) => {
       yield* core().store.ensureTopicTree(key);
       yield* core().store.updateEmbedding(memory.id, [...embedding], key);
     })),
-    embed: (text4) => run(core().defaultEmbedder.embedSingle(text4).pipe(Effect49.map((vector) => [...vector]))),
-    dream: (modelKey) => run(core().runtime.enqueue(MemoryDream, { modelKey, runId: crypto.randomUUID() }).pipe(Effect49.flatMap((jobId) => core().runtime.wait(jobId)), Effect49.asVoid)),
+    embed: (text4) => run(core().defaultEmbedder.embedSingle(text4).pipe(Effect50.map((vector) => [...vector]))),
+    dream: (modelKey) => run(core().runtime.enqueue(MemoryDream, { modelKey, runId: crypto.randomUUID() }).pipe(Effect50.flatMap((jobId) => core().runtime.wait(jobId)), Effect50.asVoid)),
     dbSchema: () => run(core().store.listSchema()),
-    repair: (modelKey) => run(core().runtime.enqueue(GraphRepair, { modelKey, runId: crypto.randomUUID() }).pipe(Effect49.flatMap((jobId) => core().runtime.wait(jobId)), Effect49.asVoid)),
+    repair: (modelKey) => run(core().runtime.enqueue(GraphRepair, { modelKey, runId: crypto.randomUUID() }).pipe(Effect50.flatMap((jobId) => core().runtime.wait(jobId)), Effect50.asVoid)),
     explain: (input, options) => run(core().store.explain(input, {
       ...options?.edgeKinds !== undefined ? { edgeKinds: options.edgeKinds } : {},
       ...options?.maxDepth !== undefined ? { maxDepth: options.maxDepth } : {},
@@ -9032,7 +9575,7 @@ var makeFacade = (state, reload, dispose) => {
     })),
     health: (modelKey) => run(core().store.topicHealth(modelKey)),
     graph: {
-      addEdge: (input) => run(Effect49.gen(function* () {
+      addEdge: (input) => run(Effect50.gen(function* () {
         const invalid = validateAddEdgeInput(input);
         if (invalid !== undefined)
           return yield* invalid;
@@ -9074,24 +9617,24 @@ var diffConfig = (oldC, newC) => {
 };
 var RELOAD_DRAIN_MS = 30000;
 var bootStack = async (options) => {
-  const scope = await Effect50.runPromise(Scope5.make());
+  const scope = await Effect51.runPromise(Scope5.make());
   let runtime;
   try {
     const layer21 = ("core" in options ? layer13(options.core) : layerConfig7(options.migrationFolder !== undefined ? { migrationFolder: options.migrationFolder } : {}).pipe(Layer26.provide(configLayerFromInput(options.config)))).pipe(Layer26.provide(Layer26.succeed(Scope5.Scope, scope)));
     const appLayer = Layer26.mergeAll(layer21, layer20, layer14);
     const rt = ManagedRuntime.make(appLayer);
     runtime = rt;
-    const [core, parser, extractor] = await rt.runPromise(Effect50.all([Service, Service19, Service12]));
+    const [core, parser, extractor] = await rt.runPromise(Effect51.all([Service, Service19, Service12]));
     return {
       runPromise: (effect) => rt.runPromise(effect),
       disposeEffect: rt.disposeEffect,
       core,
       parser,
       extractor,
-      dispose: () => Effect50.runPromise(Scope5.close(scope, Exit7.void).pipe(Effect50.andThen(rt.disposeEffect)))
+      dispose: () => Effect51.runPromise(Scope5.close(scope, Exit8.void).pipe(Effect51.andThen(rt.disposeEffect)))
     };
   } catch (cause) {
-    await Effect50.runPromise(Scope5.close(scope, Exit7.void).pipe(Effect50.andThen(runtime?.disposeEffect ?? Effect50.void))).catch(() => {
+    await Effect51.runPromise(Scope5.close(scope, Exit8.void).pipe(Effect51.andThen(runtime?.disposeEffect ?? Effect51.void))).catch(() => {
       return;
     });
     return Promise.reject(cause);
@@ -9102,7 +9645,7 @@ var makeDimple = async (options) => {
   const migrationFolder = "config" in options ? options.migrationFolder : undefined;
   let currentConfig;
   if (configSource !== undefined) {
-    currentConfig = await Effect50.runPromise(resolveConfigInput(configSource)).catch((cause) => Promise.reject(remapError(cause)));
+    currentConfig = await Effect51.runPromise(resolveConfigInput(configSource)).catch((cause) => Promise.reject(remapError(cause)));
   }
   let current = await bootStack(configSource !== undefined && currentConfig !== undefined ? {
     config: currentConfig,
@@ -9111,7 +9654,7 @@ var makeDimple = async (options) => {
   let disposed = false;
   let gate = Promise.resolve();
   let releaseGate;
-  let inflight = 0;
+  let inflight2 = 0;
   let drainWaiters = [];
   let reloadChain = Promise.resolve();
   const run = (effect) => {
@@ -9123,12 +9666,12 @@ var makeDimple = async (options) => {
         return Promise.reject(new StoreFailure({ message: "SDK disposed" }));
       }
       const stack = current;
-      inflight += 1;
-      return stack.runPromise(effect.pipe(Effect50.mapError(remapError))).catch((cause) => {
+      inflight2 += 1;
+      return stack.runPromise(effect.pipe(Effect51.mapError(remapError))).catch((cause) => {
         return Promise.reject(remapError(cause));
       }).finally(() => {
-        inflight -= 1;
-        if (inflight === 0 && drainWaiters.length > 0) {
+        inflight2 -= 1;
+        if (inflight2 === 0 && drainWaiters.length > 0) {
           const waiters = drainWaiters;
           drainWaiters = [];
           for (const wake of waiters)
@@ -9149,7 +9692,7 @@ var makeDimple = async (options) => {
     release?.();
   };
   const drain = () => {
-    if (inflight === 0)
+    if (inflight2 === 0)
       return Promise.resolve();
     return new Promise((resolve2) => {
       drainWaiters.push(resolve2);
@@ -9180,7 +9723,7 @@ var makeDimple = async (options) => {
         }));
       }
       const nextInput = input ?? configSource;
-      const resolved = await Effect50.runPromise(resolveConfigInput(nextInput));
+      const resolved = await Effect51.runPromise(resolveConfigInput(nextInput));
       if (currentConfig !== undefined && stableKey(resolved) === stableKey(currentConfig)) {
         return {
           config: resolved,
@@ -9203,10 +9746,10 @@ var makeDimple = async (options) => {
         currentConfig = resolved;
         await old.dispose();
         if (changes.storeUrl) {
-          await Effect50.runPromise(Effect50.logWarning(`reload: store database switched "${oldStoreUrl}" → "${resolved.storeUrl}" — ` + "the old db is preserved but no longer served (nothing was migrated)").pipe(Effect50.annotateLogs({ scope: "@dimple/sdk", event: "reload.store.switch" })));
+          await Effect51.runPromise(Effect51.logWarning(`reload: store database switched "${oldStoreUrl}" → "${resolved.storeUrl}" — ` + "the old db is preserved but no longer served (nothing was migrated)").pipe(Effect51.annotateLogs({ scope: "@dimple/sdk", event: "reload.store.switch" })));
         }
         if (changes.jobsUrl) {
-          await Effect50.runPromise(Effect50.logWarning(`reload: jobs database switched "${oldJobsUrl}" → "${resolved.jobs?.dbUrl}" — ` + "pending jobs remain durable in the old db").pipe(Effect50.annotateLogs({ scope: "@dimple/sdk", event: "reload.jobs.switch" })));
+          await Effect51.runPromise(Effect51.logWarning(`reload: jobs database switched "${oldJobsUrl}" → "${resolved.jobs?.dbUrl}" — ` + "pending jobs remain durable in the old db").pipe(Effect51.annotateLogs({ scope: "@dimple/sdk", event: "reload.jobs.switch" })));
         }
         return { config: resolved, changed: changes, reloaded: true };
       } finally {