@relayfx/sdk 0.0.24 → 0.0.26

package/dist/index.js

@@ -13,6 +13,7 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __require = import.meta.require;
 
 // src/adapter-outbox.ts
 var exports_adapter_outbox = {};
@@ -893,7 +894,6 @@ __export(exports_database_service, {
 });
 import * as MysqlClient from "@effect/sql-mysql2/MysqlClient";
 import * as PgClient from "@effect/sql-pg/PgClient";
-import * as SqliteClient from "@effect/sql-sqlite-bun/SqliteClient";
 import * as PgDrizzle from "drizzle-orm/effect-postgres";
 import { sql } from "drizzle-orm";
 import { Config, Context, DateTime, Effect, Layer, Redacted, Schema as Schema12 } from "effect";
@@ -941,9 +941,9 @@ var MysqlClientLive = MysqlClient.layerConfig({
   url: Config.redacted("DATABASE_URL").pipe(Config.withDefault(Redacted.make("mysql://relay:relay@localhost:5546/relay"))),
   maxConnections: Config.int("RELAY_SQL_MAX_CONNECTIONS").pipe(Config.withDefault(8))
 });
-var SqliteClientLive = SqliteClient.layerConfig({
+var SqliteClientLive = Layer.unwrap(Effect.promise(() => import("@effect/sql-sqlite-bun/SqliteClient")).pipe(Effect.map((SqliteClient) => SqliteClient.layerConfig({
   filename: Config.string("RELAY_SQLITE_FILE").pipe(Config.withDefault("relay.sqlite"))
-});
+}))));
 var timestampParam = (client, millis) => client.onDialectOrElse({
   sqlite: () => millis,
   orElse: () => toPgDate(millis)
@@ -1539,10 +1539,11 @@ __export(exports_agent_chat_repository, {
   layer: () => layer4,
   get: () => get,
   Service: () => Service4,
+  AgentChatRow: () => AgentChatRow,
   AgentChatRepositoryError: () => AgentChatRepositoryError
 });
-import { eq as eq3 } from "drizzle-orm";
 import { Context as Context4, Effect as Effect4, Layer as Layer4, Schema as Schema14 } from "effect";
+import * as SqlClient3 from "effect/unstable/sql/SqlClient";
 class AgentChatRepositoryError extends Schema14.TaggedErrorClass()("AgentChatRepositoryError", {
   message: Schema14.String
 }) {
@@ -1550,35 +1551,58 @@ class AgentChatRepositoryError extends Schema14.TaggedErrorClass()("AgentChatRep
 
 class Service4 extends Context4.Service()("@relayfx/store-sql/AgentChatRepository") {
 }
+var AgentChatRow = Schema14.Struct({
+  execution_id: Schema14.String,
+  export_json: Schema14.Unknown,
+  updated_at: Schema14.Union([Schema14.Date, Schema14.String, Schema14.Number])
+}).annotate({ identifier: "Relay.AgentChat.Row" });
 var toRecord = (row) => ({
-  executionId: row.executionId,
-  exportData: row.exportJson,
-  updatedAt: fromPgDate(row.updatedAt)
+  executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
+  exportData: decodeJson(row.export_json),
+  updatedAt: fromDbTimestamp(row.updated_at)
 });
-var mapDatabaseError2 = (effect) => effect.pipe(Effect4.mapError((error) => new AgentChatRepositoryError({ message: String(error) })));
+var toRepositoryError = (error) => new AgentChatRepositoryError({ message: String(error) });
+var decodeRow = (row) => Schema14.decodeUnknownEffect(AgentChatRow)(row).pipe(Effect4.mapError(toRepositoryError));
 var layer4 = Layer4.effect(Service4, Effect4.gen(function* () {
-  const db = yield* Service;
+  const sql4 = yield* SqlClient3.SqlClient;
+  const selectByKey = (tenantId2, executionId) => sql4`
+      SELECT execution_id, export_json, updated_at
+      FROM relay_agent_chats
+      WHERE tenant_id = ${tenantId2} AND execution_id = ${executionId}
+    `;
+  const upsert2 = sql4.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql4.withTransaction(Effect4.gen(function* () {
+      yield* sql4`
+              INSERT INTO relay_agent_chats (tenant_id, execution_id, export_json, updated_at)
+              VALUES (${tenantId2}, ${input.executionId}, ${encodeJson(input.exportData)}, ${timestampParam(sql4, input.updatedAt)})
+              ON DUPLICATE KEY UPDATE
+                export_json = VALUES(export_json),
+                updated_at = VALUES(updated_at)
+            `;
+      return yield* selectByKey(tenantId2, input.executionId);
+    })),
+    orElse: () => (tenantId2, input) => sql4`
+        INSERT INTO relay_agent_chats (tenant_id, execution_id, export_json, updated_at)
+        VALUES (${tenantId2}, ${input.executionId}, ${encodeJson(input.exportData)}, ${timestampParam(sql4, input.updatedAt)})
+        ON CONFLICT (tenant_id, execution_id) DO UPDATE SET
+          export_json = excluded.export_json,
+          updated_at = excluded.updated_at
+        RETURNING execution_id, export_json, updated_at
+      `
+  });
   const save = Effect4.fn("AgentChatRepository.save")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError2(db.insert(relayAgentChats).values({
-      tenantId: tenantId2,
-      executionId: input.executionId,
-      exportJson: input.exportData,
-      updatedAt: toPgDate(input.updatedAt)
-    }).onConflictDoUpdate({
-      target: [relayAgentChats.tenantId, relayAgentChats.executionId],
-      set: { exportJson: input.exportData, updatedAt: toPgDate(input.updatedAt) }
-    }).returning());
+    const rows = yield* upsert2(tenantId2, input).pipe(Effect4.mapError(toRepositoryError));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect4.fail(new AgentChatRepositoryError({ message: "Agent chat upsert returned no row" }));
     }
-    return toRecord(row);
+    return toRecord(yield* decodeRow(row));
   });
   const get = Effect4.fn("AgentChatRepository.get")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError2(db.select().from(relayAgentChats).where(predicate(tenantId2, relayAgentChats.tenantId, eq3(relayAgentChats.executionId, executionId))).limit(1));
-    return rows[0] === undefined ? undefined : toRecord(rows[0]);
+    const rows = yield* selectByKey(tenantId2, executionId).pipe(Effect4.mapError(toRepositoryError));
+    return rows[0] === undefined ? undefined : toRecord(yield* decodeRow(rows[0]));
   });
   return Service4.of({ save, get });
 }));
@@ -1622,7 +1646,7 @@ __export(exports_agent_definition_repository, {
   Service: () => Service5,
   AgentDefinitionRepositoryError: () => AgentDefinitionRepositoryError
 });
-import { asc as asc2, desc, eq as eq4, sql as sql4 } from "drizzle-orm";
+import { asc as asc2, desc, eq as eq3, sql as sql4 } from "drizzle-orm";
 import { Context as Context5, Effect as Effect5, Layer as Layer5, Schema as Schema15 } from "effect";
 class AgentDefinitionRepositoryError extends Schema15.TaggedErrorClass()("AgentDefinitionRepositoryError", {
   message: Schema15.String
@@ -1669,14 +1693,14 @@ var compareByCreatedAtDesc = (left, right) => {
   const createdAt = right.createdAt - left.createdAt;
   return createdAt === 0 ? left.id.localeCompare(right.id) : createdAt;
 };
-var mapDatabaseError3 = (effect) => effect.pipe(Effect5.mapError((error) => new AgentDefinitionRepositoryError({ message: String(error) })));
+var mapDatabaseError2 = (effect) => effect.pipe(Effect5.mapError((error) => new AgentDefinitionRepositoryError({ message: String(error) })));
 var mapPutError = (effect) => effect.pipe(Effect5.mapError((error) => error instanceof AgentDefinitionRepositoryError ? error : new AgentDefinitionRepositoryError({ message: String(error) })));
 var layer5 = Layer5.effect(Service5, Effect5.gen(function* () {
   const db = yield* Service;
   const put = Effect5.fn("AgentDefinitionRepository.put")(function* (input) {
     const tenantId2 = yield* current;
     return yield* mapPutError(db.transaction((tx) => Effect5.gen(function* () {
-      const existingRows = yield* tx.select().from(relayAgentDefinitions).where(predicate(tenantId2, relayAgentDefinitions.tenantId, eq4(relayAgentDefinitions.id, input.id))).for("update").limit(1);
+      const existingRows = yield* tx.select().from(relayAgentDefinitions).where(predicate(tenantId2, relayAgentDefinitions.tenantId, eq3(relayAgentDefinitions.id, input.id))).for("update").limit(1);
       const existing = existingRows[0];
       if (existing !== undefined && sameDefinitionContent(existing.definitionJson, input.definition)) {
         return toRecord2(existing);
@@ -1696,7 +1720,7 @@ var layer5 = Layer5.effect(Service5, Effect5.gen(function* () {
         definitionJson: input.definition,
         toolInputSchemaDigestsJson: input.toolInputSchemaDigests ?? {},
         updatedAt: toPgDate(input.now)
-      }).where(predicate(tenantId2, relayAgentDefinitions.tenantId, eq4(relayAgentDefinitions.id, input.id))).returning();
+      }).where(predicate(tenantId2, relayAgentDefinitions.tenantId, eq3(relayAgentDefinitions.id, input.id))).returning();
       const row = rows[0];
       if (row === undefined) {
         return yield* Effect5.fail(new AgentDefinitionRepositoryError({ message: "Agent definition put returned no row" }));
@@ -1718,22 +1742,22 @@ var layer5 = Layer5.effect(Service5, Effect5.gen(function* () {
   });
   const get2 = Effect5.fn("AgentDefinitionRepository.get")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError3(db.select().from(relayAgentDefinitions).where(predicate(tenantId2, relayAgentDefinitions.tenantId, eq4(relayAgentDefinitions.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError2(db.select().from(relayAgentDefinitions).where(predicate(tenantId2, relayAgentDefinitions.tenantId, eq3(relayAgentDefinitions.id, id2))).limit(1));
     return rows[0] === undefined ? undefined : toRecord2(rows[0]);
   });
   const getRevision = Effect5.fn("AgentDefinitionRepository.getRevision")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError3(db.select().from(relayAgentDefinitionRevisions).where(predicate(tenantId2, relayAgentDefinitionRevisions.tenantId, eq4(relayAgentDefinitionRevisions.agentDefinitionId, input.id), eq4(relayAgentDefinitionRevisions.revision, input.revision))).limit(1));
+    const rows = yield* mapDatabaseError2(db.select().from(relayAgentDefinitionRevisions).where(predicate(tenantId2, relayAgentDefinitionRevisions.tenantId, eq3(relayAgentDefinitionRevisions.agentDefinitionId, input.id), eq3(relayAgentDefinitionRevisions.revision, input.revision))).limit(1));
     return rows[0] === undefined ? undefined : toRevisionRecord(rows[0]);
   });
   const list2 = Effect5.fn("AgentDefinitionRepository.list")(function* () {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError3(db.select().from(relayAgentDefinitions).where(predicate(tenantId2, relayAgentDefinitions.tenantId)).orderBy(desc(relayAgentDefinitions.createdAt), asc2(relayAgentDefinitions.id)));
+    const rows = yield* mapDatabaseError2(db.select().from(relayAgentDefinitions).where(predicate(tenantId2, relayAgentDefinitions.tenantId)).orderBy(desc(relayAgentDefinitions.createdAt), asc2(relayAgentDefinitions.id)));
     return rows.map(toRecord2);
   });
   const listRevisions = Effect5.fn("AgentDefinitionRepository.listRevisions")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError3(db.select().from(relayAgentDefinitionRevisions).where(predicate(tenantId2, relayAgentDefinitionRevisions.tenantId, eq4(relayAgentDefinitionRevisions.agentDefinitionId, id2))).orderBy(desc(relayAgentDefinitionRevisions.revision)));
+    const rows = yield* mapDatabaseError2(db.select().from(relayAgentDefinitionRevisions).where(predicate(tenantId2, relayAgentDefinitionRevisions.tenantId, eq3(relayAgentDefinitionRevisions.agentDefinitionId, id2))).orderBy(desc(relayAgentDefinitionRevisions.revision)));
     return rows.map(toRevisionRecord);
   });
   return Service5.of({ put, get: get2, getRevision, list: list2, listRevisions });
@@ -1824,7 +1848,7 @@ __export(exports_child_execution_repository, {
   ChildExecutionRepositoryError: () => ChildExecutionRepositoryError,
   ChildExecutionNotFound: () => ChildExecutionNotFound
 });
-import { asc as asc3, eq as eq5 } from "drizzle-orm";
+import { asc as asc3, eq as eq4 } from "drizzle-orm";
 import { Context as Context6, Effect as Effect6, Layer as Layer6, Schema as Schema16 } from "effect";
 class ChildExecutionRepositoryError extends Schema16.TaggedErrorClass()("ChildExecutionRepositoryError", {
   message: Schema16.String
@@ -1863,15 +1887,15 @@ var toRecord3 = (row) => ({
   createdAt: fromPgDate(row.createdAt),
   updatedAt: fromPgDate(row.updatedAt)
 });
-var mapDatabaseError4 = (effect) => effect.pipe(Effect6.mapError((error) => new ChildExecutionRepositoryError({ message: String(error) })));
+var mapDatabaseError3 = (effect) => effect.pipe(Effect6.mapError((error) => new ChildExecutionRepositoryError({ message: String(error) })));
 var layer6 = Layer6.effect(Service6, Effect6.gen(function* () {
   const db = yield* Service;
   const create = Effect6.fn("ChildExecutionRepository.create")(function* (input) {
     const tenantId2 = yield* current;
-    const existing = yield* mapDatabaseError4(db.select().from(relayChildExecutions).where(predicate(tenantId2, relayChildExecutions.tenantId, eq5(relayChildExecutions.id, input.id))).limit(1));
+    const existing = yield* mapDatabaseError3(db.select().from(relayChildExecutions).where(predicate(tenantId2, relayChildExecutions.tenantId, eq4(relayChildExecutions.id, input.id))).limit(1));
     if (existing[0] !== undefined)
       return yield* Effect6.fail(new DuplicateChildExecution({ id: input.id }));
-    const rows = yield* mapDatabaseError4(db.insert(relayChildExecutions).values(toInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError3(db.insert(relayChildExecutions).values(toInsert(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect6.fail(new ChildExecutionRepositoryError({ message: "Child execution insert returned no row" }));
@@ -1880,21 +1904,21 @@ var layer6 = Layer6.effect(Service6, Effect6.gen(function* () {
   });
   const get3 = Effect6.fn("ChildExecutionRepository.get")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError4(db.select().from(relayChildExecutions).where(predicate(tenantId2, relayChildExecutions.tenantId, eq5(relayChildExecutions.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError3(db.select().from(relayChildExecutions).where(predicate(tenantId2, relayChildExecutions.tenantId, eq4(relayChildExecutions.id, id2))).limit(1));
     return rows[0] === undefined ? undefined : toRecord3(rows[0]);
   });
   const listByExecution = Effect6.fn("ChildExecutionRepository.listByExecution")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError4(db.select().from(relayChildExecutions).where(predicate(tenantId2, relayChildExecutions.tenantId, eq5(relayChildExecutions.executionId, executionId))).orderBy(asc3(relayChildExecutions.createdAt)));
+    const rows = yield* mapDatabaseError3(db.select().from(relayChildExecutions).where(predicate(tenantId2, relayChildExecutions.tenantId, eq4(relayChildExecutions.executionId, executionId))).orderBy(asc3(relayChildExecutions.createdAt)));
     return rows.map(toRecord3);
   });
   const updateStatus = Effect6.fn("ChildExecutionRepository.updateStatus")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError4(db.update(relayChildExecutions).set({
+    const rows = yield* mapDatabaseError3(db.update(relayChildExecutions).set({
       status: input.status,
       updatedAt: toPgDate(input.updatedAt),
       ...input.metadata === undefined ? {} : { metadataJson: input.metadata }
-    }).where(predicate(tenantId2, relayChildExecutions.tenantId, eq5(relayChildExecutions.id, input.id))).returning());
+    }).where(predicate(tenantId2, relayChildExecutions.tenantId, eq4(relayChildExecutions.id, input.id))).returning());
     const row = rows[0];
     if (row === undefined)
       return yield* Effect6.fail(new ChildExecutionNotFound({ id: input.id }));
@@ -1972,7 +1996,7 @@ __export(exports_cluster_registry_repository, {
   ClusterRegistryError: () => ClusterRegistryError
 });
 import { Context as Context7, Effect as Effect7, Layer as Layer7, Schema as Schema17 } from "effect";
-import { SqlClient as SqlClient3, SqlSchema } from "effect/unstable/sql";
+import { SqlClient as SqlClient5, SqlSchema } from "effect/unstable/sql";
 
 class ClusterRegistryError extends Schema17.TaggedErrorClass()("ClusterRegistryError", {
   message: Schema17.String
@@ -1998,7 +2022,7 @@ var toRunnerRecord = (row) => ({
 });
 var toRegistryError = (error) => new ClusterRegistryError({ message: String(error) });
 var layer7 = Layer7.effect(Service7, Effect7.gen(function* () {
-  const sql5 = yield* SqlClient3.SqlClient;
+  const sql5 = yield* SqlClient5.SqlClient;
   const runnersQuery = SqlSchema.findAll({
     Request: Schema17.Void,
     Result: RunnerRow,
@@ -2051,7 +2075,7 @@ __export(exports_compaction_repository, {
   Service: () => Service8,
   CompactionRepositoryError: () => CompactionRepositoryError
 });
-import { asc as asc4, eq as eq6 } from "drizzle-orm";
+import { asc as asc4, eq as eq5 } from "drizzle-orm";
 import { Context as Context8, Effect as Effect8, Layer as Layer8, Schema as Schema18 } from "effect";
 class CompactionRepositoryError extends Schema18.TaggedErrorClass()("CompactionRepositoryError", {
   message: Schema18.String
@@ -2068,7 +2092,7 @@ var toRecord4 = (row) => ({
   turn: row.turn,
   createdAt: fromPgDate(row.createdAt)
 });
-var mapDatabaseError5 = (effect) => effect.pipe(Effect8.mapError((error) => new CompactionRepositoryError({ message: String(error) })));
+var mapDatabaseError4 = (effect) => effect.pipe(Effect8.mapError((error) => new CompactionRepositoryError({ message: String(error) })));
 var key = (input) => `${input.executionId}:${input.checkpointId}`;
 var sameCheckpoint = (record, input) => record.summary === input.summary && record.firstKeptEntryId === input.firstKeptEntryId && record.turn === input.turn;
 var conflict = (input) => new CompactionRepositoryError({
@@ -2079,7 +2103,7 @@ var layer8 = Layer8.effect(Service8, Effect8.gen(function* () {
   const db = yield* Service;
   const get4 = Effect8.fn("CompactionRepository.get")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError5(db.select().from(relayAgentCompactions).where(predicate(tenantId2, relayAgentCompactions.tenantId, eq6(relayAgentCompactions.executionId, input.executionId), eq6(relayAgentCompactions.checkpointId, input.checkpointId))).limit(1));
+    const rows = yield* mapDatabaseError4(db.select().from(relayAgentCompactions).where(predicate(tenantId2, relayAgentCompactions.tenantId, eq5(relayAgentCompactions.executionId, input.executionId), eq5(relayAgentCompactions.checkpointId, input.checkpointId))).limit(1));
     return rows[0] === undefined ? undefined : toRecord4(rows[0]);
   });
   const record = Effect8.fn("CompactionRepository.record")(function* (input) {
@@ -2090,7 +2114,7 @@ var layer8 = Layer8.effect(Service8, Effect8.gen(function* () {
         return yield* Effect8.fail(conflict(input));
       return existing;
     }
-    const rows = yield* mapDatabaseError5(db.insert(relayAgentCompactions).values({
+    const rows = yield* mapDatabaseError4(db.insert(relayAgentCompactions).values({
       tenantId: tenantId2,
       executionId: input.executionId,
       checkpointId: input.checkpointId,
@@ -2115,7 +2139,7 @@ var layer8 = Layer8.effect(Service8, Effect8.gen(function* () {
   });
   const list3 = Effect8.fn("CompactionRepository.list")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError5(db.select().from(relayAgentCompactions).where(predicate(tenantId2, relayAgentCompactions.tenantId, eq6(relayAgentCompactions.executionId, executionId))).orderBy(asc4(relayAgentCompactions.turn), asc4(relayAgentCompactions.checkpointId)));
+    const rows = yield* mapDatabaseError4(db.select().from(relayAgentCompactions).where(predicate(tenantId2, relayAgentCompactions.tenantId, eq5(relayAgentCompactions.executionId, executionId))).orderBy(asc4(relayAgentCompactions.turn), asc4(relayAgentCompactions.checkpointId)));
     return rows.map(toRecord4);
   });
   return Service8.of({ get: get4, record, list: list3 });
@@ -2180,7 +2204,7 @@ __export(exports_envelope_repository, {
   EnvelopeReadyClaimMismatch: () => EnvelopeReadyClaimMismatch,
   EnvelopeNotFound: () => EnvelopeNotFound
 });
-import { and as and2, asc as asc5, desc as desc2, eq as eq7, inArray, lte, or, sql as sql5 } from "drizzle-orm";
+import { and as and2, asc as asc5, desc as desc2, eq as eq6, inArray, lte, or, sql as sql5 } from "drizzle-orm";
 import { Context as Context9, Effect as Effect9, Layer as Layer9, Schema as Schema19 } from "effect";
 var WaitState = Schema19.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.Store.WaitState"
@@ -2311,17 +2335,17 @@ var maxListWaitsLimit = 500;
 var defaultListWaitsLimit = 50;
 var listWaitsLimit = (input) => Math.min(Math.max(input.limit ?? defaultListWaitsLimit, 1), maxListWaitsLimit);
 var listWaitsConditions = (input) => [
-  input.executionId === undefined ? undefined : eq7(relayWaits.executionId, input.executionId),
-  input.state === undefined ? undefined : eq7(relayWaits.state, input.state)
+  input.executionId === undefined ? undefined : eq6(relayWaits.executionId, input.executionId),
+  input.state === undefined ? undefined : eq6(relayWaits.state, input.state)
 ].filter((condition) => condition !== undefined);
 var compareWaitsDesc = (left, right) => right.createdAt - left.createdAt || (left.id < right.id ? 1 : left.id > right.id ? -1 : 0);
-var mapDatabaseError6 = (effect) => effect.pipe(Effect9.mapError((error) => new EnvelopeRepositoryError({ message: String(error) })));
+var mapDatabaseError5 = (effect) => effect.pipe(Effect9.mapError((error) => new EnvelopeRepositoryError({ message: String(error) })));
 var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
   const db = yield* Service;
   const acceptEnvelope = Effect9.fn("EnvelopeRepository.acceptEnvelope")(function* (input) {
     const tenantId2 = yield* current;
     const wait = toWaitInsert(tenantId2, input);
-    yield* mapDatabaseError6(db.transaction((tx) => Effect9.gen(function* () {
+    yield* mapDatabaseError5(db.transaction((tx) => Effect9.gen(function* () {
       yield* tx.insert(relayEnvelopes).values(toEnvelopeRow(tenantId2, input.envelope));
       if (wait !== undefined) {
         yield* tx.insert(relayWaits).values(wait);
@@ -2334,17 +2358,17 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
   });
   const getEnvelope = Effect9.fn("EnvelopeRepository.getEnvelope")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError6(db.select().from(relayEnvelopes).where(predicate(tenantId2, relayEnvelopes.tenantId, eq7(relayEnvelopes.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError5(db.select().from(relayEnvelopes).where(predicate(tenantId2, relayEnvelopes.tenantId, eq6(relayEnvelopes.id, id2))).limit(1));
     return rows[0] === undefined ? undefined : toEnvelope(rows[0]);
   });
   const getWait = Effect9.fn("EnvelopeRepository.getWait")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError6(db.select().from(relayWaits).where(predicate(tenantId2, relayWaits.tenantId, eq7(relayWaits.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError5(db.select().from(relayWaits).where(predicate(tenantId2, relayWaits.tenantId, eq6(relayWaits.id, id2))).limit(1));
     return rows[0] === undefined ? undefined : toWaitRecord(rows[0]);
   });
   const createWait = Effect9.fn("EnvelopeRepository.createWait")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError6(db.insert(relayWaits).values({
+    const rows = yield* mapDatabaseError5(db.insert(relayWaits).values({
       tenantId: tenantId2,
       id: input.waitId,
       executionId: input.executionId,
@@ -2361,13 +2385,13 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
   });
   const listWaits = Effect9.fn("EnvelopeRepository.listWaits")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError6(db.select().from(relayWaits).where(predicate(tenantId2, relayWaits.tenantId, ...listWaitsConditions(input))).orderBy(desc2(relayWaits.createdAt), desc2(relayWaits.id)).limit(listWaitsLimit(input)));
+    const rows = yield* mapDatabaseError5(db.select().from(relayWaits).where(predicate(tenantId2, relayWaits.tenantId, ...listWaitsConditions(input))).orderBy(desc2(relayWaits.createdAt), desc2(relayWaits.id)).limit(listWaitsLimit(input)));
     return rows.map(toWaitRecord);
   });
   const claimReady = Effect9.fn("EnvelopeRepository.claimReady")(function* (input) {
     const tenantId2 = yield* current;
-    const candidate = db.select({ id: relayEnvelopeReady.id }).from(relayEnvelopeReady).where(predicate(tenantId2, relayEnvelopeReady.tenantId, eq7(relayEnvelopeReady.routeType, input.routeType), input.routeKey === undefined ? undefined : eq7(relayEnvelopeReady.routeKey, input.routeKey), or(and2(eq7(relayEnvelopeReady.state, "ready"), lte(relayEnvelopeReady.availableAt, toPgDate(input.now))), and2(eq7(relayEnvelopeReady.state, "claimed"), lte(relayEnvelopeReady.claimExpiresAt, toPgDate(input.now)))))).orderBy(asc5(relayEnvelopeReady.availableAt), asc5(relayEnvelopeReady.createdAt)).limit(1).for("update", { skipLocked: true });
-    const rows = yield* mapDatabaseError6(db.update(relayEnvelopeReady).set({
+    const candidate = db.select({ id: relayEnvelopeReady.id }).from(relayEnvelopeReady).where(predicate(tenantId2, relayEnvelopeReady.tenantId, eq6(relayEnvelopeReady.routeType, input.routeType), input.routeKey === undefined ? undefined : eq6(relayEnvelopeReady.routeKey, input.routeKey), or(and2(eq6(relayEnvelopeReady.state, "ready"), lte(relayEnvelopeReady.availableAt, toPgDate(input.now))), and2(eq6(relayEnvelopeReady.state, "claimed"), lte(relayEnvelopeReady.claimExpiresAt, toPgDate(input.now)))))).orderBy(asc5(relayEnvelopeReady.availableAt), asc5(relayEnvelopeReady.createdAt)).limit(1).for("update", { skipLocked: true });
+    const rows = yield* mapDatabaseError5(db.update(relayEnvelopeReady).set({
       state: "claimed",
       claimOwner: input.workerId,
       claimExpiresAt: toPgDate(input.claimExpiresAt),
@@ -2379,14 +2403,14 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
   });
   const releaseReady = Effect9.fn("EnvelopeRepository.releaseReady")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError6(db.update(relayEnvelopeReady).set({
+    const rows = yield* mapDatabaseError5(db.update(relayEnvelopeReady).set({
       state: "ready",
       availableAt: toPgDate(input.nextAvailableAt),
       claimOwner: null,
       claimExpiresAt: null,
       lastError: input.error ?? null,
       updatedAt: toPgDate(input.nextAvailableAt)
-    }).where(predicate(tenantId2, relayEnvelopeReady.tenantId, eq7(relayEnvelopeReady.id, input.id), eq7(relayEnvelopeReady.claimOwner, input.workerId), eq7(relayEnvelopeReady.state, "claimed"))).returning());
+    }).where(predicate(tenantId2, relayEnvelopeReady.tenantId, eq6(relayEnvelopeReady.id, input.id), eq6(relayEnvelopeReady.claimOwner, input.workerId), eq6(relayEnvelopeReady.state, "claimed"))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toReadyRecord(row);
@@ -2399,11 +2423,11 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
   });
   const ackReady = Effect9.fn("EnvelopeRepository.ackReady")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError6(db.update(relayEnvelopeReady).set({
+    const rows = yield* mapDatabaseError5(db.update(relayEnvelopeReady).set({
       state: "acknowledged",
       acknowledgedAt: toPgDate(input.now),
       updatedAt: toPgDate(input.now)
-    }).where(predicate(tenantId2, relayEnvelopeReady.tenantId, eq7(relayEnvelopeReady.id, input.id), eq7(relayEnvelopeReady.claimOwner, input.workerId), eq7(relayEnvelopeReady.state, "claimed"))).returning());
+    }).where(predicate(tenantId2, relayEnvelopeReady.tenantId, eq6(relayEnvelopeReady.id, input.id), eq6(relayEnvelopeReady.claimOwner, input.workerId), eq6(relayEnvelopeReady.state, "claimed"))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toReadyRecord(row);
@@ -2421,11 +2445,11 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
       return yield* Effect9.fail(new WaitNotFound({ id: input.waitId }));
     if (current2.state !== "open")
       return { wait: toWaitRecord(current2), transitioned: false };
-    const rows = yield* mapDatabaseError6(db.update(relayWaits).set({
+    const rows = yield* mapDatabaseError5(db.update(relayWaits).set({
       state: input.state,
       resolvedAt: toPgDate(input.completedAt),
       metadataJson: { ...current2.metadataJson, ...metadata3(input.metadata) }
-    }).where(predicate(tenantId2, relayWaits.tenantId, eq7(relayWaits.id, input.waitId), eq7(relayWaits.state, "open"))).returning());
+    }).where(predicate(tenantId2, relayWaits.tenantId, eq6(relayWaits.id, input.waitId), eq6(relayWaits.state, "open"))).returning());
     const row = rows[0];
     if (row === undefined) {
       const latest = yield* getWaitRow(db, tenantId2, input.waitId);
@@ -2457,8 +2481,8 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
     resolveWait
   });
 }));
-var getReadyRow = (db, tenantId2, id2) => mapDatabaseError6(db.select().from(relayEnvelopeReady).where(predicate(tenantId2, relayEnvelopeReady.tenantId, eq7(relayEnvelopeReady.id, id2))).limit(1)).pipe(Effect9.map((rows) => rows[0]));
-var getWaitRow = (db, tenantId2, id2) => mapDatabaseError6(db.select().from(relayWaits).where(predicate(tenantId2, relayWaits.tenantId, eq7(relayWaits.id, id2))).limit(1)).pipe(Effect9.map((rows) => rows[0]));
+var getReadyRow = (db, tenantId2, id2) => mapDatabaseError5(db.select().from(relayEnvelopeReady).where(predicate(tenantId2, relayEnvelopeReady.tenantId, eq6(relayEnvelopeReady.id, id2))).limit(1)).pipe(Effect9.map((rows) => rows[0]));
+var getWaitRow = (db, tenantId2, id2) => mapDatabaseError5(db.select().from(relayWaits).where(predicate(tenantId2, relayWaits.tenantId, eq6(relayWaits.id, id2))).limit(1)).pipe(Effect9.map((rows) => rows[0]));
 var memoryLayer7 = Layer9.sync(Service9, () => {
   const envelopes = new Map;
   const waits = new Map;
@@ -2668,7 +2692,7 @@ __export(exports_execution_event_repository, {
   ExecutionEventCursorNotFound: () => ExecutionEventCursorNotFound,
   DuplicateExecutionEvent: () => DuplicateExecutionEvent
 });
-import { asc as asc6, desc as desc3, eq as eq8, gt, max, or as or2, sql as sql6 } from "drizzle-orm";
+import { asc as asc6, desc as desc3, eq as eq7, gt, max, or as or2, sql as sql6 } from "drizzle-orm";
 import { Context as Context10, Effect as Effect10, Filter, Layer as Layer10, Option as Option2, Schema as Schema20, Stream } from "effect";
 var executionEventsChannel = "relay_execution_events";
 
@@ -2732,7 +2756,7 @@ var toEvent = (row) => ({
   data: row.dataJson,
   created_at: fromPgDate(row.createdAt)
 });
-var mapDatabaseError7 = (effect) => effect.pipe(Effect10.mapError((error) => new ExecutionEventRepositoryError({ message: String(error) })));
+var mapDatabaseError6 = (effect) => effect.pipe(Effect10.mapError((error) => new ExecutionEventRepositoryError({ message: String(error) })));
 var mapSqlError = (error) => new ExecutionEventRepositoryError({ message: String(error) });
 var appendedSignalPayload = (tenantId2, event) => JSON.stringify({ tenantId: tenantId2, executionId: event.execution_id, sequence: event.sequence });
 var parseAppendedSignal = (tenantId2, executionId, payload) => {
@@ -2778,7 +2802,7 @@ var layer10 = Layer10.effect(Service10, Effect10.gen(function* () {
   const db = yield* Service;
   const append = Effect10.fn("ExecutionEventRepository.append")(function* (input) {
     const tenantId2 = yield* current;
-    const previousRows = yield* mapDatabaseError7(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, input.execution_id))).orderBy(desc3(relayExecutionEvents.sequence)).limit(1));
+    const previousRows = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.execution_id))).orderBy(desc3(relayExecutionEvents.sequence)).limit(1));
     const previous = previousRows[0];
     if (previous !== undefined && input.sequence === previous.sequence) {
       return yield* Effect10.fail(duplicateError(input));
@@ -2790,11 +2814,11 @@ var layer10 = Layer10.effect(Service10, Effect10.gen(function* () {
         previous_sequence: previous.sequence
       }));
     }
-    const duplicateCursorRows = yield* mapDatabaseError7(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.cursor, input.cursor))).limit(1));
+    const duplicateCursorRows = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.cursor, input.cursor))).limit(1));
     if (duplicateCursorRows[0] !== undefined) {
       return yield* Effect10.fail(duplicateError(input));
     }
-    const rows = yield* mapDatabaseError7(db.insert(relayExecutionEvents).values(toRow(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError6(db.insert(relayExecutionEvents).values(toRow(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect10.fail(new ExecutionEventRepositoryError({ message: "Execution event append returned no row" }));
@@ -2804,49 +2828,49 @@ var layer10 = Layer10.effect(Service10, Effect10.gen(function* () {
   const list4 = Effect10.fn("ExecutionEventRepository.list")(function* (input) {
     const tenantId2 = yield* current;
     if (input.afterCursor === undefined) {
-      const rows2 = yield* mapDatabaseError7(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, input.executionId))).orderBy(asc6(relayExecutionEvents.sequence)).limit(listLimit(input)));
+      const rows2 = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId))).orderBy(asc6(relayExecutionEvents.sequence)).limit(listLimit(input)));
       return rows2.map(toEvent);
     }
-    const cursorRows = yield* mapDatabaseError7(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, input.executionId), eq8(relayExecutionEvents.cursor, input.afterCursor))).limit(1));
+    const cursorRows = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId), eq7(relayExecutionEvents.cursor, input.afterCursor))).limit(1));
     const cursorRow = cursorRows[0];
     if (cursorRow === undefined) {
       return yield* Effect10.fail(new ExecutionEventCursorNotFound({ execution_id: input.executionId, cursor: input.afterCursor }));
     }
-    const rows = yield* mapDatabaseError7(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, input.executionId), gt(relayExecutionEvents.sequence, cursorRow.sequence))).orderBy(asc6(relayExecutionEvents.sequence)).limit(listLimit(input)));
+    const rows = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId), gt(relayExecutionEvents.sequence, cursorRow.sequence))).orderBy(asc6(relayExecutionEvents.sequence)).limit(listLimit(input)));
     return rows.map(toEvent);
   });
   const findBySequenceOrCursor = Effect10.fn("ExecutionEventRepository.findBySequenceOrCursor")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError7(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, input.executionId), or2(eq8(relayExecutionEvents.sequence, input.sequence), eq8(relayExecutionEvents.cursor, input.cursor)))).orderBy(asc6(relayExecutionEvents.sequence)).limit(1));
+    const rows = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId), or2(eq7(relayExecutionEvents.sequence, input.sequence), eq7(relayExecutionEvents.cursor, input.cursor)))).orderBy(asc6(relayExecutionEvents.sequence)).limit(1));
     const row = rows[0];
     return row === undefined ? Option2.none() : Option2.some(toEvent(row));
   });
   const findByCursor = Effect10.fn("ExecutionEventRepository.findByCursor")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError7(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, input.executionId), eq8(relayExecutionEvents.cursor, input.cursor))).limit(1));
+    const rows = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId), eq7(relayExecutionEvents.cursor, input.cursor))).limit(1));
     const row = rows[0];
     return row === undefined ? Option2.none() : Option2.some(toEvent(row));
   });
   const findFirstByTypeAfterSequence = Effect10.fn("ExecutionEventRepository.findFirstByTypeAfterSequence")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError7(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, input.executionId), eq8(relayExecutionEvents.type, input.type), gt(relayExecutionEvents.sequence, input.afterSequence))).orderBy(asc6(relayExecutionEvents.sequence)).limit(1));
+    const rows = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId), eq7(relayExecutionEvents.type, input.type), gt(relayExecutionEvents.sequence, input.afterSequence))).orderBy(asc6(relayExecutionEvents.sequence)).limit(1));
     const row = rows[0];
     return row === undefined ? Option2.none() : Option2.some(toEvent(row));
   });
   const maxSequence = Effect10.fn("ExecutionEventRepository.maxSequence")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError7(db.select({ value: max(relayExecutionEvents.sequence) }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, executionId))));
+    const rows = yield* mapDatabaseError6(db.select({ value: max(relayExecutionEvents.sequence) }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, executionId))));
     const value = rows[0]?.value;
     return value === null || value === undefined ? undefined : value;
   });
   const sumUsage = Effect10.fn("ExecutionEventRepository.sumUsage")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError7(db.select({
+    const rows = yield* mapDatabaseError6(db.select({
       value: sql6`sum(
               coalesce((${relayExecutionEvents.dataJson} ->> 'input_tokens')::bigint, 0)
               + coalesce((${relayExecutionEvents.dataJson} ->> 'output_tokens')::bigint, 0)
             )`
-    }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, executionId), eq8(relayExecutionEvents.type, usageReportedEventType))));
+    }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, executionId), eq7(relayExecutionEvents.type, usageReportedEventType))));
     const value = rows[0]?.value;
     return value === null || value === undefined ? 0 : Number(value);
   });
@@ -2857,7 +2881,7 @@ var layer10 = Layer10.effect(Service10, Effect10.gen(function* () {
   const appendedSignals = (executionId) => Stream.unwrap(current.pipe(Effect10.map((tenantId2) => db.$client.listen(executionEventsChannel).pipe(Stream.mapError(mapSqlError), Stream.filterMap(Filter.fromPredicateOption((payload) => parseAppendedSignal(tenantId2, executionId, payload)))))));
   const listAfterSequence = Effect10.fn("ExecutionEventRepository.listAfterSequence")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError7(db.select().from(relayExecutionEvents).where(input.afterSequence === undefined ? predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, input.executionId)) : predicate(tenantId2, relayExecutionEvents.tenantId, eq8(relayExecutionEvents.executionId, input.executionId), gt(relayExecutionEvents.sequence, input.afterSequence))).orderBy(asc6(relayExecutionEvents.sequence)).limit(input.limit));
+    const rows = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(input.afterSequence === undefined ? predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId)) : predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId), gt(relayExecutionEvents.sequence, input.afterSequence))).orderBy(asc6(relayExecutionEvents.sequence)).limit(input.limit));
     return rows.map(toEvent);
   });
   return Service10.of({
@@ -2977,7 +3001,7 @@ __export(exports_execution_repository, {
   ExecutionNotFound: () => ExecutionNotFound,
   DuplicateExecution: () => DuplicateExecution
 });
-import { and as and3, desc as desc4, eq as eq9, lt, or as or3 } from "drizzle-orm";
+import { and as and3, desc as desc4, eq as eq8, lt, or as or3 } from "drizzle-orm";
 import { Context as Context11, Effect as Effect11, Layer as Layer11, Schema as Schema21 } from "effect";
 class ExecutionRepositoryError extends Schema21.TaggedErrorClass()("ExecutionRepositoryError", {
   message: Schema21.String
@@ -3058,7 +3082,7 @@ var toRecord5 = (row) => {
     updatedAt: fromPgDate(row.updatedAt)
   };
 };
-var mapDatabaseError8 = (effect) => effect.pipe(Effect11.mapError((error) => new ExecutionRepositoryError({ message: String(error) })));
+var mapDatabaseError7 = (effect) => effect.pipe(Effect11.mapError((error) => new ExecutionRepositoryError({ message: String(error) })));
 var maxListLimit2 = 100;
 var defaultListLimit = 50;
 var listLimit2 = (input) => Math.min(Math.max(input.limit ?? defaultListLimit, 1), maxListLimit2);
@@ -3069,20 +3093,20 @@ var nextCursorOf = (records, fetched, limit) => {
 var compareDesc = (left, right) => right.updatedAt - left.updatedAt || (left.id < right.id ? 1 : left.id > right.id ? -1 : 0);
 var afterCursor = (record2, cursor) => cursor === undefined || record2.updatedAt < cursor.updatedAt || record2.updatedAt === cursor.updatedAt && record2.id < cursor.id;
 var listConditions = (input) => [
-  input.rootAddressId === undefined ? undefined : eq9(relayExecutions.rootAddressId, input.rootAddressId),
-  input.sessionId === undefined ? undefined : eq9(relayExecutions.sessionId, input.sessionId),
-  input.status === undefined ? undefined : eq9(relayExecutions.status, input.status),
-  input.cursor === undefined ? undefined : or3(lt(relayExecutions.updatedAt, toPgDate(input.cursor.updatedAt)), and3(eq9(relayExecutions.updatedAt, toPgDate(input.cursor.updatedAt)), lt(relayExecutions.id, input.cursor.id)))
+  input.rootAddressId === undefined ? undefined : eq8(relayExecutions.rootAddressId, input.rootAddressId),
+  input.sessionId === undefined ? undefined : eq8(relayExecutions.sessionId, input.sessionId),
+  input.status === undefined ? undefined : eq8(relayExecutions.status, input.status),
+  input.cursor === undefined ? undefined : or3(lt(relayExecutions.updatedAt, toPgDate(input.cursor.updatedAt)), and3(eq8(relayExecutions.updatedAt, toPgDate(input.cursor.updatedAt)), lt(relayExecutions.id, input.cursor.id)))
 ].filter((condition) => condition !== undefined);
 var layer11 = Layer11.effect(Service11, Effect11.gen(function* () {
   const db = yield* Service;
   const create2 = Effect11.fn("ExecutionRepository.create")(function* (input) {
     const tenantId2 = yield* current;
     yield* validateCreateInput(input);
-    const existing = yield* mapDatabaseError8(db.select().from(relayExecutions).where(predicate(tenantId2, relayExecutions.tenantId, eq9(relayExecutions.id, input.id))).limit(1));
+    const existing = yield* mapDatabaseError7(db.select().from(relayExecutions).where(predicate(tenantId2, relayExecutions.tenantId, eq8(relayExecutions.id, input.id))).limit(1));
     if (existing[0] !== undefined)
       return yield* Effect11.fail(new DuplicateExecution({ id: input.id }));
-    const rows = yield* mapDatabaseError8(db.insert(relayExecutions).values(toInsert2(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError7(db.insert(relayExecutions).values(toInsert2(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect11.fail(new ExecutionRepositoryError({ message: "Execution insert returned no row" }));
@@ -3091,24 +3115,24 @@ var layer11 = Layer11.effect(Service11, Effect11.gen(function* () {
   });
   const get5 = Effect11.fn("ExecutionRepository.get")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError8(db.select().from(relayExecutions).where(predicate(tenantId2, relayExecutions.tenantId, eq9(relayExecutions.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError7(db.select().from(relayExecutions).where(predicate(tenantId2, relayExecutions.tenantId, eq8(relayExecutions.id, id2))).limit(1));
     return rows[0] === undefined ? undefined : toRecord5(rows[0]);
   });
   const list5 = Effect11.fn("ExecutionRepository.list")(function* (input) {
     const tenantId2 = yield* current;
     const limit = listLimit2(input);
-    const rows = yield* mapDatabaseError8(db.select().from(relayExecutions).where(predicate(tenantId2, relayExecutions.tenantId, ...listConditions(input))).orderBy(desc4(relayExecutions.updatedAt), desc4(relayExecutions.id)).limit(limit + 1));
+    const rows = yield* mapDatabaseError7(db.select().from(relayExecutions).where(predicate(tenantId2, relayExecutions.tenantId, ...listConditions(input))).orderBy(desc4(relayExecutions.updatedAt), desc4(relayExecutions.id)).limit(limit + 1));
     const records = rows.slice(0, limit).map(toRecord5);
     const nextCursor = nextCursorOf(records, rows.length, limit);
     return nextCursor === undefined ? { records } : { records, nextCursor };
   });
   const transition = Effect11.fn("ExecutionRepository.transition")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError8(db.update(relayExecutions).set({
+    const rows = yield* mapDatabaseError7(db.update(relayExecutions).set({
       status: input.status,
       metadataJson: metadata4(input.metadata),
       updatedAt: toPgDate(input.updatedAt)
-    }).where(predicate(tenantId2, relayExecutions.tenantId, eq9(relayExecutions.id, input.id))).returning());
+    }).where(predicate(tenantId2, relayExecutions.tenantId, eq8(relayExecutions.id, input.id))).returning());
     const row = rows[0];
     if (row === undefined)
       return yield* Effect11.fail(new ExecutionNotFound({ id: input.id }));
@@ -3187,7 +3211,7 @@ var transition = Effect11.fn("ExecutionRepository.transition.call")(function* (i
   return yield* repository.transition(input);
 });
 // ../store-sql/src/idempotency/idempotency-repository.ts
-import { eq as eq10, sql as sql7 } from "drizzle-orm";
+import { eq as eq9, sql as sql7 } from "drizzle-orm";
 import { Context as Context12, Effect as Effect12, HashMap, Layer as Layer12, Option as Option3, Ref, Schema as Schema22, Semaphore } from "effect";
 class IdempotencyRepositoryError extends Schema22.TaggedErrorClass()("IdempotencyRepositoryError", {
   message: Schema22.String
@@ -3228,7 +3252,7 @@ var layer12 = Layer12.effect(Service12, Effect12.gen(function* () {
     const tenantId2 = yield* current;
     return yield* db.transaction((tx) => Effect12.gen(function* () {
       yield* tx.execute(sql7`select pg_advisory_xact_lock(hashtextextended(${`${tenantId2}:${operationId(input)}`}, 0))`);
-      const existingRows = yield* tx.select().from(relayIdempotencyKeys).where(predicate(tenantId2, relayIdempotencyKeys.tenantId, eq10(relayIdempotencyKeys.scope, input.scope), eq10(relayIdempotencyKeys.operation, input.operation), eq10(relayIdempotencyKeys.key, input.key))).limit(1);
+      const existingRows = yield* tx.select().from(relayIdempotencyKeys).where(predicate(tenantId2, relayIdempotencyKeys.tenantId, eq9(relayIdempotencyKeys.scope, input.scope), eq9(relayIdempotencyKeys.operation, input.operation), eq9(relayIdempotencyKeys.key, input.key))).limit(1);
       const existing = existingRows[0];
       if (existing !== undefined)
         return { replayed: true, record: toRecord6(existing) };
@@ -3237,7 +3261,7 @@ var layer12 = Layer12.effect(Service12, Effect12.gen(function* () {
       const row = rows[0];
       if (row !== undefined)
         return { replayed: false, record: toRecord6(row) };
-      const winnerRows = yield* tx.select().from(relayIdempotencyKeys).where(predicate(tenantId2, relayIdempotencyKeys.tenantId, eq10(relayIdempotencyKeys.scope, input.scope), eq10(relayIdempotencyKeys.operation, input.operation), eq10(relayIdempotencyKeys.key, input.key))).limit(1);
+      const winnerRows = yield* tx.select().from(relayIdempotencyKeys).where(predicate(tenantId2, relayIdempotencyKeys.tenantId, eq9(relayIdempotencyKeys.scope, input.scope), eq9(relayIdempotencyKeys.operation, input.operation), eq9(relayIdempotencyKeys.key, input.key))).limit(1);
       const winner = winnerRows[0];
       if (winner === undefined) {
         return yield* Effect12.fail(new IdempotencyRepositoryError({ message: "Idempotency insert returned no row" }));
@@ -3314,7 +3338,7 @@ var queryRowToRecord = (row) => ({
   metadata: row.metadataJson,
   createdAt: fromPgDate(row.createdAt)
 });
-var mapDatabaseError9 = (effect) => effect.pipe(Effect13.mapError((error) => new MemoryRepositoryError({ message: String(error) })));
+var mapDatabaseError8 = (effect) => effect.pipe(Effect13.mapError((error) => new MemoryRepositoryError({ message: String(error) })));
 var parsePgFloatArray = (value) => {
   const body = value.startsWith("{") && value.endsWith("}") ? value.slice(1, -1) : value;
   if (body.length === 0)
@@ -3358,7 +3382,7 @@ var layer13 = Layer13.effect(Service13, Effect13.gen(function* () {
   const upsert2 = Effect13.fn("MemoryRepository.upsert")(function* (input) {
     const tenantId2 = yield* current;
     yield* validateVector("embedding", input.embedding);
-    const rows = yield* mapDatabaseError9(db.insert(relayMemoryRecords).values({
+    const rows = yield* mapDatabaseError8(db.insert(relayMemoryRecords).values({
       tenantId: tenantId2,
       id: input.id,
       agent: input.agent,
@@ -3389,7 +3413,7 @@ var layer13 = Layer13.effect(Service13, Effect13.gen(function* () {
     if (input.topK <= 0)
       return [];
     const queryEmbeddingSql = sql8`array[${sql8.join(input.embedding.map((value) => sql8`${value}`), sql8`, `)}]::double precision[]`;
-    const rows = yield* mapDatabaseError9(db.execute(sql8`
+    const rows = yield* mapDatabaseError8(db.execute(sql8`
           with query_embedding as (
             select ${queryEmbeddingSql} as embedding
           ),
@@ -3529,7 +3553,7 @@ __export(exports_permission_rule_repository, {
   Service: () => Service14,
   PermissionRuleRepositoryError: () => PermissionRuleRepositoryError
 });
-import { asc as asc7, eq as eq11 } from "drizzle-orm";
+import { asc as asc7, eq as eq10 } from "drizzle-orm";
 import { Context as Context14, Effect as Effect14, Layer as Layer14, Schema as Schema24 } from "effect";
 class PermissionRuleRepositoryError extends Schema24.TaggedErrorClass()("PermissionRuleRepositoryError", {
   message: Schema24.String
@@ -3544,13 +3568,13 @@ var toRecord8 = (row) => ({
   rule: row.ruleJson,
   createdAt: fromPgDate(row.createdAt)
 });
-var mapDatabaseError10 = (effect) => effect.pipe(Effect14.mapError((error) => new PermissionRuleRepositoryError({ message: String(error) })));
+var mapDatabaseError9 = (effect) => effect.pipe(Effect14.mapError((error) => new PermissionRuleRepositoryError({ message: String(error) })));
 var memoryKey = (agent, scope, pattern) => `${agent}\x00${scope}\x00${pattern}`;
 var layer14 = Layer14.effect(Service14, Effect14.gen(function* () {
   const db = yield* Service;
   const remember = Effect14.fn("PermissionRuleRepository.remember")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError10(db.insert(relayPermissionRules).values({
+    const rows = yield* mapDatabaseError9(db.insert(relayPermissionRules).values({
       tenantId: tenantId2,
       agent: input.agent,
       scope: input.scope,
@@ -3577,7 +3601,7 @@ var layer14 = Layer14.effect(Service14, Effect14.gen(function* () {
   });
   const list6 = Effect14.fn("PermissionRuleRepository.list")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError10(db.select().from(relayPermissionRules).where(predicate(tenantId2, relayPermissionRules.tenantId, eq11(relayPermissionRules.agent, input.agent), eq11(relayPermissionRules.scope, input.scope))).orderBy(asc7(relayPermissionRules.createdAt), asc7(relayPermissionRules.pattern)));
+    const rows = yield* mapDatabaseError9(db.select().from(relayPermissionRules).where(predicate(tenantId2, relayPermissionRules.tenantId, eq10(relayPermissionRules.agent, input.agent), eq10(relayPermissionRules.scope, input.scope))).orderBy(asc7(relayPermissionRules.createdAt), asc7(relayPermissionRules.pattern)));
     return rows.map(toRecord8);
   });
   return Service14.of({ remember, list: list6 });
@@ -3620,7 +3644,7 @@ __export(exports_context_epoch_repository, {
   Service: () => Service15,
   ContextEpochRepositoryError: () => ContextEpochRepositoryError
 });
-import { eq as eq12 } from "drizzle-orm";
+import { eq as eq11 } from "drizzle-orm";
 import { Context as Context15, Effect as Effect15, Layer as Layer15, Schema as Schema25 } from "effect";
 class ContextEpochRepositoryError extends Schema25.TaggedErrorClass()("ContextEpochRepositoryError", {
   message: Schema25.String
@@ -3635,7 +3659,7 @@ var toRecord9 = (row) => ({
   dynamicSourceIds: row.dynamicSourceIdsJson,
   openedAt: fromPgDate(row.openedAt)
 });
-var mapDatabaseError11 = (effect) => effect.pipe(Effect15.mapError((error) => new ContextEpochRepositoryError({ message: String(error) })));
+var mapDatabaseError10 = (effect) => effect.pipe(Effect15.mapError((error) => new ContextEpochRepositoryError({ message: String(error) })));
 var sameEpoch = (record2, input) => record2.baseline === input.baseline && JSON.stringify(record2.dynamicSourceIds) === JSON.stringify(input.dynamicSourceIds);
 var conflict2 = (executionId) => new ContextEpochRepositoryError({ message: `Context epoch already exists with different payload: ${executionId}` });
 var cloneRecord5 = (record2) => structuredClone(record2);
@@ -3643,12 +3667,12 @@ var layer15 = Layer15.effect(Service15, Effect15.gen(function* () {
   const db = yield* Service;
   const get6 = Effect15.fn("ContextEpochRepository.get")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError11(db.select().from(relayExecutionContextEpochs).where(predicate(tenantId2, relayExecutionContextEpochs.tenantId, eq12(relayExecutionContextEpochs.executionId, executionId))).limit(1));
+    const rows = yield* mapDatabaseError10(db.select().from(relayExecutionContextEpochs).where(predicate(tenantId2, relayExecutionContextEpochs.tenantId, eq11(relayExecutionContextEpochs.executionId, executionId))).limit(1));
     return rows[0] === undefined ? undefined : toRecord9(rows[0]);
   });
   const save2 = Effect15.fn("ContextEpochRepository.save")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError11(db.insert(relayExecutionContextEpochs).values({
+    const rows = yield* mapDatabaseError10(db.insert(relayExecutionContextEpochs).values({
       tenantId: tenantId2,
       executionId: input.executionId,
       baseline: input.baseline,
@@ -3722,7 +3746,7 @@ __export(exports_schedule_repository, {
   ScheduleNotFound: () => ScheduleNotFound,
   ScheduleClaimMismatch: () => ScheduleClaimMismatch
 });
-import { and as and4, asc as asc8, eq as eq13, inArray as inArray2, lte as lte2, or as or4, sql as sql9 } from "drizzle-orm";
+import { and as and4, asc as asc8, eq as eq12, inArray as inArray2, lte as lte2, or as or4, sql as sql9 } from "drizzle-orm";
 import { Context as Context16, Effect as Effect16, Layer as Layer16, Schema as Schema26 } from "effect";
 class ScheduleRepositoryError extends Schema26.TaggedErrorClass()("ScheduleRepositoryError", {
   message: Schema26.String
@@ -3789,12 +3813,12 @@ var toRecord10 = (row) => ({
   created_at: fromPgDate(row.createdAt),
   updated_at: fromPgDate(row.updatedAt)
 });
-var mapDatabaseError12 = (effect) => effect.pipe(Effect16.mapError((error) => new ScheduleRepositoryError({ message: String(error) })));
+var mapDatabaseError11 = (effect) => effect.pipe(Effect16.mapError((error) => new ScheduleRepositoryError({ message: String(error) })));
 var cancellableStates = new Set(["active", "claimed"]);
 var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
   const db = yield* Service;
-  const getRow = (tenantId2, id2) => mapDatabaseError12(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, eq13(relaySchedules.id, id2))).limit(1)).pipe(Effect16.map((rows) => rows[0]));
-  const getByIdempotencyKey = (tenantId2, key2) => mapDatabaseError12(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, eq13(relaySchedules.idempotencyKey, key2))).limit(1)).pipe(Effect16.map((rows) => rows[0]));
+  const getRow = (tenantId2, id2) => mapDatabaseError11(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, eq12(relaySchedules.id, id2))).limit(1)).pipe(Effect16.map((rows) => rows[0]));
+  const getByIdempotencyKey = (tenantId2, key2) => mapDatabaseError11(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, eq12(relaySchedules.idempotencyKey, key2))).limit(1)).pipe(Effect16.map((rows) => rows[0]));
   const create3 = Effect16.fn("ScheduleRepository.create")(function* (input) {
     const tenantId2 = yield* current;
     const invalid = validationError(input);
@@ -3805,7 +3829,7 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
       if (existing !== undefined)
         return toRecord10(existing);
     }
-    const rows = yield* mapDatabaseError12(db.insert(relaySchedules).values(toInsert4(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError11(db.insert(relaySchedules).values(toInsert4(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect16.fail(new ScheduleRepositoryError({ message: `Schedule ${input.id} was not persisted` }));
@@ -3819,17 +3843,17 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
   });
   const list7 = Effect16.fn("ScheduleRepository.list")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError12(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, input.state === undefined ? undefined : eq13(relaySchedules.state, input.state))).orderBy(asc8(relaySchedules.nextRunAt), asc8(relaySchedules.createdAt)));
+    const rows = yield* mapDatabaseError11(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, input.state === undefined ? undefined : eq12(relaySchedules.state, input.state))).orderBy(asc8(relaySchedules.nextRunAt), asc8(relaySchedules.createdAt)));
     return rows.map(toRecord10);
   });
   const cancel = Effect16.fn("ScheduleRepository.cancel")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError12(db.update(relaySchedules).set({
+    const rows = yield* mapDatabaseError11(db.update(relaySchedules).set({
       state: "cancelled",
       claimOwner: null,
       claimExpiresAt: null,
       updatedAt: toPgDate(input.cancelledAt)
-    }).where(predicate(tenantId2, relaySchedules.tenantId, eq13(relaySchedules.id, input.id), inArray2(relaySchedules.state, [...cancellableStates]))).returning());
+    }).where(predicate(tenantId2, relaySchedules.tenantId, eq12(relaySchedules.id, input.id), inArray2(relaySchedules.state, [...cancellableStates]))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toRecord10(row);
@@ -3842,8 +3866,8 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
   });
   const claimDue = Effect16.fn("ScheduleRepository.claimDue")(function* (input) {
     const tenantId2 = yield* current;
-    const candidate = db.select({ id: relaySchedules.id }).from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, or4(and4(eq13(relaySchedules.state, "active"), lte2(relaySchedules.nextRunAt, toPgDate(input.now))), and4(eq13(relaySchedules.state, "claimed"), lte2(relaySchedules.claimExpiresAt, toPgDate(input.now)))))).orderBy(asc8(relaySchedules.nextRunAt), asc8(relaySchedules.createdAt)).limit(1).for("update", { skipLocked: true });
-    const rows = yield* mapDatabaseError12(db.update(relaySchedules).set({
+    const candidate = db.select({ id: relaySchedules.id }).from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, or4(and4(eq12(relaySchedules.state, "active"), lte2(relaySchedules.nextRunAt, toPgDate(input.now))), and4(eq12(relaySchedules.state, "claimed"), lte2(relaySchedules.claimExpiresAt, toPgDate(input.now)))))).orderBy(asc8(relaySchedules.nextRunAt), asc8(relaySchedules.createdAt)).limit(1).for("update", { skipLocked: true });
+    const rows = yield* mapDatabaseError11(db.update(relaySchedules).set({
       state: "claimed",
       claimOwner: input.workerId,
       claimExpiresAt: toPgDate(input.claimExpiresAt),
@@ -3854,11 +3878,11 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
   });
   const ack = Effect16.fn("ScheduleRepository.ack")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError12(db.update(relaySchedules).set({
+    const rows = yield* mapDatabaseError11(db.update(relaySchedules).set({
       ...input.nextRunAt === undefined ? { state: "completed" } : { state: "active", nextRunAt: toPgDate(input.nextRunAt), claimOwner: null },
       claimExpiresAt: null,
       updatedAt: toPgDate(input.now)
-    }).where(predicate(tenantId2, relaySchedules.tenantId, eq13(relaySchedules.id, input.id), eq13(relaySchedules.claimOwner, input.workerId), eq13(relaySchedules.state, "claimed"))).returning());
+    }).where(predicate(tenantId2, relaySchedules.tenantId, eq12(relaySchedules.id, input.id), eq12(relaySchedules.claimOwner, input.workerId), eq12(relaySchedules.state, "claimed"))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toRecord10(row);
@@ -3871,14 +3895,14 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
   });
   const release = Effect16.fn("ScheduleRepository.release")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError12(db.update(relaySchedules).set({
+    const rows = yield* mapDatabaseError11(db.update(relaySchedules).set({
       state: "active",
       nextRunAt: toPgDate(input.nextAvailableAt),
       claimOwner: null,
       claimExpiresAt: null,
       lastError: input.error,
       updatedAt: toPgDate(input.nextAvailableAt)
-    }).where(predicate(tenantId2, relaySchedules.tenantId, eq13(relaySchedules.id, input.id), eq13(relaySchedules.claimOwner, input.workerId), eq13(relaySchedules.state, "claimed"))).returning());
+    }).where(predicate(tenantId2, relaySchedules.tenantId, eq12(relaySchedules.id, input.id), eq12(relaySchedules.claimOwner, input.workerId), eq12(relaySchedules.state, "claimed"))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toRecord10(row);
@@ -4059,7 +4083,7 @@ __export(exports_session_repository, {
   Service: () => Service17,
   DuplicateSession: () => DuplicateSession
 });
-import { and as and5, count, desc as desc5, eq as eq14, lt as lt2, or as or5 } from "drizzle-orm";
+import { and as and5, count, desc as desc5, eq as eq13, lt as lt2, or as or5 } from "drizzle-orm";
 import { Context as Context17, Effect as Effect17, Layer as Layer17, Schema as Schema27 } from "effect";
 class SessionRepositoryError extends Schema27.TaggedErrorClass()("SessionRepositoryError", {
   message: Schema27.String
@@ -4135,7 +4159,7 @@ var toEntryRecord = (row) => {
       return Effect17.fail(new SessionRepositoryError({ message: `Unknown session entry tag: ${row.tag}` }));
   }
 };
-var mapDatabaseError13 = (effect) => effect.pipe(Effect17.mapError((error) => new SessionRepositoryError({ message: String(error) })));
+var mapDatabaseError12 = (effect) => effect.pipe(Effect17.mapError((error) => new SessionRepositoryError({ message: String(error) })));
 var mapWriteError = (effect) => effect.pipe(Effect17.mapError((error) => error instanceof SessionRepositoryError ? error : new SessionRepositoryError({ message: String(error) })));
 var maxListLimit3 = 100;
 var defaultListLimit2 = 50;
@@ -4147,8 +4171,8 @@ var nextCursorOf2 = (records, fetched, limit) => {
 var compareDesc2 = (left, right) => right.updatedAt - left.updatedAt || (left.id < right.id ? 1 : left.id > right.id ? -1 : 0);
 var afterCursor2 = (record2, cursor) => cursor === undefined || record2.updatedAt < cursor.updatedAt || record2.updatedAt === cursor.updatedAt && record2.id < cursor.id;
 var listConditions2 = (input) => [
-  input.rootAddressId === undefined ? undefined : eq14(relaySessions.rootAddressId, input.rootAddressId),
-  input.cursor === undefined ? undefined : or5(lt2(relaySessions.updatedAt, toPgDate(input.cursor.updatedAt)), and5(eq14(relaySessions.updatedAt, toPgDate(input.cursor.updatedAt)), lt2(relaySessions.id, input.cursor.id)))
+  input.rootAddressId === undefined ? undefined : eq13(relaySessions.rootAddressId, input.rootAddressId),
+  input.cursor === undefined ? undefined : or5(lt2(relaySessions.updatedAt, toPgDate(input.cursor.updatedAt)), and5(eq13(relaySessions.updatedAt, toPgDate(input.cursor.updatedAt)), lt2(relaySessions.id, input.cursor.id)))
 ].filter((condition) => condition !== undefined);
 var comparableEntry = (entry) => {
   const { createdAt: _createdAt, ...value } = entry;
@@ -4192,11 +4216,11 @@ var validateCompaction = (currentPath, input) => {
 var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
   const db = yield* Service;
   const getForTenant = Effect17.fn("SessionRepository.getForTenant")(function* (tenantId2, id2) {
-    const rows = yield* mapDatabaseError13(db.select().from(relaySessions).where(predicate(tenantId2, relaySessions.tenantId, eq14(relaySessions.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError12(db.select().from(relaySessions).where(predicate(tenantId2, relaySessions.tenantId, eq13(relaySessions.id, id2))).limit(1));
     return rows[0] === undefined ? undefined : toSessionRecord(rows[0]);
   });
   const entryById = Effect17.fn("SessionRepository.entryById")(function* (tenantId2, sessionId, id2) {
-    const rows = yield* mapDatabaseError13(db.select().from(relaySessionEntries).where(predicate(tenantId2, relaySessionEntries.tenantId, eq14(relaySessionEntries.id, id2), eq14(relaySessionEntries.sessionId, sessionId))).limit(1));
+    const rows = yield* mapDatabaseError12(db.select().from(relaySessionEntries).where(predicate(tenantId2, relaySessionEntries.tenantId, eq13(relaySessionEntries.id, id2), eq13(relaySessionEntries.sessionId, sessionId))).limit(1));
     return rows[0] === undefined ? undefined : yield* toEntryRecord(rows[0]);
   });
   const pathForTenant = Effect17.fn("SessionRepository.pathForTenant")(function* (tenantId2, input) {
@@ -4231,7 +4255,7 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
     const existing = yield* getForTenant(tenantId2, input.id);
     if (existing !== undefined)
       return yield* Effect17.fail(new DuplicateSession({ id: input.id }));
-    const rows = yield* mapDatabaseError13(db.insert(relaySessions).values({
+    const rows = yield* mapDatabaseError12(db.insert(relaySessions).values({
       tenantId: tenantId2,
       id: input.id,
       rootAddressId: input.rootAddressId,
@@ -4250,13 +4274,13 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
     if (existing !== undefined) {
       if (existing.rootAddressId !== input.rootAddressId)
         return yield* Effect17.fail(rootMismatch(input.id));
-      const rows2 = yield* mapDatabaseError13(db.update(relaySessions).set({ updatedAt: toPgDate(input.now) }).where(predicate(tenantId2, relaySessions.tenantId, eq14(relaySessions.id, input.id))).returning());
+      const rows2 = yield* mapDatabaseError12(db.update(relaySessions).set({ updatedAt: toPgDate(input.now) }).where(predicate(tenantId2, relaySessions.tenantId, eq13(relaySessions.id, input.id))).returning());
       const row2 = rows2[0];
       if (row2 === undefined)
         return yield* Effect17.fail(missingSession(input.id));
       return toSessionRecord(row2);
     }
-    const rows = yield* mapDatabaseError13(db.insert(relaySessions).values({
+    const rows = yield* mapDatabaseError12(db.insert(relaySessions).values({
       tenantId: tenantId2,
       id: input.id,
       rootAddressId: input.rootAddressId,
@@ -4276,14 +4300,14 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
   const list8 = Effect17.fn("SessionRepository.list")(function* (input) {
     const tenantId2 = yield* current;
     const limit = listLimit3(input);
-    const rows = yield* mapDatabaseError13(db.select().from(relaySessions).where(predicate(tenantId2, relaySessions.tenantId, ...listConditions2(input))).orderBy(desc5(relaySessions.updatedAt), desc5(relaySessions.id)).limit(limit + 1));
+    const rows = yield* mapDatabaseError12(db.select().from(relaySessions).where(predicate(tenantId2, relaySessions.tenantId, ...listConditions2(input))).orderBy(desc5(relaySessions.updatedAt), desc5(relaySessions.id)).limit(limit + 1));
     const records = rows.slice(0, limit).map(toSessionRecord);
     const nextCursor = nextCursorOf2(records, rows.length, limit);
     return nextCursor === undefined ? { records } : { records, nextCursor };
   });
   const touch = Effect17.fn("SessionRepository.touch")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError13(db.update(relaySessions).set({ updatedAt: toPgDate(input.updatedAt) }).where(predicate(tenantId2, relaySessions.tenantId, eq14(relaySessions.id, input.id))).returning());
+    const rows = yield* mapDatabaseError12(db.update(relaySessions).set({ updatedAt: toPgDate(input.updatedAt) }).where(predicate(tenantId2, relaySessions.tenantId, eq13(relaySessions.id, input.id))).returning());
     const row = rows[0];
     if (row === undefined)
       return yield* Effect17.fail(missingSession(input.id));
@@ -4305,7 +4329,7 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
       if (entry === undefined)
         return yield* Effect17.fail(missingEntry(input.id));
     }
-    yield* mapDatabaseError13(db.update(relaySessions).set({ leafEntryId: input.id, updatedAt: toPgDate(input.updatedAt) }).where(predicate(tenantId2, relaySessions.tenantId, eq14(relaySessions.id, input.sessionId))));
+    yield* mapDatabaseError12(db.update(relaySessions).set({ leafEntryId: input.id, updatedAt: toPgDate(input.updatedAt) }).where(predicate(tenantId2, relaySessions.tenantId, eq13(relaySessions.id, input.sessionId))));
   });
   const setLeaf = Effect17.fn("SessionRepository.setLeaf")(function* (input) {
     const tenantId2 = yield* current;
@@ -4342,7 +4366,7 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
         createdAt: toPgDate(input.createdAt)
       }).onConflictDoNothing({ target: [relaySessionEntries.tenantId, relaySessionEntries.id] }).returning();
       const row = rows[0];
-      const record2 = row === undefined ? yield* tx.select().from(relaySessionEntries).where(predicate(tenantId2, relaySessionEntries.tenantId, eq14(relaySessionEntries.id, input.id), eq14(relaySessionEntries.sessionId, input.sessionId))).limit(1).pipe(Effect17.flatMap((existingRows) => {
+      const record2 = row === undefined ? yield* tx.select().from(relaySessionEntries).where(predicate(tenantId2, relaySessionEntries.tenantId, eq13(relaySessionEntries.id, input.id), eq13(relaySessionEntries.sessionId, input.sessionId))).limit(1).pipe(Effect17.flatMap((existingRows) => {
         const existingRow = existingRows[0];
         if (existingRow === undefined) {
           return Effect17.fail(new SessionRepositoryError({ message: "Session entry insert returned no row" }));
@@ -4351,7 +4375,7 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
       })) : yield* toEntryRecord(row);
       if (!sameEntry(record2, desired))
         return yield* Effect17.fail(conflictingEntry(input.id));
-      const sessionRows = yield* tx.update(relaySessions).set({ leafEntryId: input.id, updatedAt: toPgDate(input.createdAt) }).where(predicate(tenantId2, relaySessions.tenantId, eq14(relaySessions.id, input.sessionId))).returning();
+      const sessionRows = yield* tx.update(relaySessions).set({ leafEntryId: input.id, updatedAt: toPgDate(input.createdAt) }).where(predicate(tenantId2, relaySessions.tenantId, eq13(relaySessions.id, input.sessionId))).returning();
       if (sessionRows[0] === undefined)
         return yield* Effect17.fail(missingSession(input.sessionId));
       return record2;
@@ -4359,7 +4383,7 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
   });
   const countEntries = Effect17.fn("SessionRepository.countEntries")(function* (sessionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError13(db.select({ value: count() }).from(relaySessionEntries).where(predicate(tenantId2, relaySessionEntries.tenantId, eq14(relaySessionEntries.sessionId, sessionId))));
+    const rows = yield* mapDatabaseError12(db.select({ value: count() }).from(relaySessionEntries).where(predicate(tenantId2, relaySessionEntries.tenantId, eq13(relaySessionEntries.sessionId, sessionId))));
     return Number(rows[0]?.value ?? 0);
   });
   return Service17.of({ create: create4, ensure, get: get8, list: list8, touch, appendEntry, countEntries, path, setLeaf, leaf });
@@ -4548,7 +4572,7 @@ __export(exports_skill_definition_repository, {
   SkillDefinitionRepositoryError: () => SkillDefinitionRepositoryError,
   Service: () => Service18
 });
-import { asc as asc9, desc as desc6, eq as eq15, inArray as inArray3, sql as sql10 } from "drizzle-orm";
+import { asc as asc9, desc as desc6, eq as eq14, inArray as inArray3, sql as sql10 } from "drizzle-orm";
 import { Context as Context18, Effect as Effect18, HashSet, Layer as Layer18, Schema as Schema28, Semaphore as Semaphore2 } from "effect";
 class SkillDefinitionRepositoryError extends Schema28.TaggedErrorClass()("SkillDefinitionRepositoryError", {
   message: Schema28.String
@@ -4611,10 +4635,10 @@ var missingSkillMessage = (requested, records) => {
   const found = HashSet.fromIterable(records.map((record2) => record2.id));
   return `Skill definition not found: ${requested.find((id2) => !HashSet.has(found, id2)) ?? requested[0]}`;
 };
-var mapDatabaseError14 = (effect) => effect.pipe(Effect18.mapError((error) => new SkillDefinitionRepositoryError({ message: String(error) })));
+var mapDatabaseError13 = (effect) => effect.pipe(Effect18.mapError((error) => new SkillDefinitionRepositoryError({ message: String(error) })));
 var mapPutError2 = (effect) => effect.pipe(Effect18.mapError((error) => error instanceof SkillDefinitionRepositoryError ? error : new SkillDefinitionRepositoryError({ message: String(error) })));
 var skillPinLockKey = (tenantId2, executionId) => `skill-pins:${tenantId2}:${executionId}`;
-var lockExecutionPins = (db, tenantId2, executionId) => mapDatabaseError14(db.execute(sql10`select pg_advisory_xact_lock(hashtext(${skillPinLockKey(tenantId2, executionId)}))`)).pipe(Effect18.asVoid);
+var lockExecutionPins = (db, tenantId2, executionId) => mapDatabaseError13(db.execute(sql10`select pg_advisory_xact_lock(hashtext(${skillPinLockKey(tenantId2, executionId)}))`)).pipe(Effect18.asVoid);
 var layer18 = Layer18.effect(Service18, Effect18.gen(function* () {
   const db = yield* Service;
   const put2 = Effect18.fn("SkillDefinitionRepository.put")(function* (input) {
@@ -4657,32 +4681,32 @@ var layer18 = Layer18.effect(Service18, Effect18.gen(function* () {
   });
   const get9 = Effect18.fn("SkillDefinitionRepository.get")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError14(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId, eq15(relaySkillDefinitions.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError13(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId, eq14(relaySkillDefinitions.id, id2))).limit(1));
     return rows[0] === undefined ? undefined : toRecord11(rows[0]);
   });
   const getRevision2 = Effect18.fn("SkillDefinitionRepository.getRevision")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError14(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq15(relaySkillDefinitionRevisions.skillDefinitionId, input.id), eq15(relaySkillDefinitionRevisions.revision, input.revision))).limit(1));
+    const rows = yield* mapDatabaseError13(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq14(relaySkillDefinitionRevisions.skillDefinitionId, input.id), eq14(relaySkillDefinitionRevisions.revision, input.revision))).limit(1));
     return rows[0] === undefined ? undefined : toRevisionRecord2(rows[0]);
   });
   const list9 = Effect18.fn("SkillDefinitionRepository.list")(function* () {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError14(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId)).orderBy(desc6(relaySkillDefinitions.createdAt), asc9(relaySkillDefinitions.id)));
+    const rows = yield* mapDatabaseError13(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId)).orderBy(desc6(relaySkillDefinitions.createdAt), asc9(relaySkillDefinitions.id)));
     return rows.map(toRecord11);
   });
   const listRevisions2 = Effect18.fn("SkillDefinitionRepository.listRevisions")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError14(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq15(relaySkillDefinitionRevisions.skillDefinitionId, id2))).orderBy(desc6(relaySkillDefinitionRevisions.revision)));
+    const rows = yield* mapDatabaseError13(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq14(relaySkillDefinitionRevisions.skillDefinitionId, id2))).orderBy(desc6(relaySkillDefinitionRevisions.revision)));
     return rows.map(toRevisionRecord2);
   });
   const listPins = Effect18.fn("SkillDefinitionRepository.listPins")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError14(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq15(relayExecutionSkillPins.executionId, executionId))).orderBy(asc9(relayExecutionSkillPins.skillDefinitionId)));
+    const rows = yield* mapDatabaseError13(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq14(relayExecutionSkillPins.executionId, executionId))).orderBy(asc9(relayExecutionSkillPins.skillDefinitionId)));
     return rows.map(toPinRecord);
   });
   const getPinned = Effect18.fn("SkillDefinitionRepository.getPinned")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError14(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq15(relayExecutionSkillPins.executionId, input.executionId), eq15(relayExecutionSkillPins.skillDefinitionId, input.skillDefinitionId))).limit(1));
+    const rows = yield* mapDatabaseError13(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq14(relayExecutionSkillPins.executionId, input.executionId), eq14(relayExecutionSkillPins.skillDefinitionId, input.skillDefinitionId))).limit(1));
     return rows[0] === undefined ? undefined : toPinRecord(rows[0]);
   });
   const pinExecution = Effect18.fn("SkillDefinitionRepository.pinExecution")(function* (input) {
@@ -4692,7 +4716,7 @@ var layer18 = Layer18.effect(Service18, Effect18.gen(function* () {
       return [];
     return yield* mapPutError2(db.transaction((tx) => Effect18.gen(function* () {
       yield* lockExecutionPins(tx, tenantId2, input.executionId);
-      const existingRows = yield* tx.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq15(relayExecutionSkillPins.executionId, input.executionId))).orderBy(asc9(relayExecutionSkillPins.skillDefinitionId));
+      const existingRows = yield* tx.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq14(relayExecutionSkillPins.executionId, input.executionId))).orderBy(asc9(relayExecutionSkillPins.skillDefinitionId));
       if (existingRows.length > 0) {
         const existing = existingRows.map(toPinRecord);
         if (!sameIdSet(existing.map((record2) => record2.skillDefinitionId), requestedIds)) {
@@ -4851,7 +4875,7 @@ __export(exports_steering_repository, {
   SteeringRepositoryError: () => SteeringRepositoryError,
   Service: () => Service19
 });
-import { asc as asc10, eq as eq16, inArray as inArray4, isNull, max as max2, sql as sql11 } from "drizzle-orm";
+import { asc as asc10, eq as eq15, inArray as inArray4, isNull, max as max2, sql as sql11 } from "drizzle-orm";
 import { Context as Context19, Effect as Effect19, Layer as Layer19, Ref as Ref3, Schema as Schema29 } from "effect";
 class SteeringRepositoryError extends Schema29.TaggedErrorClass()("SteeringRepositoryError", {
   message: Schema29.String
@@ -4861,7 +4885,7 @@ class SteeringRepositoryError extends Schema29.TaggedErrorClass()("SteeringRepos
 class Service19 extends Context19.Service()("@relayfx/store-sql/SteeringRepository") {
 }
 var SteeringKindSchema = Schema29.Literals(["steering", "follow_up"]);
-var mapDatabaseError15 = (effect) => effect.pipe(Effect19.mapError((error) => new SteeringRepositoryError({ message: String(error) })));
+var mapDatabaseError14 = (effect) => effect.pipe(Effect19.mapError((error) => new SteeringRepositoryError({ message: String(error) })));
 var mapTransactionError = (effect) => effect.pipe(Effect19.mapError((error) => error instanceof SteeringRepositoryError ? error : new SteeringRepositoryError({ message: String(error) })));
 var toMessageRecord = (row) => {
   const consumedAt = fromNullablePgDate(row.consumedAt);
@@ -4902,21 +4926,21 @@ var consumedMessage = (message, input) => ({
 var messagesForDrain = (db, tenantId2, drain) => Effect19.gen(function* () {
   if (drain.messageSequences.length === 0)
     return { drain, messages: [] };
-  const rows = yield* mapDatabaseError15(db.select().from(relaySteeringMessages).where(predicate(tenantId2, relaySteeringMessages.tenantId, eq16(relaySteeringMessages.executionId, drain.executionId), eq16(relaySteeringMessages.kind, drain.kind), inArray4(relaySteeringMessages.sequence, [...drain.messageSequences]))).orderBy(asc10(relaySteeringMessages.sequence)));
+  const rows = yield* mapDatabaseError14(db.select().from(relaySteeringMessages).where(predicate(tenantId2, relaySteeringMessages.tenantId, eq15(relaySteeringMessages.executionId, drain.executionId), eq15(relaySteeringMessages.kind, drain.kind), inArray4(relaySteeringMessages.sequence, [...drain.messageSequences]))).orderBy(asc10(relaySteeringMessages.sequence)));
   return { drain, messages: rows.map(toMessageRecord) };
 });
 var findDrain = (db, tenantId2, input) => Effect19.gen(function* () {
-  const rows = yield* mapDatabaseError15(db.select().from(relaySteeringDrains).where(predicate(tenantId2, relaySteeringDrains.tenantId, eq16(relaySteeringDrains.executionId, input.executionId), eq16(relaySteeringDrains.kind, input.kind), eq16(relaySteeringDrains.drainId, input.drainId))).limit(1));
+  const rows = yield* mapDatabaseError14(db.select().from(relaySteeringDrains).where(predicate(tenantId2, relaySteeringDrains.tenantId, eq15(relaySteeringDrains.executionId, input.executionId), eq15(relaySteeringDrains.kind, input.kind), eq15(relaySteeringDrains.drainId, input.drainId))).limit(1));
   const row = rows[0];
   return row === undefined ? undefined : toDrainRecord(row);
 });
-var lockQueue = (db, tenantId2, executionId, kind) => mapDatabaseError15(db.execute(sql11`select pg_advisory_xact_lock(hashtext(${queueKey(tenantId2, executionId, kind)}))`)).pipe(Effect19.asVoid);
-var runningExecutionStatus = (db, tenantId2, executionId) => db.select({ status: relayExecutions.status }).from(relayExecutions).where(predicate(tenantId2, relayExecutions.tenantId, eq16(relayExecutions.id, executionId))).for("update").limit(1).pipe(Effect19.map((rows) => rows[0]?.status));
+var lockQueue = (db, tenantId2, executionId, kind) => mapDatabaseError14(db.execute(sql11`select pg_advisory_xact_lock(hashtext(${queueKey(tenantId2, executionId, kind)}))`)).pipe(Effect19.asVoid);
+var runningExecutionStatus = (db, tenantId2, executionId) => db.select({ status: relayExecutions.status }).from(relayExecutions).where(predicate(tenantId2, relayExecutions.tenantId, eq15(relayExecutions.id, executionId))).for("update").limit(1).pipe(Effect19.map((rows) => rows[0]?.status));
 var layer19 = Layer19.effect(Service19, Effect19.gen(function* () {
   const db = yield* Service;
   const appendInTransaction = Effect19.fn("SteeringRepository.appendInTransaction")(function* (tx, tenantId2, input) {
     yield* lockQueue(tx, tenantId2, input.executionId, input.kind);
-    const sequenceRows = yield* tx.select({ value: max2(relaySteeringMessages.sequence) }).from(relaySteeringMessages).where(predicate(tenantId2, relaySteeringMessages.tenantId, eq16(relaySteeringMessages.executionId, input.executionId), eq16(relaySteeringMessages.kind, input.kind)));
+    const sequenceRows = yield* tx.select({ value: max2(relaySteeringMessages.sequence) }).from(relaySteeringMessages).where(predicate(tenantId2, relaySteeringMessages.tenantId, eq15(relaySteeringMessages.executionId, input.executionId), eq15(relaySteeringMessages.kind, input.kind)));
     const sequence = Number(sequenceRows[0]?.value ?? -1) + 1;
     const rows = yield* tx.insert(relaySteeringMessages).values({
       tenantId: tenantId2,
@@ -4961,13 +4985,13 @@ var layer19 = Layer19.effect(Service19, Effect19.gen(function* () {
       const existingAfterLock = yield* findDrain(scopedTx, tenantId2, input);
       if (existingAfterLock !== undefined)
         return yield* messagesForDrain(scopedTx, tenantId2, existingAfterLock);
-      const query2 = tx.select().from(relaySteeringMessages).where(predicate(tenantId2, relaySteeringMessages.tenantId, eq16(relaySteeringMessages.executionId, input.executionId), eq16(relaySteeringMessages.kind, input.kind), isNull(relaySteeringMessages.consumedAt))).orderBy(asc10(relaySteeringMessages.sequence));
+      const query2 = tx.select().from(relaySteeringMessages).where(predicate(tenantId2, relaySteeringMessages.tenantId, eq15(relaySteeringMessages.executionId, input.executionId), eq15(relaySteeringMessages.kind, input.kind), isNull(relaySteeringMessages.consumedAt))).orderBy(asc10(relaySteeringMessages.sequence));
       const rows = input.mode === "one-at-a-time" ? yield* query2.limit(1) : yield* query2;
       const sequences = rows.map((row) => row.sequence);
       const messages = sequences.length === 0 ? [] : yield* tx.update(relaySteeringMessages).set({
         drainId: input.drainId,
         consumedAt: toPgDate(input.consumedAt)
-      }).where(predicate(tenantId2, relaySteeringMessages.tenantId, eq16(relaySteeringMessages.executionId, input.executionId), eq16(relaySteeringMessages.kind, input.kind), inArray4(relaySteeringMessages.sequence, sequences))).returning();
+      }).where(predicate(tenantId2, relaySteeringMessages.tenantId, eq15(relaySteeringMessages.executionId, input.executionId), eq15(relaySteeringMessages.kind, input.kind), inArray4(relaySteeringMessages.sequence, sequences))).returning();
       const messageBySequence = new Map(messages.map((message) => [message.sequence, message]));
       const orderedMessages = sequences.flatMap((sequence) => {
         const message = messageBySequence.get(sequence);
@@ -5087,7 +5111,7 @@ __export(exports_tool_call_repository, {
   DuplicateToolResult: () => DuplicateToolResult,
   DuplicateToolCall: () => DuplicateToolCall
 });
-import { asc as asc11, eq as eq17 } from "drizzle-orm";
+import { asc as asc11, eq as eq16 } from "drizzle-orm";
 import { Context as Context20, Effect as Effect20, Layer as Layer20, Schema as Schema30 } from "effect";
 class ToolCallRepositoryError extends Schema30.TaggedErrorClass()("ToolCallRepositoryError", {
   message: Schema30.String
@@ -5148,15 +5172,15 @@ var toResultRecord = (row) => ({
   },
   createdAt: fromPgDate(row.createdAt)
 });
-var mapDatabaseError16 = (effect) => effect.pipe(Effect20.mapError((error) => new ToolCallRepositoryError({ message: String(error) })));
+var mapDatabaseError15 = (effect) => effect.pipe(Effect20.mapError((error) => new ToolCallRepositoryError({ message: String(error) })));
 var layer20 = Layer20.effect(Service20, Effect20.gen(function* () {
   const db = yield* Service;
   const recordCall = Effect20.fn("ToolCallRepository.recordCall")(function* (input) {
     const tenantId2 = yield* current;
-    const existingRows = yield* mapDatabaseError16(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq17(relayToolCalls.id, input.call.id))).limit(1));
+    const existingRows = yield* mapDatabaseError15(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq16(relayToolCalls.id, input.call.id))).limit(1));
     if (existingRows[0] !== undefined)
       return yield* Effect20.fail(new DuplicateToolCall({ id: input.call.id }));
-    const rows = yield* mapDatabaseError16(db.insert(relayToolCalls).values(toCallInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError15(db.insert(relayToolCalls).values(toCallInsert(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect20.fail(new ToolCallRepositoryError({ message: "Tool call insert returned no row" }));
@@ -5165,24 +5189,24 @@ var layer20 = Layer20.effect(Service20, Effect20.gen(function* () {
   });
   const getCall = Effect20.fn("ToolCallRepository.getCall")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError16(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq17(relayToolCalls.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError15(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq16(relayToolCalls.id, id2))).limit(1));
     return rows[0] === undefined ? undefined : toCallRecord(rows[0]);
   });
   const listCalls = Effect20.fn("ToolCallRepository.listCalls")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError16(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq17(relayToolCalls.executionId, executionId))).orderBy(asc11(relayToolCalls.createdAt)));
+    const rows = yield* mapDatabaseError15(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq16(relayToolCalls.executionId, executionId))).orderBy(asc11(relayToolCalls.createdAt)));
     return rows.map(toCallRecord);
   });
   const recordResult = Effect20.fn("ToolCallRepository.recordResult")(function* (input) {
     const tenantId2 = yield* current;
-    const callRows = yield* mapDatabaseError16(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq17(relayToolCalls.id, input.result.call_id))).limit(1));
+    const callRows = yield* mapDatabaseError15(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq16(relayToolCalls.id, input.result.call_id))).limit(1));
     if (callRows[0] === undefined)
       return yield* Effect20.fail(new ToolCallNotFound({ id: input.result.call_id }));
-    const existingRows = yield* mapDatabaseError16(db.select().from(relayToolResults).where(predicate(tenantId2, relayToolResults.tenantId, eq17(relayToolResults.toolCallId, input.result.call_id))).limit(1));
+    const existingRows = yield* mapDatabaseError15(db.select().from(relayToolResults).where(predicate(tenantId2, relayToolResults.tenantId, eq16(relayToolResults.toolCallId, input.result.call_id))).limit(1));
     if (existingRows[0] !== undefined) {
       return yield* Effect20.fail(new DuplicateToolResult({ call_id: input.result.call_id }));
     }
-    const rows = yield* mapDatabaseError16(db.insert(relayToolResults).values(toResultInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError15(db.insert(relayToolResults).values(toResultInsert(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect20.fail(new ToolCallRepositoryError({ message: "Tool result insert returned no row" }));
@@ -5191,7 +5215,7 @@ var layer20 = Layer20.effect(Service20, Effect20.gen(function* () {
   });
   const getResult = Effect20.fn("ToolCallRepository.getResult")(function* (callId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError16(db.select().from(relayToolResults).where(predicate(tenantId2, relayToolResults.tenantId, eq17(relayToolResults.toolCallId, callId))).limit(1));
+    const rows = yield* mapDatabaseError15(db.select().from(relayToolResults).where(predicate(tenantId2, relayToolResults.tenantId, eq16(relayToolResults.toolCallId, callId))).limit(1));
     return rows[0] === undefined ? undefined : toResultRecord(rows[0]);
   });
   return Service20.of({ recordCall, getCall, listCalls, recordResult, getResult });
@@ -5272,7 +5296,7 @@ __export(exports_workspace_lease_repository, {
   Service: () => Service21,
   DuplicateWorkspaceLease: () => DuplicateWorkspaceLease
 });
-import { eq as eq18, notInArray } from "drizzle-orm";
+import { eq as eq17, notInArray } from "drizzle-orm";
 import { Context as Context21, Effect as Effect21, Layer as Layer21, Schema as Schema31 } from "effect";
 class WorkspaceLeaseRepositoryError extends Schema31.TaggedErrorClass()("WorkspaceLeaseRepositoryError", {
   message: Schema31.String
@@ -5342,8 +5366,8 @@ var toSnapshotRecord = (row) => ({
   metadata: row.metadataJson,
   created_at: fromPgDate(row.createdAt)
 });
-var mapDatabaseError17 = (effect) => effect.pipe(Effect21.mapError((error) => new WorkspaceLeaseRepositoryError({ message: String(error) })));
-var updateLease = (db, tenantId2, executionId, values) => mapDatabaseError17(db.update(relayWorkspaceLeases).set(values).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq18(relayWorkspaceLeases.executionId, executionId))).returning()).pipe(Effect21.flatMap((rows) => {
+var mapDatabaseError16 = (effect) => effect.pipe(Effect21.mapError((error) => new WorkspaceLeaseRepositoryError({ message: String(error) })));
+var updateLease = (db, tenantId2, executionId, values) => mapDatabaseError16(db.update(relayWorkspaceLeases).set(values).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq17(relayWorkspaceLeases.executionId, executionId))).returning()).pipe(Effect21.flatMap((rows) => {
   const row = rows[0];
   if (row === undefined)
     return Effect21.fail(new WorkspaceLeaseNotFound({ execution_id: executionId }));
@@ -5353,16 +5377,16 @@ var layer21 = Layer21.effect(Service21, Effect21.gen(function* () {
   const db = yield* Service;
   const getByExecution = Effect21.fn("WorkspaceLeaseRepository.getByExecution")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError17(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq18(relayWorkspaceLeases.executionId, id2))).limit(1));
+    const rows = yield* mapDatabaseError16(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq17(relayWorkspaceLeases.executionId, id2))).limit(1));
     return rows[0] === undefined ? undefined : toLeaseRecord(rows[0]);
   });
   const plan = Effect21.fn("WorkspaceLeaseRepository.plan")(function* (input) {
     const tenantId2 = yield* current;
-    const existing = yield* mapDatabaseError17(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq18(relayWorkspaceLeases.executionId, input.executionId), notInArray(relayWorkspaceLeases.status, [...terminalStatuses]))).limit(1));
+    const existing = yield* mapDatabaseError16(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq17(relayWorkspaceLeases.executionId, input.executionId), notInArray(relayWorkspaceLeases.status, [...terminalStatuses]))).limit(1));
     if (existing[0] !== undefined) {
       return yield* Effect21.fail(new DuplicateWorkspaceLease({ execution_id: input.executionId }));
     }
-    const rows = yield* mapDatabaseError17(db.insert(relayWorkspaceLeases).values(toPlanInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError16(db.insert(relayWorkspaceLeases).values(toPlanInsert(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect21.fail(new WorkspaceLeaseRepositoryError({ message: "Workspace lease insert returned no row" }));
@@ -5394,11 +5418,11 @@ var layer21 = Layer21.effect(Service21, Effect21.gen(function* () {
   });
   const recordSnapshot = Effect21.fn("WorkspaceLeaseRepository.recordSnapshot")(function* (input) {
     const tenantId2 = yield* current;
-    const leaseRows = yield* mapDatabaseError17(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq18(relayWorkspaceLeases.executionId, input.executionId))).limit(1));
+    const leaseRows = yield* mapDatabaseError16(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq17(relayWorkspaceLeases.executionId, input.executionId))).limit(1));
     if (leaseRows[0] === undefined) {
       return yield* Effect21.fail(new WorkspaceLeaseNotFound({ execution_id: input.executionId }));
     }
-    const rows = yield* mapDatabaseError17(db.insert(relayWorkspaceSnapshots).values(toSnapshotInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError16(db.insert(relayWorkspaceSnapshots).values(toSnapshotInsert(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect21.fail(new WorkspaceLeaseRepositoryError({ message: "Workspace snapshot insert returned no row" }));