@ponraaj/dimple-sdk 0.0.0-alpha.13 → 0.0.0-alpha.14

package/dist/index.js

@@ -29,10 +29,10 @@ class CoreConfigError extends Schema.TaggedError()("core.ConfigError", {
 class Service extends Context.Service()("@dimple/core/Core") {
 }
 // ../core/src/layer.ts
-import { Effect as Effect39, Layer as Layer15, Schedule as Schedule2, Schema as Schema29 } from "effect";
+import { Effect as Effect40, Layer as Layer16, Schedule as Schedule2, Schema as Schema29 } from "effect";
 
 // ../store/src/store.ts
-import { Config as Config4, Effect as Effect25, Layer as Layer10, Schema as Schema23 } from "effect";
+import { Config as Config4, Effect as Effect26, Layer as Layer11, Schema as Schema23 } 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 sql8 } from "drizzle-orm";
 
 // ../store/src/db-backend.ts
@@ -2611,7 +2611,7 @@ var routeInsertMany = Effect10.fn("topics.routeInsertMany")(function* (entries,
         children.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
       }
       const membershipRows = [];
-      const topicDelta = new Map;
+      const topicFinal = new Map;
       const outcomes = [];
       for (const entry of entries) {
         const x = new Float32Array(entry.vector);
@@ -2634,12 +2634,12 @@ var routeInsertMany = Effect10.fn("topics.routeInsertMany")(function* (entries,
           modelKey: model.id,
           updatedAt: now
         });
-        const acc = topicDelta.get(topicKey);
+        const acc = topicFinal.get(topicKey);
         if (acc) {
-          acc.count += 1;
+          acc.memberCount = leafCf.count;
           acc.ss = leafCf.ss;
         } else {
-          topicDelta.set(topicKey, { count: 1, ss: leafCf.ss });
+          topicFinal.set(topicKey, { memberCount: leafCf.count, ss: leafCf.ss });
         }
         let ancestorKey = parentOf.get(topicKey);
         while (ancestorKey !== undefined) {
@@ -2650,11 +2650,11 @@ var routeInsertMany = Effect10.fn("topics.routeInsertMany")(function* (entries,
           row.memberCount += 1;
           const ancestorSum = addToSum(sumOf(ancestorKey), x);
           sumByTopic.set(ancestorKey, ancestorSum);
-          const accA = topicDelta.get(ancestorKey);
+          const accA = topicFinal.get(ancestorKey);
           if (accA)
-            accA.count += 1;
+            accA.memberCount = row.memberCount;
           else
-            topicDelta.set(ancestorKey, { count: 1, ss: row.sumSquares });
+            topicFinal.set(ancestorKey, { memberCount: row.memberCount, ss: row.sumSquares });
           ancestorKey = parentOf.get(ancestorKey);
         }
         outcomes.push({
@@ -2664,14 +2664,14 @@ var routeInsertMany = Effect10.fn("topics.routeInsertMany")(function* (entries,
         });
       }
       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)));
+      for (const [key, final] of topicFinal) {
+        await tx.update(topics).set({ memberCount: final.memberCount, sumSquares: final.ss, updatedAt: now }).where(and(eq(topics.topicKey, key), eq(topics.modelKey, model.id)));
       }
-      return { outcomes, topicDelta };
+      return { outcomes, topicFinal };
     }),
     catch: (cause) => cause
   }).pipe(routingFailure("topics.routeInsertMany"));
-  yield* backend.upsertTopicVectors(Array.from(result.topicDelta, ([topicKey]) => ({
+  yield* backend.upsertTopicVectors(Array.from(result.topicFinal, ([topicKey]) => ({
     topicKey,
     sumVector: Array.from(sumByTopic.get(topicKey) ?? zeros)
   })), model).pipe(routingFailure("topics.routeInsertMany"));
@@ -2772,7 +2772,7 @@ var resolveTopics = Effect11.fn("topics.resolveTopics")(function* (queryVector,
 });
 
 // ../store/src/topics/lifecycle.ts
-import { Clock as Clock3, Cause as Cause3, Effect as Effect20, Exit as Exit6 } from "effect";
+import { Clock as Clock3, Cause as Cause3, Effect as Effect21, Exit as Exit6 } from "effect";
 import { and as and3, eq as eq3, inArray, ne, sql as sql3 } from "drizzle-orm";
 
 // ../workflow/src/queue.ts
@@ -2935,12 +2935,12 @@ var queues = [
 import {
   Cause,
   Clock as Clock2,
-  Context as Context8,
+  Context as Context9,
   Deferred as Deferred2,
   Duration,
-  Effect as Effect17,
+  Effect as Effect18,
   Exit as Exit5,
-  Layer as Layer7,
+  Layer as Layer8,
   Option as Option8,
   Schema as Schema18
 } from "effect";
@@ -3085,7 +3085,7 @@ var notifyExecutionDone = (executionId) => Effect14.gen(function* () {
 });
 
 // ../workflow/src/engine.ts
-import { Effect as Effect16, Exit as Exit4, Fiber, FiberMap, Layer as Layer6, Option as Option7, Schema as Schema17 } from "effect";
+import { Effect as Effect17, Exit as Exit4, Fiber, FiberMap, Layer as Layer7, Option as Option7, Schema as Schema17 } from "effect";
 import { Workflow as Workflow3, WorkflowEngine as WorkflowEngine2 } from "effect/workflow";
 import { Persistence as PersistenceNamespace2, PersistedQueue } from "effect/persistence";
 
@@ -3242,20 +3242,42 @@ var make5 = (options) => Effect15.gen(function* () {
 var layerConfig2 = (config) => Layer5.effectContext(Config3.unwrap(config).pipe(Effect15.flatMap(make5), Effect15.map((client) => Context7.make(LibsqlClient, client).pipe(Context7.add(Client.SqlClient, client))))).pipe(Layer5.provide(Reactivity.layer));
 var layer5 = (config) => Layer5.effectContext(Effect15.map(make5(config), (client) => Context7.make(LibsqlClient, client).pipe(Context7.add(Client.SqlClient, client)))).pipe(Layer5.provide(Reactivity.layer));
 // ../workflow/src/engine.ts
-import { SqlError as SqlErrorNamespace } from "effect/sql";
+import { SqlError as SqlErrorNamespace2 } from "effect/sql";
+
+// ../workflow/src/stats.ts
+import { Context as Context8, Effect as Effect16, Layer as Layer6 } from "effect";
+import { SqlClient as SqlClient2 } from "effect/sql";
+class Service7 extends Context8.Service()("@dimple/workflow/QueueStats") {
+}
+var layer6 = Layer6.effect(Service7, Effect16.gen(function* () {
+  const sql3 = yield* SqlClient2.SqlClient;
+  const pending = Effect16.fn("QueueStats.pending")(function* () {
+    const rows = yield* sql3`
+        SELECT queue_name AS queue, COUNT(*) AS count
+        FROM effect_queue
+        WHERE state = 'pending' AND queue_name != ${RESUME_QUEUE}
+        GROUP BY queue_name
+        ORDER BY queue_name
+      `;
+    return rows.map((row) => ({ queue: row.queue, pending: Number(row.count) }));
+  });
+  return Service7.of({ pending });
+}));
+
+// ../workflow/src/engine.ts
 var Persistence = PersistenceNamespace2.Persistence;
 var PersistedQueueFactory = PersistedQueue.PersistedQueueFactory;
 var PayloadCodec = Schema17.Record(Schema17.String, Schema17.Json);
-var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect16.gen(function* () {
+var layerDurable = Layer7.effect(WorkflowEngine2.WorkflowEngine)(Effect17.gen(function* () {
   const persistence = yield* Persistence;
   const queueFactory = yield* PersistedQueueFactory;
-  const scope = yield* Effect16.scope;
+  const scope = yield* Effect17.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) => Effect16.gen(function* () {
+  const resume = (state) => Effect17.gen(function* () {
     const exit = state.fiber?.pollUnsafe();
     if (exit && exit._tag === "Success" && exit.value._tag === "Complete")
       return;
@@ -3267,32 +3289,32 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect16.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(Effect16.onExit(() => {
+    state.fiber = yield* state.execute(state.payload, state.instance.executionId).pipe(Effect17.onExit(() => {
       if (!instance.interrupted)
-        return Effect16.void;
+        return Effect17.void;
       instance.suspended = false;
-      return Effect16.withFiber((fiber) => Effect16.interruptible(Fiber.interrupt(fiber)));
-    }), Workflow3.intoResult, Effect16.provideService(WorkflowEngine2.WorkflowInstance, instance), Effect16.provideService(WorkflowEngine2.WorkflowEngine, engine), Effect16.tap((result) => {
+      return Effect17.withFiber((fiber) => Effect17.interruptible(Fiber.interrupt(fiber)));
+    }), Workflow3.intoResult, Effect17.provideService(WorkflowEngine2.WorkflowInstance, instance), Effect17.provideService(WorkflowEngine2.WorkflowEngine, engine), Effect17.tap((result) => {
       if (result._tag !== "Complete")
-        return Effect16.void;
-      return Effect16.gen(function* () {
+        return Effect17.void;
+      return Effect17.gen(function* () {
         const entry2 = workflows.get(state.instance.workflow._tag);
         if (!entry2)
           return;
-        const encoded = yield* Effect16.orDie(Schema17.encodeEffect(resultCodecFor(entry2.workflow))(result));
+        const encoded = yield* Effect17.orDie(Schema17.encodeEffect(resultCodecFor(entry2.workflow))(result));
         yield* setEncodedExit(store, resultKey(state.instance.executionId), Exit4.succeed(encoded));
         yield* notifyExecutionDone(state.instance.executionId);
       });
-    }), Effect16.tap((result) => {
+    }), Effect17.tap((result) => {
       if (!state.parent || result._tag !== "Complete")
-        return Effect16.void;
+        return Effect17.void;
       const parent = executions.get(state.parent);
       if (parent)
-        return Effect16.forkIn(resume(parent), scope);
-      return Effect16.void;
-    }), Effect16.forkIn(entry.scope));
+        return Effect17.forkIn(resume(parent), scope);
+      return Effect17.void;
+    }), Effect17.forkIn(entry.scope));
   });
-  const resumeExecution = (executionId) => Effect16.gen(function* () {
+  const resumeExecution = (executionId) => Effect17.gen(function* () {
     const state = executions.get(executionId);
     if (state) {
       yield* resume(state);
@@ -3315,22 +3337,22 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect16.gen(fu
     }
   });
   const engine = WorkflowEngine2.makeUnsafe({
-    register: Effect16.fnUntraced(function* (workflow, execute) {
+    register: Effect17.fnUntraced(function* (workflow, execute) {
       workflows.set(workflow._tag, {
         workflow,
         execute,
-        scope: yield* Effect16.scope
+        scope: yield* Effect17.scope
       });
     }),
     execute: executeEncoded(workflows, executions, store, resume),
-    interrupt: Effect16.fnUntraced(function* (_workflow, executionId) {
+    interrupt: Effect17.fnUntraced(function* (_workflow, executionId) {
       const state = executions.get(executionId);
       if (!state)
         return;
       state.instance.interrupted = true;
       yield* resume(state);
     }),
-    interruptUnsafe: Effect16.fnUntraced(function* (_workflow, executionId) {
+    interruptUnsafe: Effect17.fnUntraced(function* (_workflow, executionId) {
       const state = executions.get(executionId);
       if (!state)
         return;
@@ -3340,36 +3362,36 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect16.gen(fu
       }
     }),
     resume: (_workflow, executionId) => resumeExecution(executionId),
-    activityExecute: Effect16.fnUntraced(function* (activity, attempt) {
+    activityExecute: Effect17.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)) {
         const entry = workflows.get(instance.workflow._tag);
         if (!entry)
-          return yield* Effect16.die(`activity replay: unknown workflow ${instance.workflow._tag}`);
-        return yield* Effect16.orDie(Schema17.decodeUnknownEffect(resultCodecFor(entry.workflow))(persisted.value));
+          return yield* Effect17.die(`activity replay: unknown workflow ${instance.workflow._tag}`);
+        return yield* Effect17.orDie(Schema17.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, Effect16.provideService(WorkflowEngine2.WorkflowInstance, activityInstance), Effect16.exit);
+      const result = yield* activity.executeEncoded.pipe(Workflow3.intoResult, Effect17.provideService(WorkflowEngine2.WorkflowInstance, activityInstance), Effect17.exit);
       if (result._tag === "Success" && result.value._tag !== "Suspended") {
         const entry = workflows.get(instance.workflow._tag);
         if (entry) {
-          const encoded = yield* Effect16.orDie(Schema17.encodeEffect(resultCodecFor(entry.workflow))(result.value));
+          const encoded = yield* Effect17.orDie(Schema17.encodeEffect(resultCodecFor(entry.workflow))(result.value));
           yield* setEncodedExit(store, key, Exit4.succeed(encoded));
         }
       }
       return yield* result;
     }),
-    poll: (_workflow, executionId) => Effect16.gen(function* () {
+    poll: (_workflow, executionId) => Effect17.gen(function* () {
       const state = executions.get(executionId);
       if (!state) {
         const persisted = yield* getEncodedExit(store, resultKey(executionId));
         if (persisted && Exit4.isSuccess(persisted)) {
           const workflow = yield* workflowTagFor(workflows, store, executionId);
           if (workflow) {
-            return Option7.some(yield* Effect16.orDie(Schema17.decodeUnknownEffect(resultCodecFor(workflow))(persisted.value)));
+            return Option7.some(yield* Effect17.orDie(Schema17.decodeUnknownEffect(resultCodecFor(workflow))(persisted.value)));
           }
         }
         return Option7.none();
@@ -3379,9 +3401,9 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect16.gen(fu
         return Option7.none();
       if (exit._tag === "Success")
         return Option7.some(exit.value);
-      return yield* Effect16.die(exit.cause);
+      return yield* Effect17.die(exit.cause);
     }),
-    deferredResult: Effect16.fnUntraced(function* (deferred) {
+    deferredResult: Effect17.fnUntraced(function* (deferred) {
       const instance = yield* WorkflowEngine2.WorkflowInstance;
       const persisted = yield* getEncodedExit(store, deferredKey(instance.executionId, deferred.name));
       if (persisted) {
@@ -3389,9 +3411,9 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect16.gen(fu
       }
       return Option7.none();
     }),
-    deferredDone: (options) => Effect16.gen(function* () {
+    deferredDone: (options) => Effect17.gen(function* () {
       yield* setEncodedExit(store, deferredKey(options.executionId, options.deferredName), options.exit);
-      yield* resumeQueue.offer({ executionId: options.executionId }, { id: options.executionId }).pipe(Effect16.orDie);
+      yield* resumeQueue.offer({ executionId: options.executionId }, { id: options.executionId }).pipe(Effect17.orDie);
       yield* resumeExecution(options.executionId);
     }),
     scheduleClock: (workflow, options) => engine.deferredDone(options.clock.deferred, {
@@ -3399,17 +3421,17 @@ var layerDurable = Layer6.effect(WorkflowEngine2.WorkflowEngine)(Effect16.gen(fu
       executionId: options.executionId,
       deferredName: options.clock.deferred.name,
       exit: Exit4.void
-    }).pipe(Effect16.delay(options.clock.duration), FiberMap.run(clocks, `${options.executionId}/${options.clock.name}`, {
+    }).pipe(Effect17.delay(options.clock.duration), FiberMap.run(clocks, `${options.executionId}/${options.clock.name}`, {
       onlyIfMissing: true
-    }), Effect16.asVoid)
+    }), Effect17.asVoid)
   });
   return engine;
 }));
-var executeEncoded = (workflows, executions, store, resume) => Effect16.fnUntraced(function* (workflow, options) {
-  const payload = yield* Effect16.orDie(Schema17.decodeUnknownEffect(PayloadCodec)(options.payload));
+var executeEncoded = (workflows, executions, store, resume) => Effect17.fnUntraced(function* (workflow, options) {
+  const payload = yield* Effect17.orDie(Schema17.decodeUnknownEffect(PayloadCodec)(options.payload));
   const entry = workflows.get(workflow._tag);
   if (!entry) {
-    return yield* Effect16.orDie(Effect16.fail(`Workflow ${workflow._tag} is not registered`));
+    return yield* Effect17.orDie(Effect17.fail(`Workflow ${workflow._tag} is not registered`));
   }
   let state = executions.get(options.executionId);
   if (!state) {
@@ -3425,43 +3447,43 @@ var executeEncoded = (workflows, executions, store, resume) => Effect16.fnUntrac
     yield* resume(state);
   }
   if (options.discard)
-    return yield* Effect16.void;
+    return yield* Effect17.void;
   if (!state.fiber) {
-    return yield* Effect16.orDie(Effect16.fail(`Workflow ${workflow._tag}: execution ${options.executionId} has no fiber`));
+    return yield* Effect17.orDie(Effect17.fail(`Workflow ${workflow._tag}: execution ${options.executionId} has no fiber`));
   }
   return yield* Fiber.join(state.fiber);
 });
-var loadRecord = (store, executionId) => Effect16.gen(function* () {
+var loadRecord = (store, executionId) => Effect17.gen(function* () {
   const persisted = yield* getEncodedExit(store, recordKey(executionId));
   if (persisted && Exit4.isSuccess(persisted)) {
-    return yield* Effect16.orDie(Schema17.decodeUnknownEffect(ExecutionRecord)(persisted.value));
+    return yield* Effect17.orDie(Schema17.decodeUnknownEffect(ExecutionRecord)(persisted.value));
   }
   return;
 });
-var workflowTagFor = (workflows, store, executionId) => Effect16.gen(function* () {
+var workflowTagFor = (workflows, store, executionId) => Effect17.gen(function* () {
   const record = yield* loadRecord(store, executionId);
   if (!record)
     return;
   return workflows.get(record.workflowTag)?.workflow;
 });
-var libsqlStack = (options) => Layer6.unwrap(Effect16.gen(function* () {
-  yield* Effect16.tryPromise({
+var libsqlStack = (options) => Layer7.unwrap(Effect17.gen(function* () {
+  yield* Effect17.tryPromise({
     try: () => prepareFileDatabase(options.url),
     catch: (cause) => new Error(String(cause))
-  }).pipe(Effect16.catch(() => Effect16.void));
+  }).pipe(Effect17.catch(() => Effect17.void));
   const storeLayer = PersistedQueue.layerStoreSql();
-  const inner = Layer6.mergeAll(PersistenceNamespace2.layerSql, PersistedQueue.layer.pipe(Layer6.provide(storeLayer)), PersistedQueue.layerCleanup().pipe(Layer6.provide(storeLayer))).pipe(Layer6.provide(exports_LibsqlClient.layer(options)));
-  const ctx = yield* Effect16.acquireUseRelease(Effect16.tryPromise({
+  const inner = Layer7.mergeAll(PersistenceNamespace2.layerSql, PersistedQueue.layer.pipe(Layer7.provide(storeLayer)), PersistedQueue.layerCleanup().pipe(Layer7.provide(storeLayer)), layer6).pipe(Layer7.provide(exports_LibsqlClient.layer(options)));
+  const ctx = yield* Effect17.acquireUseRelease(Effect17.tryPromise({
     try: () => acquireMigrationLock(options.url),
-    catch: (cause) => new SqlErrorNamespace.SqlError({
-      reason: new SqlErrorNamespace.LockTimeoutError({
+    catch: (cause) => new SqlErrorNamespace2.SqlError({
+      reason: new SqlErrorNamespace2.LockTimeoutError({
         cause,
         message: "timed out acquiring the jobs-database migration lock",
         operation: "libsqlStack"
       })
     })
-  }), () => Layer6.build(inner), (release) => Effect16.sync(() => release?.()));
-  return Layer6.succeedContext(ctx);
+  }), () => Layer7.build(inner), (release) => Effect17.sync(() => release?.()));
+  return Layer7.succeedContext(ctx);
 }));
 
 // ../workflow/src/runtime.ts
@@ -3473,14 +3495,14 @@ var DEFAULT_TIMEOUT = Duration.minutes(5);
 var DEFAULT_POLL_INTERVAL = Duration.millis(250);
 var PROCESS_WINDOW = Duration.seconds(30);
 
-class Service7 extends Context8.Service()("@dimple/workflow/JobRuntime") {
+class Service8 extends Context9.Service()("@dimple/workflow/JobRuntime") {
 }
 var jobsError = (jobId, cause) => {
   if (cause instanceof JobFailed || cause instanceof JobTimeout || cause instanceof JobCancelled || cause instanceof QueueError)
     return cause;
   return new QueueError({ message: cause instanceof Error ? cause.message : String(cause) });
 };
-var layer6 = (defs) => Layer7.effect(Service7, Effect17.gen(function* () {
+var layer7 = (defs) => Layer8.effect(Service8, Effect18.gen(function* () {
   const engine = yield* WorkflowEngine3.WorkflowEngine;
   const persistence = yield* Persistence2;
   const queueFactory = yield* PersistedQueueFactory2;
@@ -3488,24 +3510,24 @@ var layer6 = (defs) => Layer7.effect(Service7, Effect17.gen(function* () {
   for (const def of defs) {
     yield* def.register(engine);
   }
-  const enqueue = Effect17.fn("JobRuntime.enqueue")(function* (def, payload) {
-    const decoded = yield* Schema18.decodeUnknownEffect(def.payloadSchema)(payload).pipe(Effect17.mapError((e) => new QueueError({ message: `invalid payload: ${e.message}` })));
+  const enqueue = Effect18.fn("JobRuntime.enqueue")(function* (def, payload) {
+    const decoded = yield* Schema18.decodeUnknownEffect(def.payloadSchema)(payload).pipe(Effect18.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(Effect17.provideService(WorkflowEngine3.WorkflowEngine, engine), Effect17.mapError((cause) => new QueueError({ message: cause instanceof Error ? cause.message : String(cause) })));
-    yield* def.workflow.execute(envelope, { discard: true }).pipe(Effect17.provideService(WorkflowEngine3.WorkflowEngine, engine), Effect17.mapError((cause) => jobsError(jobId, cause)));
+    const jobId = yield* def.workflow.executionId(envelope).pipe(Effect18.provideService(WorkflowEngine3.WorkflowEngine, engine), Effect18.mapError((cause) => new QueueError({ message: cause instanceof Error ? cause.message : String(cause) })));
+    yield* def.workflow.execute(envelope, { discard: true }).pipe(Effect18.provideService(WorkflowEngine3.WorkflowEngine, engine), Effect18.mapError((cause) => jobsError(jobId, cause)));
     return jobId;
   });
-  const wait = Effect17.fn("JobRuntime.wait")(function* (jobId, options) {
+  const wait = Effect18.fn("JobRuntime.wait")(function* (jobId, options) {
     const timeout = Duration.fromInput(options?.timeout ?? DEFAULT_TIMEOUT).pipe(Option8.getOrElse(() => Duration.minutes(5)));
     const pollInterval = Duration.fromInput(options?.pollInterval ?? DEFAULT_POLL_INTERVAL).pipe(Option8.getOrElse(() => Duration.millis(250)));
-    const deadline = yield* Clock2.currentTimeMillis.pipe(Effect17.map((now) => now + Duration.toMillis(timeout)));
+    const deadline = yield* Clock2.currentTimeMillis.pipe(Effect18.map((now) => now + Duration.toMillis(timeout)));
     const completionSignal = yield* Deferred2.make();
     onExecutionDone(jobId, completionSignal);
     try {
       while (true) {
         if (yield* readMarker(store, jobId, CANCELLED)) {
-          return yield* Effect17.fail(new JobCancelled({ jobId }));
+          return yield* Effect18.fail(new JobCancelled({ jobId }));
         }
         const def = yield* findDef(defs, jobId, store);
         if (def) {
@@ -3516,7 +3538,7 @@ var layer6 = (defs) => Layer7.effect(Service7, Effect17.gen(function* () {
               if (Exit5.isSuccess(r.exit))
                 return r.exit.value;
               const failure = Exit5.getCause(r.exit).pipe(Option8.flatMap(Cause.findErrorOption), Option8.map((error) => Option8.getOrElse(Schema18.decodeUnknownOption(Schema18.String)(error), () => String(error))));
-              return yield* Effect17.fail(new JobFailed({
+              return yield* Effect18.fail(new JobFailed({
                 jobId,
                 message: Option8.getOrElse(failure, () => "workflow failed")
               }));
@@ -3526,19 +3548,19 @@ var layer6 = (defs) => Layer7.effect(Service7, Effect17.gen(function* () {
         const now = yield* Clock2.currentTimeMillis;
         if (now >= deadline) {
           yield* writeMarker(store, jobId, TIMED_OUT);
-          return yield* Effect17.fail(new JobTimeout({ jobId, timeout }));
+          return yield* Effect18.fail(new JobTimeout({ jobId, timeout }));
         }
-        yield* Effect17.race(Deferred2.await(completionSignal).pipe(Effect17.asVoid), Effect17.sleep(pollInterval));
+        yield* Effect18.race(Deferred2.await(completionSignal).pipe(Effect18.asVoid), Effect18.sleep(pollInterval));
       }
     } finally {
       offExecutionDone(jobId, completionSignal);
     }
   });
-  const submit = Effect17.fn("JobRuntime.submit")(function* (def, payload) {
+  const submit = Effect18.fn("JobRuntime.submit")(function* (def, payload) {
     const jobId = yield* enqueue(def, payload);
     return yield* wait(jobId);
   });
-  const status = Effect17.fn("JobRuntime.status")(function* (jobId) {
+  const status = Effect18.fn("JobRuntime.status")(function* (jobId) {
     if (yield* readMarker(store, jobId, CANCELLED))
       return "cancelled";
     if (yield* readMarker(store, jobId, TIMED_OUT))
@@ -3555,66 +3577,66 @@ var layer6 = (defs) => Layer7.effect(Service7, Effect17.gen(function* () {
     }
     return "pending";
   });
-  const cancel = Effect17.fn("JobRuntime.cancel")(function* (jobId) {
+  const cancel = Effect18.fn("JobRuntime.cancel")(function* (jobId) {
     yield* writeMarker(store, jobId, CANCELLED);
     return true;
   });
-  const processPending = Effect17.fn("JobRuntime.processPending")(function* (options) {
+  const processPending = Effect18.fn("JobRuntime.processPending")(function* (options) {
     const resumeQueue = yield* queueFactory.make({
       name: RESUME_QUEUE,
       schema: ResumeSignal,
       maxAttempts: 1
     });
     const window = Duration.toMillis(Duration.fromInput(options?.window ?? PROCESS_WINDOW).pipe(Option8.getOrElse(() => Duration.seconds(30))));
-    const deadline = yield* Clock2.currentTimeMillis.pipe(Effect17.map((now) => now + window));
+    const deadline = yield* Clock2.currentTimeMillis.pipe(Effect18.map((now) => now + window));
     let processed = 0;
     while (true) {
       const now = yield* Clock2.currentTimeMillis;
       if (now >= deadline)
         break;
-      const signal = yield* resumeQueue.take((value2) => Effect17.succeed(Option8.some(value2))).pipe(Effect17.mapError((e) => new QueueError({ message: e instanceof Error ? e.message : String(e) })), Effect17.timeoutOrElse({
+      const signal = yield* resumeQueue.take((value2) => Effect18.succeed(Option8.some(value2))).pipe(Effect18.mapError((e) => new QueueError({ message: e instanceof Error ? e.message : String(e) })), Effect18.timeoutOrElse({
         duration: Duration.millis(100),
-        orElse: () => Effect17.succeed(Option8.none())
+        orElse: () => Effect18.succeed(Option8.none())
       }));
       if (Option8.isNone(signal))
         continue;
       const executionId = signal.value.executionId;
       const def = yield* findDef(defs, executionId, store);
       if (def) {
-        yield* engine.resume(def.workflow, executionId).pipe(Effect17.orDie);
+        yield* engine.resume(def.workflow, executionId).pipe(Effect18.orDie);
         processed++;
       }
     }
     return processed;
   });
-  return Service7.of({ enqueue, wait, submit, status, cancel, processPending });
+  return Service8.of({ enqueue, wait, submit, status, cancel, processPending });
 }));
-var findDef = (defs, executionId, store) => Effect17.gen(function* () {
+var findDef = (defs, executionId, store) => Effect18.gen(function* () {
   const persisted = yield* getEncodedExit(store, `${executionId}/record`);
   if (!persisted || !Exit5.isSuccess(persisted))
     return;
-  const record = yield* Effect17.orDie(Schema18.decodeUnknownEffect(ExecutionRecord)(persisted.value));
+  const record = yield* Effect18.orDie(Schema18.decodeUnknownEffect(ExecutionRecord)(persisted.value));
   return defs.find((d) => d.workflow._tag === record.workflowTag);
 });
 var layerLibsql = (defs, options) => {
   const stack = libsqlStack(options);
-  return layer6(defs).pipe(Layer7.provideMerge(Layer7.mergeAll(layerDurable.pipe(Layer7.provide(stack)), stack)));
+  return layer7(defs).pipe(Layer8.provideMerge(Layer8.mergeAll(layerDurable.pipe(Layer8.provide(stack)), stack)));
 };
-var configured3 = (defs, options) => make({ name: "JobStack", layer: Layer7.suspend(() => layerLibsql(defs, options)), deps: [] });
+var configured3 = (defs, options) => make({ name: "JobStack", layer: Layer8.suspend(() => layerLibsql(defs, options)), deps: [] });
 var node3 = configured3(queues, { url: JobsConfigDefaults.dbUrl });
 // ../workflow/src/registry.ts
-import { Context as Context9, Effect as Effect18, Layer as Layer8, Option as Option9, Ref, Schema as Schema19 } from "effect";
+import { Context as Context10, Effect as Effect19, Layer as Layer9, Option as Option9, Ref, Schema as Schema19 } from "effect";
 class JobFailure extends Schema19.TaggedError()("JobFailure", {
   jobId: Schema19.String,
   message: Schema19.String
 }) {
 }
 
-class Service8 extends Context9.Service()("@dimple/workflow/JobRegistry") {
+class Service9 extends Context10.Service()("@dimple/workflow/JobRegistry") {
 }
-var layer7 = Layer8.effect(Service8, Effect18.gen(function* () {
+var layer8 = Layer9.effect(Service9, Effect19.gen(function* () {
   const handlers = yield* Ref.make(new Map);
-  const register = Effect18.fn("JobRegistry.register")(function* (type, handler) {
+  const register = Effect19.fn("JobRegistry.register")(function* (type, handler) {
     const existed = yield* Ref.modify(handlers, (map2) => {
       if (map2.has(type)) {
         return [true, map2];
@@ -3622,48 +3644,48 @@ var layer7 = Layer8.effect(Service8, Effect18.gen(function* () {
       return [false, new Map(map2).set(type, handler)];
     });
     if (existed) {
-      return yield* Effect18.fail(new RegistryError({ type, message: `Job type already registered: ${type}` }));
+      return yield* Effect19.fail(new RegistryError({ type, message: `Job type already registered: ${type}` }));
     }
   });
-  const resolve = Effect18.fn("JobRegistry.resolve")(function* (type) {
-    const handler = yield* Ref.get(handlers).pipe(Effect18.map((map2) => Option9.fromNullishOr(map2.get(type))));
+  const resolve = Effect19.fn("JobRegistry.resolve")(function* (type) {
+    const handler = yield* Ref.get(handlers).pipe(Effect19.map((map2) => Option9.fromNullishOr(map2.get(type))));
     if (Option9.isNone(handler)) {
-      return yield* Effect18.fail(new UnknownJobType({ type }));
+      return yield* Effect19.fail(new UnknownJobType({ type }));
     }
     return handler.value;
   });
-  return Service8.of({ register, resolve });
+  return Service9.of({ register, resolve });
 }));
-var configured4 = () => make({ name: "JobRegistry", layer: layer7, deps: [] });
+var configured4 = () => make({ name: "JobRegistry", layer: layer8, deps: [] });
 var node4 = configured4();
 // ../workflow/src/executor.ts
-import { Cause as Cause2, Duration as Duration2, Effect as Effect19, Layer as Layer9, Schedule } from "effect";
+import { Cause as Cause2, Duration as Duration2, Effect as Effect20, Layer as Layer10, Schedule } from "effect";
 import { DurableQueue as DurableQueue2, WorkflowEngine as WorkflowEngine4 } from "effect/workflow";
-var runHandler = (def, payload, jobId, maxAttempts) => Effect19.gen(function* () {
-  const registry = yield* Service8;
+var runHandler = (def, payload, jobId, maxAttempts) => Effect20.gen(function* () {
+  const registry = yield* Service9;
   const handler = yield* registry.resolve(def.name);
-  yield* Effect19.logInfo("job.started").pipe(Effect19.annotateLogs({
+  yield* Effect20.logInfo("job.started").pipe(Effect20.annotateLogs({
     scope: "@dimple/workflow",
     event: "job.started",
     job: def.name,
     idempotencyKey: jobId
   }));
   const run = () => handler(payload, { jobId });
-  const outcome = yield* (maxAttempts > 1 ? run().pipe(Effect19.retry({
+  const outcome = yield* (maxAttempts > 1 ? run().pipe(Effect20.retry({
     times: maxAttempts - 1,
     schedule: Schedule.spaced(Duration2.millis(250)).pipe(Schedule.jittered)
-  })) : run()).pipe(Effect19.exit);
+  })) : run()).pipe(Effect20.exit);
   if (outcome._tag === "Failure") {
-    yield* Effect19.logError("job.failed").pipe(Effect19.annotateLogs({
+    yield* Effect20.logError("job.failed").pipe(Effect20.annotateLogs({
       scope: "@dimple/workflow",
       event: "job.failed",
       job: def.name,
       idempotencyKey: jobId,
       error: Cause2.pretty(outcome.cause)
     }));
-    return yield* Effect19.failCause(outcome.cause).pipe(Effect19.mapError((e) => e.message));
+    return yield* Effect20.failCause(outcome.cause).pipe(Effect20.mapError((e) => e.message));
   }
-  yield* Effect19.logInfo("job.completed").pipe(Effect19.annotateLogs({
+  yield* Effect20.logInfo("job.completed").pipe(Effect20.annotateLogs({
     scope: "@dimple/workflow",
     event: "job.completed",
     job: def.name,
@@ -3678,23 +3700,23 @@ var workerLayer = (defs, options = {}) => {
   const layers = defs.map((def) => workerFor(def, options.concurrency ?? 1, maxAttempts));
   const [first, ...rest] = layers;
   if (!first)
-    return Layer9.empty;
-  const workers = rest.reduce((acc, layer8) => Layer9.mergeAll(acc, layer8), first);
-  return options.logging === undefined ? workers : Layer9.provideMerge(layer(options.logging))(workers);
+    return Layer10.empty;
+  const workers = rest.reduce((acc, layer9) => Layer10.mergeAll(acc, layer9), first);
+  return options.logging === undefined ? workers : Layer10.provideMerge(layer(options.logging))(workers);
 };
-var configured5 = (defs, options, deps) => make({ name: "Workers", layer: Layer9.suspend(() => workerLayer(defs, options)), deps });
+var configured5 = (defs, options, deps) => make({ name: "Workers", layer: Layer10.suspend(() => workerLayer(defs, options)), deps });
 // ../store/src/topics/lifecycle.ts
-var routingFailure3 = (tag) => (effect) => effect.pipe(Effect20.mapError((cause) => new RoutingFailure({ cause: { operation: tag, cause } })));
-var isActive = Effect20.fn("topics.isActive")(function* (modelKey) {
+var routingFailure3 = (tag) => (effect) => effect.pipe(Effect21.mapError((cause) => new RoutingFailure({ cause: { operation: tag, cause } })));
+var isActive = Effect21.fn("topics.isActive")(function* (modelKey) {
   const backend = yield* Service2;
   const db = backend.db;
-  const rows = yield* Effect20.tryPromise({
+  const rows = yield* Effect21.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 = Effect20.fn("topics.setActiveModel")(function* (model, config) {
+var setActiveModel = Effect21.fn("topics.setActiveModel")(function* (model, config) {
   const backend = yield* Service2;
   const db = backend.db;
   yield* ensureTopicTree(model, config).pipe(routingFailure3("topics.setActiveModel.seed"));
@@ -3702,14 +3724,14 @@ var setActiveModel = Effect20.fn("topics.setActiveModel")(function* (model, conf
   let routed = 0;
   let alreadyInTree = 0;
   if (memoryIds.length > 0) {
-    const topicRows = yield* Effect20.tryPromise({
+    const topicRows = yield* Effect21.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* Effect20.tryPromise({
+        const existing = yield* Effect21.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"));
@@ -3727,7 +3749,7 @@ var setActiveModel = Effect20.fn("topics.setActiveModel")(function* (model, conf
     }
   }
   const auditTimestamp = yield* Clock3.currentTimeMillis;
-  const deactivated = yield* Effect20.tryPromise({
+  const deactivated = yield* Effect21.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);
@@ -3750,18 +3772,18 @@ var setActiveModel = Effect20.fn("topics.setActiveModel")(function* (model, conf
   }).pipe(routingFailure3("topics.setActiveModel.deactivate"));
   return { routed, alreadyInTree, deactivated };
 });
-var embedOneMemory = (deps, payload, ctx) => Effect20.gen(function* () {
+var embedOneMemory = (deps, payload, ctx) => Effect21.gen(function* () {
   const envelope = payload;
   const model = deps.getModelConfig(envelope.modelKey);
   if (!model) {
-    return yield* Effect20.fail(new JobFailure({
+    return yield* Effect21.fail(new JobFailure({
       jobId: ctx.jobId,
       message: `memory.embed: unknown model "${envelope.modelKey}"`
     }));
   }
-  const content = yield* deps.getMemoryContent(envelope.memoryId).pipe(Effect20.catchTag("Store.NotFound", () => Effect20.succeed(undefined)), Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: load content: ${e}` })));
+  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}` })));
   if (content === undefined) {
-    yield* Effect20.logDebug("embed.stale-reoffer").pipe(Effect20.annotateLogs({
+    yield* Effect21.logDebug("embed.stale-reoffer").pipe(Effect21.annotateLogs({
       scope: "@dimple/store",
       event: "embed.stale-reoffer",
       memoryId: envelope.memoryId,
@@ -3769,24 +3791,24 @@ var embedOneMemory = (deps, payload, ctx) => Effect20.gen(function* () {
     }));
     return;
   }
-  const vector = yield* deps.embedOne(content, model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: embed: ${e}` })));
+  const vector = yield* deps.embedOne(content, model).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: embed: ${e}` })));
   const backend = yield* Service2;
   const db = backend.db;
-  const existing = yield* Effect20.tryPromise({
+  const existing = yield* Effect21.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(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: membership check: ${e}` })));
-  yield* ensureTopicTree(model, deps.config).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: seed tree: ${e}` })));
-  yield* backend.ensureVectorTable(model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: vector table: ${e}` })));
-  yield* backend.insertVector(envelope.memoryId, [...vector], model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: insert vector: ${e}` })));
-  yield* Effect20.tryPromise({
+  }).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}` })));
+  yield* Effect21.tryPromise({
     try: () => db.update(memories).set({ embedding: [...vector], embeddingModel: model.id }).where(eq3(memories.id, envelope.memoryId)),
     catch: (cause) => new StoreError({ message: `memory.embed: stamp embedding: ${cause}` })
-  }).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: stamp embedding: ${e}` })));
+  }).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: stamp embedding: ${e}` })));
   if (existing.length === 0) {
-    yield* routeInsert(envelope.memoryId, [...vector], model, deps.config).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: route: ${e}` })));
+    yield* routeInsert(envelope.memoryId, [...vector], model, deps.config).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: route: ${e}` })));
   }
-  yield* Effect20.logInfo("embed.completed").pipe(Effect20.annotateLogs({
+  yield* Effect21.logInfo("embed.completed").pipe(Effect21.annotateLogs({
     scope: "@dimple/store",
     event: "embed.completed",
     memoryId: envelope.memoryId,
@@ -3797,9 +3819,9 @@ var embedOneMemory = (deps, payload, ctx) => Effect20.gen(function* () {
 });
 function memoryEmbedHandler(deps) {
   const run = (payload, ctx) => embedOneMemory(deps, payload, ctx);
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect20.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect21.provideService(Service2, deps.backend)) : run;
 }
-var logBatchCompleted = (modelKey, embedded, failed, ctx) => Effect20.logInfo("embed.batch.completed").pipe(Effect20.annotateLogs({
+var logBatchCompleted = (modelKey, embedded, failed, ctx) => Effect21.logInfo("embed.batch.completed").pipe(Effect21.annotateLogs({
   scope: "@dimple/store",
   event: "embed.batch.completed",
   jobId: ctx.jobId,
@@ -3807,15 +3829,15 @@ var logBatchCompleted = (modelKey, embedded, failed, ctx) => Effect20.logInfo("e
   embedded,
   failed
 }));
-var batchFailure = (ctx, failed, total, first) => Effect20.fail(new JobFailure({
+var batchFailure = (ctx, failed, total, first) => Effect21.fail(new JobFailure({
   jobId: ctx.jobId,
   message: `memory.embed.batch: ${failed}/${total} failed — ${first}`
 }));
 function memoryEmbedBatchHandler(deps) {
-  const run = (payload, ctx) => Effect20.gen(function* () {
+  const run = (payload, ctx) => Effect21.gen(function* () {
     const model = deps.getModelConfig(payload.modelKey);
     if (!model) {
-      return yield* Effect20.fail(new JobFailure({
+      return yield* Effect21.fail(new JobFailure({
         jobId: ctx.jobId,
         message: `memory.embed: unknown model "${payload.modelKey}"`
       }));
@@ -3826,23 +3848,23 @@ function memoryEmbedBatchHandler(deps) {
     let first;
     const embedded = [];
     const stale = [];
-    yield* Effect20.forEach(payload.memoryIds, (memoryId) => Effect20.gen(function* () {
-      const content = yield* deps.getMemoryContent(memoryId).pipe(Effect20.catchTag("Store.NotFound", () => Effect20.succeed(undefined)), Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: load content: ${e}` })));
+    yield* Effect21.forEach(payload.memoryIds, (memoryId) => Effect21.gen(function* () {
+      const content = yield* deps.getMemoryContent(memoryId).pipe(Effect21.catchTag("Store.NotFound", () => Effect21.succeed(undefined)), Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: load content: ${e}` })));
       if (content === undefined) {
         stale.push(memoryId);
         return;
       }
-      const vector = yield* deps.embedOne(content, model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: embed: ${e}` })));
+      const vector = yield* deps.embedOne(content, model).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: embed: ${e}` })));
       embedded.push({ memoryId, vector });
-    }).pipe(Effect20.exit, Effect20.tap((exit) => {
+    }).pipe(Effect21.exit, Effect21.tap((exit) => {
       if (Exit6.isSuccess(exit))
-        return Effect20.void;
+        return Effect21.void;
       failed += 1;
       first ??= Cause3.pretty(exit.cause);
-      return Effect20.void;
+      return Effect21.void;
     })), { concurrency: 1, discard: true });
     for (const memoryId of stale) {
-      yield* Effect20.logDebug("embed.stale-reoffer").pipe(Effect20.annotateLogs({
+      yield* Effect21.logDebug("embed.stale-reoffer").pipe(Effect21.annotateLogs({
         scope: "@dimple/store",
         event: "embed.stale-reoffer",
         memoryId,
@@ -3856,25 +3878,25 @@ function memoryEmbedBatchHandler(deps) {
       }
       return;
     }
-    yield* ensureTopicTree(model, deps.config).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: seed tree: ${e}` })));
-    yield* backend.ensureVectorTable(model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: vector table: ${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}` })));
     const ids = embedded.map((e) => e.memoryId);
-    const members = yield* Effect20.tryPromise({
+    const members = yield* Effect21.tryPromise({
       try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(and3(eq3(topicMemberships.modelKey, model.id), inArray(topicMemberships.memoryId, ids))),
       catch: (cause) => new StoreError({ message: `memory.embed: membership check: ${cause}` })
-    }).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: membership check: ${e}` })));
+    }).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: membership check: ${e}` })));
     const memberSet = new Set(members.map((r) => r.memoryId));
     const entries = embedded.map((e) => ({ memoryId: e.memoryId, vector: [...e.vector] }));
-    yield* backend.insertVectors(entries, model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: insert vectors: ${e}` })));
-    yield* Effect20.tryPromise({
+    yield* backend.insertVectors(entries, model).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: insert vectors: ${e}` })));
+    yield* Effect21.tryPromise({
       try: () => db.transaction(async (tx) => {
         await tx.run(sql3`UPDATE ${memories} SET embedding = CASE id ${sql3.join(entries.map((entry) => sql3`WHEN ${entry.memoryId} THEN ${new Float32Array(entry.vector).buffer}`), sql3` `)} END, embedding_model = ${model.id} WHERE id IN (${sql3.join(entries.map((entry) => sql3`${entry.memoryId}`), sql3`, `)})`);
       }),
       catch: (cause) => new StoreError({ message: `memory.embed: stamp embeddings: ${cause}` })
-    }).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: stamp embeddings: ${e}` })));
+    }).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: stamp embeddings: ${e}` })));
     const fresh = entries.filter((entry) => !memberSet.has(entry.memoryId));
     if (fresh.length > 0) {
-      yield* routeInsertMany(fresh, model, deps.config).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: route: ${e}` })));
+      yield* routeInsertMany(fresh, model, deps.config).pipe(Effect21.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: route: ${e}` })));
     }
     yield* logBatchCompleted(payload.modelKey, embedded.length, failed, ctx);
     if (failed > 0) {
@@ -3882,11 +3904,11 @@ function memoryEmbedBatchHandler(deps) {
     }
     return;
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect20.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect21.provideService(Service2, deps.backend)) : run;
 }
 
 // ../store/src/topics/jobs.ts
-import { Clock as Clock4, Effect as Effect21 } from "effect";
+import { Clock as Clock4, Effect as Effect22 } from "effect";
 import { and as and4, asc as asc3, eq as eq4, inArray as inArray2, sql as sql5 } from "drizzle-orm";
 
 // ../store/src/topics/topic-vectors.ts
@@ -3925,13 +3947,13 @@ var childBaseKey = (parent, vectors) => {
   }
   return `t_${(hash >>> 0).toString(16).padStart(8, "0")}`;
 };
-var splitTopic = Effect21.fn("TopicSplit.splitTopic")(function* (topicKey, model, config) {
+var splitTopic = Effect22.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* Effect21.tryPromise({
+  const leafRows = yield* Effect22.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}` })
   });
@@ -3942,13 +3964,13 @@ var splitTopic = Effect21.fn("TopicSplit.splitTopic")(function* (topicKey, model
   if (leaf.modelKey !== model.id) {
     return yield* new ModelMismatch({ expected: model.id, actual: leaf.modelKey });
   }
-  const memberRows = yield* Effect21.tryPromise({
+  const memberRows = yield* Effect22.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* Effect21.tryPromise({
+  const growthRows = yield* Effect22.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}` })
   });
@@ -3980,7 +4002,7 @@ var splitTopic = Effect21.fn("TopicSplit.splitTopic")(function* (topicKey, model
   const forced = memberCount > hardLimit;
   if (!plan.accepted && !forced) {
     const now2 = yield* Clock4.currentTimeMillis;
-    yield* Effect21.tryPromise({
+    yield* Effect22.tryPromise({
       try: () => db.transaction(async (tx) => {
         await tx.insert(topicGrowthState).values({
           topicKey,
@@ -4013,7 +4035,7 @@ var splitTopic = Effect21.fn("TopicSplit.splitTopic")(function* (topicKey, model
     };
   }
   const now = yield* Clock4.currentTimeMillis;
-  const children = yield* Effect21.tryPromise({
+  const children = yield* Effect22.tryPromise({
     try: () => db.transaction(async (tx) => {
       const child0Cf = cfFromVectors(groupVectors(0));
       const child1Cf = cfFromVectors(groupVectors(1));
@@ -4134,34 +4156,34 @@ var splitTopic = Effect21.fn("TopicSplit.splitTopic")(function* (topicKey, model
   });
   return { accepted: true, children: children.keys, childCounts: children.counts };
 });
-var staleSplitNoOp = (notFound, model) => Effect21.gen(function* () {
+var staleSplitNoOp = (notFound, model) => Effect22.gen(function* () {
   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(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* Effect21.fail(notFound);
+  return yield* Effect22.fail(notFound);
 });
 function topicSplitHandler(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: `topic.split: unknown model "${envelope.modelKey}"`
       }));
     }
-    const outcome = yield* splitTopic(envelope.topicId, model, deps.config).pipe(Effect21.catchIf((error) => error._tag === "topics.TopicNotFound", (notFound) => staleSplitNoOp(notFound, model)), Effect21.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `${error}` })));
+    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}` })));
     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(Effect21.mapError((error) => new JobFailure({
+        yield* deps.onUnevenSplit(k0, envelope.modelKey).pipe(Effect22.mapError((error) => new JobFailure({
           jobId: ctx.jobId,
           message: `topic.split: enqueue rebalance: ${error}`
         })));
@@ -4171,14 +4193,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(Effect21.mapError((error) => new JobFailure({
+          yield* deps.onChildOverflow(outcome.children[i], envelope.modelKey).pipe(Effect22.mapError((error) => new JobFailure({
             jobId: ctx.jobId,
             message: `topic.split: enqueue child split: ${error}`
           })));
         }
       }
     }
-    yield* Effect21.logInfo("split.completed").pipe(Effect21.annotateLogs({
+    yield* Effect22.logInfo("split.completed").pipe(Effect22.annotateLogs({
       scope: "@dimple/store",
       event: "split.completed",
       topicId: envelope.topicId,
@@ -4188,16 +4210,16 @@ function topicSplitHandler(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/maintenance.ts
-import { Clock as Clock5, Effect as Effect22 } from "effect";
+import { Clock as Clock5, Effect as Effect23 } 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(Effect22.mapError((cause) => new StoreError({ message: `${tag}: ${cause}` })));
+var maintenanceError = (tag) => (effect) => effect.pipe(Effect23.mapError((cause) => new StoreError({ message: `${tag}: ${cause}` })));
 var dot2 = (a, b) => {
   let sum = 0;
   for (let i = 0;i < a.length; i++)
@@ -4215,12 +4237,12 @@ var resolvedConfig2 = (config) => ({
   maxLeafItems: config.maxLeafItems ?? DEFAULT_MAX_LEAF_ITEMS2,
   rebalanceCooldownMs: config.rebalanceCooldownMs ?? DEFAULT_REBALANCE_COOLDOWN_MS
 });
-var mergeOrBorrow = Effect22.fn("topics.mergeOrBorrow")(function* (topicKey, model, config) {
+var mergeOrBorrow = Effect23.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* Effect22.tryPromise({
+  const leafRows = yield* Effect23.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}` })
   });
@@ -4233,7 +4255,7 @@ var mergeOrBorrow = Effect22.fn("topics.mergeOrBorrow")(function* (topicKey, mod
   }
   if (leaf.memberCount >= minLeafItems)
     return { action: "none" };
-  const parentRows = yield* Effect22.tryPromise({
+  const parentRows = yield* Effect23.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}` })
   });
@@ -4241,16 +4263,16 @@ var mergeOrBorrow = Effect22.fn("topics.mergeOrBorrow")(function* (topicKey, mod
     return yield* logUnderfilled(db, topicKey, model, now, "no-borrowable");
   }
   const parentKey = parentRows[0].parentKey;
-  const parentRowRows = yield* Effect22.tryPromise({
+  const parentRowRows = yield* Effect23.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* Effect22.tryPromise({
+  const siblingRows = yield* Effect23.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* Effect22.tryPromise({
+  const relationRows = yield* Effect23.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}` })
   });
@@ -4272,7 +4294,7 @@ var mergeOrBorrow = Effect22.fn("topics.mergeOrBorrow")(function* (topicKey, mod
   const membersByTopic = new Map;
   const vecById = new Map;
   for (const sibling of siblingsOf) {
-    const members = yield* Effect22.tryPromise({
+    const members = yield* Effect23.tryPromise({
       try: () => db.select({
         memoryId: topicMemberships.memoryId,
         manualLock: topicMemberships.manualLock
@@ -4285,7 +4307,7 @@ var mergeOrBorrow = Effect22.fn("topics.mergeOrBorrow")(function* (topicKey, mod
       vecById.set(row.memoryId, new Float32Array(row.vector));
   }
   const movedIds = new Set;
-  const outcome = yield* Effect22.tryPromise({
+  const outcome = yield* Effect23.tryPromise({
     try: () => db.transaction(async (tx) => {
       const leafCf0 = cfOf(leaf);
       let leafCf = leafCf0;
@@ -4454,12 +4476,12 @@ var mergeOrBorrow = Effect22.fn("topics.mergeOrBorrow")(function* (topicKey, mod
   });
   return outcome;
 });
-var rebalanceSiblings = Effect22.fn("topics.rebalanceSiblings")(function* (topicKey, model, config) {
+var rebalanceSiblings = Effect23.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* Effect22.tryPromise({
+  const rows = yield* Effect23.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}` })
   });
@@ -4468,19 +4490,19 @@ var rebalanceSiblings = Effect22.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* Effect22.tryPromise({
+  const parentRows = yield* Effect23.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* Effect22.tryPromise({
+  const relationRows = yield* Effect23.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* Effect22.tryPromise({
+  const topicRows = yield* Effect23.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}` })
   });
@@ -4488,7 +4510,7 @@ var rebalanceSiblings = Effect22.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* Effect22.tryPromise({
+  const growthRows = yield* Effect23.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}` })
   });
@@ -4513,7 +4535,7 @@ var rebalanceSiblings = Effect22.fn("topics.rebalanceSiblings")(function* (topic
   const membersByTopic = new Map;
   const vecById = new Map;
   for (const sibling of siblings) {
-    const members = yield* Effect22.tryPromise({
+    const members = yield* Effect23.tryPromise({
       try: () => db.select({
         memoryId: topicMemberships.memoryId,
         manualLock: topicMemberships.manualLock
@@ -4526,7 +4548,7 @@ var rebalanceSiblings = Effect22.fn("topics.rebalanceSiblings")(function* (topic
       vecById.set(row2.memoryId, new Float32Array(row2.vector));
   }
   const movedIds = new Set;
-  const outcome = yield* Effect22.tryPromise({
+  const outcome = yield* Effect23.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));
@@ -4613,7 +4635,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) => Effect22.tryPromise({
+var logUnderfilled = (db, topicKey, model, now, reason) => Effect23.tryPromise({
   try: () => db.insert(topicChangeLog).values({
     topicKey,
     operation: "merge",
@@ -4623,7 +4645,7 @@ var logUnderfilled = (db, topicKey, model, now, reason) => Effect22.tryPromise({
     createdAt: now
   }),
   catch: (cause) => new StoreError({ message: `mergeOrBorrow: log underfilled: ${cause}` })
-}).pipe(Effect22.map(() => ({ action: "underfilled", reason })));
+}).pipe(Effect23.map(() => ({ action: "underfilled", reason })));
 var logUnderfilledTx = async (tx, topicKey, model, now, reason) => {
   await tx.insert(topicChangeLog).values({
     topicKey,
@@ -4636,61 +4658,61 @@ var logUnderfilledTx = async (tx, topicKey, model, now, reason) => {
   return { action: "underfilled", reason };
 };
 function topicMergeHandler(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.merge: unknown model "${envelope.modelKey}"`
       }));
     }
-    yield* mergeOrBorrow(envelope.topicId, model, deps.config).pipe(Effect22.catchIf((error) => error._tag === "topics.TopicNotFound", (notFound) => staleNoOp(notFound, model)), Effect22.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `${error}` })));
+    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}` })));
     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;
 }
 function topicRebalanceHandler(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.rebalance: unknown model "${envelope.modelKey}"`
       }));
     }
-    yield* rebalanceSiblings(envelope.topicId, model, deps.config).pipe(Effect22.catchIf((error) => error._tag === "topics.TopicNotFound", (notFound) => staleNoOp(notFound, model)), Effect22.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `${error}` })));
+    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}` })));
     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;
 }
-var staleNoOp = (notFound, model) => Effect22.gen(function* () {
+var staleNoOp = (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(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* Effect22.fail(new JobFailure({ jobId: notFound.topicKey, message: `topic missing: ${notFound.topicKey}` }));
-}).pipe(Effect22.mapError((error) => error instanceof JobFailure ? error : new JobFailure({ jobId: notFound.topicKey, message: `${error}` })));
+  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}` })));
 
 // ../store/src/topics/observability.ts
-import { Effect as Effect23 } from "effect";
+import { Effect as Effect24 } from "effect";
 import { and as and6, desc, eq as eq6, inArray as inArray3, ne as ne3, sql as sql6 } 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(Effect23.mapError((cause) => new RoutingFailure({ cause: { operation: tag, cause } })));
+var routingFailure4 = (tag) => (effect) => effect.pipe(Effect24.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 = Effect23.fn("topics.topicMetrics")(function* (modelKey, config) {
+var topicMetrics = Effect24.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* Effect23.tryPromise({
+  const rows = yield* Effect24.tryPromise({
     try: () => db.select({
       topicKey: topics.topicKey,
       kind: topics.kind,
@@ -4723,12 +4745,12 @@ var topicMetrics = Effect23.fn("topics.topicMetrics")(function* (modelKey, confi
       deferredLeaves++;
   }
   leafMemberCounts.sort((a, b) => a - b);
-  const growth = yield* Effect23.tryPromise({
+  const growth = yield* Effect24.tryPromise({
     try: () => db.select({ total: sql6`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* Effect23.tryPromise({
+  const lastLog = yield* Effect24.tryPromise({
     try: () => db.select({
       operation: topicChangeLog.operation,
       createdAt: topicChangeLog.createdAt
@@ -4748,11 +4770,11 @@ var topicMetrics = Effect23.fn("topics.topicMetrics")(function* (modelKey, confi
     lastOperation
   };
 });
-var topicChangeLog2 = Effect23.fn("topics.topicChangeLog")(function* (modelKey, opts) {
+var topicChangeLog2 = Effect24.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* Effect23.tryPromise({
+  const rows = yield* Effect24.tryPromise({
     try: () => {
       const scoped = inArray3(topicChangeLog.topicKey, modelTopicKeys(db, modelKey));
       const filtered = opts?.operation ? and6(scoped, eq6(topicChangeLog.operation, opts.operation)) : scoped;
@@ -4762,14 +4784,14 @@ var topicChangeLog2 = Effect23.fn("topics.topicChangeLog")(function* (modelKey,
   }).pipe(routingFailure4("topics.topicChangeLog"));
   return rows;
 });
-var topicHealth = Effect23.fn("topics.topicHealth")(function* (modelKey, config) {
+var topicHealth = Effect24.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* Effect23.tryPromise({
+  const rows = yield* Effect24.tryPromise({
     try: () => db.select({
       topicKey: topics.topicKey,
       kind: topics.kind,
@@ -4779,7 +4801,7 @@ var topicHealth = Effect23.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* Effect23.tryPromise({
+  const countRows = yield* Effect24.tryPromise({
     try: () => db.select({ topicKey: topicMemberships.topicKey, count: sql6`count(*)` }).from(topicMemberships).where(eq6(topicMemberships.modelKey, modelKey)).groupBy(topicMemberships.topicKey),
     catch: (cause) => cause
   }).pipe(routingFailure4("topics.topicHealth.memberships"));
@@ -4804,30 +4826,30 @@ var topicHealth = Effect23.fn("topics.topicHealth")(function* (modelKey, config)
 });
 
 // ../store/src/graph/observability.ts
-import { Effect as Effect24 } from "effect";
+import { Effect as Effect25 } from "effect";
 import { and as and7, eq as eq7, isNull, sql as sql7 } from "drizzle-orm";
-var graphCoverage = Effect24.fn("GraphCoverage.run")(function* (modelKey) {
+var graphCoverage = Effect25.fn("GraphCoverage.run")(function* (modelKey) {
   const backend = yield* Service2;
   const db = backend.db;
-  const totalRows = yield* Effect24.tryPromise({
+  const totalRows = yield* Effect25.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(Effect24.mapError((cause) => new StoreError({ message: `graphCoverage: isolated: ${cause}` })));
+  const isolatedRows = yield* backend.listIsolatedMemories(0, modelKey).pipe(Effect25.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* Effect24.tryPromise({
+  const pendingRows = yield* Effect25.tryPromise({
     try: () => db.select({ count: sql7`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* Effect24.tryPromise({
+  const conceptCount = totalMemories === 0 ? 0 : (yield* Effect25.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* Effect24.tryPromise({
+  const annotatedMemories = totalMemories === 0 ? 0 : new Set((yield* Effect25.tryPromise({
     try: () => db.select({ memoryId: memoryConcepts.memoryId }).from(memoryConcepts),
     catch: (cause) => new StoreError({ message: `graphCoverage: annotations: ${cause}` })
   })).map((row) => row.memoryId)).size;
@@ -5062,25 +5084,25 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
   const db = backend.db;
   const topicsConfig = topicsOptions?.config ?? Schema23.decodeUnknownSync(TopicConfig)({});
   const topicsEnabled = topicsOptions?.enabled ?? false;
-  const updateTopicVectorForget = (backendImpl, model, topicKey, x) => Effect25.gen(function* () {
-    const current = yield* backendImpl.fetchTopicVector(topicKey, model).pipe(Effect25.mapError((cause) => new StoreError({ message: `Store.forget: load vector: ${cause}` })));
+  const updateTopicVectorForget = (backendImpl, model, topicKey, x) => Effect26.gen(function* () {
+    const current = yield* backendImpl.fetchTopicVector(topicKey, model).pipe(Effect26.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(Effect25.mapError((cause) => new StoreError({ message: `Store.forget: write vector: ${cause}` })));
-    const relRows = yield* Effect25.tryPromise({
+    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({
       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: storeError("Store.forget: load ancestor")
     });
     let ancestorKey = relRows[0]?.parentKey;
     while (ancestorKey !== undefined) {
       const key = ancestorKey;
-      const a = yield* backendImpl.fetchTopicVector(key, model).pipe(Effect25.mapError((cause) => new StoreError({ message: `Store.forget: load vector: ${cause}` })));
+      const a = yield* backendImpl.fetchTopicVector(key, model).pipe(Effect26.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(Effect25.mapError((cause) => new StoreError({ message: `Store.forget: write vector: ${cause}` })));
-      const up = yield* Effect25.tryPromise({
+      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({
         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: storeError("Store.forget: load ancestor")
       });
@@ -5130,14 +5152,14 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     };
     const seam = auditOptions?.enqueueAudit;
     if (seam !== undefined) {
-      return propagateSeam ? seam(row).pipe(Effect25.mapError((cause) => new StoreError({ message: `audit.enqueue-failed: ${cause}` }))) : seam(row).pipe(Effect25.catch((cause) => Effect25.logError("audit.enqueue-failed").pipe(Effect25.annotateLogs({
+      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({
         scope: "@dimple/store",
         event: "audit.enqueue-failed",
         mode,
         cause: String(cause)
       }))));
     }
-    return Effect25.sync(() => {
+    return Effect26.sync(() => {
       db.insert(retrievalLog2).values({
         id: row.id,
         queryHash: row.queryHash,
@@ -5152,7 +5174,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       }).catch(() => {});
     });
   };
-  const logAudit = Effect25.fn("Store.logAudit")(function* (input) {
+  const logAudit = Effect26.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;
@@ -5163,7 +5185,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
   const graphEnabled = graphConfig?.enabled !== false;
   const GRAPH_CANDIDATE_LIMIT_MAX = 200;
   const GRAPH_ISOLATED_EXAMPLES = 10;
-  const fetchResultEdges = (ids) => Effect25.tryPromise({
+  const fetchResultEdges = (ids) => Effect26.tryPromise({
     try: () => db.select({
       fromMemoryId: artifactEdges.fromMemoryId,
       toMemoryId: artifactEdges.toMemoryId,
@@ -5172,11 +5194,11 @@ var makeStore = (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: storeError("Store.retrieval post-pass: edges")
   });
-  const fetchResultConcepts = (ids) => Effect25.tryPromise({
+  const fetchResultConcepts = (ids) => Effect26.tryPromise({
     try: () => db.select({ memoryId: memoryConcepts2.memoryId, conceptId: memoryConcepts2.conceptId }).from(memoryConcepts2).where(inArray4(memoryConcepts2.memoryId, ids)),
     catch: storeError("Store.retrieval post-pass: concepts")
   });
-  const augmentRetrieval = (results) => Effect25.gen(function* () {
+  const augmentRetrieval = (results) => Effect26.gen(function* () {
     if (results.length === 0)
       return results;
     const ids = results.map((r) => r.memory.id);
@@ -5186,7 +5208,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       supersedeDemotion: GRAPH_SUPERSEDE_DEMOTION
     });
   });
-  const augmentSearchResults = Effect25.fn("Store.augmentSearchResults")(function* (results) {
+  const augmentSearchResults = Effect26.fn("Store.augmentSearchResults")(function* (results) {
     return yield* augmentRetrieval(results);
   });
   const EDGE_KINDS = [
@@ -5196,7 +5218,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     "code_calls"
   ];
   const EDGE_SOURCES = ["rule", "llm", "agent"];
-  const write = Effect25.fn("Store.write")(function* (input) {
+  const write = Effect26.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)"
@@ -5205,7 +5227,7 @@ var makeStore = (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* Effect25.tryPromise({
+    yield* Effect26.tryPromise({
       try: () => db.transaction(async (tx) => {
         await tx.insert(memories2).values({
           id,
@@ -5238,7 +5260,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       embeddingModel: undefined
     };
   });
-  const writeMany = Effect25.fn("Store.writeMany")(function* (inputs) {
+  const writeMany = Effect26.fn("Store.writeMany")(function* (inputs) {
     if (inputs.length === 0)
       return [];
     for (const input of inputs) {
@@ -5262,7 +5284,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
         metadata: metadataBlob
       };
     });
-    yield* Effect25.tryPromise({
+    yield* Effect26.tryPromise({
       try: () => db.transaction(async (tx) => {
         await tx.insert(memories2).values(rows);
         await tx.insert(memoryEvents2).values(rows.map((row) => ({
@@ -5290,8 +5312,8 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       embeddingModel: undefined
     }));
   });
-  const get = Effect25.fn("Store.get")(function* (id) {
-    const rows = yield* Effect25.tryPromise({
+  const get = Effect26.fn("Store.get")(function* (id) {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select(memoryFields).from(memories2).where(eq8(memories2.id, id)).limit(1),
       catch: storeError("Store.get")
     });
@@ -5300,8 +5322,8 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       return yield* new NotFound({ id });
     return fromMemoryRow(row);
   });
-  const getByKey = Effect25.fn("Store.getByKey")(function* (key, namespace) {
-    const rows = yield* Effect25.tryPromise({
+  const getByKey = Effect26.fn("Store.getByKey")(function* (key, namespace) {
+    const rows = yield* Effect26.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: storeError("Store.getByKey")
     });
@@ -5310,9 +5332,9 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       return yield* new NotFound({ id: key });
     return fromMemoryRow(row);
   });
-  const recency = Effect25.fn("Store.recency")(function* (namespace, limit) {
+  const recency = Effect26.fn("Store.recency")(function* (namespace, limit) {
     const start = Date.now();
-    const rows = yield* Effect25.tryPromise({
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select(memoryFields).from(memories2).where(and8(eq8(memories2.namespace, namespace), eq8(memories2.state, "active"))).orderBy(desc2(memories2.createdAt)).limit(limit),
       catch: storeError("Store.recency")
     });
@@ -5325,7 +5347,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     yield* logRetrieval(namespace, namespace, "recency", results.length, start);
     return yield* augmentRetrieval(results);
   });
-  const searchFts5 = Effect25.fn("Store.searchFts5")(function* (query, namespace, limit, opts) {
+  const searchFts5 = Effect26.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, opts?.includeEmbedding === true);
     if (opts?.audit !== false) {
@@ -5356,7 +5378,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       return results;
     return yield* augmentRetrieval(results);
   });
-  const searchVector = Effect25.fn("Store.searchVector")(function* (query, namespace, limit, opts) {
+  const searchVector = Effect26.fn("Store.searchVector")(function* (query, namespace, limit, opts) {
     if (!modelConfig) {
       return yield* new StoreError({
         message: "Store.searchVector: no embedding model configured"
@@ -5366,7 +5388,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     let allowedMemoryIds;
     const conceptIds = opts?.conceptIds;
     if (conceptIds !== undefined && conceptIds.length > 0) {
-      const conceptRows = yield* Effect25.tryPromise({
+      const conceptRows = yield* Effect26.tryPromise({
         try: () => db.select({ memoryId: memoryConcepts2.memoryId }).from(memoryConcepts2).where(inArray4(memoryConcepts2.conceptId, conceptIds)),
         catch: storeError("Store.searchVector: concepts")
       });
@@ -5403,9 +5425,9 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       return results;
     return yield* augmentRetrieval(results);
   });
-  const supersede = Effect25.fn("Store.supersede")(function* (key, namespace) {
+  const supersede = Effect26.fn("Store.supersede")(function* (key, namespace) {
     const now = Date.now();
-    const result = yield* Effect25.tryPromise({
+    const result = yield* Effect26.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)
@@ -5417,7 +5439,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     if (!result)
       return yield* new NotFound({ id: key });
   });
-  const decrementTreeCf = (model, membership, x) => Effect25.tryPromise({
+  const decrementTreeCf = (model, membership, x) => Effect26.tryPromise({
     try: () => db.transaction(async (tx) => {
       const leafRows = await tx.select({
         topicKey: topics.topicKey,
@@ -5447,10 +5469,10 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     }),
     catch: storeError("Store: tree CF decrement")
   });
-  const forget = Effect25.fn("Store.forget")(function* (id) {
+  const forget = Effect26.fn("Store.forget")(function* (id) {
     let membership;
     if (topicsEnabled) {
-      const memberRows = yield* Effect25.tryPromise({
+      const memberRows = yield* Effect26.tryPromise({
         try: () => db.select({ topicKey: topicMemberships.topicKey, modelKey: topicMemberships.modelKey }).from(topicMemberships).where(eq8(topicMemberships.memoryId, id)),
         catch: storeError("Store.forget: load membership")
       });
@@ -5465,14 +5487,14 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
         }
       }
     }
-    const rs = yield* Effect25.tryPromise({
+    const rs = yield* Effect26.tryPromise({
       try: () => db.delete(memories2).where(eq8(memories2.id, id)),
       catch: storeError("Store.forget")
     });
     if (rs.rowsAffected === 0)
       return yield* new NotFound({ id });
     if (topicsEnabled && membership && modelConfig && modelConfig.id === membership.modelKey) {
-      const leafRows = yield* Effect25.tryPromise({
+      const leafRows = yield* Effect26.tryPromise({
         try: () => db.select({ memberCount: topics.memberCount }).from(topics).where(and8(eq8(topics.topicKey, membership.topicKey), eq8(topics.modelKey, membership.modelKey))),
         catch: storeError("Store.forget: load leaf")
       });
@@ -5480,18 +5502,18 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       if (liveCount < (topicsConfig.minLeafItems ?? 32)) {
         const enqueueMerge = topicsOptions?.enqueueMerge;
         if (enqueueMerge) {
-          yield* enqueueMerge(membership.topicKey, membership.modelKey).pipe(Effect25.mapError((cause) => new StoreError({ message: `Store.forget enqueueMerge: ${cause}` })));
+          yield* enqueueMerge(membership.topicKey, membership.modelKey).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.forget enqueueMerge: ${cause}` })));
         } else {
-          yield* mergeOrBorrow(membership.topicKey, modelConfig, topicsConfig).pipe(Effect25.provideService(Service2, backend), Effect25.mapError((cause) => new StoreError({ message: `Store.forget mergeOrBorrow: ${cause}` })));
+          yield* mergeOrBorrow(membership.topicKey, modelConfig, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.forget mergeOrBorrow: ${cause}` })));
         }
       }
     }
   });
-  const sweep = Effect25.fn("Store.sweep")(function* (namespace) {
+  const sweep = Effect26.fn("Store.sweep")(function* (namespace) {
     return yield* backend.sweep(namespace);
   });
-  const events = Effect25.fn("Store.events")(function* (memoryId) {
-    const rows = yield* Effect25.tryPromise({
+  const events = Effect26.fn("Store.events")(function* (memoryId) {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select().from(memoryEvents2).where(eq8(memoryEvents2.memoryId, memoryId)).orderBy(asc5(memoryEvents2.createdAt)),
       catch: storeError("Store.events")
     });
@@ -5508,7 +5530,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     });
   });
   const resolveModel = (modelKey) => modelConfig?.id === modelKey ? modelConfig : undefined;
-  const ensureTopicTree2 = Effect25.fn("Store.ensureTopicTree")(function* (modelKey) {
+  const ensureTopicTree2 = Effect26.fn("Store.ensureTopicTree")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -5516,33 +5538,33 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
         actual: modelKey
       });
     }
-    return yield* ensureTopicTree(model, topicsConfig).pipe(Effect25.provideService(Service2, backend));
+    return yield* ensureTopicTree(model, topicsConfig).pipe(Effect26.provideService(Service2, backend));
   });
-  const resolveTopics2 = Effect25.fn("Store.resolveTopics")(function* (queryVector, opts) {
+  const resolveTopics2 = Effect26.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(Effect25.provideService(Service2, backend));
+    return yield* resolveTopics(queryVector, modelConfig, topicsConfig, opts).pipe(Effect26.provideService(Service2, backend));
   });
-  const topicMembers = Effect25.fn("Store.topicMembers")(function* (topicKey) {
-    const rows = yield* Effect25.tryPromise({
+  const topicMembers = Effect26.fn("Store.topicMembers")(function* (topicKey) {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(eq8(topicMemberships.topicKey, topicKey)).orderBy(asc5(topicMemberships.memoryId)),
       catch: storeError("Store.topicMembers")
     });
     return rows;
   });
-  const listTopics = Effect25.fn("Store.listTopics")(function* (modelKey) {
-    const rows = yield* Effect25.tryPromise({
+  const listTopics = Effect26.fn("Store.listTopics")(function* (modelKey) {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select().from(topics).where(eq8(topics.modelKey, modelKey)).orderBy(asc5(topics.topicKey)),
       catch: storeError("Store.listTopics")
     });
     return rows;
   });
-  const topicStats = Effect25.fn("Store.topicStats")(function* (modelKey) {
-    const rows = yield* Effect25.tryPromise({
+  const topicStats = Effect26.fn("Store.topicStats")(function* (modelKey) {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select({ kind: topics.kind, depth: topics.depth }).from(topics).where(eq8(topics.modelKey, modelKey)),
       catch: storeError("Store.topicStats")
     });
@@ -5559,7 +5581,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     }
     return { depth, leafCount, internalCount, totalTopics: rows.length };
   });
-  const deleteTree = Effect25.fn("Store.deleteTree")(function* (modelKey) {
+  const deleteTree = Effect26.fn("Store.deleteTree")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -5568,7 +5590,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       });
     }
     yield* backend.deleteTopicVectors(model);
-    yield* Effect25.tryPromise({
+    yield* Effect26.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));
@@ -5580,7 +5602,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       catch: storeError("Store.deleteTree")
     });
   });
-  const processSplits = Effect25.fn("Store.processSplits")(function* (modelKey) {
+  const processSplits = Effect26.fn("Store.processSplits")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -5590,19 +5612,19 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     }
     let processed = 0;
     for (let iteration = 0;iteration < 100; iteration++) {
-      const leaves = yield* Effect25.tryPromise({
+      const leaves = yield* Effect26.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: storeError("Store.processSplits")
       });
       const candidate = leaves.find((leaf) => shouldSplit(leaf.memberCount, topicsConfig));
       if (!candidate)
         break;
-      yield* splitTopic(candidate.topicKey, model, topicsConfig).pipe(Effect25.provideService(Service2, backend), Effect25.mapError((cause) => new StoreError({ message: `Store.processSplits: ${cause}` })));
+      yield* splitTopic(candidate.topicKey, model, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.processSplits: ${cause}` })));
       processed++;
     }
     return processed;
   });
-  const mergeOrBorrow2 = Effect25.fn("Store.mergeOrBorrow")(function* (modelKey, topicKey) {
+  const mergeOrBorrow2 = Effect26.fn("Store.mergeOrBorrow")(function* (modelKey, topicKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -5610,9 +5632,9 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
         actual: modelKey
       });
     }
-    return yield* mergeOrBorrow(topicKey, model, topicsConfig).pipe(Effect25.provideService(Service2, backend), Effect25.mapError((cause) => new StoreError({ message: `Store.mergeOrBorrow: ${cause}` })));
+    return yield* mergeOrBorrow(topicKey, model, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.mergeOrBorrow: ${cause}` })));
   });
-  const rebalanceSiblings2 = Effect25.fn("Store.rebalanceSiblings")(function* (modelKey, topicKey) {
+  const rebalanceSiblings2 = Effect26.fn("Store.rebalanceSiblings")(function* (modelKey, topicKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -5620,15 +5642,15 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
         actual: modelKey
       });
     }
-    return yield* rebalanceSiblings(topicKey, model, topicsConfig).pipe(Effect25.provideService(Service2, backend), Effect25.mapError((cause) => new StoreError({ message: `Store.rebalanceSiblings: ${cause}` })));
+    return yield* rebalanceSiblings(topicKey, model, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.rebalanceSiblings: ${cause}` })));
   });
-  const setActiveModel2 = Effect25.fn("Store.setActiveModel")(function* (model) {
-    return yield* setActiveModel(model, topicsConfig).pipe(Effect25.provideService(Service2, backend));
+  const setActiveModel2 = Effect26.fn("Store.setActiveModel")(function* (model) {
+    return yield* setActiveModel(model, topicsConfig).pipe(Effect26.provideService(Service2, backend));
   });
-  const isActive2 = Effect25.fn("Store.isActive")(function* (modelKey) {
-    return yield* isActive(modelKey).pipe(Effect25.provideService(Service2, backend));
+  const isActive2 = Effect26.fn("Store.isActive")(function* (modelKey) {
+    return yield* isActive(modelKey).pipe(Effect26.provideService(Service2, backend));
   });
-  const topicMetrics2 = Effect25.fn("Store.topicMetrics")(function* (modelKey) {
+  const topicMetrics2 = Effect26.fn("Store.topicMetrics")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -5636,9 +5658,9 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
         actual: modelKey
       });
     }
-    return yield* topicMetrics(modelKey, topicsConfig).pipe(Effect25.provideService(Service2, backend));
+    return yield* topicMetrics(modelKey, topicsConfig).pipe(Effect26.provideService(Service2, backend));
   });
-  const topicChangeLog3 = Effect25.fn("Store.topicChangeLog")(function* (modelKey, opts) {
+  const topicChangeLog3 = Effect26.fn("Store.topicChangeLog")(function* (modelKey, opts) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -5646,9 +5668,9 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
         actual: modelKey
       });
     }
-    return yield* topicChangeLog2(modelKey, opts).pipe(Effect25.provideService(Service2, backend));
+    return yield* topicChangeLog2(modelKey, opts).pipe(Effect26.provideService(Service2, backend));
   });
-  const topicHealth2 = Effect25.fn("Store.topicHealth")(function* (modelKey) {
+  const topicHealth2 = Effect26.fn("Store.topicHealth")(function* (modelKey) {
     const model = resolveModel(modelKey);
     if (!model) {
       return yield* new ModelMismatch({
@@ -5656,11 +5678,11 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
         actual: modelKey
       });
     }
-    return yield* topicHealth(modelKey, topicsConfig).pipe(Effect25.provideService(Service2, backend));
+    return yield* topicHealth(modelKey, topicsConfig).pipe(Effect26.provideService(Service2, backend));
   });
-  const updateEmbedding = Effect25.fn("Store.updateEmbedding")(function* (id, embedding, modelName, options) {
+  const updateEmbedding = Effect26.fn("Store.updateEmbedding")(function* (id, embedding, modelName, options) {
     const now = Date.now();
-    const affected = yield* Effect25.tryPromise({
+    const affected = yield* Effect26.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)
@@ -5690,7 +5712,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     if (modelConfig && modelConfig.id === modelName) {
       yield* backend.ensureVectorTable(modelConfig);
       if (topicsEnabled) {
-        const memberRows = yield* Effect25.tryPromise({
+        const memberRows = yield* Effect26.tryPromise({
           try: () => db.select({
             topicKey: topicMemberships.topicKey,
             modelKey: topicMemberships.modelKey
@@ -5705,7 +5727,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
             yield* decrementTreeCf(modelConfig, mem, x);
             yield* updateTopicVectorForget(backend, modelConfig, mem.topicKey, x);
           }
-          yield* Effect25.tryPromise({
+          yield* Effect26.tryPromise({
             try: () => db.delete(topicMemberships).where(and8(eq8(topicMemberships.memoryId, id), eq8(topicMemberships.modelKey, modelName))),
             catch: storeError("Store.updateEmbedding: delete membership")
           });
@@ -5713,26 +5735,26 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       }
       yield* backend.insertVector(id, embedding, modelConfig);
       if (topicsEnabled) {
-        const routed = yield* routeInsert(id, embedding, modelConfig, topicsConfig).pipe(Effect25.provideService(Service2, backend), Effect25.mapError((cause) => new StoreError({ message: `Store.updateEmbedding topic route: ${cause}` })));
+        const routed = yield* routeInsert(id, embedding, modelConfig, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.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(Effect25.mapError((cause) => new StoreError({ message: `Store.updateEmbedding enqueueSplit: ${cause}` })));
+            yield* enqueueSplit(routed.topicKey, modelConfig.id).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbedding enqueueSplit: ${cause}` })));
           } else {
-            yield* processSplits(modelConfig.id).pipe(Effect25.mapError((cause) => new StoreError({ message: `Store.updateEmbedding processSplits: ${cause}` })));
+            yield* processSplits(modelConfig.id).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbedding processSplits: ${cause}` })));
           }
         }
       }
     }
   });
-  const updateEmbeddingMany = Effect25.fn("Store.updateEmbeddingMany")(function* (entries, modelName, options) {
+  const updateEmbeddingMany = Effect26.fn("Store.updateEmbeddingMany")(function* (entries, modelName, options) {
     if (entries.length === 0)
       return;
     const now = Date.now();
-    yield* Effect25.tryPromise({
+    yield* Effect26.tryPromise({
       try: () => db.transaction(async (tx) => {
         await tx.run(sql8`UPDATE ${memories2} SET embedding = CASE id ${sql8.join(entries.map((entry) => sql8`WHEN ${entry.id} THEN ${new Float32Array(entry.embedding).buffer}`), sql8` `)} END, embedding_model = ${modelName} WHERE id IN (${sql8.join(entries.map((entry) => entry.id), sql8`, `)})`);
         await tx.insert(memoryEvents2).values(entries.map((entry) => ({
@@ -5758,7 +5780,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       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(Effect25.provideService(Service2, backend), Effect25.mapError((cause) => new StoreError({ message: `Store.updateEmbeddingMany route: ${cause}` })));
+        const routed = yield* routeInsertMany(entries.map((entry) => ({ memoryId: entry.id, vector: entry.embedding })), modelConfig, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.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);
@@ -5772,17 +5794,17 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
           const enqueueSplit = topicsOptions?.enqueueSplit;
           if (enqueueSplit) {
             for (const topicKey of overflowed) {
-              yield* enqueueSplit(topicKey, modelConfig.id).pipe(Effect25.mapError((cause) => new StoreError({ message: `Store.updateEmbeddingMany enqueueSplit: ${cause}` })));
+              yield* enqueueSplit(topicKey, modelConfig.id).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbeddingMany enqueueSplit: ${cause}` })));
             }
           } else {
-            yield* processSplits(modelConfig.id).pipe(Effect25.mapError((cause) => new StoreError({ message: `Store.updateEmbeddingMany processSplits: ${cause}` })));
+            yield* processSplits(modelConfig.id).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbeddingMany processSplits: ${cause}` })));
           }
         }
       }
     }
   });
-  const findStale = Effect25.fn("Store.findStale")(function* (model) {
-    const rows = yield* Effect25.tryPromise({
+  const findStale = Effect26.fn("Store.findStale")(function* (model) {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select({ id: memories2.id }).from(memories2).where(and8(eq8(memories2.state, "active"), sql8`(embedding IS NULL OR embedding_model IS NULL OR embedding_model != ${model})`)),
       catch: storeError("Store.findStale")
     });
@@ -5802,14 +5824,14 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     });
     return memoryId;
   };
-  const reconcile = Effect25.fn("Store.reconcile")(function* (namespace, keyPrefix, keyRoot, walkedRoots, keptKeys) {
+  const reconcile = Effect26.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) => root === "/" ? filePath.startsWith("/") : filePath === root || filePath.startsWith(`${root}/`));
     };
     const owned = (key) => keptKeys.includes(key);
-    const rows = yield* Effect25.tryPromise({
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select({
         id: memories2.id,
         logicalKey: memories2.logicalKey,
@@ -5820,7 +5842,7 @@ var makeStore = (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* Effect25.tryPromise({
+      yield* Effect26.tryPromise({
         try: () => db.transaction(async (tx) => {
           for (const row of vanished) {
             await flipToSupersededById(tx, row.id, now, "source_removed");
@@ -5831,7 +5853,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     }
     return vanished;
   });
-  const writeSuperseding = Effect25.fn("Store.writeSuperseding")(function* (input) {
+  const writeSuperseding = Effect26.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)"
@@ -5842,7 +5864,7 @@ var makeStore = (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* Effect25.tryPromise({
+    yield* Effect26.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];
@@ -5897,7 +5919,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       ...supersededId !== undefined ? { supersededId } : undefined
     };
   });
-  const addEdge = Effect25.fn("Store.addEdge")(function* (input) {
+  const addEdge = Effect26.fn("Store.addEdge")(function* (input) {
     if (input.fromMemoryId === input.toMemoryId) {
       return yield* new StoreError({ message: "Store.addEdge: self-loops are not allowed" });
     }
@@ -5923,7 +5945,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
         message: `Store.addEdge: confidence must be a finite number in [0,1] (got ${String(confidence)})`
       });
     }
-    const endpoints = yield* Effect25.tryPromise({
+    const endpoints = yield* Effect26.tryPromise({
       try: () => db.select({ id: memories2.id }).from(memories2).where(inArray4(memories2.id, [input.fromMemoryId, input.toMemoryId])),
       catch: storeError("Store.addEdge: endpoints")
     });
@@ -5948,7 +5970,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       createdAt: now,
       updatedAt: now
     };
-    yield* Effect25.tryPromise({
+    yield* Effect26.tryPromise({
       try: () => db.transaction(async (tx) => {
         await tx.insert(artifactEdges).values(row);
         if (input.confirmed && input.edgeKind === "memory_supersedes") {
@@ -5968,17 +5990,17 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     });
     return row;
   });
-  const expireEdge = Effect25.fn("Store.expireEdge")(function* (id) {
-    const rs = yield* Effect25.tryPromise({
+  const expireEdge = Effect26.fn("Store.expireEdge")(function* (id) {
+    const rs = yield* Effect26.tryPromise({
       try: () => db.update(artifactEdges).set({ expiredAt: Date.now(), updatedAt: Date.now() }).where(eq8(artifactEdges.id, id)),
       catch: storeError("Store.expireEdge")
     });
     if (rs.rowsAffected === 0)
       return yield* new EdgeNotFound({ id });
   });
-  const confirmEdge = Effect25.fn("Store.confirmEdge")(function* (id) {
+  const confirmEdge = Effect26.fn("Store.confirmEdge")(function* (id) {
     const now = Date.now();
-    const found = yield* Effect25.tryPromise({
+    const found = yield* Effect26.tryPromise({
       try: () => db.transaction(async (tx) => {
         const rows = await tx.select().from(artifactEdges).where(eq8(artifactEdges.id, id)).limit(1);
         const edge = rows[0];
@@ -5995,15 +6017,15 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     if (!found)
       return yield* new EdgeNotFound({ id });
   });
-  const rejectEdge = Effect25.fn("Store.rejectEdge")(function* (id) {
-    const rs = yield* Effect25.tryPromise({
+  const rejectEdge = Effect26.fn("Store.rejectEdge")(function* (id) {
+    const rs = yield* Effect26.tryPromise({
       try: () => db.update(artifactEdges).set({ status: "rejected", updatedAt: Date.now() }).where(eq8(artifactEdges.id, id)),
       catch: storeError("Store.rejectEdge")
     });
     if (rs.rowsAffected === 0)
       return yield* new EdgeNotFound({ id });
   });
-  const listEdges = Effect25.fn("Store.listEdges")(function* (opts) {
+  const listEdges = Effect26.fn("Store.listEdges")(function* (opts) {
     const conditions = [];
     if (!opts?.includeExpired)
       conditions.push(isNull2(artifactEdges.expiredAt));
@@ -6014,7 +6036,7 @@ var makeStore = (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* Effect25.tryPromise({
+    const rows = yield* Effect26.tryPromise({
       try: () => {
         const base = db.select().from(artifactEdges);
         return (conditions.length === 0 ? base : base.where(and8(...conditions))).orderBy(desc2(artifactEdges.createdAt));
@@ -6023,7 +6045,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     });
     return rows;
   });
-  const explain = Effect25.fn("Store.explain")(function* (node5, opts) {
+  const explain = Effect26.fn("Store.explain")(function* (node5, opts) {
     if (node5.kind !== "memory" && node5.kind !== "topic" && node5.kind !== "concept") {
       return yield* new StoreError({
         message: `Store.explain: unknown kind "${String(node5.kind)}"`
@@ -6067,7 +6089,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       pendingConflicts: pending
     };
   });
-  const writeCandidateEdges = (candidates, now) => Effect25.tryPromise({
+  const writeCandidateEdges = (candidates, now) => Effect26.tryPromise({
     try: () => db.transaction(async (tx) => {
       let inserted = 0;
       for (const candidate of candidates) {
@@ -6097,11 +6119,11 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     }),
     catch: storeError("Store.writeCandidateEdges")
   });
-  const reconcileRenameCandidates = Effect25.fn("Store.reconcileRenameCandidates")(function* (vanished, newUnitIds) {
+  const reconcileRenameCandidates = Effect26.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* Effect25.tryPromise({
+    const newRows = yield* Effect26.tryPromise({
       try: () => db.select({ id: memories2.id, embedding: memories2.embedding }).from(memories2).where(and8(inArray4(memories2.id, newUnitIds))),
       catch: storeError("Store.reconcileRenameCandidates")
     });
@@ -6133,16 +6155,16 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     inserted = yield* writeCandidateEdges(batch, now);
     return inserted;
   });
-  const scanLeafCandidates = (memoryId, vector, topicKey, model) => Effect25.gen(function* () {
-    const memberRows = yield* Effect25.tryPromise({
+  const scanLeafCandidates = (memoryId, vector, topicKey, model) => Effect26.gen(function* () {
+    const memberRows = yield* Effect26.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: storeError("Store.updateEmbedding candidates: members")
     });
     const memberIds = memberRows.map((r) => r.memoryId);
     if (memberIds.length === 0)
       return;
-    const vectorRows = yield* backend.fetchMemoryVectors(memberIds, model).pipe(Effect25.mapError((cause) => new StoreError({ message: `Store.updateEmbedding candidates: vectors: ${cause}` })));
-    const memoryRows = yield* Effect25.tryPromise({
+    const vectorRows = yield* backend.fetchMemoryVectors(memberIds, model).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbedding candidates: vectors: ${cause}` })));
+    const memoryRows = yield* Effect26.tryPromise({
       try: () => db.select({
         id: memories2.id,
         logicalKey: memories2.logicalKey,
@@ -6151,7 +6173,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       }).from(memories2).where(and8(inArray4(memories2.id, memberIds), eq8(memories2.state, "active"))),
       catch: storeError("Store.updateEmbedding candidates: memories")
     });
-    const selfRows = yield* Effect25.tryPromise({
+    const selfRows = yield* Effect26.tryPromise({
       try: () => db.select({
         logicalKey: memories2.logicalKey,
         createdAt: memories2.createdAt,
@@ -6179,9 +6201,9 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     const now = Date.now();
     yield* writeCandidateEdges(candidates, now);
   });
-  const graphCandidates = Effect25.fn("Store.graphCandidates")(function* (opts) {
+  const graphCandidates = Effect26.fn("Store.graphCandidates")(function* (opts) {
     const limit = Math.max(1, Math.min(opts?.limit ?? 50, GRAPH_CANDIDATE_LIMIT_MAX));
-    const rows = yield* Effect25.tryPromise({
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select({
         id: artifactEdges.id,
         fromMemoryId: artifactEdges.fromMemoryId,
@@ -6193,7 +6215,7 @@ var makeStore = (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: storeError("Store.graphCandidates: pending")
     });
-    const isolatedRows = yield* backend.listIsolatedMemories(0).pipe(Effect25.mapError((cause) => new StoreError({ message: `Store.graphCandidates: isolated: ${cause}` })));
+    const isolatedRows = yield* backend.listIsolatedMemories(0).pipe(Effect26.mapError((cause) => new StoreError({ message: `Store.graphCandidates: isolated: ${cause}` })));
     const isolatedRowsDecoded = Schema23.decodeUnknownSync(Schema23.Array(Schema23.Struct({ id: Schema23.String, createdAt: Schema23.Number })))(isolatedRows);
     const isolated = isolatedRowsDecoded.map((row) => ({
       id: row.id,
@@ -6213,13 +6235,13 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       oldestIsolated: isolated.slice(0, GRAPH_ISOLATED_EXAMPLES)
     };
   });
-  const graphCoverage2 = Effect25.fn("Store.graphCoverage")(function* (modelKey) {
-    return yield* graphCoverage(modelKey).pipe(Effect25.provideService(Service2, backend));
+  const graphCoverage2 = Effect26.fn("Store.graphCoverage")(function* (modelKey) {
+    return yield* graphCoverage(modelKey).pipe(Effect26.provideService(Service2, backend));
   });
-  const createConcept = Effect25.fn("Store.createConcept")(function* (name, embedding) {
+  const createConcept = Effect26.fn("Store.createConcept")(function* (name, embedding) {
     const id = crypto.randomUUID();
     const now = Date.now();
-    yield* Effect25.tryPromise({
+    yield* Effect26.tryPromise({
       try: () => db.insert(concepts2).values({
         id,
         name,
@@ -6239,8 +6261,8 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       lastSeen: now
     };
   });
-  const getConcept = Effect25.fn("Store.getConcept")(function* (id) {
-    const rows = yield* Effect25.tryPromise({
+  const getConcept = Effect26.fn("Store.getConcept")(function* (id) {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select().from(concepts2).where(eq8(concepts2.id, id)).limit(1),
       catch: storeError("Store.getConcept")
     });
@@ -6256,8 +6278,8 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       lastSeen: row.lastSeen
     };
   });
-  const listConcepts = Effect25.fn("Store.listConcepts")(function* () {
-    const rows = yield* Effect25.tryPromise({
+  const listConcepts = Effect26.fn("Store.listConcepts")(function* () {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select().from(concepts2),
       catch: storeError("Store.listConcepts")
     });
@@ -6270,8 +6292,8 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       lastSeen: row.lastSeen
     }));
   });
-  const annotateMemory = Effect25.fn("Store.annotateMemory")(function* (memoryId, conceptId, confidence) {
-    yield* Effect25.tryPromise({
+  const annotateMemory = Effect26.fn("Store.annotateMemory")(function* (memoryId, conceptId, confidence) {
+    yield* Effect26.tryPromise({
       try: () => db.insert(memoryConcepts2).values({
         conceptId,
         memoryId,
@@ -6281,14 +6303,14 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       catch: storeError("Store.annotateMemory")
     });
   });
-  const getMemoryAnnotations = Effect25.fn("Store.getMemoryAnnotations")(function* (memoryId) {
-    const rows = yield* Effect25.tryPromise({
+  const getMemoryAnnotations = Effect26.fn("Store.getMemoryAnnotations")(function* (memoryId) {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select({ conceptId: memoryConcepts2.conceptId }).from(memoryConcepts2).where(eq8(memoryConcepts2.memoryId, memoryId)),
       catch: storeError("Store.getMemoryAnnotations")
     });
     return rows.map((r) => r.conceptId);
   });
-  const queryByMetadata = Effect25.fn("Store.queryByMetadata")(function* (filter) {
+  const queryByMetadata = Effect26.fn("Store.queryByMetadata")(function* (filter) {
     const rows = yield* backend.queryByMetadata(filter);
     const typed = rows;
     return typed.map((row) => fromMemoryRow({
@@ -6305,8 +6327,8 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       embeddingModel: row.embedding_model
     }));
   });
-  const getMemoryMetadata = Effect25.fn("Store.getMemoryMetadata")(function* (id) {
-    const rows = yield* Effect25.tryPromise({
+  const getMemoryMetadata = Effect26.fn("Store.getMemoryMetadata")(function* (id) {
+    const rows = yield* Effect26.tryPromise({
       try: () => db.select({ metadata: memories2.metadata }).from(memories2).where(eq8(memories2.id, id)).limit(1),
       catch: storeError("Store.getMemoryMetadata")
     });
@@ -6315,8 +6337,8 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       return yield* new NotFound({ id });
     return parseMetadata(row.metadata);
   });
-  const setMemoryMetadata = Effect25.fn("Store.setMemoryMetadata")(function* (id, metadata) {
-    const updated = yield* Effect25.tryPromise({
+  const setMemoryMetadata = Effect26.fn("Store.setMemoryMetadata")(function* (id, metadata) {
+    const updated = yield* Effect26.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];
@@ -6383,17 +6405,17 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     graphCoverage: graphCoverage2
   };
 };
-var layer8 = (url, options) => {
-  const base = Layer10.effect(Service5, Effect25.gen(function* () {
+var layer9 = (url, options) => {
+  const base = Layer11.effect(Service5, Effect26.gen(function* () {
     const backend = yield* Service2;
     return Service5.of(makeStore(backend, options?.embeddingModelConfig, options?.topics, options?.graphConfig, options?.enqueueAudit !== undefined ? { enqueueAudit: options.enqueueAudit } : undefined, options?.defaultTtlSecs));
-  })).pipe(Layer10.provideMerge(layer3(url, options)));
+  })).pipe(Layer11.provideMerge(layer3(url, options)));
   const config = options?.logging ?? silentConfig;
-  return Layer10.provideMerge(layer(config))(base);
+  return Layer11.provideMerge(layer(config))(base);
 };
-var configured6 = (url, options) => make({ name: "Store", layer: Layer10.suspend(() => layer8(url, options)), deps: [] });
+var configured6 = (url, options) => make({ name: "Store", layer: Layer11.suspend(() => layer9(url, options)), deps: [] });
 var node5 = configured6("file:./.dimple/dimple.db");
-var loggingFromConfig = Layer10.unwrap(Effect25.map(Effect25.service(Service4), (cfg) => layer(cfg.config.logging ?? silentConfig)));
+var loggingFromConfig = Layer11.unwrap(Effect26.map(Effect26.service(Service4), (cfg) => layer(cfg.config.logging ?? silentConfig)));
 // ../store/src/topics/index.ts
 var exports_topics = {};
 __export(exports_topics, {
@@ -6452,15 +6474,15 @@ __export(exports_topics, {
 });
 
 // ../store/src/audit.ts
-import { Effect as Effect26 } from "effect";
+import { Effect as Effect27 } from "effect";
 function auditWriteHandler(deps = {}) {
-  const run = (payload, ctx) => Effect26.gen(function* () {
+  const run = (payload, ctx) => Effect27.gen(function* () {
     const envelope = payload;
     const backend = yield* Service2;
-    yield* backend.writeAuditRows(envelope.rows).pipe(Effect26.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `audit.write: ${error}` })));
+    yield* backend.writeAuditRows(envelope.rows).pipe(Effect27.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `audit.write: ${error}` })));
     return;
   });
-  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect26.provideService(Service2, deps.backend)) : run;
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect27.provideService(Service2, deps.backend)) : run;
 }
 // ../store/src/graph/index.ts
 var exports_graph = {};
@@ -6495,7 +6517,7 @@ __export(exports_graph, {
 });
 
 // ../store/src/graph/concepts.ts
-import { Clock as Clock6, Effect as Effect27 } from "effect";
+import { Clock as Clock6, Effect as Effect28 } from "effect";
 import { and as and9, asc as asc6, eq as eq9, isNotNull, sql as sql9 } from "drizzle-orm";
 var DEFAULT_CLUSTER_K = 8;
 var DEFAULT_CLUSTER_MIN_SIZE = 3;
@@ -6618,11 +6640,11 @@ var conceptConfidence = (vector, centroid) => {
     return 0;
   return Math.min(1, Math.max(0, dot3(vector, centroid) / Math.sqrt(norm)));
 };
-var clusterLeaf = Effect27.fn("ConceptCluster.clusterLeaf")(function* (topicKey, model, config) {
+var clusterLeaf = Effect28.fn("ConceptCluster.clusterLeaf")(function* (topicKey, model, config) {
   const backend = yield* Service2;
   const db = backend.db;
   const now = yield* Clock6.currentTimeMillis;
-  const memberRows = yield* Effect27.tryPromise({
+  const memberRows = yield* Effect28.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}` })
   });
@@ -6641,11 +6663,11 @@ var clusterLeaf = Effect27.fn("ConceptCluster.clusterLeaf")(function* (topicKey,
     return { concepts: 0, annotated: 0 };
   return yield* persistClusters(db, members, config, now);
 });
-var clusterCorpus = Effect27.fn("ConceptCluster.clusterCorpus")(function* (model, config) {
+var clusterCorpus = Effect28.fn("ConceptCluster.clusterCorpus")(function* (model, config) {
   const backend = yield* Service2;
   const db = backend.db;
   const now = yield* Clock6.currentTimeMillis;
-  const rows = yield* Effect27.tryPromise({
+  const rows = yield* Effect28.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}` })
   });
@@ -6662,7 +6684,7 @@ var clusterCorpus = Effect27.fn("ConceptCluster.clusterCorpus")(function* (model
     return { concepts: 0, annotated: 0 };
   return yield* persistClusters(db, members, config, now);
 });
-var persistClusters = (db, members, config, now) => Effect27.tryPromise({
+var persistClusters = (db, members, config, now) => Effect28.tryPromise({
   try: () => db.transaction(async (tx) => {
     const { k, minClusterSize } = resolvedClusterConfig(config);
     const vectors = members.map((m) => m.vector);
@@ -6713,21 +6735,21 @@ var persistClusters = (db, members, config, now) => Effect27.tryPromise({
   catch: (cause) => new StoreError({ message: `concept cluster: persist: ${cause}` })
 });
 function conceptClusterHandler(deps) {
-  const run = (payload, ctx) => Effect27.gen(function* () {
+  const run = (payload, ctx) => Effect28.gen(function* () {
     const envelope = payload;
     const model = deps.getModelConfig(envelope.modelKey);
     if (!model) {
-      return yield* Effect27.fail(new JobFailure({
+      return yield* Effect28.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(Effect27.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `concept.cluster: ${error}` })));
+      yield* clusterLeaf(envelope.topicKey, model, deps.config).pipe(Effect28.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `concept.cluster: ${error}` })));
     } else {
-      yield* clusterCorpus(model, deps.config).pipe(Effect27.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `concept.cluster: ${error}` })));
+      yield* clusterCorpus(model, deps.config).pipe(Effect28.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `concept.cluster: ${error}` })));
     }
-    yield* Effect27.logInfo("concepts.clustered").pipe(Effect27.annotateLogs({
+    yield* Effect28.logInfo("concepts.clustered").pipe(Effect28.annotateLogs({
       scope: "@dimple/store",
       event: "concepts.clustered",
       modelKey: envelope.modelKey,
@@ -6735,10 +6757,10 @@ function conceptClusterHandler(deps) {
     }));
     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/dream.ts
-import { Clock as Clock7, Effect as Effect28 } from "effect";
+import { Clock as Clock7, Effect as Effect29 } from "effect";
 import { and as and10, asc as asc7, eq as eq10, gt, inArray as inArray5, isNull as isNull3, sql as sql10 } from "drizzle-orm";
 var dreamStateDefaults = {
   minHours: 24,
@@ -6849,18 +6871,18 @@ var writeDerivedMemoryTx = async (tx, content, sources, now) => {
   }
   return { inserted };
 };
-var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
+var runDream = Effect29.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* Effect28.tryPromise({
+  const stateRows = yield* Effect29.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;
   if (now - lastDreamAt < minHours * 3600000) {
-    yield* Effect28.logDebug("dream.skipped").pipe(Effect28.annotateLogs({ scope: "@dimple/store", event: "dream.skipped", reason: "cooldown" }));
+    yield* Effect29.logDebug("dream.skipped").pipe(Effect29.annotateLogs({ scope: "@dimple/store", event: "dream.skipped", reason: "cooldown" }));
     return {
       skipped: true,
       reason: "cooldown",
@@ -6869,13 +6891,13 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
       superseded: 0
     };
   }
-  const sinceCountRows = yield* Effect28.tryPromise({
+  const sinceCountRows = yield* Effect29.tryPromise({
     try: () => db.select({ count: sql10`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* Effect28.logDebug("dream.skipped").pipe(Effect28.annotateLogs({
+    yield* Effect29.logDebug("dream.skipped").pipe(Effect29.annotateLogs({
       scope: "@dimple/store",
       event: "dream.skipped",
       reason: "insufficient-new-memories",
@@ -6889,7 +6911,7 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
       superseded: 0
     };
   }
-  const pendingRows = yield* Effect28.tryPromise({
+  const pendingRows = yield* Effect29.tryPromise({
     try: () => db.select({
       fromMemoryId: artifactEdges.fromMemoryId,
       toMemoryId: artifactEdges.toMemoryId
@@ -6902,7 +6924,7 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
   };
   for (const row of pendingRows)
     addPair(row.fromMemoryId, row.toMemoryId);
-  const sinceRows = yield* Effect28.tryPromise({
+  const sinceRows = yield* Effect29.tryPromise({
     try: () => db.select({
       id: memories.id,
       logicalKey: memories.logicalKey,
@@ -6913,19 +6935,19 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
   });
   if (sinceRows.length > 0) {
     const sinceIds = sinceRows.map((r) => r.id);
-    const membershipRows = yield* Effect28.tryPromise({
+    const membershipRows = yield* Effect29.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* Effect28.tryPromise({
+      const mateRows = yield* Effect29.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(Effect28.mapError((cause) => new StoreError({ message: `memory.dream: scan vectors: ${cause}` })));
-      const memoryRows = yield* Effect28.tryPromise({
+      const vectorRows = yield* backend.fetchMemoryVectors(memberIds, model).pipe(Effect29.mapError((cause) => new StoreError({ message: `memory.dream: scan vectors: ${cause}` })));
+      const memoryRows = yield* Effect29.tryPromise({
         try: () => db.select({
           id: memories.id,
           logicalKey: memories.logicalKey,
@@ -6982,7 +7004,7 @@ var runDream = Effect28.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* Effect28.tryPromise({
+  const contentRows = endpointIds.length > 0 ? yield* Effect29.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}` })
   }) : [];
@@ -7002,12 +7024,12 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
   }
   let classification = { relations: [], derived: [] };
   if (dreamPairs.length > 0) {
-    classification = yield* classify.classify(dreamPairs, { maxDerived }).pipe(Effect28.mapError((error) => new StoreError({ message: `memory.dream: classify: ${error}` })));
+    classification = yield* classify.classify(dreamPairs, { maxDerived }).pipe(Effect29.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* Effect28.tryPromise({
+  const endpointRows = endpointIdsOf.length > 0 ? yield* Effect29.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}` })
   }) : [];
@@ -7025,7 +7047,7 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
   }
   const acceptedDerived = [];
   for (const derived of classification.derived) {
-    const sourceRows = derived.sources.length > 0 ? yield* Effect28.tryPromise({
+    const sourceRows = derived.sources.length > 0 ? yield* Effect29.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}` })
     }) : [];
@@ -7037,7 +7059,7 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
   }
   let superseded = 0;
   let created = 0;
-  yield* Effect28.tryPromise({
+  yield* Effect29.tryPromise({
     try: () => db.transaction(async (tx) => {
       for (const relation of acceptedRelations) {
         const result = await writeRelationEdgeTx(tx, relation, now);
@@ -7062,7 +7084,7 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
     }),
     catch: (cause) => new StoreError({ message: `memory.dream: persist: ${cause}` })
   });
-  yield* Effect28.logInfo("dream.completed").pipe(Effect28.annotateLogs({
+  yield* Effect29.logInfo("dream.completed").pipe(Effect29.annotateLogs({
     scope: "@dimple/store",
     event: "dream.completed",
     modelKey: model.id,
@@ -7073,24 +7095,24 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
   return { skipped: false, classified: dreamPairs.length, created, superseded };
 });
 function graphDreamHandler(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: `memory.dream: unknown model "${envelope.modelKey}"`
       }));
     }
-    return yield* runDream(model, deps.classify).pipe(Effect28.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `memory.dream: ${error}` })));
+    return yield* runDream(model, deps.classify).pipe(Effect29.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `memory.dream: ${error}` })));
   });
-  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/repair.ts
-import { Clock as Clock8, Effect as Effect29 } from "effect";
+import { Clock as Clock8, Effect as Effect30 } from "effect";
 import { and as and11, eq as eq11, isNotNull as isNotNull2, lt, or as or2, sql as sql11 } from "drizzle-orm";
 var DEFAULT_EXPIRED_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
-var runRepair = (db, includePurgeExpired, expiredGraceMs, now) => Effect29.tryPromise({
+var runRepair = (db, includePurgeExpired, expiredGraceMs, now) => Effect30.tryPromise({
   try: () => db.transaction(async (tx) => {
     let orphanedEdges = 0;
     let staleAnnotations = 0;
@@ -7184,10 +7206,10 @@ var runRepair = (db, includePurgeExpired, expiredGraceMs, now) => Effect29.tryPr
   catch: (cause) => new StoreError({ message: `graph.repair: ${cause}` })
 });
 function graphRepairHandler(deps) {
-  const run = (payload, ctx) => Effect29.gen(function* () {
+  const run = (payload, ctx) => Effect30.gen(function* () {
     const envelope = payload;
     if (!deps.getModelConfig(envelope.modelKey)) {
-      return yield* Effect29.fail(new JobFailure({
+      return yield* Effect30.fail(new JobFailure({
         jobId: ctx.jobId,
         message: `graph.repair: unknown model "${envelope.modelKey}"`
       }));
@@ -7195,8 +7217,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(Effect29.mapError((error) => new JobFailure({ jobId: ctx.jobId, message: `graph.repair: ${error}` })));
-    yield* Effect29.logInfo("repair.completed").pipe(Effect29.annotateLogs({
+    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({
       scope: "@dimple/store",
       event: "repair.completed",
       modelKey: envelope.modelKey,
@@ -7206,7 +7228,7 @@ function graphRepairHandler(deps) {
     }));
     return result;
   });
-  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/models.ts
 import { Schema as Schema24 } from "effect";
@@ -7285,21 +7307,21 @@ var RetrievalLogEntry = Schema24.Struct({
   createdAt: Schema24.Number
 });
 // ../embedder/src/provider.ts
-import { Context as Context10, Schema as Schema25 } from "effect";
+import { Context as Context11, Schema as Schema25 } from "effect";
 
 class EmbeddingError extends Schema25.TaggedError()("EmbeddingProvider.EmbeddingError", { message: Schema25.String, cause: Schema25.optional(Schema25.Defect()) }) {
 }
 
-class Service9 extends Context10.Service()("@dimple/embedder/EmbeddingModelRegistry") {
+class Service10 extends Context11.Service()("@dimple/embedder/EmbeddingModelRegistry") {
 }
 // ../embedder/src/transformers.ts
-import { Config as Config5, Effect as Effect32, Layer as Layer11, Option as Option11, Schema as Schema26 } from "effect";
+import { Config as Config5, Effect as Effect33, Layer as Layer12, Option as Option11, Schema as Schema26 } 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 { Effect as Effect31 } from "effect";
+import { Effect as Effect32 } from "effect";
 
 // ../installer/src/index.ts
 import { existsSync } from "node:fs";
@@ -7390,7 +7412,7 @@ var installOptionalPeers = (packages, opts) => {
   return run;
 };
 // ../embedder/src/auto-install.ts
-var installTransformers = (cwd) => Effect31.tryPromise({
+var installTransformers = (cwd) => Effect32.tryPromise({
   try: () => installOptionalPeers(["@huggingface/transformers"], { cwd, timeoutMs: 300000 }),
   catch: (cause) => 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"
@@ -7506,20 +7528,20 @@ var outputVectors = (result) => {
 };
 var make6 = (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" }));
+      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* installTransformers(process.cwd());
-        return yield* Effect32.tryPromise(importFromDisk).pipe(Effect32.mapError(() => new EmbeddingError({
+        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)"
         })));
       });
@@ -7527,17 +7549,17 @@ var make6 = (options) => {
     if (options.cacheDir)
       transformers.env.cacheDir = options.cacheDir;
     applyWasmOptions(transformers.env, options.wasm);
-    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,
       session_options: buildSessionOptions(options.sessionOptions ?? {})
-    })).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.tryPromise({
+    const result = yield* Effect33.tryPromise({
       try: () => p(texts, {
         pooling: options.pooling ?? defaults2.pooling,
         normalize: options.normalize ?? defaults2.normalize
@@ -7552,7 +7574,7 @@ var make6 = (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,
@@ -7560,9 +7582,9 @@ var make6 = (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.tryPromise({
+    const result = yield* Effect33.tryPromise({
       try: () => p(text4, {
         pooling: options.pooling ?? defaults2.pooling,
         normalize: options.normalize ?? defaults2.normalize
@@ -7590,14 +7612,14 @@ var makeTransformersModel = (options = {}) => {
   };
 };
 // ../embedder/src/registry.ts
-import { Effect as Effect33, Layer as Layer12 } from "effect";
+import { Effect as Effect34, Layer as Layer13 } 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({
@@ -7628,8 +7650,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}` })
     });
@@ -7642,7 +7664,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];
   });
@@ -7656,7 +7678,7 @@ var makeHostedEmbeddingModel = (options) => {
 };
 
 // ../retriever/src/hybrid.ts
-import { Clock as Clock9, Context as Context11, Effect as Effect35, Layer as Layer13, Schema as Schema27 } from "effect";
+import { Clock as Clock9, Context as Context12, Effect as Effect36, Layer as Layer14, Schema as Schema27 } from "effect";
 
 // ../retriever/src/rrf.ts
 function fuse(denseRanks, fts5Ranks, k, limit) {
@@ -7699,17 +7721,17 @@ class HybridError extends Schema27.TaggedError()("HybridRetrieval.HybridError",
 }) {
 }
 
-class Service10 extends Context11.Service()("@dimple/retriever/HybridRetrieval") {
+class Service11 extends Context12.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 layer12 = (options) => Layer14.effect(Service11, Effect36.gen(function* () {
   const store = yield* Service5;
-  const registry = yield* Service9;
+  const registry = yield* Service10;
   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;
@@ -7812,7 +7834,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,
@@ -7822,16 +7844,16 @@ var layer11 = (options) => Layer13.effect(Service10, Effect35.gen(function* () {
     }));
     return results;
   });
-  return Service10.of({ hybrid });
+  return Service11.of({ hybrid });
 }));
-var hybridRetrievalLayer = layer11();
+var hybridRetrievalLayer = layer12();
 var configured8 = (options, deps) => make({
   name: "HybridRetrieval",
-  layer: options === undefined ? hybridRetrievalLayer : Layer13.suspend(() => layer11(options)),
+  layer: options === undefined ? hybridRetrievalLayer : Layer14.suspend(() => layer12(options)),
   deps
 });
 // ../llm/src/llm.ts
-import { Cause as Cause4, Effect as Effect36, Option as Option12, Schema as Schema28 } from "effect";
+import { Cause as Cause4, Effect as Effect37, Option as Option12, Schema as Schema28 } from "effect";
 import {
   generateText as generateTextCall,
   NoSuchToolError,
@@ -7879,9 +7901,9 @@ var makeLLM = (model, defaults3 = {}) => {
       ...reasoningEffort !== undefined ? { providerOptions: { openaiCompatible: { reasoningEffort } } } : undefined
     };
   };
-  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,
@@ -7890,16 +7912,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({
@@ -7942,7 +7964,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
@@ -7962,7 +7984,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);
@@ -8009,7 +8031,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({
@@ -8039,11 +8061,11 @@ Judging for model: ${deps.modelId}`;
   return { classify };
 };
 // ../llm/src/service.ts
-import { Config as Config6, Context as Context12, Effect as Effect38, Layer as Layer14 } from "effect";
-class Service11 extends Context12.Service()("@dimple/LLM") {
+import { Config as Config6, Context as Context13, Effect as Effect39, Layer as Layer15 } from "effect";
+class Service12 extends Context13.Service()("@dimple/LLM") {
 }
 // ../core/src/layer.ts
-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 } : undefined,
@@ -8054,40 +8076,40 @@ var embedderFromConfig = (model) => model.provider === "transformers" ? Effect39
   ...model.autoInstall !== undefined ? { autoInstall: model.autoInstall } : undefined,
   ...model.sessionOptions !== undefined ? { sessionOptions: model.sessionOptions } : undefined,
   ...model.wasm !== undefined ? { wasm: model.wasm } : undefined
-})) : 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 } : undefined,
   ...model.baseURL !== undefined ? { baseURL: model.baseURL } : undefined
-})) : Effect39.fail(new EmbeddingError({ message: `Unknown provider: ${model.provider}` }));
-var layer13 = (options) => {
+})) : Effect40.fail(new EmbeddingError({ message: `Unknown provider: ${model.provider}` }));
+var layer14 = (options) => {
   const topicConfig = Schema29.decodeUnknownSync(TopicConfig)(options.topics?.config ?? {});
   const graphConfig = Schema29.decodeUnknownSync(exports_graph.GraphConfig)(options.graph ?? {});
   const models2 = new Map(options.models.map((m) => [m.id, m]));
   const defaultModel = models2.get(options.defaultModelId);
   const loggingConfig = options.logging ?? silentConfig;
   const getModelConfig = (key) => models2.get(key);
-  const storeWithSeams = Layer15.unwrap(Effect39.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 storeWithSeams = Layer16.unwrap(Effect40.gen(function* () {
+    const rt = yield* Service8;
+    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 = [];
-    const flushAudit = Effect39.gen(function* () {
+    const flushAudit = Effect40.gen(function* () {
       if (auditBuffer.length === 0)
         return;
       const rows = auditBuffer.splice(0, auditBuffer.length);
-      yield* rt.enqueue(AuditWrite, { rows }).pipe(Effect39.asVoid);
+      yield* rt.enqueue(AuditWrite, { rows }).pipe(Effect40.asVoid);
     });
-    const enqueueAudit = (row) => Effect39.gen(function* () {
+    const enqueueAudit = (row) => Effect40.gen(function* () {
       auditBuffer.push(row);
       if (auditBuffer.length >= 50) {
         yield* flushAudit;
       }
     });
-    yield* flushAudit.pipe(Effect39.catchCause((cause) => Effect39.logWarning("audit flush failed", cause)), Effect39.repeat(Schedule2.spaced(1000)), Effect39.forkScoped);
-    return layer8(options.storeUrl, {
+    yield* flushAudit.pipe(Effect40.catchCause((cause) => Effect40.logWarning("audit flush failed", cause)), Effect40.repeat(Schedule2.spaced(1000)), Effect40.forkScoped);
+    return layer9(options.storeUrl, {
       ...options.defaultTtlSecs !== undefined ? { defaultTtlSecs: options.defaultTtlSecs } : undefined,
       ...options.migrationFolder !== undefined ? { migrationFolder: options.migrationFolder } : undefined,
       releaseClient: true,
@@ -8105,48 +8127,49 @@ var layer13 = (options) => {
       ...options.audit !== false ? { enqueueAudit } : undefined
     });
   }));
-  const embedderRegistry = Layer15.effect(Service9, Effect39.sync(() => Service9.of({
+  const embedderRegistry = Layer16.effect(Service10, Effect40.sync(() => Service10.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 = Layer16.effect(Service, Effect40.gen(function* () {
     if (defaultModel === undefined) {
       return yield* new CoreConfigError({
         message: `@dimple/core: unknown defaultModelId "${options.defaultModelId}"`
       });
     }
     const store2 = yield* Service5;
-    const rt = yield* Service7;
-    const registry = yield* Service8;
+    const rt = yield* Service8;
+    const queueStats = yield* Service7;
+    const registry = yield* Service9;
     const backend = yield* Service2;
-    const hybrid = yield* Service10;
+    const hybrid = yield* Service11;
     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) => store2.get(memoryId).pipe(Effect39.map((m) => m.content)),
+      embedOne: (text4, model) => options.embedderFor(model).pipe(Effect40.flatMap((m) => m.embedSingle(text4))),
+      getMemoryContent: (memoryId) => store2.get(memoryId).pipe(Effect40.map((m) => m.content)),
       config: topicConfig,
       backend
     }));
     yield* register("memory.embed.batch", exports_topics.memoryEmbedBatchHandler({
       getModelConfig,
-      embedOne: (text4, model) => options.embedderFor(model).pipe(Effect39.flatMap((m) => m.embedSingle(text4))),
-      getMemoryContent: (memoryId) => store2.get(memoryId).pipe(Effect39.map((m) => m.content)),
+      embedOne: (text4, model) => options.embedderFor(model).pipe(Effect40.flatMap((m) => m.embedSingle(text4))),
+      getMemoryContent: (memoryId) => store2.get(memoryId).pipe(Effect40.map((m) => m.content)),
       config: topicConfig,
       backend
     }));
@@ -8161,12 +8184,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"
         }));
@@ -8181,6 +8204,7 @@ var layer13 = (options) => {
       store: store2,
       hybrid,
       runtime: rt,
+      queueStats,
       registry,
       models: models2,
       defaultModel,
@@ -8210,7 +8234,7 @@ var layer13 = (options) => {
   });
   return compile(group([jobStack, jobRegistry, store, embedder, retrieval, workers, core]));
 };
-var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
+var layerConfig7 = (options) => Layer16.unwrap(Effect40.gen(function* () {
   const cfg = yield* Service4;
   const embedding = cfg.config.embedding;
   if (embedding === undefined || embedding.models.length === 0) {
@@ -8232,7 +8256,7 @@ var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
       ...sessionOptions !== undefined ? { sessionOptions } : undefined
     };
   });
-  return layer13({
+  return layer14({
     storeUrl: cfg.config.storeUrl,
     ...cfg.config.defaultK !== undefined ? { defaultK: cfg.config.defaultK } : undefined,
     ...cfg.config.defaultLimit !== undefined ? { defaultLimit: cfg.config.defaultLimit } : undefined,
@@ -8374,10 +8398,10 @@ var remapError = (cause) => {
 };
 
 // src/make.ts
-import { Effect as Effect50, Exit as Exit8, Layer as Layer26, ManagedRuntime, Scope as Scope5 } from "effect";
+import { Effect as Effect51, Exit as Exit8, Layer as Layer27, ManagedRuntime, Scope as Scope5 } from "effect";
 
 // ../extractor/src/code-extractor.ts
-import { Context as Context13, Effect as Effect40, Layer as Layer16 } from "effect";
+import { Context as Context14, Effect as Effect41, Layer as Layer17 } from "effect";
 
 // ../extractor/src/models/extraction.ts
 import { Schema as Schema31 } from "effect";
@@ -8821,11 +8845,11 @@ function extract3(filePath, tree2) {
 }
 
 // ../extractor/src/code-extractor.ts
-class Service12 extends Context13.Service()("@dimple/extractor/CodeExtractor") {
+class Service13 extends Context14.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 layer15 = Layer17.effect(Service13, Effect41.succeed(Service13.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 })
     });
@@ -8841,10 +8865,10 @@ var layer14 = Layer16.effect(Service12, Effect40.succeed(Service12.of({
     });
   })
 })));
-var configured10 = () => make({ name: "CodeExtractor", layer: layer14, deps: [] });
+var configured10 = () => make({ name: "CodeExtractor", layer: layer15, deps: [] });
 var node6 = configured10();
 // ../extractor/src/content-handler.ts
-import { Context as Context14, Layer as Layer17, Schema as Schema32 } from "effect";
+import { Context as Context15, Layer as Layer18, Schema as Schema32 } from "effect";
 
 class ContentError extends Schema32.TaggedError()("Content.ContentError", {
   contentType: Schema32.String,
@@ -8852,22 +8876,22 @@ class ContentError extends Schema32.TaggedError()("Content.ContentError", {
 }) {
 }
 
-class Service13 extends Context14.Service()("@dimple/extractor/ContentHandler") {
+class Service14 extends Context15.Service()("@dimple/extractor/ContentHandler") {
 }
-var layer15 = Layer17.succeed(Service13, Service13.of({
+var layer16 = Layer18.succeed(Service14, Service14.of({
   contentType: "text/plain",
   renderText: (content) => content,
   extractText: (content) => content
 }));
 // ../parser/src/code-parser.ts
-import { Context as Context20, Effect as Effect47, Layer as Layer24 } from "effect";
+import { Context as Context21, Effect as Effect48, Layer as Layer25 } from "effect";
 import { Parser as Parser2 } from "web-tree-sitter";
 
 // ../parser/src/language-store.ts
-import { Cache, Context as Context19, Effect as Effect46, Layer as Layer23 } from "effect";
+import { Cache, Context as Context20, Effect as Effect47, Layer as Layer24 } from "effect";
 
 // ../wasm/src/wasm-registry.ts
-import { Context as Context15, Effect as Effect41, Layer as Layer18, Schema as Schema36 } from "effect";
+import { Context as Context16, Effect as Effect42, Layer as Layer19, Schema as Schema36 } from "effect";
 
 // ../shared/src/errors/wasm.ts
 import { Schema as Schema33 } from "effect";
@@ -8967,9 +8991,9 @@ for (const grammar of grammars.grammars) {
   registryMap.set(grammar.lang, grammar);
 }
 
-class Service14 extends Context15.Service()("@dimple/wasm/TreeSitterRegistry") {
-  static layer = Layer18.succeed(Service14, Service14.of({
-    resolve: Effect41.fn("TreeSitterRegistry.resolve")(function* (lang) {
+class Service15 extends Context16.Service()("@dimple/wasm/TreeSitterRegistry") {
+  static layer = Layer19.succeed(Service15, Service15.of({
+    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}` });
@@ -8979,11 +9003,11 @@ class Service14 extends Context15.Service()("@dimple/wasm/TreeSitterRegistry") {
   }));
 }
 // ../wasm/src/wasm-downloader.ts
-import { Context as Context16, Effect as Effect42, Layer as Layer19 } from "effect";
-class Service15 extends Context16.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({
+import { Context as Context17, Effect as Effect43, Layer as Layer20 } from "effect";
+class Service16 extends Context17.Service()("@dimple/wasm/WasmDownloader") {
+  static layer = Layer20.effect(Service16, Effect43.succeed(Service16.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}`,
@@ -8997,7 +9021,7 @@ class Service15 extends Context16.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}`,
@@ -9010,7 +9034,7 @@ class Service15 extends Context16.Service()("@dimple/wasm/WasmDownloader") {
   })));
 }
 // ../wasm/src/wasm-cache.ts
-import { Context as Context17, Effect as Effect43, Layer as Layer20 } from "effect";
+import { Context as Context18, Effect as Effect44, Layer as Layer21 } from "effect";
 import { existsSync as existsSync3, mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { join as join3 } from "node:path";
 
@@ -9105,37 +9129,37 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
 // ../wasm/src/wasm-cache.ts
 var paths = envPaths("dimple");
 
-class Service16 extends Context17.Service()("@dimple/wasm/WasmCache") {
+class Service17 extends Context18.Service()("@dimple/wasm/WasmCache") {
 }
-var layer16 = Layer20.effect(Service16, Effect43.succeed(Service16.of({
-  ensure: Effect43.fn("WasmCache.ensure")(function* (lang, version, download) {
+var layer17 = Layer21.effect(Service17, Effect44.succeed(Service17.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 })
       });
@@ -9149,72 +9173,72 @@ var layer16 = Layer20.effect(Service16, Effect43.succeed(Service16.of({
   })
 })));
 // ../wasm/src/grammar-store.ts
-import { Context as Context18, Effect as Effect44, Layer as Layer21 } from "effect";
-class Service17 extends Context18.Service()("@dimple/wasm/GrammarStore") {
+import { Context as Context19, Effect as Effect45, Layer as Layer22 } from "effect";
+class Service18 extends Context19.Service()("@dimple/wasm/GrammarStore") {
 }
-var layer17 = Layer21.effect(Service17, Effect44.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({
+var layer18 = Layer22.effect(Service18, Effect45.gen(function* () {
+  const registry = yield* Service15;
+  const downloader = yield* Service16;
+  const cache = yield* Service17;
+  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
     })));
     return path2;
   });
-  return Service17.of({ ensure });
+  return Service18.of({ ensure });
 }));
-var allLive = layer17.pipe(Layer21.provideMerge(Layer21.mergeAll(Service14.layer, Service15.layer, layer16)));
+var allLive = layer18.pipe(Layer22.provideMerge(Layer22.mergeAll(Service15.layer, Service16.layer, layer17)));
 var configured11 = () => make({ name: "GrammarStore", layer: allLive, deps: [] });
 var node7 = configured11();
 // ../parser/src/language-store.ts
 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 Layer23 } from "effect";
 import { Parser } from "web-tree-sitter";
-var layer18 = Layer22.effectDiscard(Effect45.tryPromise({
+var layer19 = Layer23.effectDiscard(Effect46.tryPromise({
   try: () => Parser.init(),
   catch: (cause) => new ParserInitError({ message: "Failed to initialize tree sitter", cause })
 }));
 
 // ../parser/src/language-store.ts
-class Service18 extends Context19.Service()("@dimple/parser/LanguageStore") {
+class Service19 extends Context20.Service()("@dimple/parser/LanguageStore") {
 }
-var layer19 = Layer23.effect(Service18, Effect46.gen(function* () {
-  const grammarStore = yield* Service17;
+var layer20 = Layer24.effect(Service19, Effect47.gen(function* () {
+  const grammarStore = yield* Service18;
   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 })
       });
     })
   });
   const get = (lang) => Cache.get(cache, resolveLang(lang));
-  return Service18.of({ get });
-})).pipe(Layer23.provide(Layer23.mergeAll(allLive, layer18)));
+  return Service19.of({ get });
+})).pipe(Layer24.provide(Layer24.mergeAll(allLive, layer19)));
 
 // ../parser/src/models/treeHandle.ts
 import { Schema as Schema37 } from "effect";
@@ -9227,13 +9251,13 @@ var TreeHandle = Schema37.Struct({
 });
 
 // ../parser/src/code-parser.ts
-class Service19 extends Context20.Service()("@dimple/parser/CodeParser") {
+class Service20 extends Context21.Service()("@dimple/parser/CodeParser") {
 }
-var layer20 = Layer24.effect(Service19, Effect47.gen(function* () {
-  const languageStore = yield* Service18;
+var layer21 = Layer25.effect(Service20, Effect48.gen(function* () {
+  const languageStore = yield* Service19;
   const parserByLanguage = new Map;
-  const parse2 = Effect47.fn("CodeParser.parse")(function* (request) {
-    const language = yield* languageStore.get(request.lang).pipe(Effect47.mapError((cause) => new ParseError({
+  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
     })));
@@ -9249,9 +9273,9 @@ var layer20 = Layer24.effect(Service19, Effect47.gen(function* () {
     }
     return TreeHandle.make({ tree: tree2, lang: request.lang, source: request.source });
   });
-  return Service19.of({ parse: parse2 });
-})).pipe(Layer24.provide(layer19));
-var configured12 = () => make({ name: "CodeParser", layer: layer20, deps: [] });
+  return Service20.of({ parse: parse2 });
+})).pipe(Layer25.provide(layer20));
+var configured12 = () => make({ name: "CodeParser", layer: layer21, deps: [] });
 var node8 = configured12();
 // ../parser/src/models/parseRequest.ts
 import { Schema as Schema38 } from "effect";
@@ -9260,15 +9284,15 @@ var ParseRequest = Schema38.Struct({
   source: Schema38.String
 });
 // src/config.ts
-import { Effect as Effect48, Layer as Layer25, Option as Option14, Schema as Schema39 } from "effect";
+import { Effect as Effect49, Layer as Layer26, Option as Option14, Schema as Schema39 } from "effect";
 var isString = (value2) => Option14.isSome(Schema39.decodeUnknownOption(Schema39.String)(value2));
-var resolveConfigInput = Effect48.fn("Sdk.resolveConfigInput")(function* (input) {
-  return yield* (isString(input) ? loadConfigFromFile(input) : loadConfig(input)).pipe(Effect48.mapError((error) => new ConfigError({ message: error.message })));
+var resolveConfigInput = Effect49.fn("Sdk.resolveConfigInput")(function* (input) {
+  return yield* (isString(input) ? 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) => Layer26.effect(Service4, resolveConfigInput(input).pipe(Effect49.map((config) => Service4.of({ config }))));
 
 // src/dimple.ts
-import { Cause as Cause5, Effect as Effect49, Exit as Exit7, Option as Option15, Schema as Schema40 } from "effect";
+import { Cause as Cause5, Effect as Effect50, Exit as Exit7, Option as Option15, Schema as Schema40 } from "effect";
 
 // src/indexer.ts
 import { execFileSync } from "node:child_process";
@@ -9517,7 +9541,7 @@ var makeFacade = (state, reload, dispose) => {
     }
     return;
   };
-  const runQuery = (text4, options) => run(Effect49.gen(function* () {
+  const runQuery = (text4, options) => run(Effect50.gen(function* () {
     if (!asString(text4)) {
       return yield* new InputError({ message: "query: text must be a string" });
     }
@@ -9530,7 +9554,7 @@ var makeFacade = (state, reload, dispose) => {
     let rows = yield* core().hybrid.hybrid(text4, {
       ...rest,
       ...capLimit !== undefined ? { limit: capLimit } : undefined
-    }).pipe(Effect49.map((r) => [...r]));
+    }).pipe(Effect50.map((r) => [...r]));
     let truncated = false;
     if (budget?.maxChars !== undefined && budget.maxChars > 0) {
       let used = 0;
@@ -9617,7 +9641,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);
@@ -9627,8 +9651,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) {
@@ -9693,7 +9717,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;
@@ -9713,13 +9737,13 @@ 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(Effect49.gen(function* () {
+    writeMany: (units, options) => run(Effect50.gen(function* () {
       if (!Array.isArray(units)) {
         return yield* new InputError({ message: "writeMany: units must be an array" });
       }
@@ -9739,7 +9763,7 @@ var makeFacade = (state, reload, dispose) => {
           vectors.push(...vs);
         }
         yield* core().store.updateEmbeddingMany(mems.map((mem, i) => ({ id: mem.id, embedding: [...vectors[i]] })), core().defaultModel.id);
-        return yield* Effect49.forEach(mems, (mem) => core().store.get(mem.id), {
+        return yield* Effect50.forEach(mems, (mem) => core().store.get(mem.id), {
           discard: false
         });
       }
@@ -9747,8 +9771,8 @@ var makeFacade = (state, reload, dispose) => {
     })),
     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;
@@ -9760,7 +9784,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)}`
@@ -9793,8 +9817,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)}` })
           });
@@ -9873,7 +9897,7 @@ var makeFacade = (state, reload, dispose) => {
             unitIds.set(key, id);
             freshIds.push(id);
           };
-          const upsertAll = (candidates2) => Effect49.gen(function* () {
+          const upsertAll = (candidates2) => Effect50.gen(function* () {
             const ids = [];
             for (const spec of candidates2) {
               const outcome = yield* upsertUnit(spec.input, embedUnits);
@@ -9885,7 +9909,7 @@ var makeFacade = (state, reload, dispose) => {
           if (deferEmbed) {
             const fresh = [];
             for (const spec of specs) {
-              const existing = yield* core().store.getByKey(spec.key, namespace ?? "default").pipe(Effect49.catchTag("Store.NotFound", () => Effect49.succeed(undefined)));
+              const existing = yield* core().store.getByKey(spec.key, namespace ?? "default").pipe(Effect50.catchTag("Store.NotFound", () => Effect50.succeed(undefined)));
               if (existing === undefined) {
                 fresh.push(spec);
                 continue;
@@ -9913,7 +9937,7 @@ var makeFacade = (state, reload, dispose) => {
           } else {
             const fresh = [];
             for (const spec of specs) {
-              const existing = yield* core().store.getByKey(spec.key, namespace ?? "default").pipe(Effect49.catchTag("Store.NotFound", () => Effect49.succeed(undefined)));
+              const existing = yield* core().store.getByKey(spec.key, namespace ?? "default").pipe(Effect50.catchTag("Store.NotFound", () => Effect50.succeed(undefined)));
               if (existing === undefined) {
                 fresh.push(spec);
                 continue;
@@ -9981,14 +10005,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,
@@ -9998,10 +10022,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" }));
       }
       const EMBED_BATCH = 512;
       if (deferEmbed) {
@@ -10025,21 +10049,27 @@ var makeFacade = (state, reload, dispose) => {
         ...deferEmbed ? { pendingEmbeddings: pendingEmbedIds.length } : undefined
       };
     })),
-    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) => !asNumber(v) || !Number.isFinite(v))) {
         return yield* new InputError({
           message: "updateEmbedding: embedding must be a non-empty array of finite numbers"
         });
       }
       const key = modelKey ?? core().defaultModel.id;
+      const model = core().models.get(key);
+      if (model !== undefined && embedding.length !== model.dimensions) {
+        return yield* new InputError({
+          message: `updateEmbedding: model "${key}" expects ${model.dimensions}-dimensional vectors, got ${embedding.length}`
+        });
+      }
       const memory = yield* resolveMemory(id);
       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 } : undefined,
       ...options?.maxDepth !== undefined ? { maxDepth: options.maxDepth } : undefined,
@@ -10047,15 +10077,19 @@ var makeFacade = (state, reload, dispose) => {
       ...options?.maxTotal !== undefined ? { maxTotal: options.maxTotal } : undefined,
       ...options?.includePending !== undefined ? { includePending: options.includePending } : undefined
     })),
-    health: (modelKey) => run(core().store.topicHealth(modelKey)),
+    health: (modelKey) => run(Effect50.gen(function* () {
+      const topics3 = yield* core().store.topicHealth(modelKey);
+      const jobs = yield* core().queueStats.pending();
+      return { ...topics3, jobs };
+    })),
     graph: {
-      addEdge: (input) => run(Effect49.gen(function* () {
+      addEdge: (input) => run(Effect50.gen(function* () {
         const invalid = validateAddEdgeInput(input);
         if (invalid !== undefined)
           return yield* invalid;
         return yield* core().store.addEdge(input);
       })),
-      candidates: () => run(core().store.graphCandidates()),
+      candidates: (options) => run(core().store.graphCandidates(options)),
       coverage: (modelKey) => run(core().store.graphCoverage(modelKey)),
       confirm: (id) => run(core().store.confirmEdge(id)),
       reject: (id) => run(core().store.rejectEdge(id)),
@@ -10091,28 +10125,28 @@ 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 coreNode = make({
       name: "SdkCore",
       deps: [],
-      layer: "core" in options ? layer13(options.core) : layerConfig7(options.migrationFolder !== undefined ? { migrationFolder: options.migrationFolder } : {}).pipe(Layer26.provide(configLayerFromInput(options.config)))
+      layer: "core" in options ? layer14(options.core) : layerConfig7(options.migrationFolder !== undefined ? { migrationFolder: options.migrationFolder } : {}).pipe(Layer27.provide(configLayerFromInput(options.config)))
     });
-    const appLayer = compile(group([coreNode, node8, node6])).pipe(Layer26.provide(Layer26.succeed(Scope5.Scope, scope)));
+    const appLayer = compile(group([coreNode, node8, node6])).pipe(Layer27.provide(Layer27.succeed(Scope5.Scope, scope)));
     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, Service20, Service13]));
     return {
       runPromise: (effect) => rt.runPromise(effect),
       disposeEffect: rt.disposeEffect,
       core,
       parser,
       extractor,
-      dispose: () => Effect50.runPromise(Scope5.close(scope, Exit8.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, Exit8.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);
@@ -10123,7 +10157,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,
@@ -10145,7 +10179,7 @@ var makeDimple = async (options) => {
       }
       const stack = current;
       inflight2 += 1;
-      return stack.runPromise(effect.pipe(Effect50.mapError(remapError))).catch((cause) => {
+      return stack.runPromise(effect.pipe(Effect51.mapError(remapError))).catch((cause) => {
         return Promise.reject(remapError(cause));
       }).finally(() => {
         inflight2 -= 1;
@@ -10201,7 +10235,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,
@@ -10224,10 +10258,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 {