@relayfx/sdk 0.6.1 → 0.7.0

package/dist/{index-ftgf8py0.js → index-n5sqnw4s.js}

@@ -9,6 +9,7 @@ import {
   exports_model_middleware,
   exports_model_registry,
   exports_model_resilience,
+  exports_model_telemetry,
   exports_permissions,
   exports_session,
   exports_skill_source,
@@ -16,7 +17,7 @@ import {
   exports_tool_executor,
   exports_tool_output,
   exports_turn_policy
-} from "./index-5vjhqzbk.js";
+} from "./index-qa93yf6j.js";
 import {
   ClientError,
   EventLogCursorNotFound,
@@ -46,7 +47,7 @@ import {
   exports_workflow_schema,
   exports_workspace_schema,
   followExecutionFrom
-} from "./index-fh2ftte9.js";
+} from "./index-q7xzf506.js";
 import {
   __export
 } from "./index-nb39b5ae.js";
@@ -298,14 +299,20 @@ var contentToPromptPart = (part) => {
 var toAssemblerError = (error) => PromptAssemblerError.make({
   message: error.reason !== undefined ? `${error._tag}: ${error.reason}` : error.message !== undefined ? `${error._tag}: ${error.message}` : error._tag
 });
-var resolveBlobPart = (blobs, part) => blobs.resolve(part).pipe(Effect4.map((resolved) => [
-  Prompt.makePart("file", {
-    mediaType: resolved.mediaType,
-    data: resolved._tag === "Bytes" ? resolved.bytes : resolved.url,
-    ...resolved.fileName === undefined ? {} : { fileName: resolved.fileName },
-    ...part.provider_options === undefined ? {} : { options: part.provider_options }
-  })
-]), Effect4.mapError(toAssemblerError));
+var resolveBlobPart = (blobs, part) => blobs.resolve(part).pipe(Effect4.mapError(toAssemblerError), Effect4.flatMap((resolved) => Effect4.gen(function* () {
+  const data = resolved._tag === "Bytes" ? resolved.bytes : yield* Effect4.try({
+    try: () => new URL(resolved.url),
+    catch: () => PromptAssemblerError.make({ message: "BlobStore resolved an invalid URL" })
+  });
+  return [
+    Prompt.makePart("file", {
+      mediaType: resolved.mediaType,
+      data,
+      ...resolved.fileName === undefined ? {} : { fileName: resolved.fileName },
+      ...part.provider_options === undefined ? {} : { options: part.provider_options }
+    })
+  ];
+})));
 var resolveNestedPart = (blobs, part) => {
   switch (part.type) {
     case "blob-reference":
@@ -1031,27 +1038,91 @@ __export(exports_agent_chat_repository, {
   AgentChatRow: () => AgentChatRow,
   AgentChatRepositoryError: () => AgentChatRepositoryError
 });
-import { Context as Context13, Effect as Effect14, Layer as Layer13, Schema as Schema14 } from "effect";
+import { Context as Context13, Effect as Effect14, Layer as Layer13, Schema as Schema15 } from "effect";
+import { Prompt as Prompt3 } from "effect/unstable/ai";
 import { SqlClient as SqlClient3 } from "effect/unstable/sql/SqlClient";
-class AgentChatRepositoryError extends Schema14.TaggedErrorClass()("AgentChatRepositoryError", {
-  message: Schema14.String
+
+// ../store-sql/src/prompt-wire.ts
+import { Schema as Schema14 } from "effect";
+import { Prompt as Prompt2 } from "effect/unstable/ai";
+var Byte = Schema14.Int.check(Schema14.isBetween({ minimum: 0, maximum: 255 }));
+var FileDataWire = Schema14.Union([
+  Schema14.TaggedStruct("String", { value: Schema14.String }),
+  Schema14.TaggedStruct("Bytes", { value: Schema14.Array(Byte) }),
+  Schema14.TaggedStruct("Url", { value: Schema14.String })
+]);
+var fileDataToWire = (data) => typeof data === "string" ? { _tag: "String", value: data } : data instanceof Uint8Array ? { _tag: "Bytes", value: Array.from(data) } : { _tag: "Url", value: data.toString() };
+var encodeMessage = (prompt, message, messageIndex) => ({
+  ...message,
+  content: Array.isArray(message.content) ? message.content.map((part, partIndex) => {
+    const actualContent = prompt.content[messageIndex]?.content;
+    const actualPart = Array.isArray(actualContent) ? actualContent[partIndex] : undefined;
+    return part.type === "file" && actualPart?.type === "file" ? { ...part, data: fileDataToWire(actualPart.data) } : part;
+  }) : message.content
+});
+var encodePrompt = (prompt) => {
+  const encoded = Schema14.encodeSync(Prompt2.Prompt)(prompt);
+  return Schema14.decodeUnknownSync(exports_shared_schema.JsonValue)({
+    content: encoded.content.map((message, messageIndex) => encodeMessage(prompt, message, messageIndex))
+  });
+};
+var decodePrompt = (value) => {
+  const content = typeof value === "object" && value !== null && !Array.isArray(value) && "content" in value ? value.content : undefined;
+  const decodedContent = Array.isArray(content) ? content.map((message) => {
+    if (typeof message !== "object" || message === null || Array.isArray(message))
+      return message;
+    const messageContent = message.content;
+    return {
+      ...message,
+      content: Array.isArray(messageContent) ? messageContent.map((part) => {
+        if (typeof part !== "object" || part === null || Array.isArray(part) || part.type !== "file") {
+          return part;
+        }
+        const data = Schema14.decodeUnknownSync(FileDataWire)(part.data);
+        return {
+          ...part,
+          data: data._tag === "String" ? data.value : data._tag === "Bytes" ? Uint8Array.from(data.value) : new URL(data.value)
+        };
+      }) : messageContent
+    };
+  }) : content;
+  return Schema14.decodeUnknownSync(Prompt2.Prompt)({ content: decodedContent });
+};
+
+// ../store-sql/src/chat/agent-chat-repository.ts
+class AgentChatRepositoryError extends Schema15.TaggedErrorClass()("AgentChatRepositoryError", {
+  message: Schema15.String
 }) {
 }
 
 class Service15 extends Context13.Service()("@relayfx/store-sql/chat/agent-chat-repository/Service") {
 }
-var AgentChatRow = Schema14.Struct({
-  execution_id: Schema14.String,
-  export_json: Schema14.Unknown,
-  updated_at: Schema14.Union([Schema14.Date, Schema14.String, Schema14.Finite])
+var AgentChatRow = Schema15.Struct({
+  execution_id: Schema15.String,
+  export_json: Schema15.Unknown,
+  updated_at: Schema15.Union([Schema15.Date, Schema15.String, Schema15.Finite])
 }).annotate({ identifier: "Relay.AgentChat.Row" });
-var toRecord = (row) => ({
-  executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
-  exportData: decodeJson(row.export_json),
-  updatedAt: fromDbTimestamp(row.updated_at)
+var AgentChatExportWire = Schema15.TaggedStruct("RelayAgentChatExportV1", {
+  prompt: exports_shared_schema.JsonValue
 });
 var toRepositoryError2 = (error) => AgentChatRepositoryError.make({ message: String(error) });
-var decodeRow2 = (row) => Schema14.decodeUnknownEffect(AgentChatRow)(row).pipe(Effect14.mapError(toRepositoryError2));
+var encodeExport = (exportData) => {
+  const prompt = Schema15.decodeUnknownSync(Prompt3.Prompt)(exportData);
+  return Schema15.encodeSync(AgentChatExportWire)({ _tag: "RelayAgentChatExportV1", prompt: encodePrompt(prompt) });
+};
+var decodeExport = (value) => {
+  const wire = Schema15.decodeUnknownSync(AgentChatExportWire)(decodeJson(value));
+  return Schema15.encodeSync(Prompt3.Prompt)(decodePrompt(wire.prompt));
+};
+var toRecord = (row) => Effect14.try({
+  try: () => ({
+    executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
+    exportData: decodeExport(row.export_json),
+    updatedAt: fromDbTimestamp(row.updated_at)
+  }),
+  catch: toRepositoryError2
+});
+var decodeRow2 = (row) => Schema15.decodeUnknownEffect(AgentChatRow)(row).pipe(Effect14.mapError(toRepositoryError2));
 var layer9 = Layer13.effect(Service15, Effect14.gen(function* () {
   const sql = yield* SqlClient3;
   const selectByKey = (tenantId, executionId) => sql`
@@ -1060,19 +1131,19 @@ var layer9 = Layer13.effect(Service15, Effect14.gen(function* () {
       WHERE tenant_id = ${tenantId} AND execution_id = ${executionId}
     `;
   const upsert2 = sql.onDialectOrElse({
-    mysql: () => (tenantId, input) => sql.withTransaction(Effect14.gen(function* () {
+    mysql: () => (tenantId, input, exportData) => sql.withTransaction(Effect14.gen(function* () {
       yield* sql`
               INSERT INTO relay_agent_chats (tenant_id, execution_id, export_json, updated_at)
-              VALUES (${tenantId}, ${input.executionId}, ${encodeJson(input.exportData)}, ${timestampParam(sql, input.updatedAt)})
+              VALUES (${tenantId}, ${input.executionId}, ${encodeJson(exportData)}, ${timestampParam(sql, input.updatedAt)})
               ON DUPLICATE KEY UPDATE
                 export_json = VALUES(export_json),
                 updated_at = VALUES(updated_at)
             `;
       return yield* selectByKey(tenantId, input.executionId);
     })),
-    orElse: () => (tenantId, input) => sql`
+    orElse: () => (tenantId, input, exportData) => sql`
         INSERT INTO relay_agent_chats (tenant_id, execution_id, export_json, updated_at)
-        VALUES (${tenantId}, ${input.executionId}, ${encodeJson(input.exportData)}, ${timestampParam(sql, input.updatedAt)})
+        VALUES (${tenantId}, ${input.executionId}, ${encodeJson(exportData)}, ${timestampParam(sql, input.updatedAt)})
         ON CONFLICT (tenant_id, execution_id) DO UPDATE SET
           export_json = excluded.export_json,
           updated_at = excluded.updated_at
@@ -1081,34 +1152,43 @@ var layer9 = Layer13.effect(Service15, Effect14.gen(function* () {
   });
   const save = Effect14.fn("AgentChatRepository.save")(function* (input) {
     const tenantId = yield* current();
-    const rows = yield* upsert2(tenantId, input).pipe(Effect14.mapError(toRepositoryError2));
+    const exportData = yield* Effect14.try({ try: () => encodeExport(input.exportData), catch: toRepositoryError2 });
+    const rows = yield* upsert2(tenantId, input, exportData).pipe(Effect14.mapError(toRepositoryError2));
     const row = rows[0];
     if (row === undefined) {
       return yield* AgentChatRepositoryError.make({ message: "Agent chat upsert returned no row" });
     }
-    return toRecord(yield* decodeRow2(row));
+    return yield* toRecord(yield* decodeRow2(row));
   });
   const get = Effect14.fn("AgentChatRepository.get")(function* (executionId) {
     const tenantId = yield* current();
     const rows = yield* selectByKey(tenantId, executionId).pipe(Effect14.mapError(toRepositoryError2));
-    return rows[0] === undefined ? undefined : toRecord(yield* decodeRow2(rows[0]));
+    return rows[0] === undefined ? undefined : yield* toRecord(yield* decodeRow2(rows[0]));
   });
   return Service15.of({ save, get });
 }));
 var memoryLayer7 = Layer13.sync(Service15, () => {
   const chats = new Map;
+  const cloneExport = (exportData) => Effect14.try({
+    try: () => decodeExport(encodeExport(exportData)),
+    catch: toRepositoryError2
+  });
   return Service15.of({
     save: Effect14.fn("AgentChatRepository.memory.save")(function* (input) {
+      const exportData = yield* cloneExport(input.exportData);
       const record = {
         executionId: input.executionId,
-        exportData: input.exportData,
+        exportData,
         updatedAt: input.updatedAt
       };
       yield* Effect14.sync(() => chats.set(input.executionId, record));
-      return record;
+      return { ...record, exportData: yield* cloneExport(record.exportData) };
     }),
     get: Effect14.fn("AgentChatRepository.memory.get")(function* (executionId) {
-      return yield* Effect14.sync(() => chats.get(executionId));
+      const record = yield* Effect14.sync(() => chats.get(executionId));
+      if (record === undefined)
+        return;
+      return { ...record, exportData: yield* cloneExport(record.exportData) };
     })
   });
 });
@@ -1137,32 +1217,32 @@ __export(exports_agent_definition_repository, {
   AgentDefinitionRevisionRow: () => AgentDefinitionRevisionRow,
   AgentDefinitionRepositoryError: () => AgentDefinitionRepositoryError
 });
-import { Context as Context14, Effect as Effect15, Layer as Layer14, Schema as Schema15 } from "effect";
+import { Context as Context14, Effect as Effect15, Layer as Layer14, Schema as Schema16 } from "effect";
 import { SqlClient as SqlClient4 } from "effect/unstable/sql/SqlClient";
-class AgentDefinitionRepositoryError extends Schema15.TaggedErrorClass()("AgentDefinitionRepositoryError", {
-  message: Schema15.String
+class AgentDefinitionRepositoryError extends Schema16.TaggedErrorClass()("AgentDefinitionRepositoryError", {
+  message: Schema16.String
 }) {
 }
 
 class Service16 extends Context14.Service()("@relayfx/store-sql/agent/agent-definition-repository/Service") {
 }
-var AgentDefinitionRow = Schema15.Struct({
-  id: Schema15.String,
-  current_revision: Schema15.Finite,
-  definition_json: Schema15.Unknown,
-  tool_input_schema_digests_json: Schema15.Unknown,
-  created_at: Schema15.Union([Schema15.Date, Schema15.String, Schema15.Finite]),
-  updated_at: Schema15.Union([Schema15.Date, Schema15.String, Schema15.Finite])
+var AgentDefinitionRow = Schema16.Struct({
+  id: Schema16.String,
+  current_revision: Schema16.Finite,
+  definition_json: Schema16.Unknown,
+  tool_input_schema_digests_json: Schema16.Unknown,
+  created_at: Schema16.Union([Schema16.Date, Schema16.String, Schema16.Finite]),
+  updated_at: Schema16.Union([Schema16.Date, Schema16.String, Schema16.Finite])
 }).annotate({ identifier: "Relay.AgentDefinition.Row" });
-var AgentDefinitionRevisionRow = Schema15.Struct({
-  agent_id: Schema15.String,
-  revision: Schema15.Finite,
-  definition_json: Schema15.Unknown,
-  tool_input_schema_digests_json: Schema15.Unknown,
-  created_at: Schema15.Union([Schema15.Date, Schema15.String, Schema15.Finite])
+var AgentDefinitionRevisionRow = Schema16.Struct({
+  agent_id: Schema16.String,
+  revision: Schema16.Finite,
+  definition_json: Schema16.Unknown,
+  tool_input_schema_digests_json: Schema16.Unknown,
+  created_at: Schema16.Union([Schema16.Date, Schema16.String, Schema16.Finite])
 }).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 cloneDefinition = (definition) => Schema16.decodeUnknownSync(exports_agent_schema.Definition)(globalThis.structuredClone(definition));
 var rowDigests = (json) => nonEmptyDigests(decodeJson(json));
 var toRecord2 = (row) => {
   const toolInputSchemaDigests = rowDigests(row.tool_input_schema_digests_json);
@@ -1201,9 +1281,9 @@ var compareByCreatedAtDesc = (left, right) => {
   return createdAt === 0 ? left.id.localeCompare(right.id) : createdAt;
 };
 var toRepositoryError3 = (error) => AgentDefinitionRepositoryError.make({ message: String(error) });
-var mapPutError = (error) => Schema15.is(AgentDefinitionRepositoryError)(error) ? error : toRepositoryError3(error);
-var decodeRow3 = (row) => Schema15.decodeUnknownEffect(AgentDefinitionRow)(row).pipe(Effect15.mapError(toRepositoryError3));
-var decodeRevisionRow = (row) => Schema15.decodeUnknownEffect(AgentDefinitionRevisionRow)(row).pipe(Effect15.mapError(toRepositoryError3));
+var mapPutError = (error) => Schema16.is(AgentDefinitionRepositoryError)(error) ? error : toRepositoryError3(error);
+var decodeRow3 = (row) => Schema16.decodeUnknownEffect(AgentDefinitionRow)(row).pipe(Effect15.mapError(toRepositoryError3));
+var decodeRevisionRow = (row) => Schema16.decodeUnknownEffect(AgentDefinitionRevisionRow)(row).pipe(Effect15.mapError(toRepositoryError3));
 var layer10 = Layer14.effect(Service16, Effect15.gen(function* () {
   const sql = yield* SqlClient4;
   const columns = sql.literal(["id", "current_revision", "definition_json", "tool_input_schema_digests_json", "created_at", "updated_at"].join(", "));
@@ -1407,34 +1487,34 @@ __export(exports_child_execution_repository, {
   ChildExecutionRepositoryError: () => ChildExecutionRepositoryError,
   ChildExecutionNotFound: () => ChildExecutionNotFound
 });
-import { Context as Context15, Effect as Effect16, Layer as Layer15, Predicate, Schema as Schema16 } from "effect";
+import { Context as Context15, Effect as Effect16, Layer as Layer15, Predicate, Schema as Schema17 } from "effect";
 import { SqlClient as SqlClient5 } from "effect/unstable/sql/SqlClient";
 import { isSqlError } from "effect/unstable/sql/SqlError";
-class ChildExecutionRepositoryError extends Schema16.TaggedErrorClass()("ChildExecutionRepositoryError", {
-  message: Schema16.String
+class ChildExecutionRepositoryError extends Schema17.TaggedErrorClass()("ChildExecutionRepositoryError", {
+  message: Schema17.String
 }) {
 }
 
-class DuplicateChildExecution extends Schema16.TaggedErrorClass()("DuplicateChildExecution", {
+class DuplicateChildExecution extends Schema17.TaggedErrorClass()("DuplicateChildExecution", {
   id: exports_ids_schema.ChildExecutionId
 }) {
 }
 
-class ChildExecutionNotFound extends Schema16.TaggedErrorClass()("ChildExecutionNotFound", {
+class ChildExecutionNotFound extends Schema17.TaggedErrorClass()("ChildExecutionNotFound", {
   id: exports_ids_schema.ChildExecutionId
 }) {
 }
 
 class Service17 extends Context15.Service()("@relayfx/store-sql/child/child-execution-repository/Service") {
 }
-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.Finite]),
-  updated_at: Schema16.Union([Schema16.Date, Schema16.String, Schema16.Finite])
+var ChildExecutionRow = Schema17.Struct({
+  id: Schema17.String,
+  execution_id: Schema17.String,
+  address_id: Schema17.String,
+  status: Schema17.String,
+  metadata_json: Schema17.Unknown,
+  created_at: Schema17.Union([Schema17.Date, Schema17.String, Schema17.Finite]),
+  updated_at: Schema17.Union([Schema17.Date, Schema17.String, Schema17.Finite])
 }).annotate({ identifier: "Relay.ChildExecution.Row" });
 var metadata2 = (input) => input ?? {};
 var toRecord3 = (row) => ({
@@ -1457,7 +1537,7 @@ var isDuplicateConstraint = (error) => {
   const cause = error.reason.cause;
   return Predicate.hasProperty(cause, "code") && (cause.code === "SQLITE_CONSTRAINT_PRIMARYKEY" || cause.code === 1555) || Predicate.hasProperty(cause, "errno") && cause.errno === 1555;
 };
-var decodeRow4 = (row) => Schema16.decodeUnknownEffect(ChildExecutionRow)(row).pipe(Effect16.mapError(toRepositoryError4));
+var decodeRow4 = (row) => Schema17.decodeUnknownEffect(ChildExecutionRow)(row).pipe(Effect16.mapError(toRepositoryError4));
 var layer11 = Layer15.effect(Service17, Effect16.gen(function* () {
   const sql = yield* SqlClient5;
   const columns = sql.literal(["id", "execution_id", "address_id", "status", "metadata_json", "created_at", "updated_at"].join(", "));
@@ -1614,35 +1694,35 @@ __export(exports_child_fan_out_repository, {
   ChildFanOutRepositoryError: () => ChildFanOutRepositoryError,
   ChildFanOutConflict: () => ChildFanOutConflict
 });
-import { Context as Context16, Effect as Effect17, Layer as Layer16, Schema as Schema17, Semaphore } from "effect";
+import { Context as Context16, Effect as Effect17, Layer as Layer16, Schema as Schema18, Semaphore } from "effect";
 import { SqlClient as SqlClient6 } from "effect/unstable/sql/SqlClient";
-class ChildFanOutRepositoryError extends Schema17.TaggedErrorClass()("ChildFanOutRepositoryError", { message: Schema17.String }) {
+class ChildFanOutRepositoryError extends Schema18.TaggedErrorClass()("ChildFanOutRepositoryError", { message: Schema18.String }) {
 }
 
-class ChildFanOutConflict extends Schema17.TaggedErrorClass()("ChildFanOutConflict", {
+class ChildFanOutConflict extends Schema18.TaggedErrorClass()("ChildFanOutConflict", {
   fan_out_id: exports_ids_schema.ChildFanOutId
 }) {
 }
 
 class Service18 extends Context16.Service()("@relayfx/store-sql/child/child-fan-out-repository/Service") {
 }
-var FanOutRow = Schema17.Struct({
-  definition_json: Schema17.Unknown,
+var FanOutRow = Schema18.Struct({
+  definition_json: Schema18.Unknown,
   state: exports_child_orchestration_schema.AggregateState,
-  satisfied_at: Schema17.NullOr(Schema17.Union([Schema17.Date, Schema17.String, Schema17.Finite])),
-  failed_at: Schema17.NullOr(Schema17.Union([Schema17.Date, Schema17.String, Schema17.Finite])),
-  cancelled_at: Schema17.NullOr(Schema17.Union([Schema17.Date, Schema17.String, Schema17.Finite]))
+  satisfied_at: Schema18.NullOr(Schema18.Union([Schema18.Date, Schema18.String, Schema18.Finite])),
+  failed_at: Schema18.NullOr(Schema18.Union([Schema18.Date, Schema18.String, Schema18.Finite])),
+  cancelled_at: Schema18.NullOr(Schema18.Union([Schema18.Date, Schema18.String, Schema18.Finite]))
 });
-var MemberRow = Schema17.Struct({
-  child_execution_id: Schema17.String,
-  ordinal: Schema17.Finite,
+var MemberRow = Schema18.Struct({
+  child_execution_id: Schema18.String,
+  ordinal: Schema18.Finite,
   state: exports_child_orchestration_schema.MemberState,
-  output_json: Schema17.NullOr(Schema17.Unknown),
-  error: Schema17.NullOr(Schema17.String),
-  completed_at: Schema17.NullOr(Schema17.Union([Schema17.Date, Schema17.String, Schema17.Finite]))
+  output_json: Schema18.NullOr(Schema18.Unknown),
+  error: Schema18.NullOr(Schema18.String),
+  completed_at: Schema18.NullOr(Schema18.Union([Schema18.Date, Schema18.String, Schema18.Finite]))
 });
 var repositoryError = (error) => ChildFanOutRepositoryError.make({ message: String(error) });
-var cloneDefinition2 = (value) => Schema17.decodeUnknownSync(exports_child_orchestration_schema.FanOutDefinition)(globalThis.structuredClone(value));
+var cloneDefinition2 = (value) => Schema18.decodeUnknownSync(exports_child_orchestration_schema.FanOutDefinition)(globalThis.structuredClone(value));
 var sameDefinition = (left, right) => exports_shared_schema.canonicalEquals(left, right);
 var terminal = (state) => state === "completed" || state === "failed" || state === "cancelled";
 var foldState = (state) => {
@@ -1685,9 +1765,9 @@ var layer12 = Layer16.effect(Service18, Effect17.gen(function* () {
     const rows = yield* sql`SELECT definition_json, state, satisfied_at, failed_at, cancelled_at FROM relay_child_fan_outs WHERE tenant_id = ${tenantId} AND id = ${id}`;
     if (rows[0] === undefined)
       return;
-    const row = yield* Schema17.decodeUnknownEffect(FanOutRow)(rows[0]);
+    const row = yield* Schema18.decodeUnknownEffect(FanOutRow)(rows[0]);
     const memberRows = yield* sql`SELECT child_execution_id, ordinal, state, output_json, error, completed_at FROM relay_child_fan_out_members WHERE tenant_id = ${tenantId} AND fan_out_id = ${id} ORDER BY ordinal ASC`;
-    const decodedMembers = yield* Effect17.forEach(memberRows, (member) => Schema17.decodeUnknownEffect(MemberRow)(member));
+    const decodedMembers = yield* Effect17.forEach(memberRows, (member) => Schema18.decodeUnknownEffect(MemberRow)(member));
     const definition = cloneDefinition2(decodeJson(row.definition_json));
     return {
       ...definition,
@@ -1937,23 +2017,23 @@ __export(exports_cluster_registry_repository, {
   LockRow: () => LockRow,
   ClusterRegistryError: () => ClusterRegistryError
 });
-import { Context as Context17, Effect as Effect18, Layer as Layer17, Schema as Schema18 } from "effect";
+import { Context as Context17, Effect as Effect18, Layer as Layer17, Schema as Schema19 } from "effect";
 import { SqlClient as SqlClient7 } from "effect/unstable/sql/SqlClient";
-class ClusterRegistryError extends Schema18.TaggedErrorClass()("ClusterRegistryError", {
-  message: Schema18.String
+class ClusterRegistryError extends Schema19.TaggedErrorClass()("ClusterRegistryError", {
+  message: Schema19.String
 }) {
 }
 
 class Service19 extends Context17.Service()("@relayfx/store-sql/cluster/cluster-registry-repository/Service") {
 }
-var RunnerRow = Schema18.Struct({
-  address: Schema18.String,
-  healthy: Schema18.Union([Schema18.Boolean, Schema18.Finite, Schema18.String]),
-  last_heartbeat: Schema18.Union([Schema18.Date, Schema18.String, Schema18.Finite]),
-  owned_shards: Schema18.Union([Schema18.Finite, Schema18.String, Schema18.BigInt])
+var RunnerRow = Schema19.Struct({
+  address: Schema19.String,
+  healthy: Schema19.Union([Schema19.Boolean, Schema19.Finite, Schema19.String]),
+  last_heartbeat: Schema19.Union([Schema19.Date, Schema19.String, Schema19.Finite]),
+  owned_shards: Schema19.Union([Schema19.Finite, Schema19.String, Schema19.BigInt])
 }).annotate({ identifier: "Relay.ClusterRegistry.RunnerRow" });
-var LockRow = Schema18.Struct({
-  address: Schema18.String
+var LockRow = Schema19.Struct({
+  address: Schema19.String
 }).annotate({ identifier: "Relay.ClusterRegistry.LockRow" });
 var toRunnerRecord = (row) => ({
   address: row.address,
@@ -1962,8 +2042,8 @@ var toRunnerRecord = (row) => ({
   ownedShards: Number(row.owned_shards)
 });
 var toRegistryError = (error) => ClusterRegistryError.make({ message: String(error) });
-var decodeRunnerRow = (row) => Schema18.decodeUnknownEffect(RunnerRow)(row).pipe(Effect18.mapError(toRegistryError));
-var decodeLockRow = (row) => Schema18.decodeUnknownEffect(LockRow)(row).pipe(Effect18.mapError(toRegistryError));
+var decodeRunnerRow = (row) => Schema19.decodeUnknownEffect(RunnerRow)(row).pipe(Effect18.mapError(toRegistryError));
+var decodeLockRow = (row) => Schema19.decodeUnknownEffect(LockRow)(row).pipe(Effect18.mapError(toRegistryError));
 var layer13 = Layer17.effect(Service19, Effect18.gen(function* () {
   const sql = yield* SqlClient7;
   const selectRunners = () => sql`
@@ -2010,22 +2090,22 @@ __export(exports_compaction_repository, {
   CompactionRepositoryError: () => CompactionRepositoryError,
   CompactionCheckpointRow: () => CompactionCheckpointRow
 });
-import { Context as Context18, Effect as Effect19, Layer as Layer18, Schema as Schema19 } from "effect";
+import { Context as Context18, Effect as Effect19, Layer as Layer18, Schema as Schema20 } from "effect";
 import { SqlClient as SqlClient8 } from "effect/unstable/sql/SqlClient";
-class CompactionRepositoryError extends Schema19.TaggedErrorClass()("CompactionRepositoryError", {
-  message: Schema19.String
+class CompactionRepositoryError extends Schema20.TaggedErrorClass()("CompactionRepositoryError", {
+  message: Schema20.String
 }) {
 }
 
 class Service20 extends Context18.Service()("@relayfx/store-sql/compaction/compaction-repository/Service") {
 }
-var CompactionCheckpointRow = Schema19.Struct({
-  execution_id: Schema19.String,
-  checkpoint_id: Schema19.String,
-  summary: Schema19.String,
-  first_kept_entry_id: Schema19.String,
-  turn: Schema19.Finite,
-  created_at: Schema19.Union([Schema19.Date, Schema19.String, Schema19.Finite])
+var CompactionCheckpointRow = Schema20.Struct({
+  execution_id: Schema20.String,
+  checkpoint_id: Schema20.String,
+  summary: Schema20.String,
+  first_kept_entry_id: Schema20.String,
+  turn: Schema20.Finite,
+  created_at: Schema20.Union([Schema20.Date, Schema20.String, Schema20.Finite])
 }).annotate({ identifier: "Relay.CompactionCheckpoint.Row" });
 var toRecord4 = (row) => ({
   executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
@@ -2036,7 +2116,7 @@ var toRecord4 = (row) => ({
   createdAt: fromDbTimestamp(row.created_at)
 });
 var toRepositoryError5 = (error) => CompactionRepositoryError.make({ message: String(error) });
-var decodeRow5 = (row) => Schema19.decodeUnknownEffect(CompactionCheckpointRow)(row).pipe(Effect19.mapError(toRepositoryError5));
+var decodeRow5 = (row) => Schema20.decodeUnknownEffect(CompactionCheckpointRow)(row).pipe(Effect19.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) => CompactionRepositoryError.make({
@@ -2160,20 +2240,20 @@ __export(exports_context_epoch_repository, {
   ContextEpochRow: () => ContextEpochRow,
   ContextEpochRepositoryError: () => ContextEpochRepositoryError
 });
-import { Context as Context19, Effect as Effect20, Layer as Layer19, Schema as Schema20 } from "effect";
+import { Context as Context19, Effect as Effect20, Layer as Layer19, Schema as Schema21 } from "effect";
 import { SqlClient as SqlClient9 } from "effect/unstable/sql/SqlClient";
-class ContextEpochRepositoryError extends Schema20.TaggedErrorClass()("ContextEpochRepositoryError", {
-  message: Schema20.String
+class ContextEpochRepositoryError extends Schema21.TaggedErrorClass()("ContextEpochRepositoryError", {
+  message: Schema21.String
 }) {
 }
 
 class Service21 extends Context19.Service()("@relayfx/store-sql/session/context-epoch-repository/Service") {
 }
-var ContextEpochRow = Schema20.Struct({
-  execution_id: Schema20.String,
-  baseline: Schema20.String,
-  dynamic_source_ids_json: Schema20.Unknown,
-  opened_at: Schema20.Union([Schema20.Date, Schema20.String, Schema20.Finite])
+var ContextEpochRow = Schema21.Struct({
+  execution_id: Schema21.String,
+  baseline: Schema21.String,
+  dynamic_source_ids_json: Schema21.Unknown,
+  opened_at: Schema21.Union([Schema21.Date, Schema21.String, Schema21.Finite])
 }).annotate({ identifier: "Relay.ContextEpoch.Row" });
 var toRecord5 = (row) => ({
   executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
@@ -2182,7 +2262,7 @@ var toRecord5 = (row) => ({
   openedAt: fromDbTimestamp(row.opened_at)
 });
 var toRepositoryError6 = (error) => ContextEpochRepositoryError.make({ message: String(error) });
-var decodeRow6 = (row) => Schema20.decodeUnknownEffect(ContextEpochRow)(row).pipe(Effect20.mapError(toRepositoryError6));
+var decodeRow6 = (row) => Schema21.decodeUnknownEffect(ContextEpochRow)(row).pipe(Effect20.mapError(toRepositoryError6));
 var sameEpoch = (record2, input) => record2.baseline === input.baseline && exports_shared_schema.canonicalEquals(record2.dynamicSourceIds, input.dynamicSourceIds);
 var conflict2 = (executionId) => ContextEpochRepositoryError.make({ message: `Context epoch already exists with different payload: ${executionId}` });
 var cloneRecord3 = (record2) => structuredClone(record2);
@@ -2296,30 +2376,30 @@ __export(exports_envelope_repository, {
   EnvelopeReadyClaimMismatch: () => EnvelopeReadyClaimMismatch,
   EnvelopeNotFound: () => EnvelopeNotFound
 });
-import { Context as Context20, Effect as Effect24, Layer as Layer20, Schema as Schema24 } from "effect";
+import { Context as Context20, Effect as Effect24, Layer as Layer20, Schema as Schema25 } from "effect";
 
 // ../store-sql/src/envelope/envelope-records.ts
-import { Effect as Effect23, Schema as Schema23 } from "effect";
+import { Effect as Effect23, Schema as Schema24 } from "effect";
 import { SqlClient as SqlClient10 } from "effect/unstable/sql/SqlClient";
 
 // ../store-sql/src/envelope/envelope-ready-records.ts
-import { Effect as Effect21, Schema as Schema21 } from "effect";
-var DbTimestamp = Schema21.Union([Schema21.Date, Schema21.String, Schema21.Finite]);
-var NullableDbTimestamp = Schema21.Union([Schema21.Date, Schema21.String, Schema21.Finite, Schema21.Null]);
-var NullableString = Schema21.Union([Schema21.String, Schema21.Null]);
-var envelopeReadyRow = Schema21.Struct({
-  id: Schema21.String,
-  envelope_id: Schema21.String,
-  route_type: Schema21.String,
-  route_key: Schema21.String,
-  state: Schema21.String,
+import { Effect as Effect21, Schema as Schema22 } from "effect";
+var DbTimestamp = Schema22.Union([Schema22.Date, Schema22.String, Schema22.Finite]);
+var NullableDbTimestamp = Schema22.Union([Schema22.Date, Schema22.String, Schema22.Finite, Schema22.Null]);
+var NullableString = Schema22.Union([Schema22.String, Schema22.Null]);
+var envelopeReadyRow = Schema22.Struct({
+  id: Schema22.String,
+  envelope_id: Schema22.String,
+  route_type: Schema22.String,
+  route_key: Schema22.String,
+  state: Schema22.String,
   available_at: DbTimestamp,
-  attempt: Schema21.Finite,
+  attempt: Schema22.Finite,
   claim_owner: NullableString,
   claim_expires_at: NullableDbTimestamp,
   last_error: NullableString,
   idempotency_key: NullableString,
-  metadata_json: Schema21.Unknown,
+  metadata_json: Schema22.Unknown,
   created_at: DbTimestamp,
   updated_at: DbTimestamp,
   claimed_at: NullableDbTimestamp,
@@ -2352,7 +2432,7 @@ var toReadyRecord = (row) => {
 var makeEnvelopeReadyRecordOperations = ({ sql, ts, errors }) => {
   const { EnvelopeRepositoryError, EnvelopeReadyNotFound, EnvelopeReadyClaimMismatch } = errors;
   const toRepositoryError7 = (error) => EnvelopeRepositoryError.make({ message: String(error) });
-  const decodeReadyRow = (row) => Schema21.decodeUnknownEffect(envelopeReadyRow)(row).pipe(Effect21.mapError(toRepositoryError7));
+  const decodeReadyRow = (row) => Schema22.decodeUnknownEffect(envelopeReadyRow)(row).pipe(Effect21.mapError(toRepositoryError7));
   const readyColumns = sql.literal("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");
   const selectReadyById = (tenantId, id) => sql`
     SELECT ${readyColumns}
@@ -2525,18 +2605,18 @@ var makeEnvelopeReadyRecordOperations = ({ sql, ts, errors }) => {
 };
 
 // ../store-sql/src/envelope/wait-records.ts
-import { Effect as Effect22, Schema as Schema22 } from "effect";
-var DbTimestamp2 = Schema22.Union([Schema22.Date, Schema22.String, Schema22.Finite]);
-var NullableDbTimestamp2 = Schema22.Union([Schema22.Date, Schema22.String, Schema22.Finite, Schema22.Null]);
-var NullableString2 = Schema22.Union([Schema22.String, Schema22.Null]);
-var waitRow = Schema22.Struct({
-  id: Schema22.String,
-  execution_id: Schema22.String,
+import { Effect as Effect22, Schema as Schema23 } from "effect";
+var DbTimestamp2 = Schema23.Union([Schema23.Date, Schema23.String, Schema23.Finite]);
+var NullableDbTimestamp2 = Schema23.Union([Schema23.Date, Schema23.String, Schema23.Finite, Schema23.Null]);
+var NullableString2 = Schema23.Union([Schema23.String, Schema23.Null]);
+var waitRow = Schema23.Struct({
+  id: Schema23.String,
+  execution_id: Schema23.String,
   envelope_id: NullableString2,
-  mode: Schema22.String,
+  mode: Schema23.String,
   correlation_key: NullableString2,
-  state: Schema22.String,
-  metadata_json: Schema22.Unknown,
+  state: Schema23.String,
+  metadata_json: Schema23.Unknown,
   created_at: DbTimestamp2,
   resolved_at: NullableDbTimestamp2
 }).annotate({ identifier: "Relay.Wait.Row" });
@@ -2564,7 +2644,7 @@ var waitRecordOrdering = { compareWaitsDesc };
 var makeWaitRecordOperations = ({ sql, ts, errors }) => {
   const { EnvelopeRepositoryError, WaitNotFound } = errors;
   const toRepositoryError7 = (error) => EnvelopeRepositoryError.make({ message: String(error) });
-  const decodeWaitRow = (row) => Schema22.decodeUnknownEffect(waitRow)(row).pipe(Effect22.mapError(toRepositoryError7));
+  const decodeWaitRow = (row) => Schema23.decodeUnknownEffect(waitRow)(row).pipe(Effect22.mapError(toRepositoryError7));
   const waitColumns = sql.literal("id, execution_id, envelope_id, mode, correlation_key, state, metadata_json, created_at, resolved_at");
   const selectWaitById = (tenantId, id) => sql`
     SELECT ${waitColumns}
@@ -2705,17 +2785,17 @@ var makeWaitRecordOperations = ({ sql, ts, errors }) => {
 };
 
 // ../store-sql/src/envelope/envelope-records.ts
-var DbTimestamp3 = Schema23.Union([Schema23.Date, Schema23.String, Schema23.Finite]);
-var NullableString3 = Schema23.Union([Schema23.String, Schema23.Null]);
-var envelopeRow = Schema23.Struct({
-  id: Schema23.String,
-  execution_id: Schema23.String,
-  from_address_id: Schema23.String,
-  to_address_id: Schema23.String,
-  content_json: Schema23.Unknown,
-  wait_json: Schema23.Unknown,
+var DbTimestamp3 = Schema24.Union([Schema24.Date, Schema24.String, Schema24.Finite]);
+var NullableString3 = Schema24.Union([Schema24.String, Schema24.Null]);
+var envelopeRow = Schema24.Struct({
+  id: Schema24.String,
+  execution_id: Schema24.String,
+  from_address_id: Schema24.String,
+  to_address_id: Schema24.String,
+  content_json: Schema24.Unknown,
+  wait_json: Schema24.Unknown,
   correlation_key: NullableString3,
-  metadata_json: Schema23.Unknown,
+  metadata_json: Schema24.Unknown,
   created_at: DbTimestamp3
 }).annotate({ identifier: "Relay.Envelope.Row" });
 var decodeMetadata3 = (value) => decodeJson(value);
@@ -2744,7 +2824,7 @@ var makeEnvelopeRepository = (errors) => Effect23.gen(function* () {
   const toRepositoryError7 = (error) => EnvelopeRepositoryError.make({ message: String(error) });
   const ts = (millis) => timestampParam(sql, millis);
   const envelopeColumns = sql.literal("id, execution_id, from_address_id, to_address_id, content_json, wait_json, correlation_key, metadata_json, created_at");
-  const decodeEnvelopeRow = (row) => Schema23.decodeUnknownEffect(envelopeRow)(row).pipe(Effect23.mapError(toRepositoryError7));
+  const decodeEnvelopeRow = (row) => Schema24.decodeUnknownEffect(envelopeRow)(row).pipe(Effect23.mapError(toRepositoryError7));
   const acceptEnvelope = Effect23.fn("EnvelopeRepository.acceptEnvelope")(function* (input) {
     const tenantId = yield* current();
     const envelope = input.envelope;
@@ -2804,36 +2884,36 @@ var makeEnvelopeRepository = (errors) => Effect23.gen(function* () {
 });
 
 // ../store-sql/src/envelope/envelope-repository.ts
-var WaitState = Schema24.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
+var WaitState = Schema25.Literals(["open", "resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.Store.WaitState"
 });
-var EnvelopeReadyState = Schema24.Literals(["ready", "claimed", "acknowledged"]).annotate({
+var EnvelopeReadyState = Schema25.Literals(["ready", "claimed", "acknowledged"]).annotate({
   identifier: "Relay.Store.EnvelopeReadyState"
 });
 
-class EnvelopeRepositoryError extends Schema24.TaggedErrorClass()("EnvelopeRepositoryError", {
-  message: Schema24.String
+class EnvelopeRepositoryError extends Schema25.TaggedErrorClass()("EnvelopeRepositoryError", {
+  message: Schema25.String
 }) {
 }
 
-class EnvelopeNotFound extends Schema24.TaggedErrorClass()("EnvelopeNotFound", {
+class EnvelopeNotFound extends Schema25.TaggedErrorClass()("EnvelopeNotFound", {
   id: exports_ids_schema.EnvelopeId
 }) {
 }
 
-class WaitNotFound extends Schema24.TaggedErrorClass()("WaitNotFound", {
+class WaitNotFound extends Schema25.TaggedErrorClass()("WaitNotFound", {
   id: exports_ids_schema.WaitId
 }) {
 }
 
-class EnvelopeReadyNotFound extends Schema24.TaggedErrorClass()("EnvelopeReadyNotFound", {
+class EnvelopeReadyNotFound extends Schema25.TaggedErrorClass()("EnvelopeReadyNotFound", {
   id: exports_ids_schema.EnvelopeReadyId
 }) {
 }
 
-class EnvelopeReadyClaimMismatch extends Schema24.TaggedErrorClass()("EnvelopeReadyClaimMismatch", {
+class EnvelopeReadyClaimMismatch extends Schema25.TaggedErrorClass()("EnvelopeReadyClaimMismatch", {
   id: exports_ids_schema.EnvelopeReadyId,
-  worker_id: Schema24.String
+  worker_id: Schema25.String
 }) {
 }
 
@@ -3052,35 +3132,35 @@ __export(exports_resident_repository, {
   Service: () => Service23,
   ResidentRepositoryError: () => ResidentRepositoryError
 });
-import { Clock as Clock2, Context as Context21, Effect as Effect25, Layer as Layer21, Ref as Ref4, Schema as Schema25, SchemaGetter } from "effect";
+import { Clock as Clock2, Context as Context21, Effect as Effect25, Layer as Layer21, Ref as Ref4, Schema as Schema26, SchemaGetter } from "effect";
 import { SqlClient as SqlClient11 } from "effect/unstable/sql/SqlClient";
-class ResidentRepositoryError extends Schema25.TaggedErrorClass()("ResidentRepositoryError", {
-  message: Schema25.String
+class ResidentRepositoryError extends Schema26.TaggedErrorClass()("ResidentRepositoryError", {
+  message: Schema26.String
 }) {
 }
 
 class Service23 extends Context21.Service()("@relayfx/store-sql/resident/resident-repository/Service") {
 }
-var KindRow = Schema25.Struct({
-  kind: Schema25.String,
-  agent_id: Schema25.String,
-  inbox_policy_json: Schema25.Unknown,
-  state_enabled: Schema25.NullOr(Schema25.Union([Schema25.Boolean, Schema25.Finite])).pipe(Schema25.decodeTo(Schema25.NullOr(Schema25.Boolean), {
+var KindRow = Schema26.Struct({
+  kind: Schema26.String,
+  agent_id: Schema26.String,
+  inbox_policy_json: Schema26.Unknown,
+  state_enabled: Schema26.NullOr(Schema26.Union([Schema26.Boolean, Schema26.Finite])).pipe(Schema26.decodeTo(Schema26.NullOr(Schema26.Boolean), {
     decode: SchemaGetter.transform((value) => value === null ? null : value === true || value === 1),
     encode: SchemaGetter.transform((value) => value === null ? null : value ? 1 : 0)
   })),
-  continue_as_new_after_turns: Schema25.NullOr(Schema25.Finite),
-  metadata_json: Schema25.Unknown
-});
-var InstanceRow = Schema25.Struct({
-  kind: Schema25.String,
-  key: Schema25.String,
-  address_id: Schema25.String,
-  execution_id: Schema25.String,
-  generation: Schema25.Finite,
-  status: Schema25.String,
-  created_at: Schema25.Union([Schema25.Date, Schema25.String, Schema25.Finite]),
-  destroyed_at: Schema25.NullOr(Schema25.Union([Schema25.Date, Schema25.String, Schema25.Finite]))
+  continue_as_new_after_turns: Schema26.NullOr(Schema26.Finite),
+  metadata_json: Schema26.Unknown
+});
+var InstanceRow = Schema26.Struct({
+  kind: Schema26.String,
+  key: Schema26.String,
+  address_id: Schema26.String,
+  execution_id: Schema26.String,
+  generation: Schema26.Finite,
+  status: Schema26.String,
+  created_at: Schema26.Union([Schema26.Date, Schema26.String, Schema26.Finite]),
+  destroyed_at: Schema26.NullOr(Schema26.Union([Schema26.Date, Schema26.String, Schema26.Finite]))
 });
 var repositoryError2 = (error) => ResidentRepositoryError.make({ message: String(error) });
 var toKind = (row) => ({
@@ -3101,8 +3181,8 @@ var toInstance = (row) => ({
   created_at: fromDbTimestamp(row.created_at),
   ...row.destroyed_at === null ? {} : { destroyed_at: fromDbTimestamp(row.destroyed_at) }
 });
-var decodeKind = (row) => Schema25.decodeUnknownEffect(KindRow)(row).pipe(Effect25.map(toKind), Effect25.mapError(repositoryError2));
-var decodeInstance = (row) => Schema25.decodeUnknownEffect(InstanceRow)(row).pipe(Effect25.map(toInstance), Effect25.mapError(repositoryError2));
+var decodeKind = (row) => Schema26.decodeUnknownEffect(KindRow)(row).pipe(Effect25.map(toKind), Effect25.mapError(repositoryError2));
+var decodeInstance = (row) => Schema26.decodeUnknownEffect(InstanceRow)(row).pipe(Effect25.map(toInstance), Effect25.mapError(repositoryError2));
 var layer17 = Layer21.effect(Service23, Effect25.gen(function* () {
   const sql = yield* SqlClient11;
   const getKind = Effect25.fn("ResidentRepository.getKind")(function* (kind) {
@@ -3264,7 +3344,7 @@ __export(exports_execution_event_repository, {
   ExecutionEventCursorNotFound: () => ExecutionEventCursorNotFound,
   DuplicateExecutionEvent: () => DuplicateExecutionEvent
 });
-import { Context as Context23, Effect as Effect29, Layer as Layer25, Schema as Schema27, Stream as Stream4 } from "effect";
+import { Context as Context23, Effect as Effect29, Layer as Layer25, Schema as Schema28, Stream as Stream4 } from "effect";
 
 // ../store-sql/src/database/notification-bus.ts
 var exports_notification_bus = {};
@@ -3458,7 +3538,7 @@ var makeMemoryLayer = (repository) => {
 };
 
 // ../store-sql/src/execution/execution-event-repository-sql.ts
-import { Effect as Effect28, Filter, Layer as Layer24, Option as Option3, Schema as Schema26, Stream as Stream3 } from "effect";
+import { Effect as Effect28, Filter, Layer as Layer24, Option as Option3, Schema as Schema27, Stream as Stream3 } from "effect";
 import { SqlClient as SqlClient13 } from "effect/unstable/sql/SqlClient";
 var pageResult2 = (events, limit, direction) => {
   const hasMore = events.length > limit;
@@ -3502,7 +3582,7 @@ var makeLayer = (repository) => {
     };
   };
   const toRepositoryError7 = (error) => ExecutionEventRepositoryError.make({ message: String(error) });
-  const decodeRow7 = (row) => Schema26.decodeUnknownEffect(ExecutionEventRow)(row).pipe(Effect28.mapError(toRepositoryError7));
+  const decodeRow7 = (row) => Schema27.decodeUnknownEffect(ExecutionEventRow)(row).pipe(Effect28.mapError(toRepositoryError7));
   const parsePointer = (executionId, payload) => {
     const separator = payload.lastIndexOf(":");
     if (separator <= 0 || separator === payload.length - 1)
@@ -3616,7 +3696,7 @@ var makeLayer = (repository) => {
           return yield* ExecutionEventRepositoryError.make({ message: "Execution event append returned no row" });
         }
         return toEvent(yield* decodeRow7(row));
-      })).pipe(Effect28.mapError((error) => Schema26.is(DuplicateExecutionEvent)(error) || Schema26.is(ExecutionEventOrderViolation)(error) ? error : toRepositoryError7(error)));
+      })).pipe(Effect28.mapError((error) => Schema27.is(DuplicateExecutionEvent)(error) || Schema27.is(ExecutionEventOrderViolation)(error) ? error : toRepositoryError7(error)));
     });
     const appendNext = Effect28.fn("ExecutionEventRepository.appendNext")(function* (input) {
       const tenantId = yield* current();
@@ -3654,7 +3734,7 @@ var makeLayer = (repository) => {
           return yield* ExecutionEventRepositoryError.make({ message: "Execution event append returned no row" });
         }
         return { event: toEvent(yield* decodeRow7(row)), inserted: true };
-      })).pipe(Effect28.mapError((error) => Schema26.is(DuplicateExecutionEvent)(error) ? error : toRepositoryError7(error)));
+      })).pipe(Effect28.mapError((error) => Schema27.is(DuplicateExecutionEvent)(error) ? error : toRepositoryError7(error)));
     });
     const list4 = Effect28.fn("ExecutionEventRepository.list")(function* (input) {
       const tenantId = yield* current();
@@ -3739,10 +3819,10 @@ var makeLayer = (repository) => {
       const row = rows[0];
       return row === undefined ? Option3.none() : Option3.some(toEvent(yield* decodeRow7(row)));
     });
-    const AggregateRow = Schema26.Struct({
-      value: Schema26.NullishOr(Schema26.Union([Schema26.Finite, Schema26.String, Schema26.BigInt]))
+    const AggregateRow = Schema27.Struct({
+      value: Schema27.NullishOr(Schema27.Union([Schema27.Finite, Schema27.String, Schema27.BigInt]))
     });
-    const decodeAggregate = (row) => Schema26.decodeUnknownEffect(AggregateRow)(row).pipe(Effect28.mapError(toRepositoryError7));
+    const decodeAggregate = (row) => Schema27.decodeUnknownEffect(AggregateRow)(row).pipe(Effect28.mapError(toRepositoryError7));
     const maxSequence = Effect28.fn("ExecutionEventRepository.maxSequence")(function* (executionId) {
       const tenantId = yield* current();
       const rows = yield* sql`
@@ -3856,43 +3936,43 @@ var makeLayer = (repository) => {
 // ../store-sql/src/execution/execution-event-repository.ts
 var executionEventsChannel = "relay_execution_events";
 
-class DuplicateExecutionEvent extends Schema27.TaggedErrorClass()("DuplicateExecutionEvent", {
+class DuplicateExecutionEvent extends Schema28.TaggedErrorClass()("DuplicateExecutionEvent", {
   execution_id: exports_ids_schema.ExecutionId,
   sequence: exports_execution_schema.ExecutionEventSequence,
   cursor: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ExecutionEventOrderViolation extends Schema27.TaggedErrorClass()("ExecutionEventOrderViolation", {
+class ExecutionEventOrderViolation extends Schema28.TaggedErrorClass()("ExecutionEventOrderViolation", {
   execution_id: exports_ids_schema.ExecutionId,
   sequence: exports_execution_schema.ExecutionEventSequence,
   previous_sequence: exports_execution_schema.ExecutionEventSequence
 }) {
 }
 
-class ExecutionEventCursorNotFound extends Schema27.TaggedErrorClass()("ExecutionEventCursorNotFound", {
+class ExecutionEventCursorNotFound extends Schema28.TaggedErrorClass()("ExecutionEventCursorNotFound", {
   execution_id: exports_ids_schema.ExecutionId,
   cursor: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ExecutionEventRepositoryError extends Schema27.TaggedErrorClass()("ExecutionEventRepositoryError", {
-  message: Schema27.String
+class ExecutionEventRepositoryError extends Schema28.TaggedErrorClass()("ExecutionEventRepositoryError", {
+  message: Schema28.String
 }) {
 }
 
 class Service25 extends Context23.Service()("@relayfx/store-sql/execution/execution-event-repository/Service") {
 }
-var ExecutionEventRow = Schema27.Struct({
-  id: Schema27.String,
-  execution_id: Schema27.String,
-  child_execution_id: Schema27.NullishOr(Schema27.String),
-  type: Schema27.String,
-  sequence: Schema27.Union([Schema27.Finite, Schema27.String]),
-  cursor: Schema27.String,
-  content_json: Schema27.NullishOr(Schema27.Unknown),
-  data_json: Schema27.Unknown,
-  created_at: Schema27.Union([Schema27.Date, Schema27.String, Schema27.Finite])
+var ExecutionEventRow = Schema28.Struct({
+  id: Schema28.String,
+  execution_id: Schema28.String,
+  child_execution_id: Schema28.NullishOr(Schema28.String),
+  type: Schema28.String,
+  sequence: Schema28.Union([Schema28.Finite, Schema28.String]),
+  cursor: Schema28.String,
+  content_json: Schema28.NullishOr(Schema28.Unknown),
+  data_json: Schema28.Unknown,
+  created_at: Schema28.Union([Schema28.Date, Schema28.String, Schema28.Finite])
 }).annotate({ identifier: "Relay.ExecutionEvent.Row" });
 var layer18 = makeLayer({
   DuplicateExecutionEvent,
@@ -3982,19 +4062,19 @@ __export(exports_execution_repository, {
   ExecutionNotFound: () => ExecutionNotFound2,
   DuplicateExecution: () => DuplicateExecution
 });
-import { Context as Context24, Effect as Effect30, Filter as Filter2, Layer as Layer26, Option as Option5, PubSub as PubSub3, Schema as Schema28, Stream as Stream5 } from "effect";
+import { Context as Context24, Effect as Effect30, Filter as Filter2, Layer as Layer26, Option as Option5, PubSub as PubSub3, Schema as Schema29, Stream as Stream5 } from "effect";
 import { SqlClient as SqlClient14 } from "effect/unstable/sql/SqlClient";
-class ExecutionRepositoryError extends Schema28.TaggedErrorClass()("ExecutionRepositoryError", {
-  message: Schema28.String
+class ExecutionRepositoryError extends Schema29.TaggedErrorClass()("ExecutionRepositoryError", {
+  message: Schema29.String
 }) {
 }
 
-class DuplicateExecution extends Schema28.TaggedErrorClass()("DuplicateExecution", {
+class DuplicateExecution extends Schema29.TaggedErrorClass()("DuplicateExecution", {
   id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class ExecutionNotFound2 extends Schema28.TaggedErrorClass()("ExecutionNotFound", {
+class ExecutionNotFound2 extends Schema29.TaggedErrorClass()("ExecutionNotFound", {
   id: exports_ids_schema.ExecutionId
 }) {
 }
@@ -4002,18 +4082,18 @@ var executionsChangedChannel = "relay_executions_changed";
 
 class Service26 extends Context24.Service()("@relayfx/store-sql/execution/execution-repository/Service") {
 }
-var ExecutionRow = Schema28.Struct({
-  id: Schema28.String,
-  root_address_id: Schema28.String,
-  session_id: Schema28.NullishOr(Schema28.String),
-  status: Schema28.String,
-  agent_id: Schema28.NullishOr(Schema28.String),
-  agent_revision: Schema28.NullishOr(Schema28.Finite),
-  agent_snapshot_json: Schema28.NullishOr(Schema28.Unknown),
-  agent_tool_input_schema_digests_json: Schema28.Unknown,
-  metadata_json: Schema28.Unknown,
-  created_at: Schema28.Union([Schema28.Date, Schema28.String, Schema28.Finite]),
-  updated_at: Schema28.Union([Schema28.Date, Schema28.String, Schema28.Finite])
+var ExecutionRow = Schema29.Struct({
+  id: Schema29.String,
+  root_address_id: Schema29.String,
+  session_id: Schema29.NullishOr(Schema29.String),
+  status: Schema29.String,
+  agent_id: Schema29.NullishOr(Schema29.String),
+  agent_revision: Schema29.NullishOr(Schema29.Finite),
+  agent_snapshot_json: Schema29.NullishOr(Schema29.Unknown),
+  agent_tool_input_schema_digests_json: Schema29.Unknown,
+  metadata_json: Schema29.Unknown,
+  created_at: Schema29.Union([Schema29.Date, Schema29.String, Schema29.Finite]),
+  updated_at: Schema29.Union([Schema29.Date, Schema29.String, Schema29.Finite])
 }).annotate({ identifier: "Relay.Execution.Row" });
 var metadata4 = (input) => input ?? {};
 var nonEmptyDigests2 = (digests) => digests === undefined || Object.keys(digests).length === 0 ? undefined : structuredClone(digests);
@@ -4036,7 +4116,7 @@ var validateCreateInput = (input) => {
   }
   return Effect30.void;
 };
-var cloneAgentDefinition = (definition) => Schema28.decodeUnknownSync(exports_agent_schema.Definition)(globalThis.structuredClone(definition));
+var cloneAgentDefinition = (definition) => Schema29.decodeUnknownSync(exports_agent_schema.Definition)(globalThis.structuredClone(definition));
 var cloneRecord4 = (record2) => ({
   ...record2,
   metadata: globalThis.structuredClone(record2.metadata),
@@ -4065,9 +4145,9 @@ var parsePointer = (tenantId, payload) => {
   const prefix = `${tenantId}:`;
   if (!payload.startsWith(prefix) || payload.length === prefix.length)
     return Option5.none();
-  return Schema28.decodeUnknownOption(exports_ids_schema.ExecutionId)(payload.slice(prefix.length));
+  return Schema29.decodeUnknownOption(exports_ids_schema.ExecutionId)(payload.slice(prefix.length));
 };
-var decodeRow7 = (row) => Schema28.decodeUnknownEffect(ExecutionRow)(row).pipe(Effect30.mapError(toRepositoryError7));
+var decodeRow7 = (row) => Schema29.decodeUnknownEffect(ExecutionRow)(row).pipe(Effect30.mapError(toRepositoryError7));
 var maxListLimit = 100;
 var defaultListLimit = 50;
 var listLimit = (input) => Math.min(Math.max(input.limit ?? defaultListLimit, 1), maxListLimit);
@@ -4332,29 +4412,29 @@ __export(exports_execution_state_repository, {
   ExecutionStateRepositoryError: () => ExecutionStateRepositoryError,
   ExecutionStateExecutionNotFound: () => ExecutionStateExecutionNotFound
 });
-import { Context as Context25, Effect as Effect31, Layer as Layer27, Option as Option6, Schema as Schema29 } from "effect";
+import { Context as Context25, Effect as Effect31, Layer as Layer27, Option as Option6, Schema as Schema30 } from "effect";
 import { SqlClient as SqlClient15 } from "effect/unstable/sql/SqlClient";
-class StateVersionConflict2 extends Schema29.TaggedErrorClass()("StateVersionConflict", {
+class StateVersionConflict2 extends Schema30.TaggedErrorClass()("StateVersionConflict", {
   execution_id: exports_ids_schema.ExecutionId,
-  key: Schema29.String,
-  expected_version: Schema29.Int,
-  actual_version: Schema29.Int
+  key: Schema30.String,
+  expected_version: Schema30.Int,
+  actual_version: Schema30.Int
 }) {
 }
 
-class ExecutionStateRepositoryError extends Schema29.TaggedErrorClass()("ExecutionStateRepositoryError", { message: Schema29.String }) {
+class ExecutionStateRepositoryError extends Schema30.TaggedErrorClass()("ExecutionStateRepositoryError", { message: Schema30.String }) {
 }
 
-class ExecutionStateExecutionNotFound extends Schema29.TaggedErrorClass()("ExecutionStateExecutionNotFound", { execution_id: exports_ids_schema.ExecutionId }) {
+class ExecutionStateExecutionNotFound extends Schema30.TaggedErrorClass()("ExecutionStateExecutionNotFound", { execution_id: exports_ids_schema.ExecutionId }) {
 }
 
-class StateIdempotencyConflict extends Schema29.TaggedErrorClass()("StateIdempotencyConflict", {
+class StateIdempotencyConflict extends Schema30.TaggedErrorClass()("StateIdempotencyConflict", {
   execution_id: exports_ids_schema.ExecutionId,
-  idempotency_key: Schema29.String,
-  recorded_key: Schema29.String,
-  requested_key: Schema29.String,
-  recorded_op: Schema29.Literals(["put", "delete"]),
-  requested_op: Schema29.Literals(["put", "delete"])
+  idempotency_key: Schema30.String,
+  recorded_key: Schema30.String,
+  requested_key: Schema30.String,
+  recorded_op: Schema30.Literals(["put", "delete"]),
+  requested_op: Schema30.Literals(["put", "delete"])
 }) {
 }
 
@@ -4570,7 +4650,7 @@ var layer20 = Layer27.effect(Service27, Effect31.gen(function* () {
     })).pipe(Effect31.tap((record2) => eventRepository.findByCursor({
       executionId: input.executionId,
       cursor: `${input.executionId}:state:${input.key}:${record2.version}`
-    }).pipe(Effect31.flatMap(Option6.match({ onNone: () => Effect31.void, onSome: eventRepository.notifyAppended })))), Effect31.mapError((cause) => Schema29.is(StateVersionConflict2)(cause) || Schema29.is(StateIdempotencyConflict)(cause) || Schema29.is(ExecutionStateExecutionNotFound)(cause) ? cause : error(cause)));
+    }).pipe(Effect31.flatMap(Option6.match({ onNone: () => Effect31.void, onSome: eventRepository.notifyAppended })))), Effect31.mapError((cause) => Schema30.is(StateVersionConflict2)(cause) || Schema30.is(StateIdempotencyConflict)(cause) || Schema30.is(ExecutionStateExecutionNotFound)(cause) ? cause : error(cause)));
   });
   const remove = Effect31.fn("ExecutionStateRepository.remove")(function* (input) {
     const tenant = yield* current();
@@ -4615,7 +4695,7 @@ var layer20 = Layer27.effect(Service27, Effect31.gen(function* () {
     })).pipe(Effect31.tap((record2) => record2 === undefined ? Effect31.void : eventRepository.findByCursor({
       executionId: input.executionId,
       cursor: `${input.executionId}:state:${input.key}:${record2.version + 1}`
-    }).pipe(Effect31.flatMap(Option6.match({ onNone: () => Effect31.void, onSome: eventRepository.notifyAppended })))), Effect31.mapError((cause) => Schema29.is(StateVersionConflict2)(cause) || Schema29.is(StateIdempotencyConflict)(cause) || Schema29.is(ExecutionStateExecutionNotFound)(cause) ? cause : error(cause)));
+    }).pipe(Effect31.flatMap(Option6.match({ onNone: () => Effect31.void, onSome: eventRepository.notifyAppended })))), Effect31.mapError((cause) => Schema30.is(StateVersionConflict2)(cause) || Schema30.is(StateIdempotencyConflict)(cause) || Schema30.is(ExecutionStateExecutionNotFound)(cause) ? cause : error(cause)));
   });
   const list6 = Effect31.fn("ExecutionStateRepository.list")(function* (input) {
     const tenant = yield* current();
@@ -4630,26 +4710,26 @@ var layer20 = Layer27.effect(Service27, Effect31.gen(function* () {
 }));
 var testLayer22 = (implementation) => Layer27.succeed(Service27, Service27.of(implementation));
 // ../store-sql/src/idempotency/idempotency-repository.ts
-import { Context as Context26, Effect as Effect32, HashMap, Layer as Layer28, Option as Option7, Ref as Ref5, Schema as Schema30, Semaphore as Semaphore3 } from "effect";
+import { Context as Context26, Effect as Effect32, HashMap, Layer as Layer28, Option as Option7, Ref as Ref5, Schema as Schema31, Semaphore as Semaphore3 } from "effect";
 import { SqlClient as SqlClient16 } from "effect/unstable/sql/SqlClient";
-class IdempotencyRepositoryError extends Schema30.TaggedErrorClass()("IdempotencyRepositoryError", {
-  message: Schema30.String
+class IdempotencyRepositoryError extends Schema31.TaggedErrorClass()("IdempotencyRepositoryError", {
+  message: Schema31.String
 }) {
 }
 
 class Service28 extends Context26.Service()("@relayfx/store-sql/idempotency/idempotency-repository/Service") {
 }
-var IdempotencyRow = Schema30.Struct({
-  scope: Schema30.String,
-  operation: Schema30.String,
-  key: Schema30.String,
-  result_json: Schema30.NullishOr(Schema30.Unknown),
-  metadata_json: Schema30.Unknown,
-  created_at: Schema30.Union([Schema30.Date, Schema30.String, Schema30.Finite]),
-  expires_at: Schema30.NullishOr(Schema30.Union([Schema30.Date, Schema30.String, Schema30.Finite]))
+var IdempotencyRow = Schema31.Struct({
+  scope: Schema31.String,
+  operation: Schema31.String,
+  key: Schema31.String,
+  result_json: Schema31.NullishOr(Schema31.Unknown),
+  metadata_json: Schema31.Unknown,
+  created_at: Schema31.Union([Schema31.Date, Schema31.String, Schema31.Finite]),
+  expires_at: Schema31.NullishOr(Schema31.Union([Schema31.Date, Schema31.String, Schema31.Finite]))
 }).annotate({ identifier: "Relay.Idempotency.Row" });
-var AffectedRow = Schema30.Struct({
-  affected: Schema30.Union([Schema30.Finite, Schema30.String, Schema30.BigInt])
+var AffectedRow = Schema31.Struct({
+  affected: Schema31.Union([Schema31.Finite, Schema31.String, Schema31.BigInt])
 }).annotate({ identifier: "Relay.Idempotency.AffectedRow" });
 var operationId = (input) => `${input.scope}:${input.operation}:${input.key}`;
 var metadata5 = (input) => input ?? {};
@@ -4665,8 +4745,8 @@ var toRecord7 = (row) => {
     ...expiresAt === undefined ? {} : { expiresAt }
   };
 };
-var toRepositoryError8 = (error2) => Schema30.is(IdempotencyRepositoryError)(error2) ? error2 : IdempotencyRepositoryError.make({ message: String(error2) });
-var decodeRow8 = (row) => Schema30.decodeUnknownEffect(IdempotencyRow)(row).pipe(Effect32.mapError(toRepositoryError8));
+var toRepositoryError8 = (error2) => Schema31.is(IdempotencyRepositoryError)(error2) ? error2 : IdempotencyRepositoryError.make({ message: String(error2) });
+var decodeRow8 = (row) => Schema31.decodeUnknownEffect(IdempotencyRow)(row).pipe(Effect32.mapError(toRepositoryError8));
 var layer21 = Layer28.effect(Service28, Effect32.gen(function* () {
   const sql = yield* SqlClient16;
   const keyColumn = sql.onDialectOrElse({
@@ -4708,7 +4788,7 @@ var layer21 = Layer28.effect(Service28, Effect32.gen(function* () {
     mysql: () => (tenantId, input) => Effect32.gen(function* () {
       yield* sql`INSERT IGNORE ${claimBody(tenantId, input)}`;
       const rows = yield* sql`SELECT ROW_COUNT() AS affected`;
-      const decoded = yield* Schema30.decodeUnknownEffect(AffectedRow)(rows[0]);
+      const decoded = yield* Schema31.decodeUnknownEffect(AffectedRow)(rows[0]);
       return Number(decoded.affected) > 0;
     }),
     orElse: () => (tenantId, input) => sql`INSERT ${claimBody(tenantId, input)} ON CONFLICT DO NOTHING RETURNING scope`.pipe(Effect32.map((rows) => rows.length > 0))
@@ -4798,34 +4878,34 @@ __export(exports_inbox_repository, {
   Service: () => Service29,
   InboxRepositoryError: () => InboxRepositoryError
 });
-import { Context as Context27, Effect as Effect33, Layer as Layer29, Ref as Ref6, Schema as Schema31 } from "effect";
+import { Context as Context27, Effect as Effect33, Layer as Layer29, Ref as Ref6, Schema as Schema32 } from "effect";
 import { SqlClient as SqlClient17 } from "effect/unstable/sql/SqlClient";
-class InboxRepositoryError extends Schema31.TaggedErrorClass()("InboxRepositoryError", {
-  message: Schema31.String
+class InboxRepositoryError extends Schema32.TaggedErrorClass()("InboxRepositoryError", {
+  message: Schema32.String
 }) {
 }
 
 class Service29 extends Context27.Service()("@relayfx/store-sql/inbox/inbox-repository/Service") {
 }
-var error2 = (e) => Schema31.is(InboxRepositoryError)(e) ? e : InboxRepositoryError.make({
+var error2 = (e) => Schema32.is(InboxRepositoryError)(e) ? e : InboxRepositoryError.make({
   message: `${e.message}: ${String(e.cause)}`
 });
-var DbNumber = Schema31.Union([Schema31.Finite, Schema31.FiniteFromString]);
-var InboxRow = Schema31.Struct({
-  execution_id: Schema31.String,
+var DbNumber = Schema32.Union([Schema32.Finite, Schema32.FiniteFromString]);
+var InboxRow = Schema32.Struct({
+  execution_id: Schema32.String,
   sequence: DbNumber,
-  from_address_id: Schema31.String,
-  envelope_id: Schema31.NullOr(Schema31.String),
-  content_json: Schema31.Unknown,
-  reply_wait_id: Schema31.NullOr(Schema31.String),
-  correlation_key: Schema31.NullOr(Schema31.String),
-  idempotency_key: Schema31.NullOr(Schema31.String),
-  drain_id: Schema31.NullOr(Schema31.String),
-  consumed_at: Schema31.NullOr(Schema31.Union([Schema31.Date, Schema31.String, Schema31.Finite])),
-  metadata_json: Schema31.NullOr(Schema31.Unknown),
-  created_at: Schema31.Union([Schema31.Date, Schema31.String, Schema31.Finite])
-});
-var rowToMessage = (value) => Schema31.decodeUnknownEffect(InboxRow)(value).pipe(Effect33.flatMap((row) => Schema31.decodeUnknownEffect(exports_inbox_schema.Message)({
+  from_address_id: Schema32.String,
+  envelope_id: Schema32.NullOr(Schema32.String),
+  content_json: Schema32.Unknown,
+  reply_wait_id: Schema32.NullOr(Schema32.String),
+  correlation_key: Schema32.NullOr(Schema32.String),
+  idempotency_key: Schema32.NullOr(Schema32.String),
+  drain_id: Schema32.NullOr(Schema32.String),
+  consumed_at: Schema32.NullOr(Schema32.Union([Schema32.Date, Schema32.String, Schema32.Finite])),
+  metadata_json: Schema32.NullOr(Schema32.Unknown),
+  created_at: Schema32.Union([Schema32.Date, Schema32.String, Schema32.Finite])
+});
+var rowToMessage = (value) => Schema32.decodeUnknownEffect(InboxRow)(value).pipe(Effect33.flatMap((row) => Schema32.decodeUnknownEffect(exports_inbox_schema.Message)({
   execution_id: row.execution_id,
   sequence: row.sequence,
   from: row.from_address_id,
@@ -4900,10 +4980,10 @@ var layer22 = Layer29.effect(Service29, Effect33.gen(function* () {
       const old = yield* sql`SELECT message_sequences_json FROM relay_inbox_drains WHERE tenant_id=${tenant} AND execution_id=${input.executionId} AND drain_id=${input.drainId}`;
       let sequences;
       if (old[0] !== undefined)
-        sequences = yield* Schema31.decodeUnknownEffect(Schema31.Array(DbNumber))(decodeJson(old[0].message_sequences_json)).pipe(Effect33.mapError((cause) => InboxRepositoryError.make({ message: String(cause) })));
+        sequences = yield* Schema32.decodeUnknownEffect(Schema32.Array(DbNumber))(decodeJson(old[0].message_sequences_json)).pipe(Effect33.mapError((cause) => InboxRepositoryError.make({ message: String(cause) })));
       else {
         const rows2 = yield* sql`SELECT sequence FROM relay_inbox_messages WHERE tenant_id=${tenant} AND execution_id=${input.executionId} AND consumed_at IS NULL ORDER BY sequence ASC LIMIT ${sql.literal(String(input.maxBatch ?? 100))}`;
-        sequences = yield* Effect33.forEach(rows2, (row) => Schema31.decodeUnknownEffect(Schema31.Struct({ sequence: DbNumber }))(row).pipe(Effect33.map((decoded) => decoded.sequence), Effect33.mapError((cause) => InboxRepositoryError.make({ message: String(cause) }))));
+        sequences = yield* Effect33.forEach(rows2, (row) => Schema32.decodeUnknownEffect(Schema32.Struct({ sequence: DbNumber }))(row).pipe(Effect33.map((decoded) => decoded.sequence), Effect33.mapError((cause) => InboxRepositoryError.make({ message: String(cause) }))));
         if (sequences.length === 0)
           return [];
         yield* sql`UPDATE relay_inbox_messages SET drain_id=${input.drainId}, consumed_at=${timestampParam(sql, input.consumedAt)} WHERE tenant_id=${tenant} AND execution_id=${input.executionId} AND ${sql.in("sequence", sequences)}`;
@@ -4990,10 +5070,10 @@ __export(exports_topic_repository, {
   TopicRepositoryError: () => TopicRepositoryError,
   Service: () => Service30
 });
-import { Context as Context28, Effect as Effect34, Layer as Layer30, Ref as Ref7, Schema as Schema32 } from "effect";
+import { Context as Context28, Effect as Effect34, Layer as Layer30, Ref as Ref7, Schema as Schema33 } from "effect";
 import { SqlClient as SqlClient18 } from "effect/unstable/sql/SqlClient";
-class TopicRepositoryError extends Schema32.TaggedErrorClass()("TopicRepositoryError", {
-  message: Schema32.String
+class TopicRepositoryError extends Schema33.TaggedErrorClass()("TopicRepositoryError", {
+  message: Schema33.String
 }) {
 }
 
@@ -5093,47 +5173,47 @@ __export(exports_memory_repository, {
   MemoryRow: () => MemoryRow,
   MemoryRepositoryError: () => MemoryRepositoryError
 });
-import { Context as Context29, Effect as Effect35, Layer as Layer31, Ref as Ref8, Schema as Schema33 } from "effect";
-import { Prompt as Prompt2 } from "effect/unstable/ai";
+import { Context as Context29, Effect as Effect35, Layer as Layer31, Ref as Ref8, Schema as Schema34 } from "effect";
+import { Prompt as Prompt4 } from "effect/unstable/ai";
 import { SqlClient as SqlClient19 } from "effect/unstable/sql/SqlClient";
-class MemoryRepositoryError extends Schema33.TaggedErrorClass()("MemoryRepositoryError", {
-  message: Schema33.String
+class MemoryRepositoryError extends Schema34.TaggedErrorClass()("MemoryRepositoryError", {
+  message: Schema34.String
 }) {
 }
 
 class Service31 extends Context29.Service()("@relayfx/store-sql/memory/memory-repository/Service") {
 }
 var recallCandidateCap = 1000;
-var MemoryRow = Schema33.Struct({
-  id: Schema33.String,
-  agent: Schema33.String,
-  subject: Schema33.String,
-  embedding: Schema33.Union([Schema33.Array(Schema33.Finite), Schema33.String]),
-  parts_json: Schema33.Unknown,
-  metadata_json: Schema33.Unknown,
-  created_at: Schema33.Union([Schema33.Date, Schema33.String, Schema33.Finite])
+var MemoryRow = Schema34.Struct({
+  id: Schema34.String,
+  agent: Schema34.String,
+  subject: Schema34.String,
+  embedding: Schema34.Union([Schema34.Array(Schema34.Finite), Schema34.String]),
+  parts_json: Schema34.Unknown,
+  metadata_json: Schema34.Unknown,
+  created_at: Schema34.Union([Schema34.Date, Schema34.String, Schema34.Finite])
 }).annotate({ identifier: "Relay.Memory.Row" });
 var toRepositoryError9 = (error4) => MemoryRepositoryError.make({ message: String(error4) });
-var decodeRow9 = (row) => Schema33.decodeUnknownEffect(MemoryRow)(row).pipe(Effect35.mapError(toRepositoryError9));
-var MemoryFileDataWire = Schema33.Union([
-  Schema33.TaggedStruct("String", { value: Schema33.String }),
-  Schema33.TaggedStruct("Bytes", { value: Schema33.Array(Schema33.Finite) }),
-  Schema33.TaggedStruct("Url", { value: Schema33.String })
+var decodeRow9 = (row) => Schema34.decodeUnknownEffect(MemoryRow)(row).pipe(Effect35.mapError(toRepositoryError9));
+var MemoryFileDataWire = Schema34.Union([
+  Schema34.TaggedStruct("String", { value: Schema34.String }),
+  Schema34.TaggedStruct("Bytes", { value: Schema34.Array(Schema34.Finite) }),
+  Schema34.TaggedStruct("Url", { value: Schema34.String })
 ]);
-var MemoryPartWire = Schema33.Union([
-  Schema33.Struct({ type: Schema33.Literal("text"), text: Schema33.String, options: Prompt2.ProviderOptions }),
-  Schema33.Struct({
-    type: Schema33.Literal("file"),
-    mediaType: Schema33.String,
-    fileName: Schema33.optional(Schema33.String),
+var MemoryPartWire = Schema34.Union([
+  Schema34.Struct({ type: Schema34.Literal("text"), text: Schema34.String, options: Prompt4.ProviderOptions }),
+  Schema34.Struct({
+    type: Schema34.Literal("file"),
+    mediaType: Schema34.String,
+    fileName: Schema34.optional(Schema34.String),
     data: MemoryFileDataWire,
-    options: Prompt2.ProviderOptions
+    options: Prompt4.ProviderOptions
   })
 ]);
-var MemoryPartsWire = Schema33.TaggedStruct("RelayMemoryPartsV1", {
-  parts: Schema33.Array(MemoryPartWire)
+var MemoryPartsWire = Schema34.TaggedStruct("RelayMemoryPartsV1", {
+  parts: Schema34.Array(MemoryPartWire)
 });
-var LegacyMemoryParts = Schema33.Array(Schema33.Union([Prompt2.TextPart, Prompt2.FilePart]));
+var LegacyMemoryParts = Schema34.Array(Schema34.Union([Prompt4.TextPart, Prompt4.FilePart]));
 var encodeParts = (parts) => {
   const wireParts = parts.map((part) => {
     if (part.type === "text")
@@ -5149,18 +5229,18 @@ var encodeParts = (parts) => {
       options: part.options
     };
   });
-  return Schema33.encodeSync(MemoryPartsWire)({ _tag: "RelayMemoryPartsV1", parts: wireParts });
+  return Schema34.encodeSync(MemoryPartsWire)({ _tag: "RelayMemoryPartsV1", parts: wireParts });
 };
 var decodeParts = (value) => {
   const decoded = decodeJson(value);
   if (typeof decoded !== "object" || decoded === null || !("_tag" in decoded)) {
-    return Schema33.decodeUnknownEffect(LegacyMemoryParts)(decoded).pipe(Effect35.mapError(toRepositoryError9));
+    return Schema34.decodeUnknownEffect(LegacyMemoryParts)(decoded).pipe(Effect35.mapError(toRepositoryError9));
   }
-  return Schema33.decodeUnknownEffect(MemoryPartsWire)(decoded).pipe(Effect35.map((wire) => wire.parts.map((part) => {
+  return Schema34.decodeUnknownEffect(MemoryPartsWire)(decoded).pipe(Effect35.map((wire) => wire.parts.map((part) => {
     if (part.type === "text")
-      return Prompt2.makePart("text", { text: part.text, options: part.options });
+      return Prompt4.makePart("text", { text: part.text, options: part.options });
     const data = part.data._tag === "String" ? part.data.value : part.data._tag === "Bytes" ? new Uint8Array(part.data.value) : new URL(part.data.value);
-    return Prompt2.makePart("file", {
+    return Prompt4.makePart("file", {
       mediaType: part.mediaType,
       ...part.fileName === undefined ? {} : { fileName: part.fileName },
       data,
@@ -5168,7 +5248,7 @@ var decodeParts = (value) => {
     });
   })), Effect35.mapError(toRepositoryError9));
 };
-var decodeMetadata4 = (value) => Schema33.decodeUnknownEffect(exports_shared_schema.Metadata)(decodeJson(value)).pipe(Effect35.mapError(toRepositoryError9));
+var decodeMetadata4 = (value) => Schema34.decodeUnknownEffect(exports_shared_schema.Metadata)(decodeJson(value)).pipe(Effect35.mapError(toRepositoryError9));
 var parsePgFloatArray = (value) => {
   const body = value.startsWith("{") && value.endsWith("}") ? value.slice(1, -1) : value;
   if (body.length === 0)
@@ -5221,7 +5301,7 @@ var clonePart = (part) => {
   if (part.type !== "file")
     return structuredClone(part);
   const data = typeof part.data === "string" ? part.data : part.data instanceof Uint8Array ? new Uint8Array(part.data) : new URL(part.data.toString());
-  return Prompt2.makePart("file", {
+  return Prompt4.makePart("file", {
     mediaType: part.mediaType,
     ...part.fileName === undefined ? {} : { fileName: part.fileName },
     data,
@@ -5243,7 +5323,7 @@ var layer24 = Layer31.effect(Service31, Effect35.gen(function* () {
   });
   const decodeEmbedding = sql.onDialectOrElse({
     pg: () => (value) => typeof value === "string" ? parsePgFloatArray(value) : value,
-    orElse: () => (value) => typeof value === "string" ? Schema33.decodeUnknownSync(Schema33.fromJsonString(Schema33.Array(Schema33.Finite)))(value) : value
+    orElse: () => (value) => typeof value === "string" ? Schema34.decodeUnknownSync(Schema34.fromJsonString(Schema34.Array(Schema34.Finite)))(value) : value
   });
   const toRecord8 = (row) => Effect35.all({ parts: decodeParts(row.parts_json), metadata: decodeMetadata4(row.metadata_json) }).pipe(Effect35.map(({ metadata: metadata6, parts }) => ({
     id: row.id,
@@ -5409,20 +5489,20 @@ __export(exports_permission_rule_repository, {
   PermissionRuleRow: () => PermissionRuleRow,
   PermissionRuleRepositoryError: () => PermissionRuleRepositoryError
 });
-import { Context as Context30, Effect as Effect36, Layer as Layer32, Schema as Schema34 } from "effect";
+import { Context as Context30, Effect as Effect36, Layer as Layer32, Schema as Schema35 } from "effect";
 import { SqlClient as SqlClient20 } from "effect/unstable/sql/SqlClient";
-class PermissionRuleRepositoryError extends Schema34.TaggedErrorClass()("PermissionRuleRepositoryError", {
-  message: Schema34.String
+class PermissionRuleRepositoryError extends Schema35.TaggedErrorClass()("PermissionRuleRepositoryError", {
+  message: Schema35.String
 }) {
 }
 
 class Service32 extends Context30.Service()("@relayfx/store-sql/permission/permission-rule-repository/Service") {
 }
-var PermissionRuleRow = Schema34.Struct({
-  agent: Schema34.String,
-  scope: Schema34.String,
-  rule_json: Schema34.Unknown,
-  created_at: Schema34.Union([Schema34.Date, Schema34.String, Schema34.Finite])
+var PermissionRuleRow = Schema35.Struct({
+  agent: Schema35.String,
+  scope: Schema35.String,
+  rule_json: Schema35.Unknown,
+  created_at: Schema35.Union([Schema35.Date, Schema35.String, Schema35.Finite])
 }).annotate({ identifier: "Relay.PermissionRule.Row" });
 var toRecord8 = (row) => ({
   agent: row.agent,
@@ -5431,7 +5511,7 @@ var toRecord8 = (row) => ({
   createdAt: fromDbTimestamp(row.created_at)
 });
 var toRepositoryError10 = (error4) => PermissionRuleRepositoryError.make({ message: String(error4) });
-var decodeRow10 = (row) => Schema34.decodeUnknownEffect(PermissionRuleRow)(row).pipe(Effect36.mapError(toRepositoryError10));
+var decodeRow10 = (row) => Schema35.decodeUnknownEffect(PermissionRuleRow)(row).pipe(Effect36.mapError(toRepositoryError10));
 var memoryKey = (agent, scope, pattern) => `${agent}\x00${scope}\x00${pattern}`;
 var layer25 = Layer32.effect(Service32, Effect36.gen(function* () {
   const sql = yield* SqlClient20;
@@ -5528,24 +5608,24 @@ __export(exports_presence_repository, {
   Service: () => Service33,
   PresenceRepositoryError: () => PresenceRepositoryError
 });
-import { Clock as Clock3, Context as Context31, Effect as Effect37, Layer as Layer33, PubSub as PubSub4, Schema as Schema35, Stream as Stream6 } from "effect";
+import { Clock as Clock3, Context as Context31, Effect as Effect37, Layer as Layer33, PubSub as PubSub4, Schema as Schema36, Stream as Stream6 } from "effect";
 import { SqlClient as SqlClient21 } from "effect/unstable/sql/SqlClient";
 var presenceChangedChannel = "relay_presence";
 
-class PresenceRepositoryError extends Schema35.TaggedErrorClass()("PresenceRepositoryError", { message: Schema35.String }) {
+class PresenceRepositoryError extends Schema36.TaggedErrorClass()("PresenceRepositoryError", { message: Schema36.String }) {
 }
 
 class Service33 extends Context31.Service()("@relayfx/store-sql/presence/presence-repository/Service") {
 }
 var pointer = (scope) => `${scope.kind}:${scope.id}`;
 var error4 = (cause) => PresenceRepositoryError.make({ message: String(cause) });
-var Row = Schema35.Struct({
-  id: Schema35.String,
-  scope_kind: Schema35.String,
-  scope_id: Schema35.String,
-  metadata_json: Schema35.Unknown,
-  connected_at: Schema35.Union([Schema35.Date, Schema35.String, Schema35.Finite]),
-  expires_at: Schema35.Union([Schema35.Date, Schema35.String, Schema35.Finite])
+var Row = Schema36.Struct({
+  id: Schema36.String,
+  scope_kind: Schema36.String,
+  scope_id: Schema36.String,
+  metadata_json: Schema36.Unknown,
+  connected_at: Schema36.Union([Schema36.Date, Schema36.String, Schema36.Finite]),
+  expires_at: Schema36.Union([Schema36.Date, Schema36.String, Schema36.Finite])
 });
 var layer26 = Layer33.effect(Service33, Effect37.gen(function* () {
   const sql = yield* SqlClient21;
@@ -5576,7 +5656,7 @@ var layer26 = Layer33.effect(Service33, Effect37.gen(function* () {
     const rows = yield* sql`SELECT id, scope_kind, scope_id, metadata_json, connected_at, expires_at FROM relay_presence
         WHERE tenant_id = ${tenant} AND scope_kind = ${scope.kind} AND scope_id = ${scope.id} AND expires_at > ${now}
         ORDER BY connected_at, id`.pipe(Effect37.mapError(error4));
-    return yield* Effect37.forEach(rows, (value) => Schema35.decodeUnknownEffect(Row)(value).pipe(Effect37.map((row) => ({
+    return yield* Effect37.forEach(rows, (value) => Schema36.decodeUnknownEffect(Row)(value).pipe(Effect37.map((row) => ({
       id: row.id,
       scope: { kind: row.scope_kind, id: row.scope_id },
       metadata: decodeJson(row.metadata_json),
@@ -5658,44 +5738,44 @@ __export(exports_schedule_repository, {
   ScheduleNotFound: () => ScheduleNotFound,
   ScheduleClaimMismatch: () => ScheduleClaimMismatch
 });
-import { Context as Context32, Effect as Effect38, Layer as Layer34, Schema as Schema36 } from "effect";
+import { Context as Context32, Effect as Effect38, Layer as Layer34, Schema as Schema37 } from "effect";
 import { SqlClient as SqlClient22 } from "effect/unstable/sql/SqlClient";
-class ScheduleRepositoryError extends Schema36.TaggedErrorClass()("ScheduleRepositoryError", {
-  message: Schema36.String
+class ScheduleRepositoryError extends Schema37.TaggedErrorClass()("ScheduleRepositoryError", {
+  message: Schema37.String
 }) {
 }
 
-class ScheduleNotFound extends Schema36.TaggedErrorClass()("ScheduleNotFound", {
+class ScheduleNotFound extends Schema37.TaggedErrorClass()("ScheduleNotFound", {
   id: exports_ids_schema.ScheduleId
 }) {
 }
 
-class ScheduleClaimMismatch extends Schema36.TaggedErrorClass()("ScheduleClaimMismatch", {
+class ScheduleClaimMismatch extends Schema37.TaggedErrorClass()("ScheduleClaimMismatch", {
   id: exports_ids_schema.ScheduleId,
-  worker_id: Schema36.String
+  worker_id: Schema37.String
 }) {
 }
 
 class Service34 extends Context32.Service()("@relayfx/store-sql/schedule/schedule-repository/Service") {
 }
-var ScheduleRow = Schema36.Struct({
-  id: Schema36.String,
-  kind: Schema36.String,
-  target_kind: Schema36.String,
-  address_id: Schema36.NullishOr(Schema36.String),
-  wait_id: Schema36.NullishOr(Schema36.String),
-  cron_expr: Schema36.NullishOr(Schema36.String),
-  input_json: Schema36.NullishOr(Schema36.Unknown),
-  state: Schema36.String,
-  next_run_at: Schema36.Union([Schema36.Date, Schema36.String, Schema36.Finite]),
-  attempt: Schema36.Union([Schema36.Finite, Schema36.String, Schema36.BigInt]),
-  claim_owner: Schema36.NullishOr(Schema36.String),
-  claim_expires_at: Schema36.NullishOr(Schema36.Union([Schema36.Date, Schema36.String, Schema36.Finite])),
-  last_error: Schema36.NullishOr(Schema36.String),
-  idempotency_key: Schema36.NullishOr(Schema36.String),
-  metadata_json: Schema36.Unknown,
-  created_at: Schema36.Union([Schema36.Date, Schema36.String, Schema36.Finite]),
-  updated_at: Schema36.Union([Schema36.Date, Schema36.String, Schema36.Finite])
+var ScheduleRow = Schema37.Struct({
+  id: Schema37.String,
+  kind: Schema37.String,
+  target_kind: Schema37.String,
+  address_id: Schema37.NullishOr(Schema37.String),
+  wait_id: Schema37.NullishOr(Schema37.String),
+  cron_expr: Schema37.NullishOr(Schema37.String),
+  input_json: Schema37.NullishOr(Schema37.Unknown),
+  state: Schema37.String,
+  next_run_at: Schema37.Union([Schema37.Date, Schema37.String, Schema37.Finite]),
+  attempt: Schema37.Union([Schema37.Finite, Schema37.String, Schema37.BigInt]),
+  claim_owner: Schema37.NullishOr(Schema37.String),
+  claim_expires_at: Schema37.NullishOr(Schema37.Union([Schema37.Date, Schema37.String, Schema37.Finite])),
+  last_error: Schema37.NullishOr(Schema37.String),
+  idempotency_key: Schema37.NullishOr(Schema37.String),
+  metadata_json: Schema37.Unknown,
+  created_at: Schema37.Union([Schema37.Date, Schema37.String, Schema37.Finite]),
+  updated_at: Schema37.Union([Schema37.Date, Schema37.String, Schema37.Finite])
 }).annotate({ identifier: "Relay.Schedule.Row" });
 var metadata6 = (input) => input ?? {};
 var validationError = (input) => {
@@ -5733,7 +5813,7 @@ var toRecord9 = (row) => {
   };
 };
 var toRepositoryError11 = (error5) => ScheduleRepositoryError.make({ message: String(error5) });
-var decodeRow11 = (row) => Schema36.decodeUnknownEffect(ScheduleRow)(row).pipe(Effect38.mapError(toRepositoryError11));
+var decodeRow11 = (row) => Schema37.decodeUnknownEffect(ScheduleRow)(row).pipe(Effect38.mapError(toRepositoryError11));
 var cancellableStates = new Set(["active", "claimed"]);
 var columnsText = "id, kind, target_kind, address_id, wait_id, cron_expr, input_json, state, next_run_at, attempt, claim_owner, claim_expires_at, last_error, idempotency_key, metadata_json, created_at, updated_at";
 var layer27 = Layer34.effect(Service34, Effect38.gen(function* () {
@@ -6208,68 +6288,31 @@ __export(exports_session_repository, {
   Service: () => Service35,
   DuplicateSession: () => DuplicateSession
 });
-import { Context as Context33, Effect as Effect41, Layer as Layer35, Schema as Schema40 } from "effect";
+import { Context as Context33, Effect as Effect41, Layer as Layer35, Schema as Schema41 } from "effect";
 
 // ../store-sql/src/session/session-entry-records.ts
-import { Effect as Effect39, Schema as Schema37 } from "effect";
-import { Prompt as Prompt3 } from "effect/unstable/ai";
-var sessionEntryRow = Schema37.Struct({
-  id: Schema37.String,
-  session_id: Schema37.String,
-  parent_id: Schema37.Union([Schema37.String, Schema37.Null, Schema37.Undefined]),
-  tag: Schema37.String,
-  payload_json: Schema37.Unknown,
-  created_at: Schema37.Union([Schema37.Date, Schema37.String, Schema37.Finite])
+import { Effect as Effect39, Schema as Schema38 } from "effect";
+var sessionEntryRow = Schema38.Struct({
+  id: Schema38.String,
+  session_id: Schema38.String,
+  parent_id: Schema38.Union([Schema38.String, Schema38.Null, Schema38.Undefined]),
+  tag: Schema38.String,
+  payload_json: Schema38.Unknown,
+  created_at: Schema38.Union([Schema38.Date, Schema38.String, Schema38.Finite])
 }).annotate({ identifier: "Relay.SessionEntry.Row" });
-var FileDataWire = Schema37.Union([
-  Schema37.TaggedStruct("String", { value: Schema37.String }),
-  Schema37.TaggedStruct("Bytes", { value: Schema37.Array(Schema37.Finite) }),
-  Schema37.TaggedStruct("Url", { value: Schema37.String })
-]);
-var CheckpointPromptWire = Schema37.TaggedStruct("RelaySessionCheckpointPromptV1", {
+var CheckpointPromptWire = Schema38.TaggedStruct("RelaySessionCheckpointPromptV1", {
   prompt: exports_shared_schema.JsonValue
 });
-var fileDataToWire = (data) => typeof data === "string" ? { _tag: "String", value: data } : data instanceof Uint8Array ? { _tag: "Bytes", value: Array.from(data) } : { _tag: "Url", value: data.toString() };
-var encodePromptMessage = (prompt, message, messageIndex) => ({
-  ...message,
-  content: Array.isArray(message.content) ? message.content.map((part, partIndex) => {
-    const actualContent = prompt.content[messageIndex]?.content;
-    const actualPart = Array.isArray(actualContent) ? actualContent[partIndex] : undefined;
-    return part.type === "file" && actualPart?.type === "file" ? { ...part, data: fileDataToWire(actualPart.data) } : part;
-  }) : message.content
-});
-var encodePromptContent = (prompt) => {
-  const encoded = Schema37.encodeSync(Prompt3.Prompt)(prompt);
-  return Schema37.decodeUnknownSync(exports_shared_schema.JsonValue)({
-    content: encoded.content.map((message, messageIndex) => encodePromptMessage(prompt, message, messageIndex))
-  });
-};
-var decodePromptContent = (value) => {
-  const content = typeof value === "object" && value !== null && !Array.isArray(value) && "content" in value ? value.content : undefined;
-  const decodedContent = Array.isArray(content) ? content.map((message) => {
-    if (typeof message !== "object" || message === null || Array.isArray(message))
-      return message;
-    const messageContent = message.content;
-    return {
-      ...message,
-      content: Array.isArray(messageContent) ? messageContent.map((part) => {
-        if (typeof part !== "object" || part === null || Array.isArray(part) || part.type !== "file") {
-          return part;
-        }
-        const data = Schema37.decodeUnknownSync(FileDataWire)(part.data);
-        return {
-          ...part,
-          data: data._tag === "String" ? data.value : data._tag === "Bytes" ? Uint8Array.from(data.value) : new URL(data.value)
-        };
-      }) : messageContent
-    };
-  }) : content;
-  return Schema37.decodeUnknownSync(Prompt3.Prompt)({ content: decodedContent });
-};
-var encodeCheckpointPrompt = (prompt) => Schema37.encodeSync(CheckpointPromptWire)({
+var encodeCheckpointPrompt = (prompt) => Schema38.encodeSync(CheckpointPromptWire)({
   _tag: "RelaySessionCheckpointPromptV1",
-  prompt: encodePromptContent(prompt)
-});
+  prompt: encodePrompt(prompt)
+});
+var CheckpointTelemetryWire = Schema38.Array(exports_model_telemetry.Event);
+var encodeCheckpointTelemetry = Schema38.encodeSync(CheckpointTelemetryWire);
+var decodeCheckpointTelemetry = Schema38.decodeUnknownSync(CheckpointTelemetryWire);
+var CheckpointCommitWire = exports_model_telemetry.CompactionCommit;
+var encodeCheckpointCommit = Schema38.encodeSync(CheckpointCommitWire);
+var decodeCheckpointCommit = Schema38.decodeUnknownSync(CheckpointCommitWire);
 var comparableEntry = (entry) => {
   const { createdAt: _createdAt, ...value } = entry;
   return value;
@@ -6303,6 +6346,8 @@ var appendToRecord = (input) => {
         _tag: "Compaction",
         version: 2,
         projectedHistory: input.input.projectedHistory,
+        telemetry: input.input.telemetry,
+        ...input.input.compactionCommit === undefined ? {} : { compactionCommit: input.input.compactionCommit },
         ...input.input.summary === undefined ? {} : { summary: input.input.summary }
       } : {
         ...base,
@@ -6316,13 +6361,13 @@ var appendToRecord = (input) => {
 };
 var makeSessionEntryRecords = (errors) => {
   const { SessionRepositoryError, SessionConflict } = errors;
-  const decodeCheckpointPrompt = (value) => Schema37.decodeUnknownEffect(CheckpointPromptWire)(value).pipe(Effect39.flatMap((wire) => Effect39.try({
-    try: () => decodePromptContent(wire.prompt),
+  const decodeCheckpointPrompt = (value) => Schema38.decodeUnknownEffect(CheckpointPromptWire)(value).pipe(Effect39.flatMap((wire) => Effect39.try({
+    try: () => decodePrompt(wire.prompt),
     catch: (error5) => SessionRepositoryError.make({ message: `Invalid Session checkpoint prompt: ${String(error5)}` })
-  })), Effect39.mapError((error5) => Schema37.is(SessionRepositoryError)(error5) ? error5 : SessionRepositoryError.make({ message: `Invalid Session checkpoint prompt: ${String(error5)}` })));
+  })), Effect39.mapError((error5) => Schema38.is(SessionRepositoryError)(error5) ? error5 : SessionRepositoryError.make({ message: `Invalid Session checkpoint prompt: ${String(error5)}` })));
   const clonePrompt = (prompt) => {
-    const wire = prompt.pipe(encodeCheckpointPrompt, Schema37.decodeUnknownSync(CheckpointPromptWire));
-    return decodePromptContent(wire.prompt);
+    const wire = prompt.pipe(encodeCheckpointPrompt, Schema38.decodeUnknownSync(CheckpointPromptWire));
+    return decodePrompt(wire.prompt);
   };
   const payloadFromInput = (input) => {
     switch (input._tag) {
@@ -6367,6 +6412,8 @@ var makeSessionEntryRecords = (errors) => {
         return input.version === 2 ? {
           version: 2,
           projectedHistory: encodeCheckpointPrompt(input.projectedHistory),
+          telemetry: encodeCheckpointTelemetry(input.telemetry),
+          ...input.compactionCommit === undefined ? {} : { compactionCommit: encodeCheckpointCommit(input.compactionCommit) },
           ...input.summary === undefined ? {} : { summary: input.summary },
           ...input.metadata === undefined ? {} : { metadata: input.metadata }
         } : {
@@ -6436,11 +6483,22 @@ var makeSessionEntryRecords = (errors) => {
           summary: String(payload.summary ?? "")
         });
       case "Compaction":
-        return payload.version === 2 ? decodeCheckpointPrompt(payload.projectedHistory).pipe(Effect39.map((projectedHistory) => ({
+        return payload.version === 2 ? decodeCheckpointPrompt(payload.projectedHistory).pipe(Effect39.flatMap((projectedHistory) => Effect39.try({
+          try: () => ({
+            projectedHistory,
+            telemetry: payload.telemetry === undefined ? [] : decodeCheckpointTelemetry(payload.telemetry),
+            compactionCommit: payload.compactionCommit === undefined ? undefined : decodeCheckpointCommit(payload.compactionCommit)
+          }),
+          catch: (error5) => SessionRepositoryError.make({
+            message: `Invalid Session checkpoint telemetry: ${String(error5)}`
+          })
+        })), Effect39.map(({ projectedHistory, telemetry, compactionCommit }) => ({
           ...base,
           _tag: "Compaction",
           version: 2,
           projectedHistory,
+          telemetry,
+          ...compactionCommit === undefined ? {} : { compactionCommit },
           ...payload.summary === undefined ? {} : { summary: String(payload.summary) }
         }))) : Effect39.succeed({
           ...base,
@@ -6459,9 +6517,19 @@ var makeSessionEntryRecords = (errors) => {
     }
   };
   const promptEquivalence = (left, right) => exports_shared_schema.canonicalEquals(encodeCheckpointPrompt(left), encodeCheckpointPrompt(right));
+  const telemetryEquivalence = (left, right) => exports_shared_schema.canonicalEquals(encodeCheckpointTelemetry(left), encodeCheckpointTelemetry(right));
+  const commitEquivalence = (left, right) => {
+    if (left._tag !== "Compaction" || left.version !== 2 || right._tag !== "Compaction" || right.version !== 2) {
+      return false;
+    }
+    if (left.compactionCommit === undefined || right.compactionCommit === undefined) {
+      return left.compactionCommit === right.compactionCommit;
+    }
+    return exports_shared_schema.canonicalEquals(encodeCheckpointCommit(left.compactionCommit), encodeCheckpointCommit(right.compactionCommit));
+  };
   const sameEntry = (left, right) => {
     if (left._tag === "Compaction" && left.version === 2 && right._tag === "Compaction" && right.version === 2) {
-      return left.id === right.id && left.sessionId === right.sessionId && left.parentId === right.parentId && left.summary === right.summary && promptEquivalence(left.projectedHistory, right.projectedHistory);
+      return left.id === right.id && left.sessionId === right.sessionId && left.parentId === right.parentId && left.summary === right.summary && promptEquivalence(left.projectedHistory, right.projectedHistory) && telemetryEquivalence(left.telemetry, right.telemetry) && commitEquivalence(left, right);
     }
     return exports_shared_schema.canonicalEquals(comparableEntry(left), comparableEntry(right));
   };
@@ -6491,25 +6559,25 @@ var makeSessionEntryRecords = (errors) => {
 };
 
 // ../store-sql/src/session/session-records.ts
-import { Effect as Effect40, Schema as Schema39 } from "effect";
+import { Effect as Effect40, Schema as Schema40 } from "effect";
 import { SqlClient as SqlClient23 } from "effect/unstable/sql/SqlClient";
 
 // ../store-sql/src/session/session-row.ts
-import { Schema as Schema38 } from "effect";
-var sessionRow = Schema38.Struct({
-  id: Schema38.String,
-  root_address_id: Schema38.String,
-  leaf_entry_id: Schema38.Union([Schema38.String, Schema38.Null, Schema38.Undefined]),
-  owner_execution_id: Schema38.Union([Schema38.String, Schema38.Null, Schema38.Undefined]),
-  owner_epoch: Schema38.Union([Schema38.Finite, Schema38.String, Schema38.BigInt]),
-  owner_released: Schema38.Union([Schema38.Boolean, Schema38.Finite, Schema38.String, Schema38.BigInt]),
-  metadata_json: Schema38.Unknown,
-  created_at: Schema38.Union([Schema38.Date, Schema38.String, Schema38.Finite]),
-  updated_at: Schema38.Union([Schema38.Date, Schema38.String, Schema38.Finite])
+import { Schema as Schema39 } from "effect";
+var sessionRow = Schema39.Struct({
+  id: Schema39.String,
+  root_address_id: Schema39.String,
+  leaf_entry_id: Schema39.Union([Schema39.String, Schema39.Null, Schema39.Undefined]),
+  owner_execution_id: Schema39.Union([Schema39.String, Schema39.Null, Schema39.Undefined]),
+  owner_epoch: Schema39.Union([Schema39.Finite, Schema39.String, Schema39.BigInt]),
+  owner_released: Schema39.Union([Schema39.Boolean, Schema39.Finite, Schema39.String, Schema39.BigInt]),
+  metadata_json: Schema39.Unknown,
+  created_at: Schema39.Union([Schema39.Date, Schema39.String, Schema39.Finite]),
+  updated_at: Schema39.Union([Schema39.Date, Schema39.String, Schema39.Finite])
 }).annotate({ identifier: "Relay.Session.Row" });
 var releasedFlag = (value) => value === true || value === 1 || value === "1" || value === 1n || value === "true";
-var CountRow = Schema38.Struct({
-  value: Schema38.Union([Schema38.Finite, Schema38.String, Schema38.BigInt])
+var CountRow = Schema39.Struct({
+  value: Schema39.Union([Schema39.Finite, Schema39.String, Schema39.BigInt])
 }).annotate({ identifier: "Relay.SessionEntry.CountRow" });
 var metadata7 = (input) => input ?? {};
 var toSessionRecord = (row) => ({
@@ -6588,9 +6656,9 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
       return toRepositoryError12(error5);
     }));
   }
-  const decodeSessionRow = (row) => Schema39.decodeUnknownEffect(sessionRow)(row).pipe(Effect40.mapError(toRepositoryError12));
-  const decodeEntryRow = (row) => Schema39.decodeUnknownEffect(sessionEntryRow)(row).pipe(Effect40.mapError(toRepositoryError12));
-  const decodeCountRow = (row) => Schema39.decodeUnknownEffect(CountRow)(row).pipe(Effect40.mapError(toRepositoryError12));
+  const decodeSessionRow = (row) => Schema40.decodeUnknownEffect(sessionRow)(row).pipe(Effect40.mapError(toRepositoryError12));
+  const decodeEntryRow = (row) => Schema40.decodeUnknownEffect(sessionEntryRow)(row).pipe(Effect40.mapError(toRepositoryError12));
+  const decodeCountRow = (row) => Schema40.decodeUnknownEffect(CountRow)(row).pipe(Effect40.mapError(toRepositoryError12));
   const selectSessionByKey = (tenantId, id) => sql`
       SELECT id, root_address_id, leaf_entry_id, owner_execution_id, owner_epoch, owner_released, metadata_json, created_at, updated_at
       FROM relay_sessions
@@ -6824,6 +6892,8 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
           _tag: "Compaction",
           version: 2,
           projectedHistory: input.projectedHistory,
+          telemetry: input.telemetry,
+          ...input.compactionCommit === undefined ? {} : { compactionCommit: input.compactionCommit },
           ...input.summary === undefined ? {} : { summary: input.summary }
         },
         createdAt: input.createdAt
@@ -6914,19 +6984,19 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
 });
 
 // ../store-sql/src/session/session-repository.ts
-class SessionRepositoryError extends Schema40.TaggedErrorClass()("SessionRepositoryError", {
-  message: Schema40.String
+class SessionRepositoryError extends Schema41.TaggedErrorClass()("SessionRepositoryError", {
+  message: Schema41.String
 }) {
 }
 
-class DuplicateSession extends Schema40.TaggedErrorClass()("DuplicateSession", {
+class DuplicateSession extends Schema41.TaggedErrorClass()("DuplicateSession", {
   id: exports_ids_schema.SessionId
 }) {
 }
 
-class SessionConflict extends Schema40.TaggedErrorClass()("SessionConflict", {
-  reason: Schema40.Literals(["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path", "fenced"]),
-  message: Schema40.String
+class SessionConflict extends Schema41.TaggedErrorClass()("SessionConflict", {
+  reason: Schema41.Literals(["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path", "fenced"]),
+  message: Schema41.String
 }) {
 }
 
@@ -7093,6 +7163,8 @@ var memoryLayer26 = Layer35.sync(Service35, () => {
           _tag: "Compaction",
           version: 2,
           projectedHistory: input.projectedHistory,
+          telemetry: input.telemetry,
+          ...input.compactionCommit === undefined ? {} : { compactionCommit: input.compactionCommit },
           ...input.summary === undefined ? {} : { summary: input.summary }
         },
         createdAt: input.createdAt
@@ -7216,36 +7288,36 @@ __export(exports_skill_definition_repository, {
   Service: () => Service36,
   ExecutionSkillPinRow: () => ExecutionSkillPinRow
 });
-import { Context as Context34, Effect as Effect42, HashSet, Layer as Layer36, Schema as Schema41, Semaphore as Semaphore4 } from "effect";
+import { Context as Context34, Effect as Effect42, HashSet, Layer as Layer36, Schema as Schema42, Semaphore as Semaphore4 } from "effect";
 import { SqlClient as SqlClient24 } from "effect/unstable/sql/SqlClient";
-class SkillDefinitionRepositoryError extends Schema41.TaggedErrorClass()("SkillDefinitionRepositoryError", {
-  message: Schema41.String
+class SkillDefinitionRepositoryError extends Schema42.TaggedErrorClass()("SkillDefinitionRepositoryError", {
+  message: Schema42.String
 }) {
 }
 
 class Service36 extends Context34.Service()("@relayfx/store-sql/skill/skill-definition-repository/Service") {
 }
-var SkillDefinitionRow = Schema41.Struct({
-  id: Schema41.String,
-  current_revision: Schema41.Finite,
-  definition_json: Schema41.Unknown,
-  created_at: Schema41.Union([Schema41.Date, Schema41.String, Schema41.Finite]),
-  updated_at: Schema41.Union([Schema41.Date, Schema41.String, Schema41.Finite])
+var SkillDefinitionRow = Schema42.Struct({
+  id: Schema42.String,
+  current_revision: Schema42.Finite,
+  definition_json: Schema42.Unknown,
+  created_at: Schema42.Union([Schema42.Date, Schema42.String, Schema42.Finite]),
+  updated_at: Schema42.Union([Schema42.Date, Schema42.String, Schema42.Finite])
 }).annotate({ identifier: "Relay.SkillDefinition.Row" });
-var SkillDefinitionRevisionRow = Schema41.Struct({
-  skill_definition_id: Schema41.String,
-  revision: Schema41.Finite,
-  definition_json: Schema41.Unknown,
-  created_at: Schema41.Union([Schema41.Date, Schema41.String, Schema41.Finite])
+var SkillDefinitionRevisionRow = Schema42.Struct({
+  skill_definition_id: Schema42.String,
+  revision: Schema42.Finite,
+  definition_json: Schema42.Unknown,
+  created_at: Schema42.Union([Schema42.Date, Schema42.String, Schema42.Finite])
 }).annotate({ identifier: "Relay.SkillDefinitionRevision.Row" });
-var ExecutionSkillPinRow = Schema41.Struct({
-  execution_id: Schema41.String,
-  skill_definition_id: Schema41.String,
-  skill_definition_revision: Schema41.Finite,
-  skill_definition_snapshot_json: Schema41.Unknown,
-  created_at: Schema41.Union([Schema41.Date, Schema41.String, Schema41.Finite])
+var ExecutionSkillPinRow = Schema42.Struct({
+  execution_id: Schema42.String,
+  skill_definition_id: Schema42.String,
+  skill_definition_revision: Schema42.Finite,
+  skill_definition_snapshot_json: Schema42.Unknown,
+  created_at: Schema42.Union([Schema42.Date, Schema42.String, Schema42.Finite])
 }).annotate({ identifier: "Relay.ExecutionSkillPin.Row" });
-var cloneDefinition3 = (definition) => Schema41.decodeUnknownSync(exports_skill_schema.Definition)(globalThis.structuredClone(definition));
+var cloneDefinition3 = (definition) => Schema42.decodeUnknownSync(exports_skill_schema.Definition)(globalThis.structuredClone(definition));
 var toRecord10 = (row) => ({
   id: exports_ids_schema.SkillDefinitionId.make(row.id),
   currentRevision: row.current_revision,
@@ -7301,11 +7373,11 @@ var missingSkillMessage = (requested, records) => {
   return `Skill definition not found: ${requested.find((id) => !HashSet.has(found, id)) ?? requested[0]}`;
 };
 var toRepositoryError12 = (error5) => SkillDefinitionRepositoryError.make({ message: String(error5) });
-var mapPutError2 = (error5) => Schema41.is(SkillDefinitionRepositoryError)(error5) ? error5 : toRepositoryError12(error5);
-var isUniqueViolation = (error5) => !Schema41.is(SkillDefinitionRepositoryError)(error5) && /unique|duplicate/i.test(String(error5));
-var decodeRow12 = (row) => Schema41.decodeUnknownEffect(SkillDefinitionRow)(row).pipe(Effect42.mapError(toRepositoryError12));
-var decodeRevisionRow2 = (row) => Schema41.decodeUnknownEffect(SkillDefinitionRevisionRow)(row).pipe(Effect42.mapError(toRepositoryError12));
-var decodePinRow = (row) => Schema41.decodeUnknownEffect(ExecutionSkillPinRow)(row).pipe(Effect42.mapError(toRepositoryError12));
+var mapPutError2 = (error5) => Schema42.is(SkillDefinitionRepositoryError)(error5) ? error5 : toRepositoryError12(error5);
+var isUniqueViolation = (error5) => !Schema42.is(SkillDefinitionRepositoryError)(error5) && /unique|duplicate/i.test(String(error5));
+var decodeRow12 = (row) => Schema42.decodeUnknownEffect(SkillDefinitionRow)(row).pipe(Effect42.mapError(toRepositoryError12));
+var decodeRevisionRow2 = (row) => Schema42.decodeUnknownEffect(SkillDefinitionRevisionRow)(row).pipe(Effect42.mapError(toRepositoryError12));
+var decodePinRow = (row) => Schema42.decodeUnknownEffect(ExecutionSkillPinRow)(row).pipe(Effect42.mapError(toRepositoryError12));
 var layer29 = Layer36.effect(Service36, Effect42.gen(function* () {
   const sql = yield* SqlClient24;
   const columns3 = sql.literal(["id", "current_revision", "definition_json", "created_at", "updated_at"].join(", "));
@@ -7642,37 +7714,37 @@ __export(exports_steering_repository, {
   SteeringDrainRow: () => SteeringDrainRow,
   Service: () => Service37
 });
-import { Context as Context35, Effect as Effect43, Layer as Layer37, Ref as Ref9, Schema as Schema42 } from "effect";
+import { Context as Context35, Effect as Effect43, Layer as Layer37, Ref as Ref9, Schema as Schema43 } from "effect";
 import { SqlClient as SqlClient25 } from "effect/unstable/sql/SqlClient";
-class SteeringRepositoryError extends Schema42.TaggedErrorClass()("SteeringRepositoryError", {
-  message: Schema42.String
+class SteeringRepositoryError extends Schema43.TaggedErrorClass()("SteeringRepositoryError", {
+  message: Schema43.String
 }) {
 }
 
 class Service37 extends Context35.Service()("@relayfx/store-sql/steering/steering-repository/Service") {
 }
-var SteeringKindSchema = Schema42.Literals(["steering", "follow_up"]);
-var DbTimestamp4 = Schema42.Union([Schema42.Date, Schema42.String, Schema42.Finite]);
-var SteeringMessageRow = Schema42.Struct({
-  execution_id: Schema42.String,
+var SteeringKindSchema = Schema43.Literals(["steering", "follow_up"]);
+var DbTimestamp4 = Schema43.Union([Schema43.Date, Schema43.String, Schema43.Finite]);
+var SteeringMessageRow = Schema43.Struct({
+  execution_id: Schema43.String,
   kind: SteeringKindSchema,
-  sequence: Schema42.Union([Schema42.Finite, Schema42.String]),
-  content_json: Schema42.Unknown,
-  drain_id: Schema42.NullishOr(Schema42.String),
-  consumed_at: Schema42.NullishOr(DbTimestamp4),
+  sequence: Schema43.Union([Schema43.Finite, Schema43.String]),
+  content_json: Schema43.Unknown,
+  drain_id: Schema43.NullishOr(Schema43.String),
+  consumed_at: Schema43.NullishOr(DbTimestamp4),
   created_at: DbTimestamp4
 }).annotate({ identifier: "Relay.SteeringMessage.Row" });
-var SteeringDrainRow = Schema42.Struct({
-  execution_id: Schema42.String,
+var SteeringDrainRow = Schema43.Struct({
+  execution_id: Schema43.String,
   kind: SteeringKindSchema,
-  drain_id: Schema42.String,
-  message_sequences_json: Schema42.Unknown,
+  drain_id: Schema43.String,
+  message_sequences_json: Schema43.Unknown,
   created_at: DbTimestamp4
 }).annotate({ identifier: "Relay.SteeringDrain.Row" });
 var toRepositoryError13 = (error5) => SteeringRepositoryError.make({ message: String(error5) });
-var mapTransactionError = (effect) => effect.pipe(Effect43.mapError((error5) => Schema42.is(SteeringRepositoryError)(error5) ? error5 : toRepositoryError13(error5)));
-var decodeMessageRow = (row) => Schema42.decodeUnknownEffect(SteeringMessageRow)(row).pipe(Effect43.mapError(toRepositoryError13));
-var decodeDrainRow = (row) => Schema42.decodeUnknownEffect(SteeringDrainRow)(row).pipe(Effect43.mapError(toRepositoryError13));
+var mapTransactionError = (effect) => effect.pipe(Effect43.mapError((error5) => Schema43.is(SteeringRepositoryError)(error5) ? error5 : toRepositoryError13(error5)));
+var decodeMessageRow = (row) => Schema43.decodeUnknownEffect(SteeringMessageRow)(row).pipe(Effect43.mapError(toRepositoryError13));
+var decodeDrainRow = (row) => Schema43.decodeUnknownEffect(SteeringDrainRow)(row).pipe(Effect43.mapError(toRepositoryError13));
 var toMessageRecord = (row) => {
   const consumedAt = fromNullableDbTimestamp(row.consumed_at);
   return {
@@ -7981,29 +8053,29 @@ __export(exports_tool_call_repository, {
   DuplicateToolResult: () => DuplicateToolResult,
   DuplicateToolCall: () => DuplicateToolCall
 });
-import { Context as Context36, Effect as Effect47, Layer as Layer38, Schema as Schema46 } from "effect";
+import { Context as Context36, Effect as Effect47, Layer as Layer38, Schema as Schema47 } from "effect";
 import { dual } from "effect/Function";
 
 // ../store-sql/src/tool/tool-call-records.ts
-import { Effect as Effect46, Schema as Schema45 } from "effect";
+import { Effect as Effect46, Schema as Schema46 } from "effect";
 import { SqlClient as SqlClient26 } from "effect/unstable/sql/SqlClient";
 import { isSqlError as isSqlError2 } from "effect/unstable/sql/SqlError";
 
 // ../store-sql/src/tool/tool-attempt-records.ts
-import { Effect as Effect44, Schema as Schema43 } from "effect";
-var toolAttemptRow = Schema43.Struct({
-  id: Schema43.String,
-  tool_call_id: Schema43.String,
-  attempt_number: Schema43.Union([Schema43.Finite, Schema43.String, Schema43.BigInt]),
-  state: Schema43.String,
-  worker_id: Schema43.NullishOr(Schema43.String),
-  claim_expires_at: Schema43.NullishOr(Schema43.Union([Schema43.Date, Schema43.String, Schema43.Finite])),
-  error: Schema43.NullishOr(Schema43.String),
-  created_at: Schema43.Union([Schema43.Date, Schema43.String, Schema43.Finite]),
-  completed_at: Schema43.NullishOr(Schema43.Union([Schema43.Date, Schema43.String, Schema43.Finite]))
+import { Effect as Effect44, Schema as Schema44 } from "effect";
+var toolAttemptRow = Schema44.Struct({
+  id: Schema44.String,
+  tool_call_id: Schema44.String,
+  attempt_number: Schema44.Union([Schema44.Finite, Schema44.String, Schema44.BigInt]),
+  state: Schema44.String,
+  worker_id: Schema44.NullishOr(Schema44.String),
+  claim_expires_at: Schema44.NullishOr(Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite])),
+  error: Schema44.NullishOr(Schema44.String),
+  created_at: Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite]),
+  completed_at: Schema44.NullishOr(Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite]))
 }).annotate({ identifier: "Relay.ToolAttempt.Row" });
-var MaxAttemptRow = Schema43.Struct({
-  max_attempt: Schema43.NullishOr(Schema43.Union([Schema43.Finite, Schema43.String, Schema43.BigInt]))
+var MaxAttemptRow = Schema44.Struct({
+  max_attempt: Schema44.NullishOr(Schema44.Union([Schema44.Finite, Schema44.String, Schema44.BigInt]))
 });
 var toolAttemptId = (attemptNumber) => exports_ids_schema.ToolAttemptId.make(`tool-attempt:${attemptNumber}`);
 var makeToolAttemptRecordOperations = ({
@@ -8027,15 +8099,15 @@ var makeToolAttemptRecordOperations = ({
     id: exports_ids_schema.ToolAttemptId.make(row.id),
     callId: exports_ids_schema.ToolCallId.make(row.tool_call_id),
     attemptNumber: Number(row.attempt_number),
-    state: Schema43.decodeUnknownSync(exports_tool_schema.AttemptState)(row.state),
+    state: Schema44.decodeUnknownSync(exports_tool_schema.AttemptState)(row.state),
     ...row.worker_id === null || row.worker_id === undefined ? {} : { workerId: row.worker_id },
     ...row.claim_expires_at === null || row.claim_expires_at === undefined ? {} : { claimExpiresAt: fromDbTimestamp(row.claim_expires_at) },
     ...row.error === null || row.error === undefined ? {} : { error: row.error },
     createdAt: fromDbTimestamp(row.created_at),
     ...row.completed_at === null || row.completed_at === undefined ? {} : { completedAt: fromDbTimestamp(row.completed_at) }
   });
-  const decodeAttemptRow = (row) => Schema43.decodeUnknownEffect(toolAttemptRow)(row).pipe(Effect44.mapError(toRepositoryError14));
-  const decodeMaxAttemptRow = (row) => Schema43.decodeUnknownEffect(Schema43.UndefinedOr(MaxAttemptRow))(row).pipe(Effect44.mapError(toRepositoryError14));
+  const decodeAttemptRow = (row) => Schema44.decodeUnknownEffect(toolAttemptRow)(row).pipe(Effect44.mapError(toRepositoryError14));
+  const decodeMaxAttemptRow = (row) => Schema44.decodeUnknownEffect(Schema44.UndefinedOr(MaxAttemptRow))(row).pipe(Effect44.mapError(toRepositoryError14));
   const selectAttempts = (tenantId, executionId, callId) => sql`
     SELECT ${attemptColumns}
     FROM relay_tool_attempts
@@ -8118,13 +8190,13 @@ var makeToolAttemptRecordOperations = ({
 };
 
 // ../store-sql/src/tool/tool-work-operations.ts
-import { Effect as Effect45, Schema as Schema44 } from "effect";
-var ExpiredCallRow = Schema44.Struct({
-  id: Schema44.String,
-  execution_id: Schema44.String,
-  active_attempt_id: Schema44.NullishOr(Schema44.String)
+import { Effect as Effect45, Schema as Schema45 } from "effect";
+var ExpiredCallRow = Schema45.Struct({
+  id: Schema45.String,
+  execution_id: Schema45.String,
+  active_attempt_id: Schema45.NullishOr(Schema45.String)
 });
-var IdRow = Schema44.Struct({ id: Schema44.String, execution_id: Schema44.String });
+var IdRow = Schema45.Struct({ id: Schema45.String, execution_id: Schema45.String });
 var makeToolWorkOperations = ({
   records,
   attempts,
@@ -8287,7 +8359,7 @@ var makeToolWorkOperations = ({
           WHERE tenant_id = ${tenantId} AND placement_kind = 'remote' AND placement_key = ${input.queue}
             AND state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ${ts(input.now)}
         `.pipe(Effect45.mapError(toRepositoryError14));
-      const expired = yield* Schema44.decodeUnknownEffect(Schema44.Array(ExpiredCallRow))(expiredRows).pipe(Effect45.mapError(toRepositoryError14));
+      const expired = yield* Schema45.decodeUnknownEffect(Schema45.Array(ExpiredCallRow))(expiredRows).pipe(Effect45.mapError(toRepositoryError14));
       for (const row of expired) {
         const executionId2 = exports_ids_schema.ExecutionId.make(row.execution_id);
         if (row.active_attempt_id !== null && row.active_attempt_id !== undefined) {
@@ -8301,7 +8373,7 @@ var makeToolWorkOperations = ({
           `.pipe(Effect45.mapError(toRepositoryError14));
       }
       const candidateRows = yield* selectClaimCandidate(tenantId, input).pipe(Effect45.mapError(toRepositoryError14));
-      const candidates = yield* Schema44.decodeUnknownEffect(Schema44.Array(IdRow))(candidateRows).pipe(Effect45.mapError(toRepositoryError14));
+      const candidates = yield* Schema45.decodeUnknownEffect(Schema45.Array(IdRow))(candidateRows).pipe(Effect45.mapError(toRepositoryError14));
       const candidate = candidates[0];
       if (candidate === undefined)
         return;
@@ -8476,54 +8548,54 @@ var makeToolWorkOperations = ({
 };
 
 // ../store-sql/src/tool/tool-call-records.ts
-var toolCallRow = Schema45.Struct({
-  id: Schema45.String,
-  execution_id: Schema45.String,
-  name: Schema45.String,
-  input_json: Schema45.Unknown,
-  definition_json: Schema45.NullishOr(Schema45.Unknown),
-  placement_kind: Schema45.String,
-  placement_key: Schema45.NullishOr(Schema45.String),
-  state: Schema45.String,
-  wait_id: Schema45.NullishOr(Schema45.String),
-  idempotency_key: Schema45.String,
-  available_at: Schema45.Union([Schema45.Date, Schema45.String, Schema45.Finite]),
-  active_attempt_id: Schema45.NullishOr(Schema45.String),
-  claim_owner: Schema45.NullishOr(Schema45.String),
-  claimed_at: Schema45.NullishOr(Schema45.Union([Schema45.Date, Schema45.String, Schema45.Finite])),
-  claim_expires_at: Schema45.NullishOr(Schema45.Union([Schema45.Date, Schema45.String, Schema45.Finite])),
-  external_outcome_json: Schema45.NullishOr(Schema45.Unknown),
-  external_outcome_at: Schema45.NullishOr(Schema45.Union([Schema45.Date, Schema45.String, Schema45.Finite])),
-  metadata_json: Schema45.Unknown,
-  created_at: Schema45.Union([Schema45.Date, Schema45.String, Schema45.Finite]),
-  updated_at: Schema45.Union([Schema45.Date, Schema45.String, Schema45.Finite])
+var toolCallRow = Schema46.Struct({
+  id: Schema46.String,
+  execution_id: Schema46.String,
+  name: Schema46.String,
+  input_json: Schema46.Unknown,
+  definition_json: Schema46.NullishOr(Schema46.Unknown),
+  placement_kind: Schema46.String,
+  placement_key: Schema46.NullishOr(Schema46.String),
+  state: Schema46.String,
+  wait_id: Schema46.NullishOr(Schema46.String),
+  idempotency_key: Schema46.String,
+  available_at: Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite]),
+  active_attempt_id: Schema46.NullishOr(Schema46.String),
+  claim_owner: Schema46.NullishOr(Schema46.String),
+  claimed_at: Schema46.NullishOr(Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite])),
+  claim_expires_at: Schema46.NullishOr(Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite])),
+  external_outcome_json: Schema46.NullishOr(Schema46.Unknown),
+  external_outcome_at: Schema46.NullishOr(Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite])),
+  metadata_json: Schema46.Unknown,
+  created_at: Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite]),
+  updated_at: Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite])
 }).annotate({ identifier: "Relay.ToolCall.Row" });
-var toolResultRow = Schema45.Struct({
-  tool_call_id: Schema45.String,
-  output_json: Schema45.Unknown,
-  error: Schema45.NullishOr(Schema45.String),
-  metadata_json: Schema45.Unknown,
-  created_at: Schema45.Union([Schema45.Date, Schema45.String, Schema45.Finite])
+var toolResultRow = Schema46.Struct({
+  tool_call_id: Schema46.String,
+  output_json: Schema46.Unknown,
+  error: Schema46.NullishOr(Schema46.String),
+  metadata_json: Schema46.Unknown,
+  created_at: Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite])
 }).annotate({ identifier: "Relay.ToolResult.Row" });
 var metadata8 = (input) => input ?? {};
 var normalizeCall = (call) => ({ ...call, metadata: metadata8(call.metadata) });
 var sameCallIdentity = (left, right) => exports_shared_schema.canonicalEquals(normalizeCall(left), normalizeCall(right));
 var toolCallRecordIdentity = { sameCallIdentity };
-var placementFromRow = (row) => Schema45.decodeUnknownSync(exports_tool_schema.Placement)(row.placement_kind === "remote" ? { kind: "remote", queue: row.placement_key } : row.placement_kind === "mcp" ? { kind: "mcp", server_id: row.placement_key } : { kind: row.placement_kind });
+var placementFromRow = (row) => Schema46.decodeUnknownSync(exports_tool_schema.Placement)(row.placement_kind === "remote" ? { kind: "remote", queue: row.placement_key } : row.placement_kind === "mcp" ? { kind: "mcp", server_id: row.placement_key } : { kind: row.placement_kind });
 var toCallRecord = (row) => {
-  const definition = row.definition_json === null || row.definition_json === undefined ? undefined : Schema45.decodeUnknownSync(exports_tool_schema.Definition)(decodeJson(row.definition_json));
-  const outcome = row.external_outcome_json === null || row.external_outcome_json === undefined ? undefined : Schema45.decodeUnknownSync(exports_tool_schema.ExternalOutcome)(decodeJson(row.external_outcome_json));
+  const definition = row.definition_json === null || row.definition_json === undefined ? undefined : Schema46.decodeUnknownSync(exports_tool_schema.Definition)(decodeJson(row.definition_json));
+  const outcome = row.external_outcome_json === null || row.external_outcome_json === undefined ? undefined : Schema46.decodeUnknownSync(exports_tool_schema.ExternalOutcome)(decodeJson(row.external_outcome_json));
   return {
     executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
     call: normalizeCall({
       id: exports_ids_schema.ToolCallId.make(row.id),
       name: row.name,
-      input: Schema45.decodeUnknownSync(exports_shared_schema.JsonValue)(decodeJson(row.input_json)),
-      metadata: Schema45.decodeUnknownSync(exports_shared_schema.Metadata)(decodeJson(row.metadata_json))
+      input: Schema46.decodeUnknownSync(exports_shared_schema.JsonValue)(decodeJson(row.input_json)),
+      metadata: Schema46.decodeUnknownSync(exports_shared_schema.Metadata)(decodeJson(row.metadata_json))
     }),
     ...definition === undefined ? {} : { definition },
     placement: placementFromRow(row),
-    state: Schema45.decodeUnknownSync(exports_tool_schema.CallState)(row.state),
+    state: Schema46.decodeUnknownSync(exports_tool_schema.CallState)(row.state),
     ...row.wait_id === null || row.wait_id === undefined ? {} : { waitId: exports_ids_schema.WaitId.make(row.wait_id) },
     idempotencyKey: row.idempotency_key,
     availableAt: fromDbTimestamp(row.available_at),
@@ -8540,9 +8612,9 @@ var toCallRecord = (row) => {
 var toResultRecord = (row) => ({
   result: {
     call_id: exports_ids_schema.ToolCallId.make(row.tool_call_id),
-    output: Schema45.decodeUnknownSync(exports_shared_schema.JsonValue)(decodeJson(row.output_json)),
+    output: Schema46.decodeUnknownSync(exports_shared_schema.JsonValue)(decodeJson(row.output_json)),
     ...row.error === null || row.error === undefined ? {} : { error: row.error },
-    metadata: Schema45.decodeUnknownSync(exports_shared_schema.Metadata)(decodeJson(row.metadata_json))
+    metadata: Schema46.decodeUnknownSync(exports_shared_schema.Metadata)(decodeJson(row.metadata_json))
   },
   createdAt: fromDbTimestamp(row.created_at)
 });
@@ -8659,8 +8731,8 @@ var makeToolCallRecordSupport = ({ sql, errors, toolCallIdempotencyKey }) => {
     `,
     orElse: () => selectCallByKey
   });
-  const decodeCallRow = (row) => Schema45.decodeUnknownEffect(toolCallRow)(row).pipe(Effect46.mapError(toRepositoryError14));
-  const decodeResultRow = (row) => Schema45.decodeUnknownEffect(toolResultRow)(row).pipe(Effect46.mapError(toRepositoryError14));
+  const decodeCallRow = (row) => Schema46.decodeUnknownEffect(toolCallRow)(row).pipe(Effect46.mapError(toRepositoryError14));
+  const decodeResultRow = (row) => Schema46.decodeUnknownEffect(toolResultRow)(row).pipe(Effect46.mapError(toRepositoryError14));
   const decodeCall = Effect46.fn("ToolCallRepository.decodeCall")(function* (row) {
     const decoded = yield* decodeCallRow(row);
     return yield* Effect46.try({ try: () => toCallRecord(decoded), catch: toRepositoryError14 });
@@ -8792,44 +8864,44 @@ var makeToolCallRepository = ({
 });
 
 // ../store-sql/src/tool/tool-call-repository.ts
-class ToolCallRepositoryError extends Schema46.TaggedErrorClass()("ToolCallRepositoryError", {
-  message: Schema46.String
+class ToolCallRepositoryError extends Schema47.TaggedErrorClass()("ToolCallRepositoryError", {
+  message: Schema47.String
 }) {
 }
 
-class ToolCallNotFound extends Schema46.TaggedErrorClass()("ToolCallNotFound", {
+class ToolCallNotFound extends Schema47.TaggedErrorClass()("ToolCallNotFound", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class DuplicateToolCall extends Schema46.TaggedErrorClass()("DuplicateToolCall", {
+class DuplicateToolCall extends Schema47.TaggedErrorClass()("DuplicateToolCall", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class DuplicateToolResult extends Schema46.TaggedErrorClass()("DuplicateToolResult", {
+class DuplicateToolResult extends Schema47.TaggedErrorClass()("DuplicateToolResult", {
   call_id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class ToolCallConflict extends Schema46.TaggedErrorClass()("ToolCallConflict", {
+class ToolCallConflict extends Schema47.TaggedErrorClass()("ToolCallConflict", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class ToolCallTransitionRejected extends Schema46.TaggedErrorClass()("ToolCallTransitionRejected", {
+class ToolCallTransitionRejected extends Schema47.TaggedErrorClass()("ToolCallTransitionRejected", {
   id: exports_ids_schema.ToolCallId,
-  message: Schema46.String
+  message: Schema47.String
 }) {
 }
 
-class ToolOutcomeConflict extends Schema46.TaggedErrorClass()("ToolOutcomeConflict", {
+class ToolOutcomeConflict extends Schema47.TaggedErrorClass()("ToolOutcomeConflict", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class ToolClaimRejected extends Schema46.TaggedErrorClass()("ToolClaimRejected", {
-  message: Schema46.String
+class ToolClaimRejected extends Schema47.TaggedErrorClass()("ToolClaimRejected", {
+  message: Schema47.String
 }) {
 }
 var lengthPrefixed = (value) => `${[...value].length}:${value}`;
@@ -9296,57 +9368,57 @@ __export(exports_workspace_lease_repository, {
   Service: () => Service39,
   DuplicateWorkspaceLease: () => DuplicateWorkspaceLease
 });
-import { Context as Context37, Effect as Effect48, Layer as Layer39, Schema as Schema47 } from "effect";
+import { Context as Context37, Effect as Effect48, Layer as Layer39, Schema as Schema48 } from "effect";
 import { SqlClient as SqlClient27 } from "effect/unstable/sql/SqlClient";
-class WorkspaceLeaseRepositoryError extends Schema47.TaggedErrorClass()("WorkspaceLeaseRepositoryError", {
-  message: Schema47.String
+class WorkspaceLeaseRepositoryError extends Schema48.TaggedErrorClass()("WorkspaceLeaseRepositoryError", {
+  message: Schema48.String
 }) {
 }
 
-class DuplicateWorkspaceLease extends Schema47.TaggedErrorClass()("DuplicateWorkspaceLease", {
+class DuplicateWorkspaceLease extends Schema48.TaggedErrorClass()("DuplicateWorkspaceLease", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspaceLeaseNotFound extends Schema47.TaggedErrorClass()("WorkspaceLeaseNotFound", {
+class WorkspaceLeaseNotFound extends Schema48.TaggedErrorClass()("WorkspaceLeaseNotFound", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
 class Service39 extends Context37.Service()("@relayfx/store-sql/workspace/workspace-lease-repository/Service") {
 }
-var WorkspaceLeaseRow = Schema47.Struct({
-  id: Schema47.String,
-  execution_id: Schema47.String,
-  provider_key: Schema47.String,
-  sandbox_ref: Schema47.NullishOr(Schema47.String),
-  latest_snapshot_ref: Schema47.NullishOr(Schema47.String),
-  status: Schema47.String,
-  resume_strategy: Schema47.String,
-  region: Schema47.NullishOr(Schema47.String),
-  request_json: Schema47.NullishOr(Schema47.Unknown),
-  metadata_json: Schema47.Unknown,
-  created_at: Schema47.Union([Schema47.Date, Schema47.String, Schema47.Finite]),
-  updated_at: Schema47.Union([Schema47.Date, Schema47.String, Schema47.Finite])
+var WorkspaceLeaseRow = Schema48.Struct({
+  id: Schema48.String,
+  execution_id: Schema48.String,
+  provider_key: Schema48.String,
+  sandbox_ref: Schema48.NullishOr(Schema48.String),
+  latest_snapshot_ref: Schema48.NullishOr(Schema48.String),
+  status: Schema48.String,
+  resume_strategy: Schema48.String,
+  region: Schema48.NullishOr(Schema48.String),
+  request_json: Schema48.NullishOr(Schema48.Unknown),
+  metadata_json: Schema48.Unknown,
+  created_at: Schema48.Union([Schema48.Date, Schema48.String, Schema48.Finite]),
+  updated_at: Schema48.Union([Schema48.Date, Schema48.String, Schema48.Finite])
 }).annotate({ identifier: "Relay.WorkspaceLease.Row" });
-var WorkspaceSnapshotRow = Schema47.Struct({
-  id: Schema47.String,
-  lease_id: Schema47.String,
-  execution_id: Schema47.String,
-  reason: Schema47.String,
-  snapshot_ref: Schema47.String,
-  metadata_json: Schema47.Unknown,
-  created_at: Schema47.Union([Schema47.Date, Schema47.String, Schema47.Finite])
+var WorkspaceSnapshotRow = Schema48.Struct({
+  id: Schema48.String,
+  lease_id: Schema48.String,
+  execution_id: Schema48.String,
+  reason: Schema48.String,
+  snapshot_ref: Schema48.String,
+  metadata_json: Schema48.Unknown,
+  created_at: Schema48.Union([Schema48.Date, Schema48.String, Schema48.Finite])
 }).annotate({ identifier: "Relay.WorkspaceSnapshot.Row" });
 var metadata9 = (input) => input ?? {};
 var terminalStatuses = new Set(["released", "failed"]);
 var isActive = (record2) => !terminalStatuses.has(record2.status);
-var cloneLease = (record2) => Schema47.decodeUnknownSync(exports_workspace_schema.WorkspaceLeaseRecord)(globalThis.structuredClone(record2));
-var cloneSnapshot = (record2) => Schema47.decodeUnknownSync(exports_workspace_schema.WorkspaceSnapshotRecord)(globalThis.structuredClone(record2));
+var cloneLease = (record2) => Schema48.decodeUnknownSync(exports_workspace_schema.WorkspaceLeaseRecord)(globalThis.structuredClone(record2));
+var cloneSnapshot = (record2) => Schema48.decodeUnknownSync(exports_workspace_schema.WorkspaceSnapshotRecord)(globalThis.structuredClone(record2));
 var toRepositoryError14 = (error5) => WorkspaceLeaseRepositoryError.make({ message: String(error5) });
-var decodeLeaseRow = (row) => Schema47.decodeUnknownEffect(WorkspaceLeaseRow)(row).pipe(Effect48.mapError(toRepositoryError14));
-var decodeSnapshotRow = (row) => Schema47.decodeUnknownEffect(WorkspaceSnapshotRow)(row).pipe(Effect48.mapError(toRepositoryError14));
-var decodeRequest = (value) => Schema47.decodeUnknownSync(exports_workspace_schema.WorkspaceRequest)(decodeJson(value));
+var decodeLeaseRow = (row) => Schema48.decodeUnknownEffect(WorkspaceLeaseRow)(row).pipe(Effect48.mapError(toRepositoryError14));
+var decodeSnapshotRow = (row) => Schema48.decodeUnknownEffect(WorkspaceSnapshotRow)(row).pipe(Effect48.mapError(toRepositoryError14));
+var decodeRequest = (value) => Schema48.decodeUnknownSync(exports_workspace_schema.WorkspaceRequest)(decodeJson(value));
 var toLeaseRecord = (row) => ({
   id: exports_ids_schema.WorkspaceLeaseId.make(row.id),
   execution_id: exports_ids_schema.ExecutionId.make(row.execution_id),
@@ -9699,10 +9771,10 @@ __export(exports_workflow_definition_repository, {
   Service: () => Service40,
   RepositoryError: () => RepositoryError
 });
-import { Clock as Clock4, Context as Context38, Effect as Effect49, Layer as Layer40, Schema as Schema48 } from "effect";
+import { Clock as Clock4, Context as Context38, Effect as Effect49, Layer as Layer40, Schema as Schema49 } from "effect";
 import { SqlClient as SqlClient28 } from "effect/unstable/sql/SqlClient";
-class RepositoryError extends Schema48.TaggedErrorClass()("WorkflowDefinitionRepositoryError", {
-  message: Schema48.String
+class RepositoryError extends Schema49.TaggedErrorClass()("WorkflowDefinitionRepositoryError", {
+  message: Schema49.String
 }) {
 }
 
@@ -9956,8 +10028,8 @@ var transition2 = (sql, tenant, id, status, now, data) => sql.withTransaction(Ef
 var decodeDefinition = (row) => ({
   id: exports_ids_schema.WorkflowDefinitionId.make(row.workflow_definition_id),
   revision: Number(row.revision),
-  digest: Schema48.decodeUnknownSync(exports_workflow_schema.DefinitionDigest)(row.digest),
-  definition: Schema48.decodeUnknownSync(exports_workflow_schema.Definition)(decodeJson(row.definition_json)),
+  digest: Schema49.decodeUnknownSync(exports_workflow_schema.DefinitionDigest)(row.digest),
+  definition: Schema49.decodeUnknownSync(exports_workflow_schema.Definition)(decodeJson(row.definition_json)),
   created_at: fromDbTimestamp(row.created_at)
 });
 var decodeRun = (row) => ({
@@ -9965,19 +10037,19 @@ var decodeRun = (row) => ({
   pin: {
     workflow_definition_id: exports_ids_schema.WorkflowDefinitionId.make(row.workflow_definition_id),
     workflow_definition_revision: Number(row.workflow_definition_revision),
-    workflow_definition_digest: Schema48.decodeUnknownSync(exports_workflow_schema.DefinitionDigest)(row.workflow_definition_digest)
+    workflow_definition_digest: Schema49.decodeUnknownSync(exports_workflow_schema.DefinitionDigest)(row.workflow_definition_digest)
   },
-  status: Schema48.decodeUnknownSync(exports_workflow_schema.RunStatus)(row.status),
+  status: Schema49.decodeUnknownSync(exports_workflow_schema.RunStatus)(row.status),
   created_at: fromDbTimestamp(row.created_at),
   updated_at: fromDbTimestamp(row.updated_at)
 });
 var decodeOperation = (row) => ({
   execution_id: exports_ids_schema.ExecutionId.make(row.execution_id),
   operation_id: exports_ids_schema.WorkflowOperationId.make(row.operation_id),
-  status: Schema48.decodeUnknownSync(exports_workflow_schema.OperationStatus)(row.status),
+  status: Schema49.decodeUnknownSync(exports_workflow_schema.OperationStatus)(row.status),
   ...row.fan_out_id === null || row.fan_out_id === undefined ? {} : { fan_out_id: exports_ids_schema.ChildFanOutId.make(row.fan_out_id) },
   ...row.decision === null || row.decision === undefined ? {} : { decision: Boolean(row.decision) },
-  ...row.output_json === null || row.output_json === undefined ? {} : { output: Schema48.decodeUnknownSync(exports_workflow_schema.OperationState.fields.output)(decodeJson(row.output_json)) },
+  ...row.output_json === null || row.output_json === undefined ? {} : { output: Schema49.decodeUnknownSync(exports_workflow_schema.OperationState.fields.output)(decodeJson(row.output_json)) },
   ...row.attempt === null || row.attempt === undefined ? {} : { attempt: Number(row.attempt) },
   ...row.backoff_until === null || row.backoff_until === undefined ? {} : { backoff_until: fromDbTimestamp(row.backoff_until) },
   ...row.compensation_operation_id === null || row.compensation_operation_id === undefined ? {} : { compensation_operation_id: exports_ids_schema.WorkflowOperationId.make(row.compensation_operation_id) },
@@ -9988,17 +10060,17 @@ var decodeOperation = (row) => ({
 var decodeLifecycle = (row) => ({
   execution_id: exports_ids_schema.ExecutionId.make(row.execution_id),
   sequence: Number(row.sequence),
-  type: Schema48.decodeUnknownSync(exports_workflow_schema.LifecycleEventType)(row.event_type),
+  type: Schema49.decodeUnknownSync(exports_workflow_schema.LifecycleEventType)(row.event_type),
   ...row.operation_id === null || row.operation_id === undefined ? {} : { operation_id: exports_ids_schema.WorkflowOperationId.make(row.operation_id) },
-  ...row.data_json === null || row.data_json === undefined ? {} : { data: Schema48.decodeUnknownSync(exports_workflow_schema.LifecycleEvent.fields.data)(decodeJson(row.data_json)) },
+  ...row.data_json === null || row.data_json === undefined ? {} : { data: Schema49.decodeUnknownSync(exports_workflow_schema.LifecycleEvent.fields.data)(decodeJson(row.data_json)) },
   created_at: fromDbTimestamp(row.created_at)
 });
 // ../runtime/src/tool/tool-runtime-service.ts
 import { Tool as AiTool } from "effect/unstable/ai";
-import { Chunk, Context as Context41, Effect as Effect55, Function as Function8, HashSet as HashSet3, Layer as Layer45, Option as Option12, Ref as Ref12, Schema as Schema51, Sink, Stream as Stream10 } from "effect";
+import { Chunk, Context as Context41, Effect as Effect55, Function as Function8, HashSet as HashSet3, Layer as Layer45, Option as Option12, Ref as Ref12, Schema as Schema52, Sink, Stream as Stream10 } from "effect";
 
 // ../runtime/src/execution/event-log-service.ts
-import { Context as Context39, Effect as Effect53, Function as Function7, Layer as Layer43, Option as Option10, Schema as Schema49, Stream as Stream9 } from "effect";
+import { Context as Context39, Effect as Effect53, Function as Function7, Layer as Layer43, Option as Option10, Schema as Schema50, Stream as Stream9 } from "effect";
 
 // ../runtime/src/execution/event-log-memory.ts
 import { Effect as Effect51, HashMap as HashMap2, HashSet as HashSet2, Layer as Layer41, Option as Option8, PubSub as PubSub5, Ref as Ref10, Stream as Stream7 } from "effect";
@@ -10351,14 +10423,14 @@ var makeRepositoryLayer = (eventLog) => {
 };
 
 // ../runtime/src/execution/event-log-service.ts
-class EventLogCursorNotFound2 extends Schema49.TaggedErrorClass()("EventLogCursorNotFound", {
+class EventLogCursorNotFound2 extends Schema50.TaggedErrorClass()("EventLogCursorNotFound", {
   execution_id: exports_ids_schema.ExecutionId,
   cursor: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class EventLogError extends Schema49.TaggedErrorClass()("EventLogError", {
-  message: Schema49.String
+class EventLogError extends Schema50.TaggedErrorClass()("EventLogError", {
+  message: Schema50.String
 }) {
 }
 
@@ -10427,19 +10499,19 @@ var sumUsage2 = Effect53.fn("EventLog.sumUsage.call")(function* (executionId) {
 });
 
 // ../runtime/src/wait/wait-service.ts
-import { Context as Context40, Duration as Duration2, Effect as Effect54, Layer as Layer44, Option as Option11, Schema as Schema50 } from "effect";
-class WaitNotFound2 extends Schema50.TaggedErrorClass()("WaitNotFound", {
+import { Context as Context40, Duration as Duration2, Effect as Effect54, Layer as Layer44, Option as Option11, Schema as Schema51 } from "effect";
+class WaitNotFound2 extends Schema51.TaggedErrorClass()("WaitNotFound", {
   wait_id: exports_ids_schema.WaitId
 }) {
 }
 
-class WaitDefinitionMissing extends Schema50.TaggedErrorClass()("WaitDefinitionMissing", {
+class WaitDefinitionMissing extends Schema51.TaggedErrorClass()("WaitDefinitionMissing", {
   envelope_id: exports_ids_schema.EnvelopeId
 }) {
 }
 
-class WaitServiceError extends Schema50.TaggedErrorClass()("WaitServiceError", {
-  message: Schema50.String
+class WaitServiceError extends Schema51.TaggedErrorClass()("WaitServiceError", {
+  message: Schema51.String
 }) {
 }
 
@@ -10719,20 +10791,20 @@ var upsertTool = (registry, tool) => {
   return Chunk.map(registry, (registered) => registered.definition.name === tool.definition.name ? tool : registered);
 };
 var registerTool = (tools, tool) => Ref12.update(tools, (registry) => upsertTool(registry, tool));
-var jsonValue2 = (value) => Schema51.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
-var fallbackParametersSchema = Schema51.Struct({});
+var jsonValue2 = (value) => Schema52.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var fallbackParametersSchema = Schema52.Struct({});
 var parametersForInputSchema = (inputSchema) => {
   const schema = exports_tool_schema.parametersSchema(inputSchema);
   return schema.ast._tag === "Unknown" || schema.ast._tag === "Declaration" ? { parameters: fallbackParametersSchema, jsonSchema: inputSchema } : { parameters: schema };
 };
 var attachJsonSchema = (tool, jsonSchema) => jsonSchema === undefined ? tool : Object.assign(tool, { jsonSchema });
-var isStructFieldMap = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((field) => Schema51.isSchema(field));
+var isStructFieldMap = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((field) => Schema52.isSchema(field));
 var jsonSchemaFromEffectToolParameters = (tool) => {
   const parameters = tool.parametersSchema;
-  if (Schema51.isSchema(parameters))
+  if (Schema52.isSchema(parameters))
     return AiTool.getJsonSchema(tool);
   if (isStructFieldMap(parameters))
-    return AiTool.getJsonSchemaFromSchema(Schema51.Struct(parameters));
+    return AiTool.getJsonSchemaFromSchema(Schema52.Struct(parameters));
   return AiTool.getJsonSchema(tool);
 };
 var runHandledToolkitTool = (toolkit, name, input, services) => {
@@ -10746,7 +10818,7 @@ var runHandledToolkitTool = (toolkit, name, input, services) => {
       message: "Tool handler did not produce a final result"
     })),
     onSome: (result) => result.isFailure ? Effect55.fail(ToolExecutionFailed.make({ tool_name: String(name), message: String(result.result) })) : Effect55.succeed(jsonValue2(result.encodedResult))
-  })), Effect55.provide(services), Effect55.mapError((error5) => Schema51.is(ToolExecutionFailed)(error5) ? error5 : ToolExecutionFailed.make({ tool_name: String(name), message: String(error5) })));
+  })), Effect55.provide(services), Effect55.mapError((error5) => Schema52.is(ToolExecutionFailed)(error5) ? error5 : ToolExecutionFailed.make({ tool_name: String(name), message: String(error5) })));
 };
 var finalToolResult = (tool, input, idempotencyKey) => Effect55.gen(function* () {
   if (tool.run === undefined) {
@@ -10843,7 +10915,7 @@ var recordRequested = (repository, eventLog, input, tool) => repository.ensureCa
 var repairResultEvent = (eventLog, input, record2) => ensureToolEvent(eventLog, resultEvent({ ...input, createdAt: record2.createdAt - 1 }, record2.result, input.eventSequence + 1));
 var persistReceived = (repository, input, result) => repository.recordResult({ executionId: input.executionId, result, createdAt: input.createdAt + 1 }).pipe(Effect55.catchTag("DuplicateToolResult", () => repository.getResult(input.executionId, result.call_id).pipe(Effect55.mapError(mapRepositoryError2), Effect55.flatMap((existing) => existing === undefined ? Effect55.fail(ToolRuntimeError.make({ message: "DuplicateToolResult" })) : Effect55.succeed(existing)))), Effect55.mapError(preserveRecordResultError));
 var recordReceived = (eventLog, input, record2) => ensureToolEvent(eventLog, resultEvent({ ...input, createdAt: record2.createdAt - 1 }, record2.result, input.eventSequence + 1)).pipe(Effect55.as(record2.result));
-var nonEmptyName = (name) => Schema51.decodeUnknownSync(exports_shared_schema.NonEmptyString)(name);
+var nonEmptyName = (name) => Schema52.decodeUnknownSync(exports_shared_schema.NonEmptyString)(name);
 var needsApprovalFromEffectTool = (tool) => tool.needsApproval === undefined ? undefined : typeof tool.needsApproval === "boolean" ? tool.needsApproval : true;
 var definitionFromEffectTool = (modelTool, options) => ({
   name: modelTool.name,
@@ -10884,8 +10956,8 @@ var tool = Function8.dual(2, (name, options) => {
     tool: effectTool,
     ...options.placement === undefined ? {} : { placement: options.placement },
     ...options.requiredPermissions === undefined ? {} : { requiredPermissions: options.requiredPermissions },
-    validateInput: (input) => Schema51.decodeUnknownEffect(inputSchema)(input).pipe(Effect55.mapError((error5) => ToolInputInvalid.make({ tool_name: name, message: error5.message })), Effect55.asVoid),
-    run: (input, context) => Schema51.decodeUnknownEffect(inputSchema)(input).pipe(Effect55.mapError((error5) => ToolExecutionFailed.make({ tool_name: name, message: error5.message })), Effect55.flatMap((decoded) => options.run(decoded, context)), Effect55.provideService(ToolCallInfo, context), Effect55.flatMap((output) => Schema51.encodeUnknownEffect(outputSchema)(output).pipe(Effect55.mapError((error5) => ToolExecutionFailed.make({ tool_name: name, message: error5.message })))), Effect55.map(jsonValue2))
+    validateInput: (input) => Schema52.decodeUnknownEffect(inputSchema)(input).pipe(Effect55.mapError((error5) => ToolInputInvalid.make({ tool_name: name, message: error5.message })), Effect55.asVoid),
+    run: (input, context) => Schema52.decodeUnknownEffect(inputSchema)(input).pipe(Effect55.mapError((error5) => ToolExecutionFailed.make({ tool_name: name, message: error5.message })), Effect55.flatMap((decoded) => options.run(decoded, context)), Effect55.provideService(ToolCallInfo, context), Effect55.flatMap((output) => Schema52.encodeUnknownEffect(outputSchema)(output).pipe(Effect55.mapError((error5) => ToolExecutionFailed.make({ tool_name: name, message: error5.message })))), Effect55.map(jsonValue2))
   };
 });
 var dynamicTool = Function8.dual(2, (name, options) => {
@@ -10893,7 +10965,7 @@ var dynamicTool = Function8.dual(2, (name, options) => {
   const modelTool = attachJsonSchema(AiTool.dynamic(name, {
     description: options.description,
     parameters: parameters.parameters,
-    success: Schema51.Unknown,
+    success: Schema52.Unknown,
     needsApproval: options.needsApproval
   }), parameters.jsonSchema);
   return {
@@ -10938,7 +11010,7 @@ var externalOutcomeResult = (call, input) => {
     return Effect55.succeed(placementFailureResult(input, call.externalOutcome.message));
   }
   const placement = call.placement.kind;
-  return Schema51.decodeUnknownEffect(exports_tool_schema.resultSchema(call.definition.output_schema))(call.externalOutcome.output).pipe(Effect55.map((output) => ({ call_id: input.call.id, output: jsonValue2(output) })), Effect55.catch((error5) => Effect55.succeed(placementFailureResult(input, `invalid ${placement} result: ${error5.message}`))));
+  return Schema52.decodeUnknownEffect(exports_tool_schema.resultSchema(call.definition.output_schema))(call.externalOutcome.output).pipe(Effect55.map((output) => ({ call_id: input.call.id, output: jsonValue2(output) })), Effect55.catch((error5) => Effect55.succeed(placementFailureResult(input, `invalid ${placement} result: ${error5.message}`))));
 };
 var runExternalTool = (repository, waits, call, input) => Effect55.gen(function* () {
   const waitId2 = placementWaitId(input);
@@ -10972,7 +11044,7 @@ var runExternalTool = (repository, waits, call, input) => Effect55.gen(function*
     return placementFailureResult(input, "Tool execution timed out");
   if (wait.state === "cancelled")
     return placementFailureResult(input, "Tool execution cancelled");
-  const repairedCall = waitingCall.externalOutcome === undefined && waitingCall.placement.kind === "client" ? yield* Schema51.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect55.mapError((error5) => ToolRuntimeError.make({ message: error5.message })), Effect55.flatMap((outcome) => repository.acceptClientOutcome({
+  const repairedCall = waitingCall.externalOutcome === undefined && waitingCall.placement.kind === "client" ? yield* Schema52.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect55.mapError((error5) => ToolRuntimeError.make({ message: error5.message })), Effect55.flatMap((outcome) => repository.acceptClientOutcome({
     executionId: input.executionId,
     callId: input.call.id,
     outcome,
@@ -11137,11 +11209,11 @@ __export(exports_runtime, {
 });
 
 // ../runtime/src/child/child-fan-out-runtime.ts
-import { Clock as Clock5, Context as Context44, Effect as Effect58, FiberMap, Layer as Layer48, Schema as Schema54 } from "effect";
+import { Clock as Clock5, Context as Context44, Effect as Effect58, FiberMap, Layer as Layer48, Schema as Schema55 } from "effect";
 
 // ../runtime/src/child/child-fan-out-transition-service.ts
-import { Context as Context43, Effect as Effect57, Layer as Layer47, Option as Option13, Schema as Schema53 } from "effect";
-class ChildFanOutTransitionError extends Schema53.TaggedErrorClass()("ChildFanOutTransitionError", { message: Schema53.String }) {
+import { Context as Context43, Effect as Effect57, Layer as Layer47, Option as Option13, Schema as Schema54 } from "effect";
+class ChildFanOutTransitionError extends Schema54.TaggedErrorClass()("ChildFanOutTransitionError", { message: Schema54.String }) {
 }
 
 class Service43 extends Context43.Service()("@relayfx/runtime/child/child-fan-out-transition-service/Service") {
@@ -11208,7 +11280,7 @@ var terminal2 = Effect57.fn("ChildFanOutTransitionService.terminal.call")(functi
 class HandlerService extends Context44.Service()("@relayfx/runtime/child/child-fan-out-runtime/HandlerService") {
 }
 
-class ChildFanOutRuntimeError extends Schema54.TaggedErrorClass()("ChildFanOutRuntimeError", { message: Schema54.String }) {
+class ChildFanOutRuntimeError extends Schema55.TaggedErrorClass()("ChildFanOutRuntimeError", { message: Schema55.String }) {
 }
 
 class Service44 extends Context44.Service()("@relayfx/runtime/child/child-fan-out-runtime/Service") {
@@ -11275,17 +11347,17 @@ var layerFromRuntime = Layer48.effect(Service44, Effect58.gen(function* () {
 }).pipe(Effect58.mapError(runtimeError)));
 
 // ../runtime/src/state/execution-state-service.ts
-import { Config as Config2, Context as Context45, Effect as Effect59, Function as Function10, Layer as Layer49, Schema as Schema55 } from "effect";
+import { Config as Config2, Context as Context45, Effect as Effect59, Function as Function10, Layer as Layer49, Schema as Schema56 } from "effect";
 var StateVersionConflict3 = exports_execution_state_repository.StateVersionConflict;
 
-class StateValueInvalid extends Schema55.TaggedErrorClass()("StateValueInvalid", {
-  key: Schema55.String,
-  message: Schema55.String
+class StateValueInvalid extends Schema56.TaggedErrorClass()("StateValueInvalid", {
+  key: Schema56.String,
+  message: Schema56.String
 }) {
 }
 
-class ExecutionStateError extends Schema55.TaggedErrorClass()("ExecutionStateError", {
-  message: Schema55.String
+class ExecutionStateError extends Schema56.TaggedErrorClass()("ExecutionStateError", {
+  message: Schema56.String
 }) {
 }
 var key3 = Function10.dual(2, (name, schema) => ({
@@ -11305,7 +11377,7 @@ var layer38 = Layer49.effect(Service45, Effect59.gen(function* () {
     const row = yield* repository.get(executionId, stateKey.name).pipe(Effect59.mapError(stateError));
     if (row === undefined)
       return;
-    return yield* Schema55.decodeUnknownEffect(stateKey.schema)(row.value).pipe(Effect59.mapError((cause) => invalid(stateKey.name, cause)));
+    return yield* Schema56.decodeUnknownEffect(stateKey.schema)(row.value).pipe(Effect59.mapError((cause) => invalid(stateKey.name, cause)));
   });
   const getRecord = Effect59.fn("ExecutionStateService.getRecord")((executionId, stateKey) => repository.get(executionId, stateKey).pipe(Effect59.mapError(stateError)));
   const put4 = Effect59.fn("ExecutionStateService.put")(function* (input) {
@@ -11314,8 +11386,8 @@ var layer38 = Layer49.effect(Service45, Effect59.gen(function* () {
       if (replay2 !== undefined && replay2.key === input.key.name && replay2.op === "put" && replay2.record !== undefined)
         return replay2.record;
     }
-    const value = yield* Schema55.encodeUnknownEffect(input.key.schema)(input.value).pipe(Effect59.mapError((cause) => invalid(input.key.name, cause)));
-    const encoded = yield* Schema55.encodeEffect(Schema55.UnknownFromJsonString)(value).pipe(Effect59.mapError((cause) => invalid(input.key.name, cause)));
+    const value = yield* Schema56.encodeUnknownEffect(input.key.schema)(input.value).pipe(Effect59.mapError((cause) => invalid(input.key.name, cause)));
+    const encoded = yield* Schema56.encodeEffect(Schema56.UnknownFromJsonString)(value).pipe(Effect59.mapError((cause) => invalid(input.key.name, cause)));
     const bytes = new TextEncoder().encode(encoded);
     let eventValue = { value };
     if (bytes.byteLength > eventInlineMaxBytes) {
@@ -11330,9 +11402,9 @@ var layer38 = Layer49.effect(Service45, Effect59.gen(function* () {
       ...input.expectedVersion === undefined ? {} : { expectedVersion: input.expectedVersion },
       ...input.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey },
       updatedAt: input.updatedAt
-    }).pipe(Effect59.mapError((cause) => Schema55.is(exports_execution_state_repository.StateVersionConflict)(cause) ? cause : stateError(cause)));
+    }).pipe(Effect59.mapError((cause) => Schema56.is(exports_execution_state_repository.StateVersionConflict)(cause) ? cause : stateError(cause)));
   });
-  const remove3 = Effect59.fn("ExecutionStateService.remove")((input) => repository.remove(input).pipe(Effect59.mapError((cause) => Schema55.is(exports_execution_state_repository.StateVersionConflict)(cause) ? cause : stateError(cause))));
+  const remove3 = Effect59.fn("ExecutionStateService.remove")((input) => repository.remove(input).pipe(Effect59.mapError((cause) => Schema56.is(exports_execution_state_repository.StateVersionConflict)(cause) ? cause : stateError(cause))));
   const list12 = Effect59.fn("ExecutionStateService.list")((input) => repository.list(input).pipe(Effect59.mapError(stateError)));
   return Service45.of({ getRecord, get: get12, put: put4, remove: remove3, list: list12 });
 }));
@@ -11340,7 +11412,7 @@ var memoryRepositoryDependencies = Layer49.mergeAll(exports_execution_repository
 var memoryLayer36 = layer38.pipe(Layer49.provide(exports_execution_state_repository.memoryLayer.pipe(Layer49.provide(memoryRepositoryDependencies))));
 
 // ../runtime/src/runner/runner-runtime-service.ts
-import { Config as Config8, Context as Context70, Crypto as Crypto4, Duration as Duration7, Effect as Effect99, Layer as Layer81, Option as Option26, Schema as Schema91, Stream as Stream16 } from "effect";
+import { Config as Config8, Context as Context70, Crypto as Crypto4, Duration as Duration7, Effect as Effect99, Layer as Layer81, Option as Option26, Schema as Schema92, Stream as Stream16 } from "effect";
 import {
   ClusterWorkflowEngine,
   HttpRunner,
@@ -11361,7 +11433,7 @@ import { WorkflowEngine as WorkflowEngine2 } from "effect/unstable/workflow";
 import { LanguageModel as LanguageModel2 } from "effect/unstable/ai";
 
 // ../runtime/src/agent/agent-registry-service.ts
-import { Clock as Clock6, Context as Context46, Crypto as Crypto2, Effect as Effect61, HashSet as HashSet4, Layer as Layer50, Option as Option14, Schema as Schema56 } from "effect";
+import { Clock as Clock6, Context as Context46, Crypto as Crypto2, Effect as Effect61, HashSet as HashSet4, Layer as Layer50, Option as Option14, Schema as Schema57 } from "effect";
 
 // ../runtime/src/tool/tool-input-schema-digest.ts
 import { Crypto, Effect as Effect60, Encoding } from "effect";
@@ -11383,13 +11455,13 @@ var digestDefinitions = Effect60.fn("ToolInputSchemaDigest.digestDefinitions")(f
 });
 
 // ../runtime/src/agent/agent-registry-service.ts
-class AgentDefinitionInvalid extends Schema56.TaggedErrorClass()("AgentDefinitionInvalid", {
-  message: Schema56.String
+class AgentDefinitionInvalid extends Schema57.TaggedErrorClass()("AgentDefinitionInvalid", {
+  message: Schema57.String
 }) {
 }
 
-class AgentRegistryError extends Schema56.TaggedErrorClass()("AgentRegistryError", {
-  message: Schema56.String
+class AgentRegistryError extends Schema57.TaggedErrorClass()("AgentRegistryError", {
+  message: Schema57.String
 }) {
 }
 
@@ -11431,7 +11503,7 @@ var transferToolName = (name) => `transfer_to_${name.trim().toLowerCase().replac
 var validateTurnPolicySnapshot = Effect61.fn("AgentRegistry.validateTurnPolicySnapshot")(function* (snapshot) {
   if (snapshot === undefined)
     return;
-  const decoded = yield* Schema56.decodeUnknownEffect(exports_agent_schema.TurnPolicySnapshot)(snapshot).pipe(Effect61.mapError(() => AgentDefinitionInvalid.make({ message: "definition.turn_policy must be a valid turn policy snapshot" })));
+  const decoded = yield* Schema57.decodeUnknownEffect(exports_agent_schema.TurnPolicySnapshot)(snapshot).pipe(Effect61.mapError(() => AgentDefinitionInvalid.make({ message: "definition.turn_policy must be a valid turn policy snapshot" })));
   let nodes = 0;
   const pending = [
     { snapshot: decoded, depth: 1 }
@@ -11575,35 +11647,35 @@ var listRevisions3 = Effect61.fn("AgentRegistry.listRevisions.call")(function* (
 });
 
 // ../runtime/src/agent/agent-loop-service.ts
-import { Cause as Cause2, Config as Config4, Context as Context64, Crypto as Crypto3, Effect as Effect93, HashSet as HashSet7, Layer as Layer75, Option as Option24, Ref as Ref19, Schema as Schema84, Stream as Stream13 } from "effect";
-import { AiError as AiError3, Chat, LanguageModel, Prompt as Prompt6, Tokenizer, Tool as AiTool2, Toolkit as Toolkit2 } from "effect/unstable/ai";
+import { Cause as Cause2, Config as Config4, Context as Context64, Crypto as Crypto3, Effect as Effect93, HashSet as HashSet7, Layer as Layer75, Option as Option24, Ref as Ref19, Schema as Schema85, Stream as Stream13 } from "effect";
+import { AiError as AiError3, Chat, LanguageModel, Prompt as Prompt7, Tokenizer, Tool as AiTool2, Toolkit as Toolkit2 } from "effect/unstable/ai";
 
 // ../runtime/src/child/child-run-service.ts
-import { Context as Context48, Effect as Effect63, Function as Function12, HashSet as HashSet5, Layer as Layer52, Option as Option15, Result as Result2, Schema as Schema58 } from "effect";
+import { Context as Context48, Effect as Effect63, Function as Function12, HashSet as HashSet5, Layer as Layer52, Option as Option15, Result as Result2, Schema as Schema59 } from "effect";
 
 // ../runtime/src/workspace/workspace-provider-service.ts
-import { Context as Context47, Effect as Effect62, Function as Function11, Layer as Layer51, Ref as Ref13, Schema as Schema57 } from "effect";
+import { Context as Context47, Effect as Effect62, Function as Function11, Layer as Layer51, Ref as Ref13, Schema as Schema58 } from "effect";
 
-class WorkspaceNotFound extends Schema57.TaggedErrorClass()("WorkspaceNotFound", {
+class WorkspaceNotFound extends Schema58.TaggedErrorClass()("WorkspaceNotFound", {
   sandbox_ref: exports_ids_schema.WorkspaceRef
 }) {
 }
 
-class WorkspaceUnavailable extends Schema57.TaggedErrorClass()("WorkspaceUnavailable", {
+class WorkspaceUnavailable extends Schema58.TaggedErrorClass()("WorkspaceUnavailable", {
   sandbox_ref: exports_ids_schema.WorkspaceRef,
-  message: Schema57.String
+  message: Schema58.String
 }) {
 }
 
-class WorkspaceCapabilityUnsupported extends Schema57.TaggedErrorClass()("WorkspaceCapabilityUnsupported", {
-  capability: Schema57.Literals(["suspend", "snapshot", "fork"]),
+class WorkspaceCapabilityUnsupported extends Schema58.TaggedErrorClass()("WorkspaceCapabilityUnsupported", {
+  capability: Schema58.Literals(["suspend", "snapshot", "fork"]),
   provider_key: exports_workspace_schema.WorkspaceProviderKey
 }) {
 }
 
-class WorkspaceProviderError extends Schema57.TaggedErrorClass()("WorkspaceProviderError", {
+class WorkspaceProviderError extends Schema58.TaggedErrorClass()("WorkspaceProviderError", {
   provider_key: exports_workspace_schema.WorkspaceProviderKey,
-  message: Schema57.String
+  message: Schema58.String
 }) {
 }
 
@@ -11656,28 +11728,28 @@ var destroy = Effect62.fn("WorkspaceProvider.destroy.call")(function* (ref) {
 });
 
 // ../runtime/src/child/child-run-service.ts
-class StaticChildRunPresetNotFound extends Schema58.TaggedErrorClass()("StaticChildRunPresetNotFound", {
+class StaticChildRunPresetNotFound extends Schema59.TaggedErrorClass()("StaticChildRunPresetNotFound", {
   preset_name: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ChildRunScopeBroadened extends Schema58.TaggedErrorClass()("ChildRunScopeBroadened", {
-  field: Schema58.Literals(["tool_names", "permissions"]),
+class ChildRunScopeBroadened extends Schema59.TaggedErrorClass()("ChildRunScopeBroadened", {
+  field: Schema59.Literals(["tool_names", "permissions"]),
   value: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ChildRunServiceError extends Schema58.TaggedErrorClass()("ChildRunServiceError", {
-  message: Schema58.String
+class ChildRunServiceError extends Schema59.TaggedErrorClass()("ChildRunServiceError", {
+  message: Schema59.String
 }) {
 }
 
-class ChildRunWorkspaceUnavailable extends Schema58.TaggedErrorClass()("ChildRunWorkspaceUnavailable", {
-  reason: Schema58.String
+class ChildRunWorkspaceUnavailable extends Schema59.TaggedErrorClass()("ChildRunWorkspaceUnavailable", {
+  reason: Schema59.String
 }) {
 }
 
-class ChildRunModelMissing extends Schema58.TaggedErrorClass()("ChildRunModelMissing", {}) {
+class ChildRunModelMissing extends Schema59.TaggedErrorClass()("ChildRunModelMissing", {}) {
 }
 
 class Service48 extends Context48.Service()("@relayfx/runtime/child/child-run-service/Service") {
@@ -11913,53 +11985,53 @@ var spawnDynamic = Effect63.fn("ChildRunService.spawnDynamic.call")(function* (i
 });
 
 // ../runtime/src/child/spawn-child-run-tool.ts
-import { Effect as Effect64, Schema as Schema59 } from "effect";
+import { Effect as Effect64, Schema as Schema60 } from "effect";
 var toolName = "spawn_child_run";
 var permissionName = "relay.child_run.spawn";
-var Input = Schema59.Struct({
-  preset_name: Schema59.optionalKey(exports_shared_schema.NonEmptyString),
-  instructions: Schema59.optionalKey(Schema59.String),
-  model: Schema59.optionalKey(exports_agent_schema.ModelSelection),
-  compaction_policy: Schema59.optionalKey(exports_agent_schema.CompactionPolicy),
-  tool_names: Schema59.optionalKey(Schema59.Array(Schema59.String)),
-  permissions: Schema59.optionalKey(Schema59.Array(Schema59.String)),
-  output_schema_ref: Schema59.optionalKey(Schema59.String),
-  metadata: Schema59.optionalKey(exports_shared_schema.Metadata),
-  input: Schema59.optionalKey(Schema59.Array(exports_content_schema.Part))
+var Input = Schema60.Struct({
+  preset_name: Schema60.optionalKey(exports_shared_schema.NonEmptyString),
+  instructions: Schema60.optionalKey(Schema60.String),
+  model: Schema60.optionalKey(exports_agent_schema.ModelSelection),
+  compaction_policy: Schema60.optionalKey(exports_agent_schema.CompactionPolicy),
+  tool_names: Schema60.optionalKey(Schema60.Array(Schema60.String)),
+  permissions: Schema60.optionalKey(Schema60.Array(Schema60.String)),
+  output_schema_ref: Schema60.optionalKey(Schema60.String),
+  metadata: Schema60.optionalKey(exports_shared_schema.Metadata),
+  input: Schema60.optionalKey(Schema60.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Input" });
-var Output = Schema59.Struct({
+var Output = Schema60.Struct({
   child_execution_id: exports_ids_schema.ChildExecutionId,
-  status: Schema59.Literals(["completed", "failed", "cancelled"]),
-  output: Schema59.Array(exports_content_schema.Part)
+  status: Schema60.Literals(["completed", "failed", "cancelled"]),
+  output: Schema60.Array(exports_content_schema.Part)
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Output" });
-var TransferInput = Schema59.Struct({
-  input: Schema59.optionalKey(Schema59.Array(exports_content_schema.Part))
+var TransferInput = Schema60.Struct({
+  input: Schema60.optionalKey(Schema60.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.TransferInput" });
-var ModelInput = Schema59.Struct({
-  preset_name: Schema59.optionalKey(Schema59.NullOr(Schema59.String)),
-  instructions: Schema59.optionalKey(Schema59.String),
-  model: Schema59.optionalKey(Schema59.NullOr(Schema59.Struct({
-    provider: Schema59.String,
-    model: Schema59.String,
-    registration_key: Schema59.optionalKey(Schema59.String)
+var ModelInput = Schema60.Struct({
+  preset_name: Schema60.optionalKey(Schema60.NullOr(Schema60.String)),
+  instructions: Schema60.optionalKey(Schema60.String),
+  model: Schema60.optionalKey(Schema60.NullOr(Schema60.Struct({
+    provider: Schema60.String,
+    model: Schema60.String,
+    registration_key: Schema60.optionalKey(Schema60.String)
   }))),
-  compaction_policy: Schema59.optionalKey(Schema59.Struct({
-    context_window: Schema59.Finite,
-    reserve_tokens: Schema59.Finite,
-    keep_recent_tokens: Schema59.Finite,
-    summary_model: Schema59.optionalKey(Schema59.Struct({
-      provider: Schema59.String,
-      model: Schema59.String,
-      registration_key: Schema59.optionalKey(Schema59.String)
+  compaction_policy: Schema60.optionalKey(Schema60.Struct({
+    context_window: Schema60.Finite,
+    reserve_tokens: Schema60.Finite,
+    keep_recent_tokens: Schema60.Finite,
+    summary_model: Schema60.optionalKey(Schema60.Struct({
+      provider: Schema60.String,
+      model: Schema60.String,
+      registration_key: Schema60.optionalKey(Schema60.String)
     }))
   })),
-  tool_names: Schema59.optionalKey(Schema59.Array(Schema59.String)),
-  permissions: Schema59.optionalKey(Schema59.Array(Schema59.String)),
-  output_schema_ref: Schema59.optionalKey(Schema59.NullOr(Schema59.String)),
-  input: Schema59.optionalKey(Schema59.Array(Schema59.Struct({ type: Schema59.Literal("text"), text: Schema59.String })))
+  tool_names: Schema60.optionalKey(Schema60.Array(Schema60.String)),
+  permissions: Schema60.optionalKey(Schema60.Array(Schema60.String)),
+  output_schema_ref: Schema60.optionalKey(Schema60.NullOr(Schema60.String)),
+  input: Schema60.optionalKey(Schema60.Array(Schema60.Struct({ type: Schema60.Literal("text"), text: Schema60.String })))
 });
-var ModelTransferInput = Schema59.Struct({
-  input: Schema59.optionalKey(Schema59.Array(Schema59.Struct({ type: Schema59.Literal("text"), text: Schema59.String })))
+var ModelTransferInput = Schema60.Struct({
+  input: Schema60.optionalKey(Schema60.Array(Schema60.Struct({ type: Schema60.Literal("text"), text: Schema60.String })))
 });
 var normalizeModelInput = (input) => {
   const { preset_name: presetName, model, output_schema_ref: outputSchemaRef2, ...rest } = input;
@@ -12144,7 +12216,7 @@ var registeredTool = (config) => tool(toolName, {
   permissions: [{ name: permissionName, value: true }],
   requiredPermissions: [permissionName],
   metadata: { relay_core_tool: true },
-  run: (input, context) => Schema59.decodeUnknownEffect(Input)(normalizeModelInput(input)).pipe(Effect64.mapError((error5) => ToolExecutionFailed.make({ tool_name: toolName, message: error5.message })), Effect64.flatMap((decoded) => run3(config, toolName, decoded, context, true)))
+  run: (input, context) => Schema60.decodeUnknownEffect(Input)(normalizeModelInput(input)).pipe(Effect64.mapError((error5) => ToolExecutionFailed.make({ tool_name: toolName, message: error5.message })), Effect64.flatMap((decoded) => run3(config, toolName, decoded, context, true)))
 });
 var transferToolName2 = (name) => `transfer_to_${name.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "")}`;
 var transferTools = (config) => (config.agent.handoff_targets ?? []).map((target) => {
@@ -12156,21 +12228,21 @@ var transferTools = (config) => (config.agent.handoff_targets ?? []).map((target
     permissions: [{ name: permissionName, value: true }],
     requiredPermissions: [permissionName],
     metadata: { relay_core_tool: true, handoff_target: target.name, preset_name: target.preset_name },
-    run: (input, context) => Schema59.decodeUnknownEffect(TransferInput)(input).pipe(Effect64.mapError((error5) => ToolExecutionFailed.make({ tool_name: name, message: error5.message })), Effect64.flatMap((decoded) => run3(config, name, { preset_name: target.preset_name, input: decoded.input ?? [] }, context, false)))
+    run: (input, context) => Schema60.decodeUnknownEffect(TransferInput)(input).pipe(Effect64.mapError((error5) => ToolExecutionFailed.make({ tool_name: name, message: error5.message })), Effect64.flatMap((decoded) => run3(config, name, { preset_name: target.preset_name, input: decoded.input ?? [] }, context, false)))
   });
 });
 
 // ../runtime/src/memory/memory-service.ts
-import { Clock as Clock7, Context as Context49, Effect as Effect65, Layer as Layer53, Schema as Schema60 } from "effect";
-import { EmbeddingModel as EmbeddingModel2, Prompt as Prompt4 } from "effect/unstable/ai";
+import { Clock as Clock7, Context as Context49, Effect as Effect65, Layer as Layer53, Schema as Schema61 } from "effect";
+import { EmbeddingModel as EmbeddingModel2, Prompt as Prompt5 } from "effect/unstable/ai";
 class Service49 extends Context49.Service()("@relayfx/runtime/memory/memory-service/Service") {
 }
 var defaultTopK = 5;
 var memoryError = (error5) => exports_memory.MemoryError.make({
   message: error5 instanceof Error ? `${error5.name}: ${error5.message}` : String(error5)
 });
-var decodeSubject = (subject) => Schema60.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect65.mapError(memoryError));
-var textPart = (text) => Prompt4.makePart("text", { text });
+var decodeSubject = (subject) => Schema61.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect65.mapError(memoryError));
+var textPart = (text) => Prompt5.makePart("text", { text });
 var textFromParts = (parts) => parts.filter((part) => part.type === "text").map((part) => part.text).join(`
 `).trim();
 var latestUserText = (prompt) => {
@@ -12332,8 +12404,8 @@ var layer42 = (input) => Layer54.succeed(Service50, Service50.of(make4(input)));
 var noRetryLayer = layer42({ retrySchedule: Schedule3.recurs(0) });
 
 // ../runtime/src/presence/presence-service.ts
-import { Clock as Clock8, Config as Config3, Effect as Effect66, Layer as Layer55, Random, Schedule as Schedule4, Schema as Schema61, Stream as Stream11 } from "effect";
-var isPresenceError = Schema61.is(PresenceError);
+import { Clock as Clock8, Config as Config3, Effect as Effect66, Layer as Layer55, Random, Schedule as Schedule4, Schema as Schema62, Stream as Stream11 } from "effect";
+var isPresenceError = Schema62.is(PresenceError);
 var readError = (cause) => isPresenceError(cause) ? cause : PresenceError.make({ message: String(cause) });
 var warn = (operation) => (cause) => Effect66.logWarning(`Presence ${operation} failed`).pipe(Effect66.annotateLogs({ cause: String(cause) }));
 var layerFromRepository2 = Layer55.effect(Service2, Effect66.gen(function* () {
@@ -12388,11 +12460,11 @@ var list13 = Effect66.fn("Presence.list.call")(function* (scope) {
 });
 
 // ../runtime/src/presence/presence-tool.ts
-import { Effect as Effect67, Schema as Schema62 } from "effect";
+import { Effect as Effect67, Schema as Schema63 } from "effect";
 var toolName2 = "relay_presence";
 var permissionName2 = "relay.presence.read";
-var Input2 = Schema62.Struct({ scope: Schema62.optionalKey(exports_presence_schema.Scope) });
-var Output2 = Schema62.Struct({ watcher_count: Schema62.Finite, entries: Schema62.Array(exports_presence_schema.Entry) });
+var Input2 = Schema63.Struct({ scope: Schema63.optionalKey(exports_presence_schema.Scope) });
+var Output2 = Schema63.Struct({ watcher_count: Schema63.Finite, entries: Schema63.Array(exports_presence_schema.Entry) });
 var registeredTool2 = (presence) => tool(toolName2, {
   description: "List observers currently watching an execution or session.",
   input: Input2,
@@ -12408,24 +12480,24 @@ var registeredTool2 = (presence) => tool(toolName2, {
 });
 
 // ../runtime/src/state/state-tools.ts
-import { Effect as Effect68, Schema as Schema63 } from "effect";
-var GetInput = Schema63.Struct({ key: exports_shared_schema.NonEmptyString });
-var GetOutput = Schema63.Struct({
-  value: Schema63.optionalKey(exports_shared_schema.JsonValue),
-  version: Schema63.optionalKey(Schema63.Int)
+import { Effect as Effect68, Schema as Schema64 } from "effect";
+var GetInput = Schema64.Struct({ key: exports_shared_schema.NonEmptyString });
+var GetOutput = Schema64.Struct({
+  value: Schema64.optionalKey(exports_shared_schema.JsonValue),
+  version: Schema64.optionalKey(Schema64.Int)
 });
-var PutInput = Schema63.Struct({
+var PutInput = Schema64.Struct({
   key: exports_shared_schema.NonEmptyString,
   value: exports_shared_schema.JsonValue,
-  expected_version: Schema63.optionalKey(Schema63.Int.check(Schema63.isGreaterThanOrEqualTo(0)))
+  expected_version: Schema64.optionalKey(Schema64.Int.check(Schema64.isGreaterThanOrEqualTo(0)))
 });
-var DeleteInput = Schema63.Struct({ key: exports_shared_schema.NonEmptyString, expected_version: Schema63.optionalKey(Schema63.Int) });
-var ListInput = Schema63.Struct({
-  prefix: Schema63.optionalKey(Schema63.String),
-  after_key: Schema63.optionalKey(Schema63.String),
-  limit: Schema63.optionalKey(Schema63.Int)
+var DeleteInput = Schema64.Struct({ key: exports_shared_schema.NonEmptyString, expected_version: Schema64.optionalKey(Schema64.Int) });
+var ListInput = Schema64.Struct({
+  prefix: Schema64.optionalKey(Schema64.String),
+  after_key: Schema64.optionalKey(Schema64.String),
+  limit: Schema64.optionalKey(Schema64.Int)
 });
-var RecordOutput = Schema63.Struct({
+var RecordOutput = Schema64.Struct({
   execution_id: exports_state_schema.StateRecordView.fields.execution_id,
   key: exports_state_schema.StateRecordView.fields.key,
   value: exports_state_schema.StateRecordView.fields.value,
@@ -12433,8 +12505,8 @@ var RecordOutput = Schema63.Struct({
   created_at: exports_state_schema.StateRecordView.fields.created_at,
   updated_at: exports_state_schema.StateRecordView.fields.updated_at
 });
-var PutOutput = Schema63.Struct({ key: exports_state_schema.StateKey, version: exports_state_schema.StateVersion });
-var DeleteOutput = Schema63.Struct({ deleted: Schema63.Boolean, version: Schema63.optionalKey(Schema63.Int) });
+var PutOutput = Schema64.Struct({ key: exports_state_schema.StateKey, version: exports_state_schema.StateVersion });
+var DeleteOutput = Schema64.Struct({ deleted: Schema64.Boolean, version: Schema64.optionalKey(Schema64.Int) });
 var enabled2 = (agent) => agent.metadata?.state_enabled === true;
 var mapStateError = (toolName3) => (error5) => ToolExecutionFailed.make({ tool_name: toolName3, message: error5._tag });
 var registeredTools2 = (state) => [
@@ -12475,7 +12547,7 @@ var registeredTools2 = (state) => [
   tool("state_list", {
     description: "List durable execution state",
     input: ListInput,
-    output: Schema63.Array(RecordOutput),
+    output: Schema64.Array(RecordOutput),
     metadata: { relay_core_tool: true },
     run: (input, context) => state.list({
       executionId: context.executionId,
@@ -12548,6 +12620,8 @@ var recordAppendInput = (record2) => {
         _tag: "Compaction",
         version: 2,
         projectedHistory: record2.projectedHistory,
+        telemetry: record2.telemetry,
+        ...record2.compactionCommit === undefined ? {} : { compactionCommit: record2.compactionCommit },
         ...record2.summary === undefined ? {} : { summary: record2.summary },
         ...record2.metadata === undefined ? {} : { metadata: record2.metadata }
       } : {
@@ -12686,6 +12760,8 @@ var make5 = Effect69.fn("RelaySessionStore.make")(function* (sessionId, entrySco
       sessionId,
       parentId: checkpoint.parentId === null ? null : entryId(checkpoint.parentId),
       projectedHistory: checkpoint.projectedHistory,
+      telemetry: checkpoint.telemetry,
+      ...checkpoint.compactionCommit === undefined ? {} : { compactionCommit: checkpoint.compactionCommit },
       ...checkpoint.summary === undefined ? {} : { summary: checkpoint.summary },
       createdAt: now,
       ...makeOptions?.writer === undefined ? {} : { expectedWriter: makeOptions.writer }
@@ -12736,43 +12812,43 @@ var layer43 = Function13.dual((args) => typeof args[0] === "string" && String(ar
 var memoryLayer39 = Function13.dual((args) => typeof args[0] === "string" && String(args[0]).startsWith("session:"), (sessionId, entryScope = "default") => layer43(sessionId, entryScope).pipe(Layer56.provide(exports_session_repository.memoryLayer)));
 
 // ../runtime/src/inbox/inbox-service.ts
-import { Clock as Clock12, Context as Context61, Effect as Effect81, Layer as Layer67, Schema as Schema75 } from "effect";
+import { Clock as Clock12, Context as Context61, Effect as Effect81, Layer as Layer67, Schema as Schema76 } from "effect";
 
 // ../runtime/src/wait/wait-signal.ts
-import { Effect as Effect80, Schema as Schema74 } from "effect";
+import { Effect as Effect80, Schema as Schema75 } from "effect";
 
 // ../runtime/src/workflow/execution-workflow.ts
 import { Activity, DurableDeferred, Workflow as Workflow2, WorkflowEngine } from "effect/unstable/workflow";
-import { Cause, Effect as Effect79, Exit, Function as Function14, Layer as Layer66, Option as Option20, Schema as Schema73 } from "effect";
+import { Cause, Effect as Effect79, Exit, Function as Function14, Layer as Layer66, Option as Option20, Schema as Schema74 } from "effect";
 
 // ../runtime/src/address/address-resolution-service.ts
-import { Context as Context53, Effect as Effect71, Layer as Layer58, Schema as Schema65 } from "effect";
+import { Context as Context53, Effect as Effect71, Layer as Layer58, Schema as Schema66 } from "effect";
 
 // ../runtime/src/address/address-book-service.ts
-import { Context as Context52, Effect as Effect70, Layer as Layer57, Ref as Ref15, Schema as Schema64 } from "effect";
+import { Context as Context52, Effect as Effect70, Layer as Layer57, Ref as Ref15, Schema as Schema65 } from "effect";
 var RouteKind2 = exports_address_schema.RouteKind;
 var Route = exports_address_schema.Route;
 var RouteRecord = exports_address_schema.RouteRecord;
 
-class AddressNotFound2 extends Schema64.TaggedErrorClass()("AddressNotFound", {
+class AddressNotFound2 extends Schema65.TaggedErrorClass()("AddressNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class AddressUnavailable extends Schema64.TaggedErrorClass()("AddressUnavailable", {
+class AddressUnavailable extends Schema65.TaggedErrorClass()("AddressUnavailable", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema64.String
+  route_key: Schema65.String
 }) {
 }
 
-class AddressDeferred extends Schema64.TaggedErrorClass()("AddressDeferred", {
+class AddressDeferred extends Schema65.TaggedErrorClass()("AddressDeferred", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema64.String
+  route_key: Schema65.String
 }) {
 }
 
-class AddressBookServiceError extends Schema64.TaggedErrorClass()("AddressBookServiceError", {
-  message: Schema64.String
+class AddressBookServiceError extends Schema65.TaggedErrorClass()("AddressBookServiceError", {
+  message: Schema65.String
 }) {
 }
 
@@ -12800,7 +12876,7 @@ var recordFromEntry = (entry) => ({
   updated_at: entry.updatedAt
 });
 var entryIdFor = (addressId) => exports_ids_schema.AddressBookEntryId.make(`address-book:${addressId}`);
-var validateRoute = (route) => Schema64.decodeUnknownEffect(Route)(route).pipe(Effect70.mapError((error5) => AddressBookServiceError.make({ message: String(error5) })));
+var validateRoute = (route) => Schema65.decodeUnknownEffect(Route)(route).pipe(Effect70.mapError((error5) => AddressBookServiceError.make({ message: String(error5) })));
 var mapRepositoryError5 = (error5) => {
   if (error5._tag === "AddressNotFound") {
     return AddressNotFound2.make({ address_id: error5.address_id });
@@ -12865,41 +12941,41 @@ var list14 = Effect70.fn("AddressBook.list.call")(function* () {
 });
 
 // ../runtime/src/address/address-resolution-service.ts
-class AddressRouteNotFound extends Schema65.TaggedErrorClass()("AddressRouteNotFound", {
+class AddressRouteNotFound extends Schema66.TaggedErrorClass()("AddressRouteNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class AddressRouteKindMismatch extends Schema65.TaggedErrorClass()("AddressRouteKindMismatch", {
+class AddressRouteKindMismatch extends Schema66.TaggedErrorClass()("AddressRouteKindMismatch", {
   address_id: exports_ids_schema.AddressId,
-  expected: Schema65.Literal("local-agent"),
+  expected: Schema66.Literal("local-agent"),
   actual: exports_address_schema.RouteKind,
-  route_key: Schema65.String
+  route_key: Schema66.String
 }) {
 }
 
-class AddressAgentDefinitionNotFound extends Schema65.TaggedErrorClass()("AddressAgentDefinitionNotFound", {
+class AddressAgentDefinitionNotFound extends Schema66.TaggedErrorClass()("AddressAgentDefinitionNotFound", {
   address_id: exports_ids_schema.AddressId,
   agent_id: exports_ids_schema.AgentId
 }) {
 }
 
-class AddressResolutionError extends Schema65.TaggedErrorClass()("AddressResolutionError", {
-  message: Schema65.String
+class AddressResolutionError extends Schema66.TaggedErrorClass()("AddressResolutionError", {
+  message: Schema66.String
 }) {
 }
-var LocalAgentRoute = Schema65.Struct({
-  kind: Schema65.Literal("local-agent"),
+var LocalAgentRoute = Schema66.Struct({
+  kind: Schema66.Literal("local-agent"),
   route_key: exports_shared_schema.NonEmptyString,
-  metadata: Schema65.optionalKey(exports_shared_schema.Metadata)
+  metadata: Schema66.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.AddressResolution.LocalAgentRoute" });
-var LocalAgentTarget = Schema65.Struct({
+var LocalAgentTarget = Schema66.Struct({
   address_id: exports_ids_schema.AddressId,
   route: LocalAgentRoute,
   agent_id: exports_ids_schema.AgentId,
   agent_revision: exports_agent_schema.DefinitionRevision,
   agent_snapshot: exports_agent_schema.Definition,
-  tool_input_schema_digests: Schema65.optionalKey(exports_agent_schema.ToolInputSchemaDigests)
+  tool_input_schema_digests: Schema66.optionalKey(exports_agent_schema.ToolInputSchemaDigests)
 }).annotate({ identifier: "Relay.AddressResolution.LocalAgentTarget" });
 
 class Service53 extends Context53.Service()("@relayfx/runtime/address/address-resolution-service/Service") {
@@ -12932,7 +13008,7 @@ var layer44 = Layer58.effect(Service53, Effect71.gen(function* () {
         return yield* AddressRouteNotFound.make({ address_id: addressId });
       }
       const route = yield* routeToLocalAgent(addressId, record2.route);
-      const agentId = yield* Schema65.decodeUnknownEffect(exports_ids_schema.AgentId)(route.route_key).pipe(Effect71.mapError((error5) => AddressResolutionError.make({ message: String(error5) })));
+      const agentId = yield* Schema66.decodeUnknownEffect(exports_ids_schema.AgentId)(route.route_key).pipe(Effect71.mapError((error5) => AddressResolutionError.make({ message: String(error5) })));
       const definition = yield* agentRegistry.get(agentId).pipe(Effect71.mapError(mapAgentRegistryError));
       if (definition === undefined) {
         return yield* AddressAgentDefinitionNotFound.make({
@@ -12961,13 +13037,14 @@ var resolveLocalAgent = Effect71.fn("AddressResolution.resolveLocalAgent.call")(
 });
 
 // ../runtime/src/agent/agent-loop-error.ts
-import { Schema as Schema66 } from "effect";
+import { Schema as Schema67 } from "effect";
 import { AiError as AiError2 } from "effect/unstable/ai";
 
-class AgentLoopError extends Schema66.TaggedErrorClass()("AgentLoopError", {
-  message: Schema66.String,
-  failure_classification: Schema66.optionalKey(Schema66.Literal("context-overflow")),
-  baton_failure: Schema66.optionalKey(Schema66.Union([
+class AgentLoopError extends Schema67.TaggedErrorClass()("AgentLoopError", {
+  message: Schema67.String,
+  failure_classification: Schema67.optionalKey(Schema67.Literal("context-overflow")),
+  baton_failure: Schema67.optionalKey(Schema67.Union([
+    exports_model_telemetry.DeliveryFailed,
     exports_agent_event.AgentError,
     exports_agent_event.ResumeMismatch,
     exports_turn_policy.TurnPolicyError,
@@ -12981,25 +13058,25 @@ class AgentLoopError extends Schema66.TaggedErrorClass()("AgentLoopError", {
     exports_model_registry.LanguageModelNotRegistered,
     exports_tool_executor.FrameworkFailure
   ])),
-  next_event_sequence: Schema66.optionalKey(exports_execution_schema.ExecutionEventSequence)
+  next_event_sequence: Schema67.optionalKey(exports_execution_schema.ExecutionEventSequence)
 }) {
 }
 
-class AgentLoopBudgetExceeded extends Schema66.TaggedErrorClass()("AgentLoopBudgetExceeded", {
-  tokens_used: Schema66.Int,
-  token_budget: Schema66.Int,
+class AgentLoopBudgetExceeded extends Schema67.TaggedErrorClass()("AgentLoopBudgetExceeded", {
+  tokens_used: Schema67.Int,
+  token_budget: Schema67.Int,
   next_event_sequence: exports_execution_schema.ExecutionEventSequence
 }) {
 }
-var AgentTerminalFailure = Schema66.Union([AgentLoopError, AgentLoopBudgetExceeded]);
+var AgentTerminalFailure = Schema67.Union([AgentLoopError, AgentLoopBudgetExceeded]);
 
 // ../runtime/src/child/parent-notifier-service.ts
-import { Context as Context54, Effect as Effect72, Layer as Layer59, Option as Option16, Ref as Ref16, Schema as Schema67 } from "effect";
-class ParentNotifyError extends Schema67.TaggedErrorClass()("ParentNotifyError", {
-  message: Schema67.String
+import { Context as Context54, Effect as Effect72, Layer as Layer59, Option as Option16, Ref as Ref16, Schema as Schema68 } from "effect";
+class ParentNotifyError extends Schema68.TaggedErrorClass()("ParentNotifyError", {
+  message: Schema68.String
 }) {
 }
-var ChildTerminalStatus = Schema67.Literals(["completed", "failed", "cancelled"]).annotate({
+var ChildTerminalStatus = Schema68.Literals(["completed", "failed", "cancelled"]).annotate({
   identifier: "Relay.ParentNotifier.ChildTerminalStatus"
 });
 
@@ -13080,15 +13157,15 @@ var notify = Effect72.fn("ParentNotifier.notify.call")(function* (input) {
 });
 
 // ../runtime/src/skill/skill-registry-service.ts
-import { Clock as Clock10, Context as Context55, Effect as Effect73, Layer as Layer60, Schema as Schema68 } from "effect";
+import { Clock as Clock10, Context as Context55, Effect as Effect73, Layer as Layer60, Schema as Schema69 } from "effect";
 
-class SkillDefinitionInvalid extends Schema68.TaggedErrorClass()("SkillDefinitionInvalid", {
-  message: Schema68.String
+class SkillDefinitionInvalid extends Schema69.TaggedErrorClass()("SkillDefinitionInvalid", {
+  message: Schema69.String
 }) {
 }
 
-class SkillRegistryError extends Schema68.TaggedErrorClass()("SkillRegistryError", {
-  message: Schema68.String
+class SkillRegistryError extends Schema69.TaggedErrorClass()("SkillRegistryError", {
+  message: Schema69.String
 }) {
 }
 
@@ -13241,16 +13318,16 @@ var sourceForExecution = Effect73.fn("SkillRegistry.sourceForExecution.call")(fu
 });
 
 // ../runtime/src/execution/execution-service.ts
-import { Clock as Clock11, Context as Context56, Effect as Effect74, Layer as Layer61, Option as Option17, Schema as Schema69, Stream as Stream12 } from "effect";
+import { Clock as Clock11, Context as Context56, Effect as Effect74, Layer as Layer61, Option as Option17, Schema as Schema70, Stream as Stream12 } from "effect";
 import { ShardingConfig } from "effect/unstable/cluster";
 var ExecutionServiceErrorDetails = exports_shared_schema.JsonValue.annotate({
   identifier: "Relay.ExecutionServiceErrorDetails"
 });
 
-class ExecutionServiceError extends Schema69.TaggedErrorClass()("ExecutionServiceError", {
-  message: Schema69.String,
-  details: Schema69.optionalKey(ExecutionServiceErrorDetails),
-  next_event_sequence: Schema69.optionalKey(exports_execution_schema.ExecutionEventSequence)
+class ExecutionServiceError extends Schema70.TaggedErrorClass()("ExecutionServiceError", {
+  message: Schema70.String,
+  details: Schema70.optionalKey(ExecutionServiceErrorDetails),
+  next_event_sequence: Schema70.optionalKey(exports_execution_schema.ExecutionEventSequence)
 }) {
 }
 
@@ -13431,7 +13508,7 @@ var existingTerminalExecution = Effect74.fn("ExecutionService.existingTerminalEx
     execution: undefined,
     failure: ExecutionServiceError.make({
       message: typeof metadata11.message === "string" ? metadata11.message : "Execution failed",
-      ...Schema69.is(ExecutionServiceErrorDetails)(metadata11.details) ? { details: metadata11.details } : {},
+      ...Schema70.is(ExecutionServiceErrorDetails)(metadata11.details) ? { details: metadata11.details } : {},
       next_event_sequence: event.sequence
     })
   };
@@ -13674,13 +13751,13 @@ var coordinate = Effect76.fn("ToolTransitionCoordinator.coordinate")(function* (
 });
 
 // ../runtime/src/workspace/workspace-planner-service.ts
-import { Context as Context60, Effect as Effect78, HashSet as HashSet6, Layer as Layer65, Option as Option18, Schema as Schema71 } from "effect";
+import { Context as Context60, Effect as Effect78, HashSet as HashSet6, Layer as Layer65, Option as Option18, Schema as Schema72 } from "effect";
 
 // ../runtime/src/workspace/workspace-runtime-service.ts
-import { Context as Context59, Effect as Effect77, Layer as Layer64, Schema as Schema70 } from "effect";
+import { Context as Context59, Effect as Effect77, Layer as Layer64, Schema as Schema71 } from "effect";
 
-class WorkspaceRuntimeError extends Schema70.TaggedErrorClass()("WorkspaceRuntimeError", {
-  message: Schema70.String
+class WorkspaceRuntimeError extends Schema71.TaggedErrorClass()("WorkspaceRuntimeError", {
+  message: Schema71.String
 }) {
 }
 
@@ -13708,18 +13785,18 @@ var exec = Effect77.fn("WorkspaceRuntime.exec.call")(function* (input) {
 });
 
 // ../runtime/src/workspace/workspace-planner-service.ts
-class WorkspaceRuntimeMissing extends Schema71.TaggedErrorClass()("WorkspaceRuntimeMissing", {
+class WorkspaceRuntimeMissing extends Schema72.TaggedErrorClass()("WorkspaceRuntimeMissing", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspaceLeaseMissingRef extends Schema71.TaggedErrorClass()("WorkspaceLeaseMissingRef", {
+class WorkspaceLeaseMissingRef extends Schema72.TaggedErrorClass()("WorkspaceLeaseMissingRef", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspacePlannerError extends Schema71.TaggedErrorClass()("WorkspacePlannerError", {
-  message: Schema71.String
+class WorkspacePlannerError extends Schema72.TaggedErrorClass()("WorkspacePlannerError", {
+  message: Schema72.String
 }) {
 }
 
@@ -13905,7 +13982,7 @@ var fail = Effect78.fn("WorkspacePlanner.fail.call")(function* (input) {
 });
 
 // ../runtime/src/workflow/execution-workflow-state.ts
-import { Option as Option19, Schema as Schema72 } from "effect";
+import { Option as Option19, Schema as Schema73 } from "effect";
 var toWaitSnapshot = (record2) => ({
   id: record2.id,
   execution_id: record2.executionId,
@@ -13973,7 +14050,7 @@ var waitIdFromExecution = (execution) => {
 };
 var pendingSuspensionFromExecution = (execution) => {
   const pending = execution.metadata?.pending_agent_suspension;
-  return Schema72.decodeUnknownOption(exports_agent_event.AgentSuspended)(pending).pipe(Option19.getOrUndefined);
+  return Schema73.decodeUnknownOption(exports_agent_event.AgentSuspended)(pending).pipe(Option19.getOrUndefined);
 };
 var ExecutionWorkflowState = {
   agentDefinitionPinCount,
@@ -14014,74 +14091,74 @@ var {
   workflowGenerationFromRecord: workflowGenerationFromRecord2
 } = ExecutionWorkflowState;
 
-class ExecutionWorkflowFailed extends Schema73.TaggedErrorClass()("ExecutionWorkflowFailed", {
-  message: Schema73.String,
-  terminal_failure: Schema73.optionalKey(AgentTerminalFailure)
+class ExecutionWorkflowFailed extends Schema74.TaggedErrorClass()("ExecutionWorkflowFailed", {
+  message: Schema74.String,
+  terminal_failure: Schema74.optionalKey(AgentTerminalFailure)
 }) {
 }
 
-class AgentCheckpointCompatibilityError extends Schema73.TaggedErrorClass()("AgentCheckpointCompatibilityError", {
-  message: Schema73.String
+class AgentCheckpointCompatibilityError extends Schema74.TaggedErrorClass()("AgentCheckpointCompatibilityError", {
+  message: Schema74.String
 }) {
 }
-var ExecutionWorkflowError = Schema73.Union([ExecutionWorkflowFailed, AgentCheckpointCompatibilityError]);
-var StartInput = Schema73.Struct({
+var ExecutionWorkflowError = Schema74.Union([ExecutionWorkflowFailed, AgentCheckpointCompatibilityError]);
+var StartInput = Schema74.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   root_address_id: exports_ids_schema.AddressId,
-  session_id: Schema73.optionalKey(exports_ids_schema.SessionId),
-  input: Schema73.optionalKey(Schema73.Array(exports_content_schema.Part)),
+  session_id: Schema74.optionalKey(exports_ids_schema.SessionId),
+  input: Schema74.optionalKey(Schema74.Array(exports_content_schema.Part)),
   event_sequence: exports_execution_schema.ExecutionEventSequence,
   started_at: exports_shared_schema.TimestampMillis,
   completed_at: exports_shared_schema.TimestampMillis,
-  agent_id: Schema73.optionalKey(exports_ids_schema.AgentId),
-  agent_revision: Schema73.optionalKey(exports_agent_schema.DefinitionRevision),
-  agent_snapshot: Schema73.optionalKey(exports_agent_schema.Definition),
-  agent_tool_input_schema_digests: Schema73.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
-  wait_id: Schema73.optionalKey(exports_ids_schema.WaitId),
-  resume_suspension: Schema73.optionalKey(exports_agent_event.AgentSuspended),
-  workflow_generation: Schema73.optionalKey(Schema73.Int.check(Schema73.isGreaterThanOrEqualTo(0))),
-  metadata: Schema73.optionalKey(exports_shared_schema.Metadata)
+  agent_id: Schema74.optionalKey(exports_ids_schema.AgentId),
+  agent_revision: Schema74.optionalKey(exports_agent_schema.DefinitionRevision),
+  agent_snapshot: Schema74.optionalKey(exports_agent_schema.Definition),
+  agent_tool_input_schema_digests: Schema74.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
+  wait_id: Schema74.optionalKey(exports_ids_schema.WaitId),
+  resume_suspension: Schema74.optionalKey(exports_agent_event.AgentSuspended),
+  workflow_generation: Schema74.optionalKey(Schema74.Int.check(Schema74.isGreaterThanOrEqualTo(0))),
+  metadata: Schema74.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.StartInput" });
-var WaitSignalState = Schema73.Literals(["resolved", "timed_out", "cancelled"]).annotate({
+var WaitSignalState = Schema74.Literals(["resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.ExecutionWorkflow.WaitSignalState"
 });
-var WaitSignal = Schema73.Struct({
+var WaitSignal = Schema74.Struct({
   wait_id: exports_ids_schema.WaitId,
   state: WaitSignalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.ExecutionWorkflow.WaitSignal" });
-var SignalWaitInput = Schema73.Struct({
-  workflow_execution_id: Schema73.String,
+var SignalWaitInput = Schema74.Struct({
+  workflow_execution_id: Schema74.String,
   wait_id: exports_ids_schema.WaitId,
   state: WaitSignalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.ExecutionWorkflow.SignalWaitInput" });
-var CancelExecutionInput = Schema73.Struct({
+var CancelExecutionInput = Schema74.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   cancelled_at: exports_shared_schema.TimestampMillis,
-  reason: Schema73.optionalKey(Schema73.String)
+  reason: Schema74.optionalKey(Schema74.String)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.CancelExecutionInput" });
-var CancelExecutionResult = Schema73.Struct({
+var CancelExecutionResult = Schema74.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus
 }).annotate({ identifier: "Relay.ExecutionWorkflow.CancelExecutionResult" });
-var WaitSnapshot = Schema73.Struct({
+var WaitSnapshot = Schema74.Struct({
   id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
-  envelope_id: Schema73.optionalKey(exports_ids_schema.EnvelopeId),
+  envelope_id: Schema74.optionalKey(exports_ids_schema.EnvelopeId),
   mode: exports_envelope_schema.WaitMode,
-  correlation_key: Schema73.optionalKey(Schema73.String),
-  state: Schema73.Literals(["open", "resolved", "timed_out", "cancelled"]),
+  correlation_key: Schema74.optionalKey(Schema74.String),
+  state: Schema74.Literals(["open", "resolved", "timed_out", "cancelled"]),
   metadata: exports_shared_schema.Metadata,
   created_at: exports_shared_schema.TimestampMillis,
-  resolved_at: Schema73.optionalKey(exports_shared_schema.TimestampMillis)
+  resolved_at: Schema74.optionalKey(exports_shared_schema.TimestampMillis)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.WaitSnapshot" });
-var StartResult = Schema73.Struct({
+var StartResult = Schema74.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus,
-  wait_id: Schema73.optionalKey(exports_ids_schema.WaitId),
-  wait_state: Schema73.optionalKey(Schema73.Literals(["resolved", "timed_out", "cancelled"])),
-  metadata: Schema73.optionalKey(exports_shared_schema.Metadata)
+  wait_id: Schema74.optionalKey(exports_ids_schema.WaitId),
+  wait_state: Schema74.optionalKey(Schema74.Literals(["resolved", "timed_out", "cancelled"])),
+  metadata: Schema74.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.StartResult" });
 var StartExecutionWorkflowName = "Relay/Execution/Start";
 var ActivityNames = {
@@ -14129,12 +14206,12 @@ var StartExecutionWorkflow = Workflow2.make(StartExecutionWorkflowName, {
 var mapExecutionError = (error5) => {
   if (error5.details === undefined)
     return ExecutionWorkflowFailed.make({ message: error5.message });
-  const terminalFailure = Schema73.decodeUnknownOption(AgentTerminalFailure)(error5.details).pipe(Option20.getOrUndefined);
+  const terminalFailure = Schema74.decodeUnknownOption(AgentTerminalFailure)(error5.details).pipe(Option20.getOrUndefined);
   return terminalFailure === undefined ? ExecutionWorkflowFailed.make({ message: "Malformed durable agent failure details" }) : ExecutionWorkflowFailed.make({ message: error5.message, terminal_failure: terminalFailure });
 };
 var mapAgentLoopError = (error5) => ExecutionServiceError.make({
   message: error5._tag === "AgentLoopBudgetExceeded" ? `AgentLoopBudgetExceeded: used ${error5.tokens_used} of ${error5.token_budget} tokens` : error5.message,
-  details: error5.pipe(Schema73.encodeSync(AgentTerminalFailure), Schema73.decodeUnknownSync(exports_shared_schema.JsonValue)),
+  details: error5.pipe(Schema74.encodeSync(AgentTerminalFailure), Schema74.decodeUnknownSync(exports_shared_schema.JsonValue)),
   ...error5.next_event_sequence === undefined ? {} : { next_event_sequence: error5.next_event_sequence }
 });
 var mapWaitError2 = (error5) => ExecutionWorkflowFailed.make({
@@ -14283,7 +14360,7 @@ var prepareCancellation = Effect79.fn("ExecutionWorkflow.prepareCancellation")(f
       signals,
       terminalNoop: false
     };
-  })).pipe(Effect79.mapError((error5) => Schema73.is(ExecutionWorkflowFailed)(error5) ? error5 : ExecutionWorkflowFailed.make({ message: "Tool cancellation transaction failed" })));
+  })).pipe(Effect79.mapError((error5) => Schema74.is(ExecutionWorkflowFailed)(error5) ? error5 : ExecutionWorkflowFailed.make({ message: "Tool cancellation transaction failed" })));
 });
 var signalPreparedCancellation = Effect79.fn("ExecutionWorkflow.signalPreparedCancellation")(function* (prepared, signaledAt) {
   for (const pending of prepared.signals) {
@@ -14360,7 +14437,7 @@ var cancelExecution = (input, turn, reason) => Activity.make({
 });
 var loadCancellationRequested = (input, turn) => Activity.make({
   name: ActivityNames.checkCancel(turn),
-  success: Schema73.Boolean,
+  success: Schema74.Boolean,
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     const repository = yield* exports_execution_repository.Service;
@@ -14370,7 +14447,7 @@ var loadCancellationRequested = (input, turn) => Activity.make({
 });
 var loadWait = (name, waitId2) => Activity.make({
   name,
-  success: Schema73.UndefinedOr(WaitSnapshot),
+  success: Schema74.UndefinedOr(WaitSnapshot),
   error: ExecutionWorkflowFailed,
   execute: get11(waitId2).pipe(Effect79.map((record2) => record2 === undefined ? undefined : toWaitSnapshot2(record2)), Effect79.mapError(mapWaitError2))
 });
@@ -14413,7 +14490,7 @@ var decodeOptionalNumberSetting = (value, key4, valid) => {
 var optionalNumberForStart = (input, key4, valid) => decodeOptionalNumberSetting(metadataSetting2(input, key4), key4, valid).pipe(Effect79.map((value) => value === null ? undefined : value));
 var continueAsNewAfterTurnsForStart = (input) => optionalNumberForStart(input, continueAsNewAfterTurnsMetadataKey2, (value) => Number.isInteger(value) && value > 0);
 var toolOutputMaxBytesForStart = (input) => decodeOptionalNumberSetting(metadataSetting2(input, toolOutputMaxBytesMetadataKey2), toolOutputMaxBytesMetadataKey2, (value) => value >= 0);
-var decodeMemorySubject = (value) => typeof value === "string" ? Schema73.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(value).pipe(Effect79.mapError(() => ExecutionWorkflowFailed.make({ message: `Invalid memory_subject_id metadata value: ${value}` }))) : Effect79.fail(ExecutionWorkflowFailed.make({ message: "memory_subject_id metadata value must be a string" }));
+var decodeMemorySubject = (value) => typeof value === "string" ? Schema74.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(value).pipe(Effect79.mapError(() => ExecutionWorkflowFailed.make({ message: `Invalid memory_subject_id metadata value: ${value}` }))) : Effect79.fail(ExecutionWorkflowFailed.make({ message: "memory_subject_id metadata value must be a string" }));
 var memorySubjectForStart = Effect79.fn("ExecutionWorkflow.memorySubjectForStart")(function* (input) {
   const executionSubject = memorySubjectFromMetadata2(input.metadata);
   if (executionSubject !== undefined)
@@ -14424,7 +14501,7 @@ var memorySubjectForStart = Effect79.fn("ExecutionWorkflow.memorySubjectForStart
 var nextEventSequence4 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect79.map((max) => max === undefined ? 0 : max + 1), Effect79.mapError(mapEventLogError6));
 var ensureWorkspace = (input) => Activity.make({
   name: ActivityNames.ensureWorkspace,
-  success: Schema73.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema74.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     if (input.agent_snapshot === undefined)
@@ -14441,19 +14518,19 @@ var ensureWorkspace = (input) => Activity.make({
 });
 var suspendWorkspace = (input, key4) => Activity.make({
   name: ActivityNames.suspendWorkspace(key4),
-  success: Schema73.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema74.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: suspend2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect79.mapError(mapWorkspaceError))
 });
 var resumeWorkspace = (input, key4) => Activity.make({
   name: ActivityNames.resumeWorkspace(key4),
-  success: Schema73.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema74.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: resume2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect79.map((plan2) => plan2?.lease), Effect79.mapError(mapWorkspaceError))
 });
 var releaseWorkspace = (input) => Activity.make({
   name: ActivityNames.releaseWorkspace,
-  success: Schema73.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema74.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: release2({ executionId: input.execution_id, now: input.completed_at }).pipe(Effect79.mapError(mapWorkspaceError))
 });
@@ -14529,7 +14606,7 @@ var completeExecution = (input, waitId2, waitState, workspaceRuntimeLayer, turn,
         ...input.metadata,
         wait_id: wait.wait_id,
         wait_state: "open",
-        pending_agent_suspension: wait.suspension.pipe(Schema73.encodeSync(exports_agent_event.AgentSuspended), Schema73.decodeUnknownSync(exports_shared_schema.JsonValue)),
+        pending_agent_suspension: wait.suspension.pipe(Schema74.encodeSync(exports_agent_event.AgentSuspended), Schema74.decodeUnknownSync(exports_shared_schema.JsonValue)),
         ...generationMetadata2(workflowGenerationForStart2(input))
       },
       nextEventSequence: wait.next_event_sequence
@@ -14545,12 +14622,12 @@ var completeExecution = (input, waitId2, waitState, workspaceRuntimeLayer, turn,
 });
 var failIncompatibleCheckpoint = (input, error5) => Activity.make({
   name: ActivityNames.failIncompatibleCheckpoint,
-  success: Schema73.Void,
+  success: Schema74.Void,
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     const eventLog = yield* Service41;
     const eventSequence = yield* nextEventSequence4(eventLog, input.execution_id);
-    const details = yield* error5.pipe(Schema73.encodeEffect(AgentCheckpointCompatibilityError), Effect79.flatMap(Schema73.decodeUnknownEffect(exports_shared_schema.JsonValue)), Effect79.mapError(() => ExecutionWorkflowFailed.make({ message: "Invalid checkpoint failure details" })));
+    const details = yield* error5.pipe(Schema74.encodeEffect(AgentCheckpointCompatibilityError), Effect79.flatMap(Schema74.decodeUnknownEffect(exports_shared_schema.JsonValue)), Effect79.mapError(() => ExecutionWorkflowFailed.make({ message: "Invalid checkpoint failure details" })));
     yield* run4({
       executionId: input.execution_id,
       eventSequence,
@@ -14565,7 +14642,7 @@ var failIncompatibleCheckpoint = (input, error5) => Activity.make({
 });
 var loadChildCancellationRequested = (input) => Activity.make({
   name: ActivityNames.checkQueuedChildCancellation,
-  success: Schema73.Boolean,
+  success: Schema74.Boolean,
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     const context = childDispatchContext2(input);
@@ -14577,7 +14654,7 @@ var loadChildCancellationRequested = (input) => Activity.make({
 });
 var notifyParentActivity = (input, context, status, output) => Activity.make({
   name: ActivityNames.notifyParent(status),
-  success: Schema73.Void,
+  success: Schema74.Void,
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     const notifier = yield* Effect79.serviceOption(Service54);
@@ -14855,8 +14932,8 @@ var signalWait = Effect79.fn("ExecutionWorkflow.signalWait")(function* (input) {
 });
 
 // ../runtime/src/wait/wait-signal.ts
-class WaitSignalError extends Schema74.TaggedErrorClass()("WaitSignalError", {
-  message: Schema74.String
+class WaitSignalError extends Schema75.TaggedErrorClass()("WaitSignalError", {
+  message: Schema75.String
 }) {
 }
 var signalWorkflowWait = Effect80.fn("WaitSignal.signalWorkflowWait")(function* (input) {
@@ -14875,19 +14952,19 @@ var signalWorkflowWait = Effect80.fn("WaitSignal.signalWorkflowWait")(function*
 });
 
 // ../runtime/src/inbox/inbox-service.ts
-class InboxDeliveryError extends Schema75.TaggedErrorClass()("InboxDeliveryError", {
+class InboxDeliveryError extends Schema76.TaggedErrorClass()("InboxDeliveryError", {
   execution_id: exports_ids_schema.ExecutionId,
-  message: Schema75.String
+  message: Schema76.String
 }) {
 }
 
-class InboxReplyTokenInvalid extends Schema75.TaggedErrorClass()("InboxReplyTokenInvalid", {
-  reply_token: Schema75.String
+class InboxReplyTokenInvalid extends Schema76.TaggedErrorClass()("InboxReplyTokenInvalid", {
+  reply_token: Schema76.String
 }) {
 }
 
-class InboxServiceError extends Schema75.TaggedErrorClass()("InboxServiceError", {
-  message: Schema75.String
+class InboxServiceError extends Schema76.TaggedErrorClass()("InboxServiceError", {
+  message: Schema76.String
 }) {
 }
 
@@ -14995,9 +15072,9 @@ var layerWithSignal = (dependencies) => makeLayer2(dependencies);
 var memoryLayer42 = layer50.pipe(Layer67.provide(exports_inbox_repository.memoryLayer), Layer67.provide(exports_envelope_repository.memoryLayer));
 
 // ../runtime/src/topic/topic-service.ts
-import { Clock as Clock13, Context as Context62, Effect as Effect82, Layer as Layer68, Random as Random2, Schema as Schema76 } from "effect";
-class TopicServiceError extends Schema76.TaggedErrorClass()("TopicServiceError", {
-  message: Schema76.String
+import { Clock as Clock13, Context as Context62, Effect as Effect82, Layer as Layer68, Random as Random2, Schema as Schema77 } from "effect";
+class TopicServiceError extends Schema77.TaggedErrorClass()("TopicServiceError", {
+  message: Schema77.String
 }) {
 }
 
@@ -15073,17 +15150,17 @@ var layer51 = Layer68.effect(Service63, Effect82.gen(function* () {
 var memoryLayer43 = layer51.pipe(Layer68.provide(exports_topic_repository.memoryLayer));
 
 // ../runtime/src/topic/publish-to-topic-tool.ts
-import { Effect as Effect83, Schema as Schema77 } from "effect";
+import { Effect as Effect83, Schema as Schema78 } from "effect";
 var toolName3 = "publish_to_topic";
 var permissionName3 = "relay.topic.publish";
-var ContentInput = Schema77.Union([Schema77.String, Schema77.Array(exports_content_schema.TextPart)]);
-var Input3 = Schema77.Struct({
-  topic: Schema77.String,
+var ContentInput = Schema78.Union([Schema78.String, Schema78.Array(exports_content_schema.TextPart)]);
+var Input3 = Schema78.Struct({
+  topic: Schema78.String,
   content: ContentInput
 }).annotate({ identifier: "Relay.PublishToTopicTool.Input" });
-var Output3 = Schema77.Struct({
-  envelope_id: Schema77.String,
-  subscriber_count: Schema77.Int
+var Output3 = Schema78.Struct({
+  envelope_id: Schema78.String,
+  subscriber_count: Schema78.Int
 }).annotate({ identifier: "Relay.PublishToTopicTool.Output" });
 var registeredTool3 = (config) => tool(toolName3, {
   description: "Publish a durable message to every subscriber of a topic.",
@@ -15105,23 +15182,23 @@ var registeredTool3 = (config) => tool(toolName3, {
 });
 
 // ../runtime/src/inbox/wait-for-messages-tool.ts
-import { Effect as Effect84, Schema as Schema78 } from "effect";
+import { Effect as Effect84, Schema as Schema79 } from "effect";
 var toolName4 = "wait_for_messages";
 var permissionName4 = "relay.inbox.wait";
-var Input4 = Schema78.Struct({ timeout: Schema78.optionalKey(Schema78.String) }).annotate({
+var Input4 = Schema79.Struct({ timeout: Schema79.optionalKey(Schema79.String) }).annotate({
   identifier: "Relay.WaitForMessagesTool.Input"
 });
-var MessageView = Schema78.Struct({
-  sequence: Schema78.Int,
-  from: Schema78.String,
-  content: Schema78.Array(exports_content_schema.TextPart),
-  reply_token: Schema78.optionalKey(Schema78.String),
-  correlation_key: Schema78.optionalKey(Schema78.String),
-  metadata: Schema78.optionalKey(exports_shared_schema.Metadata)
+var MessageView = Schema79.Struct({
+  sequence: Schema79.Int,
+  from: Schema79.String,
+  content: Schema79.Array(exports_content_schema.TextPart),
+  reply_token: Schema79.optionalKey(Schema79.String),
+  correlation_key: Schema79.optionalKey(Schema79.String),
+  metadata: Schema79.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.WaitForMessagesTool.MessageView" });
-var Output4 = Schema78.Struct({
-  status: Schema78.Literals(["messages", "timed_out"]),
-  messages: Schema78.Array(MessageView)
+var Output4 = Schema79.Struct({
+  status: Schema79.Literals(["messages", "timed_out"]),
+  messages: Schema79.Array(MessageView)
 }).annotate({ identifier: "Relay.WaitForMessagesTool.Output" });
 var project = (message) => ({
   sequence: message.sequence,
@@ -15178,18 +15255,18 @@ var registeredTool4 = (config) => tool(toolName4, {
 });
 
 // ../runtime/src/inbox/send-message-tool.ts
-import { Effect as Effect85, Schema as Schema79 } from "effect";
+import { Effect as Effect85, Schema as Schema80 } from "effect";
 var toolName5 = "send_message";
 var permissionName5 = "relay.inbox.send";
-var ContentInput2 = Schema79.Union([Schema79.String, Schema79.Array(exports_content_schema.TextPart)]);
-var Input5 = Schema79.Struct({
-  to: Schema79.String,
+var ContentInput2 = Schema80.Union([Schema80.String, Schema80.Array(exports_content_schema.TextPart)]);
+var Input5 = Schema80.Struct({
+  to: Schema80.String,
   content: ContentInput2,
-  reply_token: Schema79.optionalKey(Schema79.String)
+  reply_token: Schema80.optionalKey(Schema80.String)
 }).annotate({ identifier: "Relay.SendMessageTool.Input" });
-var Output5 = Schema79.Struct({
-  envelope_id: Schema79.String,
-  delivered: Schema79.Literals(["inbox", "outbox", "reply"])
+var Output5 = Schema80.Struct({
+  envelope_id: Schema80.String,
+  delivered: Schema80.Literals(["inbox", "outbox", "reply"])
 }).annotate({ identifier: "Relay.SendMessageTool.Output" });
 var registeredTool5 = (config) => tool(toolName5, {
   description: "Send a durable message to an address or reply to an inbox message.",
@@ -15227,26 +15304,26 @@ var registeredTool5 = (config) => tool(toolName5, {
 });
 
 // ../runtime/src/envelope/envelope-service.ts
-import { Context as Context63, Effect as Effect86, Layer as Layer69, Schema as Schema80 } from "effect";
-class EnvelopeAddressNotFound extends Schema80.TaggedErrorClass()("EnvelopeAddressNotFound", {
+import { Context as Context63, Effect as Effect86, Layer as Layer69, Schema as Schema81 } from "effect";
+class EnvelopeAddressNotFound extends Schema81.TaggedErrorClass()("EnvelopeAddressNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class EnvelopeRouteUnavailable extends Schema80.TaggedErrorClass()("EnvelopeRouteUnavailable", {
+class EnvelopeRouteUnavailable extends Schema81.TaggedErrorClass()("EnvelopeRouteUnavailable", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema80.String
+  route_key: Schema81.String
 }) {
 }
 
-class EnvelopeRouteDeferred extends Schema80.TaggedErrorClass()("EnvelopeRouteDeferred", {
+class EnvelopeRouteDeferred extends Schema81.TaggedErrorClass()("EnvelopeRouteDeferred", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema80.String
+  route_key: Schema81.String
 }) {
 }
 
-class EnvelopeServiceError extends Schema80.TaggedErrorClass()("EnvelopeServiceError", {
-  message: Schema80.String
+class EnvelopeServiceError extends Schema81.TaggedErrorClass()("EnvelopeServiceError", {
+  message: Schema81.String
 }) {
 }
 
@@ -15453,6 +15530,7 @@ var strategy = (config) => {
         const existing = yield* config.repository.get({ executionId: config.executionId, checkpointId: id }).pipe(Effect87.mapError(mapRepositoryError11));
         if (existing !== undefined)
           return existing.summary;
+        yield* config.onSummarizeStarted?.({ turn: request.turn, overflow: request.overflow }) ?? Effect87.void;
         const summary = yield* config.options?.summaryModel === undefined ? base.summarize(plan2, request) : Effect87.scoped(config.options.summaryModel.pipe(Effect87.flatMap(Layer70.build), Effect87.flatMap((context) => Effect87.provide(base.summarize(plan2, request), context))));
         const createdAt = yield* Clock14.currentTimeMillis;
         const input = {
@@ -15478,9 +15556,9 @@ var make8 = (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 Clock15, Effect as Effect88, Layer as Layer71, Option as Option21, Schema as Schema81 } from "effect";
+import { Clock as Clock15, Effect as Effect88, Layer as Layer71, Option as Option21, Schema as Schema82 } from "effect";
 var permissionTokenPrefix = "wait:permission:";
-var jsonValue3 = (value) => Schema81.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
+var jsonValue3 = (value) => Schema82.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
 var waitIdForToolCall = (executionId, toolCallId) => Identifiers.waitId("permission", executionId, toolCallId);
 var tokenFor = (executionId, request) => waitIdForToolCall(executionId, request.call.id);
 var matchingRule = (rules, tool3, params) => {
@@ -15642,7 +15720,7 @@ var awaitAnswer = Effect88.fn("RelayPermissions.awaitAnswer")(function* (config,
 var resolve8 = (config, pending) => pending.token.startsWith(permissionTokenPrefix) ? awaitAnswer(config, pending).pipe(Effect88.orDie) : Effect88.succeed({ _tag: "Approved" });
 var rememberRule = Effect88.fn("RelayPermissions.rememberRule")(function* (config, rule) {
   const createdAt = yield* Clock15.currentTimeMillis;
-  const decodedRule = yield* Schema81.decodeUnknownEffect(exports_agent_schema.PermissionRule)(rule).pipe(Effect88.mapError((error5) => permissionError(error5.message)));
+  const decodedRule = yield* Schema82.decodeUnknownEffect(exports_agent_schema.PermissionRule)(rule).pipe(Effect88.mapError((error5) => permissionError(error5.message)));
   yield* config.repository.remember({
     agent: config.agentName,
     scope: config.scope,
@@ -15660,9 +15738,9 @@ var layer54 = (config) => Layer71.mergeAll(Layer71.succeed(exports_permissions.P
 })));
 
 // ../runtime/src/agent/relay-steering.ts
-import { Clock as Clock16, Effect as Effect89, Layer as Layer72, Schema as Schema82 } from "effect";
-import { Prompt as Prompt5 } from "effect/unstable/ai";
-var jsonValue4 = (value) => Schema82.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+import { Clock as Clock16, Effect as Effect89, Layer as Layer72, Schema as Schema83 } from "effect";
+import { Prompt as Prompt6 } from "effect/unstable/ai";
+var jsonValue4 = (value) => Schema83.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var stringifyJson2 = (value) => JSON.stringify(jsonValue4(value));
 var createdAtForSequence2 = (config, sequence) => config.startedAt + sequence - config.eventSequence;
 var drainId = (config, kind, sequence) => `drain:${config.executionId}:steering:${kind}:sequence:${sequence}`;
@@ -15680,22 +15758,22 @@ var purePromptPart = (part) => {
 };
 var contentToPromptPart2 = (part) => {
   const pure = purePromptPart(part);
-  return pure === undefined ? Prompt5.makePart("text", { text: stringifyJson2(part) }) : contentToPromptPart(pure);
+  return pure === undefined ? Prompt6.makePart("text", { text: stringifyJson2(part) }) : contentToPromptPart(pure);
 };
-var promptForContent = (content) => Prompt5.fromMessages([
-  Prompt5.makeMessage("user", {
-    content: content.length === 0 ? [Prompt5.makePart("text", { text: "" })] : content.map((part) => contentToPromptPart2(part))
+var promptForContent = (content) => Prompt6.fromMessages([
+  Prompt6.makeMessage("user", {
+    content: content.length === 0 ? [Prompt6.makePart("text", { text: "" })] : content.map((part) => contentToPromptPart2(part))
   })
 ]);
 var promptTextParts = (prompt) => prompt.content.flatMap((message) => typeof message.content === "string" ? [exports_content_schema.text(message.content)] : message.content.flatMap((part) => part.type === "text" ? [exports_content_schema.text(part.text)] : []));
 var contentFromMessage = (message) => {
   if (typeof message.prompt === "string")
     return [exports_content_schema.text(message.prompt)];
-  const prompt = Prompt5.make(message.prompt);
+  const prompt = Prompt6.make(message.prompt);
   const textParts = promptTextParts(prompt);
   if (textParts.length > 0)
     return textParts;
-  return [exports_content_schema.text(prompt.pipe(Schema82.encodeSync(Prompt5.Prompt), stringifyJson2))];
+  return [exports_content_schema.text(prompt.pipe(Schema83.encodeSync(Prompt6.Prompt), stringifyJson2))];
 };
 var steeringDeliveredEvent = (config, kind, drain2, messages, sequence) => ({
   id: exports_ids_schema.EventId.make(`event:${drain2.drainId}:delivered`),
@@ -15740,8 +15818,8 @@ var layer55 = (config) => Layer72.succeed(exports_steering.Steering, exports_ste
 }));
 
 // ../runtime/src/agent/relay-tool-executor.ts
-import { Deferred as Deferred3, Effect as Effect90, Layer as Layer73, Option as Option22, Schema as Schema83 } from "effect";
-var jsonValue5 = (value) => Schema83.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+import { Deferred as Deferred3, Effect as Effect90, Layer as Layer73, Option as Option22, Schema as Schema84 } from "effect";
+var jsonValue5 = (value) => Schema84.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var errorDetail = (error5) => {
   switch (error5._tag) {
     case "ToolNotRegistered":
@@ -16057,7 +16135,7 @@ var {
   usageReportedEvent: usageReportedEvent2
 } = AgentLoopEvents;
 
-class AgentLoopWaitRequested extends Schema84.TaggedErrorClass()("AgentLoopWaitRequested", {
+class AgentLoopWaitRequested extends Schema85.TaggedErrorClass()("AgentLoopWaitRequested", {
   wait_id: exports_ids_schema.WaitId,
   tool_call: exports_tool_schema.Call,
   suspension: exports_agent_event.AgentSuspended,
@@ -16067,7 +16145,7 @@ class AgentLoopWaitRequested extends Schema84.TaggedErrorClass()("AgentLoopWaitR
 
 class Service61 extends Context64.Service()("@relayfx/runtime/agent/agent-loop-service/Service") {
 }
-var jsonValue6 = (value) => Schema84.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue6 = (value) => Schema85.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var toolNames = (agent) => HashSet7.fromIterable(agent.tool_names);
 var turnPolicyFromSnapshot = (snapshot2) => {
   switch (snapshot2.kind) {
@@ -16159,7 +16237,7 @@ var runStructuredTurn = Effect93.fn("AgentLoop.runStructuredTurn")(function* (la
     prompt: STRUCTURED_TURN_PROMPT,
     schema: registration.schema,
     objectName: "output"
-  })).pipe(Effect93.mapError((error5) => Schema84.is(AgentLoopError)(error5) ? error5 : loopError(error5, sequence)));
+  })).pipe(Effect93.mapError((error5) => Schema85.is(AgentLoopError)(error5) ? error5 : loopError(error5, sequence)));
   return jsonValue6(response.value);
 });
 var loopError = (error5, nextEventSequence5) => AgentLoopError.make({
@@ -16168,6 +16246,23 @@ var loopError = (error5, nextEventSequence5) => AgentLoopError.make({
 });
 var appendEvent = (eventLog, allocator, event, nextEventSequence5) => appendIdempotentTo(eventLog, event).pipe(Effect93.tap((appended) => allocator.advanceTo(appended.sequence + 1)), Effect93.mapError((error5) => loopError(error5, nextEventSequence5)));
 var compactionCommittedCursor = (executionId, checkpointId2) => `execution:${executionId}:agent-compaction:${checkpointId2}:committed`;
+var appendCompactionStartedEvent = Effect93.fn("AgentLoop.appendCompactionStartedEvent")(function* (eventLog, allocator, input, info) {
+  const cursor = `execution:${input.executionId}:agent-compaction:turn:${info.turn}:started`;
+  const existing = yield* eventLog.findByCursor({ executionId: input.executionId, cursor }).pipe(Effect93.mapError((error5) => loopError(error5, input.eventSequence + 1)));
+  if (Option24.isSome(existing))
+    return;
+  const sequence = yield* allocator.allocate(1);
+  const data = { turn: info.turn, overflow: info.overflow };
+  yield* appendEvent(eventLog, allocator, {
+    id: exports_ids_schema.EventId.make(`event:${input.executionId}:agent-compaction:turn:${info.turn}:started`),
+    execution_id: input.executionId,
+    type: "agent.compaction.started",
+    sequence,
+    cursor,
+    data,
+    created_at: input.startedAt + (sequence - input.eventSequence)
+  }, sequence + 1);
+});
 var appendCompactionCommittedEvent = Effect93.fn("AgentLoop.appendCompactionCommittedEvent")(function* (eventLog, allocator, input, checkpoint) {
   if (input.sessionId === undefined)
     return;
@@ -16193,8 +16288,8 @@ var appendCompactionCommittedEvent = Effect93.fn("AgentLoop.appendCompactionComm
 });
 var toolFromDefinition = (definition) => AiTool2.dynamic(definition.name, {
   description: definition.description,
-  parameters: Schema84.make(exports_tool_schema.parametersSchema(definition.input_schema).ast),
-  success: Schema84.Unknown,
+  parameters: Schema85.make(exports_tool_schema.parametersSchema(definition.input_schema).ast),
+  success: Schema85.Unknown,
   ...definition.needs_approval === undefined ? {} : { needsApproval: definition.needs_approval }
 });
 var toolkitFromRegistered = (registered) => Toolkit2.make(...registered.map((tool3) => toolFromDefinition(tool3.definition)));
@@ -16224,7 +16319,7 @@ var restoreHistory = Effect93.fn("AgentLoop.restoreHistory")(function* (chats, i
   }
   return history;
 });
-var promptEquivalence = Schema84.toEquivalence(Prompt6.Prompt);
+var promptEquivalence = Schema85.toEquivalence(Prompt7.Prompt);
 var reconcileCompactionCheckpoint = Effect93.fn("AgentLoop.reconcileCompactionCheckpoint")(function* (sessions, chats, input, restoredHistory, onCheckpointCommitted, failOnMismatch = false) {
   if (input.sessionId === undefined)
     return restoredHistory;
@@ -16267,10 +16362,10 @@ var toolCallDecodeMaxRetriesConfig = Config4.int("RELAY_AGENT_TOOL_CALL_DECODE_M
 var isToolCallDecodeError = (error5) => AiError3.isAiError(error5) && error5.method === "streamText" && error5.reason._tag === "InvalidOutputError";
 var toolCallDecodeFeedback = (error5, availableToolNames) => {
   const tools = availableToolNames.length === 0 ? "(no tools are available)" : availableToolNames.join(", ");
-  return Prompt6.fromMessages([
-    Prompt6.makeMessage("user", {
+  return Prompt7.fromMessages([
+    Prompt7.makeMessage("user", {
       content: [
-        Prompt6.makePart("text", {
+        Prompt7.makePart("text", {
           text: `Your previous response contained an invalid tool call: ${error5.reason.message}. Only call these tools with arguments matching their input schemas: ${tools}. Re-issue the intended tool calls.`
         })
       ]
@@ -16291,7 +16386,7 @@ var withToolCallDecodeResilience = (base, availableToolNames, maxRetries, record
         if (Cause2.hasInterrupts(cause))
           return Stream13.failCause(cause);
         const error5 = Cause2.squash(cause);
-        const continuation = !emitted && retriesLeft > 0 && isToolCallDecodeError(error5) ? attempt(Prompt6.concat(Prompt6.make(prompt), toolCallDecodeFeedback(error5, availableToolNames)), retriesLeft - 1) : Stream13.failCause(cause);
+        const continuation = !emitted && retriesLeft > 0 && isToolCallDecodeError(error5) ? attempt(Prompt7.concat(Prompt7.make(prompt), toolCallDecodeFeedback(error5, availableToolNames)), retriesLeft - 1) : Stream13.failCause(cause);
         return Stream13.unwrap(recordFailureClassification(exports_model_registry.classifyFailure(base, error5)).pipe(Effect93.as(continuation)));
       }));
     }))));
@@ -16316,7 +16411,7 @@ var restoreContextEpoch = Effect93.fn("AgentLoop.restoreContextEpoch")(function*
   return { baseline: epoch.baseline, dynamicSourceIds: epoch.dynamicSourceIds };
 });
 var mapBatonRunError = (error5, current2) => {
-  if (Schema84.is(exports_agent_event.AgentSuspended)(error5)) {
+  if (Schema85.is(exports_agent_event.AgentSuspended)(error5)) {
     return AgentLoopWaitRequested.make({
       wait_id: exports_ids_schema.WaitId.make(error5.token),
       tool_call: {
@@ -16329,29 +16424,31 @@ var mapBatonRunError = (error5, current2) => {
     });
   }
   let message;
-  if (Schema84.is(exports_agent_event.AgentError)(error5))
+  if (Schema85.is(exports_model_telemetry.DeliveryFailed)(error5))
+    message = `Telemetry delivery failed: ${error5.message}`;
+  else if (Schema85.is(exports_agent_event.AgentError)(error5))
     message = error5.message;
-  else if (Schema84.is(exports_agent_event.ResumeMismatch)(error5))
+  else if (Schema85.is(exports_agent_event.ResumeMismatch)(error5))
     message = `Resume mismatch: ${error5.reason}`;
-  else if (Schema84.is(exports_turn_policy.TurnPolicyError)(error5))
+  else if (Schema85.is(exports_turn_policy.TurnPolicyError)(error5))
     message = error5.message;
-  else if (Schema84.is(exports_agent_event.TurnPolicyStopped)(error5))
+  else if (Schema85.is(exports_agent_event.TurnPolicyStopped)(error5))
     message = `Turn policy stopped at turn ${error5.turn}`;
-  else if (Schema84.is(exports_agent_event.TurnLimitExceeded)(error5))
+  else if (Schema85.is(exports_agent_event.TurnLimitExceeded)(error5))
     message = "Tool call turn limit exceeded";
-  else if (Schema84.is(exports_agent_event.MiddlewareViolation)(error5))
+  else if (Schema85.is(exports_agent_event.MiddlewareViolation)(error5))
     message = `ModelMiddleware violation at turn ${error5.turn}: ${error5.detail}`;
-  else if (Schema84.is(exports_agent_event.DuplicateToolCallId)(error5))
+  else if (Schema85.is(exports_agent_event.DuplicateToolCallId)(error5))
     message = `Duplicate tool call id: ${error5.id}`;
-  else if (Schema84.is(exports_agent_event.ProgressOverflow)(error5))
+  else if (Schema85.is(exports_agent_event.ProgressOverflow)(error5))
     message = `Tool progress overflow: ${error5.toolCallId}`;
-  else if (Schema84.is(exports_agent_event.ToolNameCollision)(error5))
+  else if (Schema85.is(exports_agent_event.ToolNameCollision)(error5))
     message = `Tool name collision: ${error5.name}`;
-  else if (Schema84.is(AiError3.AiError)(error5))
+  else if (Schema85.is(AiError3.AiError)(error5))
     message = error5.message;
-  else if (Schema84.is(exports_model_registry.LanguageModelNotRegistered)(error5))
+  else if (Schema85.is(exports_model_registry.LanguageModelNotRegistered)(error5))
     message = `Language model not registered: ${error5.provider}/${error5.model}`;
-  else if (Schema84.is(exports_tool_executor.FrameworkFailure)(error5))
+  else if (Schema85.is(exports_tool_executor.FrameworkFailure)(error5))
     message = error5.message;
   else {
     const exhaustive = error5;
@@ -16359,14 +16456,14 @@ var mapBatonRunError = (error5, current2) => {
   }
   return AgentLoopError.make({ message, baton_failure: error5, next_event_sequence: current2 });
 };
-var isBatonRunError = (error5) => Schema84.is(exports_agent_event.AgentSuspended)(error5) || Schema84.is(exports_agent_event.ResumeMismatch)(error5) || Schema84.is(exports_turn_policy.TurnPolicyError)(error5) || Schema84.is(exports_agent_event.TurnPolicyStopped)(error5) || Schema84.is(exports_agent_event.TurnLimitExceeded)(error5) || Schema84.is(exports_agent_event.MiddlewareViolation)(error5) || Schema84.is(exports_agent_event.DuplicateToolCallId)(error5) || Schema84.is(exports_agent_event.ProgressOverflow)(error5) || Schema84.is(exports_agent_event.ToolNameCollision)(error5) || Schema84.is(exports_agent_event.AgentError)(error5) || Schema84.is(AiError3.AiError)(error5) || Schema84.is(exports_model_registry.LanguageModelNotRegistered)(error5) || Schema84.is(exports_tool_executor.FrameworkFailure)(error5);
+var isBatonRunError = (error5) => Schema85.is(exports_agent_event.AgentSuspended)(error5) || Schema85.is(exports_agent_event.ResumeMismatch)(error5) || Schema85.is(exports_turn_policy.TurnPolicyError)(error5) || Schema85.is(exports_agent_event.TurnPolicyStopped)(error5) || Schema85.is(exports_agent_event.TurnLimitExceeded)(error5) || Schema85.is(exports_agent_event.MiddlewareViolation)(error5) || Schema85.is(exports_agent_event.DuplicateToolCallId)(error5) || Schema85.is(exports_agent_event.ProgressOverflow)(error5) || Schema85.is(exports_agent_event.ToolNameCollision)(error5) || Schema85.is(exports_agent_event.AgentError)(error5) || Schema85.is(AiError3.AiError)(error5) || Schema85.is(exports_model_registry.LanguageModelNotRegistered)(error5) || Schema85.is(exports_tool_executor.FrameworkFailure)(error5);
 var mapBoundaryError = (errorOrCurrent, current2, failureClassification) => {
   if (current2 === undefined) {
     const sequence = errorOrCurrent;
     return (error6) => mapBoundaryError(error6, sequence);
   }
   const error5 = errorOrCurrent;
-  if (Schema84.is(AgentLoopError)(error5) || Schema84.is(AgentLoopWaitRequested)(error5) || Schema84.is(AgentLoopBudgetExceeded)(error5))
+  if (Schema85.is(AgentLoopError)(error5) || Schema85.is(AgentLoopWaitRequested)(error5) || Schema85.is(AgentLoopBudgetExceeded)(error5))
     return error5;
   const mapped = isBatonRunError(error5) ? mapBatonRunError(error5, current2) : loopError(error5, current2);
   return mapped._tag === "AgentLoopError" && failureClassification === "context-overflow" ? AgentLoopError.make({
@@ -16384,9 +16481,9 @@ var terminalMemoryTranscript = (prompt, text) => {
     return;
   if (promptHasAssistantText(prompt, text))
     return prompt;
-  return Prompt6.fromMessages([
+  return Prompt7.fromMessages([
     ...prompt.content,
-    Prompt6.makeMessage("assistant", { content: [Prompt6.makePart("text", { text })] })
+    Prompt7.makeMessage("assistant", { content: [Prompt7.makePart("text", { text })] })
   ]);
 };
 var recallOnlyMemory = (memory) => exports_memory.Memory.of({
@@ -16609,7 +16706,8 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
       const compactionService = activeCompactionOptions === undefined ? undefined : exports_compaction.Compaction.of(make8({
         executionId: input.executionId,
         repository: activeCompactionRepository,
-        options: activeCompactionOptions
+        options: activeCompactionOptions,
+        onSummarizeStarted: (info) => appendCompactionStartedEvent(eventLog, allocator, input, info).pipe(Effect93.mapError((error5) => exports_compaction.CompactionError.make({ message: error5.message, cause: error5 })))
       }));
       if (memory !== undefined && Option24.isNone(durableMemory)) {
         return yield* AgentLoopError.make({
@@ -16752,7 +16850,7 @@ var run5 = Effect93.fn("AgentLoop.run.call")(function* (input) {
 // ../runtime/src/cluster/execution-entity.ts
 import { ClusterSchema, Entity } from "effect/unstable/cluster";
 import { Rpc } from "effect/unstable/rpc";
-import { Schema as Schema85 } from "effect";
+import { Schema as Schema86 } from "effect";
 var Start = Rpc.make("start", {
   payload: StartInput,
   success: StartResult,
@@ -16760,12 +16858,12 @@ var Start = Rpc.make("start", {
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var SignalWait = Rpc.make("signalWait", {
   payload: SignalWaitInput,
-  success: Schema85.Void,
+  success: Schema86.Void,
   error: ExecutionWorkflowFailed
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var Dispatch = Rpc.make("dispatch", {
   payload: StartInput,
-  success: Schema85.Void,
+  success: Schema86.Void,
   error: ExecutionWorkflowError
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var Cancel = Rpc.make("cancel", {
@@ -16788,10 +16886,10 @@ var layer59 = entity.toLayer(entity.of({
 var client = entity.client;
 
 // ../runtime/src/execution/execution-watch-service.ts
-import { Config as Config5, Context as Context65, Duration as Duration4, Effect as Effect94, Layer as Layer76, Ref as Ref20, Schema as Schema86, Stream as Stream14 } from "effect";
+import { Config as Config5, Context as Context65, Duration as Duration4, Effect as Effect94, Layer as Layer76, Ref as Ref20, Schema as Schema87, Stream as Stream14 } from "effect";
 
-class ExecutionWatchError extends Schema86.TaggedErrorClass()("ExecutionWatchError", {
-  message: Schema86.String
+class ExecutionWatchError extends Schema87.TaggedErrorClass()("ExecutionWatchError", {
+  message: Schema87.String
 }) {
 }
 
@@ -16839,20 +16937,20 @@ var layerFromServices = Layer76.effect(Service65, Effect94.gen(function* () {
 }));
 
 // ../runtime/src/resident/resident-registry-service.ts
-import { Context as Context66, Effect as Effect95, Layer as Layer77, Schema as Schema87 } from "effect";
-class ResidentKindNotFound extends Schema87.TaggedErrorClass()("ResidentKindNotFound", {
+import { Context as Context66, Effect as Effect95, Layer as Layer77, Schema as Schema88 } from "effect";
+class ResidentKindNotFound extends Schema88.TaggedErrorClass()("ResidentKindNotFound", {
   kind: exports_ids_schema.ResidentKindName
 }) {
 }
 
-class ResidentKindInvalid extends Schema87.TaggedErrorClass()("ResidentKindInvalid", {
+class ResidentKindInvalid extends Schema88.TaggedErrorClass()("ResidentKindInvalid", {
   kind: exports_ids_schema.ResidentKindName,
-  message: Schema87.String
+  message: Schema88.String
 }) {
 }
 
-class ResidentRegistryError extends Schema87.TaggedErrorClass()("ResidentRegistryError", {
-  message: Schema87.String
+class ResidentRegistryError extends Schema88.TaggedErrorClass()("ResidentRegistryError", {
+  message: Schema88.String
 }) {
 }
 
@@ -16884,21 +16982,21 @@ var layer60 = Layer77.effect(Service66, Effect95.gen(function* () {
 }));
 
 // ../runtime/src/resident/resident-instance-service.ts
-import { Context as Context67, Effect as Effect96, Function as Function16, Layer as Layer78, Schema as Schema88 } from "effect";
-class ResidentDestroyed extends Schema88.TaggedErrorClass()("ResidentDestroyed", {
+import { Context as Context67, Effect as Effect96, Function as Function16, Layer as Layer78, Schema as Schema89 } from "effect";
+class ResidentDestroyed extends Schema89.TaggedErrorClass()("ResidentDestroyed", {
   kind: exports_ids_schema.ResidentKindName,
   key: exports_ids_schema.ResidentKey
 }) {
 }
 
-class ResidentNotFound2 extends Schema88.TaggedErrorClass()("ResidentNotFound", {
+class ResidentNotFound2 extends Schema89.TaggedErrorClass()("ResidentNotFound", {
   kind: exports_ids_schema.ResidentKindName,
   key: exports_ids_schema.ResidentKey
 }) {
 }
 
-class ResidentServiceError extends Schema88.TaggedErrorClass()("ResidentServiceError", {
-  message: Schema88.String
+class ResidentServiceError extends Schema89.TaggedErrorClass()("ResidentServiceError", {
+  message: Schema89.String
 }) {
 }
 
@@ -17001,9 +17099,9 @@ var layer61 = Layer78.effect(Service67, Effect96.gen(function* () {
 }));
 
 // ../runtime/src/execution/session-stream-service.ts
-import { Config as Config6, Context as Context68, Duration as Duration5, Effect as Effect97, HashSet as HashSet8, Layer as Layer79, Ref as Ref21, Schema as Schema89, Stream as Stream15 } from "effect";
-class SessionStreamError extends Schema89.TaggedErrorClass()("SessionStreamError", {
-  message: Schema89.String
+import { Config as Config6, Context as Context68, Duration as Duration5, Effect as Effect97, HashSet as HashSet8, Layer as Layer79, Ref as Ref21, Schema as Schema90, Stream as Stream15 } from "effect";
+class SessionStreamError extends Schema90.TaggedErrorClass()("SessionStreamError", {
+  message: Schema90.String
 }) {
 }
 
@@ -17036,15 +17134,15 @@ var layerFromServices2 = Layer79.effect(Service68, Effect97.gen(function* () {
 }));
 
 // ../runtime/src/schedule/scheduler-service.ts
-import { Clock as Clock17, Config as Config7, Context as Context69, Cron, DateTime as DateTime2, Duration as Duration6, Effect as Effect98, Layer as Layer80, Option as Option25, Random as Random3, Result as Result3, Schema as Schema90 } from "effect";
-class SchedulerError extends Schema90.TaggedErrorClass()("SchedulerError", {
-  message: Schema90.String
+import { Clock as Clock17, Config as Config7, Context as Context69, Cron, DateTime as DateTime2, Duration as Duration6, Effect as Effect98, Layer as Layer80, Option as Option25, Random as Random3, Result as Result3, Schema as Schema91 } from "effect";
+class SchedulerError extends Schema91.TaggedErrorClass()("SchedulerError", {
+  message: Schema91.String
 }) {
 }
 
-class ScheduleCronInvalid extends Schema90.TaggedErrorClass()("ScheduleCronInvalid", {
-  cron_expr: Schema90.String,
-  message: Schema90.String
+class ScheduleCronInvalid extends Schema91.TaggedErrorClass()("ScheduleCronInvalid", {
+  cron_expr: Schema91.String,
+  message: Schema91.String
 }) {
 }
 
@@ -17199,25 +17297,25 @@ var runOnce2 = Effect98.fn("SchedulerService.runOnce.call")(function* () {
 });
 
 // ../runtime/src/runner/runner-runtime-service.ts
-var DatabaseMode = Schema91.Literals(["sql", "pg", "mysql", "sqlite", "memory"]).annotate({
+var DatabaseMode = Schema92.Literals(["sql", "pg", "mysql", "sqlite", "memory"]).annotate({
   identifier: "Relay.RunnerRuntime.DatabaseMode"
 });
-var ReadinessStatus = Schema91.Struct({
+var ReadinessStatus = Schema92.Struct({
   database: DatabaseMode,
-  cluster: Schema91.Literal("ready"),
-  workflow: Schema91.Literals(["ready", "client"]),
-  executionEntity: Schema91.Literals(["registered", "client"])
+  cluster: Schema92.Literal("ready"),
+  workflow: Schema92.Literals(["ready", "client"]),
+  executionEntity: Schema92.Literals(["registered", "client"])
 }).annotate({ identifier: "Relay.RunnerRuntime.ReadinessStatus" });
 
-class RunnerRuntimeError extends Schema91.TaggedErrorClass()("RunnerRuntimeError", {
-  message: Schema91.String
+class RunnerRuntimeError extends Schema92.TaggedErrorClass()("RunnerRuntimeError", {
+  message: Schema92.String
 }) {
 }
 
-class ClusterConfigMismatch extends Schema91.TaggedErrorClass()("ClusterConfigMismatch", {
-  field: Schema91.String,
-  expected: Schema91.String,
-  actual: Schema91.String
+class ClusterConfigMismatch extends Schema92.TaggedErrorClass()("ClusterConfigMismatch", {
+  field: Schema92.String,
+  expected: Schema92.String,
+  actual: Schema92.String
 }) {
 }
 
@@ -17231,7 +17329,7 @@ var memoryClusterLayer = Sharding.layer.pipe(Layer81.provideMerge(Runners.layerN
 var clusterHost = Config8.string("RELAY_CLUSTER_HOST").pipe(Config8.withDefault("localhost"));
 var clusterPort = Config8.int("RELAY_CLUSTER_PORT").pipe(Config8.withDefault(34431));
 var clusterShardsPerGroup = Config8.int("RELAY_CLUSTER_SHARDS_PER_GROUP").pipe(Config8.withDefault(300));
-var clusterShardGroups = Config8.schema(Config8.Array(Schema91.String), "RELAY_CLUSTER_SHARD_GROUPS").pipe(Config8.withDefault(["default", "execution"]));
+var clusterShardGroups = Config8.schema(Config8.Array(Schema92.String), "RELAY_CLUSTER_SHARD_GROUPS").pipe(Config8.withDefault(["default", "execution"]));
 var runnerAddressKey = (address) => `${address.host}:${address.port}`;
 var runnerAddressEquals = (left, right) => left.host === right.host && left.port === right.port;
 var shardingConfigFromEnv = Layer81.effect(ShardingConfig2.ShardingConfig, Effect99.gen(function* () {
@@ -17562,24 +17660,24 @@ var check = Effect99.fn("RunnerRuntime.check.call")(function* () {
 });
 
 // ../runtime/src/workflow/definition-runtime.ts
-import { Cause as Cause3, Clock as Clock18, Context as Context71, Effect as Effect100, Exit as Exit2, FiberMap as FiberMap2, Layer as Layer82, Option as Option27, Schema as Schema92 } from "effect";
+import { Cause as Cause3, Clock as Clock18, Context as Context71, Effect as Effect100, Exit as Exit2, FiberMap as FiberMap2, Layer as Layer82, Option as Option27, Schema as Schema93 } from "effect";
 import { dual as dual2 } from "effect/Function";
 
-class UnsupportedOperation extends Schema92.TaggedErrorClass()("UnsupportedWorkflowOperation", { operation_id: exports_ids_schema.WorkflowOperationId, kind: Schema92.String }) {
+class UnsupportedOperation extends Schema93.TaggedErrorClass()("UnsupportedWorkflowOperation", { operation_id: exports_ids_schema.WorkflowOperationId, kind: Schema93.String }) {
 }
 
-class PinnedDefinitionNotFound extends Schema92.TaggedErrorClass()("PinnedWorkflowDefinitionNotFound", { execution_id: exports_ids_schema.ExecutionId }) {
+class PinnedDefinitionNotFound extends Schema93.TaggedErrorClass()("PinnedWorkflowDefinitionNotFound", { execution_id: exports_ids_schema.ExecutionId }) {
 }
 
-class PinnedDefinitionMismatch extends Schema92.TaggedErrorClass()("PinnedWorkflowDefinitionMismatch", { execution_id: exports_ids_schema.ExecutionId }) {
+class PinnedDefinitionMismatch extends Schema93.TaggedErrorClass()("PinnedWorkflowDefinitionMismatch", { execution_id: exports_ids_schema.ExecutionId }) {
 }
 
-class WorkflowRuntimeError extends Schema92.TaggedErrorClass()("WorkflowRuntimeError", {
-  message: Schema92.String
+class WorkflowRuntimeError extends Schema93.TaggedErrorClass()("WorkflowRuntimeError", {
+  message: Schema93.String
 }) {
 }
 
-class WorkflowJoinPolicyNotSatisfied extends Schema92.TaggedErrorClass()("WorkflowJoinPolicyNotSatisfied", { policy: Schema92.String }) {
+class WorkflowJoinPolicyNotSatisfied extends Schema93.TaggedErrorClass()("WorkflowJoinPolicyNotSatisfied", { policy: Schema93.String }) {
 }
 var runtimeError2 = (error5) => WorkflowRuntimeError.make({ message: String(error5) });
 var mapRuntimeError2 = Effect100.mapError(runtimeError2);
@@ -17592,13 +17690,13 @@ class Service71 extends Context71.Service()("@relayfx/runtime/workflow/definitio
 var fanOutIdFor = dual2(2, (executionId, fanOutKey) => exports_ids_schema.ChildFanOutId.make(`workflow:${executionId}:fan-out:${fanOutKey}`));
 var childExecutionIdFor = (fanOutId, operationId2) => exports_ids_schema.ChildExecutionId.make(`${fanOutId}:member:${operationId2}`);
 
-class WorkflowCancelled extends Schema92.TaggedErrorClass()("WorkflowCancelled", {}) {
+class WorkflowCancelled extends Schema93.TaggedErrorClass()("WorkflowCancelled", {}) {
 }
 
-class WorkflowBudgetExceeded extends Schema92.TaggedErrorClass()("WorkflowBudgetExceeded", { operation_id: exports_ids_schema.WorkflowOperationId }) {
+class WorkflowBudgetExceeded extends Schema93.TaggedErrorClass()("WorkflowBudgetExceeded", { operation_id: exports_ids_schema.WorkflowOperationId }) {
 }
 
-class WorkflowJoining extends Schema92.TaggedErrorClass()("WorkflowJoining", {
+class WorkflowJoining extends Schema93.TaggedErrorClass()("WorkflowJoining", {
   fan_out_id: exports_ids_schema.ChildFanOutId
 }) {
 }
@@ -17853,7 +17951,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
         break;
       }
       case "cancellation":
-        output2 = yield* execute(operation.operation).pipe(Effect100.catchIf(Schema92.is(WorkflowCancelled), () => operation.on_cancel === undefined ? Effect100.fail(WorkflowCancelled.make()) : execute(operation.on_cancel)));
+        output2 = yield* execute(operation.operation).pipe(Effect100.catchIf(Schema93.is(WorkflowCancelled), () => operation.on_cancel === undefined ? Effect100.fail(WorkflowCancelled.make()) : execute(operation.on_cancel)));
         break;
       case "compensation":
         output2 = yield* execute(operation.operation);
@@ -17900,7 +17998,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
   const result = yield* Effect100.exit(execute(revision.definition.entry_operation_id));
   if (Exit2.isFailure(result)) {
     const failure2 = Cause3.findErrorOption(result.cause);
-    if (Option27.isSome(failure2) && Schema92.is(WorkflowJoining)(failure2.value))
+    if (Option27.isSome(failure2) && Schema93.is(WorkflowJoining)(failure2.value))
       return yield* result;
     const currentRun = yield* repository.inspect(executionId);
     if (currentRun?.status === "cancelled") {
@@ -17971,12 +18069,12 @@ var layerFromRuntime2 = Layer82.effect(Service71, Effect100.gen(function* () {
 }));
 
 // src/runtime.ts
-import { Cause as Cause5, Context as Context74, Effect as Effect112, Layer as Layer86, Option as Option31, Schema as Schema100 } from "effect";
+import { Cause as Cause5, Context as Context74, Effect as Effect112, Layer as Layer86, Option as Option31, Schema as Schema101 } from "effect";
 import { SqlClient as SqlClient31 } from "effect/unstable/sql/SqlClient";
 
 // src/runtime-acquisition-error.ts
-import { Cause as Cause4, Function as Function17, Schema as Schema93 } from "effect";
-var RuntimeConfigurationCategory = Schema93.Literals([
+import { Cause as Cause4, Function as Function17, Schema as Schema94 } from "effect";
+var RuntimeConfigurationCategory = Schema94.Literals([
   "missing-http-client",
   "provider-config",
   "model-registration",
@@ -17984,31 +18082,31 @@ var RuntimeConfigurationCategory = Schema93.Literals([
   "database-config",
   "unknown-host-layer"
 ]);
-var RuntimeConfigurationScope = Schema93.Literals(["host-layer", "database-client"]);
+var RuntimeConfigurationScope = Schema94.Literals(["host-layer", "database-client"]);
 
-class RuntimeHostLayerFailure extends Schema93.TaggedErrorClass()("RuntimeHostLayerFailure", { category: RuntimeConfigurationCategory }) {
+class RuntimeHostLayerFailure extends Schema94.TaggedErrorClass()("RuntimeHostLayerFailure", { category: RuntimeConfigurationCategory }) {
 }
-var SafeCauseReason = Schema93.TaggedUnion({
+var SafeCauseReason = Schema94.TaggedUnion({
   Fail: {
     category: RuntimeConfigurationCategory,
-    errorTag: Schema93.Literals(["RuntimeHostLayerFailure", "UnknownTypedFailure"])
+    errorTag: Schema94.Literals(["RuntimeHostLayerFailure", "UnknownTypedFailure"])
   },
-  Die: { defectTag: Schema93.Literal("UnknownDefect") },
+  Die: { defectTag: Schema94.Literal("UnknownDefect") },
   Interrupt: {}
 });
-var SafeCause = Schema93.Struct({
-  reasons: Schema93.Array(SafeCauseReason).check(Schema93.isMaxLength(16)),
-  truncated: Schema93.Boolean
+var SafeCause = Schema94.Struct({
+  reasons: Schema94.Array(SafeCauseReason).check(Schema94.isMaxLength(16)),
+  truncated: Schema94.Boolean
 });
 
-class RuntimeConfigurationError extends Schema93.TaggedErrorClass()("RuntimeConfigurationError", {
+class RuntimeConfigurationError extends Schema94.TaggedErrorClass()("RuntimeConfigurationError", {
   category: RuntimeConfigurationCategory,
   scope: RuntimeConfigurationScope,
   cause: SafeCause
 }) {
 }
 var typedFailure = (error5) => {
-  if (Schema93.is(RuntimeHostLayerFailure)(error5)) {
+  if (Schema94.is(RuntimeHostLayerFailure)(error5)) {
     return { _tag: "Fail", category: error5.category, errorTag: "RuntimeHostLayerFailure" };
   }
   return { _tag: "Fail", category: "unknown-host-layer", errorTag: "UnknownTypedFailure" };
@@ -18027,11 +18125,11 @@ var safeCause = (cause) => {
 var normalizeAcquisitionCauseImpl = (cause, scope, preserve) => {
   const summary = safeCause(cause);
   return Cause4.map(cause, (error5) => {
-    if (Schema93.is(RuntimeConfigurationError)(error5) || preserve !== undefined && preserve(error5))
+    if (Schema94.is(RuntimeConfigurationError)(error5) || preserve !== undefined && preserve(error5))
       return error5;
     const reason = typedFailure(error5);
     return RuntimeConfigurationError.make({
-      category: Schema93.is(RuntimeHostLayerFailure)(error5) ? reason.category : scope === "database-client" ? "database-config" : "unknown-host-layer",
+      category: Schema94.is(RuntimeHostLayerFailure)(error5) ? reason.category : scope === "database-client" ? "database-config" : "unknown-host-layer",
       scope,
       cause: summary
     });
@@ -18053,16 +18151,16 @@ var renderConfigurationError = (error5) => {
   return `Runtime configuration error [${error5.category}/${error5.scope}]: ${remediation}; causes=${reasons}${error5.cause.truncated ? ",truncated" : ""}`;
 };
 // src/internal-client.ts
-import { Clock as Clock19, Effect as Effect109, Layer as Layer84, Option as Option30, Random as Random4, Schema as Schema99, Stream as Stream17 } from "effect";
+import { Clock as Clock19, Effect as Effect109, Layer as Layer84, Option as Option30, Random as Random4, Schema as Schema100, Stream as Stream17 } from "effect";
 import { EntityId, ShardId, Sharding as Sharding2, ShardingConfig as ShardingConfig3 } from "effect/unstable/cluster";
 
 // src/runtime-capability-policy.ts
-import { Context as Context72, Effect as Effect101, Function as Function18, Layer as Layer83, Schema as Schema94 } from "effect";
+import { Context as Context72, Effect as Effect101, Function as Function18, Layer as Layer83, Schema as Schema95 } from "effect";
 
-class RuntimeCapabilityUnavailable extends Schema94.TaggedErrorClass()("RuntimeCapabilityUnavailable", {
-  capability: Schema94.Literals(["fan-out", "workflow-definition"]),
-  role: Schema94.Literals(["embedded", "runner", "client"]),
-  nextAction: Schema94.Literals(["enable-embedded-capability", "use-embedded-runtime"])
+class RuntimeCapabilityUnavailable extends Schema95.TaggedErrorClass()("RuntimeCapabilityUnavailable", {
+  capability: Schema95.Literals(["fan-out", "workflow-definition"]),
+  role: Schema95.Literals(["embedded", "runner", "client"]),
+  nextAction: Schema95.Literals(["enable-embedded-capability", "use-embedded-runtime"])
 }) {
 }
 
@@ -18080,7 +18178,7 @@ var layer64 = Function18.dual(2, (role, capabilities) => Layer83.succeed(Service
 }));
 
 // src/client-baton-agent.ts
-import { Effect as Effect102, Schema as Schema95 } from "effect";
+import { Effect as Effect102, Schema as Schema96 } from "effect";
 var isRegisterBatonAgentInput = (input) => ("agent" in input);
 var toolRefsFromBatonAgent = (agent) => Object.values(agent.toolkit.tools).map((tool3) => ({ name: tool3.name }));
 var modelSelectionFromBatonAgent = (selection) => ({
@@ -18088,9 +18186,9 @@ var modelSelectionFromBatonAgent = (selection) => ({
   model: selection.model,
   ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
 });
-var decodeBatonAgentName = (name) => Schema95.decodeUnknownEffect(exports_shared_schema.NonEmptyString)(name).pipe(Effect102.mapError(() => ClientError.make({ message: "Baton agent name must not be blank" })));
-var decodeBatonAgentMetadata = (metadata11) => metadata11 === undefined ? Effect102.void : Schema95.decodeUnknownEffect(exports_shared_schema.Metadata)(metadata11).pipe(Effect102.mapError(() => ClientError.make({ message: "Baton agent metadata must be JSON metadata" })));
-var decodeBatonMemorySubject = (subject) => Schema95.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect102.mapError(() => ClientError.make({ message: "Baton agent memory subject must be a MemorySubjectId" })));
+var decodeBatonAgentName = (name) => Schema96.decodeUnknownEffect(exports_shared_schema.NonEmptyString)(name).pipe(Effect102.mapError(() => ClientError.make({ message: "Baton agent name must not be blank" })));
+var decodeBatonAgentMetadata = (metadata11) => metadata11 === undefined ? Effect102.void : Schema96.decodeUnknownEffect(exports_shared_schema.Metadata)(metadata11).pipe(Effect102.mapError(() => ClientError.make({ message: "Baton agent metadata must be JSON metadata" })));
+var decodeBatonMemorySubject = (subject) => Schema96.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect102.mapError(() => ClientError.make({ message: "Baton agent memory subject must be a MemorySubjectId" })));
 var metadataFromBatonAgent = Effect102.fn("Client.metadataFromBatonAgent")(function* (input) {
   const agentMetadata = yield* decodeBatonAgentMetadata(input.agent.metadata);
   const memorySubject = input.agent.memory === undefined ? undefined : yield* decodeBatonMemorySubject(input.agent.memory.subject);
@@ -18199,10 +18297,10 @@ import { Effect as Effect104, Option as Option29 } from "effect";
 import { Effect as Effect103 } from "effect";
 
 // src/client-error-mapping.ts
-import { Option as Option28, Schema as Schema96 } from "effect";
+import { Option as Option28, Schema as Schema97 } from "effect";
 var errorMessage2 = (error5) => error5 instanceof Error ? error5.message : String(error5);
 var toClientError = (error5) => ClientError.make({ message: errorMessage2(error5) });
-var toStreamError = (error5) => Option28.match(Schema96.decodeUnknownOption(EventLogCursorNotFound)(error5), {
+var toStreamError = (error5) => Option28.match(Schema97.decodeUnknownOption(EventLogCursorNotFound)(error5), {
   onNone: () => toClientError(error5),
   onSome: (cursorError) => cursorError
 });
@@ -18333,8 +18431,8 @@ var childStartInput = (input, accepted2, pin, definition, createdAt, parentWaitI
 var childRunInternals = { childStartInput, internalSpawnChildRunInput };
 
 // src/client-execution-payloads.ts
-import { Effect as Effect105, Schema as Schema97 } from "effect";
-var encodeExecutionCursor = (cursor) => Schema97.encodeEffect(exports_pagination_schema.ExecutionCursorCodec)({ id: cursor.id, at: cursor.updatedAt }).pipe(Effect105.mapError(toClientError));
+import { Effect as Effect105, Schema as Schema98 } from "effect";
+var encodeExecutionCursor = (cursor) => Schema98.encodeEffect(exports_pagination_schema.ExecutionCursorCodec)({ id: cursor.id, at: cursor.updatedAt }).pipe(Effect105.mapError(toClientError));
 var executionIdFromIdempotencyKey = (idempotencyKey) => exports_ids_schema.ExecutionId.make(`execution:${idempotencyKey}`);
 var metadataWithIdempotencyKey = (metadata11, idempotencyKey) => ({
   ...metadata11,
@@ -18451,9 +18549,9 @@ var wakeRuntime = Effect107.fn("Client.waits.wakeRuntime")(function* (waits, eve
 var runtimeWakeInternals = { wakeRuntime };
 
 // src/client-tool-outcome.ts
-import { Effect as Effect108, Schema as Schema98 } from "effect";
+import { Effect as Effect108, Schema as Schema99 } from "effect";
 var toolWaitId = (executionId, callId) => Identifiers.waitId("tool", executionId, callId);
-var acceptedWaitOutcome = (wait) => Schema98.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect108.mapError(toClientError));
+var acceptedWaitOutcome = (wait) => Schema99.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect108.mapError(toClientError));
 var resolveToolOutcomeWait = Effect108.fn("Client.resolveToolOutcomeWait")(function* (waits, eventLog, call, outcome, completedAt) {
   const waitId2 = call.waitId ?? toolWaitId(call.executionId, call.call.id);
   const wait = yield* waits.get(waitId2).pipe(Effect108.mapError(toClientError));
@@ -18734,7 +18832,7 @@ var replyValueFrom = (content) => {
   const text = content.filter((part) => part.type === "text").map((part) => part.text).join("");
   if (text.length === 0)
     return Option30.none();
-  return Schema99.decodeUnknownOption(Schema99.UnknownFromJsonString)(text);
+  return Schema100.decodeUnknownOption(Schema100.UnknownFromJsonString)(text);
 };
 var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
   const makeExecutionClient = yield* client;
@@ -18814,7 +18912,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
         status: "queued",
         metadata: { operation: "envelope-send" },
         createdAt
-      }).pipe(Effect109.catchIf(Schema99.is(exports_execution_repository.DuplicateExecution), () => Effect109.void), Effect109.mapError(toClientError));
+      }).pipe(Effect109.catchIf(Schema100.is(exports_execution_repository.DuplicateExecution), () => Effect109.void), Effect109.mapError(toClientError));
     }
     const maxSequence3 = yield* eventLog.maxSequence(executionId).pipe(Effect109.mapError(toClientError));
     return yield* envelopes.send({
@@ -19060,7 +19158,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       return records.map(toWaitView);
     }),
     listExecutions: Effect109.fn("Client.runtime.listExecutions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema99.decodeEffect(exports_pagination_schema.ExecutionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema100.decodeEffect(exports_pagination_schema.ExecutionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
       const result = yield* executionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.status === undefined ? {} : { status: input.status },
@@ -19110,13 +19208,13 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       }).pipe(Effect109.mapError(toClientError));
     }),
     listSessions: Effect109.fn("Client.runtime.listSessions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema99.decodeEffect(exports_pagination_schema.SessionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema100.decodeEffect(exports_pagination_schema.SessionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
       const result = yield* sessionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
       });
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema99.encodeEffect(exports_pagination_schema.SessionCursorCodec)({
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema100.encodeEffect(exports_pagination_schema.SessionCursorCodec)({
         id: result.nextCursor.id,
         at: result.nextCursor.updatedAt
       });
@@ -19129,7 +19227,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       const session = yield* sessionRepository.get(input.session_id).pipe(Effect109.mapError(toClientError));
       if (session === undefined)
         return yield* ClientError.make({ message: `Session not found: ${input.session_id}` });
-      const cursor = input.cursor === undefined ? undefined : yield* Schema99.decodeEffect(exports_pagination_schema.ExecutionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })), Effect109.mapError(toClientError));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema100.decodeEffect(exports_pagination_schema.ExecutionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })), Effect109.mapError(toClientError));
       const result = yield* executionRepository.list({
         sessionId: input.session_id,
         ...input.limit === undefined ? {} : { limit: input.limit },
@@ -19200,7 +19298,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       if (instance === undefined || instance.status === "destroyed") {
         return yield* ResidentNotFound.make({ kind: input.kind, key: input.key });
       }
-      const encoded = yield* Schema99.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect109.mapError(toClientError));
+      const encoded = yield* Schema100.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect109.mapError(toClientError));
       const inputRef = inputSchemaRef(input.command.name);
       const outputRef = outputSchemaRef(input.command.name);
       if (Option30.isSome(schemaRegistry)) {
@@ -19247,7 +19345,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
           message: "reply carried no decodable content"
         });
       }
-      return yield* Schema99.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect109.mapError((issue) => CommandReplyInvalid.make({
+      return yield* Schema100.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect109.mapError((issue) => CommandReplyInvalid.make({
         command: input.command.name,
         wait_id: outcome.wait_id,
         message: errorMessage2(issue)
@@ -19288,14 +19386,14 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
       ...input.expected_version === undefined ? {} : { expectedVersion: input.expected_version },
       ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
       updatedAt: input.updated_at
-    }).pipe(Effect109.mapError((error5) => Schema99.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
+    }).pipe(Effect109.mapError((error5) => Schema100.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
     deleteResidentState: Effect109.fn("Client.runtime.deleteResidentState")((input) => executionState.remove({
       executionId: input.execution_id,
       key: input.key,
       ...input.expected_version === undefined ? {} : { expectedVersion: input.expected_version },
       ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
       removedAt: input.removed_at
-    }).pipe(Effect109.mapError((error5) => Schema99.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
+    }).pipe(Effect109.mapError((error5) => Schema100.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
     listResidentState: Effect109.fn("Client.runtime.listResidentState")((input) => executionState.list({
       executionId: input.execution_id,
       ...input.prefix === undefined ? {} : { prefix: input.prefix },
@@ -19554,77 +19652,77 @@ import { Effect as Effect111 } from "effect";
 var recoverPersistedFanOut = (recover) => recover().pipe(Effect111.mapError((error5) => WorkflowRuntimeError.make({ message: error5._tag })), Effect111.asVoid);
 
 // src/runtime.ts
-var Dialect2 = Schema100.Literals(["pg", "mysql", "sqlite"]);
+var Dialect2 = Schema101.Literals(["pg", "mysql", "sqlite"]);
 
-class NotificationFailure extends Schema100.TaggedErrorClass()("NotificationFailure", {
-  reason: Schema100.String
+class NotificationFailure extends Schema101.TaggedErrorClass()("NotificationFailure", {
+  reason: Schema101.String
 }) {
 }
 
-class ClusterFailure extends Schema100.TaggedErrorClass()("ClusterFailure", {
-  reason: Schema100.String
+class ClusterFailure extends Schema101.TaggedErrorClass()("ClusterFailure", {
+  reason: Schema101.String
 }) {
 }
 
-class SqlFailure extends Schema100.TaggedErrorClass()("SqlFailure", {
-  category: Schema100.Literals(["connection", "statement", "unknown"]),
-  operation: Schema100.Literals(["acquire", "migrate", "verify", "notify", "readiness"]),
-  retryable: Schema100.Boolean
+class SqlFailure extends Schema101.TaggedErrorClass()("SqlFailure", {
+  category: Schema101.Literals(["connection", "statement", "unknown"]),
+  operation: Schema101.Literals(["acquire", "migrate", "verify", "notify", "readiness"]),
+  retryable: Schema101.Boolean
 }) {
 }
-var SqlDialect = Schema100.Literals(["sqlite", "pg", "mysql", "mssql", "clickhouse"]);
+var SqlDialect = Schema101.Literals(["sqlite", "pg", "mysql", "mssql", "clickhouse"]);
 
-class DatabaseDialectMismatch extends Schema100.TaggedErrorClass()("DatabaseDialectMismatch", { expected: Dialect2, actual: SqlDialect }) {
+class DatabaseDialectMismatch extends Schema101.TaggedErrorClass()("DatabaseDialectMismatch", { expected: Dialect2, actual: SqlDialect }) {
 }
 
-class DatabaseAlreadyOwned extends Schema100.TaggedErrorClass()("DatabaseAlreadyOwned", {
+class DatabaseAlreadyOwned extends Schema101.TaggedErrorClass()("DatabaseAlreadyOwned", {
   databaseIdentity: DatabaseIdentity
 }) {
 }
 
-class UnsupportedTopology extends Schema100.TaggedErrorClass()("UnsupportedTopology", {
-  reason: Schema100.String
+class UnsupportedTopology extends Schema101.TaggedErrorClass()("UnsupportedTopology", {
+  reason: Schema101.String
 }) {
 }
 
-class MigratorError extends Schema100.TaggedErrorClass()("MigratorError", {
-  reason: Schema100.String
+class MigratorError extends Schema101.TaggedErrorClass()("MigratorError", {
+  reason: Schema101.String
 }) {
 }
 
-class SchemaHeadMismatch extends Schema100.TaggedErrorClass()("SchemaHeadMismatch", {
-  expected: Schema100.String,
-  actual: Schema100.String
+class SchemaHeadMismatch extends Schema101.TaggedErrorClass()("SchemaHeadMismatch", {
+  expected: Schema101.String,
+  actual: Schema101.String
 }) {
 }
 
-class HostUnavailable extends Schema100.TaggedErrorClass()("HostUnavailable", {
-  host: Schema100.String,
-  reason: Schema100.String
+class HostUnavailable extends Schema101.TaggedErrorClass()("HostUnavailable", {
+  host: Schema101.String,
+  reason: Schema101.String
 }) {
 }
-var RuntimeTopologyCause = Schema100.Union([
+var RuntimeTopologyCause = Schema101.Union([
   ClusterFailure,
   DatabaseDialectMismatch,
   DatabaseAlreadyOwned,
   UnsupportedTopology
 ]);
-var RuntimeMigrationCause = Schema100.Union([
+var RuntimeMigrationCause = Schema101.Union([
   SqlFailure,
   MigratorError,
   SchemaHeadMismatch
 ]);
-var RuntimeReadinessCause = Schema100.Union([
+var RuntimeReadinessCause = Schema101.Union([
   SqlFailure,
   NotificationFailure,
   ClusterFailure,
   HostUnavailable
 ]);
 
-class RuntimeTopologyError extends Schema100.TaggedErrorClass()("RuntimeTopologyError", {
+class RuntimeTopologyError extends Schema101.TaggedErrorClass()("RuntimeTopologyError", {
   dialect: Dialect2,
-  role: Schema100.Literals(["embedded", "runner", "client"]),
-  nextAction: Schema100.Literals([
+  role: Schema101.Literals(["embedded", "runner", "client"]),
+  nextAction: Schema101.Literals([
     "use-embedded",
     "use-postgres-or-mysql",
     "use-client-constructor",
@@ -19635,39 +19733,39 @@ class RuntimeTopologyError extends Schema100.TaggedErrorClass()("RuntimeTopology
 }) {
 }
 
-class RuntimeMigrationError extends Schema100.TaggedErrorClass()("RuntimeMigrationError", {
+class RuntimeMigrationError extends Schema101.TaggedErrorClass()("RuntimeMigrationError", {
   dialect: Dialect2,
-  phase: Schema100.Literals(["apply", "verify"]),
-  nextAction: Schema100.Literals(["retry", "inspect-schema", "run-compatible-release"]),
+  phase: Schema101.Literals(["apply", "verify"]),
+  nextAction: Schema101.Literals(["retry", "inspect-schema", "run-compatible-release"]),
   cause: RuntimeMigrationCause
 }) {
 }
 
-class RuntimeReadinessError extends Schema100.TaggedErrorClass()("RuntimeReadinessError", {
-  phase: Schema100.Literals(["database", "notification", "cluster", "hosts"]),
+class RuntimeReadinessError extends Schema101.TaggedErrorClass()("RuntimeReadinessError", {
+  phase: Schema101.Literals(["database", "notification", "cluster", "hosts"]),
   cause: RuntimeReadinessCause
 }) {
 }
-var RuntimeCapabilityStatus = Schema100.Union([
-  Schema100.Struct({
-    enabled: Schema100.Literal(false),
-    source: Schema100.Literals(["local-host", "role-unavailable"]),
-    health: Schema100.Literal("not-applicable")
+var RuntimeCapabilityStatus = Schema101.Union([
+  Schema101.Struct({
+    enabled: Schema101.Literal(false),
+    source: Schema101.Literals(["local-host", "role-unavailable"]),
+    health: Schema101.Literal("not-applicable")
   }),
-  Schema100.Struct({
-    enabled: Schema100.Literal(true),
-    source: Schema100.Literal("local-host"),
-    health: Schema100.Literals(["healthy", "unhealthy"])
+  Schema101.Struct({
+    enabled: Schema101.Literal(true),
+    source: Schema101.Literal("local-host"),
+    health: Schema101.Literals(["healthy", "unhealthy"])
   })
 ]);
-var ReadinessStatus2 = Schema100.Struct({
-  ready: Schema100.Literal(true),
-  role: Schema100.Literals(["embedded", "runner", "client"]),
+var ReadinessStatus2 = Schema101.Struct({
+  ready: Schema101.Literal(true),
+  role: Schema101.Literals(["embedded", "runner", "client"]),
   dialect: Dialect2,
   databaseIdentity: DatabaseIdentity,
-  schemaHead: Schema100.String,
-  notification: Schema100.Literals(["pg-listen-notify", "polling", "in-process"]),
-  capabilities: Schema100.Struct({
+  schemaHead: Schema101.String,
+  notification: Schema101.Literals(["pg-listen-notify", "polling", "in-process"]),
+  capabilities: Schema101.Struct({
     fanOut: RuntimeCapabilityStatus,
     workflowDefinition: RuntimeCapabilityStatus
   })
@@ -19681,7 +19779,7 @@ var normalizeHost = (layer65, _role, _dialect) => layer65.pipe(Layer86.catchCaus
   role: _role,
   nextAction: _role === "embedded" ? "use-embedded" : "use-different-database",
   cause: ClusterFailure.make({ reason: "cluster configuration is incompatible" })
-}) : error5), "host-layer", (error5) => Schema100.is(RuntimeConfigurationError)(error5) || Schema100.is(RuntimeTopologyError)(error5) || Schema100.is(RuntimeMigrationError)(error5))))));
+}) : error5), "host-layer", (error5) => Schema101.is(RuntimeConfigurationError)(error5) || Schema101.is(RuntimeTopologyError)(error5) || Schema101.is(RuntimeMigrationError)(error5))))));
 var actualDialect = (sql) => sql.onDialectOrElse({
   sqlite: () => "sqlite",
   pg: () => "pg",