@relayfx/sdk 0.0.27 → 0.0.28

package/dist/index.js

@@ -863,10 +863,11 @@ __export(exports_address_book_repository, {
   Service: () => Service3,
   RouteKind: () => RouteKind2,
   AddressNotFound: () => AddressNotFound,
+  AddressBookRow: () => AddressBookRow,
   AddressBookRepositoryError: () => AddressBookRepositoryError
 });
-import { asc, eq as eq2, sql as sql3 } from "drizzle-orm";
-import { Context as Context3, Effect as Effect3, Layer as Layer3, Schema as Schema13 } from "effect";
+import { Clock, Context as Context3, Effect as Effect3, Layer as Layer3, Schema as Schema13 } from "effect";
+import * as SqlClient3 from "effect/unstable/sql/SqlClient";
 
 // ../store-sql/src/database/database-service.ts
 var exports_database_service = {};
@@ -954,539 +955,143 @@ var encodeJson = (value) => JSON.stringify(value);
 var decodeJson = (value) => typeof value === "string" ? JSON.parse(value) : value;
 var decodeBool = (value) => value === true || value === 1 || value === "1";
 
-// ../store-sql/src/schema/relay-schema.ts
-var exports_relay_schema = {};
-__export(exports_relay_schema, {
-  relayWorkspaceSnapshots: () => relayWorkspaceSnapshots,
-  relayWorkspaceLeases: () => relayWorkspaceLeases,
-  relayWaits: () => relayWaits,
-  relayToolResults: () => relayToolResults,
-  relayToolCalls: () => relayToolCalls,
-  relaySteeringMessages: () => relaySteeringMessages,
-  relaySteeringDrains: () => relaySteeringDrains,
-  relaySkillDefinitions: () => relaySkillDefinitions,
-  relaySkillDefinitionRevisions: () => relaySkillDefinitionRevisions,
-  relaySessions: () => relaySessions,
-  relaySessionEntries: () => relaySessionEntries,
-  relaySchedules: () => relaySchedules,
-  relayRouteAttempts: () => relayRouteAttempts,
-  relayPermissionRules: () => relayPermissionRules,
-  relayMemoryRecords: () => relayMemoryRecords,
-  relayIdempotencyKeys: () => relayIdempotencyKeys,
-  relayExecutions: () => relayExecutions,
-  relayExecutionSkillPins: () => relayExecutionSkillPins,
-  relayExecutionEvents: () => relayExecutionEvents,
-  relayExecutionContextEpochs: () => relayExecutionContextEpochs,
-  relayEnvelopes: () => relayEnvelopes,
-  relayEnvelopeReady: () => relayEnvelopeReady,
-  relayChildExecutions: () => relayChildExecutions,
-  relayAgentDefinitions: () => relayAgentDefinitions,
-  relayAgentDefinitionRevisions: () => relayAgentDefinitionRevisions,
-  relayAgentCompactions: () => relayAgentCompactions,
-  relayAgentChats: () => relayAgentChats,
-  relayAddressBookEntries: () => relayAddressBookEntries
+// ../store-sql/src/tenant/tenant-id.ts
+import { and, eq } from "drizzle-orm";
+import { Context as Context2, Effect as Effect2, Layer as Layer2, Option } from "effect";
+
+class Service2 extends Context2.Service()("@relayfx/store-sql/TenantId") {
+}
+var make = (tenantId) => Service2.of({ tenantId });
+var layer2 = (tenantId) => Layer2.succeed(Service2, make(tenantId));
+var systemLayer = layer2(exports_ids_schema.SystemTenantId);
+var current = Effect2.gen(function* () {
+  const service = yield* Effect2.serviceOption(Service2);
+  return Option.match(service, {
+    onNone: () => exports_ids_schema.SystemTenantId,
+    onSome: (value) => value.tenantId
+  });
+}).pipe(Effect2.withSpan("TenantId.current"));
+var predicate = (tenantId, tenantColumn, ...conditions) => and(eq(tenantColumn, tenantId), ...conditions);
+
+// ../store-sql/src/address/address-book-repository.ts
+var RouteKind2 = exports_address_schema.RouteKind;
+
+class AddressNotFound extends Schema13.TaggedErrorClass()("AddressNotFound", {
+  address_id: exports_ids_schema.AddressId
+}) {
+}
+
+class AddressBookRepositoryError extends Schema13.TaggedErrorClass()("AddressBookRepositoryError", {
+  message: Schema13.String
+}) {
+}
+
+class Service3 extends Context3.Service()("@relayfx/store-sql/AddressBookRepository") {
+}
+var AddressBookRow = Schema13.Struct({
+  id: Schema13.String,
+  address_id: Schema13.String,
+  route_kind: Schema13.String,
+  route_key: Schema13.String,
+  metadata_json: Schema13.Unknown,
+  created_at: Schema13.Union([Schema13.Date, Schema13.String, Schema13.Number]),
+  updated_at: Schema13.Union([Schema13.Date, Schema13.String, Schema13.Number])
+}).annotate({ identifier: "Relay.AddressBook.Row" });
+var metadata = (input) => input.metadata ?? {};
+var toEntry = (row) => ({
+  id: exports_ids_schema.AddressBookEntryId.make(row.id),
+  addressId: exports_ids_schema.AddressId.make(row.address_id),
+  routeKind: row.route_kind,
+  routeKey: row.route_key,
+  metadata: decodeJson(row.metadata_json),
+  createdAt: fromDbTimestamp(row.created_at),
+  updatedAt: fromDbTimestamp(row.updated_at)
 });
-import {
-  doublePrecision,
-  index,
-  integer,
-  jsonb,
-  pgTable,
-  primaryKey,
-  text as text2,
-  timestamp,
-  uniqueIndex
-} from "drizzle-orm/pg-core";
-import { sql as sql2 } from "drizzle-orm";
-var tenantId = () => text2("tenant_id").$type().notNull().default(exports_ids_schema.SystemTenantId);
-var relayAddressBookEntries = pgTable("relay_address_book_entries", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  addressId: text2("address_id").$type().notNull(),
-  routeKind: text2("route_kind").notNull(),
-  routeKey: text2("route_key").notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_address_book_entries" }),
-  uniqueIndex("uq_relay_address_book_address").on(table.tenantId, table.addressId)
-]);
-var relayAgentDefinitions = pgTable("relay_agent_definitions", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  name: text2("name").notNull(),
-  currentRevision: integer("current_revision").$type().notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  toolInputSchemaDigestsJson: jsonb("tool_input_schema_digests_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_agent_definitions" }),
-  index("idx_relay_agent_definitions_name").on(table.tenantId, table.name)
-]);
-var relayAgentDefinitionRevisions = pgTable("relay_agent_definition_revisions", {
-  tenantId: tenantId(),
-  agentDefinitionId: text2("agent_definition_id").$type().notNull(),
-  revision: integer("revision").$type().notNull(),
-  name: text2("name").notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  toolInputSchemaDigestsJson: jsonb("tool_input_schema_digests_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.agentDefinitionId, table.revision],
-    name: "pk_relay_agent_definition_revisions"
-  }),
-  index("idx_relay_agent_definition_revisions_definition").on(table.tenantId, table.agentDefinitionId, table.revision)
-]);
-var relaySkillDefinitions = pgTable("relay_skill_definitions", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  name: text2("name").notNull(),
-  currentRevision: integer("current_revision").$type().notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_skill_definitions" }),
-  index("idx_relay_skill_definitions_name").on(table.tenantId, table.name)
-]);
-var relaySkillDefinitionRevisions = pgTable("relay_skill_definition_revisions", {
-  tenantId: tenantId(),
-  skillDefinitionId: text2("skill_definition_id").notNull().$type(),
-  revision: integer("revision").notNull().$type(),
-  name: text2("name").notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.skillDefinitionId, table.revision],
-    name: "pk_relay_skill_definition_revisions"
-  }),
-  index("idx_relay_skill_definition_revisions_definition").on(table.tenantId, table.skillDefinitionId, table.revision)
-]);
-var relayExecutionSkillPins = pgTable("relay_execution_skill_pins", {
-  tenantId: tenantId(),
-  executionId: text2("execution_id").notNull().$type(),
-  skillDefinitionId: text2("skill_definition_id").notNull().$type(),
-  skillDefinitionRevision: integer("skill_definition_revision").notNull().$type(),
-  skillDefinitionSnapshotJson: jsonb("skill_definition_snapshot_json").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.executionId, table.skillDefinitionId],
-    name: "pk_relay_execution_skill_pins"
-  }),
-  index("idx_relay_execution_skill_pins_execution").on(table.tenantId, table.executionId)
-]);
-var relayAgentChats = pgTable("relay_agent_chats", {
-  tenantId: tenantId(),
-  executionId: text2("execution_id").$type().notNull(),
-  exportJson: jsonb("export_json").notNull(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId], name: "pk_relay_agent_chats" })]);
-var relayAgentCompactions = pgTable("relay_agent_compactions", {
-  tenantId: tenantId(),
-  executionId: text2("execution_id").notNull().$type(),
-  checkpointId: text2("checkpoint_id").notNull(),
-  summary: text2("summary").notNull(),
-  firstKeptEntryId: text2("first_kept_entry_id").$type().notNull(),
-  turn: integer("turn").notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.executionId, table.checkpointId],
-    name: "pk_relay_agent_compactions"
-  }),
-  index("idx_relay_agent_compactions_execution_turn").on(table.tenantId, table.executionId, table.turn)
-]);
-var relayMemoryRecords = pgTable("relay_memory_records", {
-  tenantId: tenantId(),
-  id: text2("id").notNull(),
-  agent: text2("agent").notNull(),
-  subject: text2("subject").$type().notNull(),
-  embedding: doublePrecision("embedding").array().notNull(),
-  partsJson: jsonb("parts_json").$type().notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_memory_records" }),
-  index("idx_relay_memory_records_agent_subject").on(table.tenantId, table.agent, table.subject)
-]);
-var relayPermissionRules = pgTable("relay_permission_rules", {
-  tenantId: tenantId(),
-  agent: text2("agent").notNull(),
-  scope: text2("scope").notNull(),
-  pattern: text2("pattern").notNull(),
-  ruleJson: jsonb("rule_json").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.agent, table.scope, table.pattern],
-    name: "pk_relay_permission_rules"
-  }),
-  index("idx_relay_permission_rules_agent_scope").on(table.tenantId, table.agent, table.scope)
-]);
-var relaySteeringMessages = pgTable("relay_steering_messages", {
-  tenantId: tenantId(),
-  executionId: text2("execution_id").notNull(),
-  kind: text2("kind").notNull(),
-  sequence: integer("sequence").notNull(),
-  contentJson: jsonb("content_json").$type().notNull(),
-  drainId: text2("drain_id"),
-  consumedAt: timestamp("consumed_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.executionId, table.kind, table.sequence],
-    name: "pk_relay_steering_messages"
-  }),
-  index("idx_relay_steering_messages_unconsumed").on(table.tenantId, table.executionId, table.kind, table.consumedAt, table.sequence),
-  index("idx_relay_steering_messages_drain").on(table.tenantId, table.executionId, table.kind, table.drainId, table.sequence)
-]);
-var relaySteeringDrains = pgTable("relay_steering_drains", {
-  tenantId: tenantId(),
-  executionId: text2("execution_id").notNull(),
-  kind: text2("kind").notNull(),
-  drainId: text2("drain_id").notNull(),
-  messageSequencesJson: jsonb("message_sequences_json").$type().notNull().default([]),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.executionId, table.kind, table.drainId],
-    name: "pk_relay_steering_drains"
-  })
-]);
-var relaySessions = pgTable("relay_sessions", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  rootAddressId: text2("root_address_id").$type().notNull(),
-  leafEntryId: text2("leaf_entry_id").$type(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_sessions" }),
-  index("idx_relay_sessions_updated_id").on(table.tenantId, table.updatedAt, table.id),
-  index("idx_relay_sessions_root_updated_id").on(table.tenantId, table.rootAddressId, table.updatedAt, table.id)
-]);
-var relaySessionEntries = pgTable("relay_session_entries", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  sessionId: text2("session_id").$type().notNull(),
-  parentId: text2("parent_id").$type(),
-  tag: text2("tag").notNull(),
-  payloadJson: jsonb("payload_json").notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_session_entries" }),
-  index("idx_relay_session_entries_session_created").on(table.tenantId, table.sessionId, table.createdAt, table.id),
-  index("idx_relay_session_entries_session_parent").on(table.tenantId, table.sessionId, table.parentId)
-]);
-var relayExecutionContextEpochs = pgTable("relay_execution_context_epochs", {
-  tenantId: tenantId(),
-  executionId: text2("execution_id").$type().notNull(),
-  baseline: text2("baseline").notNull(),
-  dynamicSourceIdsJson: jsonb("dynamic_source_ids_json").$type().notNull().default([]),
-  openedAt: timestamp("opened_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId], name: "pk_relay_execution_context_epochs" })]);
-var relayExecutions = pgTable("relay_executions", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  rootAddressId: text2("root_address_id").$type().notNull(),
-  sessionId: text2("session_id").$type(),
-  status: text2("status").$type().notNull(),
-  agentDefinitionId: text2("agent_definition_id").$type(),
-  agentDefinitionRevision: integer("agent_definition_revision").$type(),
-  agentDefinitionSnapshotJson: jsonb("agent_definition_snapshot_json").$type(),
-  agentDefinitionToolInputSchemaDigestsJson: jsonb("agent_definition_tool_input_schema_digests_json").$type().notNull().default({}),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_executions" }),
-  index("idx_relay_executions_root_status").on(table.tenantId, table.rootAddressId, table.status),
-  index("idx_relay_executions_session_updated_id").on(table.tenantId, table.sessionId, table.updatedAt, table.id),
-  index("idx_relay_executions_updated_id").on(table.tenantId, table.updatedAt, table.id),
-  index("idx_relay_executions_root_status_updated_id").on(table.tenantId, table.rootAddressId, table.status, table.updatedAt, table.id)
-]);
-var relayChildExecutions = pgTable("relay_child_executions", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  executionId: text2("execution_id").$type().notNull(),
-  addressId: text2("address_id").$type().notNull(),
-  status: text2("status").$type().notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_child_executions" }),
-  index("idx_relay_child_executions_parent").on(table.tenantId, table.executionId)
-]);
-var relayEnvelopes = pgTable("relay_envelopes", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  executionId: text2("execution_id").$type().notNull(),
-  fromAddressId: text2("from_address_id").$type().notNull(),
-  toAddressId: text2("to_address_id").$type().notNull(),
-  contentJson: jsonb("content_json").$type().notNull(),
-  waitJson: jsonb("wait_json").$type(),
-  correlationKey: text2("correlation_key"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_envelopes" }),
-  index("idx_relay_envelopes_execution").on(table.tenantId, table.executionId, table.createdAt),
-  index("idx_relay_envelopes_to_address").on(table.tenantId, table.toAddressId, table.createdAt)
-]);
-var relayWaits = pgTable("relay_waits", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  executionId: text2("execution_id").$type().notNull(),
-  envelopeId: text2("envelope_id").$type(),
-  mode: text2("mode").$type().notNull(),
-  correlationKey: text2("correlation_key"),
-  state: text2("state").notNull().default("open"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  resolvedAt: timestamp("resolved_at", { withTimezone: true })
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_waits" }),
-  index("idx_relay_waits_execution_state").on(table.tenantId, table.executionId, table.state)
-]);
-var relayWorkspaceLeases = pgTable("relay_workspace_leases", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  executionId: text2("execution_id").$type().notNull(),
-  providerKey: text2("provider_key").$type().notNull(),
-  sandboxRef: text2("sandbox_ref").$type(),
-  latestSnapshotRef: text2("latest_snapshot_ref").$type(),
-  status: text2("status").$type().notNull(),
-  resumeStrategy: text2("resume_strategy").$type().notNull(),
-  region: text2("region"),
-  requestJson: jsonb("request_json").$type(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_workspace_leases" }),
-  uniqueIndex("uq_relay_workspace_leases_active_execution").on(table.tenantId, table.executionId).where(sql2`${table.status} not in ('released', 'failed')`),
-  index("idx_relay_workspace_leases_execution").on(table.tenantId, table.executionId),
-  index("idx_relay_workspace_leases_status_updated").on(table.tenantId, table.status, table.updatedAt)
-]);
-var relayWorkspaceSnapshots = pgTable("relay_workspace_snapshots", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  leaseId: text2("lease_id").$type().notNull(),
-  executionId: text2("execution_id").$type().notNull(),
-  reason: text2("reason").$type().notNull(),
-  snapshotRef: text2("snapshot_ref").$type().notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_workspace_snapshots" }),
-  index("idx_relay_workspace_snapshots_lease").on(table.tenantId, table.leaseId, table.createdAt),
-  index("idx_relay_workspace_snapshots_execution").on(table.tenantId, table.executionId, table.createdAt)
-]);
-var relayEnvelopeReady = pgTable("relay_envelope_ready", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  envelopeId: text2("envelope_id").$type().notNull(),
-  routeType: text2("route_type").notNull(),
-  routeKey: text2("route_key").notNull(),
-  state: text2("state").notNull().default("ready"),
-  availableAt: timestamp("available_at", { withTimezone: true }).notNull().defaultNow(),
-  attempt: integer("attempt").notNull().default(0),
-  claimOwner: text2("claim_owner"),
-  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
-  lastError: text2("last_error"),
-  idempotencyKey: text2("idempotency_key"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
-  claimedAt: timestamp("claimed_at", { withTimezone: true }),
-  acknowledgedAt: timestamp("acknowledged_at", { withTimezone: true })
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_envelope_ready" }),
-  index("idx_relay_envelope_ready_state_available").on(table.tenantId, table.state, table.availableAt),
-  index("idx_relay_envelope_ready_claim_expires").on(table.tenantId, table.claimExpiresAt),
-  uniqueIndex("uq_relay_envelope_ready_idempotency").on(table.tenantId, table.idempotencyKey)
-]);
-var relaySchedules = pgTable("relay_schedules", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  kind: text2("kind").notNull(),
-  targetKind: text2("target_kind").notNull(),
-  addressId: text2("address_id").$type(),
-  waitId: text2("wait_id").$type(),
-  cronExpr: text2("cron_expr"),
-  inputJson: jsonb("input_json").$type(),
-  state: text2("state").notNull().default("active"),
-  nextRunAt: timestamp("next_run_at", { withTimezone: true }).notNull(),
-  attempt: integer("attempt").notNull().default(0),
-  claimOwner: text2("claim_owner"),
-  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
-  lastError: text2("last_error"),
-  idempotencyKey: text2("idempotency_key"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_schedules" }),
-  index("idx_relay_schedules_state_next_run").on(table.tenantId, table.state, table.nextRunAt),
-  index("idx_relay_schedules_claim_expires").on(table.tenantId, table.claimExpiresAt),
-  index("idx_relay_schedules_wait").on(table.tenantId, table.waitId),
-  uniqueIndex("uq_relay_schedules_idempotency").on(table.tenantId, table.idempotencyKey)
-]);
-var relayExecutionEvents = pgTable("relay_execution_events", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  executionId: text2("execution_id").$type().notNull(),
-  childExecutionId: text2("child_execution_id").$type(),
-  type: text2("type").notNull(),
-  sequence: integer("sequence").notNull(),
-  cursor: text2("cursor").notNull(),
-  contentJson: jsonb("content_json").$type(),
-  dataJson: jsonb("data_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_execution_events" }),
-  index("idx_relay_execution_events_execution").on(table.tenantId, table.executionId, table.createdAt),
-  uniqueIndex("uq_relay_execution_events_sequence").on(table.tenantId, table.executionId, table.sequence),
-  uniqueIndex("uq_relay_execution_events_cursor").on(table.tenantId, table.cursor)
-]);
-var relayToolCalls = pgTable("relay_tool_calls", {
-  tenantId: tenantId(),
-  id: text2("id").$type().notNull(),
-  executionId: text2("execution_id").$type().notNull(),
-  name: text2("name").notNull(),
-  inputJson: jsonb("input_json").notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_tool_calls" }),
-  index("idx_relay_tool_calls_execution").on(table.tenantId, table.executionId, table.createdAt)
-]);
-var relayToolResults = pgTable("relay_tool_results", {
-  tenantId: tenantId(),
-  toolCallId: text2("tool_call_id").$type().notNull(),
-  outputJson: jsonb("output_json").notNull(),
-  error: text2("error"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.toolCallId], name: "pk_relay_tool_results" })]);
-var relayRouteAttempts = pgTable("relay_route_attempts", {
-  tenantId: tenantId(),
-  id: text2("id").notNull(),
-  envelopeReadyId: text2("envelope_ready_id").$type().notNull(),
-  routeKey: text2("route_key").notNull(),
-  state: text2("state").notNull(),
-  detail: text2("detail"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_route_attempts" }),
-  index("idx_relay_route_attempts_ready").on(table.tenantId, table.envelopeReadyId, table.createdAt)
-]);
-var relayIdempotencyKeys = pgTable("relay_idempotency_keys", {
-  tenantId: tenantId(),
-  id: text2("id").notNull(),
-  scope: text2("scope").notNull(),
-  operation: text2("operation").notNull(),
-  key: text2("key").notNull(),
-  resultJson: jsonb("result_json").$type(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
-  expiresAt: timestamp("expires_at", { withTimezone: true })
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_idempotency_keys" }),
-  uniqueIndex("uq_relay_idempotency_scope_operation_key").on(table.tenantId, table.scope, table.operation, table.key)
-]);
-
-// ../store-sql/src/tenant/tenant-id.ts
-import { and, eq } from "drizzle-orm";
-import { Context as Context2, Effect as Effect2, Layer as Layer2, Option } from "effect";
-
-class Service2 extends Context2.Service()("@relayfx/store-sql/TenantId") {
-}
-var make = (tenantId2) => Service2.of({ tenantId: tenantId2 });
-var layer2 = (tenantId2) => Layer2.succeed(Service2, make(tenantId2));
-var systemLayer = layer2(exports_ids_schema.SystemTenantId);
-var current = Effect2.gen(function* () {
-  const service = yield* Effect2.serviceOption(Service2);
-  return Option.match(service, {
-    onNone: () => exports_ids_schema.SystemTenantId,
-    onSome: (value) => value.tenantId
+var toRepositoryError = (error) => new AddressBookRepositoryError({ message: String(error) });
+var decodeRow = (row) => Schema13.decodeUnknownEffect(AddressBookRow)(row).pipe(Effect3.mapError(toRepositoryError));
+var layer3 = Layer3.effect(Service3, Effect3.gen(function* () {
+  const sql2 = yield* SqlClient3.SqlClient;
+  const columns = sql2.literal(["id", "address_id", "route_kind", "route_key", "metadata_json", "created_at", "updated_at"].join(", "));
+  const selectByAddress = (tenantId, addressId) => sql2`
+      SELECT ${columns}
+      FROM relay_address_book_entries
+      WHERE tenant_id = ${tenantId} AND address_id = ${addressId}
+    `;
+  const upsertEntry = sql2.onDialectOrElse({
+    mysql: () => (tenantId, input, now) => sql2.withTransaction(Effect3.gen(function* () {
+      yield* sql2`
+              INSERT INTO relay_address_book_entries (
+                tenant_id, ${columns}
+              )
+              VALUES (
+                ${tenantId},
+                ${input.id},
+                ${input.addressId},
+                ${input.routeKind},
+                ${input.routeKey},
+                ${encodeJson(metadata(input))},
+                ${timestampParam(sql2, now)},
+                ${timestampParam(sql2, now)}
+              )
+              ON DUPLICATE KEY UPDATE
+                route_kind = VALUES(route_kind),
+                route_key = VALUES(route_key),
+                metadata_json = VALUES(metadata_json),
+                updated_at = VALUES(updated_at)
+            `;
+      return yield* selectByAddress(tenantId, input.addressId);
+    })),
+    orElse: () => (tenantId, input, now) => sql2`
+        INSERT INTO relay_address_book_entries (
+          tenant_id, ${columns}
+        )
+        VALUES (
+          ${tenantId},
+          ${input.id},
+          ${input.addressId},
+          ${input.routeKind},
+          ${input.routeKey},
+          ${encodeJson(metadata(input))},
+          ${timestampParam(sql2, now)},
+          ${timestampParam(sql2, now)}
+        )
+        ON CONFLICT (tenant_id, address_id) DO UPDATE SET
+          route_kind = excluded.route_kind,
+          route_key = excluded.route_key,
+          metadata_json = excluded.metadata_json,
+          updated_at = excluded.updated_at
+        RETURNING ${columns}
+      `
   });
-}).pipe(Effect2.withSpan("TenantId.current"));
-var predicate = (tenantId2, tenantColumn, ...conditions) => and(eq(tenantColumn, tenantId2), ...conditions);
-
-// ../store-sql/src/address/address-book-repository.ts
-var RouteKind2 = exports_address_schema.RouteKind;
-
-class AddressNotFound extends Schema13.TaggedErrorClass()("AddressNotFound", {
-  address_id: exports_ids_schema.AddressId
-}) {
-}
-
-class AddressBookRepositoryError extends Schema13.TaggedErrorClass()("AddressBookRepositoryError", {
-  message: Schema13.String
-}) {
-}
-
-class Service3 extends Context3.Service()("@relayfx/store-sql/AddressBookRepository") {
-}
-var metadata = (input) => input.metadata ?? {};
-var toEntry = (row) => ({
-  id: row.id,
-  addressId: row.addressId,
-  routeKind: row.routeKind,
-  routeKey: row.routeKey,
-  metadata: row.metadataJson,
-  createdAt: fromPgDate(row.createdAt),
-  updatedAt: fromPgDate(row.updatedAt)
-});
-var mapDatabaseError = (effect) => effect.pipe(Effect3.mapError((error) => new AddressBookRepositoryError({ message: String(error) })));
-var layer3 = Layer3.effect(Service3, Effect3.gen(function* () {
-  const db = yield* Service;
   const upsert = Effect3.fn("AddressBookRepository.upsert")(function* (input) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError(db.insert(relayAddressBookEntries).values({
-      tenantId: tenantId2,
-      id: input.id,
-      addressId: input.addressId,
-      routeKind: input.routeKind,
-      routeKey: input.routeKey,
-      metadataJson: metadata(input)
-    }).onConflictDoUpdate({
-      target: [relayAddressBookEntries.tenantId, relayAddressBookEntries.addressId],
-      set: {
-        routeKind: input.routeKind,
-        routeKey: input.routeKey,
-        metadataJson: metadata(input),
-        updatedAt: sql3`now()`
-      }
-    }).returning());
+    const tenantId = yield* current;
+    const now = yield* Clock.currentTimeMillis;
+    const rows = yield* upsertEntry(tenantId, input, now).pipe(Effect3.mapError(toRepositoryError));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect3.fail(new AddressBookRepositoryError({ message: "Address upsert returned no row" }));
     }
-    return toEntry(row);
+    return toEntry(yield* decodeRow(row));
   });
   const resolve = Effect3.fn("AddressBookRepository.resolve")(function* (addressId) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError(db.select().from(relayAddressBookEntries).where(predicate(tenantId2, relayAddressBookEntries.tenantId, eq2(relayAddressBookEntries.addressId, addressId))).limit(1));
+    const tenantId = yield* current;
+    const rows = yield* selectByAddress(tenantId, addressId).pipe(Effect3.mapError(toRepositoryError));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect3.fail(new AddressNotFound({ address_id: addressId }));
     }
-    return toEntry(row);
+    return toEntry(yield* decodeRow(row));
   });
   const list = Effect3.fn("AddressBookRepository.list")(function* () {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError(db.select().from(relayAddressBookEntries).where(predicate(tenantId2, relayAddressBookEntries.tenantId)).orderBy(asc(relayAddressBookEntries.addressId)));
-    return rows.map(toEntry);
+    const tenantId = yield* current;
+    const rows = yield* sql2`
+        SELECT ${columns}
+        FROM relay_address_book_entries
+        WHERE tenant_id = ${tenantId}
+        ORDER BY address_id ASC
+      `.pipe(Effect3.mapError(toRepositoryError));
+    const decoded = yield* Effect3.forEach(rows, decodeRow);
+    return decoded.map(toEntry);
   });
   return Service3.of({ upsert, resolve, list });
 }));
@@ -1543,7 +1148,7 @@ __export(exports_agent_chat_repository, {
   AgentChatRepositoryError: () => AgentChatRepositoryError
 });
 import { Context as Context4, Effect as Effect4, Layer as Layer4, Schema as Schema14 } from "effect";
-import * as SqlClient3 from "effect/unstable/sql/SqlClient";
+import * as SqlClient5 from "effect/unstable/sql/SqlClient";
 class AgentChatRepositoryError extends Schema14.TaggedErrorClass()("AgentChatRepositoryError", {
   message: Schema14.String
 }) {
@@ -1561,29 +1166,29 @@ var toRecord = (row) => ({
   exportData: decodeJson(row.export_json),
   updatedAt: fromDbTimestamp(row.updated_at)
 });
-var toRepositoryError = (error) => new AgentChatRepositoryError({ message: String(error) });
-var decodeRow = (row) => Schema14.decodeUnknownEffect(AgentChatRow)(row).pipe(Effect4.mapError(toRepositoryError));
+var toRepositoryError2 = (error) => new AgentChatRepositoryError({ message: String(error) });
+var decodeRow2 = (row) => Schema14.decodeUnknownEffect(AgentChatRow)(row).pipe(Effect4.mapError(toRepositoryError2));
 var layer4 = Layer4.effect(Service4, Effect4.gen(function* () {
-  const sql4 = yield* SqlClient3.SqlClient;
-  const selectByKey = (tenantId2, executionId) => sql4`
+  const sql2 = yield* SqlClient5.SqlClient;
+  const selectByKey = (tenantId, executionId) => sql2`
       SELECT execution_id, export_json, updated_at
       FROM relay_agent_chats
-      WHERE tenant_id = ${tenantId2} AND execution_id = ${executionId}
+      WHERE tenant_id = ${tenantId} AND execution_id = ${executionId}
     `;
-  const upsert2 = sql4.onDialectOrElse({
-    mysql: () => (tenantId2, input) => sql4.withTransaction(Effect4.gen(function* () {
-      yield* sql4`
+  const upsert2 = sql2.onDialectOrElse({
+    mysql: () => (tenantId, input) => sql2.withTransaction(Effect4.gen(function* () {
+      yield* sql2`
               INSERT INTO relay_agent_chats (tenant_id, execution_id, export_json, updated_at)
-              VALUES (${tenantId2}, ${input.executionId}, ${encodeJson(input.exportData)}, ${timestampParam(sql4, input.updatedAt)})
+              VALUES (${tenantId}, ${input.executionId}, ${encodeJson(input.exportData)}, ${timestampParam(sql2, input.updatedAt)})
               ON DUPLICATE KEY UPDATE
                 export_json = VALUES(export_json),
                 updated_at = VALUES(updated_at)
             `;
-      return yield* selectByKey(tenantId2, input.executionId);
+      return yield* selectByKey(tenantId, input.executionId);
     })),
-    orElse: () => (tenantId2, input) => sql4`
+    orElse: () => (tenantId, input) => sql2`
         INSERT INTO relay_agent_chats (tenant_id, execution_id, export_json, updated_at)
-        VALUES (${tenantId2}, ${input.executionId}, ${encodeJson(input.exportData)}, ${timestampParam(sql4, input.updatedAt)})
+        VALUES (${tenantId}, ${input.executionId}, ${encodeJson(input.exportData)}, ${timestampParam(sql2, input.updatedAt)})
         ON CONFLICT (tenant_id, execution_id) DO UPDATE SET
           export_json = excluded.export_json,
           updated_at = excluded.updated_at
@@ -1591,18 +1196,18 @@ var layer4 = Layer4.effect(Service4, Effect4.gen(function* () {
       `
   });
   const save = Effect4.fn("AgentChatRepository.save")(function* (input) {
-    const tenantId2 = yield* current;
-    const rows = yield* upsert2(tenantId2, input).pipe(Effect4.mapError(toRepositoryError));
+    const tenantId = yield* current;
+    const rows = yield* upsert2(tenantId, input).pipe(Effect4.mapError(toRepositoryError2));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect4.fail(new AgentChatRepositoryError({ message: "Agent chat upsert returned no row" }));
     }
-    return toRecord(yield* decodeRow(row));
+    return toRecord(yield* decodeRow2(row));
   });
   const get = Effect4.fn("AgentChatRepository.get")(function* (executionId) {
-    const tenantId2 = yield* current;
-    const rows = yield* selectByKey(tenantId2, executionId).pipe(Effect4.mapError(toRepositoryError));
-    return rows[0] === undefined ? undefined : toRecord(yield* decodeRow(rows[0]));
+    const tenantId = yield* current;
+    const rows = yield* selectByKey(tenantId, executionId).pipe(Effect4.mapError(toRepositoryError2));
+    return rows[0] === undefined ? undefined : toRecord(yield* decodeRow2(rows[0]));
   });
   return Service4.of({ save, get });
 }));
@@ -1644,10 +1249,12 @@ __export(exports_agent_definition_repository, {
   getRevision: () => getRevision,
   get: () => get2,
   Service: () => Service5,
+  AgentDefinitionRow: () => AgentDefinitionRow,
+  AgentDefinitionRevisionRow: () => AgentDefinitionRevisionRow,
   AgentDefinitionRepositoryError: () => AgentDefinitionRepositoryError
 });
-import { asc as asc2, desc, eq as eq3, sql as sql4 } from "drizzle-orm";
 import { Context as Context5, Effect as Effect5, Layer as Layer5, Schema as Schema15 } from "effect";
+import * as SqlClient7 from "effect/unstable/sql/SqlClient";
 class AgentDefinitionRepositoryError extends Schema15.TaggedErrorClass()("AgentDefinitionRepositoryError", {
   message: Schema15.String
 }) {
@@ -1655,29 +1262,45 @@ class AgentDefinitionRepositoryError extends Schema15.TaggedErrorClass()("AgentD
 
 class Service5 extends Context5.Service()("@relayfx/store-sql/AgentDefinitionRepository") {
 }
+var AgentDefinitionRow = Schema15.Struct({
+  id: Schema15.String,
+  current_revision: Schema15.Number,
+  definition_json: Schema15.Unknown,
+  tool_input_schema_digests_json: Schema15.Unknown,
+  created_at: Schema15.Union([Schema15.Date, Schema15.String, Schema15.Number]),
+  updated_at: Schema15.Union([Schema15.Date, Schema15.String, Schema15.Number])
+}).annotate({ identifier: "Relay.AgentDefinition.Row" });
+var AgentDefinitionRevisionRow = Schema15.Struct({
+  agent_definition_id: Schema15.String,
+  revision: Schema15.Number,
+  definition_json: Schema15.Unknown,
+  tool_input_schema_digests_json: Schema15.Unknown,
+  created_at: Schema15.Union([Schema15.Date, Schema15.String, Schema15.Number])
+}).annotate({ identifier: "Relay.AgentDefinitionRevision.Row" });
 var nonEmptyDigests = (digests) => digests === undefined || Object.keys(digests).length === 0 ? undefined : structuredClone(digests);
+var cloneDefinition = (definition) => Schema15.decodeUnknownSync(exports_agent_schema.Definition)(globalThis.structuredClone(definition));
+var rowDigests = (json) => nonEmptyDigests(decodeJson(json));
 var toRecord2 = (row) => {
-  const toolInputSchemaDigests = nonEmptyDigests(row.toolInputSchemaDigestsJson);
+  const toolInputSchemaDigests = rowDigests(row.tool_input_schema_digests_json);
   return {
-    id: row.id,
-    currentRevision: row.currentRevision,
-    definition: row.definitionJson,
+    id: exports_ids_schema.AgentDefinitionId.make(row.id),
+    currentRevision: row.current_revision,
+    definition: cloneDefinition(decodeJson(row.definition_json)),
     ...toolInputSchemaDigests === undefined ? {} : { toolInputSchemaDigests },
-    createdAt: fromPgDate(row.createdAt),
-    updatedAt: fromPgDate(row.updatedAt)
+    createdAt: fromDbTimestamp(row.created_at),
+    updatedAt: fromDbTimestamp(row.updated_at)
   };
 };
 var toRevisionRecord = (row) => {
-  const toolInputSchemaDigests = nonEmptyDigests(row.toolInputSchemaDigestsJson);
+  const toolInputSchemaDigests = rowDigests(row.tool_input_schema_digests_json);
   return {
-    id: row.agentDefinitionId,
+    id: exports_ids_schema.AgentDefinitionId.make(row.agent_definition_id),
     revision: row.revision,
-    definition: row.definitionJson,
+    definition: cloneDefinition(decodeJson(row.definition_json)),
     ...toolInputSchemaDigests === undefined ? {} : { toolInputSchemaDigests },
-    createdAt: fromPgDate(row.createdAt)
+    createdAt: fromDbTimestamp(row.created_at)
   };
 };
-var cloneDefinition = (definition) => Schema15.decodeUnknownSync(exports_agent_schema.Definition)(globalThis.structuredClone(definition));
 var cloneRecord = (record) => ({
   ...record,
   definition: cloneDefinition(record.definition),
@@ -1693,72 +1316,123 @@ var compareByCreatedAtDesc = (left, right) => {
   const createdAt = right.createdAt - left.createdAt;
   return createdAt === 0 ? left.id.localeCompare(right.id) : createdAt;
 };
-var mapDatabaseError2 = (effect) => effect.pipe(Effect5.mapError((error) => new AgentDefinitionRepositoryError({ message: String(error) })));
-var mapPutError = (effect) => effect.pipe(Effect5.mapError((error) => error instanceof AgentDefinitionRepositoryError ? error : new AgentDefinitionRepositoryError({ message: String(error) })));
+var toRepositoryError3 = (error) => new AgentDefinitionRepositoryError({ message: String(error) });
+var mapPutError = (error) => error instanceof AgentDefinitionRepositoryError ? error : toRepositoryError3(error);
+var decodeRow3 = (row) => Schema15.decodeUnknownEffect(AgentDefinitionRow)(row).pipe(Effect5.mapError(toRepositoryError3));
+var decodeRevisionRow = (row) => Schema15.decodeUnknownEffect(AgentDefinitionRevisionRow)(row).pipe(Effect5.mapError(toRepositoryError3));
 var layer5 = Layer5.effect(Service5, Effect5.gen(function* () {
-  const db = yield* Service;
+  const sql2 = yield* SqlClient7.SqlClient;
+  const columns = sql2.literal(["id", "current_revision", "definition_json", "tool_input_schema_digests_json", "created_at", "updated_at"].join(", "));
+  const revisionColumns = sql2.literal(["agent_definition_id", "revision", "definition_json", "tool_input_schema_digests_json", "created_at"].join(", "));
+  const selectByKey = (tenantId, id2) => sql2`
+      SELECT ${columns}
+      FROM relay_agent_definitions
+      WHERE tenant_id = ${tenantId} AND id = ${id2}
+    `;
+  const lockClause = sql2.onDialectOrElse({
+    sqlite: () => sql2.literal(""),
+    orElse: () => sql2.literal("FOR UPDATE")
+  });
+  const selectByKeyForUpdate = (tenantId, id2) => sql2`
+      SELECT ${columns}
+      FROM relay_agent_definitions
+      WHERE tenant_id = ${tenantId} AND id = ${id2}
+      ${lockClause}
+    `;
   const put = Effect5.fn("AgentDefinitionRepository.put")(function* (input) {
-    const tenantId2 = yield* current;
-    return yield* mapPutError(db.transaction((tx) => Effect5.gen(function* () {
-      const existingRows = yield* tx.select().from(relayAgentDefinitions).where(predicate(tenantId2, relayAgentDefinitions.tenantId, eq3(relayAgentDefinitions.id, input.id))).for("update").limit(1);
-      const existing = existingRows[0];
-      if (existing !== undefined && sameDefinitionContent(existing.definitionJson, input.definition)) {
+    const tenantId = yield* current;
+    return yield* sql2.withTransaction(Effect5.gen(function* () {
+      const existingRows = yield* selectByKeyForUpdate(tenantId, input.id);
+      const existing = existingRows[0] === undefined ? undefined : yield* decodeRow3(existingRows[0]);
+      if (existing !== undefined && sameDefinitionContent(decodeJson(existing.definition_json), input.definition)) {
         return toRecord2(existing);
       }
-      const rows = existing === undefined ? yield* tx.insert(relayAgentDefinitions).values({
-        tenantId: tenantId2,
-        id: input.id,
-        name: input.definition.name,
-        currentRevision: 1,
-        definitionJson: input.definition,
-        toolInputSchemaDigestsJson: input.toolInputSchemaDigests ?? {},
-        createdAt: toPgDate(input.now),
-        updatedAt: toPgDate(input.now)
-      }).returning() : yield* tx.update(relayAgentDefinitions).set({
-        name: input.definition.name,
-        currentRevision: sql4`${relayAgentDefinitions.currentRevision} + 1`,
-        definitionJson: input.definition,
-        toolInputSchemaDigestsJson: input.toolInputSchemaDigests ?? {},
-        updatedAt: toPgDate(input.now)
-      }).where(predicate(tenantId2, relayAgentDefinitions.tenantId, eq3(relayAgentDefinitions.id, input.id))).returning();
-      const row = rows[0];
-      if (row === undefined) {
-        return yield* Effect5.fail(new AgentDefinitionRepositoryError({ message: "Agent definition put returned no row" }));
+      const nextRevision = (existing?.current_revision ?? 0) + 1;
+      const definitionJson = encodeJson(input.definition);
+      const digestsJson = encodeJson(input.toolInputSchemaDigests ?? {});
+      if (existing === undefined) {
+        yield* sql2`
+                INSERT INTO relay_agent_definitions (
+                  tenant_id, id, name, current_revision, definition_json, tool_input_schema_digests_json, created_at, updated_at
+                )
+                VALUES (
+                  ${tenantId},
+                  ${input.id},
+                  ${input.definition.name},
+                  ${nextRevision},
+                  ${definitionJson},
+                  ${digestsJson},
+                  ${timestampParam(sql2, input.now)},
+                  ${timestampParam(sql2, input.now)}
+                )
+              `;
+      } else {
+        yield* sql2`
+                UPDATE relay_agent_definitions
+                SET name = ${input.definition.name},
+                  current_revision = ${nextRevision},
+                  definition_json = ${definitionJson},
+                  tool_input_schema_digests_json = ${digestsJson},
+                  updated_at = ${timestampParam(sql2, input.now)}
+                WHERE tenant_id = ${tenantId} AND id = ${input.id}
+              `;
       }
-      const revisionRows = yield* tx.insert(relayAgentDefinitionRevisions).values({
-        tenantId: tenantId2,
-        agentDefinitionId: row.id,
-        revision: row.currentRevision,
-        name: input.definition.name,
-        definitionJson: input.definition,
-        toolInputSchemaDigestsJson: input.toolInputSchemaDigests ?? {},
-        createdAt: toPgDate(input.now)
-      }).returning();
-      if (revisionRows[0] === undefined) {
-        return yield* Effect5.fail(new AgentDefinitionRepositoryError({ message: "Agent definition revision insert returned no row" }));
+      yield* sql2`
+              INSERT INTO relay_agent_definition_revisions (
+                tenant_id, agent_definition_id, revision, name, definition_json, tool_input_schema_digests_json, created_at
+              )
+              VALUES (
+                ${tenantId},
+                ${input.id},
+                ${nextRevision},
+                ${input.definition.name},
+                ${definitionJson},
+                ${digestsJson},
+                ${timestampParam(sql2, input.now)}
+              )
+            `;
+      const rows = yield* selectByKey(tenantId, input.id);
+      if (rows[0] === undefined) {
+        return yield* Effect5.fail(new AgentDefinitionRepositoryError({ message: "Agent definition put returned no row" }));
       }
-      return toRecord2(row);
-    })));
+      return toRecord2(yield* decodeRow3(rows[0]));
+    })).pipe(Effect5.mapError(mapPutError));
   });
   const get2 = Effect5.fn("AgentDefinitionRepository.get")(function* (id2) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError2(db.select().from(relayAgentDefinitions).where(predicate(tenantId2, relayAgentDefinitions.tenantId, eq3(relayAgentDefinitions.id, id2))).limit(1));
-    return rows[0] === undefined ? undefined : toRecord2(rows[0]);
+    const tenantId = yield* current;
+    const rows = yield* selectByKey(tenantId, id2).pipe(Effect5.mapError(toRepositoryError3));
+    return rows[0] === undefined ? undefined : toRecord2(yield* decodeRow3(rows[0]));
   });
   const getRevision = Effect5.fn("AgentDefinitionRepository.getRevision")(function* (input) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError2(db.select().from(relayAgentDefinitionRevisions).where(predicate(tenantId2, relayAgentDefinitionRevisions.tenantId, eq3(relayAgentDefinitionRevisions.agentDefinitionId, input.id), eq3(relayAgentDefinitionRevisions.revision, input.revision))).limit(1));
-    return rows[0] === undefined ? undefined : toRevisionRecord(rows[0]);
+    const tenantId = yield* current;
+    const rows = yield* sql2`
+        SELECT ${revisionColumns}
+        FROM relay_agent_definition_revisions
+        WHERE tenant_id = ${tenantId} AND agent_definition_id = ${input.id} AND revision = ${input.revision}
+      `.pipe(Effect5.mapError(toRepositoryError3));
+    return rows[0] === undefined ? undefined : toRevisionRecord(yield* decodeRevisionRow(rows[0]));
   });
   const list2 = Effect5.fn("AgentDefinitionRepository.list")(function* () {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError2(db.select().from(relayAgentDefinitions).where(predicate(tenantId2, relayAgentDefinitions.tenantId)).orderBy(desc(relayAgentDefinitions.createdAt), asc2(relayAgentDefinitions.id)));
-    return rows.map(toRecord2);
+    const tenantId = yield* current;
+    const rows = yield* sql2`
+        SELECT ${columns}
+        FROM relay_agent_definitions
+        WHERE tenant_id = ${tenantId}
+        ORDER BY created_at DESC, id ASC
+      `.pipe(Effect5.mapError(toRepositoryError3));
+    const decoded = yield* Effect5.forEach(rows, decodeRow3);
+    return decoded.map(toRecord2);
   });
   const listRevisions = Effect5.fn("AgentDefinitionRepository.listRevisions")(function* (id2) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError2(db.select().from(relayAgentDefinitionRevisions).where(predicate(tenantId2, relayAgentDefinitionRevisions.tenantId, eq3(relayAgentDefinitionRevisions.agentDefinitionId, id2))).orderBy(desc(relayAgentDefinitionRevisions.revision)));
-    return rows.map(toRevisionRecord);
+    const tenantId = yield* current;
+    const rows = yield* sql2`
+        SELECT ${revisionColumns}
+        FROM relay_agent_definition_revisions
+        WHERE tenant_id = ${tenantId} AND agent_definition_id = ${id2}
+        ORDER BY revision DESC
+      `.pipe(Effect5.mapError(toRepositoryError3));
+    const decoded = yield* Effect5.forEach(rows, decodeRevisionRow);
+    return decoded.map(toRevisionRecord);
   });
   return Service5.of({ put, get: get2, getRevision, list: list2, listRevisions });
 }));
@@ -1845,11 +1519,12 @@ __export(exports_child_execution_repository, {
   create: () => create,
   Service: () => Service6,
   DuplicateChildExecution: () => DuplicateChildExecution,
+  ChildExecutionRow: () => ChildExecutionRow,
   ChildExecutionRepositoryError: () => ChildExecutionRepositoryError,
   ChildExecutionNotFound: () => ChildExecutionNotFound
 });
-import { asc as asc3, eq as eq4 } from "drizzle-orm";
 import { Context as Context6, Effect as Effect6, Layer as Layer6, Schema as Schema16 } from "effect";
+import * as SqlClient9 from "effect/unstable/sql/SqlClient";
 class ChildExecutionRepositoryError extends Schema16.TaggedErrorClass()("ChildExecutionRepositoryError", {
   message: Schema16.String
 }) {
@@ -1867,62 +1542,112 @@ class ChildExecutionNotFound extends Schema16.TaggedErrorClass()("ChildExecution
 
 class Service6 extends Context6.Service()("@relayfx/store-sql/ChildExecutionRepository") {
 }
+var ChildExecutionRow = Schema16.Struct({
+  id: Schema16.String,
+  execution_id: Schema16.String,
+  address_id: Schema16.String,
+  status: Schema16.String,
+  metadata_json: Schema16.Unknown,
+  created_at: Schema16.Union([Schema16.Date, Schema16.String, Schema16.Number]),
+  updated_at: Schema16.Union([Schema16.Date, Schema16.String, Schema16.Number])
+}).annotate({ identifier: "Relay.ChildExecution.Row" });
 var metadata2 = (input) => input ?? {};
-var toInsert = (tenantId2, input) => ({
-  tenantId: tenantId2,
-  id: input.id,
-  executionId: input.executionId,
-  addressId: input.addressId,
-  status: input.status,
-  metadataJson: metadata2(input.metadata),
-  createdAt: toPgDate(input.createdAt),
-  updatedAt: toPgDate(input.createdAt)
-});
 var toRecord3 = (row) => ({
-  id: row.id,
-  executionId: row.executionId,
-  addressId: row.addressId,
+  id: exports_ids_schema.ChildExecutionId.make(row.id),
+  executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
+  addressId: exports_ids_schema.AddressId.make(row.address_id),
   status: row.status,
-  metadata: row.metadataJson,
-  createdAt: fromPgDate(row.createdAt),
-  updatedAt: fromPgDate(row.updatedAt)
+  metadata: decodeJson(row.metadata_json),
+  createdAt: fromDbTimestamp(row.created_at),
+  updatedAt: fromDbTimestamp(row.updated_at)
 });
-var mapDatabaseError3 = (effect) => effect.pipe(Effect6.mapError((error) => new ChildExecutionRepositoryError({ message: String(error) })));
+var toRepositoryError4 = (error) => new ChildExecutionRepositoryError({ message: String(error) });
+var decodeRow4 = (row) => Schema16.decodeUnknownEffect(ChildExecutionRow)(row).pipe(Effect6.mapError(toRepositoryError4));
 var layer6 = Layer6.effect(Service6, Effect6.gen(function* () {
-  const db = yield* Service;
+  const sql2 = yield* SqlClient9.SqlClient;
+  const columns = sql2.literal(["id", "execution_id", "address_id", "status", "metadata_json", "created_at", "updated_at"].join(", "));
+  const selectByKey = (tenantId, id2) => sql2`
+      SELECT ${columns}
+      FROM relay_child_executions
+      WHERE tenant_id = ${tenantId} AND id = ${id2}
+    `;
+  const insertStatement = (tenantId, input) => sql2`
+      INSERT INTO relay_child_executions (
+        tenant_id, ${columns}
+      )
+      VALUES (
+        ${tenantId},
+        ${input.id},
+        ${input.executionId},
+        ${input.addressId},
+        ${input.status},
+        ${encodeJson(metadata2(input.metadata))},
+        ${timestampParam(sql2, input.createdAt)},
+        ${timestampParam(sql2, input.createdAt)}
+      )
+    `;
+  const insertChildExecution = sql2.onDialectOrElse({
+    mysql: () => (tenantId, input) => sql2.withTransaction(Effect6.gen(function* () {
+      yield* insertStatement(tenantId, input);
+      return yield* selectByKey(tenantId, input.id);
+    })),
+    orElse: () => (tenantId, input) => sql2`
+        ${insertStatement(tenantId, input)}
+        RETURNING ${columns}
+      `
+  });
+  const updateStatement = (tenantId, input) => sql2`
+      UPDATE relay_child_executions
+      SET status = ${input.status},
+        updated_at = ${timestampParam(sql2, input.updatedAt)}
+        ${input.metadata === undefined ? sql2.literal("") : sql2`, metadata_json = ${encodeJson(input.metadata)}`}
+      WHERE tenant_id = ${tenantId} AND id = ${input.id}
+    `;
+  const updateChildExecution = sql2.onDialectOrElse({
+    mysql: () => (tenantId, input) => sql2.withTransaction(Effect6.gen(function* () {
+      yield* updateStatement(tenantId, input);
+      return yield* selectByKey(tenantId, input.id);
+    })),
+    orElse: () => (tenantId, input) => sql2`
+        ${updateStatement(tenantId, input)}
+        RETURNING ${columns}
+      `
+  });
   const create = Effect6.fn("ChildExecutionRepository.create")(function* (input) {
-    const tenantId2 = yield* current;
-    const existing = yield* mapDatabaseError3(db.select().from(relayChildExecutions).where(predicate(tenantId2, relayChildExecutions.tenantId, eq4(relayChildExecutions.id, input.id))).limit(1));
+    const tenantId = yield* current;
+    const existing = yield* selectByKey(tenantId, input.id).pipe(Effect6.mapError(toRepositoryError4));
     if (existing[0] !== undefined)
       return yield* Effect6.fail(new DuplicateChildExecution({ id: input.id }));
-    const rows = yield* mapDatabaseError3(db.insert(relayChildExecutions).values(toInsert(tenantId2, input)).returning());
+    const rows = yield* insertChildExecution(tenantId, input).pipe(Effect6.mapError(toRepositoryError4));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect6.fail(new ChildExecutionRepositoryError({ message: "Child execution insert returned no row" }));
     }
-    return toRecord3(row);
+    return toRecord3(yield* decodeRow4(row));
   });
   const get3 = Effect6.fn("ChildExecutionRepository.get")(function* (id2) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError3(db.select().from(relayChildExecutions).where(predicate(tenantId2, relayChildExecutions.tenantId, eq4(relayChildExecutions.id, id2))).limit(1));
-    return rows[0] === undefined ? undefined : toRecord3(rows[0]);
+    const tenantId = yield* current;
+    const rows = yield* selectByKey(tenantId, id2).pipe(Effect6.mapError(toRepositoryError4));
+    return rows[0] === undefined ? undefined : toRecord3(yield* decodeRow4(rows[0]));
   });
   const listByExecution = Effect6.fn("ChildExecutionRepository.listByExecution")(function* (executionId) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError3(db.select().from(relayChildExecutions).where(predicate(tenantId2, relayChildExecutions.tenantId, eq4(relayChildExecutions.executionId, executionId))).orderBy(asc3(relayChildExecutions.createdAt)));
-    return rows.map(toRecord3);
+    const tenantId = yield* current;
+    const rows = yield* sql2`
+        SELECT ${columns}
+        FROM relay_child_executions
+        WHERE tenant_id = ${tenantId} AND execution_id = ${executionId}
+        ORDER BY created_at ASC
+      `.pipe(Effect6.mapError(toRepositoryError4));
+    const decoded = yield* Effect6.forEach(rows, decodeRow4);
+    return decoded.map(toRecord3);
   });
   const updateStatus = Effect6.fn("ChildExecutionRepository.updateStatus")(function* (input) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError3(db.update(relayChildExecutions).set({
-      status: input.status,
-      updatedAt: toPgDate(input.updatedAt),
-      ...input.metadata === undefined ? {} : { metadataJson: input.metadata }
-    }).where(predicate(tenantId2, relayChildExecutions.tenantId, eq4(relayChildExecutions.id, input.id))).returning());
+    const tenantId = yield* current;
+    const rows = yield* updateChildExecution(tenantId, input).pipe(Effect6.mapError(toRepositoryError4));
     const row = rows[0];
     if (row === undefined)
       return yield* Effect6.fail(new ChildExecutionNotFound({ id: input.id }));
-    return toRecord3(row);
+    return toRecord3(yield* decodeRow4(row));
   });
   return Service6.of({ create, get: get3, listByExecution, updateStatus });
 }));
@@ -1996,8 +1721,7 @@ __export(exports_cluster_registry_repository, {
   ClusterRegistryError: () => ClusterRegistryError
 });
 import { Context as Context7, Effect as Effect7, Layer as Layer7, Schema as Schema17 } from "effect";
-import { SqlClient as SqlClient5, SqlSchema } from "effect/unstable/sql";
-
+import * as SqlClient11 from "effect/unstable/sql/SqlClient";
 class ClusterRegistryError extends Schema17.TaggedErrorClass()("ClusterRegistryError", {
   message: Schema17.String
 }) {
@@ -2007,48 +1731,41 @@ class Service7 extends Context7.Service()("@relayfx/store-sql/ClusterRegistryRep
 }
 var RunnerRow = Schema17.Struct({
   address: Schema17.String,
-  healthy: Schema17.Boolean,
-  last_heartbeat: Schema17.Union([Schema17.Date, Schema17.DateFromString]),
-  owned_shards: Schema17.Union([Schema17.Number, Schema17.NumberFromString])
+  healthy: Schema17.Union([Schema17.Boolean, Schema17.Number, Schema17.String]),
+  last_heartbeat: Schema17.Union([Schema17.Date, Schema17.String, Schema17.Number]),
+  owned_shards: Schema17.Union([Schema17.Number, Schema17.String, Schema17.BigInt])
 }).annotate({ identifier: "Relay.ClusterRegistry.RunnerRow" });
 var LockRow = Schema17.Struct({
   address: Schema17.String
 }).annotate({ identifier: "Relay.ClusterRegistry.LockRow" });
 var toRunnerRecord = (row) => ({
   address: row.address,
-  healthy: row.healthy,
-  lastHeartbeat: row.last_heartbeat.getTime(),
-  ownedShards: row.owned_shards
+  healthy: decodeBool(row.healthy),
+  lastHeartbeat: fromDbTimestamp(row.last_heartbeat),
+  ownedShards: Number(row.owned_shards)
 });
 var toRegistryError = (error) => new ClusterRegistryError({ message: String(error) });
+var decodeRunnerRow = (row) => Schema17.decodeUnknownEffect(RunnerRow)(row).pipe(Effect7.mapError(toRegistryError));
+var decodeLockRow = (row) => Schema17.decodeUnknownEffect(LockRow)(row).pipe(Effect7.mapError(toRegistryError));
 var layer7 = Layer7.effect(Service7, Effect7.gen(function* () {
-  const sql5 = yield* SqlClient5.SqlClient;
-  const runnersQuery = SqlSchema.findAll({
-    Request: Schema17.Void,
-    Result: RunnerRow,
-    execute: () => sql5`
-        SELECT r.address, r.healthy, r.last_heartbeat, COUNT(l.shard_id) AS owned_shards
-        FROM cluster_runners r
-        LEFT JOIN cluster_locks l ON l.address = r.address
-        GROUP BY r.address, r.healthy, r.last_heartbeat
-        ORDER BY r.address
-      `
-  });
-  const ownerQuery = SqlSchema.findAll({
-    Request: Schema17.Struct({ shard_id: Schema17.String }),
-    Result: LockRow,
-    execute: ({ shard_id }) => sql5`SELECT address FROM cluster_locks WHERE shard_id = ${shard_id}`
+  const sql2 = yield* SqlClient11.SqlClient;
+  const selectRunners = () => sql2`
+      SELECT r.address, r.healthy, r.last_heartbeat, COUNT(l.shard_id) AS owned_shards
+      FROM cluster_runners r
+      LEFT JOIN cluster_locks l ON l.address = r.address
+      GROUP BY r.address, r.healthy, r.last_heartbeat
+      ORDER BY r.address
+    `;
+  const selectOwner = (shardId) => sql2`SELECT address FROM cluster_locks WHERE shard_id = ${shardId}`;
+  const listRunners = Effect7.fn("ClusterRegistryRepository.listRunners")(function* () {
+    const rows = yield* selectRunners().pipe(Effect7.catchTag("SqlError", () => Effect7.succeed([])));
+    return yield* Effect7.forEach(rows, (row) => Effect7.map(decodeRunnerRow(row), toRunnerRecord));
   });
-  return Service7.of({
-    listRunners: Effect7.fn("ClusterRegistryRepository.listRunners")(function* () {
-      const rows = yield* runnersQuery(undefined).pipe(Effect7.catchTag("SqlError", () => Effect7.succeed([])), Effect7.mapError(toRegistryError));
-      return rows.map(toRunnerRecord);
-    }),
-    lockOwner: Effect7.fn("ClusterRegistryRepository.lockOwner")(function* (shardId) {
-      const rows = yield* ownerQuery({ shard_id: shardId }).pipe(Effect7.catchTag("SqlError", () => Effect7.succeed([])), Effect7.mapError(toRegistryError));
-      return rows[0]?.address;
-    })
+  const lockOwner = Effect7.fn("ClusterRegistryRepository.lockOwner")(function* (shardId) {
+    const rows = yield* selectOwner(shardId).pipe(Effect7.catchTag("SqlError", () => Effect7.succeed([])));
+    return rows[0] === undefined ? undefined : (yield* decodeLockRow(rows[0])).address;
   });
+  return Service7.of({ listRunners, lockOwner });
 }));
 var memoryLayer5 = Layer7.succeed(Service7, Service7.of({
   listRunners: () => Effect7.succeed([]),
@@ -2073,10 +1790,11 @@ __export(exports_compaction_repository, {
   layer: () => layer8,
   get: () => get4,
   Service: () => Service8,
-  CompactionRepositoryError: () => CompactionRepositoryError
+  CompactionRepositoryError: () => CompactionRepositoryError,
+  CompactionCheckpointRow: () => CompactionCheckpointRow
 });
-import { asc as asc4, eq as eq5 } from "drizzle-orm";
 import { Context as Context8, Effect as Effect8, Layer as Layer8, Schema as Schema18 } from "effect";
+import * as SqlClient13 from "effect/unstable/sql/SqlClient";
 class CompactionRepositoryError extends Schema18.TaggedErrorClass()("CompactionRepositoryError", {
   message: Schema18.String
 }) {
@@ -2084,15 +1802,24 @@ class CompactionRepositoryError extends Schema18.TaggedErrorClass()("CompactionR
 
 class Service8 extends Context8.Service()("@relayfx/store-sql/CompactionRepository") {
 }
+var CompactionCheckpointRow = Schema18.Struct({
+  execution_id: Schema18.String,
+  checkpoint_id: Schema18.String,
+  summary: Schema18.String,
+  first_kept_entry_id: Schema18.String,
+  turn: Schema18.Number,
+  created_at: Schema18.Union([Schema18.Date, Schema18.String, Schema18.Number])
+}).annotate({ identifier: "Relay.CompactionCheckpoint.Row" });
 var toRecord4 = (row) => ({
-  executionId: row.executionId,
-  checkpointId: row.checkpointId,
+  executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
+  checkpointId: row.checkpoint_id,
   summary: row.summary,
-  firstKeptEntryId: row.firstKeptEntryId,
+  firstKeptEntryId: exports_ids_schema.SessionEntryId.make(row.first_kept_entry_id),
   turn: row.turn,
-  createdAt: fromPgDate(row.createdAt)
+  createdAt: fromDbTimestamp(row.created_at)
 });
-var mapDatabaseError4 = (effect) => effect.pipe(Effect8.mapError((error) => new CompactionRepositoryError({ message: String(error) })));
+var toRepositoryError5 = (error) => new CompactionRepositoryError({ message: String(error) });
+var decodeRow5 = (row) => Schema18.decodeUnknownEffect(CompactionCheckpointRow)(row).pipe(Effect8.mapError(toRepositoryError5));
 var key = (input) => `${input.executionId}:${input.checkpointId}`;
 var sameCheckpoint = (record, input) => record.summary === input.summary && record.firstKeptEntryId === input.firstKeptEntryId && record.turn === input.turn;
 var conflict = (input) => new CompactionRepositoryError({
@@ -2100,37 +1827,56 @@ var conflict = (input) => new CompactionRepositoryError({
 });
 var cloneRecord2 = (record) => structuredClone(record);
 var layer8 = Layer8.effect(Service8, Effect8.gen(function* () {
-  const db = yield* Service;
+  const sql2 = yield* SqlClient13.SqlClient;
+  const columns = sql2.literal(["execution_id", "checkpoint_id", "summary", "first_kept_entry_id", "turn", "created_at"].join(", "));
+  const selectByKey = (tenantId, input) => sql2`
+      SELECT ${columns}
+      FROM relay_agent_compactions
+      WHERE tenant_id = ${tenantId} AND execution_id = ${input.executionId} AND checkpoint_id = ${input.checkpointId}
+    `;
+  const insertValues = (tenantId, input) => sql2`
+      (
+        tenant_id, ${columns}
+      )
+      VALUES (
+        ${tenantId},
+        ${input.executionId},
+        ${input.checkpointId},
+        ${input.summary},
+        ${input.firstKeptEntryId},
+        ${input.turn},
+        ${timestampParam(sql2, input.createdAt)}
+      )
+    `;
+  const insertCheckpoint = sql2.onDialectOrElse({
+    mysql: () => (tenantId, input) => sql2.withTransaction(Effect8.gen(function* () {
+      yield* sql2`
+              INSERT IGNORE INTO relay_agent_compactions ${insertValues(tenantId, input)}
+            `;
+      return yield* selectByKey(tenantId, input);
+    })),
+    orElse: () => (tenantId, input) => sql2`
+        INSERT INTO relay_agent_compactions ${insertValues(tenantId, input)}
+        ON CONFLICT (tenant_id, execution_id, checkpoint_id) DO NOTHING
+        RETURNING ${columns}
+      `
+  });
   const get4 = Effect8.fn("CompactionRepository.get")(function* (input) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError4(db.select().from(relayAgentCompactions).where(predicate(tenantId2, relayAgentCompactions.tenantId, eq5(relayAgentCompactions.executionId, input.executionId), eq5(relayAgentCompactions.checkpointId, input.checkpointId))).limit(1));
-    return rows[0] === undefined ? undefined : toRecord4(rows[0]);
+    const tenantId = yield* current;
+    const rows = yield* selectByKey(tenantId, input).pipe(Effect8.mapError(toRepositoryError5));
+    return rows[0] === undefined ? undefined : toRecord4(yield* decodeRow5(rows[0]));
   });
   const record = Effect8.fn("CompactionRepository.record")(function* (input) {
-    const tenantId2 = yield* current;
+    const tenantId = yield* current;
     const existing = yield* get4(input);
     if (existing !== undefined) {
       if (!sameCheckpoint(existing, input))
         return yield* Effect8.fail(conflict(input));
       return existing;
     }
-    const rows = yield* mapDatabaseError4(db.insert(relayAgentCompactions).values({
-      tenantId: tenantId2,
-      executionId: input.executionId,
-      checkpointId: input.checkpointId,
-      summary: input.summary,
-      firstKeptEntryId: input.firstKeptEntryId,
-      turn: input.turn,
-      createdAt: toPgDate(input.createdAt)
-    }).onConflictDoNothing({
-      target: [
-        relayAgentCompactions.tenantId,
-        relayAgentCompactions.executionId,
-        relayAgentCompactions.checkpointId
-      ]
-    }).returning());
+    const rows = yield* insertCheckpoint(tenantId, input).pipe(Effect8.mapError(toRepositoryError5));
     const row = rows[0];
-    const saved = row === undefined ? yield* get4(input) : toRecord4(row);
+    const saved = row === undefined ? yield* get4(input) : toRecord4(yield* decodeRow5(row));
     if (saved === undefined)
       return yield* Effect8.fail(new CompactionRepositoryError({ message: "Compaction checkpoint insert returned no row" }));
     if (!sameCheckpoint(saved, input))
@@ -2138,9 +1884,15 @@ var layer8 = Layer8.effect(Service8, Effect8.gen(function* () {
     return saved;
   });
   const list3 = Effect8.fn("CompactionRepository.list")(function* (executionId) {
-    const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError4(db.select().from(relayAgentCompactions).where(predicate(tenantId2, relayAgentCompactions.tenantId, eq5(relayAgentCompactions.executionId, executionId))).orderBy(asc4(relayAgentCompactions.turn), asc4(relayAgentCompactions.checkpointId)));
-    return rows.map(toRecord4);
+    const tenantId = yield* current;
+    const rows = yield* sql2`
+        SELECT ${columns}
+        FROM relay_agent_compactions
+        WHERE tenant_id = ${tenantId} AND execution_id = ${executionId}
+        ORDER BY turn ASC, checkpoint_id ASC
+      `.pipe(Effect8.mapError(toRepositoryError5));
+    const decoded = yield* Effect8.forEach(rows, decodeRow5);
+    return decoded.map(toRecord4);
   });
   return Service8.of({ get: get4, record, list: list3 });
 }));
@@ -2208,7 +1960,7 @@ __export(exports_envelope_repository, {
   EnvelopeNotFound: () => EnvelopeNotFound
 });
 import { Context as Context9, Effect as Effect9, Layer as Layer9, Schema as Schema19 } from "effect";
-import * as SqlClient6 from "effect/unstable/sql/SqlClient";
+import * as SqlClient15 from "effect/unstable/sql/SqlClient";
 var WaitState = Schema19.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.Store.WaitState"
 });
@@ -2349,124 +2101,124 @@ var maxListWaitsLimit = 500;
 var defaultListWaitsLimit = 50;
 var listWaitsLimit = (input) => Math.min(Math.max(input.limit ?? defaultListWaitsLimit, 1), maxListWaitsLimit);
 var compareWaitsDesc = (left, right) => right.createdAt - left.createdAt || (left.id < right.id ? 1 : left.id > right.id ? -1 : 0);
-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 toRepositoryError6 = (error) => new EnvelopeRepositoryError({ message: String(error) });
+var decodeEnvelopeRow = (row) => Schema19.decodeUnknownEffect(EnvelopeRow)(row).pipe(Effect9.mapError(toRepositoryError6));
+var decodeWaitRow = (row) => Schema19.decodeUnknownEffect(WaitRow)(row).pipe(Effect9.mapError(toRepositoryError6));
+var decodeReadyRow = (row) => Schema19.decodeUnknownEffect(EnvelopeReadyRow)(row).pipe(Effect9.mapError(toRepositoryError6));
 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 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`
+  const sql2 = yield* SqlClient15.SqlClient;
+  const ts = (millis) => timestampParam(sql2, millis);
+  const waitColumns = sql2.literal(waitColumnsText);
+  const readyColumns = sql2.literal(readyColumnsText);
+  const envelopeColumns = sql2.literal(envelopeColumnsText);
+  const selectWaitById = (tenantId, id2) => sql2`
       SELECT ${waitColumns}
       FROM relay_waits
-      WHERE tenant_id = ${tenantId2} AND id = ${id2}
+      WHERE tenant_id = ${tenantId} AND id = ${id2}
     `;
-  const selectReadyById = (tenantId2, id2) => sql5`
+  const selectReadyById = (tenantId, id2) => sql2`
       SELECT ${readyColumns}
       FROM relay_envelope_ready
-      WHERE tenant_id = ${tenantId2} AND id = ${id2}
+      WHERE tenant_id = ${tenantId} AND id = ${id2}
     `;
-  const getWaitRow = (tenantId2, id2) => Effect9.gen(function* () {
-    const rows = yield* selectWaitById(tenantId2, id2).pipe(Effect9.mapError(toRepositoryError2));
+  const getWaitRow = (tenantId, id2) => Effect9.gen(function* () {
+    const rows = yield* selectWaitById(tenantId, id2).pipe(Effect9.mapError(toRepositoryError6));
     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));
+  const getReadyRow = (tenantId, id2) => Effect9.gen(function* () {
+    const rows = yield* selectReadyById(tenantId, id2).pipe(Effect9.mapError(toRepositoryError6));
     return rows[0] === undefined ? undefined : yield* decodeReadyRow(rows[0]);
   });
   const acceptEnvelope = Effect9.fn("EnvelopeRepository.acceptEnvelope")(function* (input) {
-    const tenantId2 = yield* current;
+    const tenantId = yield* current;
     const envelope = input.envelope;
     const wait = envelope.wait;
     const waitId = input.waitId;
     const ready = input.ready;
-    yield* sql5.withTransaction(Effect9.gen(function* () {
-      yield* sql5`
+    yield* sql2.withTransaction(Effect9.gen(function* () {
+      yield* sql2`
               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)})
+              VALUES (${tenantId}, ${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`
+        yield* sql2`
                 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)})
+                VALUES (${tenantId}, ${waitId}, ${envelope.execution_id}, ${envelope.id}, ${wait.mode}, ${wait.correlation_key ?? null}, 'open', ${encodeJson(metadata3(wait.metadata))}, ${ts(envelope.created_at)})
               `;
       }
       if (ready !== undefined) {
-        yield* sql5`
+        yield* sql2`
                 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)})
+                VALUES (${tenantId}, ${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));
+    })).pipe(Effect9.mapError(toRepositoryError6));
     return accepted(input);
   });
   const getEnvelope = Effect9.fn("EnvelopeRepository.getEnvelope")(function* (id2) {
-    const tenantId2 = yield* current;
-    const rows = yield* sql5`
+    const tenantId = yield* current;
+    const rows = yield* sql2`
         SELECT ${envelopeColumns}
         FROM relay_envelopes
-        WHERE tenant_id = ${tenantId2} AND id = ${id2}
-      `.pipe(Effect9.mapError(toRepositoryError2));
+        WHERE tenant_id = ${tenantId} AND id = ${id2}
+      `.pipe(Effect9.mapError(toRepositoryError6));
     return rows[0] === undefined ? undefined : toEnvelope(yield* decodeEnvelopeRow(rows[0]));
   });
   const getWait = Effect9.fn("EnvelopeRepository.getWait")(function* (id2) {
-    const tenantId2 = yield* current;
-    const row = yield* getWaitRow(tenantId2, id2);
+    const tenantId = yield* current;
+    const row = yield* getWaitRow(tenantId, id2);
     return row === undefined ? undefined : toWaitRecord(row);
   });
   const createWait = Effect9.fn("EnvelopeRepository.createWait")(function* (input) {
-    const tenantId2 = yield* current;
-    yield* sql5`
+    const tenantId = yield* current;
+    yield* sql2`
         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);
+        VALUES (${tenantId}, ${input.waitId}, ${input.executionId}, ${null}, ${input.mode}, ${input.correlationKey ?? null}, 'open', ${encodeJson(metadata3(input.metadata))}, ${ts(input.createdAt)})
+      `.pipe(Effect9.mapError(toRepositoryError6));
+    const row = yield* getWaitRow(tenantId, input.waitId);
     if (row === undefined) {
       return yield* Effect9.fail(new EnvelopeRepositoryError({ message: `Wait ${input.waitId} was not persisted` }));
     }
     return toWaitRecord(row);
   });
   const listWaits = Effect9.fn("EnvelopeRepository.listWaits")(function* (input) {
-    const tenantId2 = yield* current;
+    const tenantId = yield* current;
     const conditions = [
-      sql5`tenant_id = ${tenantId2}`,
-      ...input.executionId === undefined ? [] : [sql5`execution_id = ${input.executionId}`],
-      ...input.state === undefined ? [] : [sql5`state = ${input.state}`]
+      sql2`tenant_id = ${tenantId}`,
+      ...input.executionId === undefined ? [] : [sql2`execution_id = ${input.executionId}`],
+      ...input.state === undefined ? [] : [sql2`state = ${input.state}`]
     ];
-    const rows = yield* sql5`
+    const rows = yield* sql2`
         SELECT ${waitColumns}
         FROM relay_waits
-        WHERE ${sql5.and(conditions)}
+        WHERE ${sql2.and(conditions)}
         ORDER BY created_at DESC, id DESC
-        LIMIT ${sql5.literal(String(listWaitsLimit(input)))}
-      `.pipe(Effect9.mapError(toRepositoryError2));
+        LIMIT ${sql2.literal(String(listWaitsLimit(input)))}
+      `.pipe(Effect9.mapError(toRepositoryError6));
     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 claimablePredicate = (input) => sql2.or([
+    sql2.and([sql2`state = 'ready'`, sql2`available_at <= ${ts(input.now)}`]),
+    sql2.and([
+      sql2`state = 'claimed'`,
+      sql2`claim_expires_at IS NOT NULL`,
+      sql2`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}`],
+  const claimConditions = (tenantId, input) => sql2.and([
+    sql2`tenant_id = ${tenantId}`,
+    sql2`route_type = ${input.routeType}`,
+    ...input.routeKey === undefined ? [] : [sql2`route_key = ${input.routeKey}`],
     claimablePredicate(input)
   ]);
-  const claimUpdateSet = (input) => sql5`
+  const claimUpdateSet = (input) => sql2`
       state = 'claimed',
       claim_owner = ${input.workerId},
       claim_expires_at = ${ts(input.claimExpiresAt)},
@@ -2474,11 +2226,11 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
       updated_at = ${ts(input.now)},
       attempt = attempt + 1
     `;
-  const runClaimReady = sql5.onDialectOrElse({
-    mysql: () => (tenantId2, input) => sql5.withTransaction(Effect9.gen(function* () {
-      const candidates = yield* sql5`
+  const runClaimReady = sql2.onDialectOrElse({
+    mysql: () => (tenantId, input) => sql2.withTransaction(Effect9.gen(function* () {
+      const candidates = yield* sql2`
               SELECT id FROM relay_envelope_ready
-              WHERE ${claimConditions(tenantId2, input)}
+              WHERE ${claimConditions(tenantId, input)}
               ORDER BY available_at ASC, created_at ASC
               LIMIT 1
               FOR UPDATE
@@ -2486,57 +2238,57 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
       const candidate = candidates[0];
       if (candidate === undefined)
         return [];
-      yield* sql5`
+      yield* sql2`
               UPDATE relay_envelope_ready
               SET ${claimUpdateSet(input)}
-              WHERE tenant_id = ${tenantId2} AND id = ${candidate.id} AND ${claimablePredicate(input)}
+              WHERE tenant_id = ${tenantId} AND id = ${candidate.id} AND ${claimablePredicate(input)}
             `;
-      const rows = yield* sql5`
+      const rows = yield* sql2`
               SELECT ${readyColumns}
               FROM relay_envelope_ready
-              WHERE tenant_id = ${tenantId2} AND id = ${candidate.id}
+              WHERE tenant_id = ${tenantId} 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`
+    orElse: () => (tenantId, input) => Effect9.gen(function* () {
+      const candidates = yield* sql2`
             SELECT id FROM relay_envelope_ready
-            WHERE ${claimConditions(tenantId2, input)}
+            WHERE ${claimConditions(tenantId, input)}
             ORDER BY available_at ASC, created_at ASC
             LIMIT 1
           `;
       const candidate = candidates[0];
       if (candidate === undefined)
         return [];
-      return yield* sql5`
+      return yield* sql2`
             UPDATE relay_envelope_ready
             SET ${claimUpdateSet(input)}
-            WHERE tenant_id = ${tenantId2} AND id = ${candidate.id} AND ${claimablePredicate(input)}
+            WHERE tenant_id = ${tenantId} AND id = ${candidate.id} AND ${claimablePredicate(input)}
             RETURNING ${readyColumns}
           `;
     })
   });
   const claimReady = Effect9.fn("EnvelopeRepository.claimReady")(function* (input) {
-    const tenantId2 = yield* current;
-    const rows = yield* runClaimReady(tenantId2, input).pipe(Effect9.mapError(toRepositoryError2));
+    const tenantId = yield* current;
+    const rows = yield* runClaimReady(tenantId, input).pipe(Effect9.mapError(toRepositoryError6));
     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`
+  const runReleaseReady = sql2.onDialectOrElse({
+    mysql: () => (tenantId, input) => sql2.withTransaction(Effect9.gen(function* () {
+      const locked = yield* sql2`
               SELECT ${readyColumns}
               FROM relay_envelope_ready
-              WHERE tenant_id = ${tenantId2} AND id = ${input.id}
+              WHERE tenant_id = ${tenantId} AND id = ${input.id}
               FOR UPDATE
             `;
       const current2 = locked[0];
       if (current2 === undefined || current2.state !== "claimed" || current2.claim_owner !== input.workerId) {
         return [];
       }
-      yield* sql5`
+      yield* sql2`
               UPDATE relay_envelope_ready
               SET state = 'ready',
                   available_at = ${ts(input.nextAvailableAt)},
@@ -2544,11 +2296,11 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
                   claim_expires_at = NULL,
                   last_error = ${input.error ?? null},
                   updated_at = ${ts(input.nextAvailableAt)}
-              WHERE tenant_id = ${tenantId2} AND id = ${input.id}
+              WHERE tenant_id = ${tenantId} AND id = ${input.id}
             `;
-      return yield* selectReadyById(tenantId2, input.id);
+      return yield* selectReadyById(tenantId, input.id);
     })),
-    orElse: () => (tenantId2, input) => sql5`
+    orElse: () => (tenantId, input) => sql2`
         UPDATE relay_envelope_ready
         SET state = 'ready',
             available_at = ${ts(input.nextAvailableAt)},
@@ -2556,105 +2308,105 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
             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'
+        WHERE tenant_id = ${tenantId} 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* runReleaseReady(tenantId2, input).pipe(Effect9.mapError(toRepositoryError2));
+    const tenantId = yield* current;
+    const rows = yield* runReleaseReady(tenantId, input).pipe(Effect9.mapError(toRepositoryError6));
     if (rows[0] !== undefined)
       return toReadyRecord(yield* decodeReadyRow(rows[0]));
-    const current2 = yield* getReadyRow(tenantId2, input.id);
+    const current2 = yield* getReadyRow(tenantId, input.id);
     if (current2 === undefined)
       return yield* Effect9.fail(new EnvelopeReadyNotFound({ id: input.id }));
     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`
+  const runAckReady = sql2.onDialectOrElse({
+    mysql: () => (tenantId, input) => sql2.withTransaction(Effect9.gen(function* () {
+      const locked = yield* sql2`
               SELECT ${readyColumns}
               FROM relay_envelope_ready
-              WHERE tenant_id = ${tenantId2} AND id = ${input.id}
+              WHERE tenant_id = ${tenantId} AND id = ${input.id}
               FOR UPDATE
             `;
       const current2 = locked[0];
       if (current2 === undefined || current2.state !== "claimed" || current2.claim_owner !== input.workerId) {
         return [];
       }
-      yield* sql5`
+      yield* sql2`
               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}
+              WHERE tenant_id = ${tenantId} AND id = ${input.id}
             `;
-      return yield* selectReadyById(tenantId2, input.id);
+      return yield* selectReadyById(tenantId, input.id);
     })),
-    orElse: () => (tenantId2, input) => sql5`
+    orElse: () => (tenantId, input) => sql2`
         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'
+        WHERE tenant_id = ${tenantId} 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* runAckReady(tenantId2, input).pipe(Effect9.mapError(toRepositoryError2));
+    const tenantId = yield* current;
+    const rows = yield* runAckReady(tenantId, input).pipe(Effect9.mapError(toRepositoryError6));
     if (rows[0] !== undefined)
       return toReadyRecord(yield* decodeReadyRow(rows[0]));
-    const current2 = yield* getReadyRow(tenantId2, input.id);
+    const current2 = yield* getReadyRow(tenantId, input.id);
     if (current2 === undefined)
       return yield* Effect9.fail(new EnvelopeReadyNotFound({ id: input.id }));
     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`
+  const runCompleteWait = sql2.onDialectOrElse({
+    mysql: () => (tenantId, input, merged) => sql2.withTransaction(Effect9.gen(function* () {
+      const locked = yield* sql2`
               SELECT ${waitColumns}
               FROM relay_waits
-              WHERE tenant_id = ${tenantId2} AND id = ${input.waitId}
+              WHERE tenant_id = ${tenantId} AND id = ${input.waitId}
               FOR UPDATE
             `;
       const current2 = locked[0];
       if (current2 === undefined || current2.state !== "open")
         return [];
-      yield* sql5`
+      yield* sql2`
               UPDATE relay_waits
               SET state = ${input.state},
                   resolved_at = ${ts(input.completedAt)},
                   metadata_json = ${encodeJson(merged)}
-              WHERE tenant_id = ${tenantId2} AND id = ${input.waitId}
+              WHERE tenant_id = ${tenantId} AND id = ${input.waitId}
             `;
-      return yield* selectWaitById(tenantId2, input.waitId);
+      return yield* selectWaitById(tenantId, input.waitId);
     })),
-    orElse: () => (tenantId2, input, merged) => sql5`
+    orElse: () => (tenantId, input, merged) => sql2`
         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'
+        WHERE tenant_id = ${tenantId} 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(tenantId2, input.waitId);
+    const tenantId = yield* current;
+    const current2 = yield* getWaitRow(tenantId, input.waitId);
     if (current2 === undefined)
       return yield* Effect9.fail(new WaitNotFound({ id: 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));
+    const rows = yield* runCompleteWait(tenantId, input, merged).pipe(Effect9.mapError(toRepositoryError6));
     if (rows[0] === undefined) {
-      const latest = yield* getWaitRow(tenantId2, input.waitId);
+      const latest = yield* getWaitRow(tenantId, input.waitId);
       if (latest === undefined)
         return yield* Effect9.fail(new WaitNotFound({ id: input.waitId }));
       return { wait: toWaitRecord(latest), transitioned: false };
@@ -2870,30 +2622,482 @@ var resolveWait = Effect9.fn("EnvelopeRepository.resolveWait.call")(function* (i
   return yield* repository.resolveWait(input);
 });
 // ../store-sql/src/execution/execution-event-repository.ts
-var exports_execution_event_repository = {};
-__export(exports_execution_event_repository, {
-  testLayer: () => testLayer9,
-  sumUsage: () => sumUsage,
-  notifyAppended: () => notifyAppended,
-  memoryLayer: () => memoryLayer8,
-  maxSequence: () => maxSequence,
-  listAfterSequence: () => listAfterSequence,
-  list: () => list4,
-  layer: () => layer10,
-  findFirstByTypeAfterSequence: () => findFirstByTypeAfterSequence,
-  findBySequenceOrCursor: () => findBySequenceOrCursor,
-  findByCursor: () => findByCursor,
-  executionEventsChannel: () => executionEventsChannel,
-  appendedSignals: () => appendedSignals,
-  append: () => append,
-  Service: () => Service10,
-  ExecutionEventRepositoryError: () => ExecutionEventRepositoryError,
-  ExecutionEventOrderViolation: () => ExecutionEventOrderViolation,
-  ExecutionEventCursorNotFound: () => ExecutionEventCursorNotFound,
-  DuplicateExecutionEvent: () => DuplicateExecutionEvent
-});
-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 exports_execution_event_repository = {};
+__export(exports_execution_event_repository, {
+  testLayer: () => testLayer9,
+  sumUsage: () => sumUsage,
+  notifyAppended: () => notifyAppended,
+  memoryLayer: () => memoryLayer8,
+  maxSequence: () => maxSequence,
+  listAfterSequence: () => listAfterSequence,
+  list: () => list4,
+  layer: () => layer10,
+  findFirstByTypeAfterSequence: () => findFirstByTypeAfterSequence,
+  findBySequenceOrCursor: () => findBySequenceOrCursor,
+  findByCursor: () => findByCursor,
+  executionEventsChannel: () => executionEventsChannel,
+  appendedSignals: () => appendedSignals,
+  append: () => append,
+  Service: () => Service10,
+  ExecutionEventRepositoryError: () => ExecutionEventRepositoryError,
+  ExecutionEventOrderViolation: () => ExecutionEventOrderViolation,
+  ExecutionEventCursorNotFound: () => ExecutionEventCursorNotFound,
+  DuplicateExecutionEvent: () => DuplicateExecutionEvent
+});
+import { asc, desc, eq as eq2, gt, max, or, sql as sql3 } from "drizzle-orm";
+import { Context as Context10, Effect as Effect10, Filter, Layer as Layer10, Option as Option2, Schema as Schema20, Stream } from "effect";
+
+// ../store-sql/src/schema/relay-schema.ts
+var exports_relay_schema = {};
+__export(exports_relay_schema, {
+  relayWorkspaceSnapshots: () => relayWorkspaceSnapshots,
+  relayWorkspaceLeases: () => relayWorkspaceLeases,
+  relayWaits: () => relayWaits,
+  relayToolResults: () => relayToolResults,
+  relayToolCalls: () => relayToolCalls,
+  relaySteeringMessages: () => relaySteeringMessages,
+  relaySteeringDrains: () => relaySteeringDrains,
+  relaySkillDefinitions: () => relaySkillDefinitions,
+  relaySkillDefinitionRevisions: () => relaySkillDefinitionRevisions,
+  relaySessions: () => relaySessions,
+  relaySessionEntries: () => relaySessionEntries,
+  relaySchedules: () => relaySchedules,
+  relayRouteAttempts: () => relayRouteAttempts,
+  relayPermissionRules: () => relayPermissionRules,
+  relayMemoryRecords: () => relayMemoryRecords,
+  relayIdempotencyKeys: () => relayIdempotencyKeys,
+  relayExecutions: () => relayExecutions,
+  relayExecutionSkillPins: () => relayExecutionSkillPins,
+  relayExecutionEvents: () => relayExecutionEvents,
+  relayExecutionContextEpochs: () => relayExecutionContextEpochs,
+  relayEnvelopes: () => relayEnvelopes,
+  relayEnvelopeReady: () => relayEnvelopeReady,
+  relayChildExecutions: () => relayChildExecutions,
+  relayAgentDefinitions: () => relayAgentDefinitions,
+  relayAgentDefinitionRevisions: () => relayAgentDefinitionRevisions,
+  relayAgentCompactions: () => relayAgentCompactions,
+  relayAgentChats: () => relayAgentChats,
+  relayAddressBookEntries: () => relayAddressBookEntries
+});
+import {
+  doublePrecision,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  primaryKey,
+  text as text2,
+  timestamp,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+import { sql as sql2 } from "drizzle-orm";
+var tenantId = () => text2("tenant_id").$type().notNull().default(exports_ids_schema.SystemTenantId);
+var relayAddressBookEntries = pgTable("relay_address_book_entries", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  addressId: text2("address_id").$type().notNull(),
+  routeKind: text2("route_kind").notNull(),
+  routeKey: text2("route_key").notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_address_book_entries" }),
+  uniqueIndex("uq_relay_address_book_address").on(table.tenantId, table.addressId)
+]);
+var relayAgentDefinitions = pgTable("relay_agent_definitions", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  name: text2("name").notNull(),
+  currentRevision: integer("current_revision").$type().notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  toolInputSchemaDigestsJson: jsonb("tool_input_schema_digests_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_agent_definitions" }),
+  index("idx_relay_agent_definitions_name").on(table.tenantId, table.name)
+]);
+var relayAgentDefinitionRevisions = pgTable("relay_agent_definition_revisions", {
+  tenantId: tenantId(),
+  agentDefinitionId: text2("agent_definition_id").$type().notNull(),
+  revision: integer("revision").$type().notNull(),
+  name: text2("name").notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  toolInputSchemaDigestsJson: jsonb("tool_input_schema_digests_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.agentDefinitionId, table.revision],
+    name: "pk_relay_agent_definition_revisions"
+  }),
+  index("idx_relay_agent_definition_revisions_definition").on(table.tenantId, table.agentDefinitionId, table.revision)
+]);
+var relaySkillDefinitions = pgTable("relay_skill_definitions", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  name: text2("name").notNull(),
+  currentRevision: integer("current_revision").$type().notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_skill_definitions" }),
+  index("idx_relay_skill_definitions_name").on(table.tenantId, table.name)
+]);
+var relaySkillDefinitionRevisions = pgTable("relay_skill_definition_revisions", {
+  tenantId: tenantId(),
+  skillDefinitionId: text2("skill_definition_id").notNull().$type(),
+  revision: integer("revision").notNull().$type(),
+  name: text2("name").notNull(),
+  definitionJson: jsonb("definition_json").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.skillDefinitionId, table.revision],
+    name: "pk_relay_skill_definition_revisions"
+  }),
+  index("idx_relay_skill_definition_revisions_definition").on(table.tenantId, table.skillDefinitionId, table.revision)
+]);
+var relayExecutionSkillPins = pgTable("relay_execution_skill_pins", {
+  tenantId: tenantId(),
+  executionId: text2("execution_id").notNull().$type(),
+  skillDefinitionId: text2("skill_definition_id").notNull().$type(),
+  skillDefinitionRevision: integer("skill_definition_revision").notNull().$type(),
+  skillDefinitionSnapshotJson: jsonb("skill_definition_snapshot_json").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.executionId, table.skillDefinitionId],
+    name: "pk_relay_execution_skill_pins"
+  }),
+  index("idx_relay_execution_skill_pins_execution").on(table.tenantId, table.executionId)
+]);
+var relayAgentChats = pgTable("relay_agent_chats", {
+  tenantId: tenantId(),
+  executionId: text2("execution_id").$type().notNull(),
+  exportJson: jsonb("export_json").notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId], name: "pk_relay_agent_chats" })]);
+var relayAgentCompactions = pgTable("relay_agent_compactions", {
+  tenantId: tenantId(),
+  executionId: text2("execution_id").notNull().$type(),
+  checkpointId: text2("checkpoint_id").notNull(),
+  summary: text2("summary").notNull(),
+  firstKeptEntryId: text2("first_kept_entry_id").$type().notNull(),
+  turn: integer("turn").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.executionId, table.checkpointId],
+    name: "pk_relay_agent_compactions"
+  }),
+  index("idx_relay_agent_compactions_execution_turn").on(table.tenantId, table.executionId, table.turn)
+]);
+var relayMemoryRecords = pgTable("relay_memory_records", {
+  tenantId: tenantId(),
+  id: text2("id").notNull(),
+  agent: text2("agent").notNull(),
+  subject: text2("subject").$type().notNull(),
+  embedding: doublePrecision("embedding").array().notNull(),
+  partsJson: jsonb("parts_json").$type().notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_memory_records" }),
+  index("idx_relay_memory_records_agent_subject").on(table.tenantId, table.agent, table.subject)
+]);
+var relayPermissionRules = pgTable("relay_permission_rules", {
+  tenantId: tenantId(),
+  agent: text2("agent").notNull(),
+  scope: text2("scope").notNull(),
+  pattern: text2("pattern").notNull(),
+  ruleJson: jsonb("rule_json").$type().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.agent, table.scope, table.pattern],
+    name: "pk_relay_permission_rules"
+  }),
+  index("idx_relay_permission_rules_agent_scope").on(table.tenantId, table.agent, table.scope)
+]);
+var relaySteeringMessages = pgTable("relay_steering_messages", {
+  tenantId: tenantId(),
+  executionId: text2("execution_id").notNull(),
+  kind: text2("kind").notNull(),
+  sequence: integer("sequence").notNull(),
+  contentJson: jsonb("content_json").$type().notNull(),
+  drainId: text2("drain_id"),
+  consumedAt: timestamp("consumed_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.executionId, table.kind, table.sequence],
+    name: "pk_relay_steering_messages"
+  }),
+  index("idx_relay_steering_messages_unconsumed").on(table.tenantId, table.executionId, table.kind, table.consumedAt, table.sequence),
+  index("idx_relay_steering_messages_drain").on(table.tenantId, table.executionId, table.kind, table.drainId, table.sequence)
+]);
+var relaySteeringDrains = pgTable("relay_steering_drains", {
+  tenantId: tenantId(),
+  executionId: text2("execution_id").notNull(),
+  kind: text2("kind").notNull(),
+  drainId: text2("drain_id").notNull(),
+  messageSequencesJson: jsonb("message_sequences_json").$type().notNull().default([]),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({
+    columns: [table.tenantId, table.executionId, table.kind, table.drainId],
+    name: "pk_relay_steering_drains"
+  })
+]);
+var relaySessions = pgTable("relay_sessions", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  rootAddressId: text2("root_address_id").$type().notNull(),
+  leafEntryId: text2("leaf_entry_id").$type(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_sessions" }),
+  index("idx_relay_sessions_updated_id").on(table.tenantId, table.updatedAt, table.id),
+  index("idx_relay_sessions_root_updated_id").on(table.tenantId, table.rootAddressId, table.updatedAt, table.id)
+]);
+var relaySessionEntries = pgTable("relay_session_entries", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  sessionId: text2("session_id").$type().notNull(),
+  parentId: text2("parent_id").$type(),
+  tag: text2("tag").notNull(),
+  payloadJson: jsonb("payload_json").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_session_entries" }),
+  index("idx_relay_session_entries_session_created").on(table.tenantId, table.sessionId, table.createdAt, table.id),
+  index("idx_relay_session_entries_session_parent").on(table.tenantId, table.sessionId, table.parentId)
+]);
+var relayExecutionContextEpochs = pgTable("relay_execution_context_epochs", {
+  tenantId: tenantId(),
+  executionId: text2("execution_id").$type().notNull(),
+  baseline: text2("baseline").notNull(),
+  dynamicSourceIdsJson: jsonb("dynamic_source_ids_json").$type().notNull().default([]),
+  openedAt: timestamp("opened_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId], name: "pk_relay_execution_context_epochs" })]);
+var relayExecutions = pgTable("relay_executions", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  rootAddressId: text2("root_address_id").$type().notNull(),
+  sessionId: text2("session_id").$type(),
+  status: text2("status").$type().notNull(),
+  agentDefinitionId: text2("agent_definition_id").$type(),
+  agentDefinitionRevision: integer("agent_definition_revision").$type(),
+  agentDefinitionSnapshotJson: jsonb("agent_definition_snapshot_json").$type(),
+  agentDefinitionToolInputSchemaDigestsJson: jsonb("agent_definition_tool_input_schema_digests_json").$type().notNull().default({}),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_executions" }),
+  index("idx_relay_executions_root_status").on(table.tenantId, table.rootAddressId, table.status),
+  index("idx_relay_executions_session_updated_id").on(table.tenantId, table.sessionId, table.updatedAt, table.id),
+  index("idx_relay_executions_updated_id").on(table.tenantId, table.updatedAt, table.id),
+  index("idx_relay_executions_root_status_updated_id").on(table.tenantId, table.rootAddressId, table.status, table.updatedAt, table.id)
+]);
+var relayChildExecutions = pgTable("relay_child_executions", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  executionId: text2("execution_id").$type().notNull(),
+  addressId: text2("address_id").$type().notNull(),
+  status: text2("status").$type().notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_child_executions" }),
+  index("idx_relay_child_executions_parent").on(table.tenantId, table.executionId)
+]);
+var relayEnvelopes = pgTable("relay_envelopes", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  executionId: text2("execution_id").$type().notNull(),
+  fromAddressId: text2("from_address_id").$type().notNull(),
+  toAddressId: text2("to_address_id").$type().notNull(),
+  contentJson: jsonb("content_json").$type().notNull(),
+  waitJson: jsonb("wait_json").$type(),
+  correlationKey: text2("correlation_key"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_envelopes" }),
+  index("idx_relay_envelopes_execution").on(table.tenantId, table.executionId, table.createdAt),
+  index("idx_relay_envelopes_to_address").on(table.tenantId, table.toAddressId, table.createdAt)
+]);
+var relayWaits = pgTable("relay_waits", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  executionId: text2("execution_id").$type().notNull(),
+  envelopeId: text2("envelope_id").$type(),
+  mode: text2("mode").$type().notNull(),
+  correlationKey: text2("correlation_key"),
+  state: text2("state").notNull().default("open"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  resolvedAt: timestamp("resolved_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_waits" }),
+  index("idx_relay_waits_execution_state").on(table.tenantId, table.executionId, table.state)
+]);
+var relayWorkspaceLeases = pgTable("relay_workspace_leases", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  executionId: text2("execution_id").$type().notNull(),
+  providerKey: text2("provider_key").$type().notNull(),
+  sandboxRef: text2("sandbox_ref").$type(),
+  latestSnapshotRef: text2("latest_snapshot_ref").$type(),
+  status: text2("status").$type().notNull(),
+  resumeStrategy: text2("resume_strategy").$type().notNull(),
+  region: text2("region"),
+  requestJson: jsonb("request_json").$type(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_workspace_leases" }),
+  uniqueIndex("uq_relay_workspace_leases_active_execution").on(table.tenantId, table.executionId).where(sql2`${table.status} not in ('released', 'failed')`),
+  index("idx_relay_workspace_leases_execution").on(table.tenantId, table.executionId),
+  index("idx_relay_workspace_leases_status_updated").on(table.tenantId, table.status, table.updatedAt)
+]);
+var relayWorkspaceSnapshots = pgTable("relay_workspace_snapshots", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  leaseId: text2("lease_id").$type().notNull(),
+  executionId: text2("execution_id").$type().notNull(),
+  reason: text2("reason").$type().notNull(),
+  snapshotRef: text2("snapshot_ref").$type().notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_workspace_snapshots" }),
+  index("idx_relay_workspace_snapshots_lease").on(table.tenantId, table.leaseId, table.createdAt),
+  index("idx_relay_workspace_snapshots_execution").on(table.tenantId, table.executionId, table.createdAt)
+]);
+var relayEnvelopeReady = pgTable("relay_envelope_ready", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  envelopeId: text2("envelope_id").$type().notNull(),
+  routeType: text2("route_type").notNull(),
+  routeKey: text2("route_key").notNull(),
+  state: text2("state").notNull().default("ready"),
+  availableAt: timestamp("available_at", { withTimezone: true }).notNull().defaultNow(),
+  attempt: integer("attempt").notNull().default(0),
+  claimOwner: text2("claim_owner"),
+  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+  lastError: text2("last_error"),
+  idempotencyKey: text2("idempotency_key"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  claimedAt: timestamp("claimed_at", { withTimezone: true }),
+  acknowledgedAt: timestamp("acknowledged_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_envelope_ready" }),
+  index("idx_relay_envelope_ready_state_available").on(table.tenantId, table.state, table.availableAt),
+  index("idx_relay_envelope_ready_claim_expires").on(table.tenantId, table.claimExpiresAt),
+  uniqueIndex("uq_relay_envelope_ready_idempotency").on(table.tenantId, table.idempotencyKey)
+]);
+var relaySchedules = pgTable("relay_schedules", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  kind: text2("kind").notNull(),
+  targetKind: text2("target_kind").notNull(),
+  addressId: text2("address_id").$type(),
+  waitId: text2("wait_id").$type(),
+  cronExpr: text2("cron_expr"),
+  inputJson: jsonb("input_json").$type(),
+  state: text2("state").notNull().default("active"),
+  nextRunAt: timestamp("next_run_at", { withTimezone: true }).notNull(),
+  attempt: integer("attempt").notNull().default(0),
+  claimOwner: text2("claim_owner"),
+  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+  lastError: text2("last_error"),
+  idempotencyKey: text2("idempotency_key"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_schedules" }),
+  index("idx_relay_schedules_state_next_run").on(table.tenantId, table.state, table.nextRunAt),
+  index("idx_relay_schedules_claim_expires").on(table.tenantId, table.claimExpiresAt),
+  index("idx_relay_schedules_wait").on(table.tenantId, table.waitId),
+  uniqueIndex("uq_relay_schedules_idempotency").on(table.tenantId, table.idempotencyKey)
+]);
+var relayExecutionEvents = pgTable("relay_execution_events", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  executionId: text2("execution_id").$type().notNull(),
+  childExecutionId: text2("child_execution_id").$type(),
+  type: text2("type").notNull(),
+  sequence: integer("sequence").notNull(),
+  cursor: text2("cursor").notNull(),
+  contentJson: jsonb("content_json").$type(),
+  dataJson: jsonb("data_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_execution_events" }),
+  index("idx_relay_execution_events_execution").on(table.tenantId, table.executionId, table.createdAt),
+  uniqueIndex("uq_relay_execution_events_sequence").on(table.tenantId, table.executionId, table.sequence),
+  uniqueIndex("uq_relay_execution_events_cursor").on(table.tenantId, table.cursor)
+]);
+var relayToolCalls = pgTable("relay_tool_calls", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  executionId: text2("execution_id").$type().notNull(),
+  name: text2("name").notNull(),
+  inputJson: jsonb("input_json").notNull(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_tool_calls" }),
+  index("idx_relay_tool_calls_execution").on(table.tenantId, table.executionId, table.createdAt)
+]);
+var relayToolResults = pgTable("relay_tool_results", {
+  tenantId: tenantId(),
+  toolCallId: text2("tool_call_id").$type().notNull(),
+  outputJson: jsonb("output_json").notNull(),
+  error: text2("error"),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [primaryKey({ columns: [table.tenantId, table.toolCallId], name: "pk_relay_tool_results" })]);
+var relayRouteAttempts = pgTable("relay_route_attempts", {
+  tenantId: tenantId(),
+  id: text2("id").notNull(),
+  envelopeReadyId: text2("envelope_ready_id").$type().notNull(),
+  routeKey: text2("route_key").notNull(),
+  state: text2("state").notNull(),
+  detail: text2("detail"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_route_attempts" }),
+  index("idx_relay_route_attempts_ready").on(table.tenantId, table.envelopeReadyId, table.createdAt)
+]);
+var relayIdempotencyKeys = pgTable("relay_idempotency_keys", {
+  tenantId: tenantId(),
+  id: text2("id").notNull(),
+  scope: text2("scope").notNull(),
+  operation: text2("operation").notNull(),
+  key: text2("key").notNull(),
+  resultJson: jsonb("result_json").$type(),
+  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  expiresAt: timestamp("expires_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_idempotency_keys" }),
+  uniqueIndex("uq_relay_idempotency_scope_operation_key").on(table.tenantId, table.scope, table.operation, table.key)
+]);
+
+// ../store-sql/src/execution/execution-event-repository.ts
 var executionEventsChannel = "relay_execution_events";
 
 class DuplicateExecutionEvent extends Schema20.TaggedErrorClass()("DuplicateExecutionEvent", {
@@ -2956,7 +3160,7 @@ var toEvent = (row) => ({
   data: row.dataJson,
   created_at: fromPgDate(row.createdAt)
 });
-var mapDatabaseError5 = (effect) => effect.pipe(Effect10.mapError((error) => new ExecutionEventRepositoryError({ message: String(error) })));
+var mapDatabaseError = (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) => {
@@ -3002,7 +3206,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* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.execution_id))).orderBy(desc2(relayExecutionEvents.sequence)).limit(1));
+    const previousRows = yield* mapDatabaseError(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, input.execution_id))).orderBy(desc(relayExecutionEvents.sequence)).limit(1));
     const previous = previousRows[0];
     if (previous !== undefined && input.sequence === previous.sequence) {
       return yield* Effect10.fail(duplicateError(input));
@@ -3014,11 +3218,11 @@ var layer10 = Layer10.effect(Service10, Effect10.gen(function* () {
         previous_sequence: previous.sequence
       }));
     }
-    const duplicateCursorRows = yield* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.cursor, input.cursor))).limit(1));
+    const duplicateCursorRows = yield* mapDatabaseError(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.cursor, input.cursor))).limit(1));
     if (duplicateCursorRows[0] !== undefined) {
       return yield* Effect10.fail(duplicateError(input));
     }
-    const rows = yield* mapDatabaseError5(db.insert(relayExecutionEvents).values(toRow(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError(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" }));
@@ -3028,49 +3232,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* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId))).orderBy(asc5(relayExecutionEvents.sequence)).limit(listLimit(input)));
+      const rows2 = yield* mapDatabaseError(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, input.executionId))).orderBy(asc(relayExecutionEvents.sequence)).limit(listLimit(input)));
       return rows2.map(toEvent);
     }
-    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 cursorRows = yield* mapDatabaseError(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, input.executionId), eq2(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* 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)));
+    const rows = yield* mapDatabaseError(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, input.executionId), gt(relayExecutionEvents.sequence, cursorRow.sequence))).orderBy(asc(relayExecutionEvents.sequence)).limit(listLimit(input)));
     return rows.map(toEvent);
   });
   const findBySequenceOrCursor = Effect10.fn("ExecutionEventRepository.findBySequenceOrCursor")(function* (input) {
     const tenantId2 = yield* current;
-    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 rows = yield* mapDatabaseError(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, input.executionId), or(eq2(relayExecutionEvents.sequence, input.sequence), eq2(relayExecutionEvents.cursor, input.cursor)))).orderBy(asc(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* mapDatabaseError5(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, input.executionId), eq6(relayExecutionEvents.cursor, input.cursor))).limit(1));
+    const rows = yield* mapDatabaseError(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, input.executionId), eq2(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* 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 rows = yield* mapDatabaseError(db.select().from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, input.executionId), eq2(relayExecutionEvents.type, input.type), gt(relayExecutionEvents.sequence, input.afterSequence))).orderBy(asc(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* mapDatabaseError5(db.select({ value: max(relayExecutionEvents.sequence) }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, executionId))));
+    const rows = yield* mapDatabaseError(db.select({ value: max(relayExecutionEvents.sequence) }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(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* mapDatabaseError5(db.select({
-      value: sql5`sum(
+    const rows = yield* mapDatabaseError(db.select({
+      value: sql3`sum(
               coalesce((${relayExecutionEvents.dataJson} ->> 'input_tokens')::bigint, 0)
               + coalesce((${relayExecutionEvents.dataJson} ->> 'output_tokens')::bigint, 0)
             )`
-    }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq6(relayExecutionEvents.executionId, executionId), eq6(relayExecutionEvents.type, usageReportedEventType))));
+    }).from(relayExecutionEvents).where(predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, executionId), eq2(relayExecutionEvents.type, usageReportedEventType))));
     const value = rows[0]?.value;
     return value === null || value === undefined ? 0 : Number(value);
   });
@@ -3081,7 +3285,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* 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));
+    const rows = yield* mapDatabaseError(db.select().from(relayExecutionEvents).where(input.afterSequence === undefined ? predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, input.executionId)) : predicate(tenantId2, relayExecutionEvents.tenantId, eq2(relayExecutionEvents.executionId, input.executionId), gt(relayExecutionEvents.sequence, input.afterSequence))).orderBy(asc(relayExecutionEvents.sequence)).limit(input.limit));
     return rows.map(toEvent);
   });
   return Service10.of({
@@ -3203,7 +3407,7 @@ __export(exports_execution_repository, {
   DuplicateExecution: () => DuplicateExecution
 });
 import { Context as Context11, Effect as Effect11, Layer as Layer11, Schema as Schema21 } from "effect";
-import * as SqlClient8 from "effect/unstable/sql/SqlClient";
+import * as SqlClient17 from "effect/unstable/sql/SqlClient";
 class ExecutionRepositoryError extends Schema21.TaggedErrorClass()("ExecutionRepositoryError", {
   message: Schema21.String
 }) {
@@ -3283,8 +3487,8 @@ var toRecord5 = (row) => {
     updatedAt: fromDbTimestamp(row.updated_at)
   };
 };
-var toRepositoryError3 = (error) => new ExecutionRepositoryError({ message: String(error) });
-var decodeRow2 = (row) => Schema21.decodeUnknownEffect(ExecutionRow)(row).pipe(Effect11.mapError(toRepositoryError3));
+var toRepositoryError7 = (error) => new ExecutionRepositoryError({ message: String(error) });
+var decodeRow6 = (row) => Schema21.decodeUnknownEffect(ExecutionRow)(row).pipe(Effect11.mapError(toRepositoryError7));
 var maxListLimit2 = 100;
 var defaultListLimit = 50;
 var listLimit2 = (input) => Math.min(Math.max(input.limit ?? defaultListLimit, 1), maxListLimit2);
@@ -3295,8 +3499,8 @@ 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 layer11 = Layer11.effect(Service11, Effect11.gen(function* () {
-  const sql6 = yield* SqlClient8.SqlClient;
-  const columns = sql6.literal([
+  const sql4 = yield* SqlClient17.SqlClient;
+  const columns = sql4.literal([
     "id",
     "root_address_id",
     "session_id",
@@ -3309,12 +3513,12 @@ var layer11 = Layer11.effect(Service11, Effect11.gen(function* () {
     "created_at",
     "updated_at"
   ].join(", "));
-  const selectByKey = (tenantId2, id2) => sql6`
+  const selectByKey = (tenantId2, id2) => sql4`
       SELECT ${columns}
       FROM relay_executions
       WHERE tenant_id = ${tenantId2} AND id = ${id2}
     `;
-  const insertStatement = (tenantId2, input) => sql6`
+  const insertStatement = (tenantId2, input) => sql4`
       INSERT INTO relay_executions (
         tenant_id, ${columns}
       )
@@ -3329,48 +3533,48 @@ var layer11 = Layer11.effect(Service11, Effect11.gen(function* () {
         ${input.agentDefinitionSnapshot === undefined ? null : encodeJson(input.agentDefinitionSnapshot)},
         ${encodeJson(input.agentDefinitionToolInputSchemaDigests ?? {})},
         ${encodeJson(metadata4(input.metadata))},
-        ${timestampParam(sql6, input.createdAt)},
-        ${timestampParam(sql6, input.createdAt)}
+        ${timestampParam(sql4, input.createdAt)},
+        ${timestampParam(sql4, input.createdAt)}
       )
     `;
-  const insertExecution = sql6.onDialectOrElse({
-    mysql: () => (tenantId2, input) => sql6.withTransaction(Effect11.gen(function* () {
+  const insertExecution = sql4.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql4.withTransaction(Effect11.gen(function* () {
       yield* insertStatement(tenantId2, input);
       return yield* selectByKey(tenantId2, input.id);
     })),
-    orElse: () => (tenantId2, input) => sql6`
+    orElse: () => (tenantId2, input) => sql4`
         ${insertStatement(tenantId2, input)}
         RETURNING ${columns}
       `
   });
-  const updateStatement = (tenantId2, input) => sql6`
+  const updateStatement = (tenantId2, input) => sql4`
       UPDATE relay_executions
       SET status = ${input.status},
         metadata_json = ${encodeJson(metadata4(input.metadata))},
-        updated_at = ${timestampParam(sql6, input.updatedAt)}
+        updated_at = ${timestampParam(sql4, input.updatedAt)}
       WHERE tenant_id = ${tenantId2} AND id = ${input.id}
     `;
-  const updateExecution = sql6.onDialectOrElse({
-    mysql: () => (tenantId2, input) => sql6.withTransaction(Effect11.gen(function* () {
+  const updateExecution = sql4.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql4.withTransaction(Effect11.gen(function* () {
       yield* updateStatement(tenantId2, input);
       return yield* selectByKey(tenantId2, input.id);
     })),
-    orElse: () => (tenantId2, input) => sql6`
+    orElse: () => (tenantId2, input) => sql4`
         ${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}`],
+    sql4`tenant_id = ${tenantId2}`,
+    ...input.rootAddressId === undefined ? [] : [sql4`root_address_id = ${input.rootAddressId}`],
+    ...input.sessionId === undefined ? [] : [sql4`session_id = ${input.sessionId}`],
+    ...input.status === undefined ? [] : [sql4`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}`
+      sql4.or([
+        sql4`updated_at < ${timestampParam(sql4, input.cursor.updatedAt)}`,
+        sql4.and([
+          sql4`updated_at = ${timestampParam(sql4, input.cursor.updatedAt)}`,
+          sql4`id < ${input.cursor.id}`
         ])
       ])
     ]
@@ -3378,43 +3582,43 @@ var layer11 = Layer11.effect(Service11, Effect11.gen(function* () {
   const create2 = Effect11.fn("ExecutionRepository.create")(function* (input) {
     const tenantId2 = yield* current;
     yield* validateCreateInput(input);
-    const existing = yield* selectByKey(tenantId2, input.id).pipe(Effect11.mapError(toRepositoryError3));
+    const existing = yield* selectByKey(tenantId2, input.id).pipe(Effect11.mapError(toRepositoryError7));
     if (existing[0] !== undefined)
       return yield* Effect11.fail(new DuplicateExecution({ id: input.id }));
-    const rows = yield* insertExecution(tenantId2, input).pipe(Effect11.mapError(toRepositoryError3));
+    const rows = yield* insertExecution(tenantId2, input).pipe(Effect11.mapError(toRepositoryError7));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect11.fail(new ExecutionRepositoryError({ message: "Execution insert returned no row" }));
     }
-    return toRecord5(yield* decodeRow2(row));
+    return toRecord5(yield* decodeRow6(row));
   });
   const get5 = Effect11.fn("ExecutionRepository.get")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* selectByKey(tenantId2, id2).pipe(Effect11.mapError(toRepositoryError3));
-    return rows[0] === undefined ? undefined : toRecord5(yield* decodeRow2(rows[0]));
+    const rows = yield* selectByKey(tenantId2, id2).pipe(Effect11.mapError(toRepositoryError7));
+    return rows[0] === undefined ? undefined : toRecord5(yield* decodeRow6(rows[0]));
   });
   const list5 = Effect11.fn("ExecutionRepository.list")(function* (input) {
     const tenantId2 = yield* current;
     const limit = listLimit2(input);
-    const rows = yield* sql6`
+    const rows = yield* sql4`
         SELECT ${columns}
         FROM relay_executions
-        WHERE ${sql6.and(listConditions(tenantId2, input))}
+        WHERE ${sql4.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);
+        LIMIT ${sql4.literal(String(limit + 1))}
+      `.pipe(Effect11.mapError(toRepositoryError7));
+    const decoded = yield* Effect11.forEach(rows.slice(0, limit), decodeRow6);
     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* updateExecution(tenantId2, input).pipe(Effect11.mapError(toRepositoryError3));
+    const rows = yield* updateExecution(tenantId2, input).pipe(Effect11.mapError(toRepositoryError7));
     const row = rows[0];
     if (row === undefined)
       return yield* Effect11.fail(new ExecutionNotFound({ id: input.id }));
-    return toRecord5(yield* decodeRow2(row));
+    return toRecord5(yield* decodeRow6(row));
   });
   return Service11.of({ create: create2, get: get5, list: list5, transition });
 }));
@@ -3489,7 +3693,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 eq7, sql as sql6 } from "drizzle-orm";
+import { eq as eq3, sql as sql4 } 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
@@ -3512,7 +3716,7 @@ var toRecord6 = (row) => {
     ...expiresAt === undefined ? {} : { expiresAt }
   };
 };
-var toInsert2 = (tenantId2, input, result) => ({
+var toInsert = (tenantId2, input, result) => ({
   tenantId: tenantId2,
   id: operationId(input),
   scope: input.scope,
@@ -3529,17 +3733,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(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);
+      yield* tx.execute(sql4`select pg_advisory_xact_lock(hashtextextended(${`${tenantId2}:${operationId(input)}`}, 0))`);
+      const existingRows = yield* tx.select().from(relayIdempotencyKeys).where(predicate(tenantId2, relayIdempotencyKeys.tenantId, eq3(relayIdempotencyKeys.scope, input.scope), eq3(relayIdempotencyKeys.operation, input.operation), eq3(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(toInsert2(tenantId2, input, result)).onConflictDoNothing().returning();
+      const rows = yield* tx.insert(relayIdempotencyKeys).values(toInsert(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, eq7(relayIdempotencyKeys.scope, input.scope), eq7(relayIdempotencyKeys.operation, input.operation), eq7(relayIdempotencyKeys.key, input.key))).limit(1);
+      const winnerRows = yield* tx.select().from(relayIdempotencyKeys).where(predicate(tenantId2, relayIdempotencyKeys.tenantId, eq3(relayIdempotencyKeys.scope, input.scope), eq3(relayIdempotencyKeys.operation, input.operation), eq3(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" }));
@@ -3589,7 +3793,7 @@ __export(exports_memory_repository, {
   Service: () => Service13,
   MemoryRepositoryError: () => MemoryRepositoryError
 });
-import { sql as sql7 } from "drizzle-orm";
+import { sql as sql5 } 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
@@ -3616,7 +3820,7 @@ var queryRowToRecord = (row) => ({
   metadata: row.metadataJson,
   createdAt: fromPgDate(row.createdAt)
 });
-var mapDatabaseError6 = (effect) => effect.pipe(Effect13.mapError((error) => new MemoryRepositoryError({ message: String(error) })));
+var mapDatabaseError2 = (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)
@@ -3660,7 +3864,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* mapDatabaseError6(db.insert(relayMemoryRecords).values({
+    const rows = yield* mapDatabaseError2(db.insert(relayMemoryRecords).values({
       tenantId: tenantId2,
       id: input.id,
       agent: input.agent,
@@ -3690,8 +3894,8 @@ var layer13 = Layer13.effect(Service13, Effect13.gen(function* () {
     yield* validateVector("query embedding", input.embedding);
     if (input.topK <= 0)
       return [];
-    const queryEmbeddingSql = sql7`array[${sql7.join(input.embedding.map((value) => sql7`${value}`), sql7`, `)}]::double precision[]`;
-    const rows = yield* mapDatabaseError6(db.execute(sql7`
+    const queryEmbeddingSql = sql5`array[${sql5.join(input.embedding.map((value) => sql5`${value}`), sql5`, `)}]::double precision[]`;
+    const rows = yield* mapDatabaseError2(db.execute(sql5`
           with query_embedding as (
             select ${queryEmbeddingSql} as embedding
           ),
@@ -3829,10 +4033,11 @@ __export(exports_permission_rule_repository, {
   list: () => list6,
   layer: () => layer14,
   Service: () => Service14,
+  PermissionRuleRow: () => PermissionRuleRow,
   PermissionRuleRepositoryError: () => PermissionRuleRepositoryError
 });
-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";
+import * as SqlClient19 from "effect/unstable/sql/SqlClient";
 class PermissionRuleRepositoryError extends Schema24.TaggedErrorClass()("PermissionRuleRepositoryError", {
   message: Schema24.String
 }) {
@@ -3840,47 +4045,71 @@ class PermissionRuleRepositoryError extends Schema24.TaggedErrorClass()("Permiss
 
 class Service14 extends Context14.Service()("@relayfx/store-sql/PermissionRuleRepository") {
 }
+var PermissionRuleRow = Schema24.Struct({
+  agent: Schema24.String,
+  scope: Schema24.String,
+  rule_json: Schema24.Unknown,
+  created_at: Schema24.Union([Schema24.Date, Schema24.String, Schema24.Number])
+}).annotate({ identifier: "Relay.PermissionRule.Row" });
 var toRecord8 = (row) => ({
   agent: row.agent,
   scope: row.scope,
-  rule: row.ruleJson,
-  createdAt: fromPgDate(row.createdAt)
+  rule: decodeJson(row.rule_json),
+  createdAt: fromDbTimestamp(row.created_at)
 });
-var mapDatabaseError7 = (effect) => effect.pipe(Effect14.mapError((error) => new PermissionRuleRepositoryError({ message: String(error) })));
+var toRepositoryError8 = (error) => new PermissionRuleRepositoryError({ message: String(error) });
+var decodeRow7 = (row) => Schema24.decodeUnknownEffect(PermissionRuleRow)(row).pipe(Effect14.mapError(toRepositoryError8));
 var memoryKey = (agent, scope, pattern) => `${agent}\x00${scope}\x00${pattern}`;
 var layer14 = Layer14.effect(Service14, Effect14.gen(function* () {
-  const db = yield* Service;
+  const sql6 = yield* SqlClient19.SqlClient;
+  const selectByKey = (tenantId2, input) => sql6`
+      SELECT agent, scope, rule_json, created_at
+      FROM relay_permission_rules
+      WHERE tenant_id = ${tenantId2}
+        AND agent = ${input.agent}
+        AND scope = ${input.scope}
+        AND pattern = ${input.rule.pattern}
+    `;
+  const upsert3 = sql6.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql6.withTransaction(Effect14.gen(function* () {
+      yield* sql6`
+              INSERT INTO relay_permission_rules (tenant_id, agent, scope, pattern, rule_json, created_at)
+              VALUES (${tenantId2}, ${input.agent}, ${input.scope}, ${input.rule.pattern}, ${encodeJson(input.rule)}, ${timestampParam(sql6, input.createdAt)})
+              ON DUPLICATE KEY UPDATE
+                rule_json = VALUES(rule_json),
+                created_at = VALUES(created_at)
+            `;
+      return yield* selectByKey(tenantId2, input);
+    })),
+    orElse: () => (tenantId2, input) => sql6`
+        INSERT INTO relay_permission_rules (tenant_id, agent, scope, pattern, rule_json, created_at)
+        VALUES (${tenantId2}, ${input.agent}, ${input.scope}, ${input.rule.pattern}, ${encodeJson(input.rule)}, ${timestampParam(sql6, input.createdAt)})
+        ON CONFLICT (tenant_id, agent, scope, pattern) DO UPDATE SET
+          rule_json = excluded.rule_json,
+          created_at = excluded.created_at
+        RETURNING agent, scope, rule_json, created_at
+      `
+  });
   const remember = Effect14.fn("PermissionRuleRepository.remember")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError7(db.insert(relayPermissionRules).values({
-      tenantId: tenantId2,
-      agent: input.agent,
-      scope: input.scope,
-      pattern: input.rule.pattern,
-      ruleJson: input.rule,
-      createdAt: toPgDate(input.createdAt)
-    }).onConflictDoUpdate({
-      target: [
-        relayPermissionRules.tenantId,
-        relayPermissionRules.agent,
-        relayPermissionRules.scope,
-        relayPermissionRules.pattern
-      ],
-      set: {
-        ruleJson: input.rule,
-        createdAt: toPgDate(input.createdAt)
-      }
-    }).returning());
+    const rows = yield* upsert3(tenantId2, input).pipe(Effect14.mapError(toRepositoryError8));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect14.fail(new PermissionRuleRepositoryError({ message: "Permission rule upsert returned no row" }));
     }
-    return toRecord8(row);
+    return toRecord8(yield* decodeRow7(row));
   });
   const list6 = Effect14.fn("PermissionRuleRepository.list")(function* (input) {
     const tenantId2 = yield* current;
-    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);
+    const rows = yield* sql6`
+        SELECT agent, scope, rule_json, created_at
+        FROM relay_permission_rules
+        WHERE tenant_id = ${tenantId2}
+          AND agent = ${input.agent}
+          AND scope = ${input.scope}
+        ORDER BY created_at ASC, pattern ASC
+      `.pipe(Effect14.mapError(toRepositoryError8));
+    return yield* Effect14.forEach(rows, (row) => decodeRow7(row).pipe(Effect14.map(toRecord8)));
   });
   return Service14.of({ remember, list: list6 });
 }));
@@ -3920,10 +4149,11 @@ __export(exports_context_epoch_repository, {
   layer: () => layer15,
   get: () => get6,
   Service: () => Service15,
+  ContextEpochRow: () => ContextEpochRow,
   ContextEpochRepositoryError: () => ContextEpochRepositoryError
 });
-import { eq as eq9 } from "drizzle-orm";
 import { Context as Context15, Effect as Effect15, Layer as Layer15, Schema as Schema25 } from "effect";
+import * as SqlClient21 from "effect/unstable/sql/SqlClient";
 class ContextEpochRepositoryError extends Schema25.TaggedErrorClass()("ContextEpochRepositoryError", {
   message: Schema25.String
 }) {
@@ -3931,37 +4161,60 @@ class ContextEpochRepositoryError extends Schema25.TaggedErrorClass()("ContextEp
 
 class Service15 extends Context15.Service()("@relayfx/store-sql/ContextEpochRepository") {
 }
+var ContextEpochRow = Schema25.Struct({
+  execution_id: Schema25.String,
+  baseline: Schema25.String,
+  dynamic_source_ids_json: Schema25.Unknown,
+  opened_at: Schema25.Union([Schema25.Date, Schema25.String, Schema25.Number])
+}).annotate({ identifier: "Relay.ContextEpoch.Row" });
 var toRecord9 = (row) => ({
-  executionId: row.executionId,
+  executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
   baseline: row.baseline,
-  dynamicSourceIds: row.dynamicSourceIdsJson,
-  openedAt: fromPgDate(row.openedAt)
+  dynamicSourceIds: decodeJson(row.dynamic_source_ids_json),
+  openedAt: fromDbTimestamp(row.opened_at)
 });
-var mapDatabaseError8 = (effect) => effect.pipe(Effect15.mapError((error) => new ContextEpochRepositoryError({ message: String(error) })));
+var toRepositoryError9 = (error) => new ContextEpochRepositoryError({ message: String(error) });
+var decodeRow8 = (row) => Schema25.decodeUnknownEffect(ContextEpochRow)(row).pipe(Effect15.mapError(toRepositoryError9));
 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);
 var layer15 = Layer15.effect(Service15, Effect15.gen(function* () {
-  const db = yield* Service;
+  const sql6 = yield* SqlClient21.SqlClient;
+  const selectByKey = (tenantId2, executionId) => sql6`
+      SELECT execution_id, baseline, dynamic_source_ids_json, opened_at
+      FROM relay_execution_context_epochs
+      WHERE tenant_id = ${tenantId2} AND execution_id = ${executionId}
+    `;
+  const insertIfAbsent = sql6.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql6.withTransaction(Effect15.gen(function* () {
+      yield* sql6`
+              INSERT IGNORE INTO relay_execution_context_epochs (tenant_id, execution_id, baseline, dynamic_source_ids_json, opened_at)
+              VALUES (${tenantId2}, ${input.executionId}, ${input.baseline}, ${encodeJson([...input.dynamicSourceIds])}, ${timestampParam(sql6, input.openedAt)})
+            `;
+      return yield* selectByKey(tenantId2, input.executionId);
+    })),
+    orElse: () => (tenantId2, input) => sql6`
+        INSERT INTO relay_execution_context_epochs (tenant_id, execution_id, baseline, dynamic_source_ids_json, opened_at)
+        VALUES (${tenantId2}, ${input.executionId}, ${input.baseline}, ${encodeJson([...input.dynamicSourceIds])}, ${timestampParam(sql6, input.openedAt)})
+        ON CONFLICT (tenant_id, execution_id) DO NOTHING
+        RETURNING execution_id, baseline, dynamic_source_ids_json, opened_at
+      `
+  });
   const get6 = Effect15.fn("ContextEpochRepository.get")(function* (executionId) {
     const tenantId2 = yield* current;
-    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 rows = yield* selectByKey(tenantId2, executionId).pipe(Effect15.mapError(toRepositoryError9));
+    return rows[0] === undefined ? undefined : toRecord9(yield* decodeRow8(rows[0]));
   });
   const save2 = Effect15.fn("ContextEpochRepository.save")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError8(db.insert(relayExecutionContextEpochs).values({
-      tenantId: tenantId2,
-      executionId: input.executionId,
-      baseline: input.baseline,
-      dynamicSourceIdsJson: [...input.dynamicSourceIds],
-      openedAt: toPgDate(input.openedAt)
-    }).onConflictDoNothing({
-      target: [relayExecutionContextEpochs.tenantId, relayExecutionContextEpochs.executionId]
-    }).returning());
+    const rows = yield* insertIfAbsent(tenantId2, input).pipe(Effect15.mapError(toRepositoryError9));
     const row = rows[0];
-    if (row !== undefined)
-      return toRecord9(row);
+    if (row !== undefined) {
+      const record2 = toRecord9(yield* decodeRow8(row));
+      if (!sameEpoch(record2, input))
+        return yield* Effect15.fail(conflict2(input.executionId));
+      return record2;
+    }
     const existing = yield* get6(input.executionId);
     if (existing === undefined) {
       return yield* Effect15.fail(new ContextEpochRepositoryError({ message: "Context epoch insert returned no row" }));
@@ -4024,7 +4277,7 @@ __export(exports_schedule_repository, {
   ScheduleNotFound: () => ScheduleNotFound,
   ScheduleClaimMismatch: () => ScheduleClaimMismatch
 });
-import { and as and2, asc as asc7, eq as eq10, inArray, lte, or as or2, sql as sql8 } from "drizzle-orm";
+import { and as and2, asc as asc2, eq as eq4, inArray, lte, or as or2, sql as sql6 } 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
@@ -4060,7 +4313,7 @@ var validationError = (input) => {
   }
   return;
 };
-var toInsert3 = (tenantId2, input) => ({
+var toInsert2 = (tenantId2, input) => ({
   tenantId: tenantId2,
   id: input.id,
   kind: input.kind,
@@ -4091,12 +4344,12 @@ var toRecord10 = (row) => ({
   created_at: fromPgDate(row.createdAt),
   updated_at: fromPgDate(row.updatedAt)
 });
-var mapDatabaseError9 = (effect) => effect.pipe(Effect16.mapError((error) => new ScheduleRepositoryError({ message: String(error) })));
+var mapDatabaseError3 = (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) => 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 getRow = (tenantId2, id2) => mapDatabaseError3(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, eq4(relaySchedules.id, id2))).limit(1)).pipe(Effect16.map((rows) => rows[0]));
+  const getByIdempotencyKey = (tenantId2, key2) => mapDatabaseError3(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, eq4(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);
@@ -4107,7 +4360,7 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
       if (existing !== undefined)
         return toRecord10(existing);
     }
-    const rows = yield* mapDatabaseError9(db.insert(relaySchedules).values(toInsert3(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError3(db.insert(relaySchedules).values(toInsert2(tenantId2, input)).returning());
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect16.fail(new ScheduleRepositoryError({ message: `Schedule ${input.id} was not persisted` }));
@@ -4121,17 +4374,17 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
   });
   const list7 = Effect16.fn("ScheduleRepository.list")(function* (input) {
     const tenantId2 = yield* current;
-    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)));
+    const rows = yield* mapDatabaseError3(db.select().from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, input.state === undefined ? undefined : eq4(relaySchedules.state, input.state))).orderBy(asc2(relaySchedules.nextRunAt), asc2(relaySchedules.createdAt)));
     return rows.map(toRecord10);
   });
   const cancel = Effect16.fn("ScheduleRepository.cancel")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError9(db.update(relaySchedules).set({
+    const rows = yield* mapDatabaseError3(db.update(relaySchedules).set({
       state: "cancelled",
       claimOwner: null,
       claimExpiresAt: null,
       updatedAt: toPgDate(input.cancelledAt)
-    }).where(predicate(tenantId2, relaySchedules.tenantId, eq10(relaySchedules.id, input.id), inArray(relaySchedules.state, [...cancellableStates]))).returning());
+    }).where(predicate(tenantId2, relaySchedules.tenantId, eq4(relaySchedules.id, input.id), inArray(relaySchedules.state, [...cancellableStates]))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toRecord10(row);
@@ -4144,23 +4397,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, 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({
+    const candidate = db.select({ id: relaySchedules.id }).from(relaySchedules).where(predicate(tenantId2, relaySchedules.tenantId, or2(and2(eq4(relaySchedules.state, "active"), lte(relaySchedules.nextRunAt, toPgDate(input.now))), and2(eq4(relaySchedules.state, "claimed"), lte(relaySchedules.claimExpiresAt, toPgDate(input.now)))))).orderBy(asc2(relaySchedules.nextRunAt), asc2(relaySchedules.createdAt)).limit(1).for("update", { skipLocked: true });
+    const rows = yield* mapDatabaseError3(db.update(relaySchedules).set({
       state: "claimed",
       claimOwner: input.workerId,
       claimExpiresAt: toPgDate(input.claimExpiresAt),
       updatedAt: toPgDate(input.now),
-      attempt: sql8`${relaySchedules.attempt} + 1`
+      attempt: sql6`${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* mapDatabaseError9(db.update(relaySchedules).set({
+    const rows = yield* mapDatabaseError3(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, eq10(relaySchedules.id, input.id), eq10(relaySchedules.claimOwner, input.workerId), eq10(relaySchedules.state, "claimed"))).returning());
+    }).where(predicate(tenantId2, relaySchedules.tenantId, eq4(relaySchedules.id, input.id), eq4(relaySchedules.claimOwner, input.workerId), eq4(relaySchedules.state, "claimed"))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toRecord10(row);
@@ -4173,14 +4426,14 @@ var layer16 = Layer16.effect(Service16, Effect16.gen(function* () {
   });
   const release = Effect16.fn("ScheduleRepository.release")(function* (input) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError9(db.update(relaySchedules).set({
+    const rows = yield* mapDatabaseError3(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, eq10(relaySchedules.id, input.id), eq10(relaySchedules.claimOwner, input.workerId), eq10(relaySchedules.state, "claimed"))).returning());
+    }).where(predicate(tenantId2, relaySchedules.tenantId, eq4(relaySchedules.id, input.id), eq4(relaySchedules.claimOwner, input.workerId), eq4(relaySchedules.state, "claimed"))).returning());
     const row = rows[0];
     if (row !== undefined)
       return toRecord10(row);
@@ -4364,7 +4617,7 @@ __export(exports_session_repository, {
   DuplicateSession: () => DuplicateSession
 });
 import { Context as Context17, Effect as Effect17, Layer as Layer17, Schema as Schema27 } from "effect";
-import * as SqlClient10 from "effect/unstable/sql/SqlClient";
+import * as SqlClient23 from "effect/unstable/sql/SqlClient";
 class SessionRepositoryError extends Schema27.TaggedErrorClass()("SessionRepositoryError", {
   message: Schema27.String
 }) {
@@ -4458,11 +4711,11 @@ var toEntryRecord = (row) => {
       return Effect17.fail(new SessionRepositoryError({ message: `Unknown session entry tag: ${row.tag}` }));
   }
 };
-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 toRepositoryError10 = (error) => error instanceof SessionRepositoryError ? error : new SessionRepositoryError({ message: String(error) });
+var mapRepositoryError = (effect) => effect.pipe(Effect17.mapError(toRepositoryError10));
+var decodeSessionRow = (row) => Schema27.decodeUnknownEffect(SessionRow)(row).pipe(Effect17.mapError(toRepositoryError10));
+var decodeEntryRow = (row) => Schema27.decodeUnknownEffect(SessionEntryRow)(row).pipe(Effect17.mapError(toRepositoryError10));
+var decodeCountRow = (row) => Schema27.decodeUnknownEffect(CountRow)(row).pipe(Effect17.mapError(toRepositoryError10));
 var maxListLimit3 = 100;
 var defaultListLimit2 = 50;
 var listLimit3 = (input) => Math.min(Math.max(input.limit ?? defaultListLimit2, 1), maxListLimit3);
@@ -4512,39 +4765,39 @@ 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 sql9 = yield* SqlClient10.SqlClient;
-  const selectSessionByKey = (tenantId2, id2) => sql9`
+  const sql7 = yield* SqlClient23.SqlClient;
+  const selectSessionByKey = (tenantId2, id2) => sql7`
       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`
+  const selectEntryByKey = (tenantId2, sessionId, id2) => sql7`
       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`
+  const insertSession = (tenantId2, input) => sql7`
       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)})
+      VALUES (${tenantId2}, ${input.id}, ${input.rootAddressId}, ${encodeJson(metadata7(input.metadata))}, ${timestampParam(sql7, input.timestamp)}, ${timestampParam(sql7, input.timestamp)})
     `;
-  const touchSession = (tenantId2, id2, updatedAt) => sql9`
+  const touchSession = (tenantId2, id2, updatedAt) => sql7`
       UPDATE relay_sessions
-      SET updated_at = ${timestampParam(sql9, updatedAt)}
+      SET updated_at = ${timestampParam(sql7, updatedAt)}
       WHERE tenant_id = ${tenantId2} AND id = ${id2}
     `;
-  const updateLeaf = (tenantId2, input) => sql9`
+  const updateLeaf = (tenantId2, input) => sql7`
       UPDATE relay_sessions
-      SET leaf_entry_id = ${input.id}, updated_at = ${timestampParam(sql9, input.updatedAt)}
+      SET leaf_entry_id = ${input.id}, updated_at = ${timestampParam(sql7, input.updatedAt)}
       WHERE tenant_id = ${tenantId2} AND id = ${input.sessionId}
     `;
-  const insertEntryIfAbsent = sql9.onDialectOrElse({
-    mysql: () => (tenantId2, input) => sql9`
+  const insertEntryIfAbsent = sql7.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql7`
         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)})
+        VALUES (${tenantId2}, ${input.id}, ${input.sessionId}, ${input.parentId}, ${input.input._tag}, ${encodeJson(payloadFromInput(input.input))}, ${timestampParam(sql7, input.createdAt)})
       `,
-    orElse: () => (tenantId2, input) => sql9`
+    orElse: () => (tenantId2, input) => sql7`
         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)})
+        VALUES (${tenantId2}, ${input.id}, ${input.sessionId}, ${input.parentId}, ${input.input._tag}, ${encodeJson(payloadFromInput(input.input))}, ${timestampParam(sql7, input.createdAt)})
         ON CONFLICT (tenant_id, id) DO NOTHING
       `
   });
@@ -4630,23 +4883,23 @@ 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 conditions = [sql9`tenant_id = ${tenantId2}`];
+    const conditions = [sql7`tenant_id = ${tenantId2}`];
     if (input.rootAddressId !== undefined) {
-      conditions.push(sql9`root_address_id = ${input.rootAddressId}`);
+      conditions.push(sql7`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 cursorTimestamp = timestampParam(sql7, input.cursor.updatedAt);
+      conditions.push(sql7.or([
+        sql7`updated_at < ${cursorTimestamp}`,
+        sql7.and([sql7`updated_at = ${cursorTimestamp}`, sql7`id < ${input.cursor.id}`])
       ]));
     }
-    const rows = yield* mapRepositoryError(sql9`
+    const rows = yield* mapRepositoryError(sql7`
         SELECT id, root_address_id, leaf_entry_id, metadata_json, created_at, updated_at
         FROM relay_sessions
-        WHERE ${sql9.and(conditions)}
+        WHERE ${sql7.and(conditions)}
         ORDER BY updated_at DESC, id DESC
-        LIMIT ${sql9.literal(String(limit + 1))}
+        LIMIT ${sql7.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);
@@ -4693,7 +4946,7 @@ 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* mapRepositoryError(sql9.withTransaction(Effect17.gen(function* () {
+    return yield* mapRepositoryError(sql7.withTransaction(Effect17.gen(function* () {
       yield* insertEntryIfAbsent(tenantId2, input);
       const entryRows = yield* selectEntryByKey(tenantId2, input.sessionId, input.id);
       const entryRow = entryRows[0];
@@ -4712,7 +4965,7 @@ var layer17 = Layer17.effect(Service17, Effect17.gen(function* () {
   });
   const countEntries = Effect17.fn("SessionRepository.countEntries")(function* (sessionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapRepositoryError(sql9`
+    const rows = yield* mapRepositoryError(sql7`
         SELECT COUNT(*) AS value
         FROM relay_session_entries
         WHERE tenant_id = ${tenantId2} AND session_id = ${sessionId}
@@ -4908,7 +5161,7 @@ __export(exports_skill_definition_repository, {
   SkillDefinitionRepositoryError: () => SkillDefinitionRepositoryError,
   Service: () => Service18
 });
-import { asc as asc8, desc as desc3, eq as eq11, inArray as inArray2, sql as sql9 } from "drizzle-orm";
+import { asc as asc3, desc as desc2, eq as eq5, inArray as inArray2, sql as sql7 } 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
@@ -4971,10 +5224,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 mapDatabaseError10 = (effect) => effect.pipe(Effect18.mapError((error) => new SkillDefinitionRepositoryError({ message: String(error) })));
+var mapDatabaseError4 = (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) => mapDatabaseError10(db.execute(sql9`select pg_advisory_xact_lock(hashtext(${skillPinLockKey(tenantId2, executionId)}))`)).pipe(Effect18.asVoid);
+var lockExecutionPins = (db, tenantId2, executionId) => mapDatabaseError4(db.execute(sql7`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) {
@@ -4992,7 +5245,7 @@ var layer18 = Layer18.effect(Service18, Effect18.gen(function* () {
         target: [relaySkillDefinitions.tenantId, relaySkillDefinitions.id],
         set: {
           name: input.definition.frontmatter.name,
-          currentRevision: sql9`${relaySkillDefinitions.currentRevision} + 1`,
+          currentRevision: sql7`${relaySkillDefinitions.currentRevision} + 1`,
           definitionJson: input.definition,
           updatedAt: toPgDate(input.now)
         }
@@ -5017,32 +5270,32 @@ var layer18 = Layer18.effect(Service18, Effect18.gen(function* () {
   });
   const get9 = Effect18.fn("SkillDefinitionRepository.get")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError10(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId, eq11(relaySkillDefinitions.id, id2))).limit(1));
+    const rows = yield* mapDatabaseError4(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId, eq5(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* mapDatabaseError10(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq11(relaySkillDefinitionRevisions.skillDefinitionId, input.id), eq11(relaySkillDefinitionRevisions.revision, input.revision))).limit(1));
+    const rows = yield* mapDatabaseError4(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq5(relaySkillDefinitionRevisions.skillDefinitionId, input.id), eq5(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* mapDatabaseError10(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId)).orderBy(desc3(relaySkillDefinitions.createdAt), asc8(relaySkillDefinitions.id)));
+    const rows = yield* mapDatabaseError4(db.select().from(relaySkillDefinitions).where(predicate(tenantId2, relaySkillDefinitions.tenantId)).orderBy(desc2(relaySkillDefinitions.createdAt), asc3(relaySkillDefinitions.id)));
     return rows.map(toRecord11);
   });
   const listRevisions2 = Effect18.fn("SkillDefinitionRepository.listRevisions")(function* (id2) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError10(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq11(relaySkillDefinitionRevisions.skillDefinitionId, id2))).orderBy(desc3(relaySkillDefinitionRevisions.revision)));
+    const rows = yield* mapDatabaseError4(db.select().from(relaySkillDefinitionRevisions).where(predicate(tenantId2, relaySkillDefinitionRevisions.tenantId, eq5(relaySkillDefinitionRevisions.skillDefinitionId, id2))).orderBy(desc2(relaySkillDefinitionRevisions.revision)));
     return rows.map(toRevisionRecord2);
   });
   const listPins = Effect18.fn("SkillDefinitionRepository.listPins")(function* (executionId) {
     const tenantId2 = yield* current;
-    const rows = yield* mapDatabaseError10(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq11(relayExecutionSkillPins.executionId, executionId))).orderBy(asc8(relayExecutionSkillPins.skillDefinitionId)));
+    const rows = yield* mapDatabaseError4(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq5(relayExecutionSkillPins.executionId, executionId))).orderBy(asc3(relayExecutionSkillPins.skillDefinitionId)));
     return rows.map(toPinRecord);
   });
   const getPinned = Effect18.fn("SkillDefinitionRepository.getPinned")(function* (input) {
     const tenantId2 = yield* current;
-    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));
+    const rows = yield* mapDatabaseError4(db.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq5(relayExecutionSkillPins.executionId, input.executionId), eq5(relayExecutionSkillPins.skillDefinitionId, input.skillDefinitionId))).limit(1));
     return rows[0] === undefined ? undefined : toPinRecord(rows[0]);
   });
   const pinExecution = Effect18.fn("SkillDefinitionRepository.pinExecution")(function* (input) {
@@ -5052,7 +5305,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, eq11(relayExecutionSkillPins.executionId, input.executionId))).orderBy(asc8(relayExecutionSkillPins.skillDefinitionId));
+      const existingRows = yield* tx.select().from(relayExecutionSkillPins).where(predicate(tenantId2, relayExecutionSkillPins.tenantId, eq5(relayExecutionSkillPins.executionId, input.executionId))).orderBy(asc3(relayExecutionSkillPins.skillDefinitionId));
       if (existingRows.length > 0) {
         const existing = existingRows.map(toPinRecord);
         if (!sameIdSet(existing.map((record2) => record2.skillDefinitionId), requestedIds)) {
@@ -5214,7 +5467,7 @@ __export(exports_steering_repository, {
   Service: () => Service19
 });
 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";
+import * as SqlClient25 from "effect/unstable/sql/SqlClient";
 class SteeringRepositoryError extends Schema29.TaggedErrorClass()("SteeringRepositoryError", {
   message: Schema29.String
 }) {
@@ -5240,10 +5493,10 @@ var SteeringDrainRow = Schema29.Struct({
   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 toRepositoryError11 = (error) => new SteeringRepositoryError({ message: String(error) });
+var mapTransactionError = (effect) => effect.pipe(Effect19.mapError((error) => error instanceof SteeringRepositoryError ? error : toRepositoryError11(error)));
+var decodeMessageRow = (row) => Schema29.decodeUnknownEffect(SteeringMessageRow)(row).pipe(Effect19.mapError(toRepositoryError11));
+var decodeDrainRow = (row) => Schema29.decodeUnknownEffect(SteeringDrainRow)(row).pipe(Effect19.mapError(toRepositoryError11));
 var toMessageRecord = (row) => {
   const consumedAt = fromNullableDbTimestamp(row.consumed_at);
   return {
@@ -5281,21 +5534,21 @@ var consumedMessage = (message, input) => ({
   createdAt: message.createdAt
 });
 var layer19 = Layer19.effect(Service19, Effect19.gen(function* () {
-  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),
+  const sql8 = yield* SqlClient25.SqlClient;
+  const lockQueue = sql8.onDialectOrElse({
+    pg: () => (tenantId2, executionId, kind) => sql8`SELECT pg_advisory_xact_lock(hashtext(${queueKey(tenantId2, executionId, kind)}))`.pipe(Effect19.asVoid),
     orElse: () => () => Effect19.void
   });
-  const selectMessagesBySequences = (tenantId2, executionId, kind, sequences) => sql10`
+  const selectMessagesBySequences = (tenantId2, executionId, kind, sequences) => sql8`
       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)}
+        AND ${sql8.in("sequence", sequences)}
       ORDER BY sequence ASC
     `;
-  const selectDrain = (tenantId2, input) => sql10`
+  const selectDrain = (tenantId2, input) => sql8`
       SELECT execution_id, kind, drain_id, message_sequences_json, created_at
       FROM relay_steering_drains
       WHERE tenant_id = ${tenantId2}
@@ -5304,7 +5557,7 @@ var layer19 = Layer19.effect(Service19, Effect19.gen(function* () {
         AND drain_id = ${input.drainId}
     `;
   const findDrain = Effect19.fn("SteeringRepository.findDrain")(function* (tenantId2, input) {
-    const rows = yield* selectDrain(tenantId2, input).pipe(Effect19.mapError(toRepositoryError5));
+    const rows = yield* selectDrain(tenantId2, input).pipe(Effect19.mapError(toRepositoryError11));
     return rows[0] === undefined ? undefined : toDrainRecord(yield* decodeDrainRow(rows[0]));
   });
   const messagesForDrain = Effect19.fn("SteeringRepository.messagesForDrain")(function* (tenantId2, drain) {
@@ -5312,46 +5565,46 @@ var layer19 = Layer19.effect(Service19, Effect19.gen(function* () {
       return { drain, messages: [] };
     const rows = yield* selectMessagesBySequences(tenantId2, drain.executionId, drain.kind, [
       ...drain.messageSequences
-    ]).pipe(Effect19.mapError(toRepositoryError5));
+    ]).pipe(Effect19.mapError(toRepositoryError11));
     const messages = yield* Effect19.forEach(rows, (row) => decodeMessageRow(row).pipe(Effect19.map(toMessageRecord)));
     return { drain, messages };
   });
-  const insertMessage = sql10.onDialectOrElse({
+  const insertMessage = sql8.onDialectOrElse({
     mysql: () => (tenantId2, input, sequence) => Effect19.gen(function* () {
-      yield* sql10`
+      yield* sql8`
             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)})
+            VALUES (${tenantId2}, ${input.executionId}, ${input.kind}, ${sequence}, ${encodeJson(input.content)}, ${timestampParam(sql8, input.createdAt)})
           `;
       return yield* selectMessagesBySequences(tenantId2, input.executionId, input.kind, [sequence]);
     }),
-    orElse: () => (tenantId2, input, sequence) => sql10`
+    orElse: () => (tenantId2, input, sequence) => sql8`
         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)})
+        VALUES (${tenantId2}, ${input.executionId}, ${input.kind}, ${sequence}, ${encodeJson(input.content)}, ${timestampParam(sql8, input.createdAt)})
         RETURNING execution_id, kind, sequence, content_json, drain_id, consumed_at, created_at
       `
   });
-  const insertDrain = sql10.onDialectOrElse({
+  const insertDrain = sql8.onDialectOrElse({
     mysql: () => (tenantId2, input, sequences) => Effect19.gen(function* () {
-      yield* sql10`
+      yield* sql8`
             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)})
+            VALUES (${tenantId2}, ${input.executionId}, ${input.kind}, ${input.drainId}, ${encodeJson(sequences)}, ${timestampParam(sql8, input.createdAt)})
           `;
       return yield* selectDrain(tenantId2, input);
     }),
-    orElse: () => (tenantId2, input, sequences) => sql10`
+    orElse: () => (tenantId2, input, sequences) => sql8`
         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)})
+        VALUES (${tenantId2}, ${input.executionId}, ${input.kind}, ${input.drainId}, ${encodeJson(sequences)}, ${timestampParam(sql8, input.createdAt)})
         RETURNING execution_id, kind, drain_id, message_sequences_json, created_at
       `
   });
-  const selectExecutionStatus = sql10.onDialectOrElse({
-    sqlite: () => (tenantId2, executionId) => sql10`
+  const selectExecutionStatus = sql8.onDialectOrElse({
+    sqlite: () => (tenantId2, executionId) => sql8`
         SELECT status
         FROM relay_executions
         WHERE tenant_id = ${tenantId2} AND id = ${executionId}
         LIMIT 1
       `,
-    orElse: () => (tenantId2, executionId) => sql10`
+    orElse: () => (tenantId2, executionId) => sql8`
         SELECT status
         FROM relay_executions
         WHERE tenant_id = ${tenantId2} AND id = ${executionId}
@@ -5361,7 +5614,7 @@ var layer19 = Layer19.effect(Service19, Effect19.gen(function* () {
   });
   const appendInTransaction = Effect19.fn("SteeringRepository.appendInTransaction")(function* (tenantId2, input) {
     yield* lockQueue(tenantId2, input.executionId, input.kind);
-    const sequenceRows = yield* sql10`
+    const sequenceRows = yield* sql8`
         SELECT COALESCE(MAX(sequence), -1) + 1 AS next_sequence
         FROM relay_steering_messages
         WHERE tenant_id = ${tenantId2}
@@ -5378,11 +5631,11 @@ var layer19 = Layer19.effect(Service19, Effect19.gen(function* () {
   });
   const append2 = Effect19.fn("SteeringRepository.append")(function* (input) {
     const tenantId2 = yield* current;
-    return yield* sql10.withTransaction(appendInTransaction(tenantId2, input)).pipe(mapTransactionError);
+    return yield* sql8.withTransaction(appendInTransaction(tenantId2, input)).pipe(mapTransactionError);
   });
   const appendForRunning = Effect19.fn("SteeringRepository.appendForRunning")(function* (input) {
     const tenantId2 = yield* current;
-    return yield* sql10.withTransaction(Effect19.gen(function* () {
+    return yield* sql8.withTransaction(Effect19.gen(function* () {
       const statusRows = yield* selectExecutionStatus(tenantId2, input.executionId);
       const status = statusRows[0]?.status;
       if (status === undefined) {
@@ -5399,12 +5652,12 @@ var layer19 = Layer19.effect(Service19, Effect19.gen(function* () {
     const existing = yield* findDrain(tenantId2, input);
     if (existing !== undefined)
       return yield* messagesForDrain(tenantId2, existing);
-    return yield* sql10.withTransaction(Effect19.gen(function* () {
+    return yield* sql8.withTransaction(Effect19.gen(function* () {
       yield* lockQueue(tenantId2, input.executionId, input.kind);
       const existingAfterLock = yield* findDrain(tenantId2, input);
       if (existingAfterLock !== undefined)
         return yield* messagesForDrain(tenantId2, existingAfterLock);
-      const unconsumedRows = yield* sql10`
+      const unconsumedRows = yield* sql8`
               SELECT execution_id, kind, sequence, content_json, drain_id, consumed_at, created_at
               FROM relay_steering_messages
               WHERE tenant_id = ${tenantId2}
@@ -5412,18 +5665,18 @@ var layer19 = Layer19.effect(Service19, Effect19.gen(function* () {
                 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("")}
+              ${input.mode === "one-at-a-time" ? sql8.literal("LIMIT 1") : sql8.literal("")}
             `;
       const unconsumed = yield* Effect19.forEach(unconsumedRows, decodeMessageRow);
       const sequences = unconsumed.map((row) => Number(row.sequence));
       if (sequences.length > 0) {
-        yield* sql10`
+        yield* sql8`
                 UPDATE relay_steering_messages
-                SET drain_id = ${input.drainId}, consumed_at = ${timestampParam(sql10, input.consumedAt)}
+                SET drain_id = ${input.drainId}, consumed_at = ${timestampParam(sql8, input.consumedAt)}
                 WHERE tenant_id = ${tenantId2}
                   AND execution_id = ${input.executionId}
                   AND kind = ${input.kind}
-                  AND ${sql10.in("sequence", sequences)}
+                  AND ${sql8.in("sequence", sequences)}
               `;
       }
       const messageRows = sequences.length === 0 ? [] : yield* selectMessagesBySequences(tenantId2, input.executionId, input.kind, sequences);
@@ -5529,14 +5782,16 @@ __export(exports_tool_call_repository, {
   layer: () => layer20,
   getResult: () => getResult,
   getCall: () => getCall,
+  ToolResultRow: () => ToolResultRow,
+  ToolCallRow: () => ToolCallRow,
   ToolCallRepositoryError: () => ToolCallRepositoryError,
   ToolCallNotFound: () => ToolCallNotFound,
   Service: () => Service20,
   DuplicateToolResult: () => DuplicateToolResult,
   DuplicateToolCall: () => DuplicateToolCall
 });
-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";
+import * as SqlClient27 from "effect/unstable/sql/SqlClient";
 class ToolCallRepositoryError extends Schema30.TaggedErrorClass()("ToolCallRepositoryError", {
   message: Schema30.String
 }) {
@@ -5559,88 +5814,153 @@ class DuplicateToolResult extends Schema30.TaggedErrorClass()("DuplicateToolResu
 
 class Service20 extends Context20.Service()("@relayfx/store-sql/ToolCallRepository") {
 }
+var ToolCallRow = Schema30.Struct({
+  id: Schema30.String,
+  execution_id: Schema30.String,
+  name: Schema30.String,
+  input_json: Schema30.Unknown,
+  metadata_json: Schema30.Unknown,
+  created_at: Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number])
+}).annotate({ identifier: "Relay.ToolCall.Row" });
+var ToolResultRow = Schema30.Struct({
+  tool_call_id: Schema30.String,
+  output_json: Schema30.Unknown,
+  error: Schema30.NullishOr(Schema30.String),
+  metadata_json: Schema30.Unknown,
+  created_at: Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number])
+}).annotate({ identifier: "Relay.ToolResult.Row" });
 var metadata8 = (input) => input ?? {};
-var toCallInsert = (tenantId2, input) => ({
-  tenantId: tenantId2,
-  id: input.call.id,
-  executionId: input.executionId,
-  name: input.call.name,
-  inputJson: input.call.input,
-  metadataJson: metadata8(input.call.metadata),
-  createdAt: toPgDate(input.createdAt)
-});
 var toCallRecord = (row) => ({
-  executionId: row.executionId,
+  executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
   call: {
-    id: row.id,
+    id: exports_ids_schema.ToolCallId.make(row.id),
     name: row.name,
-    input: row.inputJson,
-    metadata: row.metadataJson
+    input: decodeJson(row.input_json),
+    metadata: decodeJson(row.metadata_json)
   },
-  createdAt: fromPgDate(row.createdAt)
-});
-var toResultInsert = (tenantId2, input) => ({
-  tenantId: tenantId2,
-  toolCallId: input.result.call_id,
-  outputJson: input.result.output,
-  metadataJson: metadata8(input.result.metadata),
-  createdAt: toPgDate(input.createdAt),
-  ...input.result.error === undefined ? {} : { error: input.result.error }
+  createdAt: fromDbTimestamp(row.created_at)
 });
 var toResultRecord = (row) => ({
   result: {
-    call_id: row.toolCallId,
-    output: row.outputJson,
-    ...row.error === null ? {} : { error: row.error },
-    metadata: row.metadataJson
+    call_id: exports_ids_schema.ToolCallId.make(row.tool_call_id),
+    output: decodeJson(row.output_json),
+    ...row.error === null || row.error === undefined ? {} : { error: row.error },
+    metadata: decodeJson(row.metadata_json)
   },
-  createdAt: fromPgDate(row.createdAt)
+  createdAt: fromDbTimestamp(row.created_at)
 });
-var mapDatabaseError11 = (effect) => effect.pipe(Effect20.mapError((error) => new ToolCallRepositoryError({ message: String(error) })));
+var toRepositoryError12 = (error) => new ToolCallRepositoryError({ message: String(error) });
+var decodeCallRow = (row) => Schema30.decodeUnknownEffect(ToolCallRow)(row).pipe(Effect20.mapError(toRepositoryError12));
+var decodeResultRow = (row) => Schema30.decodeUnknownEffect(ToolResultRow)(row).pipe(Effect20.mapError(toRepositoryError12));
 var layer20 = Layer20.effect(Service20, Effect20.gen(function* () {
-  const db = yield* Service;
+  const sql8 = yield* SqlClient27.SqlClient;
+  const callColumns = sql8.literal(["id", "execution_id", "name", "input_json", "metadata_json", "created_at"].join(", "));
+  const resultColumns = sql8.literal(["tool_call_id", "output_json", "error", "metadata_json", "created_at"].join(", "));
+  const selectCallByKey = (tenantId2, id2) => sql8`
+      SELECT ${callColumns}
+      FROM relay_tool_calls
+      WHERE tenant_id = ${tenantId2} AND id = ${id2}
+    `;
+  const selectResultByKey = (tenantId2, callId) => sql8`
+      SELECT ${resultColumns}
+      FROM relay_tool_results
+      WHERE tenant_id = ${tenantId2} AND tool_call_id = ${callId}
+    `;
+  const insertCallStatement = (tenantId2, input) => sql8`
+      INSERT INTO relay_tool_calls (
+        tenant_id, ${callColumns}
+      )
+      VALUES (
+        ${tenantId2},
+        ${input.call.id},
+        ${input.executionId},
+        ${input.call.name},
+        ${encodeJson(input.call.input)},
+        ${encodeJson(metadata8(input.call.metadata))},
+        ${timestampParam(sql8, input.createdAt)}
+      )
+    `;
+  const insertCall = sql8.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql8.withTransaction(Effect20.gen(function* () {
+      yield* insertCallStatement(tenantId2, input);
+      return yield* selectCallByKey(tenantId2, input.call.id);
+    })),
+    orElse: () => (tenantId2, input) => sql8`
+        ${insertCallStatement(tenantId2, input)}
+        RETURNING ${callColumns}
+      `
+  });
+  const insertResultStatement = (tenantId2, input) => sql8`
+      INSERT INTO relay_tool_results (
+        tenant_id, ${resultColumns}
+      )
+      VALUES (
+        ${tenantId2},
+        ${input.result.call_id},
+        ${encodeJson(input.result.output)},
+        ${input.result.error ?? null},
+        ${encodeJson(metadata8(input.result.metadata))},
+        ${timestampParam(sql8, input.createdAt)}
+      )
+    `;
+  const insertResult = sql8.onDialectOrElse({
+    mysql: () => (tenantId2, input) => sql8.withTransaction(Effect20.gen(function* () {
+      yield* insertResultStatement(tenantId2, input);
+      return yield* selectResultByKey(tenantId2, input.result.call_id);
+    })),
+    orElse: () => (tenantId2, input) => sql8`
+        ${insertResultStatement(tenantId2, input)}
+        RETURNING ${resultColumns}
+      `
+  });
   const recordCall = Effect20.fn("ToolCallRepository.recordCall")(function* (input) {
     const tenantId2 = yield* current;
-    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)
+    const existing = yield* selectCallByKey(tenantId2, input.call.id).pipe(Effect20.mapError(toRepositoryError12));
+    if (existing[0] !== undefined)
       return yield* Effect20.fail(new DuplicateToolCall({ id: input.call.id }));
-    const rows = yield* mapDatabaseError11(db.insert(relayToolCalls).values(toCallInsert(tenantId2, input)).returning());
+    const rows = yield* insertCall(tenantId2, input).pipe(Effect20.mapError(toRepositoryError12));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect20.fail(new ToolCallRepositoryError({ message: "Tool call insert returned no row" }));
     }
-    return toCallRecord(row);
+    return toCallRecord(yield* decodeCallRow(row));
   });
   const getCall = Effect20.fn("ToolCallRepository.getCall")(function* (id2) {
     const tenantId2 = yield* current;
-    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 rows = yield* selectCallByKey(tenantId2, id2).pipe(Effect20.mapError(toRepositoryError12));
+    return rows[0] === undefined ? undefined : toCallRecord(yield* decodeCallRow(rows[0]));
   });
   const listCalls = Effect20.fn("ToolCallRepository.listCalls")(function* (executionId) {
     const tenantId2 = yield* current;
-    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 rows = yield* sql8`
+        SELECT ${callColumns}
+        FROM relay_tool_calls
+        WHERE tenant_id = ${tenantId2} AND execution_id = ${executionId}
+        ORDER BY created_at ASC
+      `.pipe(Effect20.mapError(toRepositoryError12));
+    const decoded = yield* Effect20.forEach(rows, decodeCallRow);
+    return decoded.map(toCallRecord);
   });
   const recordResult = Effect20.fn("ToolCallRepository.recordResult")(function* (input) {
     const tenantId2 = yield* current;
-    const callRows = yield* mapDatabaseError11(db.select().from(relayToolCalls).where(predicate(tenantId2, relayToolCalls.tenantId, eq12(relayToolCalls.id, input.result.call_id))).limit(1));
+    const callRows = yield* selectCallByKey(tenantId2, input.result.call_id).pipe(Effect20.mapError(toRepositoryError12));
     if (callRows[0] === undefined)
       return yield* Effect20.fail(new ToolCallNotFound({ id: input.result.call_id }));
-    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) {
+    const existing = yield* selectResultByKey(tenantId2, input.result.call_id).pipe(Effect20.mapError(toRepositoryError12));
+    if (existing[0] !== undefined) {
       return yield* Effect20.fail(new DuplicateToolResult({ call_id: input.result.call_id }));
     }
-    const rows = yield* mapDatabaseError11(db.insert(relayToolResults).values(toResultInsert(tenantId2, input)).returning());
+    const rows = yield* insertResult(tenantId2, input).pipe(Effect20.mapError(toRepositoryError12));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect20.fail(new ToolCallRepositoryError({ message: "Tool result insert returned no row" }));
     }
-    return toResultRecord(row);
+    return toResultRecord(yield* decodeResultRow(row));
   });
   const getResult = Effect20.fn("ToolCallRepository.getResult")(function* (callId) {
     const tenantId2 = yield* current;
-    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]);
+    const rows = yield* selectResultByKey(tenantId2, callId).pipe(Effect20.mapError(toRepositoryError12));
+    return rows[0] === undefined ? undefined : toResultRecord(yield* decodeResultRow(rows[0]));
   });
   return Service20.of({ recordCall, getCall, listCalls, recordResult, getResult });
 }));
@@ -5720,7 +6040,7 @@ __export(exports_workspace_lease_repository, {
   Service: () => Service21,
   DuplicateWorkspaceLease: () => DuplicateWorkspaceLease
 });
-import { eq as eq13, notInArray } from "drizzle-orm";
+import { eq as eq6, 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
@@ -5790,8 +6110,8 @@ var toSnapshotRecord = (row) => ({
   metadata: row.metadataJson,
   created_at: fromPgDate(row.createdAt)
 });
-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) => {
+var mapDatabaseError5 = (effect) => effect.pipe(Effect21.mapError((error) => new WorkspaceLeaseRepositoryError({ message: String(error) })));
+var updateLease = (db, tenantId2, executionId, values) => mapDatabaseError5(db.update(relayWorkspaceLeases).set(values).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq6(relayWorkspaceLeases.executionId, executionId))).returning()).pipe(Effect21.flatMap((rows) => {
   const row = rows[0];
   if (row === undefined)
     return Effect21.fail(new WorkspaceLeaseNotFound({ execution_id: executionId }));
@@ -5801,16 +6121,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* mapDatabaseError12(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq13(relayWorkspaceLeases.executionId, id2))).limit(1));
+    const rows = yield* mapDatabaseError5(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq6(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* mapDatabaseError12(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq13(relayWorkspaceLeases.executionId, input.executionId), notInArray(relayWorkspaceLeases.status, [...terminalStatuses]))).limit(1));
+    const existing = yield* mapDatabaseError5(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq6(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* mapDatabaseError12(db.insert(relayWorkspaceLeases).values(toPlanInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError5(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" }));
@@ -5842,11 +6162,11 @@ var layer21 = Layer21.effect(Service21, Effect21.gen(function* () {
   });
   const recordSnapshot = Effect21.fn("WorkspaceLeaseRepository.recordSnapshot")(function* (input) {
     const tenantId2 = yield* current;
-    const leaseRows = yield* mapDatabaseError12(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq13(relayWorkspaceLeases.executionId, input.executionId))).limit(1));
+    const leaseRows = yield* mapDatabaseError5(db.select().from(relayWorkspaceLeases).where(predicate(tenantId2, relayWorkspaceLeases.tenantId, eq6(relayWorkspaceLeases.executionId, input.executionId))).limit(1));
     if (leaseRows[0] === undefined) {
       return yield* Effect21.fail(new WorkspaceLeaseNotFound({ execution_id: input.executionId }));
     }
-    const rows = yield* mapDatabaseError12(db.insert(relayWorkspaceSnapshots).values(toSnapshotInsert(tenantId2, input)).returning());
+    const rows = yield* mapDatabaseError5(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" }));
@@ -6253,7 +6573,7 @@ __export(exports_agent_registry_service, {
   AgentRegistryError: () => AgentRegistryError,
   AgentDefinitionInvalid: () => AgentDefinitionInvalid
 });
-import { Clock, Context as Context26, Crypto as Crypto2, Effect as Effect28, HashSet as HashSet4, Layer as Layer26, Option as Option7, Schema as Schema36 } from "effect";
+import { Clock as Clock2, Context as Context26, Crypto as Crypto2, Effect as Effect28, HashSet as HashSet4, Layer as Layer26, Option as Option7, Schema as Schema36 } from "effect";
 
 // ../runtime/src/tool/tool-input-schema-digest.ts
 import { Crypto, Effect as Effect24 } from "effect";
@@ -7210,7 +7530,7 @@ var layer24 = Layer26.effect(Service26, Effect28.gen(function* () {
   return Service26.of({
     register: Effect28.fn("AgentRegistry.register")(function* (input) {
       yield* validateDefinition(input.definition);
-      const now = yield* Clock.currentTimeMillis;
+      const now = yield* Clock2.currentTimeMillis;
       const toolDefinitions = Option7.isNone(toolRuntime) ? [] : yield* toolRuntime.value.definitions;
       const selectedToolNames = input.definition.tool_names.filter((toolName) => toolDefinitions.some((definition) => definition.name === toolName));
       const crypto = yield* Effect28.serviceOption(Crypto2.Crypto);
@@ -9498,7 +9818,7 @@ var transferTools = (config) => (config.agent.handoff_targets ?? []).map((target
 });
 
 // ../runtime/src/memory/memory-service.ts
-import { Clock as Clock2, Context as Context45, Effect as Effect53, Layer as Layer46, Schema as Schema52 } from "effect";
+import { Clock as Clock3, Context as Context45, Effect as Effect53, Layer as Layer46, Schema as Schema52 } from "effect";
 import * as Ai13 from "effect/unstable/ai";
 
 // ../runtime/src/model/embedding-model-service.ts
@@ -9734,7 +10054,7 @@ var make6 = (options = {}) => Effect53.gen(function* () {
       return;
     const subject = yield* decodeSubject(input.key.subject);
     const embedding = yield* embed(models, text3, options);
-    const createdAt = yield* Clock2.currentTimeMillis;
+    const createdAt = yield* Clock3.currentTimeMillis;
     yield* repository.upsert({
       id: memoryId(input, text3),
       agent: input.key.agent,
@@ -9901,7 +10221,7 @@ var resolve4 = Effect55.fn("SchemaRegistry.resolve.call")(function* (ref) {
 });
 
 // ../runtime/src/session/session-store-service.ts
-import { Clock as Clock3, Context as Context49, Effect as Effect56, Layer as Layer50, Ref as Ref15 } from "effect";
+import { Clock as Clock4, Context as Context49, Effect as Effect56, Layer as Layer50, Ref as Ref15 } from "effect";
 
 class Service36 extends Context49.Service()("@relayfx/runtime/RelaySessionStore") {
 }
@@ -9948,7 +10268,7 @@ var make8 = Effect56.fn("RelaySessionStore.make")(function* (sessionId, entrySco
   });
   const append4 = Effect56.fn("RelaySessionStore.append")(function* (input) {
     const current2 = yield* initialState2();
-    const now = yield* Clock3.currentTimeMillis;
+    const now = yield* Clock4.currentTimeMillis;
     const entry = yield* repository.appendEntry({
       id: exports_ids_schema.SessionEntryId.make(`${entryPrefix}${current2.next}`),
       sessionId,
@@ -9964,7 +10284,7 @@ var make8 = Effect56.fn("RelaySessionStore.make")(function* (sessionId, entrySco
     ...leaf2 === undefined ? {} : { leafId: entryId(leaf2) }
   }).pipe(Effect56.mapError(mapError)));
   const setLeaf2 = Effect56.fn("RelaySessionStore.setLeaf")(function* (id2) {
-    const now = yield* Clock3.currentTimeMillis;
+    const now = yield* Clock4.currentTimeMillis;
     return yield* repository.setLeaf({
       sessionId,
       id: id2 === null ? null : entryId(id2),
@@ -10236,7 +10556,7 @@ var assemble = Effect59.fn("PromptAssembler.assemble.call")(function* (input) {
 var layer39 = exports_approvals.autoApprove;
 
 // ../runtime/src/agent/relay-compaction.ts
-import { Clock as Clock4, Effect as Effect60, Layer as Layer54 } from "effect";
+import { Clock as Clock5, Effect as Effect60, Layer as Layer54 } from "effect";
 var checkpointId = (input) => `compaction:${input.executionId}:turn:${input.turn}:keep:${input.firstKeptEntryId}`;
 var mapRepositoryError7 = (error) => new exports_compaction.CompactionError({ message: error.message, cause: error });
 var sameCheckpointBoundary = (record2, input) => record2.firstKeptEntryId === input.firstKeptEntryId && record2.turn === input.turn;
@@ -10261,7 +10581,7 @@ var strategy = (config) => {
         if (existing !== undefined)
           return existing.summary;
         const summary = yield* base.summarize(plan2, request);
-        const createdAt = yield* Clock4.currentTimeMillis;
+        const createdAt = yield* Clock5.currentTimeMillis;
         const input = {
           executionId: config.executionId,
           checkpointId: id2,
@@ -10285,7 +10605,7 @@ var make9 = (config) => exports_compaction.make(strategy(config), defaultOptions
 var layerFromEpoch = (epoch) => exports_instructions.layer(epoch.baseline.length === 0 ? [] : [exports_instructions.staticSource("relay:context-epoch", epoch.baseline)]);
 
 // ../runtime/src/agent/relay-permissions.ts
-import { Clock as Clock5, Effect as Effect61, Equal as Equal2, Layer as Layer55, Option as Option19, Schema as Schema57 } from "effect";
+import { Clock as Clock6, Effect as Effect61, Equal as Equal2, Layer as Layer55, Option as Option19, Schema as Schema57 } from "effect";
 var jsonValue4 = (value) => Schema57.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
 var waitIdForToolCall = (toolCallId) => exports_ids_schema.WaitId.make(`wait:permission:${toolCallId}`);
 var fallbackToolCallId = (request) => `${request.agentName}:${request.turn}:${request.tool}`;
@@ -10451,7 +10771,7 @@ var awaitAnswer = Effect61.fn("RelayPermissions.awaitAnswer")(function* (config,
   return Option19.some(answer);
 });
 var rememberRule = Effect61.fn("RelayPermissions.rememberRule")(function* (config, rule) {
-  const createdAt = yield* Clock5.currentTimeMillis;
+  const createdAt = yield* Clock6.currentTimeMillis;
   const decodedRule = yield* Schema57.decodeUnknownEffect(exports_agent_schema.PermissionRule)(rule).pipe(Effect61.mapError((error) => permissionError(error.message)));
   yield* config.repository.remember({
     agent: config.agentName,
@@ -10468,7 +10788,7 @@ var layer40 = (config) => Layer55.mergeAll(Layer55.succeed(exports_permissions.P
 })));
 
 // ../runtime/src/agent/relay-steering.ts
-import { Clock as Clock6, Effect as Effect62, Layer as Layer56, Schema as Schema58 } from "effect";
+import { Clock as Clock7, Effect as Effect62, Layer as Layer56, Schema as Schema58 } from "effect";
 import * as Ai16 from "effect/unstable/ai";
 var jsonValue5 = (value) => Schema58.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var stringifyJson2 = (value) => JSON.stringify(jsonValue5(value));
@@ -10534,7 +10854,7 @@ var drain2 = Effect62.fn("RelaySteering.drain")(function* (config, kind, mode) {
   yield* appendIdempotentTo(config.eventLog, steeringReceivedEvent(config, kind, result.drain, result.messages, sequence));
   return result.messages.map((message) => ({ prompt: promptForContent(message.content) }));
 });
-var append4 = (config, kind, message) => Clock6.currentTimeMillis.pipe(Effect62.flatMap((createdAt) => config.repository.append({
+var append4 = (config, kind, message) => Clock7.currentTimeMillis.pipe(Effect62.flatMap((createdAt) => config.repository.append({
   executionId: config.executionId,
   kind,
   content: contentFromMessage(message),
@@ -11378,7 +11698,7 @@ __export(exports_skill_registry_service, {
   SkillDefinitionInvalid: () => SkillDefinitionInvalid,
   Service: () => Service42
 });
-import { Clock as Clock7, Context as Context55, Effect as Effect68, Layer as Layer61, Schema as Schema62 } from "effect";
+import { Clock as Clock8, Context as Context55, Effect as Effect68, Layer as Layer61, Schema as Schema62 } from "effect";
 
 class SkillDefinitionInvalid extends Schema62.TaggedErrorClass()("SkillDefinitionInvalid", {
   message: Schema62.String
@@ -11456,7 +11776,7 @@ var layer45 = Layer61.effect(Service42, Effect68.gen(function* () {
   return Service42.of({
     register: Effect68.fn("SkillRegistry.register")(function* (input) {
       yield* validateDefinition2(input.definition);
-      const now = yield* Clock7.currentTimeMillis;
+      const now = yield* Clock8.currentTimeMillis;
       const record2 = yield* repository.put({ id: input.id, definition: input.definition, now }).pipe(Effect68.mapError(mapRepositoryError8));
       return { record: toPublicRecord2(record2) };
     }),
@@ -11477,7 +11797,7 @@ var layer45 = Layer61.effect(Service42, Effect68.gen(function* () {
       return { records: records.map(toPublicRevisionRecord2) };
     }),
     pinExecution: Effect68.fn("SkillRegistry.pinExecution")(function* (input) {
-      const now = yield* Clock7.currentTimeMillis;
+      const now = yield* Clock8.currentTimeMillis;
       const records = yield* repository.pinExecution({
         executionId: input.execution_id,
         skillDefinitionIds: input.skill_definition_ids,
@@ -11555,7 +11875,7 @@ __export(exports_execution_service, {
   Service: () => Service43,
   ExecutionServiceError: () => ExecutionServiceError
 });
-import { Clock as Clock8, Context as Context56, Effect as Effect69, Layer as Layer62, Option as Option24, Schema as Schema63, Stream as Stream8 } from "effect";
+import { Clock as Clock9, Context as Context56, Effect as Effect69, Layer as Layer62, Option as Option24, Schema as Schema63, Stream as Stream8 } from "effect";
 import { ShardingConfig } from "effect/unstable/cluster";
 class ExecutionServiceError extends Schema63.TaggedErrorClass()("ExecutionServiceError", {
   message: Schema63.String,
@@ -11636,7 +11956,7 @@ var nextEventSequence2 = Effect69.fn("ExecutionService.nextEventSequence")(funct
 });
 var childRunBaseInput = Effect69.fn("ExecutionService.childRunBaseInput")(function* (eventLog, input) {
   const eventSequence = yield* nextEventSequence2(eventLog, input);
-  const createdAt = input.created_at ?? (yield* Clock8.currentTimeMillis);
+  const createdAt = input.created_at ?? (yield* Clock9.currentTimeMillis);
   return {
     childExecutionId: childExecutionId2(input),
     executionId: input.execution_id,
@@ -13154,7 +13474,7 @@ __export(exports_scheduler_service, {
   SchedulerError: () => SchedulerError,
   ScheduleCronInvalid: () => ScheduleCronInvalid
 });
-import { Clock as Clock9, Config as Config4, Context as Context60, Cron, Duration as Duration4, Effect as Effect75, Layer as Layer67, Random, Result as Result3, Schema as Schema69 } from "effect";
+import { Clock as Clock10, Config as Config4, Context as Context60, Cron, Duration as Duration4, Effect as Effect75, Layer as Layer67, Random, Result as Result3, Schema as Schema69 } from "effect";
 
 // ../runtime/src/wait/wait-signal.ts
 var exports_wait_signal = {};
@@ -13293,7 +13613,7 @@ var make14 = Effect75.gen(function* () {
   const runOnce = Effect75.gen(function* () {
     let dispatched = 0;
     while (true) {
-      const now = yield* Clock9.currentTimeMillis;
+      const now = yield* Clock10.currentTimeMillis;
       const claimed = yield* schedules.claimDue({ workerId, now, claimExpiresAt: now + claimTtlMillis }).pipe(Effect75.mapError(toSchedulerError));
       if (claimed === undefined)
         return dispatched;
@@ -13907,7 +14227,7 @@ var guard = Effect77.fn("ActivityVersionRegistry.guard")(function* (input) {
   }));
 });
 // src/client.ts
-import { Clock as Clock10, Context as Context62, Effect as Effect78, Layer as Layer69, Option as Option28, Schema as Schema72, SchemaGetter, SchemaIssue, Stream as Stream10 } from "effect";
+import { Clock as Clock11, Context as Context62, Effect as Effect78, Layer as Layer69, Option as Option28, Schema as Schema72, SchemaGetter, SchemaIssue, Stream as Stream10 } from "effect";
 import { EntityId, ShardId, Sharding as Sharding2, ShardingConfig as ShardingConfig3 } from "effect/unstable/cluster";
 
 class ClientError extends Schema72.TaggedErrorClass()("ClientError", {
@@ -14375,7 +14695,7 @@ var layerFromRuntime = Layer69.effect(Service49, Effect78.gen(function* () {
       const context = yield* exports_child_run_service.resolveForDispatch(input).pipe(Effect78.mapError((error) => new ClientError({ message: error._tag })));
       const pin = yield* parentDefinitionPin(executionRepository, input.execution_id);
       const definition = yield* exports_child_run_service.childDefinition(pin.agentDefinitionSnapshot, context).pipe(Effect78.mapError((error) => new ClientError({ message: error._tag })));
-      const createdAt = input.created_at ?? (yield* Clock10.currentTimeMillis);
+      const createdAt = input.created_at ?? (yield* Clock11.currentTimeMillis);
       const parentWaitId = input.wait === true ? yield* createChildJoinWait(waits, eventLog, input, accepted2, createdAt) : undefined;
       const startPayload = childStartInput(input, accepted2, pin, definition, createdAt, parentWaitId);
       const client2 = makeExecutionClient(startPayload.execution_id);
@@ -14418,7 +14738,7 @@ var layerFromRuntime = Layer69.effect(Service49, Effect78.gen(function* () {
       if (input.cron_expr !== undefined) {
         yield* exports_scheduler_service.parseCron(input.cron_expr).pipe(Effect78.mapError(toClientError));
       }
-      const createdAt = yield* Clock10.currentTimeMillis;
+      const createdAt = yield* Clock11.currentTimeMillis;
       const schedule = yield* schedules.create({
         id: input.schedule_id,
         kind: input.kind,