@relayfx/sdk 0.0.26 → 0.0.27

package/dist/index.js

@@ -2196,16 +2196,19 @@ __export(exports_envelope_repository, {
   ackReady: () => ackReady,
   acceptEnvelope: () => acceptEnvelope,
   WaitState: () => WaitState,
+  WaitRow: () => WaitRow,
   WaitNotFound: () => WaitNotFound,
   Service: () => Service9,
+  EnvelopeRow: () => EnvelopeRow,
   EnvelopeRepositoryError: () => EnvelopeRepositoryError,
   EnvelopeReadyState: () => EnvelopeReadyState,
+  EnvelopeReadyRow: () => EnvelopeReadyRow,
   EnvelopeReadyNotFound: () => EnvelopeReadyNotFound,
   EnvelopeReadyClaimMismatch: () => EnvelopeReadyClaimMismatch,
   EnvelopeNotFound: () => EnvelopeNotFound
 });
-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";
+import * as SqlClient6 from "effect/unstable/sql/SqlClient";
 var WaitState = Schema19.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.Store.WaitState"
 });
@@ -2241,87 +2244,98 @@ class EnvelopeReadyClaimMismatch extends Schema19.TaggedErrorClass()("EnvelopeRe
 
 class Service9 extends Context9.Service()("@relayfx/store-sql/EnvelopeRepository") {
 }
+var DbTimestamp = Schema19.Union([Schema19.Date, Schema19.String, Schema19.Number]);
+var NullableDbTimestamp = Schema19.Union([Schema19.Date, Schema19.String, Schema19.Number, Schema19.Null]);
+var NullableString = Schema19.Union([Schema19.String, Schema19.Null]);
+var EnvelopeRow = Schema19.Struct({
+  id: Schema19.String,
+  execution_id: Schema19.String,
+  from_address_id: Schema19.String,
+  to_address_id: Schema19.String,
+  content_json: Schema19.Unknown,
+  wait_json: Schema19.Unknown,
+  correlation_key: NullableString,
+  metadata_json: Schema19.Unknown,
+  created_at: DbTimestamp
+}).annotate({ identifier: "Relay.Envelope.Row" });
+var WaitRow = Schema19.Struct({
+  id: Schema19.String,
+  execution_id: Schema19.String,
+  envelope_id: NullableString,
+  mode: Schema19.String,
+  correlation_key: NullableString,
+  state: Schema19.String,
+  metadata_json: Schema19.Unknown,
+  created_at: DbTimestamp,
+  resolved_at: NullableDbTimestamp
+}).annotate({ identifier: "Relay.Wait.Row" });
+var EnvelopeReadyRow = Schema19.Struct({
+  id: Schema19.String,
+  envelope_id: Schema19.String,
+  route_type: Schema19.String,
+  route_key: Schema19.String,
+  state: Schema19.String,
+  available_at: DbTimestamp,
+  attempt: Schema19.Number,
+  claim_owner: NullableString,
+  claim_expires_at: NullableDbTimestamp,
+  last_error: NullableString,
+  idempotency_key: NullableString,
+  metadata_json: Schema19.Unknown,
+  created_at: DbTimestamp,
+  updated_at: DbTimestamp,
+  claimed_at: NullableDbTimestamp,
+  acknowledged_at: NullableDbTimestamp
+}).annotate({ identifier: "Relay.EnvelopeReady.Row" });
 var metadata3 = (input) => input ?? {};
-var toEnvelopeRow = (tenantId2, input) => ({
-  tenantId: tenantId2,
-  id: input.id,
-  executionId: input.execution_id,
-  fromAddressId: input.from,
-  toAddressId: input.to,
-  contentJson: input.content,
-  metadataJson: metadata3(input.metadata),
-  createdAt: toPgDate(input.created_at),
-  ...input.wait === undefined ? {} : { waitJson: input.wait },
-  ...input.correlation_key === undefined ? {} : { correlationKey: input.correlation_key }
-});
-var toEnvelope = (row) => ({
-  id: row.id,
-  execution_id: row.executionId,
-  from: row.fromAddressId,
-  to: row.toAddressId,
-  content: row.contentJson,
-  ...row.waitJson === null ? {} : { wait: row.waitJson },
-  ...row.correlationKey === null ? {} : { correlation_key: row.correlationKey },
-  metadata: row.metadataJson,
-  created_at: fromPgDate(row.createdAt)
-});
-var toWaitInsert = (tenantId2, input) => {
-  if (input.waitId === undefined || input.envelope.wait === undefined)
-    return;
+var decodeMetadata = (value) => decodeJson(value);
+var toEnvelope = (row) => {
+  const wait = row.wait_json === null || row.wait_json === undefined ? undefined : decodeJson(row.wait_json);
   return {
-    tenantId: tenantId2,
-    id: input.waitId,
-    executionId: input.envelope.execution_id,
-    envelopeId: input.envelope.id,
-    mode: input.envelope.wait.mode,
-    metadataJson: metadata3(input.envelope.wait.metadata),
-    createdAt: toPgDate(input.envelope.created_at),
-    ...input.envelope.wait.correlation_key === undefined ? {} : { correlationKey: input.envelope.wait.correlation_key }
+    id: exports_ids_schema.EnvelopeId.make(row.id),
+    execution_id: exports_ids_schema.ExecutionId.make(row.execution_id),
+    from: exports_ids_schema.AddressId.make(row.from_address_id),
+    to: exports_ids_schema.AddressId.make(row.to_address_id),
+    content: decodeJson(row.content_json),
+    ...wait === undefined ? {} : { wait },
+    ...row.correlation_key === null ? {} : { correlation_key: row.correlation_key },
+    metadata: decodeMetadata(row.metadata_json),
+    created_at: fromDbTimestamp(row.created_at)
   };
 };
 var toWaitRecord = (row) => {
-  const resolvedAt = fromNullablePgDate(row.resolvedAt);
+  const resolvedAt = fromNullableDbTimestamp(row.resolved_at);
   return {
-    id: row.id,
-    executionId: row.executionId,
-    ...row.envelopeId === null ? {} : { envelopeId: row.envelopeId },
+    id: exports_ids_schema.WaitId.make(row.id),
+    executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
+    ...row.envelope_id === null ? {} : { envelopeId: exports_ids_schema.EnvelopeId.make(row.envelope_id) },
     mode: row.mode,
-    ...row.correlationKey === null ? {} : { correlationKey: row.correlationKey },
+    ...row.correlation_key === null ? {} : { correlationKey: row.correlation_key },
     state: row.state,
-    metadata: row.metadataJson,
-    createdAt: fromPgDate(row.createdAt),
+    metadata: decodeMetadata(row.metadata_json),
+    createdAt: fromDbTimestamp(row.created_at),
     ...resolvedAt === undefined ? {} : { resolvedAt }
   };
 };
-var toReadyInsert = (tenantId2, envelope, input) => ({
-  tenantId: tenantId2,
-  id: input.id,
-  envelopeId: envelope.id,
-  routeType: input.routeType,
-  routeKey: input.routeKey,
-  availableAt: toPgDate(input.availableAt),
-  metadataJson: metadata3(input.metadata),
-  ...input.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey }
-});
 var toReadyRecord = (row) => {
-  const claimExpiresAt = fromNullablePgDate(row.claimExpiresAt);
-  const claimedAt = fromNullablePgDate(row.claimedAt);
-  const acknowledgedAt = fromNullablePgDate(row.acknowledgedAt);
+  const claimExpiresAt = fromNullableDbTimestamp(row.claim_expires_at);
+  const claimedAt = fromNullableDbTimestamp(row.claimed_at);
+  const acknowledgedAt = fromNullableDbTimestamp(row.acknowledged_at);
   return {
-    id: row.id,
-    envelopeId: row.envelopeId,
-    routeType: row.routeType,
-    routeKey: row.routeKey,
+    id: exports_ids_schema.EnvelopeReadyId.make(row.id),
+    envelopeId: exports_ids_schema.EnvelopeId.make(row.envelope_id),
+    routeType: row.route_type,
+    routeKey: row.route_key,
     state: row.state,
-    availableAt: fromPgDate(row.availableAt),
+    availableAt: fromDbTimestamp(row.available_at),
     attempt: row.attempt,
-    ...row.claimOwner === null ? {} : { claimOwner: row.claimOwner },
+    ...row.claim_owner === null ? {} : { claimOwner: row.claim_owner },
     ...claimExpiresAt === undefined ? {} : { claimExpiresAt },
-    ...row.lastError === null ? {} : { lastError: row.lastError },
-    ...row.idempotencyKey === null ? {} : { idempotencyKey: row.idempotencyKey },
-    metadata: row.metadataJson,
-    createdAt: fromPgDate(row.createdAt),
-    updatedAt: fromPgDate(row.updatedAt),
+    ...row.last_error === null ? {} : { lastError: row.last_error },
+    ...row.idempotency_key === null ? {} : { idempotencyKey: row.idempotency_key },
+    metadata: decodeMetadata(row.metadata_json),
+    createdAt: fromDbTimestamp(row.created_at),
+    updatedAt: fromDbTimestamp(row.updated_at),
     ...claimedAt === undefined ? {} : { claimedAt },
     ...acknowledgedAt === undefined ? {} : { acknowledgedAt }
   };
@@ -2334,50 +2348,85 @@ var accepted = (input) => ({
 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 : 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 mapDatabaseError5 = (effect) => effect.pipe(Effect9.mapError((error) => new EnvelopeRepositoryError({ message: String(error) })));
+var toRepositoryError2 = (error) => new EnvelopeRepositoryError({ message: String(error) });
+var decodeEnvelopeRow = (row) => Schema19.decodeUnknownEffect(EnvelopeRow)(row).pipe(Effect9.mapError(toRepositoryError2));
+var decodeWaitRow = (row) => Schema19.decodeUnknownEffect(WaitRow)(row).pipe(Effect9.mapError(toRepositoryError2));
+var decodeReadyRow = (row) => Schema19.decodeUnknownEffect(EnvelopeReadyRow)(row).pipe(Effect9.mapError(toRepositoryError2));
+var waitColumnsText = "id, execution_id, envelope_id, mode, correlation_key, state, metadata_json, created_at, resolved_at";
+var readyColumnsText = "id, envelope_id, route_type, route_key, state, available_at, attempt, claim_owner, claim_expires_at, last_error, idempotency_key, metadata_json, created_at, updated_at, claimed_at, acknowledged_at";
+var envelopeColumnsText = "id, execution_id, from_address_id, to_address_id, content_json, wait_json, correlation_key, metadata_json, created_at";
 var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
-  const db = yield* Service;
+  const sql5 = yield* SqlClient6.SqlClient;
+  const ts = (millis) => timestampParam(sql5, millis);
+  const waitColumns = sql5.literal(waitColumnsText);
+  const readyColumns = sql5.literal(readyColumnsText);
+  const envelopeColumns = sql5.literal(envelopeColumnsText);
+  const selectWaitById = (tenantId2, id2) => sql5`
+      SELECT ${waitColumns}
+      FROM relay_waits
+      WHERE tenant_id = ${tenantId2} AND id = ${id2}
+    `;
+  const selectReadyById = (tenantId2, id2) => sql5`
+      SELECT ${readyColumns}
+      FROM relay_envelope_ready
+      WHERE tenant_id = ${tenantId2} AND id = ${id2}
+    `;
+  const getWaitRow = (tenantId2, id2) => Effect9.gen(function* () {
+    const rows = yield* selectWaitById(tenantId2, id2).pipe(Effect9.mapError(toRepositoryError2));
+    return rows[0] === undefined ? undefined : yield* decodeWaitRow(rows[0]);
+  });
+  const getReadyRow = (tenantId2, id2) => Effect9.gen(function* () {
+    const rows = yield* selectReadyById(tenantId2, id2).pipe(Effect9.mapError(toRepositoryError2));
+    return rows[0] === undefined ? undefined : yield* decodeReadyRow(rows[0]);
+  });
   const acceptEnvelope = Effect9.fn("EnvelopeRepository.acceptEnvelope")(function* (input) {
     const tenantId2 = yield* current;
-    const wait = toWaitInsert(tenantId2, input);
-    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);
+    const envelope = input.envelope;
+    const wait = envelope.wait;
+    const waitId = input.waitId;
+    const ready = input.ready;
+    yield* sql5.withTransaction(Effect9.gen(function* () {
+      yield* sql5`
+              INSERT INTO relay_envelopes (tenant_id, id, execution_id, from_address_id, to_address_id, content_json, wait_json, correlation_key, metadata_json, created_at)
+              VALUES (${tenantId2}, ${envelope.id}, ${envelope.execution_id}, ${envelope.from}, ${envelope.to}, ${encodeJson(envelope.content)}, ${wait === undefined ? null : encodeJson(wait)}, ${envelope.correlation_key ?? null}, ${encodeJson(metadata3(envelope.metadata))}, ${ts(envelope.created_at)})
+            `;
+      if (waitId !== undefined && wait !== undefined) {
+        yield* sql5`
+                INSERT INTO relay_waits (tenant_id, id, execution_id, envelope_id, mode, correlation_key, state, metadata_json, created_at)
+                VALUES (${tenantId2}, ${waitId}, ${envelope.execution_id}, ${envelope.id}, ${wait.mode}, ${wait.correlation_key ?? null}, 'open', ${encodeJson(metadata3(wait.metadata))}, ${ts(envelope.created_at)})
+              `;
       }
-      if (input.ready !== undefined) {
-        yield* tx.insert(relayEnvelopeReady).values(toReadyInsert(tenantId2, input.envelope, input.ready));
+      if (ready !== undefined) {
+        yield* sql5`
+                INSERT INTO relay_envelope_ready (tenant_id, id, envelope_id, route_type, route_key, state, available_at, attempt, idempotency_key, metadata_json, created_at, updated_at)
+                VALUES (${tenantId2}, ${ready.id}, ${envelope.id}, ${ready.routeType}, ${ready.routeKey}, 'ready', ${ts(ready.availableAt)}, 0, ${ready.idempotencyKey ?? null}, ${encodeJson(metadata3(ready.metadata))}, ${ts(envelope.created_at)}, ${ts(envelope.created_at)})
+              `;
       }
-    })));
+    })).pipe(Effect9.mapError(toRepositoryError2));
     return accepted(input);
   });
   const getEnvelope = Effect9.fn("EnvelopeRepository.getEnvelope")(function* (id2) {
     const tenantId2 = yield* current;
-    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 rows = yield* sql5`
+        SELECT ${envelopeColumns}
+        FROM relay_envelopes
+        WHERE tenant_id = ${tenantId2} AND id = ${id2}
+      `.pipe(Effect9.mapError(toRepositoryError2));
+    return rows[0] === undefined ? undefined : toEnvelope(yield* decodeEnvelopeRow(rows[0]));
   });
   const getWait = Effect9.fn("EnvelopeRepository.getWait")(function* (id2) {
     const tenantId2 = yield* current;
-    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 row = yield* getWaitRow(tenantId2, id2);
+    return row === undefined ? undefined : toWaitRecord(row);
   });
   const createWait = Effect9.fn("EnvelopeRepository.createWait")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError5(db.insert(relayWaits).values({
-      tenantId: tenantId2,
-      id: input.waitId,
-      executionId: input.executionId,
-      mode: input.mode,
-      metadataJson: metadata3(input.metadata),
-      createdAt: toPgDate(input.createdAt),
-      ...input.correlationKey === undefined ? {} : { correlationKey: input.correlationKey }
-    }).returning());
-    const row = rows[0];
+    yield* sql5`
+        INSERT INTO relay_waits (tenant_id, id, execution_id, envelope_id, mode, correlation_key, state, metadata_json, created_at)
+        VALUES (${tenantId2}, ${input.waitId}, ${input.executionId}, ${null}, ${input.mode}, ${input.correlationKey ?? null}, 'open', ${encodeJson(metadata3(input.metadata))}, ${ts(input.createdAt)})
+      `.pipe(Effect9.mapError(toRepositoryError2));
+    const row = yield* getWaitRow(tenantId2, input.waitId);
     if (row === undefined) {
       return yield* Effect9.fail(new EnvelopeRepositoryError({ message: `Wait ${input.waitId} was not persisted` }));
     }
@@ -2385,79 +2434,232 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
   });
   const listWaits = Effect9.fn("EnvelopeRepository.listWaits")(function* (input) {
     const tenantId2 = yield* current;
-    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 conditions = [
+      sql5`tenant_id = ${tenantId2}`,
+      ...input.executionId === undefined ? [] : [sql5`execution_id = ${input.executionId}`],
+      ...input.state === undefined ? [] : [sql5`state = ${input.state}`]
+    ];
+    const rows = yield* sql5`
+        SELECT ${waitColumns}
+        FROM relay_waits
+        WHERE ${sql5.and(conditions)}
+        ORDER BY created_at DESC, id DESC
+        LIMIT ${sql5.literal(String(listWaitsLimit(input)))}
+      `.pipe(Effect9.mapError(toRepositoryError2));
+    const records = [];
+    for (const row of rows) {
+      records.push(toWaitRecord(yield* decodeWaitRow(row)));
+    }
+    return records;
+  });
+  const claimablePredicate = (input) => sql5.or([
+    sql5.and([sql5`state = 'ready'`, sql5`available_at <= ${ts(input.now)}`]),
+    sql5.and([
+      sql5`state = 'claimed'`,
+      sql5`claim_expires_at IS NOT NULL`,
+      sql5`claim_expires_at <= ${ts(input.now)}`
+    ])
+  ]);
+  const claimConditions = (tenantId2, input) => sql5.and([
+    sql5`tenant_id = ${tenantId2}`,
+    sql5`route_type = ${input.routeType}`,
+    ...input.routeKey === undefined ? [] : [sql5`route_key = ${input.routeKey}`],
+    claimablePredicate(input)
+  ]);
+  const claimUpdateSet = (input) => sql5`
+      state = 'claimed',
+      claim_owner = ${input.workerId},
+      claim_expires_at = ${ts(input.claimExpiresAt)},
+      claimed_at = ${ts(input.now)},
+      updated_at = ${ts(input.now)},
+      attempt = attempt + 1
+    `;
+  const runClaimReady = sql5.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql5.withTransaction(Effect9.gen(function* () {
+      const candidates = yield* sql5`
+              SELECT id FROM relay_envelope_ready
+              WHERE ${claimConditions(tenantId2, input)}
+              ORDER BY available_at ASC, created_at ASC
+              LIMIT 1
+              FOR UPDATE
+            `;
+      const candidate = candidates[0];
+      if (candidate === undefined)
+        return [];
+      yield* sql5`
+              UPDATE relay_envelope_ready
+              SET ${claimUpdateSet(input)}
+              WHERE tenant_id = ${tenantId2} AND id = ${candidate.id} AND ${claimablePredicate(input)}
+            `;
+      const rows = yield* sql5`
+              SELECT ${readyColumns}
+              FROM relay_envelope_ready
+              WHERE tenant_id = ${tenantId2} AND id = ${candidate.id}
+            `;
+      const row = rows[0];
+      if (row === undefined || row.state !== "claimed" || row.claim_owner !== input.workerId)
+        return [];
+      return rows;
+    })),
+    orElse: () => (tenantId2, input) => Effect9.gen(function* () {
+      const candidates = yield* sql5`
+            SELECT id FROM relay_envelope_ready
+            WHERE ${claimConditions(tenantId2, input)}
+            ORDER BY available_at ASC, created_at ASC
+            LIMIT 1
+          `;
+      const candidate = candidates[0];
+      if (candidate === undefined)
+        return [];
+      return yield* sql5`
+            UPDATE relay_envelope_ready
+            SET ${claimUpdateSet(input)}
+            WHERE tenant_id = ${tenantId2} AND id = ${candidate.id} AND ${claimablePredicate(input)}
+            RETURNING ${readyColumns}
+          `;
+    })
   });
   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, 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),
-      claimedAt: toPgDate(input.now),
-      updatedAt: toPgDate(input.now),
-      attempt: sql5`${relayEnvelopeReady.attempt} + 1`
-    }).where(predicate(tenantId2, relayEnvelopeReady.tenantId, inArray(relayEnvelopeReady.id, candidate))).returning());
-    return rows[0] === undefined ? undefined : toReadyRecord(rows[0]);
+    const rows = yield* runClaimReady(tenantId2, input).pipe(Effect9.mapError(toRepositoryError2));
+    return rows[0] === undefined ? undefined : toReadyRecord(yield* decodeReadyRow(rows[0]));
+  });
+  const runReleaseReady = sql5.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql5.withTransaction(Effect9.gen(function* () {
+      const locked = yield* sql5`
+              SELECT ${readyColumns}
+              FROM relay_envelope_ready
+              WHERE tenant_id = ${tenantId2} AND id = ${input.id}
+              FOR UPDATE
+            `;
+      const current2 = locked[0];
+      if (current2 === undefined || current2.state !== "claimed" || current2.claim_owner !== input.workerId) {
+        return [];
+      }
+      yield* sql5`
+              UPDATE relay_envelope_ready
+              SET state = 'ready',
+                  available_at = ${ts(input.nextAvailableAt)},
+                  claim_owner = NULL,
+                  claim_expires_at = NULL,
+                  last_error = ${input.error ?? null},
+                  updated_at = ${ts(input.nextAvailableAt)}
+              WHERE tenant_id = ${tenantId2} AND id = ${input.id}
+            `;
+      return yield* selectReadyById(tenantId2, input.id);
+    })),
+    orElse: () => (tenantId2, input) => sql5`
+        UPDATE relay_envelope_ready
+        SET state = 'ready',
+            available_at = ${ts(input.nextAvailableAt)},
+            claim_owner = NULL,
+            claim_expires_at = NULL,
+            last_error = ${input.error ?? null},
+            updated_at = ${ts(input.nextAvailableAt)}
+        WHERE tenant_id = ${tenantId2} AND id = ${input.id} AND claim_owner = ${input.workerId} AND state = 'claimed'
+        RETURNING ${readyColumns}
+      `
   });
   const releaseReady = Effect9.fn("EnvelopeRepository.releaseReady")(function* (input) {
     const tenantId2 = yield* current;
-    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, 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);
-    const current2 = yield* getReadyRow(db, tenantId2, input.id);
+    const rows = yield* runReleaseReady(tenantId2, input).pipe(Effect9.mapError(toRepositoryError2));
+    if (rows[0] !== undefined)
+      return toReadyRecord(yield* decodeReadyRow(rows[0]));
+    const current2 = yield* getReadyRow(tenantId2, input.id);
     if (current2 === undefined)
       return yield* Effect9.fail(new EnvelopeReadyNotFound({ id: input.id }));
-    if (current2.state === "acknowledged" && current2.claimOwner === input.workerId)
+    if (current2.state === "acknowledged" && current2.claim_owner === input.workerId)
       return toReadyRecord(current2);
     return yield* Effect9.fail(new EnvelopeReadyClaimMismatch({ id: input.id, worker_id: input.workerId }));
   });
+  const runAckReady = sql5.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql5.withTransaction(Effect9.gen(function* () {
+      const locked = yield* sql5`
+              SELECT ${readyColumns}
+              FROM relay_envelope_ready
+              WHERE tenant_id = ${tenantId2} AND id = ${input.id}
+              FOR UPDATE
+            `;
+      const current2 = locked[0];
+      if (current2 === undefined || current2.state !== "claimed" || current2.claim_owner !== input.workerId) {
+        return [];
+      }
+      yield* sql5`
+              UPDATE relay_envelope_ready
+              SET state = 'acknowledged',
+                  acknowledged_at = ${ts(input.now)},
+                  updated_at = ${ts(input.now)}
+              WHERE tenant_id = ${tenantId2} AND id = ${input.id}
+            `;
+      return yield* selectReadyById(tenantId2, input.id);
+    })),
+    orElse: () => (tenantId2, input) => sql5`
+        UPDATE relay_envelope_ready
+        SET state = 'acknowledged',
+            acknowledged_at = ${ts(input.now)},
+            updated_at = ${ts(input.now)}
+        WHERE tenant_id = ${tenantId2} AND id = ${input.id} AND claim_owner = ${input.workerId} AND state = 'claimed'
+        RETURNING ${readyColumns}
+      `
+  });
   const ackReady = Effect9.fn("EnvelopeRepository.ackReady")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError5(db.update(relayEnvelopeReady).set({
-      state: "acknowledged",
-      acknowledgedAt: toPgDate(input.now),
-      updatedAt: toPgDate(input.now)
-    }).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);
-    const current2 = yield* getReadyRow(db, tenantId2, input.id);
+    const rows = yield* runAckReady(tenantId2, input).pipe(Effect9.mapError(toRepositoryError2));
+    if (rows[0] !== undefined)
+      return toReadyRecord(yield* decodeReadyRow(rows[0]));
+    const current2 = yield* getReadyRow(tenantId2, input.id);
     if (current2 === undefined)
       return yield* Effect9.fail(new EnvelopeReadyNotFound({ id: input.id }));
-    if (current2.state === "acknowledged" && current2.claimOwner === input.workerId)
+    if (current2.state === "acknowledged" && current2.claim_owner === input.workerId)
       return toReadyRecord(current2);
     return yield* Effect9.fail(new EnvelopeReadyClaimMismatch({ id: input.id, worker_id: input.workerId }));
   });
+  const runCompleteWait = sql5.onDialectOrElse({
+    mysql: () => (tenantId2, input, merged) => sql5.withTransaction(Effect9.gen(function* () {
+      const locked = yield* sql5`
+              SELECT ${waitColumns}
+              FROM relay_waits
+              WHERE tenant_id = ${tenantId2} AND id = ${input.waitId}
+              FOR UPDATE
+            `;
+      const current2 = locked[0];
+      if (current2 === undefined || current2.state !== "open")
+        return [];
+      yield* sql5`
+              UPDATE relay_waits
+              SET state = ${input.state},
+                  resolved_at = ${ts(input.completedAt)},
+                  metadata_json = ${encodeJson(merged)}
+              WHERE tenant_id = ${tenantId2} AND id = ${input.waitId}
+            `;
+      return yield* selectWaitById(tenantId2, input.waitId);
+    })),
+    orElse: () => (tenantId2, input, merged) => sql5`
+        UPDATE relay_waits
+        SET state = ${input.state},
+            resolved_at = ${ts(input.completedAt)},
+            metadata_json = ${encodeJson(merged)}
+        WHERE tenant_id = ${tenantId2} AND id = ${input.waitId} AND state = 'open'
+        RETURNING ${waitColumns}
+      `
+  });
   const completeWait = Effect9.fn("EnvelopeRepository.completeWait")(function* (input) {
     const tenantId2 = yield* current;
-    const current2 = yield* getWaitRow(db, tenantId2, input.waitId);
+    const current2 = yield* getWaitRow(tenantId2, input.waitId);
     if (current2 === undefined)
       return yield* Effect9.fail(new WaitNotFound({ id: input.waitId }));
-    if (current2.state !== "open")
-      return { wait: toWaitRecord(current2), transitioned: false };
-    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, 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);
+    const currentRecord = toWaitRecord(current2);
+    if (currentRecord.state !== "open")
+      return { wait: currentRecord, transitioned: false };
+    const merged = { ...currentRecord.metadata, ...metadata3(input.metadata) };
+    const rows = yield* runCompleteWait(tenantId2, input, merged).pipe(Effect9.mapError(toRepositoryError2));
+    if (rows[0] === undefined) {
+      const latest = yield* getWaitRow(tenantId2, input.waitId);
       if (latest === undefined)
         return yield* Effect9.fail(new WaitNotFound({ id: input.waitId }));
       return { wait: toWaitRecord(latest), transitioned: false };
     }
-    return { wait: toWaitRecord(row), transitioned: true };
+    return { wait: toWaitRecord(yield* decodeWaitRow(rows[0])), transitioned: true };
   });
   const resolveWait = Effect9.fn("EnvelopeRepository.resolveWait")(function* (input) {
     const result = yield* completeWait({
@@ -2481,8 +2683,6 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
     resolveWait
   });
 }));
-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;
@@ -2692,7 +2892,7 @@ __export(exports_execution_event_repository, {
   ExecutionEventCursorNotFound: () => ExecutionEventCursorNotFound,
   DuplicateExecutionEvent: () => DuplicateExecutionEvent
 });
-import { asc as asc6, desc as desc3, eq as eq7, gt, max, or as or2, sql as sql6 } from "drizzle-orm";
+import { asc as asc5, desc as desc2, eq as eq6, gt, max, or, sql as sql5 } 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";
 
@@ -2756,7 +2956,7 @@ var toEvent = (row) => ({
   data: row.dataJson,
   created_at: fromPgDate(row.createdAt)
 });
-var mapDatabaseError6 = (effect) => effect.pipe(Effect10.mapError((error) => new ExecutionEventRepositoryError({ message: String(error) })));
+var mapDatabaseError5 = (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) => {
@@ -2802,7 +3002,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* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.execution_id))).orderBy(desc3(relayExecutionEvents.sequence)).limit(1));
+    const previousRows = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.execution_id))).orderBy(desc2(relayExecutionEvents.sequence)).limit(1));
     const previous = previousRows[0];
     if (previous !== undefined && input.sequence === previous.sequence) {
       return yield* Effect10.fail(duplicateError(input));
@@ -2814,11 +3014,11 @@ var layer10 = Layer10.effect(Service10, Effect10.gen(function* () {
         previous_sequence: previous.sequence
       }));
     }
-    const duplicateCursorRows = yield* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.cursor, input.cursor))).limit(1));
+    const duplicateCursorRows = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.cursor, input.cursor))).limit(1));
     if (duplicateCursorRows[0] !== undefined) {
       return yield* Effect10.fail(duplicateError(input));
     }
-    const rows = yield* mapDatabaseError6(db.insert(relayExecutionEvents).values(toRow(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError5(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" }));
@@ -2828,49 +3028,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* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId))).orderBy(asc6(relayExecutionEvents.sequence)).limit(listLimit(input)));
+      const rows2 = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId))).orderBy(asc5(relayExecutionEvents.sequence)).limit(listLimit(input)));
       return rows2.map(toEvent);
     }
-    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 cursorRows = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId), eq6(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* 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)));
+    const rows = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId), gt(relayExecutionEvents.sequence, cursorRow.sequence))).orderBy(asc5(relayExecutionEvents.sequence)).limit(listLimit(input)));
     return rows.map(toEvent);
   });
   const findBySequenceOrCursor = Effect10.fn("ExecutionEventRepository.findBySequenceOrCursor")(function* (input) {
     const tenantId2 = yield* current;
-    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 rows = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId), or(eq6(relayExecutionEvents.sequence, input.sequence), eq6(relayExecutionEvents.cursor, input.cursor)))).orderBy(asc5(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* mapDatabaseError6(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, input.executionId), eq7(relayExecutionEvents.cursor, input.cursor))).limit(1));
+    const rows = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId), eq6(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* 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 rows = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId), eq6(relayExecutionEvents.type, input.type), gt(relayExecutionEvents.sequence, input.afterSequence))).orderBy(asc5(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* mapDatabaseError6(db.select({ value: max(relayExecutionEvents.sequence) }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, executionId))));
+    const rows = yield* mapDatabaseError5(db.select({ value: max(relayExecutionEvents.sequence) }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(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* mapDatabaseError6(db.select({
-      value: sql6`sum(
+    const rows = yield* mapDatabaseError5(db.select({
+      value: sql5`sum(
               coalesce((${relayExecutionEvents.dataJson} ->> 'input_tokens')::bigint, 0)
               + coalesce((${relayExecutionEvents.dataJson} ->> 'output_tokens')::bigint, 0)
             )`
-    }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq7(relayExecutionEvents.executionId, executionId), eq7(relayExecutionEvents.type, usageReportedEventType))));
+    }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, executionId), eq6(relayExecutionEvents.type, usageReportedEventType))));
     const value = rows[0]?.value;
     return value === null || value === undefined ? 0 : Number(value);
   });
@@ -2881,7 +3081,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* 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));
+    const rows = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(input.afterSequence === undefined ? predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId)) : predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId), gt(relayExecutionEvents.sequence, input.afterSequence))).orderBy(asc5(relayExecutionEvents.sequence)).limit(input.limit));
     return rows.map(toEvent);
   });
   return Service10.of({
@@ -2997,12 +3197,13 @@ __export(exports_execution_repository, {
   get: () => get5,
   create: () => create2,
   Service: () => Service11,
+  ExecutionRow: () => ExecutionRow,
   ExecutionRepositoryError: () => ExecutionRepositoryError,
   ExecutionNotFound: () => ExecutionNotFound,
   DuplicateExecution: () => DuplicateExecution
 });
-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";
+import * as SqlClient8 from "effect/unstable/sql/SqlClient";
 class ExecutionRepositoryError extends Schema21.TaggedErrorClass()("ExecutionRepositoryError", {
   message: Schema21.String
 }) {
@@ -3020,6 +3221,19 @@ class ExecutionNotFound extends Schema21.TaggedErrorClass()("ExecutionNotFound",
 
 class Service11 extends Context11.Service()("@relayfx/store-sql/ExecutionRepository") {
 }
+var ExecutionRow = Schema21.Struct({
+  id: Schema21.String,
+  root_address_id: Schema21.String,
+  session_id: Schema21.NullishOr(Schema21.String),
+  status: Schema21.String,
+  agent_definition_id: Schema21.NullishOr(Schema21.String),
+  agent_definition_revision: Schema21.NullishOr(Schema21.Number),
+  agent_definition_snapshot_json: Schema21.NullishOr(Schema21.Unknown),
+  agent_definition_tool_input_schema_digests_json: Schema21.Unknown,
+  metadata_json: Schema21.Unknown,
+  created_at: Schema21.Union([Schema21.Date, Schema21.String, Schema21.Number]),
+  updated_at: Schema21.Union([Schema21.Date, Schema21.String, Schema21.Number])
+}).annotate({ identifier: "Relay.Execution.Row" });
 var metadata4 = (input) => input ?? {};
 var nonEmptyDigests2 = (digests) => digests === undefined || Object.keys(digests).length === 0 ? undefined : structuredClone(digests);
 var hasCompleteAgentDefinitionPin = (input) => {
@@ -3052,37 +3266,25 @@ var cloneRecord3 = (record2) => ({
   ...record2.agentDefinitionSnapshot === undefined ? {} : { agentDefinitionSnapshot: cloneAgentDefinition(record2.agentDefinitionSnapshot) },
   ...record2.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: structuredClone(record2.agentDefinitionToolInputSchemaDigests) }
 });
-var toInsert2 = (tenantId2, input) => ({
-  tenantId: tenantId2,
-  id: input.id,
-  rootAddressId: input.rootAddressId,
-  ...input.sessionId === undefined ? {} : { sessionId: input.sessionId },
-  status: input.status,
-  ...input.agentDefinitionId === undefined ? {} : { agentDefinitionId: input.agentDefinitionId },
-  ...input.agentDefinitionRevision === undefined ? {} : { agentDefinitionRevision: input.agentDefinitionRevision },
-  ...input.agentDefinitionSnapshot === undefined ? {} : { agentDefinitionSnapshotJson: cloneAgentDefinition(input.agentDefinitionSnapshot) },
-  ...input.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigestsJson: input.agentDefinitionToolInputSchemaDigests },
-  metadataJson: metadata4(input.metadata),
-  createdAt: toPgDate(input.createdAt),
-  updatedAt: toPgDate(input.createdAt)
-});
 var toRecord5 = (row) => {
-  const agentDefinitionToolInputSchemaDigests = nonEmptyDigests2(row.agentDefinitionToolInputSchemaDigestsJson);
+  const snapshotJson = row.agent_definition_snapshot_json;
+  const digests = nonEmptyDigests2(decodeJson(row.agent_definition_tool_input_schema_digests_json));
   return {
-    id: row.id,
-    rootAddressId: row.rootAddressId,
-    ...row.sessionId === null || row.sessionId === undefined ? {} : { sessionId: row.sessionId },
+    id: exports_ids_schema.ExecutionId.make(row.id),
+    rootAddressId: exports_ids_schema.AddressId.make(row.root_address_id),
+    ...row.session_id === null || row.session_id === undefined ? {} : { sessionId: exports_ids_schema.SessionId.make(row.session_id) },
     status: row.status,
-    ...row.agentDefinitionId === null || row.agentDefinitionId === undefined ? {} : { agentDefinitionId: row.agentDefinitionId },
-    ...row.agentDefinitionRevision === null || row.agentDefinitionRevision === undefined ? {} : { agentDefinitionRevision: row.agentDefinitionRevision },
-    ...row.agentDefinitionSnapshotJson === null || row.agentDefinitionSnapshotJson === undefined ? {} : { agentDefinitionSnapshot: cloneAgentDefinition(row.agentDefinitionSnapshotJson) },
-    ...agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigests },
-    metadata: row.metadataJson,
-    createdAt: fromPgDate(row.createdAt),
-    updatedAt: fromPgDate(row.updatedAt)
+    ...row.agent_definition_id === null || row.agent_definition_id === undefined ? {} : { agentDefinitionId: exports_ids_schema.AgentDefinitionId.make(row.agent_definition_id) },
+    ...row.agent_definition_revision === null || row.agent_definition_revision === undefined ? {} : { agentDefinitionRevision: row.agent_definition_revision },
+    ...snapshotJson === null || snapshotJson === undefined ? {} : { agentDefinitionSnapshot: cloneAgentDefinition(decodeJson(snapshotJson)) },
+    ...digests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: digests },
+    metadata: decodeJson(row.metadata_json),
+    createdAt: fromDbTimestamp(row.created_at),
+    updatedAt: fromDbTimestamp(row.updated_at)
   };
 };
-var mapDatabaseError7 = (effect) => effect.pipe(Effect11.mapError((error) => new ExecutionRepositoryError({ message: String(error) })));
+var toRepositoryError3 = (error) => new ExecutionRepositoryError({ message: String(error) });
+var decodeRow2 = (row) => Schema21.decodeUnknownEffect(ExecutionRow)(row).pipe(Effect11.mapError(toRepositoryError3));
 var maxListLimit2 = 100;
 var defaultListLimit = 50;
 var listLimit2 = (input) => Math.min(Math.max(input.limit ?? defaultListLimit, 1), maxListLimit2);
@@ -3092,51 +3294,127 @@ 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 : 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 sql6 = yield* SqlClient8.SqlClient;
+  const columns = sql6.literal([
+    "id",
+    "root_address_id",
+    "session_id",
+    "status",
+    "agent_definition_id",
+    "agent_definition_revision",
+    "agent_definition_snapshot_json",
+    "agent_definition_tool_input_schema_digests_json",
+    "metadata_json",
+    "created_at",
+    "updated_at"
+  ].join(", "));
+  const selectByKey = (tenantId2, id2) => sql6`
+      SELECT ${columns}
+      FROM relay_executions
+      WHERE tenant_id = ${tenantId2} AND id = ${id2}
+    `;
+  const insertStatement = (tenantId2, input) => sql6`
+      INSERT INTO relay_executions (
+        tenant_id, ${columns}
+      )
+      VALUES (
+        ${tenantId2},
+        ${input.id},
+        ${input.rootAddressId},
+        ${input.sessionId ?? null},
+        ${input.status},
+        ${input.agentDefinitionId ?? null},
+        ${input.agentDefinitionRevision ?? null},
+        ${input.agentDefinitionSnapshot === undefined ? null : encodeJson(input.agentDefinitionSnapshot)},
+        ${encodeJson(input.agentDefinitionToolInputSchemaDigests ?? {})},
+        ${encodeJson(metadata4(input.metadata))},
+        ${timestampParam(sql6, input.createdAt)},
+        ${timestampParam(sql6, input.createdAt)}
+      )
+    `;
+  const insertExecution = sql6.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql6.withTransaction(Effect11.gen(function* () {
+      yield* insertStatement(tenantId2, input);
+      return yield* selectByKey(tenantId2, input.id);
+    })),
+    orElse: () => (tenantId2, input) => sql6`
+        ${insertStatement(tenantId2, input)}
+        RETURNING ${columns}
+      `
+  });
+  const updateStatement = (tenantId2, input) => sql6`
+      UPDATE relay_executions
+      SET status = ${input.status},
+        metadata_json = ${encodeJson(metadata4(input.metadata))},
+        updated_at = ${timestampParam(sql6, input.updatedAt)}
+      WHERE tenant_id = ${tenantId2} AND id = ${input.id}
+    `;
+  const updateExecution = sql6.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql6.withTransaction(Effect11.gen(function* () {
+      yield* updateStatement(tenantId2, input);
+      return yield* selectByKey(tenantId2, input.id);
+    })),
+    orElse: () => (tenantId2, input) => sql6`
+        ${updateStatement(tenantId2, input)}
+        RETURNING ${columns}
+      `
+  });
+  const listConditions = (tenantId2, input) => [
+    sql6`tenant_id = ${tenantId2}`,
+    ...input.rootAddressId === undefined ? [] : [sql6`root_address_id = ${input.rootAddressId}`],
+    ...input.sessionId === undefined ? [] : [sql6`session_id = ${input.sessionId}`],
+    ...input.status === undefined ? [] : [sql6`status = ${input.status}`],
+    ...input.cursor === undefined ? [] : [
+      sql6.or([
+        sql6`updated_at < ${timestampParam(sql6, input.cursor.updatedAt)}`,
+        sql6.and([
+          sql6`updated_at = ${timestampParam(sql6, input.cursor.updatedAt)}`,
+          sql6`id < ${input.cursor.id}`
+        ])
+      ])
+    ]
+  ];
   const create2 = Effect11.fn("ExecutionRepository.create")(function* (input) {
     const tenantId2 = yield* current;
     yield* validateCreateInput(input);
-    const existing = yield* mapDatabaseError7(db.select().from(relayExecutions).where(predicate(tenantId2, relayExecutions.tenantId, eq8(relayExecutions.id, input.id))).limit(1));
+    const existing = yield* selectByKey(tenantId2, input.id).pipe(Effect11.mapError(toRepositoryError3));
     if (existing[0] !== undefined)
       return yield* Effect11.fail(new DuplicateExecution({ id: input.id }));
-    const rows = yield* mapDatabaseError7(db.insert(relayExecutions).values(toInsert2(tenantId2, input)).returning());
+    const rows = yield* insertExecution(tenantId2, input).pipe(Effect11.mapError(toRepositoryError3));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect11.fail(new ExecutionRepositoryError({ message: "Execution insert returned no row" }));
     }
-    return toRecord5(row);
+    return toRecord5(yield* decodeRow2(row));
   });
   const get5 = Effect11.fn("ExecutionRepository.get")(function* (id2) {
     const tenantId2 = yield* current;
-    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 rows = yield* selectByKey(tenantId2, id2).pipe(Effect11.mapError(toRepositoryError3));
+    return rows[0] === undefined ? undefined : toRecord5(yield* decodeRow2(rows[0]));
   });
   const list5 = Effect11.fn("ExecutionRepository.list")(function* (input) {
     const tenantId2 = yield* current;
     const limit = listLimit2(input);
-    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 rows = yield* sql6`
+        SELECT ${columns}
+        FROM relay_executions
+        WHERE ${sql6.and(listConditions(tenantId2, input))}
+        ORDER BY updated_at DESC, id DESC
+        LIMIT ${sql6.literal(String(limit + 1))}
+      `.pipe(Effect11.mapError(toRepositoryError3));
+    const decoded = yield* Effect11.forEach(rows.slice(0, limit), decodeRow2);
+    const records = decoded.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* mapDatabaseError7(db.update(relayExecutions).set({
-      status: input.status,
-      metadataJson: metadata4(input.metadata),
-      updatedAt: toPgDate(input.updatedAt)
-    }).where(predicate(tenantId2, relayExecutions.tenantId, eq8(relayExecutions.id, input.id))).returning());
+    const rows = yield* updateExecution(tenantId2, input).pipe(Effect11.mapError(toRepositoryError3));
     const row = rows[0];
     if (row === undefined)
       return yield* Effect11.fail(new ExecutionNotFound({ id: input.id }));
-    return toRecord5(row);
+    return toRecord5(yield* decodeRow2(row));
   });
   return Service11.of({ create: create2, get: get5, list: list5, transition });
 }));
@@ -3211,7 +3489,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 eq9, sql as sql7 } from "drizzle-orm";
+import { eq as eq7, sql as sql6 } 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
@@ -3234,7 +3512,7 @@ var toRecord6 = (row) => {
     ...expiresAt === undefined ? {} : { expiresAt }
   };
 };
-var toInsert3 = (tenantId2, input, result) => ({
+var toInsert2 = (tenantId2, input, result) => ({
   tenantId: tenantId2,
   id: operationId(input),
   scope: input.scope,
@@ -3251,17 +3529,17 @@ var layer12 = Layer12.effect(Service12, Effect12.gen(function* () {
   const runOnce = (input, create3) => 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, eq9(relayIdempotencyKeys.scope, input.scope), eq9(relayIdempotencyKeys.operation, input.operation), eq9(relayIdempotencyKeys.key, input.key))).limit(1);
+      yield* tx.execute(sql6`select pg_advisory_xact_lock(hashtextextended(${`${tenantId2}:${operationId(input)}`}, 0))`);
+      const existingRows = yield* tx.select().from(relayIdempotencyKeys).where(predicate(tenantId2, relayIdempotencyKeys.tenantId, eq7(relayIdempotencyKeys.scope, input.scope), eq7(relayIdempotencyKeys.operation, input.operation), eq7(relayIdempotencyKeys.key, input.key))).limit(1);
       const existing = existingRows[0];
       if (existing !== undefined)
         return { replayed: true, record: toRecord6(existing) };
       const result = yield* create3;
-      const rows = yield* tx.insert(relayIdempotencyKeys).values(toInsert3(tenantId2, input, result)).onConflictDoNothing().returning();
+      const rows = yield* tx.insert(relayIdempotencyKeys).values(toInsert2(tenantId2, input, result)).onConflictDoNothing().returning();
       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, eq9(relayIdempotencyKeys.scope, input.scope), eq9(relayIdempotencyKeys.operation, input.operation), eq9(relayIdempotencyKeys.key, input.key))).limit(1);
+      const winnerRows = yield* tx.select().from(relayIdempotencyKeys).where(predicate(tenantId2, relayIdempotencyKeys.tenantId, eq7(relayIdempotencyKeys.scope, input.scope), eq7(relayIdempotencyKeys.operation, input.operation), eq7(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" }));
@@ -3311,7 +3589,7 @@ __export(exports_memory_repository, {
   Service: () => Service13,
   MemoryRepositoryError: () => MemoryRepositoryError
 });
-import { sql as sql8 } from "drizzle-orm";
+import { sql as sql7 } from "drizzle-orm";
 import { Context as Context13, Effect as Effect13, Layer as Layer13, Ref as Ref2, Schema as Schema23 } from "effect";
 class MemoryRepositoryError extends Schema23.TaggedErrorClass()("MemoryRepositoryError", {
   message: Schema23.String
@@ -3338,7 +3616,7 @@ var queryRowToRecord = (row) => ({
   metadata: row.metadataJson,
   createdAt: fromPgDate(row.createdAt)
 });
-var mapDatabaseError8 = (effect) => effect.pipe(Effect13.mapError((error) => new MemoryRepositoryError({ message: String(error) })));
+var mapDatabaseError6 = (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)
@@ -3382,7 +3660,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* mapDatabaseError8(db.insert(relayMemoryRecords).values({
+    const rows = yield* mapDatabaseError6(db.insert(relayMemoryRecords).values({
       tenantId: tenantId2,
       id: input.id,
       agent: input.agent,
@@ -3412,8 +3690,8 @@ var layer13 = Layer13.effect(Service13, Effect13.gen(function* () {
     yield* validateVector("query embedding", input.embedding);
     if (input.topK <= 0)
       return [];
-    const queryEmbeddingSql = sql8`array[${sql8.join(input.embedding.map((value) => sql8`${value}`), sql8`, `)}]::double precision[]`;
-    const rows = yield* mapDatabaseError8(db.execute(sql8`
+    const queryEmbeddingSql = sql7`array[${sql7.join(input.embedding.map((value) => sql7`${value}`), sql7`, `)}]::double precision[]`;
+    const rows = yield* mapDatabaseError6(db.execute(sql7`
           with query_embedding as (
             select ${queryEmbeddingSql} as embedding
           ),
@@ -3553,7 +3831,7 @@ __export(exports_permission_rule_repository, {
   Service: () => Service14,
   PermissionRuleRepositoryError: () => PermissionRuleRepositoryError
 });
-import { asc as asc7, eq as eq10 } from "drizzle-orm";
+import { asc as asc6, eq as eq8 } 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
@@ -3568,13 +3846,13 @@ var toRecord8 = (row) => ({
   rule: row.ruleJson,
   createdAt: fromPgDate(row.createdAt)
 });
-var mapDatabaseError9 = (effect) => effect.pipe(Effect14.mapError((error) => new PermissionRuleRepositoryError({ message: String(error) })));
+var mapDatabaseError7 = (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* mapDatabaseError9(db.insert(relayPermissionRules).values({
+    const rows = yield* mapDatabaseError7(db.insert(relayPermissionRules).values({
       tenantId: tenantId2,
       agent: input.agent,
       scope: input.scope,
@@ -3601,7 +3879,7 @@ var layer14 = Layer14.effect(Service14, Effect14.gen(function* () {
   });
   const list6 = Effect14.fn("PermissionRuleRepository.list")(function* (input) {
     const tenantId2 = yield* current;
-    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)));
+    const rows = yield* mapDatabaseError7(db.select().from(relayPermissionRules).where(predicate(tenantId2, relayPermissionRules.tenantId, eq8(relayPermissionRules.agent, input.agent), eq8(relayPermissionRules.scope, input.scope))).orderBy(asc6(relayPermissionRules.createdAt), asc6(relayPermissionRules.pattern)));
     return rows.map(toRecord8);
   });
   return Service14.of({ remember, list: list6 });
@@ -3644,7 +3922,7 @@ __export(exports_context_epoch_repository, {
   Service: () => Service15,
   ContextEpochRepositoryError: () => ContextEpochRepositoryError
 });
-import { eq as eq11 } from "drizzle-orm";
+import { eq as eq9 } 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
@@ -3659,7 +3937,7 @@ var toRecord9 = (row) => ({
   dynamicSourceIds: row.dynamicSourceIdsJson,
   openedAt: fromPgDate(row.openedAt)
 });
-var mapDatabaseError10 = (effect) => effect.pipe(Effect15.mapError((error) => new ContextEpochRepositoryError({ message: String(error) })));
+var mapDatabaseError8 = (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);
@@ -3667,12 +3945,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* mapDatabaseError10(db.select().from(relayExecutionContextEpochs).where(predicate(tenantId2, relayExecutionContextEpochs.tenantId, eq11(relayExecutionContextEpochs.executionId, executionId))).limit(1));
+    const rows = yield* mapDatabaseError8(db.select().from(relayExecutionContextEpochs).where(predicate(tenantId2, relayExecutionContextEpochs.tenantId, eq9(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* mapDatabaseError10(db.insert(relayExecutionContextEpochs).values({
+    const rows = yield* mapDatabaseError8(db.insert(relayExecutionContextEpochs).values({
       tenantId: tenantId2,
       executionId: input.executionId,
       baseline: input.baseline,
@@ -3746,7 +4024,7 @@ __export(exports_schedule_repository, {
   ScheduleNotFound: () => ScheduleNotFound,
   ScheduleClaimMismatch: () => ScheduleClaimMismatch
 });
-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 { and as and2, asc as asc7, eq as eq10, inArray, lte, or as or2, sql as sql8 } 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
@@ -3782,7 +4060,7 @@ var validationError = (input) => {
   }
   return;
 };
-var toInsert4 = (tenantId2, input) => ({
+var toInsert3 = (tenantId2, input) => ({
   tenantId: tenantId2,
   id: input.id,
   kind: input.kind,
@@ -3813,12 +4091,12 @@ var toRecord10 = (row) => ({
   created_at: fromPgDate(row.createdAt),
   updated_at: fromPgDate(row.updatedAt)
 });
-var mapDatabaseError11 = (effect) => effect.pipe(Effect16.mapError((error) => new ScheduleRepositoryError({ message: String(error) })));
+var mapDatabaseError9 = (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) => 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 getRow = (tenantId2, id2) => mapDatabaseError9(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, eq10(relaySchedules.id, id2))).limit(1)).pipe(Effect16.map((rows) => rows[0]));
+  const getByIdempotencyKey = (tenantId2, key2) => mapDatabaseError9(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, eq10(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);
@@ -3829,7 +4107,7 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
       if (existing !== undefined)
         return toRecord10(existing);
     }
-    const rows = yield* mapDatabaseError11(db.insert(relaySchedules).values(toInsert4(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError9(db.insert(relaySchedules).values(toInsert3(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect16.fail(new ScheduleRepositoryError({ message: `Schedule ${input.id} was not persisted` }));
@@ -3843,17 +4121,17 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
   });
   const list7 = Effect16.fn("ScheduleRepository.list")(function* (input) {
     const tenantId2 = yield* current;
-    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)));
+    const rows = yield* mapDatabaseError9(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, input.state === undefined ? undefined : eq10(relaySchedules.state, input.state))).orderBy(asc7(relaySchedules.nextRunAt), asc7(relaySchedules.createdAt)));
     return rows.map(toRecord10);
   });
   const cancel = Effect16.fn("ScheduleRepository.cancel")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError11(db.update(relaySchedules).set({
+    const rows = yield* mapDatabaseError9(db.update(relaySchedules).set({
       state: "cancelled",
       claimOwner: null,
       claimExpiresAt: null,
       updatedAt: toPgDate(input.cancelledAt)
-    }).where(predicate(tenantId2, relaySchedules.tenantId, eq12(relaySchedules.id, input.id), inArray2(relaySchedules.state, [...cancellableStates]))).returning());
+    }).where(predicate(tenantId2, relaySchedules.tenantId, eq10(relaySchedules.id, input.id), inArray(relaySchedules.state, [...cancellableStates]))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toRecord10(row);
@@ -3866,23 +4144,23 @@ 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(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({
+    const candidate = db.select({ id: relaySchedules.id }).from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, or2(and2(eq10(relaySchedules.state, "active"), lte(relaySchedules.nextRunAt, toPgDate(input.now))), and2(eq10(relaySchedules.state, "claimed"), lte(relaySchedules.claimExpiresAt, toPgDate(input.now)))))).orderBy(asc7(relaySchedules.nextRunAt), asc7(relaySchedules.createdAt)).limit(1).for("update", { skipLocked: true });
+    const rows = yield* mapDatabaseError9(db.update(relaySchedules).set({
       state: "claimed",
       claimOwner: input.workerId,
       claimExpiresAt: toPgDate(input.claimExpiresAt),
       updatedAt: toPgDate(input.now),
-      attempt: sql9`${relaySchedules.attempt} + 1`
-    }).where(predicate(tenantId2, relaySchedules.tenantId, inArray2(relaySchedules.id, candidate))).returning());
+      attempt: sql8`${relaySchedules.attempt} + 1`
+    }).where(predicate(tenantId2, relaySchedules.tenantId, inArray(relaySchedules.id, candidate))).returning());
     return rows[0] === undefined ? undefined : toRecord10(rows[0]);
   });
   const ack = Effect16.fn("ScheduleRepository.ack")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError11(db.update(relaySchedules).set({
+    const rows = yield* mapDatabaseError9(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, eq12(relaySchedules.id, input.id), eq12(relaySchedules.claimOwner, input.workerId), eq12(relaySchedules.state, "claimed"))).returning());
+    }).where(predicate(tenantId2, relaySchedules.tenantId, eq10(relaySchedules.id, input.id), eq10(relaySchedules.claimOwner, input.workerId), eq10(relaySchedules.state, "claimed"))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toRecord10(row);
@@ -3895,14 +4173,14 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
   });
   const release = Effect16.fn("ScheduleRepository.release")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError11(db.update(relaySchedules).set({
+    const rows = yield* mapDatabaseError9(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, eq12(relaySchedules.id, input.id), eq12(relaySchedules.claimOwner, input.workerId), eq12(relaySchedules.state, "claimed"))).returning());
+    }).where(predicate(tenantId2, relaySchedules.tenantId, eq10(relaySchedules.id, input.id), eq10(relaySchedules.claimOwner, input.workerId), eq10(relaySchedules.state, "claimed"))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toRecord10(row);
@@ -4079,12 +4357,14 @@ __export(exports_session_repository, {
   create: () => create4,
   countEntries: () => countEntries,
   appendEntry: () => appendEntry,
+  SessionRow: () => SessionRow,
   SessionRepositoryError: () => SessionRepositoryError,
+  SessionEntryRow: () => SessionEntryRow,
   Service: () => Service17,
   DuplicateSession: () => DuplicateSession
 });
-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";
+import * as SqlClient10 from "effect/unstable/sql/SqlClient";
 class SessionRepositoryError extends Schema27.TaggedErrorClass()("SessionRepositoryError", {
   message: Schema27.String
 }) {
@@ -4097,14 +4377,33 @@ class DuplicateSession extends Schema27.TaggedErrorClass()("DuplicateSession", {
 
 class Service17 extends Context17.Service()("@relayfx/store-sql/SessionRepository") {
 }
+var SessionRow = Schema27.Struct({
+  id: Schema27.String,
+  root_address_id: Schema27.String,
+  leaf_entry_id: Schema27.Union([Schema27.String, Schema27.Null, Schema27.Undefined]),
+  metadata_json: Schema27.Unknown,
+  created_at: Schema27.Union([Schema27.Date, Schema27.String, Schema27.Number]),
+  updated_at: Schema27.Union([Schema27.Date, Schema27.String, Schema27.Number])
+}).annotate({ identifier: "Relay.Session.Row" });
+var SessionEntryRow = Schema27.Struct({
+  id: Schema27.String,
+  session_id: Schema27.String,
+  parent_id: Schema27.Union([Schema27.String, Schema27.Null, Schema27.Undefined]),
+  tag: Schema27.String,
+  payload_json: Schema27.Unknown,
+  created_at: Schema27.Union([Schema27.Date, Schema27.String, Schema27.Number])
+}).annotate({ identifier: "Relay.SessionEntry.Row" });
+var CountRow = Schema27.Struct({
+  value: Schema27.Union([Schema27.Number, Schema27.String, Schema27.BigInt])
+}).annotate({ identifier: "Relay.SessionEntry.CountRow" });
 var metadata7 = (input) => input ?? {};
 var toSessionRecord = (row) => ({
-  id: row.id,
-  rootAddressId: row.rootAddressId,
-  ...row.leafEntryId === null || row.leafEntryId === undefined ? {} : { leafEntryId: row.leafEntryId },
-  metadata: row.metadataJson,
-  createdAt: fromPgDate(row.createdAt),
-  updatedAt: fromPgDate(row.updatedAt)
+  id: exports_ids_schema.SessionId.make(row.id),
+  rootAddressId: exports_ids_schema.AddressId.make(row.root_address_id),
+  ...row.leaf_entry_id === null || row.leaf_entry_id === undefined ? {} : { leafEntryId: exports_ids_schema.SessionEntryId.make(row.leaf_entry_id) },
+  metadata: decodeJson(row.metadata_json),
+  createdAt: fromDbTimestamp(row.created_at),
+  updatedAt: fromDbTimestamp(row.updated_at)
 });
 var payloadFromInput = (input) => {
   switch (input._tag) {
@@ -4127,12 +4426,12 @@ var payloadFromInput = (input) => {
   }
 };
 var toEntryRecord = (row) => {
-  const payload = row.payloadJson;
+  const payload = decodeJson(row.payload_json);
   const base = {
-    id: row.id,
-    sessionId: row.sessionId,
-    parentId: row.parentId,
-    createdAt: fromPgDate(row.createdAt),
+    id: exports_ids_schema.SessionEntryId.make(row.id),
+    sessionId: exports_ids_schema.SessionId.make(row.session_id),
+    parentId: row.parent_id === null || row.parent_id === undefined ? null : exports_ids_schema.SessionEntryId.make(row.parent_id),
+    createdAt: fromDbTimestamp(row.created_at),
     ...payload.metadata === undefined ? {} : { metadata: payload.metadata }
   };
   switch (row.tag) {
@@ -4159,8 +4458,11 @@ var toEntryRecord = (row) => {
       return Effect17.fail(new SessionRepositoryError({ message: `Unknown session entry tag: ${row.tag}` }));
   }
 };
-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 toRepositoryError4 = (error) => error instanceof SessionRepositoryError ? error : new SessionRepositoryError({ message: String(error) });
+var mapRepositoryError = (effect) => effect.pipe(Effect17.mapError(toRepositoryError4));
+var decodeSessionRow = (row) => Schema27.decodeUnknownEffect(SessionRow)(row).pipe(Effect17.mapError(toRepositoryError4));
+var decodeEntryRow = (row) => Schema27.decodeUnknownEffect(SessionEntryRow)(row).pipe(Effect17.mapError(toRepositoryError4));
+var decodeCountRow = (row) => Schema27.decodeUnknownEffect(CountRow)(row).pipe(Effect17.mapError(toRepositoryError4));
 var maxListLimit3 = 100;
 var defaultListLimit2 = 50;
 var listLimit3 = (input) => Math.min(Math.max(input.limit ?? defaultListLimit2, 1), maxListLimit3);
@@ -4170,10 +4472,6 @@ 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 : 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;
   return value;
@@ -4214,19 +4512,58 @@ var validateCompaction = (currentPath, input) => {
   return currentPath.some((item) => item.id === entry.firstKeptEntryId) ? Effect17.void : Effect17.fail(missingEntry(entry.firstKeptEntryId));
 };
 var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
-  const db = yield* Service;
+  const sql9 = yield* SqlClient10.SqlClient;
+  const selectSessionByKey = (tenantId2, id2) => sql9`
+      SELECT id, root_address_id, leaf_entry_id, metadata_json, created_at, updated_at
+      FROM relay_sessions
+      WHERE tenant_id = ${tenantId2} AND id = ${id2}
+    `;
+  const selectEntryByKey = (tenantId2, sessionId, id2) => sql9`
+      SELECT id, session_id, parent_id, tag, payload_json, created_at
+      FROM relay_session_entries
+      WHERE tenant_id = ${tenantId2} AND id = ${id2} AND session_id = ${sessionId}
+    `;
+  const insertSession = (tenantId2, input) => sql9`
+      INSERT INTO relay_sessions (tenant_id, id, root_address_id, metadata_json, created_at, updated_at)
+      VALUES (${tenantId2}, ${input.id}, ${input.rootAddressId}, ${encodeJson(metadata7(input.metadata))}, ${timestampParam(sql9, input.timestamp)}, ${timestampParam(sql9, input.timestamp)})
+    `;
+  const touchSession = (tenantId2, id2, updatedAt) => sql9`
+      UPDATE relay_sessions
+      SET updated_at = ${timestampParam(sql9, updatedAt)}
+      WHERE tenant_id = ${tenantId2} AND id = ${id2}
+    `;
+  const updateLeaf = (tenantId2, input) => sql9`
+      UPDATE relay_sessions
+      SET leaf_entry_id = ${input.id}, updated_at = ${timestampParam(sql9, input.updatedAt)}
+      WHERE tenant_id = ${tenantId2} AND id = ${input.sessionId}
+    `;
+  const insertEntryIfAbsent = sql9.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql9`
+        INSERT IGNORE INTO relay_session_entries (tenant_id, id, session_id, parent_id, tag, payload_json, created_at)
+        VALUES (${tenantId2}, ${input.id}, ${input.sessionId}, ${input.parentId}, ${input.input._tag}, ${encodeJson(payloadFromInput(input.input))}, ${timestampParam(sql9, input.createdAt)})
+      `,
+    orElse: () => (tenantId2, input) => sql9`
+        INSERT INTO relay_session_entries (tenant_id, id, session_id, parent_id, tag, payload_json, created_at)
+        VALUES (${tenantId2}, ${input.id}, ${input.sessionId}, ${input.parentId}, ${input.input._tag}, ${encodeJson(payloadFromInput(input.input))}, ${timestampParam(sql9, input.createdAt)})
+        ON CONFLICT (tenant_id, id) DO NOTHING
+      `
+  });
   const getForTenant = Effect17.fn("SessionRepository.getForTenant")(function* (tenantId2, id2) {
-    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 rows = yield* mapRepositoryError(selectSessionByKey(tenantId2, id2));
+    return rows[0] === undefined ? undefined : toSessionRecord(yield* decodeSessionRow(rows[0]));
+  });
+  const requireSession = Effect17.fn("SessionRepository.requireSession")(function* (tenantId2, id2) {
+    const session = yield* getForTenant(tenantId2, id2);
+    if (session === undefined)
+      return yield* Effect17.fail(missingSession(id2));
+    return session;
   });
   const entryById = Effect17.fn("SessionRepository.entryById")(function* (tenantId2, sessionId, id2) {
-    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 rows = yield* mapRepositoryError(selectEntryByKey(tenantId2, sessionId, id2));
+    return rows[0] === undefined ? undefined : yield* toEntryRecord(yield* decodeEntryRow(rows[0]));
   });
   const pathForTenant = Effect17.fn("SessionRepository.pathForTenant")(function* (tenantId2, input) {
-    const session = yield* getForTenant(tenantId2, input.sessionId);
-    if (session === undefined)
-      return yield* Effect17.fail(missingSession(input.sessionId));
+    const session = yield* requireSession(tenantId2, input.sessionId);
     const start = input.leafId ?? session.leafEntryId;
     if (start === undefined)
       return [];
@@ -4255,18 +4592,16 @@ 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* mapDatabaseError12(db.insert(relaySessions).values({
-      tenantId: tenantId2,
+    yield* mapRepositoryError(insertSession(tenantId2, {
       id: input.id,
       rootAddressId: input.rootAddressId,
-      metadataJson: metadata7(input.metadata),
-      createdAt: toPgDate(input.createdAt),
-      updatedAt: toPgDate(input.createdAt)
-    }).returning());
-    const row = rows[0];
-    if (row === undefined)
+      ...input.metadata === undefined ? {} : { metadata: input.metadata },
+      timestamp: input.createdAt
+    }));
+    const created = yield* getForTenant(tenantId2, input.id);
+    if (created === undefined)
       return yield* Effect17.fail(new SessionRepositoryError({ message: "Session insert returned no row" }));
-    return toSessionRecord(row);
+    return created;
   });
   const ensure = Effect17.fn("SessionRepository.ensure")(function* (input) {
     const tenantId2 = yield* current;
@@ -4274,24 +4609,19 @@ 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* 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);
+      yield* mapRepositoryError(touchSession(tenantId2, input.id, input.now));
+      return yield* requireSession(tenantId2, input.id);
     }
-    const rows = yield* mapDatabaseError12(db.insert(relaySessions).values({
-      tenantId: tenantId2,
+    yield* mapRepositoryError(insertSession(tenantId2, {
       id: input.id,
       rootAddressId: input.rootAddressId,
-      metadataJson: metadata7(input.metadata),
-      createdAt: toPgDate(input.now),
-      updatedAt: toPgDate(input.now)
-    }).returning());
-    const row = rows[0];
-    if (row === undefined)
+      ...input.metadata === undefined ? {} : { metadata: input.metadata },
+      timestamp: input.now
+    }));
+    const created = yield* getForTenant(tenantId2, input.id);
+    if (created === undefined)
       return yield* Effect17.fail(new SessionRepositoryError({ message: "Session insert returned no row" }));
-    return toSessionRecord(row);
+    return created;
   });
   const get8 = Effect17.fn("SessionRepository.get")(function* (id2) {
     const tenantId2 = yield* current;
@@ -4300,36 +4630,46 @@ 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* 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 conditions = [sql9`tenant_id = ${tenantId2}`];
+    if (input.rootAddressId !== undefined) {
+      conditions.push(sql9`root_address_id = ${input.rootAddressId}`);
+    }
+    if (input.cursor !== undefined) {
+      const cursorTimestamp = timestampParam(sql9, input.cursor.updatedAt);
+      conditions.push(sql9.or([
+        sql9`updated_at < ${cursorTimestamp}`,
+        sql9.and([sql9`updated_at = ${cursorTimestamp}`, sql9`id < ${input.cursor.id}`])
+      ]));
+    }
+    const rows = yield* mapRepositoryError(sql9`
+        SELECT id, root_address_id, leaf_entry_id, metadata_json, created_at, updated_at
+        FROM relay_sessions
+        WHERE ${sql9.and(conditions)}
+        ORDER BY updated_at DESC, id DESC
+        LIMIT ${sql9.literal(String(limit + 1))}
+      `);
+    const records = yield* Effect17.forEach(rows.slice(0, limit), (row) => decodeSessionRow(row).pipe(Effect17.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* 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));
-    return toSessionRecord(row);
+    yield* mapRepositoryError(touchSession(tenantId2, input.id, input.updatedAt));
+    return yield* requireSession(tenantId2, input.id);
   });
   const leaf = Effect17.fn("SessionRepository.leaf")(function* (sessionId) {
     const tenantId2 = yield* current;
-    const session = yield* getForTenant(tenantId2, sessionId);
-    if (session === undefined)
-      return yield* Effect17.fail(missingSession(sessionId));
+    const session = yield* requireSession(tenantId2, sessionId);
     return session.leafEntryId ?? null;
   });
   const setLeafForTenant = Effect17.fn("SessionRepository.setLeafForTenant")(function* (tenantId2, input) {
-    const session = yield* getForTenant(tenantId2, input.sessionId);
-    if (session === undefined)
-      return yield* Effect17.fail(missingSession(input.sessionId));
+    yield* requireSession(tenantId2, input.sessionId);
     if (input.id !== null) {
       const entry = yield* entryById(tenantId2, input.sessionId, input.id);
       if (entry === undefined)
         return yield* Effect17.fail(missingEntry(input.id));
     }
-    yield* mapDatabaseError12(db.update(relaySessions).set({ leafEntryId: input.id, updatedAt: toPgDate(input.updatedAt) }).where(predicate(tenantId2, relaySessions.tenantId, eq13(relaySessions.id, input.sessionId))));
+    yield* mapRepositoryError(updateLeaf(tenantId2, input));
   });
   const setLeaf = Effect17.fn("SessionRepository.setLeaf")(function* (input) {
     const tenantId2 = yield* current;
@@ -4337,9 +4677,7 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
   });
   const appendEntry = Effect17.fn("SessionRepository.appendEntry")(function* (input) {
     const tenantId2 = yield* current;
-    const session = yield* getForTenant(tenantId2, input.sessionId);
-    if (session === undefined)
-      return yield* Effect17.fail(missingSession(input.sessionId));
+    const session = yield* requireSession(tenantId2, input.sessionId);
     const existing = yield* entryById(tenantId2, input.sessionId, input.id);
     const desired = appendToRecord(input);
     if (existing !== undefined) {
@@ -4355,27 +4693,18 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
     }
     const currentPath = session.leafEntryId === undefined ? [] : yield* pathForTenant(tenantId2, { sessionId: input.sessionId });
     yield* validateCompaction(currentPath, input);
-    return yield* mapWriteError(db.transaction((tx) => Effect17.gen(function* () {
-      const rows = yield* tx.insert(relaySessionEntries).values({
-        tenantId: tenantId2,
-        id: input.id,
-        sessionId: input.sessionId,
-        parentId: input.parentId,
-        tag: input.input._tag,
-        payloadJson: payloadFromInput(input.input),
-        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, 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" }));
-        }
-        return toEntryRecord(existingRow);
-      })) : yield* toEntryRecord(row);
+    return yield* mapRepositoryError(sql9.withTransaction(Effect17.gen(function* () {
+      yield* insertEntryIfAbsent(tenantId2, input);
+      const entryRows = yield* selectEntryByKey(tenantId2, input.sessionId, input.id);
+      const entryRow = entryRows[0];
+      if (entryRow === undefined) {
+        return yield* Effect17.fail(new SessionRepositoryError({ message: "Session entry insert returned no row" }));
+      }
+      const record2 = yield* toEntryRecord(yield* decodeEntryRow(entryRow));
       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, eq13(relaySessions.id, input.sessionId))).returning();
+      yield* updateLeaf(tenantId2, { sessionId: input.sessionId, id: input.id, updatedAt: input.createdAt });
+      const sessionRows = yield* selectSessionByKey(tenantId2, input.sessionId);
       if (sessionRows[0] === undefined)
         return yield* Effect17.fail(missingSession(input.sessionId));
       return record2;
@@ -4383,8 +4712,15 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
   });
   const countEntries = Effect17.fn("SessionRepository.countEntries")(function* (sessionId) {
     const tenantId2 = yield* current;
-    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);
+    const rows = yield* mapRepositoryError(sql9`
+        SELECT COUNT(*) AS value
+        FROM relay_session_entries
+        WHERE tenant_id = ${tenantId2} AND session_id = ${sessionId}
+      `);
+    if (rows[0] === undefined)
+      return 0;
+    const counted = yield* decodeCountRow(rows[0]);
+    return Number(counted.value);
   });
   return Service17.of({ create: create4, ensure, get: get8, list: list8, touch, appendEntry, countEntries, path, setLeaf, leaf });
 }));
@@ -4572,7 +4908,7 @@ __export(exports_skill_definition_repository, {
   SkillDefinitionRepositoryError: () => SkillDefinitionRepositoryError,
   Service: () => Service18
 });
-import { asc as asc9, desc as desc6, eq as eq14, inArray as inArray3, sql as sql10 } from "drizzle-orm";
+import { asc as asc8, desc as desc3, eq as eq11, inArray as inArray2, sql as sql9 } 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
@@ -4635,10 +4971,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 mapDatabaseError13 = (effect) => effect.pipe(Effect18.mapError((error) => new SkillDefinitionRepositoryError({ message: String(error) })));
+var mapDatabaseError10 = (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) => mapDatabaseError13(db.execute(sql10`select pg_advisory_xact_lock(hashtext(${skillPinLockKey(tenantId2, executionId)}))`)).pipe(Effect18.asVoid);
+var lockExecutionPins = (db, tenantId2, executionId) => mapDatabaseError10(db.execute(sql9`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) {
@@ -4656,7 +4992,7 @@ var layer18 = Layer18.effect(Service18, Effect18.gen(function* () {
         target: [relaySkillDefinitions.tenantId, relaySkillDefinitions.id],
         set: {
           name: input.definition.frontmatter.name,
-          currentRevision: sql10`${relaySkillDefinitions.currentRevision} + 1`,
+          currentRevision: sql9`${relaySkillDefinitions.currentRevision} + 1`,
           definitionJson: input.definition,
           updatedAt: toPgDate(input.now)
         }
@@ -4681,32 +5017,32 @@ var layer18 = Layer18.effect(Service18, Effect18.gen(function* () {
   });
   const get9 = Effect18.fn("SkillDefinitionRepository.get")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError13(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId, eq14(relaySkillDefinitions.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError10(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId, eq11(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* mapDatabaseError13(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq14(relaySkillDefinitionRevisions.skillDefinitionId, input.id), eq14(relaySkillDefinitionRevisions.revision, input.revision))).limit(1));
+    const rows = yield* mapDatabaseError10(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq11(relaySkillDefinitionRevisions.skillDefinitionId, input.id), eq11(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* mapDatabaseError13(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId)).orderBy(desc6(relaySkillDefinitions.createdAt), asc9(relaySkillDefinitions.id)));
+    const rows = yield* mapDatabaseError10(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId)).orderBy(desc3(relaySkillDefinitions.createdAt), asc8(relaySkillDefinitions.id)));
     return rows.map(toRecord11);
   });
   const listRevisions2 = Effect18.fn("SkillDefinitionRepository.listRevisions")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError13(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq14(relaySkillDefinitionRevisions.skillDefinitionId, id2))).orderBy(desc6(relaySkillDefinitionRevisions.revision)));
+    const rows = yield* mapDatabaseError10(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq11(relaySkillDefinitionRevisions.skillDefinitionId, id2))).orderBy(desc3(relaySkillDefinitionRevisions.revision)));
     return rows.map(toRevisionRecord2);
   });
   const listPins = Effect18.fn("SkillDefinitionRepository.listPins")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError13(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq14(relayExecutionSkillPins.executionId, executionId))).orderBy(asc9(relayExecutionSkillPins.skillDefinitionId)));
+    const rows = yield* mapDatabaseError10(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq11(relayExecutionSkillPins.executionId, executionId))).orderBy(asc8(relayExecutionSkillPins.skillDefinitionId)));
     return rows.map(toPinRecord);
   });
   const getPinned = Effect18.fn("SkillDefinitionRepository.getPinned")(function* (input) {
     const tenantId2 = yield* current;
-    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));
+    const rows = yield* mapDatabaseError10(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq11(relayExecutionSkillPins.executionId, input.executionId), eq11(relayExecutionSkillPins.skillDefinitionId, input.skillDefinitionId))).limit(1));
     return rows[0] === undefined ? undefined : toPinRecord(rows[0]);
   });
   const pinExecution = Effect18.fn("SkillDefinitionRepository.pinExecution")(function* (input) {
@@ -4716,7 +5052,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, eq14(relayExecutionSkillPins.executionId, input.executionId))).orderBy(asc9(relayExecutionSkillPins.skillDefinitionId));
+      const existingRows = yield* tx.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq11(relayExecutionSkillPins.executionId, input.executionId))).orderBy(asc8(relayExecutionSkillPins.skillDefinitionId));
       if (existingRows.length > 0) {
         const existing = existingRows.map(toPinRecord);
         if (!sameIdSet(existing.map((record2) => record2.skillDefinitionId), requestedIds)) {
@@ -4726,7 +5062,7 @@ var layer18 = Layer18.effect(Service18, Effect18.gen(function* () {
         }
         return existing;
       }
-      const currentRows = yield* tx.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId, inArray3(relaySkillDefinitions.id, [...requestedIds])));
+      const currentRows = yield* tx.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId, inArray2(relaySkillDefinitions.id, [...requestedIds])));
       const currentRecords = currentRows.map(toRecord11);
       if (currentRecords.length !== requestedIds.length) {
         return yield* Effect18.fail(new SkillDefinitionRepositoryError({ message: missingSkillMessage(requestedIds, currentRecords) }));
@@ -4873,10 +5209,12 @@ __export(exports_steering_repository, {
   appendForRunning: () => appendForRunning,
   append: () => append2,
   SteeringRepositoryError: () => SteeringRepositoryError,
+  SteeringMessageRow: () => SteeringMessageRow,
+  SteeringDrainRow: () => SteeringDrainRow,
   Service: () => Service19
 });
-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";
+import * as SqlClient12 from "effect/unstable/sql/SqlClient";
 class SteeringRepositoryError extends Schema29.TaggedErrorClass()("SteeringRepositoryError", {
   message: Schema29.String
 }) {
@@ -4885,26 +5223,45 @@ class SteeringRepositoryError extends Schema29.TaggedErrorClass()("SteeringRepos
 class Service19 extends Context19.Service()("@relayfx/store-sql/SteeringRepository") {
 }
 var SteeringKindSchema = Schema29.Literals(["steering", "follow_up"]);
-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 DbTimestamp2 = Schema29.Union([Schema29.Date, Schema29.String, Schema29.Number]);
+var SteeringMessageRow = Schema29.Struct({
+  execution_id: Schema29.String,
+  kind: SteeringKindSchema,
+  sequence: Schema29.Union([Schema29.Number, Schema29.String]),
+  content_json: Schema29.Unknown,
+  drain_id: Schema29.NullishOr(Schema29.String),
+  consumed_at: Schema29.NullishOr(DbTimestamp2),
+  created_at: DbTimestamp2
+}).annotate({ identifier: "Relay.SteeringMessage.Row" });
+var SteeringDrainRow = Schema29.Struct({
+  execution_id: Schema29.String,
+  kind: SteeringKindSchema,
+  drain_id: Schema29.String,
+  message_sequences_json: Schema29.Unknown,
+  created_at: DbTimestamp2
+}).annotate({ identifier: "Relay.SteeringDrain.Row" });
+var toRepositoryError5 = (error) => new SteeringRepositoryError({ message: String(error) });
+var mapTransactionError = (effect) => effect.pipe(Effect19.mapError((error) => error instanceof SteeringRepositoryError ? error : toRepositoryError5(error)));
+var decodeMessageRow = (row) => Schema29.decodeUnknownEffect(SteeringMessageRow)(row).pipe(Effect19.mapError(toRepositoryError5));
+var decodeDrainRow = (row) => Schema29.decodeUnknownEffect(SteeringDrainRow)(row).pipe(Effect19.mapError(toRepositoryError5));
 var toMessageRecord = (row) => {
-  const consumedAt = fromNullablePgDate(row.consumedAt);
+  const consumedAt = fromNullableDbTimestamp(row.consumed_at);
   return {
-    executionId: exports_ids_schema.ExecutionId.make(row.executionId),
-    kind: Schema29.decodeUnknownSync(SteeringKindSchema)(row.kind),
-    sequence: row.sequence,
-    content: row.contentJson,
-    ...row.drainId === null || row.drainId === undefined ? {} : { drainId: row.drainId },
+    executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
+    kind: row.kind,
+    sequence: Number(row.sequence),
+    content: decodeJson(row.content_json),
+    ...row.drain_id === null || row.drain_id === undefined ? {} : { drainId: row.drain_id },
     ...consumedAt === undefined ? {} : { consumedAt },
-    createdAt: fromPgDate(row.createdAt)
+    createdAt: fromDbTimestamp(row.created_at)
   };
 };
 var toDrainRecord = (row) => ({
-  executionId: exports_ids_schema.ExecutionId.make(row.executionId),
-  kind: Schema29.decodeUnknownSync(SteeringKindSchema)(row.kind),
-  drainId: row.drainId,
-  messageSequences: row.messageSequencesJson,
-  createdAt: fromPgDate(row.createdAt)
+  executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
+  kind: row.kind,
+  drainId: row.drain_id,
+  messageSequences: decodeJson(row.message_sequences_json).map(Number),
+  createdAt: fromDbTimestamp(row.created_at)
 });
 var queueKey = (tenantId2, executionId, kind) => JSON.stringify([tenantId2, executionId, kind]);
 var drainKey = (tenantId2, executionId, kind, drainId) => JSON.stringify([tenantId2, executionId, kind, drainId]);
@@ -4923,94 +5280,161 @@ var consumedMessage = (message, input) => ({
   consumedAt: input.consumedAt,
   createdAt: message.createdAt
 });
-var messagesForDrain = (db, tenantId2, drain) => Effect19.gen(function* () {
-  if (drain.messageSequences.length === 0)
-    return { drain, messages: [] };
-  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* 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) => 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, 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,
-      executionId: input.executionId,
-      kind: input.kind,
-      sequence,
-      contentJson: input.content,
-      createdAt: toPgDate(input.createdAt)
-    }).returning();
+  const sql10 = yield* SqlClient12.SqlClient;
+  const lockQueue = sql10.onDialectOrElse({
+    pg: () => (tenantId2, executionId, kind) => sql10`SELECT pg_advisory_xact_lock(hashtext(${queueKey(tenantId2, executionId, kind)}))`.pipe(Effect19.asVoid),
+    orElse: () => () => Effect19.void
+  });
+  const selectMessagesBySequences = (tenantId2, executionId, kind, sequences) => sql10`
+      SELECT execution_id, kind, sequence, content_json, drain_id, consumed_at, created_at
+      FROM relay_steering_messages
+      WHERE tenant_id = ${tenantId2}
+        AND execution_id = ${executionId}
+        AND kind = ${kind}
+        AND ${sql10.in("sequence", sequences)}
+      ORDER BY sequence ASC
+    `;
+  const selectDrain = (tenantId2, input) => sql10`
+      SELECT execution_id, kind, drain_id, message_sequences_json, created_at
+      FROM relay_steering_drains
+      WHERE tenant_id = ${tenantId2}
+        AND execution_id = ${input.executionId}
+        AND kind = ${input.kind}
+        AND drain_id = ${input.drainId}
+    `;
+  const findDrain = Effect19.fn("SteeringRepository.findDrain")(function* (tenantId2, input) {
+    const rows = yield* selectDrain(tenantId2, input).pipe(Effect19.mapError(toRepositoryError5));
+    return rows[0] === undefined ? undefined : toDrainRecord(yield* decodeDrainRow(rows[0]));
+  });
+  const messagesForDrain = Effect19.fn("SteeringRepository.messagesForDrain")(function* (tenantId2, drain) {
+    if (drain.messageSequences.length === 0)
+      return { drain, messages: [] };
+    const rows = yield* selectMessagesBySequences(tenantId2, drain.executionId, drain.kind, [
+      ...drain.messageSequences
+    ]).pipe(Effect19.mapError(toRepositoryError5));
+    const messages = yield* Effect19.forEach(rows, (row) => decodeMessageRow(row).pipe(Effect19.map(toMessageRecord)));
+    return { drain, messages };
+  });
+  const insertMessage = sql10.onDialectOrElse({
+    mysql: () => (tenantId2, input, sequence) => Effect19.gen(function* () {
+      yield* sql10`
+            INSERT INTO relay_steering_messages (tenant_id, execution_id, kind, sequence, content_json, created_at)
+            VALUES (${tenantId2}, ${input.executionId}, ${input.kind}, ${sequence}, ${encodeJson(input.content)}, ${timestampParam(sql10, input.createdAt)})
+          `;
+      return yield* selectMessagesBySequences(tenantId2, input.executionId, input.kind, [sequence]);
+    }),
+    orElse: () => (tenantId2, input, sequence) => sql10`
+        INSERT INTO relay_steering_messages (tenant_id, execution_id, kind, sequence, content_json, created_at)
+        VALUES (${tenantId2}, ${input.executionId}, ${input.kind}, ${sequence}, ${encodeJson(input.content)}, ${timestampParam(sql10, input.createdAt)})
+        RETURNING execution_id, kind, sequence, content_json, drain_id, consumed_at, created_at
+      `
+  });
+  const insertDrain = sql10.onDialectOrElse({
+    mysql: () => (tenantId2, input, sequences) => Effect19.gen(function* () {
+      yield* sql10`
+            INSERT INTO relay_steering_drains (tenant_id, execution_id, kind, drain_id, message_sequences_json, created_at)
+            VALUES (${tenantId2}, ${input.executionId}, ${input.kind}, ${input.drainId}, ${encodeJson(sequences)}, ${timestampParam(sql10, input.createdAt)})
+          `;
+      return yield* selectDrain(tenantId2, input);
+    }),
+    orElse: () => (tenantId2, input, sequences) => sql10`
+        INSERT INTO relay_steering_drains (tenant_id, execution_id, kind, drain_id, message_sequences_json, created_at)
+        VALUES (${tenantId2}, ${input.executionId}, ${input.kind}, ${input.drainId}, ${encodeJson(sequences)}, ${timestampParam(sql10, input.createdAt)})
+        RETURNING execution_id, kind, drain_id, message_sequences_json, created_at
+      `
+  });
+  const selectExecutionStatus = sql10.onDialectOrElse({
+    sqlite: () => (tenantId2, executionId) => sql10`
+        SELECT status
+        FROM relay_executions
+        WHERE tenant_id = ${tenantId2} AND id = ${executionId}
+        LIMIT 1
+      `,
+    orElse: () => (tenantId2, executionId) => sql10`
+        SELECT status
+        FROM relay_executions
+        WHERE tenant_id = ${tenantId2} AND id = ${executionId}
+        LIMIT 1
+        FOR UPDATE
+      `
+  });
+  const appendInTransaction = Effect19.fn("SteeringRepository.appendInTransaction")(function* (tenantId2, input) {
+    yield* lockQueue(tenantId2, input.executionId, input.kind);
+    const sequenceRows = yield* sql10`
+        SELECT COALESCE(MAX(sequence), -1) + 1 AS next_sequence
+        FROM relay_steering_messages
+        WHERE tenant_id = ${tenantId2}
+          AND execution_id = ${input.executionId}
+          AND kind = ${input.kind}
+      `;
+    const sequence = Number(sequenceRows[0]?.next_sequence ?? 0);
+    const rows = yield* insertMessage(tenantId2, input, sequence);
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect19.fail(new SteeringRepositoryError({ message: "Steering message insert returned no row" }));
     }
-    return toMessageRecord(row);
+    return toMessageRecord(yield* decodeMessageRow(row));
   });
   const append2 = Effect19.fn("SteeringRepository.append")(function* (input) {
     const tenantId2 = yield* current;
-    return yield* mapTransactionError(db.transaction((tx) => appendInTransaction(tx, tenantId2, input)));
+    return yield* sql10.withTransaction(appendInTransaction(tenantId2, input)).pipe(mapTransactionError);
   });
   const appendForRunning = Effect19.fn("SteeringRepository.appendForRunning")(function* (input) {
     const tenantId2 = yield* current;
-    return yield* mapTransactionError(db.transaction((tx) => Effect19.gen(function* () {
-      const scopedTx = tx;
-      const status = yield* runningExecutionStatus(scopedTx, tenantId2, input.executionId);
+    return yield* sql10.withTransaction(Effect19.gen(function* () {
+      const statusRows = yield* selectExecutionStatus(tenantId2, input.executionId);
+      const status = statusRows[0]?.status;
       if (status === undefined) {
         return yield* Effect19.fail(new SteeringRepositoryError({ message: `Execution not found: ${input.executionId}` }));
       }
       if (status !== "running") {
         return yield* Effect19.fail(new SteeringRepositoryError({ message: `Execution is not running: ${input.executionId}` }));
       }
-      return yield* appendInTransaction(scopedTx, tenantId2, input);
-    })));
+      return yield* appendInTransaction(tenantId2, input);
+    })).pipe(mapTransactionError);
   });
   const drainUnconsumed = Effect19.fn("SteeringRepository.drainUnconsumed")(function* (input) {
     const tenantId2 = yield* current;
-    const existing = yield* findDrain(db, tenantId2, input);
+    const existing = yield* findDrain(tenantId2, input);
     if (existing !== undefined)
-      return yield* messagesForDrain(db, tenantId2, existing);
-    return yield* mapTransactionError(db.transaction((tx) => Effect19.gen(function* () {
-      const scopedTx = tx;
-      yield* lockQueue(scopedTx, tenantId2, input.executionId, input.kind);
-      const existingAfterLock = yield* findDrain(scopedTx, tenantId2, input);
+      return yield* messagesForDrain(tenantId2, existing);
+    return yield* sql10.withTransaction(Effect19.gen(function* () {
+      yield* lockQueue(tenantId2, input.executionId, input.kind);
+      const existingAfterLock = yield* findDrain(tenantId2, input);
       if (existingAfterLock !== undefined)
-        return yield* messagesForDrain(scopedTx, tenantId2, existingAfterLock);
-      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, 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);
-        return message === undefined ? [] : [message];
-      });
-      const drainRows = yield* tx.insert(relaySteeringDrains).values({
-        tenantId: tenantId2,
-        executionId: input.executionId,
-        kind: input.kind,
-        drainId: input.drainId,
-        messageSequencesJson: sequences,
-        createdAt: toPgDate(input.createdAt)
-      }).returning();
+        return yield* messagesForDrain(tenantId2, existingAfterLock);
+      const unconsumedRows = yield* sql10`
+              SELECT execution_id, kind, sequence, content_json, drain_id, consumed_at, created_at
+              FROM relay_steering_messages
+              WHERE tenant_id = ${tenantId2}
+                AND execution_id = ${input.executionId}
+                AND kind = ${input.kind}
+                AND consumed_at IS NULL
+              ORDER BY sequence ASC
+              ${input.mode === "one-at-a-time" ? sql10.literal("LIMIT 1") : sql10.literal("")}
+            `;
+      const unconsumed = yield* Effect19.forEach(unconsumedRows, decodeMessageRow);
+      const sequences = unconsumed.map((row) => Number(row.sequence));
+      if (sequences.length > 0) {
+        yield* sql10`
+                UPDATE relay_steering_messages
+                SET drain_id = ${input.drainId}, consumed_at = ${timestampParam(sql10, input.consumedAt)}
+                WHERE tenant_id = ${tenantId2}
+                  AND execution_id = ${input.executionId}
+                  AND kind = ${input.kind}
+                  AND ${sql10.in("sequence", sequences)}
+              `;
+      }
+      const messageRows = sequences.length === 0 ? [] : yield* selectMessagesBySequences(tenantId2, input.executionId, input.kind, sequences);
+      const messages = yield* Effect19.forEach(messageRows, (row) => decodeMessageRow(row).pipe(Effect19.map(toMessageRecord)));
+      const drainRows = yield* insertDrain(tenantId2, input, sequences);
       const drainRow = drainRows[0];
       if (drainRow === undefined) {
         return yield* Effect19.fail(new SteeringRepositoryError({ message: "Steering drain insert returned no row" }));
       }
-      return { drain: toDrainRecord(drainRow), messages: orderedMessages.map(toMessageRecord) };
-    })));
+      return { drain: toDrainRecord(yield* decodeDrainRow(drainRow)), messages };
+    })).pipe(mapTransactionError);
   });
   return Service19.of({ append: append2, appendForRunning, drainUnconsumed });
 }));
@@ -5111,7 +5535,7 @@ __export(exports_tool_call_repository, {
   DuplicateToolResult: () => DuplicateToolResult,
   DuplicateToolCall: () => DuplicateToolCall
 });
-import { asc as asc11, eq as eq16 } from "drizzle-orm";
+import { asc as asc9, eq as eq12 } 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
@@ -5172,15 +5596,15 @@ var toResultRecord = (row) => ({
   },
   createdAt: fromPgDate(row.createdAt)
 });
-var mapDatabaseError15 = (effect) => effect.pipe(Effect20.mapError((error) => new ToolCallRepositoryError({ message: String(error) })));
+var mapDatabaseError11 = (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* mapDatabaseError15(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq16(relayToolCalls.id, input.call.id))).limit(1));
+    const existingRows = yield* mapDatabaseError11(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq12(relayToolCalls.id, input.call.id))).limit(1));
     if (existingRows[0] !== undefined)
       return yield* Effect20.fail(new DuplicateToolCall({ id: input.call.id }));
-    const rows = yield* mapDatabaseError15(db.insert(relayToolCalls).values(toCallInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError11(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" }));
@@ -5189,24 +5613,24 @@ var layer20 = Layer20.effect(Service20, Effect20.gen(function* () {
   });
   const getCall = Effect20.fn("ToolCallRepository.getCall")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError15(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq16(relayToolCalls.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError11(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq12(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* mapDatabaseError15(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq16(relayToolCalls.executionId, executionId))).orderBy(asc11(relayToolCalls.createdAt)));
+    const rows = yield* mapDatabaseError11(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq12(relayToolCalls.executionId, executionId))).orderBy(asc9(relayToolCalls.createdAt)));
     return rows.map(toCallRecord);
   });
   const recordResult = Effect20.fn("ToolCallRepository.recordResult")(function* (input) {
     const tenantId2 = yield* current;
-    const callRows = yield* mapDatabaseError15(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq16(relayToolCalls.id, input.result.call_id))).limit(1));
+    const callRows = yield* mapDatabaseError11(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq12(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* mapDatabaseError15(db.select().from(relayToolResults).where(predicate(tenantId2, relayToolResults.tenantId, eq16(relayToolResults.toolCallId, input.result.call_id))).limit(1));
+    const existingRows = yield* mapDatabaseError11(db.select().from(relayToolResults).where(predicate(tenantId2, relayToolResults.tenantId, eq12(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* mapDatabaseError15(db.insert(relayToolResults).values(toResultInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError11(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" }));
@@ -5215,7 +5639,7 @@ var layer20 = Layer20.effect(Service20, Effect20.gen(function* () {
   });
   const getResult = Effect20.fn("ToolCallRepository.getResult")(function* (callId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError15(db.select().from(relayToolResults).where(predicate(tenantId2, relayToolResults.tenantId, eq16(relayToolResults.toolCallId, callId))).limit(1));
+    const rows = yield* mapDatabaseError11(db.select().from(relayToolResults).where(predicate(tenantId2, relayToolResults.tenantId, eq12(relayToolResults.toolCallId, callId))).limit(1));
     return rows[0] === undefined ? undefined : toResultRecord(rows[0]);
   });
   return Service20.of({ recordCall, getCall, listCalls, recordResult, getResult });
@@ -5296,7 +5720,7 @@ __export(exports_workspace_lease_repository, {
   Service: () => Service21,
   DuplicateWorkspaceLease: () => DuplicateWorkspaceLease
 });
-import { eq as eq17, notInArray } from "drizzle-orm";
+import { eq as eq13, 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
@@ -5366,8 +5790,8 @@ var toSnapshotRecord = (row) => ({
   metadata: row.metadataJson,
   created_at: fromPgDate(row.createdAt)
 });
-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) => {
+var mapDatabaseError12 = (effect) => effect.pipe(Effect21.mapError((error) => new WorkspaceLeaseRepositoryError({ message: String(error) })));
+var updateLease = (db, tenantId2, executionId, values) => mapDatabaseError12(db.update(relayWorkspaceLeases).set(values).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq13(relayWorkspaceLeases.executionId, executionId))).returning()).pipe(Effect21.flatMap((rows) => {
   const row = rows[0];
   if (row === undefined)
     return Effect21.fail(new WorkspaceLeaseNotFound({ execution_id: executionId }));
@@ -5377,16 +5801,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* mapDatabaseError16(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq17(relayWorkspaceLeases.executionId, id2))).limit(1));
+    const rows = yield* mapDatabaseError12(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq13(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* mapDatabaseError16(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq17(relayWorkspaceLeases.executionId, input.executionId), notInArray(relayWorkspaceLeases.status, [...terminalStatuses]))).limit(1));
+    const existing = yield* mapDatabaseError12(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq13(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* mapDatabaseError16(db.insert(relayWorkspaceLeases).values(toPlanInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError12(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" }));
@@ -5418,11 +5842,11 @@ var layer21 = Layer21.effect(Service21, Effect21.gen(function* () {
   });
   const recordSnapshot = Effect21.fn("WorkspaceLeaseRepository.recordSnapshot")(function* (input) {
     const tenantId2 = yield* current;
-    const leaseRows = yield* mapDatabaseError16(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq17(relayWorkspaceLeases.executionId, input.executionId))).limit(1));
+    const leaseRows = yield* mapDatabaseError12(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq13(relayWorkspaceLeases.executionId, input.executionId))).limit(1));
     if (leaseRows[0] === undefined) {
       return yield* Effect21.fail(new WorkspaceLeaseNotFound({ execution_id: input.executionId }));
     }
-    const rows = yield* mapDatabaseError16(db.insert(relayWorkspaceSnapshots).values(toSnapshotInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError12(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" }));
@@ -5608,7 +6032,7 @@ var recordWaitTransitioned = (state) => Metric.update(Metric.withAttributes(wait
 var recordChildRunSpawned = (kind) => Metric.update(Metric.withAttributes(childRunSpawned, { kind }), 1);
 var recordAddressResolved = (routeKind) => Metric.update(Metric.withAttributes(addressResolved, { route_kind: routeKind }), 1);
 var recordEventAppended = (eventType) => Metric.update(Metric.withAttributes(eventAppended, { event_type: eventType }), 1);
-var recordEventReplayed = (source, count2) => Metric.update(Metric.withAttributes(eventReplayed, { source }), count2);
+var recordEventReplayed = (source, count) => Metric.update(Metric.withAttributes(eventReplayed, { source }), count);
 var recordRunnerReadinessChecked = (database) => Metric.update(Metric.withAttributes(runnerReadinessChecked, { database }), 1);
 var recordModelUsage = (input) => Effect22.gen(function* () {
   yield* Metric.update(Metric.withAttributes(modelTokens, { direction: "input", provider: input.provider, model: input.model }), input.inputTokens);
@@ -5674,7 +6098,7 @@ var recordFromEntry = (entry) => ({
 });
 var entryIdFor = (addressId) => exports_ids_schema.AddressBookEntryId.make(`address-book:${addressId}`);
 var validateRoute = (route) => Schema32.decodeUnknownEffect(Route2)(route).pipe(Effect23.mapError((error) => new AddressBookServiceError({ message: String(error) })));
-var mapRepositoryError = (error) => {
+var mapRepositoryError2 = (error) => {
   if (error._tag === "AddressNotFound") {
     return new AddressNotFound2({ address_id: error.address_id });
   }
@@ -5685,7 +6109,7 @@ var layerFromRepository = Layer22.effect(Service22, Effect23.gen(function* () {
   return Service22.of({
     resolve: Effect23.fn("AddressBook.repository.resolve")(function* (addressId) {
       yield* Effect23.annotateCurrentSpan("relay.address.id", addressId);
-      const entry = yield* repository.resolve(addressId).pipe(Effect23.mapError(mapRepositoryError));
+      const entry = yield* repository.resolve(addressId).pipe(Effect23.mapError(mapRepositoryError2));
       const route = yield* resolveRoute(addressId, routeFromEntry(entry));
       yield* Effect23.annotateCurrentSpan({
         "relay.route.kind": route.kind,
@@ -6108,7 +6532,7 @@ var memoryLayer21 = Layer23.effect(Service23, Effect25.gen(function* () {
     }),
     maxSequence: Effect25.fn("EventLog.memory.maxSequence")(function* (executionId) {
       const executionEvents = yield* allEvents(executionId);
-      return executionEvents.length === 0 ? undefined : executionEvents.reduce((max3, event) => event.sequence > max3 ? event.sequence : max3, executionEvents[0].sequence);
+      return executionEvents.length === 0 ? undefined : executionEvents.reduce((max2, event) => event.sequence > max2 ? event.sequence : max2, executionEvents[0].sequence);
     }),
     sumUsage: Effect25.fn("EventLog.memory.sumUsage")(function* (executionId) {
       const executionEvents = yield* allEvents(executionId);
@@ -6194,7 +6618,7 @@ class WaitServiceError extends Schema34.TaggedErrorClass()("WaitServiceError", {
 
 class Service24 extends Context24.Service()("@relayfx/runtime/WaitService") {
 }
-var mapRepositoryError2 = (error) => {
+var mapRepositoryError3 = (error) => {
   if (error._tag === "WaitNotFound")
     return new WaitNotFound2({ wait_id: error.id });
   return new WaitServiceError({ message: error.message });
@@ -6269,7 +6693,7 @@ var createTimeoutSchedule = Effect26.fn("WaitService.createTimeoutSchedule")(fun
   }).pipe(Effect26.mapError((error) => new WaitServiceError({ message: error.message })));
 });
 var complete = Effect26.fn("WaitService.complete")(function* (repository, eventLog, input, event) {
-  const result = yield* repository.completeWait(input).pipe(Effect26.mapError(mapRepositoryError2));
+  const result = yield* repository.completeWait(input).pipe(Effect26.mapError(mapRepositoryError3));
   if (result.transitioned) {
     yield* eventLog.append(event(result.wait)).pipe(Effect26.mapError(mapEventLogError));
   }
@@ -6429,7 +6853,7 @@ var validateInput = (tool, input) => {
     return Effect27.void;
   return Schema35.decodeUnknownEffect(tool.inputSchema)(input.call.input).pipe(Effect27.mapError((error) => new ToolInputInvalid({ tool_name: input.call.name, message: error.message })), Effect27.asVoid);
 };
-var mapRepositoryError3 = (error) => new ToolRuntimeError({ message: error._tag });
+var mapRepositoryError4 = (error) => new ToolRuntimeError({ message: error._tag });
 var mapEventLogError2 = (error) => new ToolRuntimeError({ message: error._tag });
 var preserveToolError = (toolName, error) => {
   if (typeof error === "object" && error !== null && "_tag" in error) {
@@ -6446,7 +6870,7 @@ var preserveToolError = (toolName, error) => {
     message: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
   });
 };
-var preserveRecordResultError = (error) => error._tag === "ToolRuntimeError" ? error : mapRepositoryError3(error);
+var preserveRecordResultError = (error) => error._tag === "ToolRuntimeError" ? error : mapRepositoryError4(error);
 var requestedEvent = (input) => ({
   id: exports_ids_schema.EventId.make(`event:${input.call.id}:tool-requested`),
   execution_id: input.executionId,
@@ -6603,12 +7027,12 @@ var resolveApproval = (waits, eventLog, input) => Effect27.gen(function* () {
     return { _tag: "approved" };
   return { _tag: "denied", reason: deniedReason(existing.state) };
 });
-var recordRequested = (repository, eventLog, input) => repository.getCall(input.call.id).pipe(Effect27.mapError(mapRepositoryError3), Effect27.flatMap((existing) => {
+var recordRequested = (repository, eventLog, input) => repository.getCall(input.call.id).pipe(Effect27.mapError(mapRepositoryError4), Effect27.flatMap((existing) => {
   if (existing !== undefined)
     return Effect27.void;
-  return repository.recordCall({ executionId: input.executionId, call: input.call, createdAt: input.createdAt }).pipe(Effect27.mapError(mapRepositoryError3), Effect27.flatMap(() => appendIdempotentTo(eventLog, requestedEvent(input)).pipe(Effect27.mapError(mapEventLogError2))), Effect27.asVoid);
+  return repository.recordCall({ executionId: input.executionId, call: input.call, createdAt: input.createdAt }).pipe(Effect27.mapError(mapRepositoryError4), Effect27.flatMap(() => appendIdempotentTo(eventLog, requestedEvent(input)).pipe(Effect27.mapError(mapEventLogError2))), Effect27.asVoid);
 }));
-var recordReceived = (repository, eventLog, input, result) => repository.recordResult({ result, createdAt: input.createdAt + 1 }).pipe(Effect27.catchTag("DuplicateToolResult", () => repository.getResult(result.call_id).pipe(Effect27.mapError(mapRepositoryError3), Effect27.flatMap((existing) => existing === undefined ? Effect27.fail(new ToolRuntimeError({ message: "DuplicateToolResult" })) : Effect27.succeed(existing)))), Effect27.mapError(preserveRecordResultError), Effect27.flatMap((record2) => appendIdempotentTo(eventLog, resultEvent(input, record2.result)).pipe(Effect27.mapError(mapEventLogError2), Effect27.as(record2.result))));
+var recordReceived = (repository, eventLog, input, result) => repository.recordResult({ result, createdAt: input.createdAt + 1 }).pipe(Effect27.catchTag("DuplicateToolResult", () => repository.getResult(result.call_id).pipe(Effect27.mapError(mapRepositoryError4), Effect27.flatMap((existing) => existing === undefined ? Effect27.fail(new ToolRuntimeError({ message: "DuplicateToolResult" })) : Effect27.succeed(existing)))), Effect27.mapError(preserveRecordResultError), Effect27.flatMap((record2) => appendIdempotentTo(eventLog, resultEvent(input, record2.result)).pipe(Effect27.mapError(mapEventLogError2), Effect27.as(record2.result))));
 var definitionFromAiTool = (tool, permissions = []) => ({
   name: tool.name,
   description: Ai.Tool.getDescription(tool) ?? "",
@@ -6632,7 +7056,7 @@ var layer23 = (initialTools = []) => Layer25.effect(Service25, Effect27.gen(func
       if (tool === undefined) {
         return yield* Effect27.fail(new ToolNotRegistered({ tool_name: input.call.name }));
       }
-      const existingResult = yield* repository.getResult(input.call.id).pipe(Effect27.mapError(mapRepositoryError3));
+      const existingResult = yield* repository.getResult(input.call.id).pipe(Effect27.mapError(mapRepositoryError4));
       if (existingResult !== undefined)
         return existingResult.result;
       return yield* Effect27.gen(function* () {
@@ -6712,7 +7136,7 @@ var toPublicRevisionRecord = (record2) => ({
   ...record2.toolInputSchemaDigests === undefined ? {} : { tool_input_schema_digests: record2.toolInputSchemaDigests },
   created_at: record2.createdAt
 });
-var mapRepositoryError4 = (error) => new AgentRegistryError({ message: error.message });
+var mapRepositoryError5 = (error) => new AgentRegistryError({ message: error.message });
 var hasText = (value) => value === undefined || value.trim().length > 0;
 var requireText = (value, field) => value.trim().length === 0 ? Effect28.fail(new AgentDefinitionInvalid({ message: `${field} must not be blank` })) : Effect28.void;
 var requireOptionalText = (value, field) => hasText(value) ? Effect28.void : Effect28.fail(new AgentDefinitionInvalid({ message: `${field} must not be blank` }));
@@ -6791,23 +7215,23 @@ var layer24 = Layer26.effect(Service26, Effect28.gen(function* () {
       const selectedToolNames = input.definition.tool_names.filter((toolName) => toolDefinitions.some((definition) => definition.name === toolName));
       const crypto = yield* Effect28.serviceOption(Crypto2.Crypto);
       const toolInputSchemaDigests = selectedToolNames.length === 0 ? {} : Option7.isNone(crypto) ? yield* Effect28.fail(new AgentRegistryError({ message: "Tool input schema digest computation requires Crypto" })) : yield* digestDefinitions(toolDefinitions, selectedToolNames).pipe(Effect28.provideService(Crypto2.Crypto, crypto.value), Effect28.mapError((error) => new AgentRegistryError({ message: String(error) })));
-      const record2 = yield* repository.put({ id: input.id, definition: input.definition, toolInputSchemaDigests, now }).pipe(Effect28.mapError(mapRepositoryError4));
+      const record2 = yield* repository.put({ id: input.id, definition: input.definition, toolInputSchemaDigests, now }).pipe(Effect28.mapError(mapRepositoryError5));
       return { record: toPublicRecord(record2) };
     }),
     get: Effect28.fn("AgentRegistry.get")(function* (id2) {
-      const record2 = yield* repository.get(id2).pipe(Effect28.mapError(mapRepositoryError4));
+      const record2 = yield* repository.get(id2).pipe(Effect28.mapError(mapRepositoryError5));
       return record2 === undefined ? undefined : toPublicRecord(record2);
     }),
     getRevision: Effect28.fn("AgentRegistry.getRevision")(function* (input) {
-      const record2 = yield* repository.getRevision(input).pipe(Effect28.mapError(mapRepositoryError4));
+      const record2 = yield* repository.getRevision(input).pipe(Effect28.mapError(mapRepositoryError5));
       return record2 === undefined ? undefined : toPublicRevisionRecord(record2);
     }),
     list: Effect28.fn("AgentRegistry.list")(function* () {
-      const records = yield* repository.list().pipe(Effect28.mapError(mapRepositoryError4));
+      const records = yield* repository.list().pipe(Effect28.mapError(mapRepositoryError5));
       return { records: records.map(toPublicRecord) };
     }),
     listRevisions: Effect28.fn("AgentRegistry.listRevisions")(function* (id2) {
-      const records = yield* repository.listRevisions(id2).pipe(Effect28.mapError(mapRepositoryError4));
+      const records = yield* repository.listRevisions(id2).pipe(Effect28.mapError(mapRepositoryError5));
       return { records: records.map(toPublicRevisionRecord) };
     })
   });
@@ -8748,7 +9172,7 @@ var spawnedEvent = (input, kind, context, presetName, workspaceRef) => ({
   },
   created_at: input.createdAt
 });
-var mapRepositoryError5 = (error) => new ChildRunServiceError({ message: error._tag });
+var mapRepositoryError6 = (error) => new ChildRunServiceError({ message: error._tag });
 var mapEventLogError3 = (error) => new ChildRunServiceError({ message: error._tag });
 var persistChild = Effect50.fn("ChildRunService.persistChild")(function* (repository, eventLog, input, kind, context, presetName) {
   const workspaceRef = yield* childWorkspaceRef(input, context);
@@ -8759,7 +9183,7 @@ var persistChild = Effect50.fn("ChildRunService.persistChild")(function* (reposi
     status: "queued",
     metadata: childMetadata(kind, context, presetName, workspaceRef),
     createdAt: input.createdAt
-  }).pipe(Effect50.mapError(mapRepositoryError5));
+  }).pipe(Effect50.mapError(mapRepositoryError6));
   yield* eventLog.append(spawnedEvent(input, kind, context, presetName, workspaceRef)).pipe(Effect50.mapError(mapEventLogError3));
   return acceptedOutput(input);
 });
@@ -8901,7 +9325,7 @@ var hasDynamicOverride = (input) => input.instructions !== undefined || input.mo
 var childExecutionId = (context) => exports_ids_schema.ChildExecutionId.make(`${context.executionId}:child:${context.call.id}`);
 var childAddressId = (id2) => exports_ids_schema.AddressId.make(`address:child:${id2}`);
 var childWaitId = (id2) => exports_ids_schema.WaitId.make(`wait:child:${id2}`);
-var nextEventSequence = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect51.map((max3) => max3 === undefined ? 0 : max3 + 1), Effect51.mapError((error) => new ToolRuntimeError({ message: error.message })));
+var nextEventSequence = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect51.map((max2) => max2 === undefined ? 0 : max2 + 1), Effect51.mapError((error) => new ToolRuntimeError({ message: error.message })));
 var mapChildRunError = (activeToolName, error) => new ToolExecutionFailed({ tool_name: activeToolName, message: error._tag });
 var mapWaitError = (error) => new ToolRuntimeError({ message: error._tag === "WaitNotFound" ? error.wait_id : error.message });
 var spawnInput = (config, input, context, id2) => ({
@@ -9814,7 +10238,7 @@ var layer39 = exports_approvals.autoApprove;
 // ../runtime/src/agent/relay-compaction.ts
 import { Clock as Clock4, Effect as Effect60, Layer as Layer54 } from "effect";
 var checkpointId = (input) => `compaction:${input.executionId}:turn:${input.turn}:keep:${input.firstKeptEntryId}`;
-var mapRepositoryError6 = (error) => new exports_compaction.CompactionError({ message: error.message, cause: error });
+var mapRepositoryError7 = (error) => new exports_compaction.CompactionError({ message: error.message, cause: error });
 var sameCheckpointBoundary = (record2, input) => record2.firstKeptEntryId === input.firstKeptEntryId && record2.turn === input.turn;
 var defaultOptions = (options) => ({
   ...options?.contextWindow === undefined ? {} : { contextWindow: options.contextWindow },
@@ -9833,7 +10257,7 @@ var strategy = (config) => {
         firstKeptEntryId: plan2.firstKeptEntryId
       });
       return Effect60.gen(function* () {
-        const existing = yield* config.repository.get({ executionId: config.executionId, checkpointId: id2 }).pipe(Effect60.mapError(mapRepositoryError6));
+        const existing = yield* config.repository.get({ executionId: config.executionId, checkpointId: id2 }).pipe(Effect60.mapError(mapRepositoryError7));
         if (existing !== undefined)
           return existing.summary;
         const summary = yield* base.summarize(plan2, request);
@@ -9847,7 +10271,7 @@ var strategy = (config) => {
           createdAt
         };
         const record2 = yield* config.repository.record(input).pipe(Effect60.matchEffect({
-          onFailure: (error) => config.repository.get({ executionId: config.executionId, checkpointId: id2 }).pipe(Effect60.mapError(mapRepositoryError6), Effect60.flatMap((saved) => saved !== undefined && sameCheckpointBoundary(saved, input) ? Effect60.succeed(saved) : Effect60.fail(mapRepositoryError6(error)))),
+          onFailure: (error) => config.repository.get({ executionId: config.executionId, checkpointId: id2 }).pipe(Effect60.mapError(mapRepositoryError7), Effect60.flatMap((saved) => saved !== undefined && sameCheckpointBoundary(saved, input) ? Effect60.succeed(saved) : Effect60.fail(mapRepositoryError7(error)))),
           onSuccess: Effect60.succeed
         }));
         return record2.summary;
@@ -9909,7 +10333,7 @@ var evaluateDecision = Effect61.fn("RelayPermissions.evaluateDecision")(function
 });
 var permissionError = (message) => new exports_permissions.PermissionError({ message });
 var createdAtForSequence = (config, sequence) => config.startedAt + sequence - config.eventSequence;
-var nextLoggedSequence = (eventLog, executionId, fallback) => eventLog.maxSequence(executionId).pipe(Effect61.mapError((error) => permissionError(error.message)), Effect61.map((max3) => max3 === undefined ? fallback : Math.max(max3 + 1, fallback)));
+var nextLoggedSequence = (eventLog, executionId, fallback) => eventLog.maxSequence(executionId).pipe(Effect61.mapError((error) => permissionError(error.message)), Effect61.map((max2) => max2 === undefined ? fallback : Math.max(max2 + 1, fallback)));
 var allocateEventSequence = Effect61.fn("RelayPermissions.allocateEventSequence")(function* (config) {
   const fallback = yield* config.allocator.allocate(1);
   const sequence = yield* nextLoggedSequence(config.eventLog, config.executionId, fallback);
@@ -10141,7 +10565,7 @@ var errorDetail = (error) => {
       return error.tool_name;
   }
 };
-var nextLoggedSequence2 = (eventLog, executionId, fallback) => eventLog.maxSequence(executionId).pipe(Effect63.map((max3) => max3 === undefined ? fallback : Math.max(max3 + 1, fallback)), Effect63.catch(() => Effect63.succeed(fallback)));
+var nextLoggedSequence2 = (eventLog, executionId, fallback) => eventLog.maxSequence(executionId).pipe(Effect63.map((max2) => max2 === undefined ? fallback : Math.max(max2 + 1, fallback)), Effect63.catch(() => Effect63.succeed(fallback)));
 var requestedCursor = (executionId, callId) => `${executionId}:tool:${callId}:requested`;
 var hasRequestedEvent = (config, callId) => config.eventLog.findByCursor({
   executionId: config.executionId,
@@ -10226,7 +10650,7 @@ var layer43 = Layer58.effect(exports_tool_output.ToolOutputStore, Service37.pipe
 // ../runtime/src/agent/sequence-allocator.ts
 import { Effect as Effect65, Ref as Ref17 } from "effect";
 var make12 = (first) => Ref17.make(first).pipe(Effect65.map((ref) => ({
-  allocate: (count2) => Ref17.getAndUpdate(ref, (value) => value + count2),
+  allocate: (count) => Ref17.getAndUpdate(ref, (value) => value + count),
   current: Ref17.get(ref),
   resetTo: (sequence) => Ref17.set(ref, sequence)
 })));
@@ -10877,7 +11301,7 @@ var make13 = Effect67.fn("ParentNotifier.make")(function* (options) {
   const eventLog = yield* Service23;
   const repository = yield* exports_child_execution_repository.Service;
   const waits = yield* Service24;
-  const nextSequence = (executionId) => eventLog.maxSequence(executionId).pipe(Effect67.map((max3) => max3 === undefined ? 0 : max3 + 1), Effect67.mapError(toParentNotifyError));
+  const nextSequence = (executionId) => eventLog.maxSequence(executionId).pipe(Effect67.map((max2) => max2 === undefined ? 0 : max2 + 1), Effect67.mapError(toParentNotifyError));
   const appendTerminalEvent = (input) => Effect67.gen(function* () {
     const sequence = yield* nextSequence(input.parentExecutionId);
     const event = childRunEvent(input, sequence);
@@ -10988,7 +11412,7 @@ var toPublicPinRecord = (record2) => ({
   skill_definition_snapshot: record2.skillDefinitionSnapshot,
   created_at: record2.createdAt
 });
-var mapRepositoryError7 = (error) => new SkillRegistryError({ message: error.message });
+var mapRepositoryError8 = (error) => new SkillRegistryError({ message: error.message });
 var requireText2 = (value, field) => value.trim().length === 0 ? Effect68.fail(new SkillDefinitionInvalid({ message: `${field} must not be blank` })) : Effect68.void;
 var requireOptionalText2 = (value, field) => value === undefined || value.trim().length > 0 ? Effect68.void : Effect68.fail(new SkillDefinitionInvalid({ message: `${field} must not be blank` }));
 var validateDefinition2 = Effect68.fn("SkillRegistry.validateDefinition")(function* (definition) {
@@ -11033,23 +11457,23 @@ var layer45 = Layer61.effect(Service42, Effect68.gen(function* () {
     register: Effect68.fn("SkillRegistry.register")(function* (input) {
       yield* validateDefinition2(input.definition);
       const now = yield* Clock7.currentTimeMillis;
-      const record2 = yield* repository.put({ id: input.id, definition: input.definition, now }).pipe(Effect68.mapError(mapRepositoryError7));
+      const record2 = yield* repository.put({ id: input.id, definition: input.definition, now }).pipe(Effect68.mapError(mapRepositoryError8));
       return { record: toPublicRecord2(record2) };
     }),
     get: Effect68.fn("SkillRegistry.get")(function* (id2) {
-      const record2 = yield* repository.get(id2).pipe(Effect68.mapError(mapRepositoryError7));
+      const record2 = yield* repository.get(id2).pipe(Effect68.mapError(mapRepositoryError8));
       return record2 === undefined ? undefined : toPublicRecord2(record2);
     }),
     getRevision: Effect68.fn("SkillRegistry.getRevision")(function* (input) {
-      const record2 = yield* repository.getRevision(input).pipe(Effect68.mapError(mapRepositoryError7));
+      const record2 = yield* repository.getRevision(input).pipe(Effect68.mapError(mapRepositoryError8));
       return record2 === undefined ? undefined : toPublicRevisionRecord2(record2);
     }),
     list: Effect68.fn("SkillRegistry.list")(function* () {
-      const records = yield* repository.list().pipe(Effect68.mapError(mapRepositoryError7));
+      const records = yield* repository.list().pipe(Effect68.mapError(mapRepositoryError8));
       return { records: records.map(toPublicRecord2) };
     }),
     listRevisions: Effect68.fn("SkillRegistry.listRevisions")(function* (id2) {
-      const records = yield* repository.listRevisions(id2).pipe(Effect68.mapError(mapRepositoryError7));
+      const records = yield* repository.listRevisions(id2).pipe(Effect68.mapError(mapRepositoryError8));
       return { records: records.map(toPublicRevisionRecord2) };
     }),
     pinExecution: Effect68.fn("SkillRegistry.pinExecution")(function* (input) {
@@ -11058,15 +11482,15 @@ var layer45 = Layer61.effect(Service42, Effect68.gen(function* () {
         executionId: input.execution_id,
         skillDefinitionIds: input.skill_definition_ids,
         now
-      }).pipe(Effect68.mapError(mapRepositoryError7));
+      }).pipe(Effect68.mapError(mapRepositoryError8));
       return { records: records.map(toPublicPinRecord) };
     }),
     listPins: Effect68.fn("SkillRegistry.listPins")(function* (executionId) {
-      const records = yield* repository.listPins(executionId).pipe(Effect68.mapError(mapRepositoryError7));
+      const records = yield* repository.listPins(executionId).pipe(Effect68.mapError(mapRepositoryError8));
       return { records: records.map(toPublicPinRecord) };
     }),
     getPinned: Effect68.fn("SkillRegistry.getPinned")(function* (input) {
-      const record2 = yield* repository.getPinned(input).pipe(Effect68.mapError(mapRepositoryError7));
+      const record2 = yield* repository.getPinned(input).pipe(Effect68.mapError(mapRepositoryError8));
       return record2 === undefined ? undefined : toPublicPinRecord(record2);
     })
   });
@@ -11154,7 +11578,7 @@ var toExecution = (record2) => ({
   created_at: record2.createdAt,
   updated_at: record2.updatedAt
 });
-var mapRepositoryError8 = (error) => new ExecutionServiceError({ message: error._tag });
+var mapRepositoryError9 = (error) => new ExecutionServiceError({ message: error._tag });
 var mapEventLogError4 = (error) => new ExecutionServiceError({ message: error._tag });
 var mapChildRunError2 = (error) => new ExecutionServiceError({ message: error._tag });
 var childExecutionId2 = (input) => input.child_execution_id ?? exports_ids_schema.ChildExecutionId.make(`${input.execution_id}:child:${input.address_id}`);
@@ -11164,8 +11588,8 @@ var hasCompleteAgentDefinitionPin2 = (input) => {
     input.agentDefinitionRevision !== undefined,
     input.agentDefinitionSnapshot !== undefined
   ];
-  const count2 = present.filter(Boolean).length;
-  return count2 === 0 || count2 === present.length;
+  const count = present.filter(Boolean).length;
+  return count === 0 || count === present.length;
 };
 var validateAcceptInput = (input) => !hasCompleteAgentDefinitionPin2(input) ? Effect69.fail(new ExecutionServiceError({
   message: "agent definition pin must include id, revision, and snapshot together"
@@ -11207,8 +11631,8 @@ var presetMap2 = (presets) => new Map(Object.entries(presets ?? {}).map(([name,
 var nextEventSequence2 = Effect69.fn("ExecutionService.nextEventSequence")(function* (eventLog, input) {
   if (input.event_sequence !== undefined)
     return input.event_sequence;
-  const max3 = yield* eventLog.maxSequence(input.execution_id).pipe(Effect69.mapError(mapEventLogError4));
-  return max3 === undefined ? 0 : max3 + 1;
+  const max2 = yield* eventLog.maxSequence(input.execution_id).pipe(Effect69.mapError(mapEventLogError4));
+  return max2 === undefined ? 0 : max2 + 1;
 });
 var childRunBaseInput = Effect69.fn("ExecutionService.childRunBaseInput")(function* (eventLog, input) {
   const eventSequence = yield* nextEventSequence2(eventLog, input);
@@ -11305,7 +11729,7 @@ var updateStatus2 = Effect69.fn("ExecutionService.updateStatus")(function* (repo
     status,
     updatedAt,
     ...metadata11 === undefined ? {} : { metadata: metadata11 }
-  }).pipe(Effect69.mapError(mapRepositoryError8));
+  }).pipe(Effect69.mapError(mapRepositoryError9));
   return toExecution(record2);
 });
 var layer46 = Layer62.effect(Service43, Effect69.gen(function* () {
@@ -11340,7 +11764,7 @@ var layer46 = Layer62.effect(Service43, Effect69.gen(function* () {
         ...input.agentDefinitionSnapshot === undefined ? {} : { agentDefinitionSnapshot: input.agentDefinitionSnapshot },
         ...input.agentDefinitionToolInputSchemaDigests === undefined ? {} : { agentDefinitionToolInputSchemaDigests: input.agentDefinitionToolInputSchemaDigests },
         ...input.metadata === undefined ? {} : { metadata: input.metadata }
-      }).pipe(Effect69.mapError(mapRepositoryError8));
+      }).pipe(Effect69.mapError(mapRepositoryError9));
       yield* eventLog.append(acceptedEvent(input)).pipe(Effect69.mapError(mapEventLogError4));
       yield* recordExecutionAccepted;
       return toExecution(record2);
@@ -11514,13 +11938,13 @@ var selectedDefinitions = (input) => {
 var requiresWorkspace = (definition) => definition.requirements?.some((requirement) => requirement.type === "workspace") ?? false;
 var needsWorkspace = (input) => selectedDefinitions(input).some(requiresWorkspace);
 var leaseId = (executionId) => exports_ids_schema.WorkspaceLeaseId.make(`workspace-lease:${executionId}`);
-var mapRepositoryError9 = (error) => new WorkspacePlannerError({ message: error._tag });
+var mapRepositoryError10 = (error) => new WorkspacePlannerError({ message: error._tag });
 var mapEventLogError5 = (error) => new WorkspacePlannerError({ message: error._tag });
 var providerOrMissing = (executionId) => Effect71.serviceOption(Service29).pipe(Effect71.flatMap((provider) => Option25.match(provider, {
   onNone: () => Effect71.fail(new WorkspaceRuntimeMissing({ execution_id: executionId })),
   onSome: Effect71.succeed
 })));
-var nextEventSequence3 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect71.map((max3) => max3 === undefined ? 0 : max3 + 1), Effect71.catch(() => Effect71.succeed(0)));
+var nextEventSequence3 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect71.map((max2) => max2 === undefined ? 0 : max2 + 1), Effect71.catch(() => Effect71.succeed(0)));
 var workspaceEvent = (type, lease, sequence, createdAt) => ({
   id: exports_ids_schema.EventId.make(`event:${lease.execution_id}:workspace:${type}:${sequence}`),
   execution_id: lease.execution_id,
@@ -11556,13 +11980,13 @@ var missingRef = (executionId) => new WorkspaceLeaseMissingRef({ execution_id: e
 var ensureFromExisting = Effect71.fn("WorkspacePlanner.ensureFromExisting")(function* (repository, eventLog, provider, lease, input) {
   if (lease.sandbox_ref === undefined) {
     const handle2 = yield* provider.acquire(providerAcquireSpec(input));
-    const running2 = yield* repository.markRunning({ executionId: input.executionId, sandboxRef: handle2.ref, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError9));
+    const running2 = yield* repository.markRunning({ executionId: input.executionId, sandboxRef: handle2.ref, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError10));
     const sequence2 = yield* nextEventSequence3(eventLog, input.executionId);
     yield* appendWorkspaceEvent(eventLog, "workspace.lease.acquired", running2, sequence2, input.now);
     return planResult(running2, handle2);
   }
   const handle = yield* provider.resume(lease.sandbox_ref);
-  const running = yield* repository.markResumed({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError9));
+  const running = yield* repository.markResumed({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError10));
   const sequence = yield* nextEventSequence3(eventLog, input.executionId);
   yield* appendWorkspaceEvent(eventLog, "workspace.resumed", running, sequence, input.now);
   return planResult(running, handle);
@@ -11575,21 +11999,21 @@ var layer47 = Layer64.effect(Service45, Effect71.gen(function* () {
       if (!needsWorkspace(input))
         return;
       const provider = yield* providerOrMissing(input.executionId);
-      const existing = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError9));
+      const existing = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError10));
       if (existing !== undefined && existing.status !== "released" && existing.status !== "failed") {
         return yield* ensureFromExisting(repository, eventLog, provider, existing, input);
       }
-      const planned = yield* repository.plan(planInput(input, provider)).pipe(Effect71.mapError(mapRepositoryError9));
+      const planned = yield* repository.plan(planInput(input, provider)).pipe(Effect71.mapError(mapRepositoryError10));
       let sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.lease.planned", planned, sequence, input.now);
       const handle = yield* provider.acquire(providerAcquireSpec(input));
-      const running = yield* repository.markRunning({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError9));
+      const running = yield* repository.markRunning({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError10));
       sequence += 1;
       yield* appendWorkspaceEvent(eventLog, "workspace.lease.acquired", running, sequence, input.now);
       return planResult(running, handle);
     }),
     suspend: Effect71.fn("WorkspacePlanner.suspend")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError9));
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       if (lease.sandbox_ref === undefined)
@@ -11604,26 +12028,26 @@ var layer47 = Layer64.effect(Service45, Effect71.gen(function* () {
       if (provider.capabilities.can_suspend) {
         yield* provider.suspend(lease.sandbox_ref);
       }
-      const suspended2 = yield* repository.markSuspended({ executionId: input.executionId, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError9));
+      const suspended2 = yield* repository.markSuspended({ executionId: input.executionId, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError10));
       const sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.suspended", suspended2, sequence, input.now);
       return suspended2;
     }),
     resume: Effect71.fn("WorkspacePlanner.resume")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError9));
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       if (lease.sandbox_ref === undefined)
         return yield* Effect71.fail(missingRef(input.executionId));
       const provider = yield* providerOrMissing(input.executionId);
       const handle = yield* provider.resume(lease.sandbox_ref);
-      const running = yield* repository.markResumed({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError9));
+      const running = yield* repository.markResumed({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError10));
       const sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.resumed", running, sequence, input.now);
       return planResult(running, handle);
     }),
     attach: Effect71.fn("WorkspacePlanner.attach")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError9));
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       if (lease.sandbox_ref === undefined)
@@ -11633,27 +12057,27 @@ var layer47 = Layer64.effect(Service45, Effect71.gen(function* () {
       return planResult(lease, handle);
     }),
     release: Effect71.fn("WorkspacePlanner.release")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError9));
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       if (lease.sandbox_ref === undefined)
         return yield* Effect71.fail(missingRef(input.executionId));
       const provider = yield* providerOrMissing(input.executionId);
       yield* provider.destroy(lease.sandbox_ref);
-      const released = yield* repository.markReleased({ executionId: input.executionId, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError9));
+      const released = yield* repository.markReleased({ executionId: input.executionId, updatedAt: input.now }).pipe(Effect71.mapError(mapRepositoryError10));
       const sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.lease.released", released, sequence, input.now);
       return released;
     }),
     fail: Effect71.fn("WorkspacePlanner.fail")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError9));
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect71.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       const failed = yield* repository.markFailed({
         executionId: input.executionId,
         updatedAt: input.now,
         ...input.metadata === undefined ? {} : { metadata: input.metadata }
-      }).pipe(Effect71.mapError(mapRepositoryError9));
+      }).pipe(Effect71.mapError(mapRepositoryError10));
       const sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.lease.failed", failed, sequence, input.now);
       return failed;
@@ -11798,7 +12222,7 @@ var mapWaitError2 = (error) => new ExecutionWorkflowFailed({
   message: error._tag === "WaitNotFound" ? `Wait not found: ${error.wait_id}` : error.message
 });
 var mapAddressResolutionError = (error) => new ExecutionWorkflowFailed({ message: error._tag });
-var mapRepositoryError10 = (error) => new ExecutionWorkflowFailed({ message: error._tag });
+var mapRepositoryError11 = (error) => new ExecutionWorkflowFailed({ message: error._tag });
 var mapChildExecutionRepositoryError = (error) => new ExecutionWorkflowFailed({ message: error._tag });
 var mapSkillRegistryError = (error) => new ExecutionWorkflowFailed({ message: error.message });
 var mapEventLogError6 = (error) => new ExecutionWorkflowFailed({ message: error._tag });
@@ -11888,7 +12312,7 @@ var openChildStatuses = new Set(["queued", "running", "waiting"]);
 var childCancelReason = "parent cancelled";
 var cancelChildExecution = Effect72.fn("ExecutionWorkflow.cancelChildExecution")(function* (executionId, cancelledAt) {
   const repository = yield* exports_execution_repository.Service;
-  const record2 = yield* repository.get(executionId).pipe(Effect72.mapError(mapRepositoryError10));
+  const record2 = yield* repository.get(executionId).pipe(Effect72.mapError(mapRepositoryError11));
   if (record2 === undefined || terminalExecutionStatuses.has(record2.status))
     return;
   if (record2.status === "waiting") {
@@ -11923,7 +12347,7 @@ var cancelChildExecution = Effect72.fn("ExecutionWorkflow.cancelChildExecution")
       cancellation_requested: true,
       cancellation_reason: childCancelReason
     }
-  }).pipe(Effect72.mapError(mapRepositoryError10));
+  }).pipe(Effect72.mapError(mapRepositoryError11));
 });
 var cancelOpenChildren = Effect72.fn("ExecutionWorkflow.cancelOpenChildren")(function* (executionId, cancelledAt) {
   const children = yield* exports_child_execution_repository.listByExecution(executionId).pipe(Effect72.mapError(mapChildExecutionRepositoryError));
@@ -11964,7 +12388,7 @@ var loadCancellationRequested = (input, turn) => Activity.make({
   error: ExecutionWorkflowFailed,
   execute: Effect72.gen(function* () {
     const repository = yield* exports_execution_repository.Service;
-    const record2 = yield* repository.get(input.execution_id).pipe(Effect72.mapError(mapRepositoryError10));
+    const record2 = yield* repository.get(input.execution_id).pipe(Effect72.mapError(mapRepositoryError11));
     return record2?.metadata?.cancellation_requested === true;
   })
 });
@@ -11987,7 +12411,7 @@ var markWaiting = (input, repository, wait) => Activity.make({
       wait_state: wait.state,
       ...generationMetadata(workflowGenerationForStart(input))
     }
-  }).pipe(Effect72.mapError(mapRepositoryError10), Effect72.map((record2) => ({
+  }).pipe(Effect72.mapError(mapRepositoryError11), Effect72.map((record2) => ({
     id: record2.id,
     root_address_id: record2.rootAddressId,
     ...record2.sessionId === undefined ? {} : { session_id: record2.sessionId },
@@ -12076,7 +12500,7 @@ var steeringEnabledForStart = (input) => {
     return executionSetting === true;
   return steeringMetadataValue(input.agent_definition_snapshot?.metadata) === true;
 };
-var nextEventSequence4 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect72.map((max3) => max3 === undefined ? 0 : max3 + 1), Effect72.mapError(mapEventLogError6));
+var nextEventSequence4 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect72.map((max2) => max2 === undefined ? 0 : max2 + 1), Effect72.mapError(mapEventLogError6));
 var ensureWorkspace = (input) => Activity.make({
   name: ActivityNames.ensureWorkspace,
   success: Schema66.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
@@ -12403,7 +12827,7 @@ var startRequest = Effect72.fn("ExecutionWorkflow.startRequest")(function* (inpu
 });
 var cancelRequest = Effect72.fn("ExecutionWorkflow.cancelRequest")(function* (input) {
   const repository = yield* exports_execution_repository.Service;
-  const record2 = yield* repository.get(input.execution_id).pipe(Effect72.mapError(mapRepositoryError10));
+  const record2 = yield* repository.get(input.execution_id).pipe(Effect72.mapError(mapRepositoryError11));
   if (record2 === undefined) {
     return yield* Effect72.fail(new ExecutionWorkflowFailed({ message: `Execution not found: ${input.execution_id}` }));
   }
@@ -12443,7 +12867,7 @@ var cancelRequest = Effect72.fn("ExecutionWorkflow.cancelRequest")(function* (in
       cancellation_requested: true,
       ...input.reason === undefined ? {} : { cancellation_reason: input.reason }
     }
-  }).pipe(Effect72.mapError(mapRepositoryError10));
+  }).pipe(Effect72.mapError(mapRepositoryError11));
   return { execution_id: record2.id, status: record2.status };
 });
 var poll = (executionId) => StartExecutionWorkflow.poll(executionId);
@@ -12460,7 +12884,7 @@ var workflowExecutionIdForExecution = (executionId, workflowGeneration = 0) => S
 });
 var activeWorkflowExecutionIdForExecution = Effect72.fn("ExecutionWorkflow.activeWorkflowExecutionIdForExecution")(function* (executionId) {
   const repository = yield* exports_execution_repository.Service;
-  const record2 = yield* repository.get(executionId).pipe(Effect72.mapError(mapRepositoryError10));
+  const record2 = yield* repository.get(executionId).pipe(Effect72.mapError(mapRepositoryError11));
   return yield* workflowExecutionIdForExecution(executionId, record2 === undefined ? 0 : workflowGenerationFromRecord(record2));
 });
 var signalWait = Effect72.fn("ExecutionWorkflow.signalWait")(function* (input) {
@@ -12552,7 +12976,7 @@ var mapAddressBookError2 = (error) => {
   }
   return new EnvelopeServiceError({ message: error.message });
 };
-var mapRepositoryError11 = (error) => new EnvelopeServiceError({ message: error.message });
+var mapRepositoryError12 = (error) => new EnvelopeServiceError({ message: error.message });
 var mapEventLogError7 = (error) => new EnvelopeServiceError({ message: error._tag });
 var envelopeFrom = (input) => ({
   id: input.envelopeId,
@@ -12647,7 +13071,7 @@ var layer50 = Layer66.effect(Service46, Effect73.gen(function* () {
         envelope,
         ...waitId === undefined ? {} : { waitId },
         ...ready === undefined ? {} : { ready }
-      }).pipe(Effect73.mapError(mapRepositoryError11));
+      }).pipe(Effect73.mapError(mapRepositoryError12));
       yield* eventLog.append(acceptedEvent2(input)).pipe(Effect73.mapError(mapEventLogError7));
       yield* eventLog.append(routedEvent(input, route)).pipe(Effect73.mapError(mapEventLogError7));
       if (ready !== undefined) {
@@ -12787,8 +13211,8 @@ var dispatchMetadata = (schedule) => ({
   schedule_id: schedule.id
 });
 var nextEventSequence5 = Effect75.fn("SchedulerService.nextEventSequence")(function* (eventLog, executionId) {
-  const max3 = yield* eventLog.maxSequence(executionId).pipe(Effect75.mapError(toSchedulerError));
-  return max3 === undefined ? 0 : max3 + 1;
+  const max2 = yield* eventLog.maxSequence(executionId).pipe(Effect75.mapError(toSchedulerError));
+  return max2 === undefined ? 0 : max2 + 1;
 });
 var make14 = Effect75.gen(function* () {
   const schedules = yield* exports_schedule_repository.Service;
@@ -13631,8 +14055,8 @@ var toLease = (record2) => ({
   claim_expires_at: record2.claimExpiresAt ?? record2.updatedAt
 });
 var nextEventSequence6 = Effect78.fn("Client.nextEventSequence")(function* (eventLog, executionId) {
-  const max3 = yield* eventLog.maxSequence(executionId).pipe(Effect78.mapError(toClientError));
-  return max3 === undefined ? 0 : max3 + 1;
+  const max2 = yield* eventLog.maxSequence(executionId).pipe(Effect78.mapError(toClientError));
+  return max2 === undefined ? 0 : max2 + 1;
 });
 var wakeRuntime = Effect78.fn("Client.wakeRuntime")(function* (waits, eventLog, executionRepository, makeExecutionClient, input) {
   const wait = yield* waits.get(input.wait_id).pipe(Effect78.mapError(toClientError));