@relayfx/sdk 0.4.2 → 0.6.0

package/dist/{index-y9ncz0zd.js → index-96b7htye.js}

@@ -16,7 +16,7 @@ import {
   exports_tool_executor,
   exports_tool_output,
   exports_turn_policy
-} from "./index-x32kbvxv.js";
+} from "./index-c6jave5p.js";
 import {
   ClientError,
   EventLogCursorNotFound,
@@ -46,7 +46,7 @@ import {
   exports_workflow_schema,
   exports_workspace_schema,
   followExecutionFrom
-} from "./index-3w6txjtg.js";
+} from "./index-fh2ftte9.js";
 import {
   __export
 } from "./index-nb39b5ae.js";
@@ -550,12 +550,12 @@ var notRegistered = (selection) => LanguageModelNotRegistered.make({
 
 class Service8 extends Context6.Service()("@relayfx/runtime/model/language-model-service/Service") {
 }
-var registrationFromLayer2 = exports_model_registry.registrationFromLayer;
+var registrationFromLayer2 = exports_model_registry.registration;
 var fromModelRegistry = (registry) => Service8.of({
   register: (input) => registry.register(input),
   registrations: registry.registrations,
-  provide: (selection, effect) => registry.provide(toSelection(selection), effect),
-  provideForAgent: (agent, effect) => registry.provide(toSelection(agent.model), effect)
+  provide: (selection, effect) => registry.operate(toSelection(selection), effect),
+  provideForAgent: (agent, effect) => registry.operate(toSelection(agent.model), effect)
 });
 var testLayer5 = (implementation) => Layer6.succeed(Service8, Service8.of(implementation));
 var register3 = Effect6.fn("LanguageModelService.register.call")(function* (input) {
@@ -616,9 +616,9 @@ var validate = (registrations3) => Effect7.gen(function* () {
   return registrations3;
 });
 var fromRegistrations = (registrations3, options) => {
-  const registryLayer = exports_model_registry.layer(registrations3, options);
+  const registryLayer = exports_model_registry.layer(registrations3.map((registration) => Effect7.succeed(registration)), options);
   const hubLayer = Layer7.effect(Service9, Effect7.gen(function* () {
-    const modelRegistry = yield* exports_model_registry.Service;
+    const modelRegistry = yield* exports_model_registry.ModelRegistry;
     return Service9.of({
       modelRegistry,
       languageModelService: fromModelRegistry(modelRegistry)
@@ -633,7 +633,7 @@ var layer4 = Function4.dual((args) => Array.isArray(args[0]), (registrations3, o
 var layerFromRegistrationEffects2 = Function4.dual((args) => Array.isArray(args[0]), (declarations, options) => Layer7.unwrap(Effect7.all(declarations).pipe(Effect7.flatMap(validate), Effect7.map((items) => fromRegistrations(items, options)))));
 var testLayer6 = (modelRegistry) => {
   const languageModelService = fromModelRegistry(modelRegistry);
-  return Layer7.mergeAll(Layer7.succeed(Service9, Service9.of({ modelRegistry, languageModelService })), Layer7.succeed(exports_model_registry.Service, modelRegistry), Layer7.succeed(Service8, languageModelService));
+  return Layer7.mergeAll(Layer7.succeed(Service9, Service9.of({ modelRegistry, languageModelService })), Layer7.succeed(exports_model_registry.ModelRegistry, modelRegistry), Layer7.succeed(Service8, languageModelService));
 };
 
 // ../runtime/src/schema-registry/schema-registry-service.ts
@@ -6206,7 +6206,7 @@ __export(exports_session_repository, {
   Service: () => Service35,
   DuplicateSession: () => DuplicateSession
 });
-import { Context as Context33, Effect as Effect41, Layer as Layer35, Schema as Schema39 } from "effect";
+import { Context as Context33, Effect as Effect41, Layer as Layer35, Schema as Schema40 } from "effect";
 
 // ../store-sql/src/session/session-entry-records.ts
 import { Effect as Effect39, Schema as Schema37 } from "effect";
@@ -6489,16 +6489,23 @@ var makeSessionEntryRecords = (errors) => {
 };
 
 // ../store-sql/src/session/session-records.ts
-import { Effect as Effect40, Schema as Schema38 } from "effect";
+import { Effect as Effect40, Schema as Schema39 } 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])
 }).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])
 }).annotate({ identifier: "Relay.SessionEntry.CountRow" });
@@ -6507,6 +6514,13 @@ var toSessionRecord = (row) => ({
   id: exports_ids_schema.SessionId.make(row.id),
   rootAddressId: exports_ids_schema.AddressId.make(row.root_address_id),
   ...row.leaf_entry_id === null || row.leaf_entry_id === undefined ? {} : { leafEntryId: exports_ids_schema.SessionEntryId.make(row.leaf_entry_id) },
+  ...row.owner_execution_id === null || row.owner_execution_id === undefined ? {} : {
+    writer: {
+      executionId: exports_ids_schema.ExecutionId.make(row.owner_execution_id),
+      epoch: Number(row.owner_epoch),
+      released: releasedFlag(row.owner_released)
+    }
+  },
   metadata: decodeJson(row.metadata_json),
   createdAt: fromDbTimestamp(row.created_at),
   updatedAt: fromDbTimestamp(row.updated_at)
@@ -6527,9 +6541,29 @@ var makeSessionRecordSupport = (errors) => {
     missingSession: (id) => SessionRepositoryError.make({ message: `Session ${id} does not exist` }),
     rootMismatch: (id) => SessionRepositoryError.make({ message: `Session ${id} already exists for a different root address` }),
     cloneSession: (record2) => structuredClone(record2),
-    currentLeaf: (session) => session.leafEntryId ?? null
+    currentLeaf: (session) => session.leafEntryId ?? null,
+    writerFenceViolation: (session, expected) => {
+      if (expected === undefined)
+        return;
+      const writer = session.writer;
+      if (writer === undefined)
+        return `Session ${session.id} has no writer claim`;
+      if (writer.released)
+        return `Session ${session.id} writer claim was released`;
+      if (writer.executionId !== expected.executionId || writer.epoch !== expected.epoch)
+        return `Session ${session.id} is owned by ${writer.executionId} at epoch ${writer.epoch}`;
+      return;
+    },
+    nextWriterClaim: (current2, executionId) => {
+      if (current2 === undefined || current2.released)
+        return { _tag: "Claimed", writer: { executionId, epoch: (current2?.epoch ?? 0) + 1, released: false } };
+      if (current2.executionId === executionId)
+        return { _tag: "Claimed", writer: { executionId, epoch: current2.epoch, released: false } };
+      return { _tag: "Busy", writer: current2 };
+    }
   };
 };
+// ../store-sql/src/session/session-records.ts
 var makeSessionRepository = (errors) => Effect40.gen(function* () {
   const { SessionRepositoryError, DuplicateSession } = errors;
   const {
@@ -6542,7 +6576,7 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
     toEntryRecord,
     validateCompaction
   } = makeSessionEntryRecords(errors);
-  const { currentLeaf, missingSession, rootMismatch } = makeSessionRecordSupport(errors);
+  const { currentLeaf, missingSession, nextWriterClaim, rootMismatch, writerFenceViolation } = makeSessionRecordSupport(errors);
   const sql = yield* SqlClient23;
   const toRepositoryError12 = (error5) => SessionRepositoryError.make({ message: String(error5) });
   function mapRepositoryError(effect) {
@@ -6552,14 +6586,23 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
       return toRepositoryError12(error5);
     }));
   }
-  const decodeSessionRow = (row) => Schema38.decodeUnknownEffect(sessionRow)(row).pipe(Effect40.mapError(toRepositoryError12));
-  const decodeEntryRow = (row) => Schema38.decodeUnknownEffect(sessionEntryRow)(row).pipe(Effect40.mapError(toRepositoryError12));
-  const decodeCountRow = (row) => Schema38.decodeUnknownEffect(CountRow)(row).pipe(Effect40.mapError(toRepositoryError12));
+  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 selectSessionByKey = (tenantId, id) => sql`
-      SELECT id, root_address_id, leaf_entry_id, metadata_json, created_at, updated_at
+      SELECT id, root_address_id, leaf_entry_id, owner_execution_id, owner_epoch, owner_released, metadata_json, created_at, updated_at
       FROM relay_sessions
       WHERE tenant_id = ${tenantId} AND id = ${id}
     `;
+  const releasedParam = sql.onDialectOrElse({
+    pg: () => (released) => released,
+    orElse: () => (released) => released ? 1 : 0
+  });
+  const updateWriter = (tenantId, input) => sql`
+      UPDATE relay_sessions
+      SET owner_execution_id = ${input.writer.executionId}, owner_epoch = ${input.writer.epoch}, owner_released = ${releasedParam(input.writer.released)}, updated_at = ${timestampParam(sql, input.updatedAt)}
+      WHERE tenant_id = ${tenantId} AND id = ${input.sessionId}
+    `;
   const lockSession = sql.onDialectOrElse({
     pg: () => (tenantId, id) => sql`SELECT id FROM relay_sessions WHERE tenant_id = ${tenantId} AND id = ${id} FOR UPDATE`,
     mysql: () => (tenantId, id) => sql`SELECT id FROM relay_sessions WHERE tenant_id = ${tenantId} AND id = ${id} FOR UPDATE`,
@@ -6689,14 +6732,14 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
       ]));
     }
     const rows = yield* mapRepositoryError(sql`
-        SELECT id, root_address_id, leaf_entry_id, metadata_json, created_at, updated_at
+        SELECT id, root_address_id, leaf_entry_id, owner_execution_id, owner_epoch, owner_released, metadata_json, created_at, updated_at
         FROM relay_sessions
         WHERE ${sql.and(conditions)}
         ORDER BY updated_at DESC, id DESC
         LIMIT ${sql.literal(String(limit + 1))}
       `);
     const records = yield* Effect40.forEach(rows.slice(0, limit), (row) => decodeSessionRow(row).pipe(Effect40.map(toSessionRecord)));
-    const nextCursor = nextCursorOf2(records, rows.length, limit);
+    const nextCursor = sessionRecordPaging.nextCursorOf(records, rows.length, limit);
     return nextCursor === undefined ? { records } : { records, nextCursor };
   });
   const touch = Effect40.fn("SessionRepository.touch")(function* (input) {
@@ -6727,6 +6770,9 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
     return yield* mapRepositoryError(sql.withTransaction(Effect40.gen(function* () {
       yield* lockSession(tenantId, input.sessionId);
       const session = yield* requireSession(tenantId, input.sessionId);
+      const fence = writerFenceViolation(session, input.expectedWriter);
+      if (fence !== undefined)
+        return yield* conflict4("fenced", fence);
       if (input.expectedLeafId !== undefined && input.expectedLeafId !== currentLeaf(session)) {
         return yield* conflict4("stale-leaf", `Expected Session leaf ${String(input.expectedLeafId)} but found ${String(currentLeaf(session))}`);
       }
@@ -6764,6 +6810,9 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
     return yield* mapRepositoryError(sql.withTransaction(Effect40.gen(function* () {
       yield* lockSession(tenantId, input.sessionId);
       const session = yield* requireSession(tenantId, input.sessionId);
+      const checkpointFence = writerFenceViolation(session, input.expectedWriter);
+      if (checkpointFence !== undefined)
+        return yield* conflict4("fenced", checkpointFence);
       const existing = yield* entryById(tenantId, input.sessionId, input.id);
       const appendInput = {
         id: input.id,
@@ -6816,9 +6865,40 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
     const counted = yield* decodeCountRow(rows[0]);
     return Number(counted.value);
   });
+  const claimWriter = Effect40.fn("SessionRepository.claimWriter")(function* (input) {
+    const tenantId = yield* current();
+    return yield* mapRepositoryError(sql.withTransaction(Effect40.gen(function* () {
+      yield* lockSession(tenantId, input.sessionId);
+      const session = yield* requireSession(tenantId, input.sessionId);
+      const claim = nextWriterClaim(session.writer, input.executionId);
+      if (claim._tag === "Busy")
+        return claim;
+      yield* updateWriter(tenantId, { sessionId: input.sessionId, writer: claim.writer, updatedAt: input.now });
+      return claim;
+    })));
+  });
+  const releaseWriter = Effect40.fn("SessionRepository.releaseWriter")(function* (input) {
+    const tenantId = yield* current();
+    yield* mapRepositoryError(sql.withTransaction(Effect40.gen(function* () {
+      yield* lockSession(tenantId, input.sessionId);
+      const session = yield* getForTenant(tenantId, input.sessionId);
+      const writer = session?.writer;
+      if (session === undefined || writer === undefined || writer.executionId !== input.executionId)
+        return;
+      if (writer.released)
+        return;
+      yield* updateWriter(tenantId, {
+        sessionId: input.sessionId,
+        writer: { ...writer, released: true },
+        updatedAt: input.now
+      });
+    })));
+  });
   return {
     create: create5,
     ensure,
+    claimWriter,
+    releaseWriter,
     get: get9,
     list: list10,
     touch,
@@ -6832,19 +6912,19 @@ var makeSessionRepository = (errors) => Effect40.gen(function* () {
 });
 
 // ../store-sql/src/session/session-repository.ts
-class SessionRepositoryError extends Schema39.TaggedErrorClass()("SessionRepositoryError", {
-  message: Schema39.String
+class SessionRepositoryError extends Schema40.TaggedErrorClass()("SessionRepositoryError", {
+  message: Schema40.String
 }) {
 }
 
-class DuplicateSession extends Schema39.TaggedErrorClass()("DuplicateSession", {
+class DuplicateSession extends Schema40.TaggedErrorClass()("DuplicateSession", {
   id: exports_ids_schema.SessionId
 }) {
 }
 
-class SessionConflict extends Schema39.TaggedErrorClass()("SessionConflict", {
-  reason: Schema39.Literals(["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path"]),
-  message: Schema39.String
+class SessionConflict extends Schema40.TaggedErrorClass()("SessionConflict", {
+  reason: Schema40.Literals(["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path", "fenced"]),
+  message: Schema40.String
 }) {
 }
 
@@ -6863,7 +6943,7 @@ var {
   sameEntry,
   validateCompaction
 } = makeSessionEntryRecords(repositoryErrors);
-var { cloneSession, currentLeaf, missingSession, rootMismatch } = makeSessionRecordSupport(repositoryErrors);
+var { cloneSession, currentLeaf, missingSession, nextWriterClaim, rootMismatch, writerFenceViolation } = makeSessionRecordSupport(repositoryErrors);
 var { afterCursor: afterCursor3, compareDesc: compareDesc3, nextCursorOf: nextCursorOf3 } = sessionRecordPaging;
 var layer28 = Layer35.effect(Service35, makeSessionRepository(repositoryErrors).pipe(Effect41.map(Service35.of)));
 var layerFromTenant = layer28;
@@ -6931,6 +7011,25 @@ var memoryLayer26 = Layer35.sync(Service35, () => {
       sessions.set(input.id, record2);
       return cloneSession(record2);
     }),
+    claimWriter: Effect41.fn("SessionRepository.memory.claimWriter")(function* (input) {
+      const session = sessions.get(input.sessionId);
+      if (session === undefined)
+        return yield* missingSession(input.sessionId);
+      const claim = nextWriterClaim(session.writer, input.executionId);
+      if (claim._tag === "Busy")
+        return claim;
+      sessions.set(input.sessionId, { ...session, writer: claim.writer, updatedAt: input.now });
+      return claim;
+    }),
+    releaseWriter: Effect41.fn("SessionRepository.memory.releaseWriter")((input) => Effect41.sync(() => {
+      const session = sessions.get(input.sessionId);
+      const writer = session?.writer;
+      if (session === undefined || writer === undefined || writer.executionId !== input.executionId)
+        return;
+      if (writer.released)
+        return;
+      sessions.set(input.sessionId, { ...session, writer: { ...writer, released: true }, updatedAt: input.now });
+    })),
     get: Effect41.fn("SessionRepository.memory.get")((id) => Effect41.sync(() => {
       const record2 = sessions.get(id);
       return record2 === undefined ? undefined : cloneSession(record2);
@@ -6954,6 +7053,9 @@ var memoryLayer26 = Layer35.sync(Service35, () => {
       const session = sessions.get(input.sessionId);
       if (session === undefined)
         return yield* missingSession(input.sessionId);
+      const fence = writerFenceViolation(session, input.expectedWriter);
+      if (fence !== undefined)
+        return yield* conflict4("fenced", fence);
       if (input.expectedLeafId !== undefined && input.expectedLeafId !== currentLeaf(session)) {
         return yield* conflict4("stale-leaf", `Expected Session leaf ${String(input.expectedLeafId)} but found ${String(currentLeaf(session))}`);
       }
@@ -6978,6 +7080,9 @@ var memoryLayer26 = Layer35.sync(Service35, () => {
       const session = sessions.get(input.sessionId);
       if (session === undefined)
         return yield* missingSession(input.sessionId);
+      const fence = writerFenceViolation(session, input.expectedWriter);
+      if (fence !== undefined)
+        return yield* conflict4("fenced", fence);
       const appendInput = {
         id: input.id,
         sessionId: input.sessionId,
@@ -7101,36 +7206,36 @@ __export(exports_skill_definition_repository, {
   Service: () => Service36,
   ExecutionSkillPinRow: () => ExecutionSkillPinRow
 });
-import { Context as Context34, Effect as Effect42, HashSet, Layer as Layer36, Schema as Schema40, Semaphore as Semaphore4 } from "effect";
+import { Context as Context34, Effect as Effect42, HashSet, Layer as Layer36, Schema as Schema41, Semaphore as Semaphore4 } from "effect";
 import { SqlClient as SqlClient24 } from "effect/unstable/sql/SqlClient";
-class SkillDefinitionRepositoryError extends Schema40.TaggedErrorClass()("SkillDefinitionRepositoryError", {
-  message: Schema40.String
+class SkillDefinitionRepositoryError extends Schema41.TaggedErrorClass()("SkillDefinitionRepositoryError", {
+  message: Schema41.String
 }) {
 }
 
 class Service36 extends Context34.Service()("@relayfx/store-sql/skill/skill-definition-repository/Service") {
 }
-var SkillDefinitionRow = Schema40.Struct({
-  id: Schema40.String,
-  current_revision: Schema40.Finite,
-  definition_json: Schema40.Unknown,
-  created_at: Schema40.Union([Schema40.Date, Schema40.String, Schema40.Finite]),
-  updated_at: Schema40.Union([Schema40.Date, Schema40.String, Schema40.Finite])
+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])
 }).annotate({ identifier: "Relay.SkillDefinition.Row" });
-var SkillDefinitionRevisionRow = Schema40.Struct({
-  skill_definition_id: Schema40.String,
-  revision: Schema40.Finite,
-  definition_json: Schema40.Unknown,
-  created_at: Schema40.Union([Schema40.Date, Schema40.String, Schema40.Finite])
+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])
 }).annotate({ identifier: "Relay.SkillDefinitionRevision.Row" });
-var ExecutionSkillPinRow = Schema40.Struct({
-  execution_id: Schema40.String,
-  skill_definition_id: Schema40.String,
-  skill_definition_revision: Schema40.Finite,
-  skill_definition_snapshot_json: Schema40.Unknown,
-  created_at: Schema40.Union([Schema40.Date, Schema40.String, Schema40.Finite])
+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])
 }).annotate({ identifier: "Relay.ExecutionSkillPin.Row" });
-var cloneDefinition3 = (definition) => Schema40.decodeUnknownSync(exports_skill_schema.Definition)(globalThis.structuredClone(definition));
+var cloneDefinition3 = (definition) => Schema41.decodeUnknownSync(exports_skill_schema.Definition)(globalThis.structuredClone(definition));
 var toRecord10 = (row) => ({
   id: exports_ids_schema.SkillDefinitionId.make(row.id),
   currentRevision: row.current_revision,
@@ -7186,11 +7291,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) => Schema40.is(SkillDefinitionRepositoryError)(error5) ? error5 : toRepositoryError12(error5);
-var isUniqueViolation = (error5) => !Schema40.is(SkillDefinitionRepositoryError)(error5) && /unique|duplicate/i.test(String(error5));
-var decodeRow12 = (row) => Schema40.decodeUnknownEffect(SkillDefinitionRow)(row).pipe(Effect42.mapError(toRepositoryError12));
-var decodeRevisionRow2 = (row) => Schema40.decodeUnknownEffect(SkillDefinitionRevisionRow)(row).pipe(Effect42.mapError(toRepositoryError12));
-var decodePinRow = (row) => Schema40.decodeUnknownEffect(ExecutionSkillPinRow)(row).pipe(Effect42.mapError(toRepositoryError12));
+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 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(", "));
@@ -7527,37 +7632,37 @@ __export(exports_steering_repository, {
   SteeringDrainRow: () => SteeringDrainRow,
   Service: () => Service37
 });
-import { Context as Context35, Effect as Effect43, Layer as Layer37, Ref as Ref9, Schema as Schema41 } from "effect";
+import { Context as Context35, Effect as Effect43, Layer as Layer37, Ref as Ref9, Schema as Schema42 } from "effect";
 import { SqlClient as SqlClient25 } from "effect/unstable/sql/SqlClient";
-class SteeringRepositoryError extends Schema41.TaggedErrorClass()("SteeringRepositoryError", {
-  message: Schema41.String
+class SteeringRepositoryError extends Schema42.TaggedErrorClass()("SteeringRepositoryError", {
+  message: Schema42.String
 }) {
 }
 
 class Service37 extends Context35.Service()("@relayfx/store-sql/steering/steering-repository/Service") {
 }
-var SteeringKindSchema = Schema41.Literals(["steering", "follow_up"]);
-var DbTimestamp4 = Schema41.Union([Schema41.Date, Schema41.String, Schema41.Finite]);
-var SteeringMessageRow = Schema41.Struct({
-  execution_id: Schema41.String,
+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,
   kind: SteeringKindSchema,
-  sequence: Schema41.Union([Schema41.Finite, Schema41.String]),
-  content_json: Schema41.Unknown,
-  drain_id: Schema41.NullishOr(Schema41.String),
-  consumed_at: Schema41.NullishOr(DbTimestamp4),
+  sequence: Schema42.Union([Schema42.Finite, Schema42.String]),
+  content_json: Schema42.Unknown,
+  drain_id: Schema42.NullishOr(Schema42.String),
+  consumed_at: Schema42.NullishOr(DbTimestamp4),
   created_at: DbTimestamp4
 }).annotate({ identifier: "Relay.SteeringMessage.Row" });
-var SteeringDrainRow = Schema41.Struct({
-  execution_id: Schema41.String,
+var SteeringDrainRow = Schema42.Struct({
+  execution_id: Schema42.String,
   kind: SteeringKindSchema,
-  drain_id: Schema41.String,
-  message_sequences_json: Schema41.Unknown,
+  drain_id: Schema42.String,
+  message_sequences_json: Schema42.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) => Schema41.is(SteeringRepositoryError)(error5) ? error5 : toRepositoryError13(error5)));
-var decodeMessageRow = (row) => Schema41.decodeUnknownEffect(SteeringMessageRow)(row).pipe(Effect43.mapError(toRepositoryError13));
-var decodeDrainRow = (row) => Schema41.decodeUnknownEffect(SteeringDrainRow)(row).pipe(Effect43.mapError(toRepositoryError13));
+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 toMessageRecord = (row) => {
   const consumedAt = fromNullableDbTimestamp(row.consumed_at);
   return {
@@ -7866,29 +7971,29 @@ __export(exports_tool_call_repository, {
   DuplicateToolResult: () => DuplicateToolResult,
   DuplicateToolCall: () => DuplicateToolCall
 });
-import { Context as Context36, Effect as Effect47, Layer as Layer38, Schema as Schema45 } from "effect";
+import { Context as Context36, Effect as Effect47, Layer as Layer38, Schema as Schema46 } from "effect";
 import { dual } from "effect/Function";
 
 // ../store-sql/src/tool/tool-call-records.ts
-import { Effect as Effect46, Schema as Schema44 } from "effect";
+import { Effect as Effect46, Schema as Schema45 } 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 Schema42 } from "effect";
-var toolAttemptRow = Schema42.Struct({
-  id: Schema42.String,
-  tool_call_id: Schema42.String,
-  attempt_number: Schema42.Union([Schema42.Finite, Schema42.String, Schema42.BigInt]),
-  state: Schema42.String,
-  worker_id: Schema42.NullishOr(Schema42.String),
-  claim_expires_at: Schema42.NullishOr(Schema42.Union([Schema42.Date, Schema42.String, Schema42.Finite])),
-  error: Schema42.NullishOr(Schema42.String),
-  created_at: Schema42.Union([Schema42.Date, Schema42.String, Schema42.Finite]),
-  completed_at: Schema42.NullishOr(Schema42.Union([Schema42.Date, Schema42.String, Schema42.Finite]))
+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]))
 }).annotate({ identifier: "Relay.ToolAttempt.Row" });
-var MaxAttemptRow = Schema42.Struct({
-  max_attempt: Schema42.NullishOr(Schema42.Union([Schema42.Finite, Schema42.String, Schema42.BigInt]))
+var MaxAttemptRow = Schema43.Struct({
+  max_attempt: Schema43.NullishOr(Schema43.Union([Schema43.Finite, Schema43.String, Schema43.BigInt]))
 });
 var toolAttemptId = (attemptNumber) => exports_ids_schema.ToolAttemptId.make(`tool-attempt:${attemptNumber}`);
 var makeToolAttemptRecordOperations = ({
@@ -7912,15 +8017,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: Schema42.decodeUnknownSync(exports_tool_schema.AttemptState)(row.state),
+    state: Schema43.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) => Schema42.decodeUnknownEffect(toolAttemptRow)(row).pipe(Effect44.mapError(toRepositoryError14));
-  const decodeMaxAttemptRow = (row) => Schema42.decodeUnknownEffect(Schema42.UndefinedOr(MaxAttemptRow))(row).pipe(Effect44.mapError(toRepositoryError14));
+  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 selectAttempts = (tenantId, executionId, callId) => sql`
     SELECT ${attemptColumns}
     FROM relay_tool_attempts
@@ -8003,13 +8108,13 @@ var makeToolAttemptRecordOperations = ({
 };
 
 // ../store-sql/src/tool/tool-work-operations.ts
-import { Effect as Effect45, Schema as Schema43 } from "effect";
-var ExpiredCallRow = Schema43.Struct({
-  id: Schema43.String,
-  execution_id: Schema43.String,
-  active_attempt_id: Schema43.NullishOr(Schema43.String)
+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)
 });
-var IdRow = Schema43.Struct({ id: Schema43.String, execution_id: Schema43.String });
+var IdRow = Schema44.Struct({ id: Schema44.String, execution_id: Schema44.String });
 var makeToolWorkOperations = ({
   records,
   attempts,
@@ -8172,7 +8277,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* Schema43.decodeUnknownEffect(Schema43.Array(ExpiredCallRow))(expiredRows).pipe(Effect45.mapError(toRepositoryError14));
+      const expired = yield* Schema44.decodeUnknownEffect(Schema44.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) {
@@ -8186,7 +8291,7 @@ var makeToolWorkOperations = ({
           `.pipe(Effect45.mapError(toRepositoryError14));
       }
       const candidateRows = yield* selectClaimCandidate(tenantId, input).pipe(Effect45.mapError(toRepositoryError14));
-      const candidates = yield* Schema43.decodeUnknownEffect(Schema43.Array(IdRow))(candidateRows).pipe(Effect45.mapError(toRepositoryError14));
+      const candidates = yield* Schema44.decodeUnknownEffect(Schema44.Array(IdRow))(candidateRows).pipe(Effect45.mapError(toRepositoryError14));
       const candidate = candidates[0];
       if (candidate === undefined)
         return;
@@ -8361,54 +8466,54 @@ var makeToolWorkOperations = ({
 };
 
 // ../store-sql/src/tool/tool-call-records.ts
-var toolCallRow = Schema44.Struct({
-  id: Schema44.String,
-  execution_id: Schema44.String,
-  name: Schema44.String,
-  input_json: Schema44.Unknown,
-  definition_json: Schema44.NullishOr(Schema44.Unknown),
-  placement_kind: Schema44.String,
-  placement_key: Schema44.NullishOr(Schema44.String),
-  state: Schema44.String,
-  wait_id: Schema44.NullishOr(Schema44.String),
-  idempotency_key: Schema44.String,
-  available_at: Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite]),
-  active_attempt_id: Schema44.NullishOr(Schema44.String),
-  claim_owner: Schema44.NullishOr(Schema44.String),
-  claimed_at: Schema44.NullishOr(Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite])),
-  claim_expires_at: Schema44.NullishOr(Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite])),
-  external_outcome_json: Schema44.NullishOr(Schema44.Unknown),
-  external_outcome_at: Schema44.NullishOr(Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite])),
-  metadata_json: Schema44.Unknown,
-  created_at: Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite]),
-  updated_at: Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite])
+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])
 }).annotate({ identifier: "Relay.ToolCall.Row" });
-var toolResultRow = Schema44.Struct({
-  tool_call_id: Schema44.String,
-  output_json: Schema44.Unknown,
-  error: Schema44.NullishOr(Schema44.String),
-  metadata_json: Schema44.Unknown,
-  created_at: Schema44.Union([Schema44.Date, Schema44.String, Schema44.Finite])
+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])
 }).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) => Schema44.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) => 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 toCallRecord = (row) => {
-  const definition = row.definition_json === null || row.definition_json === undefined ? undefined : Schema44.decodeUnknownSync(exports_tool_schema.Definition)(decodeJson(row.definition_json));
-  const outcome = row.external_outcome_json === null || row.external_outcome_json === undefined ? undefined : Schema44.decodeUnknownSync(exports_tool_schema.ExternalOutcome)(decodeJson(row.external_outcome_json));
+  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));
   return {
     executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
     call: normalizeCall({
       id: exports_ids_schema.ToolCallId.make(row.id),
       name: row.name,
-      input: Schema44.decodeUnknownSync(exports_shared_schema.JsonValue)(decodeJson(row.input_json)),
-      metadata: Schema44.decodeUnknownSync(exports_shared_schema.Metadata)(decodeJson(row.metadata_json))
+      input: Schema45.decodeUnknownSync(exports_shared_schema.JsonValue)(decodeJson(row.input_json)),
+      metadata: Schema45.decodeUnknownSync(exports_shared_schema.Metadata)(decodeJson(row.metadata_json))
     }),
     ...definition === undefined ? {} : { definition },
     placement: placementFromRow(row),
-    state: Schema44.decodeUnknownSync(exports_tool_schema.CallState)(row.state),
+    state: Schema45.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),
@@ -8425,9 +8530,9 @@ var toCallRecord = (row) => {
 var toResultRecord = (row) => ({
   result: {
     call_id: exports_ids_schema.ToolCallId.make(row.tool_call_id),
-    output: Schema44.decodeUnknownSync(exports_shared_schema.JsonValue)(decodeJson(row.output_json)),
+    output: Schema45.decodeUnknownSync(exports_shared_schema.JsonValue)(decodeJson(row.output_json)),
     ...row.error === null || row.error === undefined ? {} : { error: row.error },
-    metadata: Schema44.decodeUnknownSync(exports_shared_schema.Metadata)(decodeJson(row.metadata_json))
+    metadata: Schema45.decodeUnknownSync(exports_shared_schema.Metadata)(decodeJson(row.metadata_json))
   },
   createdAt: fromDbTimestamp(row.created_at)
 });
@@ -8544,8 +8649,8 @@ var makeToolCallRecordSupport = ({ sql, errors, toolCallIdempotencyKey }) => {
     `,
     orElse: () => selectCallByKey
   });
-  const decodeCallRow = (row) => Schema44.decodeUnknownEffect(toolCallRow)(row).pipe(Effect46.mapError(toRepositoryError14));
-  const decodeResultRow = (row) => Schema44.decodeUnknownEffect(toolResultRow)(row).pipe(Effect46.mapError(toRepositoryError14));
+  const decodeCallRow = (row) => Schema45.decodeUnknownEffect(toolCallRow)(row).pipe(Effect46.mapError(toRepositoryError14));
+  const decodeResultRow = (row) => Schema45.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 });
@@ -8677,44 +8782,44 @@ var makeToolCallRepository = ({
 });
 
 // ../store-sql/src/tool/tool-call-repository.ts
-class ToolCallRepositoryError extends Schema45.TaggedErrorClass()("ToolCallRepositoryError", {
-  message: Schema45.String
+class ToolCallRepositoryError extends Schema46.TaggedErrorClass()("ToolCallRepositoryError", {
+  message: Schema46.String
 }) {
 }
 
-class ToolCallNotFound extends Schema45.TaggedErrorClass()("ToolCallNotFound", {
+class ToolCallNotFound extends Schema46.TaggedErrorClass()("ToolCallNotFound", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class DuplicateToolCall extends Schema45.TaggedErrorClass()("DuplicateToolCall", {
+class DuplicateToolCall extends Schema46.TaggedErrorClass()("DuplicateToolCall", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class DuplicateToolResult extends Schema45.TaggedErrorClass()("DuplicateToolResult", {
+class DuplicateToolResult extends Schema46.TaggedErrorClass()("DuplicateToolResult", {
   call_id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class ToolCallConflict extends Schema45.TaggedErrorClass()("ToolCallConflict", {
+class ToolCallConflict extends Schema46.TaggedErrorClass()("ToolCallConflict", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class ToolCallTransitionRejected extends Schema45.TaggedErrorClass()("ToolCallTransitionRejected", {
+class ToolCallTransitionRejected extends Schema46.TaggedErrorClass()("ToolCallTransitionRejected", {
   id: exports_ids_schema.ToolCallId,
-  message: Schema45.String
+  message: Schema46.String
 }) {
 }
 
-class ToolOutcomeConflict extends Schema45.TaggedErrorClass()("ToolOutcomeConflict", {
+class ToolOutcomeConflict extends Schema46.TaggedErrorClass()("ToolOutcomeConflict", {
   id: exports_ids_schema.ToolCallId
 }) {
 }
 
-class ToolClaimRejected extends Schema45.TaggedErrorClass()("ToolClaimRejected", {
-  message: Schema45.String
+class ToolClaimRejected extends Schema46.TaggedErrorClass()("ToolClaimRejected", {
+  message: Schema46.String
 }) {
 }
 var lengthPrefixed = (value) => `${[...value].length}:${value}`;
@@ -9181,57 +9286,57 @@ __export(exports_workspace_lease_repository, {
   Service: () => Service39,
   DuplicateWorkspaceLease: () => DuplicateWorkspaceLease
 });
-import { Context as Context37, Effect as Effect48, Layer as Layer39, Schema as Schema46 } from "effect";
+import { Context as Context37, Effect as Effect48, Layer as Layer39, Schema as Schema47 } from "effect";
 import { SqlClient as SqlClient27 } from "effect/unstable/sql/SqlClient";
-class WorkspaceLeaseRepositoryError extends Schema46.TaggedErrorClass()("WorkspaceLeaseRepositoryError", {
-  message: Schema46.String
+class WorkspaceLeaseRepositoryError extends Schema47.TaggedErrorClass()("WorkspaceLeaseRepositoryError", {
+  message: Schema47.String
 }) {
 }
 
-class DuplicateWorkspaceLease extends Schema46.TaggedErrorClass()("DuplicateWorkspaceLease", {
+class DuplicateWorkspaceLease extends Schema47.TaggedErrorClass()("DuplicateWorkspaceLease", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspaceLeaseNotFound extends Schema46.TaggedErrorClass()("WorkspaceLeaseNotFound", {
+class WorkspaceLeaseNotFound extends Schema47.TaggedErrorClass()("WorkspaceLeaseNotFound", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
 class Service39 extends Context37.Service()("@relayfx/store-sql/workspace/workspace-lease-repository/Service") {
 }
-var WorkspaceLeaseRow = Schema46.Struct({
-  id: Schema46.String,
-  execution_id: Schema46.String,
-  provider_key: Schema46.String,
-  sandbox_ref: Schema46.NullishOr(Schema46.String),
-  latest_snapshot_ref: Schema46.NullishOr(Schema46.String),
-  status: Schema46.String,
-  resume_strategy: Schema46.String,
-  region: Schema46.NullishOr(Schema46.String),
-  request_json: Schema46.NullishOr(Schema46.Unknown),
-  metadata_json: Schema46.Unknown,
-  created_at: Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite]),
-  updated_at: Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite])
+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])
 }).annotate({ identifier: "Relay.WorkspaceLease.Row" });
-var WorkspaceSnapshotRow = Schema46.Struct({
-  id: Schema46.String,
-  lease_id: Schema46.String,
-  execution_id: Schema46.String,
-  reason: Schema46.String,
-  snapshot_ref: Schema46.String,
-  metadata_json: Schema46.Unknown,
-  created_at: Schema46.Union([Schema46.Date, Schema46.String, Schema46.Finite])
+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])
 }).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) => Schema46.decodeUnknownSync(exports_workspace_schema.WorkspaceLeaseRecord)(globalThis.structuredClone(record2));
-var cloneSnapshot = (record2) => Schema46.decodeUnknownSync(exports_workspace_schema.WorkspaceSnapshotRecord)(globalThis.structuredClone(record2));
+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 toRepositoryError14 = (error5) => WorkspaceLeaseRepositoryError.make({ message: String(error5) });
-var decodeLeaseRow = (row) => Schema46.decodeUnknownEffect(WorkspaceLeaseRow)(row).pipe(Effect48.mapError(toRepositoryError14));
-var decodeSnapshotRow = (row) => Schema46.decodeUnknownEffect(WorkspaceSnapshotRow)(row).pipe(Effect48.mapError(toRepositoryError14));
-var decodeRequest = (value) => Schema46.decodeUnknownSync(exports_workspace_schema.WorkspaceRequest)(decodeJson(value));
+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 toLeaseRecord = (row) => ({
   id: exports_ids_schema.WorkspaceLeaseId.make(row.id),
   execution_id: exports_ids_schema.ExecutionId.make(row.execution_id),
@@ -9584,10 +9689,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 Schema47 } from "effect";
+import { Clock as Clock4, Context as Context38, Effect as Effect49, Layer as Layer40, Schema as Schema48 } from "effect";
 import { SqlClient as SqlClient28 } from "effect/unstable/sql/SqlClient";
-class RepositoryError extends Schema47.TaggedErrorClass()("WorkflowDefinitionRepositoryError", {
-  message: Schema47.String
+class RepositoryError extends Schema48.TaggedErrorClass()("WorkflowDefinitionRepositoryError", {
+  message: Schema48.String
 }) {
 }
 
@@ -9841,8 +9946,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: Schema47.decodeUnknownSync(exports_workflow_schema.DefinitionDigest)(row.digest),
-  definition: Schema47.decodeUnknownSync(exports_workflow_schema.Definition)(decodeJson(row.definition_json)),
+  digest: Schema48.decodeUnknownSync(exports_workflow_schema.DefinitionDigest)(row.digest),
+  definition: Schema48.decodeUnknownSync(exports_workflow_schema.Definition)(decodeJson(row.definition_json)),
   created_at: fromDbTimestamp(row.created_at)
 });
 var decodeRun = (row) => ({
@@ -9850,19 +9955,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: Schema47.decodeUnknownSync(exports_workflow_schema.DefinitionDigest)(row.workflow_definition_digest)
+    workflow_definition_digest: Schema48.decodeUnknownSync(exports_workflow_schema.DefinitionDigest)(row.workflow_definition_digest)
   },
-  status: Schema47.decodeUnknownSync(exports_workflow_schema.RunStatus)(row.status),
+  status: Schema48.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: Schema47.decodeUnknownSync(exports_workflow_schema.OperationStatus)(row.status),
+  status: Schema48.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: Schema47.decodeUnknownSync(exports_workflow_schema.OperationState.fields.output)(decodeJson(row.output_json)) },
+  ...row.output_json === null || row.output_json === undefined ? {} : { output: Schema48.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) },
@@ -9873,17 +9978,17 @@ var decodeOperation = (row) => ({
 var decodeLifecycle = (row) => ({
   execution_id: exports_ids_schema.ExecutionId.make(row.execution_id),
   sequence: Number(row.sequence),
-  type: Schema47.decodeUnknownSync(exports_workflow_schema.LifecycleEventType)(row.event_type),
+  type: Schema48.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: Schema47.decodeUnknownSync(exports_workflow_schema.LifecycleEvent.fields.data)(decodeJson(row.data_json)) },
+  ...row.data_json === null || row.data_json === undefined ? {} : { data: Schema48.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 Schema50, 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 Schema51, 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 Schema48, Stream as Stream9 } from "effect";
+import { Context as Context39, Effect as Effect53, Function as Function7, Layer as Layer43, Option as Option10, Schema as Schema49, 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";
@@ -10236,14 +10341,14 @@ var makeRepositoryLayer = (eventLog) => {
 };
 
 // ../runtime/src/execution/event-log-service.ts
-class EventLogCursorNotFound2 extends Schema48.TaggedErrorClass()("EventLogCursorNotFound", {
+class EventLogCursorNotFound2 extends Schema49.TaggedErrorClass()("EventLogCursorNotFound", {
   execution_id: exports_ids_schema.ExecutionId,
   cursor: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class EventLogError extends Schema48.TaggedErrorClass()("EventLogError", {
-  message: Schema48.String
+class EventLogError extends Schema49.TaggedErrorClass()("EventLogError", {
+  message: Schema49.String
 }) {
 }
 
@@ -10312,19 +10417,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 Schema49 } from "effect";
-class WaitNotFound2 extends Schema49.TaggedErrorClass()("WaitNotFound", {
+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", {
   wait_id: exports_ids_schema.WaitId
 }) {
 }
 
-class WaitDefinitionMissing extends Schema49.TaggedErrorClass()("WaitDefinitionMissing", {
+class WaitDefinitionMissing extends Schema50.TaggedErrorClass()("WaitDefinitionMissing", {
   envelope_id: exports_ids_schema.EnvelopeId
 }) {
 }
 
-class WaitServiceError extends Schema49.TaggedErrorClass()("WaitServiceError", {
-  message: Schema49.String
+class WaitServiceError extends Schema50.TaggedErrorClass()("WaitServiceError", {
+  message: Schema50.String
 }) {
 }
 
@@ -10604,20 +10709,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) => Schema50.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
-var fallbackParametersSchema = Schema50.Struct({});
+var jsonValue2 = (value) => Schema51.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var fallbackParametersSchema = Schema51.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) => Schema50.isSchema(field));
+var isStructFieldMap = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((field) => Schema51.isSchema(field));
 var jsonSchemaFromEffectToolParameters = (tool) => {
   const parameters = tool.parametersSchema;
-  if (Schema50.isSchema(parameters))
+  if (Schema51.isSchema(parameters))
     return AiTool.getJsonSchema(tool);
   if (isStructFieldMap(parameters))
-    return AiTool.getJsonSchemaFromSchema(Schema50.Struct(parameters));
+    return AiTool.getJsonSchemaFromSchema(Schema51.Struct(parameters));
   return AiTool.getJsonSchema(tool);
 };
 var runHandledToolkitTool = (toolkit, name, input, services) => {
@@ -10631,7 +10736,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) => Schema50.is(ToolExecutionFailed)(error5) ? error5 : ToolExecutionFailed.make({ tool_name: String(name), message: String(error5) })));
+  })), Effect55.provide(services), Effect55.mapError((error5) => Schema51.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) {
@@ -10728,7 +10833,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) => Schema50.decodeUnknownSync(exports_shared_schema.NonEmptyString)(name);
+var nonEmptyName = (name) => Schema51.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,
@@ -10769,8 +10874,8 @@ var tool = Function8.dual(2, (name, options) => {
     tool: effectTool,
     ...options.placement === undefined ? {} : { placement: options.placement },
     ...options.requiredPermissions === undefined ? {} : { requiredPermissions: options.requiredPermissions },
-    validateInput: (input) => Schema50.decodeUnknownEffect(inputSchema)(input).pipe(Effect55.mapError((error5) => ToolInputInvalid.make({ tool_name: name, message: error5.message })), Effect55.asVoid),
-    run: (input, context) => Schema50.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) => Schema50.encodeUnknownEffect(outputSchema)(output).pipe(Effect55.mapError((error5) => ToolExecutionFailed.make({ tool_name: name, message: error5.message })))), Effect55.map(jsonValue2))
+    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))
   };
 });
 var dynamicTool = Function8.dual(2, (name, options) => {
@@ -10778,7 +10883,7 @@ var dynamicTool = Function8.dual(2, (name, options) => {
   const modelTool = attachJsonSchema(AiTool.dynamic(name, {
     description: options.description,
     parameters: parameters.parameters,
-    success: Schema50.Unknown,
+    success: Schema51.Unknown,
     needsApproval: options.needsApproval
   }), parameters.jsonSchema);
   return {
@@ -10823,7 +10928,7 @@ var externalOutcomeResult = (call, input) => {
     return Effect55.succeed(placementFailureResult(input, call.externalOutcome.message));
   }
   const placement = call.placement.kind;
-  return Schema50.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 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}`))));
 };
 var runExternalTool = (repository, waits, call, input) => Effect55.gen(function* () {
   const waitId2 = placementWaitId(input);
@@ -10857,7 +10962,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* Schema50.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* Schema51.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,
@@ -11022,11 +11127,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 Schema53 } from "effect";
+import { Clock as Clock5, Context as Context44, Effect as Effect58, FiberMap, Layer as Layer48, Schema as Schema54 } 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 Schema52 } from "effect";
-class ChildFanOutTransitionError extends Schema52.TaggedErrorClass()("ChildFanOutTransitionError", { message: Schema52.String }) {
+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 }) {
 }
 
 class Service43 extends Context43.Service()("@relayfx/runtime/child/child-fan-out-transition-service/Service") {
@@ -11093,7 +11198,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 Schema53.TaggedErrorClass()("ChildFanOutRuntimeError", { message: Schema53.String }) {
+class ChildFanOutRuntimeError extends Schema54.TaggedErrorClass()("ChildFanOutRuntimeError", { message: Schema54.String }) {
 }
 
 class Service44 extends Context44.Service()("@relayfx/runtime/child/child-fan-out-runtime/Service") {
@@ -11160,17 +11265,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 Schema54 } from "effect";
+import { Config as Config2, Context as Context45, Effect as Effect59, Function as Function10, Layer as Layer49, Schema as Schema55 } from "effect";
 var StateVersionConflict3 = exports_execution_state_repository.StateVersionConflict;
 
-class StateValueInvalid extends Schema54.TaggedErrorClass()("StateValueInvalid", {
-  key: Schema54.String,
-  message: Schema54.String
+class StateValueInvalid extends Schema55.TaggedErrorClass()("StateValueInvalid", {
+  key: Schema55.String,
+  message: Schema55.String
 }) {
 }
 
-class ExecutionStateError extends Schema54.TaggedErrorClass()("ExecutionStateError", {
-  message: Schema54.String
+class ExecutionStateError extends Schema55.TaggedErrorClass()("ExecutionStateError", {
+  message: Schema55.String
 }) {
 }
 var key3 = Function10.dual(2, (name, schema) => ({
@@ -11190,7 +11295,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* Schema54.decodeUnknownEffect(stateKey.schema)(row.value).pipe(Effect59.mapError((cause) => invalid(stateKey.name, cause)));
+    return yield* Schema55.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) {
@@ -11199,8 +11304,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* Schema54.encodeUnknownEffect(input.key.schema)(input.value).pipe(Effect59.mapError((cause) => invalid(input.key.name, cause)));
-    const encoded = yield* Schema54.encodeEffect(Schema54.UnknownFromJsonString)(value).pipe(Effect59.mapError((cause) => invalid(input.key.name, cause)));
+    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 bytes = new TextEncoder().encode(encoded);
     let eventValue = { value };
     if (bytes.byteLength > eventInlineMaxBytes) {
@@ -11215,9 +11320,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) => Schema54.is(exports_execution_state_repository.StateVersionConflict)(cause) ? cause : stateError(cause)));
+    }).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) => Schema54.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 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 });
 }));
@@ -11225,7 +11330,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 Schema90, 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 Schema91, Stream as Stream16 } from "effect";
 import {
   ClusterWorkflowEngine,
   HttpRunner,
@@ -11246,7 +11351,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 Schema55 } 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 Schema56 } from "effect";
 
 // ../runtime/src/tool/tool-input-schema-digest.ts
 import { Crypto, Effect as Effect60, Encoding } from "effect";
@@ -11268,13 +11373,13 @@ var digestDefinitions = Effect60.fn("ToolInputSchemaDigest.digestDefinitions")(f
 });
 
 // ../runtime/src/agent/agent-registry-service.ts
-class AgentDefinitionInvalid extends Schema55.TaggedErrorClass()("AgentDefinitionInvalid", {
-  message: Schema55.String
+class AgentDefinitionInvalid extends Schema56.TaggedErrorClass()("AgentDefinitionInvalid", {
+  message: Schema56.String
 }) {
 }
 
-class AgentRegistryError extends Schema55.TaggedErrorClass()("AgentRegistryError", {
-  message: Schema55.String
+class AgentRegistryError extends Schema56.TaggedErrorClass()("AgentRegistryError", {
+  message: Schema56.String
 }) {
 }
 
@@ -11316,7 +11421,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* Schema55.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* Schema56.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 }
@@ -11460,35 +11565,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 Schema83, Stream as Stream13 } from "effect";
+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";
 
 // ../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 Schema57 } 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 Schema58 } 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 Schema56 } from "effect";
+import { Context as Context47, Effect as Effect62, Function as Function11, Layer as Layer51, Ref as Ref13, Schema as Schema57 } from "effect";
 
-class WorkspaceNotFound extends Schema56.TaggedErrorClass()("WorkspaceNotFound", {
+class WorkspaceNotFound extends Schema57.TaggedErrorClass()("WorkspaceNotFound", {
   sandbox_ref: exports_ids_schema.WorkspaceRef
 }) {
 }
 
-class WorkspaceUnavailable extends Schema56.TaggedErrorClass()("WorkspaceUnavailable", {
+class WorkspaceUnavailable extends Schema57.TaggedErrorClass()("WorkspaceUnavailable", {
   sandbox_ref: exports_ids_schema.WorkspaceRef,
-  message: Schema56.String
+  message: Schema57.String
 }) {
 }
 
-class WorkspaceCapabilityUnsupported extends Schema56.TaggedErrorClass()("WorkspaceCapabilityUnsupported", {
-  capability: Schema56.Literals(["suspend", "snapshot", "fork"]),
+class WorkspaceCapabilityUnsupported extends Schema57.TaggedErrorClass()("WorkspaceCapabilityUnsupported", {
+  capability: Schema57.Literals(["suspend", "snapshot", "fork"]),
   provider_key: exports_workspace_schema.WorkspaceProviderKey
 }) {
 }
 
-class WorkspaceProviderError extends Schema56.TaggedErrorClass()("WorkspaceProviderError", {
+class WorkspaceProviderError extends Schema57.TaggedErrorClass()("WorkspaceProviderError", {
   provider_key: exports_workspace_schema.WorkspaceProviderKey,
-  message: Schema56.String
+  message: Schema57.String
 }) {
 }
 
@@ -11541,28 +11646,28 @@ var destroy = Effect62.fn("WorkspaceProvider.destroy.call")(function* (ref) {
 });
 
 // ../runtime/src/child/child-run-service.ts
-class StaticChildRunPresetNotFound extends Schema57.TaggedErrorClass()("StaticChildRunPresetNotFound", {
+class StaticChildRunPresetNotFound extends Schema58.TaggedErrorClass()("StaticChildRunPresetNotFound", {
   preset_name: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ChildRunScopeBroadened extends Schema57.TaggedErrorClass()("ChildRunScopeBroadened", {
-  field: Schema57.Literals(["tool_names", "permissions"]),
+class ChildRunScopeBroadened extends Schema58.TaggedErrorClass()("ChildRunScopeBroadened", {
+  field: Schema58.Literals(["tool_names", "permissions"]),
   value: exports_shared_schema.NonEmptyString
 }) {
 }
 
-class ChildRunServiceError extends Schema57.TaggedErrorClass()("ChildRunServiceError", {
-  message: Schema57.String
+class ChildRunServiceError extends Schema58.TaggedErrorClass()("ChildRunServiceError", {
+  message: Schema58.String
 }) {
 }
 
-class ChildRunWorkspaceUnavailable extends Schema57.TaggedErrorClass()("ChildRunWorkspaceUnavailable", {
-  reason: Schema57.String
+class ChildRunWorkspaceUnavailable extends Schema58.TaggedErrorClass()("ChildRunWorkspaceUnavailable", {
+  reason: Schema58.String
 }) {
 }
 
-class ChildRunModelMissing extends Schema57.TaggedErrorClass()("ChildRunModelMissing", {}) {
+class ChildRunModelMissing extends Schema58.TaggedErrorClass()("ChildRunModelMissing", {}) {
 }
 
 class Service48 extends Context48.Service()("@relayfx/runtime/child/child-run-service/Service") {
@@ -11798,53 +11903,53 @@ var spawnDynamic = Effect63.fn("ChildRunService.spawnDynamic.call")(function* (i
 });
 
 // ../runtime/src/child/spawn-child-run-tool.ts
-import { Effect as Effect64, Schema as Schema58 } from "effect";
+import { Effect as Effect64, Schema as Schema59 } from "effect";
 var toolName = "spawn_child_run";
 var permissionName = "relay.child_run.spawn";
-var Input = Schema58.Struct({
-  preset_name: Schema58.optionalKey(exports_shared_schema.NonEmptyString),
-  instructions: Schema58.optionalKey(Schema58.String),
-  model: Schema58.optionalKey(exports_agent_schema.ModelSelection),
-  compaction_policy: Schema58.optionalKey(exports_agent_schema.CompactionPolicy),
-  tool_names: Schema58.optionalKey(Schema58.Array(Schema58.String)),
-  permissions: Schema58.optionalKey(Schema58.Array(Schema58.String)),
-  output_schema_ref: Schema58.optionalKey(Schema58.String),
-  metadata: Schema58.optionalKey(exports_shared_schema.Metadata),
-  input: Schema58.optionalKey(Schema58.Array(exports_content_schema.Part))
+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))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Input" });
-var Output = Schema58.Struct({
+var Output = Schema59.Struct({
   child_execution_id: exports_ids_schema.ChildExecutionId,
-  status: Schema58.Literals(["completed", "failed", "cancelled"]),
-  output: Schema58.Array(exports_content_schema.Part)
+  status: Schema59.Literals(["completed", "failed", "cancelled"]),
+  output: Schema59.Array(exports_content_schema.Part)
 }).annotate({ identifier: "Relay.SpawnChildRunTool.Output" });
-var TransferInput = Schema58.Struct({
-  input: Schema58.optionalKey(Schema58.Array(exports_content_schema.Part))
+var TransferInput = Schema59.Struct({
+  input: Schema59.optionalKey(Schema59.Array(exports_content_schema.Part))
 }).annotate({ identifier: "Relay.SpawnChildRunTool.TransferInput" });
-var ModelInput = Schema58.Struct({
-  preset_name: Schema58.optionalKey(Schema58.NullOr(Schema58.String)),
-  instructions: Schema58.optionalKey(Schema58.String),
-  model: Schema58.optionalKey(Schema58.NullOr(Schema58.Struct({
-    provider: Schema58.String,
-    model: Schema58.String,
-    registration_key: Schema58.optionalKey(Schema58.String)
+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)
   }))),
-  compaction_policy: Schema58.optionalKey(Schema58.Struct({
-    context_window: Schema58.Finite,
-    reserve_tokens: Schema58.Finite,
-    keep_recent_tokens: Schema58.Finite,
-    summary_model: Schema58.optionalKey(Schema58.Struct({
-      provider: Schema58.String,
-      model: Schema58.String,
-      registration_key: Schema58.optionalKey(Schema58.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)
     }))
   })),
-  tool_names: Schema58.optionalKey(Schema58.Array(Schema58.String)),
-  permissions: Schema58.optionalKey(Schema58.Array(Schema58.String)),
-  output_schema_ref: Schema58.optionalKey(Schema58.NullOr(Schema58.String)),
-  input: Schema58.optionalKey(Schema58.Array(Schema58.Struct({ type: Schema58.Literal("text"), text: Schema58.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 })))
 });
-var ModelTransferInput = Schema58.Struct({
-  input: Schema58.optionalKey(Schema58.Array(Schema58.Struct({ type: Schema58.Literal("text"), text: Schema58.String })))
+var ModelTransferInput = Schema59.Struct({
+  input: Schema59.optionalKey(Schema59.Array(Schema59.Struct({ type: Schema59.Literal("text"), text: Schema59.String })))
 });
 var normalizeModelInput = (input) => {
   const { preset_name: presetName, model, output_schema_ref: outputSchemaRef2, ...rest } = input;
@@ -12029,7 +12134,7 @@ var registeredTool = (config) => tool(toolName, {
   permissions: [{ name: permissionName, value: true }],
   requiredPermissions: [permissionName],
   metadata: { relay_core_tool: true },
-  run: (input, context) => Schema58.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) => 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)))
 });
 var transferToolName2 = (name) => `transfer_to_${name.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "")}`;
 var transferTools = (config) => (config.agent.handoff_targets ?? []).map((target) => {
@@ -12041,12 +12146,12 @@ 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) => Schema58.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) => 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)))
   });
 });
 
 // ../runtime/src/memory/memory-service.ts
-import { Clock as Clock7, Context as Context49, Effect as Effect65, Layer as Layer53, Schema as Schema59 } from "effect";
+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";
 class Service49 extends Context49.Service()("@relayfx/runtime/memory/memory-service/Service") {
 }
@@ -12054,7 +12159,7 @@ var defaultTopK = 5;
 var memoryError = (error5) => exports_memory.MemoryError.make({
   message: error5 instanceof Error ? `${error5.name}: ${error5.message}` : String(error5)
 });
-var decodeSubject = (subject) => Schema59.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect65.mapError(memoryError));
+var decodeSubject = (subject) => Schema60.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect65.mapError(memoryError));
 var textPart = (text) => Prompt4.makePart("text", { text });
 var textFromParts = (parts) => parts.filter((part) => part.type === "text").map((part) => part.text).join(`
 `).trim();
@@ -12217,8 +12322,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 Schema60, Stream as Stream11 } from "effect";
-var isPresenceError = Schema60.is(PresenceError);
+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);
 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* () {
@@ -12273,11 +12378,11 @@ var list13 = Effect66.fn("Presence.list.call")(function* (scope) {
 });
 
 // ../runtime/src/presence/presence-tool.ts
-import { Effect as Effect67, Schema as Schema61 } from "effect";
+import { Effect as Effect67, Schema as Schema62 } from "effect";
 var toolName2 = "relay_presence";
 var permissionName2 = "relay.presence.read";
-var Input2 = Schema61.Struct({ scope: Schema61.optionalKey(exports_presence_schema.Scope) });
-var Output2 = Schema61.Struct({ watcher_count: Schema61.Finite, entries: Schema61.Array(exports_presence_schema.Entry) });
+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 registeredTool2 = (presence) => tool(toolName2, {
   description: "List observers currently watching an execution or session.",
   input: Input2,
@@ -12293,24 +12398,24 @@ var registeredTool2 = (presence) => tool(toolName2, {
 });
 
 // ../runtime/src/state/state-tools.ts
-import { Effect as Effect68, Schema as Schema62 } from "effect";
-var GetInput = Schema62.Struct({ key: exports_shared_schema.NonEmptyString });
-var GetOutput = Schema62.Struct({
-  value: Schema62.optionalKey(exports_shared_schema.JsonValue),
-  version: Schema62.optionalKey(Schema62.Int)
+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)
 });
-var PutInput = Schema62.Struct({
+var PutInput = Schema63.Struct({
   key: exports_shared_schema.NonEmptyString,
   value: exports_shared_schema.JsonValue,
-  expected_version: Schema62.optionalKey(Schema62.Int.check(Schema62.isGreaterThanOrEqualTo(0)))
+  expected_version: Schema63.optionalKey(Schema63.Int.check(Schema63.isGreaterThanOrEqualTo(0)))
 });
-var DeleteInput = Schema62.Struct({ key: exports_shared_schema.NonEmptyString, expected_version: Schema62.optionalKey(Schema62.Int) });
-var ListInput = Schema62.Struct({
-  prefix: Schema62.optionalKey(Schema62.String),
-  after_key: Schema62.optionalKey(Schema62.String),
-  limit: Schema62.optionalKey(Schema62.Int)
+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 RecordOutput = Schema62.Struct({
+var RecordOutput = Schema63.Struct({
   execution_id: exports_state_schema.StateRecordView.fields.execution_id,
   key: exports_state_schema.StateRecordView.fields.key,
   value: exports_state_schema.StateRecordView.fields.value,
@@ -12318,8 +12423,8 @@ var RecordOutput = Schema62.Struct({
   created_at: exports_state_schema.StateRecordView.fields.created_at,
   updated_at: exports_state_schema.StateRecordView.fields.updated_at
 });
-var PutOutput = Schema62.Struct({ key: exports_state_schema.StateKey, version: exports_state_schema.StateVersion });
-var DeleteOutput = Schema62.Struct({ deleted: Schema62.Boolean, version: Schema62.optionalKey(Schema62.Int) });
+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 enabled2 = (agent) => agent.metadata?.state_enabled === true;
 var mapStateError = (toolName3) => (error5) => ToolExecutionFailed.make({ tool_name: toolName3, message: error5._tag });
 var registeredTools2 = (state) => [
@@ -12360,7 +12465,7 @@ var registeredTools2 = (state) => [
   tool("state_list", {
     description: "List durable execution state",
     input: ListInput,
-    output: Schema62.Array(RecordOutput),
+    output: Schema63.Array(RecordOutput),
     metadata: { relay_core_tool: true },
     run: (input, context) => state.list({
       executionId: context.executionId,
@@ -12537,7 +12642,8 @@ var make5 = Effect69.fn("RelaySessionStore.make")(function* (sessionId, entrySco
       parentId: current2.leaf,
       input: toAppendInput(input),
       createdAt: now,
-      ...expectedLeafId === undefined ? {} : { expectedLeafId: expectedLeafId === null ? null : entryId(expectedLeafId) }
+      ...expectedLeafId === undefined ? {} : { expectedLeafId: expectedLeafId === null ? null : entryId(expectedLeafId) },
+      ...makeOptions?.writer === undefined ? {} : { expectedWriter: makeOptions.writer }
     }).pipe(Effect69.mapError(mapWriteError));
     yield* Ref14.set(state, { leaf: entry.id, next: current2.next + 1 });
     return entry;
@@ -12571,7 +12677,8 @@ var make5 = Effect69.fn("RelaySessionStore.make")(function* (sessionId, entrySco
       parentId: checkpoint.parentId === null ? null : entryId(checkpoint.parentId),
       projectedHistory: checkpoint.projectedHistory,
       ...checkpoint.summary === undefined ? {} : { summary: checkpoint.summary },
-      createdAt: now
+      createdAt: now,
+      ...makeOptions?.writer === undefined ? {} : { expectedWriter: makeOptions.writer }
     }).pipe(Effect69.mapError(mapWriteError));
     const current2 = yield* Ref14.get(state);
     if (current2 === undefined) {
@@ -12619,43 +12726,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 Schema74 } from "effect";
+import { Clock as Clock12, Context as Context61, Effect as Effect81, Layer as Layer67, Schema as Schema75 } from "effect";
 
 // ../runtime/src/wait/wait-signal.ts
-import { Effect as Effect80, Schema as Schema73 } from "effect";
+import { Effect as Effect80, Schema as Schema74 } 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 Schema72 } from "effect";
+import { Cause, Effect as Effect79, Exit, Function as Function14, Layer as Layer66, Option as Option20, Schema as Schema73 } from "effect";
 
 // ../runtime/src/address/address-resolution-service.ts
-import { Context as Context53, Effect as Effect71, Layer as Layer58, Schema as Schema64 } from "effect";
+import { Context as Context53, Effect as Effect71, Layer as Layer58, Schema as Schema65 } from "effect";
 
 // ../runtime/src/address/address-book-service.ts
-import { Context as Context52, Effect as Effect70, Layer as Layer57, Ref as Ref15, Schema as Schema63 } from "effect";
+import { Context as Context52, Effect as Effect70, Layer as Layer57, Ref as Ref15, Schema as Schema64 } from "effect";
 var RouteKind2 = exports_address_schema.RouteKind;
 var Route = exports_address_schema.Route;
 var RouteRecord = exports_address_schema.RouteRecord;
 
-class AddressNotFound2 extends Schema63.TaggedErrorClass()("AddressNotFound", {
+class AddressNotFound2 extends Schema64.TaggedErrorClass()("AddressNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class AddressUnavailable extends Schema63.TaggedErrorClass()("AddressUnavailable", {
+class AddressUnavailable extends Schema64.TaggedErrorClass()("AddressUnavailable", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema63.String
+  route_key: Schema64.String
 }) {
 }
 
-class AddressDeferred extends Schema63.TaggedErrorClass()("AddressDeferred", {
+class AddressDeferred extends Schema64.TaggedErrorClass()("AddressDeferred", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema63.String
+  route_key: Schema64.String
 }) {
 }
 
-class AddressBookServiceError extends Schema63.TaggedErrorClass()("AddressBookServiceError", {
-  message: Schema63.String
+class AddressBookServiceError extends Schema64.TaggedErrorClass()("AddressBookServiceError", {
+  message: Schema64.String
 }) {
 }
 
@@ -12683,7 +12790,7 @@ var recordFromEntry = (entry) => ({
   updated_at: entry.updatedAt
 });
 var entryIdFor = (addressId) => exports_ids_schema.AddressBookEntryId.make(`address-book:${addressId}`);
-var validateRoute = (route) => Schema63.decodeUnknownEffect(Route)(route).pipe(Effect70.mapError((error5) => AddressBookServiceError.make({ message: String(error5) })));
+var validateRoute = (route) => Schema64.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 });
@@ -12748,41 +12855,41 @@ var list14 = Effect70.fn("AddressBook.list.call")(function* () {
 });
 
 // ../runtime/src/address/address-resolution-service.ts
-class AddressRouteNotFound extends Schema64.TaggedErrorClass()("AddressRouteNotFound", {
+class AddressRouteNotFound extends Schema65.TaggedErrorClass()("AddressRouteNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class AddressRouteKindMismatch extends Schema64.TaggedErrorClass()("AddressRouteKindMismatch", {
+class AddressRouteKindMismatch extends Schema65.TaggedErrorClass()("AddressRouteKindMismatch", {
   address_id: exports_ids_schema.AddressId,
-  expected: Schema64.Literal("local-agent"),
+  expected: Schema65.Literal("local-agent"),
   actual: exports_address_schema.RouteKind,
-  route_key: Schema64.String
+  route_key: Schema65.String
 }) {
 }
 
-class AddressAgentDefinitionNotFound extends Schema64.TaggedErrorClass()("AddressAgentDefinitionNotFound", {
+class AddressAgentDefinitionNotFound extends Schema65.TaggedErrorClass()("AddressAgentDefinitionNotFound", {
   address_id: exports_ids_schema.AddressId,
   agent_id: exports_ids_schema.AgentId
 }) {
 }
 
-class AddressResolutionError extends Schema64.TaggedErrorClass()("AddressResolutionError", {
-  message: Schema64.String
+class AddressResolutionError extends Schema65.TaggedErrorClass()("AddressResolutionError", {
+  message: Schema65.String
 }) {
 }
-var LocalAgentRoute = Schema64.Struct({
-  kind: Schema64.Literal("local-agent"),
+var LocalAgentRoute = Schema65.Struct({
+  kind: Schema65.Literal("local-agent"),
   route_key: exports_shared_schema.NonEmptyString,
-  metadata: Schema64.optionalKey(exports_shared_schema.Metadata)
+  metadata: Schema65.optionalKey(exports_shared_schema.Metadata)
 }).annotate({ identifier: "Relay.AddressResolution.LocalAgentRoute" });
-var LocalAgentTarget = Schema64.Struct({
+var LocalAgentTarget = Schema65.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: Schema64.optionalKey(exports_agent_schema.ToolInputSchemaDigests)
+  tool_input_schema_digests: Schema65.optionalKey(exports_agent_schema.ToolInputSchemaDigests)
 }).annotate({ identifier: "Relay.AddressResolution.LocalAgentTarget" });
 
 class Service53 extends Context53.Service()("@relayfx/runtime/address/address-resolution-service/Service") {
@@ -12815,7 +12922,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* Schema64.decodeUnknownEffect(exports_ids_schema.AgentId)(route.route_key).pipe(Effect71.mapError((error5) => AddressResolutionError.make({ message: String(error5) })));
+      const agentId = yield* Schema65.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({
@@ -12844,13 +12951,13 @@ var resolveLocalAgent = Effect71.fn("AddressResolution.resolveLocalAgent.call")(
 });
 
 // ../runtime/src/agent/agent-loop-error.ts
-import { Schema as Schema65 } from "effect";
+import { Schema as Schema66 } from "effect";
 import { AiError as AiError2 } from "effect/unstable/ai";
 
-class AgentLoopError extends Schema65.TaggedErrorClass()("AgentLoopError", {
-  message: Schema65.String,
-  failure_classification: Schema65.optionalKey(Schema65.Literal("context-overflow")),
-  baton_failure: Schema65.optionalKey(Schema65.Union([
+class AgentLoopError extends Schema66.TaggedErrorClass()("AgentLoopError", {
+  message: Schema66.String,
+  failure_classification: Schema66.optionalKey(Schema66.Literal("context-overflow")),
+  baton_failure: Schema66.optionalKey(Schema66.Union([
     exports_agent_event.AgentError,
     exports_agent_event.ResumeMismatch,
     exports_turn_policy.TurnPolicyError,
@@ -12858,31 +12965,31 @@ class AgentLoopError extends Schema65.TaggedErrorClass()("AgentLoopError", {
     exports_agent_event.TurnLimitExceeded,
     exports_agent_event.MiddlewareViolation,
     exports_agent_event.DuplicateToolCallId,
-    exports_agent_event.ProgressOverflowError,
+    exports_agent_event.ProgressOverflow,
     exports_agent_event.ToolNameCollision,
     AiError2.AiError,
     exports_model_registry.LanguageModelNotRegistered,
     exports_tool_executor.FrameworkFailure
   ])),
-  next_event_sequence: Schema65.optionalKey(exports_execution_schema.ExecutionEventSequence)
+  next_event_sequence: Schema66.optionalKey(exports_execution_schema.ExecutionEventSequence)
 }) {
 }
 
-class AgentLoopBudgetExceeded extends Schema65.TaggedErrorClass()("AgentLoopBudgetExceeded", {
-  tokens_used: Schema65.Int,
-  token_budget: Schema65.Int,
+class AgentLoopBudgetExceeded extends Schema66.TaggedErrorClass()("AgentLoopBudgetExceeded", {
+  tokens_used: Schema66.Int,
+  token_budget: Schema66.Int,
   next_event_sequence: exports_execution_schema.ExecutionEventSequence
 }) {
 }
-var AgentTerminalFailure = Schema65.Union([AgentLoopError, AgentLoopBudgetExceeded]);
+var AgentTerminalFailure = Schema66.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 Schema66 } from "effect";
-class ParentNotifyError extends Schema66.TaggedErrorClass()("ParentNotifyError", {
-  message: Schema66.String
+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
 }) {
 }
-var ChildTerminalStatus = Schema66.Literals(["completed", "failed", "cancelled"]).annotate({
+var ChildTerminalStatus = Schema67.Literals(["completed", "failed", "cancelled"]).annotate({
   identifier: "Relay.ParentNotifier.ChildTerminalStatus"
 });
 
@@ -12963,15 +13070,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 Schema67 } from "effect";
+import { Clock as Clock10, Context as Context55, Effect as Effect73, Layer as Layer60, Schema as Schema68 } from "effect";
 
-class SkillDefinitionInvalid extends Schema67.TaggedErrorClass()("SkillDefinitionInvalid", {
-  message: Schema67.String
+class SkillDefinitionInvalid extends Schema68.TaggedErrorClass()("SkillDefinitionInvalid", {
+  message: Schema68.String
 }) {
 }
 
-class SkillRegistryError extends Schema67.TaggedErrorClass()("SkillRegistryError", {
-  message: Schema67.String
+class SkillRegistryError extends Schema68.TaggedErrorClass()("SkillRegistryError", {
+  message: Schema68.String
 }) {
 }
 
@@ -13124,16 +13231,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 Schema68, Stream as Stream12 } from "effect";
+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 { ShardingConfig } from "effect/unstable/cluster";
 var ExecutionServiceErrorDetails = exports_shared_schema.JsonValue.annotate({
   identifier: "Relay.ExecutionServiceErrorDetails"
 });
 
-class ExecutionServiceError extends Schema68.TaggedErrorClass()("ExecutionServiceError", {
-  message: Schema68.String,
-  details: Schema68.optionalKey(ExecutionServiceErrorDetails),
-  next_event_sequence: Schema68.optionalKey(exports_execution_schema.ExecutionEventSequence)
+class ExecutionServiceError extends Schema69.TaggedErrorClass()("ExecutionServiceError", {
+  message: Schema69.String,
+  details: Schema69.optionalKey(ExecutionServiceErrorDetails),
+  next_event_sequence: Schema69.optionalKey(exports_execution_schema.ExecutionEventSequence)
 }) {
 }
 
@@ -13268,6 +13375,37 @@ var failedEvent = (input, error5) => ({
   created_at: input.completedAt
 });
 var terminalEvent2 = (events) => events.find((event) => event.type === "execution.completed" || event.type === "execution.failed");
+var terminalStatuses2 = new Set(["completed", "failed", "cancelled"]);
+var claimSessionWriter = Effect74.fn("ExecutionService.claimSessionWriter")(function* (sessions, repository, input) {
+  if (input.sessionId === undefined)
+    return;
+  const sessionId = input.sessionId;
+  const mapSessionError = (error5) => ExecutionServiceError.make({ message: error5.message });
+  const claim = yield* sessions.claimWriter({ sessionId, executionId: input.executionId, now: input.createdAt }).pipe(Effect74.mapError(mapSessionError));
+  if (claim._tag === "Claimed")
+    return;
+  const owner = yield* repository.get(claim.writer.executionId).pipe(Effect74.mapError(mapRepositoryError7));
+  if (owner !== undefined && !terminalStatuses2.has(owner.status)) {
+    return yield* ExecutionServiceError.make({
+      message: `Session ${sessionId} is owned by execution ${claim.writer.executionId} at epoch ${claim.writer.epoch}`
+    });
+  }
+  yield* sessions.releaseWriter({ sessionId, executionId: claim.writer.executionId, now: input.createdAt }).pipe(Effect74.mapError(mapSessionError));
+  const seized = yield* sessions.claimWriter({ sessionId, executionId: input.executionId, now: input.createdAt }).pipe(Effect74.mapError(mapSessionError));
+  if (seized._tag === "Busy") {
+    return yield* ExecutionServiceError.make({
+      message: `Session ${sessionId} is owned by execution ${seized.writer.executionId} at epoch ${seized.writer.epoch}`
+    });
+  }
+});
+var releaseSessionWriter = Effect74.fn("ExecutionService.releaseSessionWriter")(function* (sessions, execution, now) {
+  if (Option17.isNone(sessions))
+    return;
+  const sessionId = execution.session_id;
+  if (sessionId === undefined)
+    return;
+  yield* sessions.value.releaseWriter({ sessionId, executionId: execution.id, now }).pipe(Effect74.ignore);
+});
 var existingTerminalExecution = Effect74.fn("ExecutionService.existingTerminalExecution")(function* (repository, eventLog, input) {
   const events = yield* eventLog.replay({ executionId: input.executionId }).pipe(Effect74.mapError(mapEventLogError4));
   const event = terminalEvent2(events);
@@ -13283,7 +13421,7 @@ var existingTerminalExecution = Effect74.fn("ExecutionService.existingTerminalEx
     execution: undefined,
     failure: ExecutionServiceError.make({
       message: typeof metadata11.message === "string" ? metadata11.message : "Execution failed",
-      ...Schema68.is(ExecutionServiceErrorDetails)(metadata11.details) ? { details: metadata11.details } : {},
+      ...Schema69.is(ExecutionServiceErrorDetails)(metadata11.details) ? { details: metadata11.details } : {},
       next_event_sequence: event.sequence
     })
   };
@@ -13326,6 +13464,7 @@ var layer46 = Layer61.effect(Service56, Effect74.gen(function* () {
           rootAddressId: input.rootAddressId,
           now: input.createdAt
         }).pipe(Effect74.mapError((error5) => ExecutionServiceError.make({ message: error5.message })));
+        yield* claimSessionWriter(sessions.value, repository, input);
       }
       const record2 = yield* repository.create({
         id: input.executionId,
@@ -13361,6 +13500,7 @@ var layer46 = Layer61.effect(Service56, Effect74.gen(function* () {
           if (failedExecution.status !== "failed")
             return failedExecution;
           yield* appendIdempotentTo(eventLog, failedEvent(input, error5)).pipe(Effect74.mapError(mapEventLogError4));
+          yield* releaseSessionWriter(sessions, failedExecution, input.completedAt);
           yield* recordExecutionFinished("failed");
           yield* recordExecutionDuration("failed", failedExecution.updated_at - failedExecution.created_at);
           return yield* error5;
@@ -13376,6 +13516,7 @@ var layer46 = Layer61.effect(Service56, Effect74.gen(function* () {
           if (execution.status !== "completed")
             return execution;
           yield* appendIdempotentTo(eventLog, completedEvent(input, resultMetadata, completedSequence)).pipe(Effect74.mapError(mapEventLogError4));
+          yield* releaseSessionWriter(sessions, execution, input.completedAt);
           yield* recordExecutionFinished("completed");
           yield* recordExecutionDuration("completed", execution.updated_at - execution.created_at);
           return execution;
@@ -13392,6 +13533,7 @@ var layer46 = Layer61.effect(Service56, Effect74.gen(function* () {
       if (execution.status !== "cancelled")
         return execution;
       yield* appendIdempotentTo(eventLog, cancelledEvent(input)).pipe(Effect74.mapError(mapEventLogError4));
+      yield* releaseSessionWriter(sessions, execution, input.cancelledAt);
       yield* recordExecutionFinished("cancelled");
       yield* recordExecutionDuration("cancelled", execution.updated_at - execution.created_at);
       return execution;
@@ -13473,18 +13615,25 @@ var layer47 = Layer62.effect(Service57, Effect75.gen(function* () {
   return Service57.of({
     run: (executionId, effect) => Effect75.gen(function* () {
       const signal = yield* Deferred2.make();
-      yield* Ref17.update(active, (entries) => new Map(entries).set(executionId, signal));
+      const done = yield* Deferred2.make();
+      const entry = { signal, done };
+      yield* Ref17.update(active, (entries) => new Map(entries).set(executionId, entry));
       const interrupted = Deferred2.await(signal).pipe(Effect75.andThen(() => Effect75.interrupt));
       return yield* Effect75.raceFirst(effect, interrupted).pipe(Effect75.ensuring(Ref17.update(active, (entries) => {
         const next = new Map(entries);
-        if (next.get(executionId) === signal)
+        if (next.get(executionId) === entry)
           next.delete(executionId);
         return next;
-      })));
+      }).pipe(Effect75.andThen(Deferred2.succeed(done, undefined)))));
     }),
     interrupt: Effect75.fn("ActiveExecutionRegistry.interrupt")(function* (executionId) {
-      const signal = yield* Ref17.get(active).pipe(Effect75.map((entries) => entries.get(executionId)));
-      return signal === undefined ? false : yield* Deferred2.succeed(signal, undefined);
+      const entry = yield* Ref17.get(active).pipe(Effect75.map((entries) => entries.get(executionId)));
+      return entry === undefined ? false : yield* Deferred2.succeed(entry.signal, undefined);
+    }),
+    awaitQuiescent: Effect75.fn("ActiveExecutionRegistry.awaitQuiescent")(function* (executionId) {
+      const entry = yield* Ref17.get(active).pipe(Effect75.map((entries) => entries.get(executionId)));
+      if (entry !== undefined)
+        yield* Deferred2.await(entry.done);
     })
   });
 }));
@@ -13515,13 +13664,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 Schema70 } from "effect";
+import { Context as Context60, Effect as Effect78, HashSet as HashSet6, Layer as Layer65, Option as Option18, Schema as Schema71 } from "effect";
 
 // ../runtime/src/workspace/workspace-runtime-service.ts
-import { Context as Context59, Effect as Effect77, Layer as Layer64, Schema as Schema69 } from "effect";
+import { Context as Context59, Effect as Effect77, Layer as Layer64, Schema as Schema70 } from "effect";
 
-class WorkspaceRuntimeError extends Schema69.TaggedErrorClass()("WorkspaceRuntimeError", {
-  message: Schema69.String
+class WorkspaceRuntimeError extends Schema70.TaggedErrorClass()("WorkspaceRuntimeError", {
+  message: Schema70.String
 }) {
 }
 
@@ -13549,18 +13698,18 @@ var exec = Effect77.fn("WorkspaceRuntime.exec.call")(function* (input) {
 });
 
 // ../runtime/src/workspace/workspace-planner-service.ts
-class WorkspaceRuntimeMissing extends Schema70.TaggedErrorClass()("WorkspaceRuntimeMissing", {
+class WorkspaceRuntimeMissing extends Schema71.TaggedErrorClass()("WorkspaceRuntimeMissing", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspaceLeaseMissingRef extends Schema70.TaggedErrorClass()("WorkspaceLeaseMissingRef", {
+class WorkspaceLeaseMissingRef extends Schema71.TaggedErrorClass()("WorkspaceLeaseMissingRef", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class WorkspacePlannerError extends Schema70.TaggedErrorClass()("WorkspacePlannerError", {
-  message: Schema70.String
+class WorkspacePlannerError extends Schema71.TaggedErrorClass()("WorkspacePlannerError", {
+  message: Schema71.String
 }) {
 }
 
@@ -13746,7 +13895,7 @@ var fail = Effect78.fn("WorkspacePlanner.fail.call")(function* (input) {
 });
 
 // ../runtime/src/workflow/execution-workflow-state.ts
-import { Option as Option19, Schema as Schema71 } from "effect";
+import { Option as Option19, Schema as Schema72 } from "effect";
 var toWaitSnapshot = (record2) => ({
   id: record2.id,
   execution_id: record2.executionId,
@@ -13814,7 +13963,7 @@ var waitIdFromExecution = (execution) => {
 };
 var pendingSuspensionFromExecution = (execution) => {
   const pending = execution.metadata?.pending_agent_suspension;
-  return Schema71.decodeUnknownOption(exports_agent_event.AgentSuspended)(pending).pipe(Option19.getOrUndefined);
+  return Schema72.decodeUnknownOption(exports_agent_event.AgentSuspended)(pending).pipe(Option19.getOrUndefined);
 };
 var ExecutionWorkflowState = {
   agentDefinitionPinCount,
@@ -13855,74 +14004,74 @@ var {
   workflowGenerationFromRecord: workflowGenerationFromRecord2
 } = ExecutionWorkflowState;
 
-class ExecutionWorkflowFailed extends Schema72.TaggedErrorClass()("ExecutionWorkflowFailed", {
-  message: Schema72.String,
-  terminal_failure: Schema72.optionalKey(AgentTerminalFailure)
+class ExecutionWorkflowFailed extends Schema73.TaggedErrorClass()("ExecutionWorkflowFailed", {
+  message: Schema73.String,
+  terminal_failure: Schema73.optionalKey(AgentTerminalFailure)
 }) {
 }
 
-class AgentCheckpointCompatibilityError extends Schema72.TaggedErrorClass()("AgentCheckpointCompatibilityError", {
-  message: Schema72.String
+class AgentCheckpointCompatibilityError extends Schema73.TaggedErrorClass()("AgentCheckpointCompatibilityError", {
+  message: Schema73.String
 }) {
 }
-var ExecutionWorkflowError = Schema72.Union([ExecutionWorkflowFailed, AgentCheckpointCompatibilityError]);
-var StartInput = Schema72.Struct({
+var ExecutionWorkflowError = Schema73.Union([ExecutionWorkflowFailed, AgentCheckpointCompatibilityError]);
+var StartInput = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   root_address_id: exports_ids_schema.AddressId,
-  session_id: Schema72.optionalKey(exports_ids_schema.SessionId),
-  input: Schema72.optionalKey(Schema72.Array(exports_content_schema.Part)),
+  session_id: Schema73.optionalKey(exports_ids_schema.SessionId),
+  input: Schema73.optionalKey(Schema73.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: Schema72.optionalKey(exports_ids_schema.AgentId),
-  agent_revision: Schema72.optionalKey(exports_agent_schema.DefinitionRevision),
-  agent_snapshot: Schema72.optionalKey(exports_agent_schema.Definition),
-  agent_tool_input_schema_digests: Schema72.optionalKey(exports_agent_schema.ToolInputSchemaDigests),
-  wait_id: Schema72.optionalKey(exports_ids_schema.WaitId),
-  resume_suspension: Schema72.optionalKey(exports_agent_event.AgentSuspended),
-  workflow_generation: Schema72.optionalKey(Schema72.Int.check(Schema72.isGreaterThanOrEqualTo(0))),
-  metadata: Schema72.optionalKey(exports_shared_schema.Metadata)
+  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)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.StartInput" });
-var WaitSignalState = Schema72.Literals(["resolved", "timed_out", "cancelled"]).annotate({
+var WaitSignalState = Schema73.Literals(["resolved", "timed_out", "cancelled"]).annotate({
   identifier: "Relay.ExecutionWorkflow.WaitSignalState"
 });
-var WaitSignal = Schema72.Struct({
+var WaitSignal = Schema73.Struct({
   wait_id: exports_ids_schema.WaitId,
   state: WaitSignalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.ExecutionWorkflow.WaitSignal" });
-var SignalWaitInput = Schema72.Struct({
-  workflow_execution_id: Schema72.String,
+var SignalWaitInput = Schema73.Struct({
+  workflow_execution_id: Schema73.String,
   wait_id: exports_ids_schema.WaitId,
   state: WaitSignalState,
   signaled_at: exports_shared_schema.TimestampMillis
 }).annotate({ identifier: "Relay.ExecutionWorkflow.SignalWaitInput" });
-var CancelExecutionInput = Schema72.Struct({
+var CancelExecutionInput = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   cancelled_at: exports_shared_schema.TimestampMillis,
-  reason: Schema72.optionalKey(Schema72.String)
+  reason: Schema73.optionalKey(Schema73.String)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.CancelExecutionInput" });
-var CancelExecutionResult = Schema72.Struct({
+var CancelExecutionResult = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus
 }).annotate({ identifier: "Relay.ExecutionWorkflow.CancelExecutionResult" });
-var WaitSnapshot = Schema72.Struct({
+var WaitSnapshot = Schema73.Struct({
   id: exports_ids_schema.WaitId,
   execution_id: exports_ids_schema.ExecutionId,
-  envelope_id: Schema72.optionalKey(exports_ids_schema.EnvelopeId),
+  envelope_id: Schema73.optionalKey(exports_ids_schema.EnvelopeId),
   mode: exports_envelope_schema.WaitMode,
-  correlation_key: Schema72.optionalKey(Schema72.String),
-  state: Schema72.Literals(["open", "resolved", "timed_out", "cancelled"]),
+  correlation_key: Schema73.optionalKey(Schema73.String),
+  state: Schema73.Literals(["open", "resolved", "timed_out", "cancelled"]),
   metadata: exports_shared_schema.Metadata,
   created_at: exports_shared_schema.TimestampMillis,
-  resolved_at: Schema72.optionalKey(exports_shared_schema.TimestampMillis)
+  resolved_at: Schema73.optionalKey(exports_shared_schema.TimestampMillis)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.WaitSnapshot" });
-var StartResult = Schema72.Struct({
+var StartResult = Schema73.Struct({
   execution_id: exports_ids_schema.ExecutionId,
   status: exports_execution_schema.ExecutionStatus,
-  wait_id: Schema72.optionalKey(exports_ids_schema.WaitId),
-  wait_state: Schema72.optionalKey(Schema72.Literals(["resolved", "timed_out", "cancelled"])),
-  metadata: Schema72.optionalKey(exports_shared_schema.Metadata)
+  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)
 }).annotate({ identifier: "Relay.ExecutionWorkflow.StartResult" });
 var StartExecutionWorkflowName = "Relay/Execution/Start";
 var ActivityNames = {
@@ -13970,12 +14119,12 @@ var StartExecutionWorkflow = Workflow2.make(StartExecutionWorkflowName, {
 var mapExecutionError = (error5) => {
   if (error5.details === undefined)
     return ExecutionWorkflowFailed.make({ message: error5.message });
-  const terminalFailure = Schema72.decodeUnknownOption(AgentTerminalFailure)(error5.details).pipe(Option20.getOrUndefined);
+  const terminalFailure = Schema73.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(Schema72.encodeSync(AgentTerminalFailure), Schema72.decodeUnknownSync(exports_shared_schema.JsonValue)),
+  details: error5.pipe(Schema73.encodeSync(AgentTerminalFailure), Schema73.decodeUnknownSync(exports_shared_schema.JsonValue)),
   ...error5.next_event_sequence === undefined ? {} : { next_event_sequence: error5.next_event_sequence }
 });
 var mapWaitError2 = (error5) => ExecutionWorkflowFailed.make({
@@ -14124,7 +14273,7 @@ var prepareCancellation = Effect79.fn("ExecutionWorkflow.prepareCancellation")(f
       signals,
       terminalNoop: false
     };
-  })).pipe(Effect79.mapError((error5) => Schema72.is(ExecutionWorkflowFailed)(error5) ? error5 : ExecutionWorkflowFailed.make({ message: "Tool cancellation transaction failed" })));
+  })).pipe(Effect79.mapError((error5) => Schema73.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) {
@@ -14149,23 +14298,39 @@ var cancelChildExecution = Effect79.fn("ExecutionWorkflow.cancelChildExecution")
     reason: childCancelReason
   });
   yield* signalPreparedCancellation(prepared, cancelledAt);
+  const activeExecutions = yield* Effect79.serviceOption(Service57);
+  if (Option20.isSome(activeExecutions)) {
+    yield* activeExecutions.value.interrupt(executionId);
+    yield* activeExecutions.value.awaitQuiescent(executionId);
+  }
 });
 var cancelOpenChildren = Effect79.fn("ExecutionWorkflow.cancelOpenChildren")(function* (executionId, cancelledAt) {
-  const children = yield* exports_child_execution_repository.listByExecution(executionId).pipe(Effect79.mapError(mapChildExecutionRepositoryError));
-  yield* Effect79.forEach(children.filter((child) => openChildStatuses.has(child.status)), (child) => Effect79.gen(function* () {
-    yield* exports_child_execution_repository.updateStatus({
-      id: child.id,
-      status: "cancelled",
-      updatedAt: cancelledAt,
-      metadata: {
-        ...child.metadata,
-        cancellation_requested: true,
-        cancellation_reason: childCancelReason,
-        cancellation_requested_at: cancelledAt
-      }
-    }).pipe(Effect79.mapError(mapChildExecutionRepositoryError));
-    yield* cancelChildExecution(exports_ids_schema.ExecutionId.make(child.id), cancelledAt);
-  }), { discard: true });
+  const pending = [executionId];
+  const seen = new Set([executionId]);
+  while (pending.length > 0) {
+    const current2 = pending.shift();
+    const children = yield* exports_child_execution_repository.listByExecution(current2).pipe(Effect79.mapError(mapChildExecutionRepositoryError));
+    yield* Effect79.forEach(children.filter((child) => openChildStatuses.has(child.status)), (child) => Effect79.gen(function* () {
+      yield* exports_child_execution_repository.updateStatus({
+        id: child.id,
+        status: "cancelled",
+        updatedAt: cancelledAt,
+        metadata: {
+          ...child.metadata,
+          cancellation_requested: true,
+          cancellation_reason: childCancelReason,
+          cancellation_requested_at: cancelledAt
+        }
+      }).pipe(Effect79.mapError(mapChildExecutionRepositoryError));
+      yield* cancelChildExecution(exports_ids_schema.ExecutionId.make(child.id), cancelledAt);
+    }), { discard: true });
+    for (const child of children) {
+      if (seen.has(child.id))
+        continue;
+      seen.add(child.id);
+      pending.push(exports_ids_schema.ExecutionId.make(child.id));
+    }
+  }
 });
 var cancelExecution = (input, turn, reason) => Activity.make({
   name: ActivityNames.cancel(turn),
@@ -14185,7 +14350,7 @@ var cancelExecution = (input, turn, reason) => Activity.make({
 });
 var loadCancellationRequested = (input, turn) => Activity.make({
   name: ActivityNames.checkCancel(turn),
-  success: Schema72.Boolean,
+  success: Schema73.Boolean,
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     const repository = yield* exports_execution_repository.Service;
@@ -14195,7 +14360,7 @@ var loadCancellationRequested = (input, turn) => Activity.make({
 });
 var loadWait = (name, waitId2) => Activity.make({
   name,
-  success: Schema72.UndefinedOr(WaitSnapshot),
+  success: Schema73.UndefinedOr(WaitSnapshot),
   error: ExecutionWorkflowFailed,
   execute: get11(waitId2).pipe(Effect79.map((record2) => record2 === undefined ? undefined : toWaitSnapshot2(record2)), Effect79.mapError(mapWaitError2))
 });
@@ -14238,7 +14403,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" ? Schema72.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" ? 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 memorySubjectForStart = Effect79.fn("ExecutionWorkflow.memorySubjectForStart")(function* (input) {
   const executionSubject = memorySubjectFromMetadata2(input.metadata);
   if (executionSubject !== undefined)
@@ -14249,7 +14414,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: Schema72.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema73.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     if (input.agent_snapshot === undefined)
@@ -14266,19 +14431,19 @@ var ensureWorkspace = (input) => Activity.make({
 });
 var suspendWorkspace = (input, key4) => Activity.make({
   name: ActivityNames.suspendWorkspace(key4),
-  success: Schema72.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema73.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: Schema72.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema73.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: Schema72.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
+  success: Schema73.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
   execute: release2({ executionId: input.execution_id, now: input.completed_at }).pipe(Effect79.mapError(mapWorkspaceError))
 });
@@ -14354,7 +14519,7 @@ var completeExecution = (input, waitId2, waitState, workspaceRuntimeLayer, turn,
         ...input.metadata,
         wait_id: wait.wait_id,
         wait_state: "open",
-        pending_agent_suspension: wait.suspension.pipe(Schema72.encodeSync(exports_agent_event.AgentSuspended), Schema72.decodeUnknownSync(exports_shared_schema.JsonValue)),
+        pending_agent_suspension: wait.suspension.pipe(Schema73.encodeSync(exports_agent_event.AgentSuspended), Schema73.decodeUnknownSync(exports_shared_schema.JsonValue)),
         ...generationMetadata2(workflowGenerationForStart2(input))
       },
       nextEventSequence: wait.next_event_sequence
@@ -14370,12 +14535,12 @@ var completeExecution = (input, waitId2, waitState, workspaceRuntimeLayer, turn,
 });
 var failIncompatibleCheckpoint = (input, error5) => Activity.make({
   name: ActivityNames.failIncompatibleCheckpoint,
-  success: Schema72.Void,
+  success: Schema73.Void,
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     const eventLog = yield* Service41;
     const eventSequence = yield* nextEventSequence4(eventLog, input.execution_id);
-    const details = yield* error5.pipe(Schema72.encodeEffect(AgentCheckpointCompatibilityError), Effect79.flatMap(Schema72.decodeUnknownEffect(exports_shared_schema.JsonValue)), Effect79.mapError(() => ExecutionWorkflowFailed.make({ message: "Invalid checkpoint failure details" })));
+    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" })));
     yield* run4({
       executionId: input.execution_id,
       eventSequence,
@@ -14390,7 +14555,7 @@ var failIncompatibleCheckpoint = (input, error5) => Activity.make({
 });
 var loadChildCancellationRequested = (input) => Activity.make({
   name: ActivityNames.checkQueuedChildCancellation,
-  success: Schema72.Boolean,
+  success: Schema73.Boolean,
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     const context = childDispatchContext2(input);
@@ -14402,7 +14567,7 @@ var loadChildCancellationRequested = (input) => Activity.make({
 });
 var notifyParentActivity = (input, context, status, output) => Activity.make({
   name: ActivityNames.notifyParent(status),
-  success: Schema72.Void,
+  success: Schema73.Void,
   error: ExecutionWorkflowFailed,
   execute: Effect79.gen(function* () {
     const notifier = yield* Effect79.serviceOption(Service54);
@@ -14632,6 +14797,10 @@ var cancelRequest = Effect79.fn("ExecutionWorkflow.cancelRequest")(function* (in
     return { execution_id: prepared.record.id, status: prepared.status };
   }
   yield* signalPreparedCancellation(prepared, input.cancelled_at);
+  if (Option20.isSome(activeExecutions)) {
+    yield* activeExecutions.value.interrupt(prepared.record.id);
+    yield* activeExecutions.value.awaitQuiescent(prepared.record.id);
+  }
   yield* cancelOpenChildren(prepared.record.id, input.cancelled_at);
   const eventLog = yield* Service41;
   const eventSequence = yield* nextEventSequence4(eventLog, prepared.record.id);
@@ -14642,8 +14811,6 @@ var cancelRequest = Effect79.fn("ExecutionWorkflow.cancelRequest")(function* (in
     ...input.reason === undefined ? {} : { reason: input.reason },
     metadata: prepared.record.metadata
   }).pipe(Effect79.mapError(mapExecutionError));
-  if (Option20.isSome(activeExecutions))
-    yield* activeExecutions.value.interrupt(prepared.record.id);
   return { execution_id: prepared.record.id, status: cancelled.status };
 });
 var workflowIdPlaceholderAddressId = exports_ids_schema.AddressId.make("address:workflow-id-placeholder");
@@ -14678,8 +14845,8 @@ var signalWait = Effect79.fn("ExecutionWorkflow.signalWait")(function* (input) {
 });
 
 // ../runtime/src/wait/wait-signal.ts
-class WaitSignalError extends Schema73.TaggedErrorClass()("WaitSignalError", {
-  message: Schema73.String
+class WaitSignalError extends Schema74.TaggedErrorClass()("WaitSignalError", {
+  message: Schema74.String
 }) {
 }
 var signalWorkflowWait = Effect80.fn("WaitSignal.signalWorkflowWait")(function* (input) {
@@ -14698,19 +14865,19 @@ var signalWorkflowWait = Effect80.fn("WaitSignal.signalWorkflowWait")(function*
 });
 
 // ../runtime/src/inbox/inbox-service.ts
-class InboxDeliveryError extends Schema74.TaggedErrorClass()("InboxDeliveryError", {
+class InboxDeliveryError extends Schema75.TaggedErrorClass()("InboxDeliveryError", {
   execution_id: exports_ids_schema.ExecutionId,
-  message: Schema74.String
+  message: Schema75.String
 }) {
 }
 
-class InboxReplyTokenInvalid extends Schema74.TaggedErrorClass()("InboxReplyTokenInvalid", {
-  reply_token: Schema74.String
+class InboxReplyTokenInvalid extends Schema75.TaggedErrorClass()("InboxReplyTokenInvalid", {
+  reply_token: Schema75.String
 }) {
 }
 
-class InboxServiceError extends Schema74.TaggedErrorClass()("InboxServiceError", {
-  message: Schema74.String
+class InboxServiceError extends Schema75.TaggedErrorClass()("InboxServiceError", {
+  message: Schema75.String
 }) {
 }
 
@@ -14818,9 +14985,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 Schema75 } from "effect";
-class TopicServiceError extends Schema75.TaggedErrorClass()("TopicServiceError", {
-  message: Schema75.String
+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
 }) {
 }
 
@@ -14896,17 +15063,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 Schema76 } from "effect";
+import { Effect as Effect83, Schema as Schema77 } from "effect";
 var toolName3 = "publish_to_topic";
 var permissionName3 = "relay.topic.publish";
-var ContentInput = Schema76.Union([Schema76.String, Schema76.Array(exports_content_schema.TextPart)]);
-var Input3 = Schema76.Struct({
-  topic: Schema76.String,
+var ContentInput = Schema77.Union([Schema77.String, Schema77.Array(exports_content_schema.TextPart)]);
+var Input3 = Schema77.Struct({
+  topic: Schema77.String,
   content: ContentInput
 }).annotate({ identifier: "Relay.PublishToTopicTool.Input" });
-var Output3 = Schema76.Struct({
-  envelope_id: Schema76.String,
-  subscriber_count: Schema76.Int
+var Output3 = Schema77.Struct({
+  envelope_id: Schema77.String,
+  subscriber_count: Schema77.Int
 }).annotate({ identifier: "Relay.PublishToTopicTool.Output" });
 var registeredTool3 = (config) => tool(toolName3, {
   description: "Publish a durable message to every subscriber of a topic.",
@@ -14928,23 +15095,23 @@ var registeredTool3 = (config) => tool(toolName3, {
 });
 
 // ../runtime/src/inbox/wait-for-messages-tool.ts
-import { Effect as Effect84, Schema as Schema77 } from "effect";
+import { Effect as Effect84, Schema as Schema78 } from "effect";
 var toolName4 = "wait_for_messages";
 var permissionName4 = "relay.inbox.wait";
-var Input4 = Schema77.Struct({ timeout: Schema77.optionalKey(Schema77.String) }).annotate({
+var Input4 = Schema78.Struct({ timeout: Schema78.optionalKey(Schema78.String) }).annotate({
   identifier: "Relay.WaitForMessagesTool.Input"
 });
-var MessageView = Schema77.Struct({
-  sequence: Schema77.Int,
-  from: Schema77.String,
-  content: Schema77.Array(exports_content_schema.TextPart),
-  reply_token: Schema77.optionalKey(Schema77.String),
-  correlation_key: Schema77.optionalKey(Schema77.String),
-  metadata: Schema77.optionalKey(exports_shared_schema.Metadata)
+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)
 }).annotate({ identifier: "Relay.WaitForMessagesTool.MessageView" });
-var Output4 = Schema77.Struct({
-  status: Schema77.Literals(["messages", "timed_out"]),
-  messages: Schema77.Array(MessageView)
+var Output4 = Schema78.Struct({
+  status: Schema78.Literals(["messages", "timed_out"]),
+  messages: Schema78.Array(MessageView)
 }).annotate({ identifier: "Relay.WaitForMessagesTool.Output" });
 var project = (message) => ({
   sequence: message.sequence,
@@ -15001,18 +15168,18 @@ var registeredTool4 = (config) => tool(toolName4, {
 });
 
 // ../runtime/src/inbox/send-message-tool.ts
-import { Effect as Effect85, Schema as Schema78 } from "effect";
+import { Effect as Effect85, Schema as Schema79 } from "effect";
 var toolName5 = "send_message";
 var permissionName5 = "relay.inbox.send";
-var ContentInput2 = Schema78.Union([Schema78.String, Schema78.Array(exports_content_schema.TextPart)]);
-var Input5 = Schema78.Struct({
-  to: Schema78.String,
+var ContentInput2 = Schema79.Union([Schema79.String, Schema79.Array(exports_content_schema.TextPart)]);
+var Input5 = Schema79.Struct({
+  to: Schema79.String,
   content: ContentInput2,
-  reply_token: Schema78.optionalKey(Schema78.String)
+  reply_token: Schema79.optionalKey(Schema79.String)
 }).annotate({ identifier: "Relay.SendMessageTool.Input" });
-var Output5 = Schema78.Struct({
-  envelope_id: Schema78.String,
-  delivered: Schema78.Literals(["inbox", "outbox", "reply"])
+var Output5 = Schema79.Struct({
+  envelope_id: Schema79.String,
+  delivered: Schema79.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.",
@@ -15050,26 +15217,26 @@ var registeredTool5 = (config) => tool(toolName5, {
 });
 
 // ../runtime/src/envelope/envelope-service.ts
-import { Context as Context63, Effect as Effect86, Layer as Layer69, Schema as Schema79 } from "effect";
-class EnvelopeAddressNotFound extends Schema79.TaggedErrorClass()("EnvelopeAddressNotFound", {
+import { Context as Context63, Effect as Effect86, Layer as Layer69, Schema as Schema80 } from "effect";
+class EnvelopeAddressNotFound extends Schema80.TaggedErrorClass()("EnvelopeAddressNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
 }
 
-class EnvelopeRouteUnavailable extends Schema79.TaggedErrorClass()("EnvelopeRouteUnavailable", {
+class EnvelopeRouteUnavailable extends Schema80.TaggedErrorClass()("EnvelopeRouteUnavailable", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema79.String
+  route_key: Schema80.String
 }) {
 }
 
-class EnvelopeRouteDeferred extends Schema79.TaggedErrorClass()("EnvelopeRouteDeferred", {
+class EnvelopeRouteDeferred extends Schema80.TaggedErrorClass()("EnvelopeRouteDeferred", {
   address_id: exports_ids_schema.AddressId,
-  route_key: Schema79.String
+  route_key: Schema80.String
 }) {
 }
 
-class EnvelopeServiceError extends Schema79.TaggedErrorClass()("EnvelopeServiceError", {
-  message: Schema79.String
+class EnvelopeServiceError extends Schema80.TaggedErrorClass()("EnvelopeServiceError", {
+  message: Schema80.String
 }) {
 }
 
@@ -15250,7 +15417,7 @@ var send2 = Effect86.fn("EnvelopeService.send.call")(function* (input) {
 });
 
 // ../runtime/src/agent/relay-approvals.ts
-var layer53 = exports_approvals.autoApprove;
+var layer53 = exports_approvals.layerAutoApprove;
 
 // ../runtime/src/agent/relay-compaction.ts
 import { Clock as Clock14, Effect as Effect87, Layer as Layer70 } from "effect";
@@ -15301,11 +15468,11 @@ 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 Schema80 } from "effect";
-var jsonValue3 = (value) => Schema80.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
+import { Clock as Clock15, Effect as Effect88, Layer as Layer71, Option as Option21, Schema as Schema81 } from "effect";
+var permissionTokenPrefix = "wait:permission:";
+var jsonValue3 = (value) => Schema81.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
 var waitIdForToolCall = (executionId, toolCallId) => Identifiers.waitId("permission", executionId, toolCallId);
-var fallbackToolCallId = (request) => `${request.agentName}:${request.turn}:${request.tool}`;
-var tokenFor = (executionId, request) => waitIdForToolCall(executionId, request.toolCallId ?? fallbackToolCallId(request));
+var tokenFor = (executionId, request) => waitIdForToolCall(executionId, request.call.id);
 var matchingRule = (rules, tool3, params) => {
   let matched;
   for (const rule of rules) {
@@ -15315,7 +15482,7 @@ var matchingRule = (rules, tool3, params) => {
   return matched;
 };
 var staticDecision = (executionId, ruleset, request) => {
-  const rule = matchingRule(ruleset.rules, request.tool, request.params);
+  const rule = matchingRule(ruleset.rules, request.call.name, request.call.params);
   const level = rule?.level ?? ruleset.fallback ?? "ask";
   switch (level) {
     case "allow":
@@ -15329,25 +15496,8 @@ var staticDecision = (executionId, ruleset, request) => {
       return { _tag: "Ask", token: tokenFor(executionId, request) };
   }
 };
-var evaluateDecision = Effect88.fn("RelayPermissions.evaluateDecision")(function* (config, request) {
-  const remembered = yield* config.repository.list({ agent: config.agentName, scope: config.scope }).pipe(Effect88.mapError((error5) => permissionError(error5.message)));
-  const rule = matchingRule(remembered.map((record2) => record2.rule), request.tool, request.params);
-  if (rule !== undefined) {
-    switch (rule.level) {
-      case "allow":
-        return { _tag: "Allow" };
-      case "deny":
-        return {
-          _tag: "Deny",
-          ...rule.reason === undefined ? {} : { reason: rule.reason }
-        };
-      case "ask":
-        return { _tag: "Ask", token: tokenFor(config.executionId, request) };
-    }
-  }
-  return staticDecision(config.executionId, config.ruleset, request);
-});
 var permissionError = (message) => exports_permissions.PermissionError.make({ message });
+var rememberedRules = (config) => config.repository.list({ agent: config.agentName, scope: config.scope }).pipe(Effect88.mapError((error5) => permissionError(error5.message)), Effect88.map((records) => records.map((record2) => record2.rule)));
 var createdAtForSequence = (config, sequence) => config.startedAt + sequence - config.eventSequence;
 var nextLoggedSequence = (eventLog, executionId, fallback) => eventLog.maxSequence(executionId).pipe(Effect88.mapError((error5) => permissionError(error5.message)), Effect88.map((max) => max === undefined ? fallback : Math.max(max + 1, fallback)));
 var allocateEventSequence = Effect88.fn("RelayPermissions.allocateEventSequence")(function* (config) {
@@ -15357,19 +15507,19 @@ var allocateEventSequence = Effect88.fn("RelayPermissions.allocateEventSequence"
   return sequence;
 });
 var resetAllocatorToLog = (config) => config.allocator.current.pipe(Effect88.flatMap((current2) => nextLoggedSequence(config.eventLog, config.executionId, current2)), Effect88.flatMap(config.allocator.resetTo));
-var permissionRequestedCursor = (config, pending, waitId2) => `${config.executionId}:permission:${pending.toolCallId ?? waitId2}:requested`;
-var permissionResolvedCursor = (config, pending, wait) => `${config.executionId}:permission:${pending.toolCallId ?? wait.id}:resolved`;
+var permissionRequestedCursor = (config, pending) => `${config.executionId}:permission:${pending.call.id}:requested`;
+var permissionResolvedCursor = (config, pending) => `${config.executionId}:permission:${pending.call.id}:resolved`;
 var permissionRequestedEvent = (config, pending, waitId2, sequence) => ({
-  id: Identifiers.eventId(config.executionId, pending.toolCallId ?? waitId2, "permission-requested"),
+  id: Identifiers.eventId(config.executionId, pending.call.id, "permission-requested"),
   execution_id: config.executionId,
   type: "permission.ask.requested",
   sequence,
-  cursor: permissionRequestedCursor(config, pending, waitId2),
+  cursor: permissionRequestedCursor(config, pending),
   data: {
-    tool_call_id: pending.toolCallId ?? pending.token,
-    tool_name: pending.tool,
+    tool_call_id: pending.call.id,
+    tool_name: pending.call.name,
     wait_id: waitId2,
-    input: jsonValue3(pending.params),
+    input: jsonValue3(pending.call.params),
     agent_name: pending.agentName,
     scope: config.scope
   },
@@ -15394,15 +15544,28 @@ var answerForWait = (wait) => {
     return { _tag: "Denied", reason: "Permission ask cancelled" };
   return { _tag: "Denied", reason: "Permission denied" };
 };
+var resolutionForAnswer = (pending, answer) => {
+  switch (answer._tag) {
+    case "Approved":
+      return { _tag: "Approved" };
+    case "Always":
+      return { _tag: "Approved", remember: { pattern: pending.call.name, level: "allow" } };
+    case "Denied":
+      return {
+        _tag: "Denied",
+        ...answer.reason === undefined ? {} : { reason: answer.reason }
+      };
+  }
+};
 var permissionResolvedEvent = (config, pending, wait, answer, sequence) => ({
-  id: Identifiers.eventId(config.executionId, pending.toolCallId ?? wait.id, "permission-resolved"),
+  id: Identifiers.eventId(config.executionId, pending.call.id, "permission-resolved"),
   execution_id: config.executionId,
   type: "permission.ask.resolved",
   sequence,
-  cursor: permissionResolvedCursor(config, pending, wait),
+  cursor: permissionResolvedCursor(config, pending),
   data: {
-    tool_call_id: pending.toolCallId ?? "",
-    tool_name: pending.tool,
+    tool_call_id: pending.call.id,
+    tool_name: pending.call.name,
     wait_id: wait.id,
     answer: answer._tag,
     state: wait.state
@@ -15416,7 +15579,7 @@ var appendPermissionEvent = (config, event) => appendIdempotentTo(config.eventLo
   onSome: (prior) => samePermissionEvent(prior, event) ? Effect88.succeed(prior) : Effect88.fail(permissionError(error5.message))
 })))), Effect88.mapError((error5) => permissionError(error5.message)), Effect88.tap(() => resetAllocatorToLog(config)));
 var ensurePermissionRequestedEvent = Effect88.fn("RelayPermissions.ensurePermissionRequestedEvent")(function* (config, pending, waitId2) {
-  const cursor = permissionRequestedCursor(config, pending, waitId2);
+  const cursor = permissionRequestedCursor(config, pending);
   const existing = yield* findEventByCursor(config, cursor);
   if (Option21.isSome(existing))
     return;
@@ -15430,12 +15593,12 @@ var createAsk = Effect88.fn("RelayPermissions.createAsk")(function* (config, pen
     waitId: waitId2,
     executionId: config.executionId,
     mode: "event",
-    correlationKey: pending.toolCallId ?? pending.token,
+    correlationKey: pending.call.id,
     metadata: {
       kind: "tool-permission",
-      tool_call_id: pending.toolCallId ?? pending.token,
-      tool_name: pending.tool,
-      input: jsonValue3(pending.params),
+      tool_call_id: pending.call.id,
+      tool_name: pending.call.name,
+      input: jsonValue3(pending.call.params),
       agent_name: pending.agentName,
       scope: config.scope
     },
@@ -15449,26 +15612,27 @@ var awaitAnswer = Effect88.fn("RelayPermissions.awaitAnswer")(function* (config,
   const existing = yield* config.waits.get(waitId2).pipe(Effect88.mapError((error5) => permissionError(error5.message)));
   if (existing === undefined) {
     yield* createAsk(config, pending);
-    return Option21.none();
+    return pending;
   }
   if (existing.state === "open") {
     yield* ensurePermissionRequestedEvent(config, pending, waitId2);
-    return Option21.none();
+    return pending;
   }
   const answer = answerForWait(existing);
-  const resolvedCursor = permissionResolvedCursor(config, pending, existing);
+  const resolvedCursor = permissionResolvedCursor(config, pending);
   const resolved = yield* findEventByCursor(config, resolvedCursor);
   if (Option21.isSome(resolved)) {
     yield* resetAllocatorToLog(config);
-    return Option21.some(answer);
+    return resolutionForAnswer(pending, answer);
   }
   const resolvedSequence = yield* allocateEventSequence(config);
   yield* appendPermissionEvent(config, permissionResolvedEvent(config, pending, existing, answer, resolvedSequence));
-  return Option21.some(answer);
+  return resolutionForAnswer(pending, answer);
 });
+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* Schema80.decodeUnknownEffect(exports_agent_schema.PermissionRule)(rule).pipe(Effect88.mapError((error5) => permissionError(error5.message)));
+  const decodedRule = yield* Schema81.decodeUnknownEffect(exports_agent_schema.PermissionRule)(rule).pipe(Effect88.mapError((error5) => permissionError(error5.message)));
   yield* config.repository.remember({
     agent: config.agentName,
     scope: config.scope,
@@ -15477,16 +15641,18 @@ var rememberRule = Effect88.fn("RelayPermissions.rememberRule")(function* (confi
   }).pipe(Effect88.mapError((error5) => permissionError(error5.message)));
 });
 var layer54 = (config) => Layer71.mergeAll(Layer71.succeed(exports_permissions.Permissions, exports_permissions.Permissions.of({
-  evaluate: (request) => evaluateDecision(config, request),
-  await: (pending) => awaitAnswer(config, pending)
+  evaluate: (request) => Effect88.succeed(staticDecision(config.executionId, config.ruleset, request))
 })), Layer71.succeed(exports_permissions.RuleStore, exports_permissions.RuleStore.of({
-  remember: (rule) => rememberRule(config, rule)
+  remember: (rule) => rememberRule(config, rule),
+  rules: rememberedRules(config)
+})), Layer71.succeed(exports_approvals.Approvals, exports_approvals.Approvals.of({
+  resolve: (pending) => resolve8(config, pending)
 })));
 
 // ../runtime/src/agent/relay-steering.ts
-import { Clock as Clock16, Effect as Effect89, Layer as Layer72, Schema as Schema81 } from "effect";
+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) => Schema81.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue4 = (value) => Schema82.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}`;
@@ -15519,12 +15685,12 @@ var contentFromMessage = (message) => {
   const textParts = promptTextParts(prompt);
   if (textParts.length > 0)
     return textParts;
-  return [exports_content_schema.text(prompt.pipe(Schema81.encodeSync(Prompt5.Prompt), stringifyJson2))];
+  return [exports_content_schema.text(prompt.pipe(Schema82.encodeSync(Prompt5.Prompt), stringifyJson2))];
 };
-var steeringReceivedEvent = (config, kind, drain2, messages, sequence) => ({
-  id: exports_ids_schema.EventId.make(`event:${drain2.drainId}:received`),
+var steeringDeliveredEvent = (config, kind, drain2, messages, sequence) => ({
+  id: exports_ids_schema.EventId.make(`event:${drain2.drainId}:delivered`),
   execution_id: config.executionId,
-  type: "steering.received",
+  type: "steering.delivered",
   sequence,
   cursor: `${config.executionId}:steering:${kind}:${drain2.drainId}`,
   content: messages.flatMap((message) => message.content),
@@ -15547,7 +15713,7 @@ var drain2 = Effect89.fn("RelaySteering.drain")(function* (config, kind, mode) {
     consumedAt: createdAt,
     createdAt
   });
-  yield* appendIdempotentTo(config.eventLog, steeringReceivedEvent(config, kind, result.drain, result.messages, sequence));
+  yield* appendIdempotentTo(config.eventLog, steeringDeliveredEvent(config, kind, result.drain, result.messages, sequence));
   return result.messages.map((message) => ({ prompt: promptForContent(message.content) }));
 });
 var append4 = (config, kind, message) => Clock16.currentTimeMillis.pipe(Effect89.flatMap((createdAt) => config.repository.append({
@@ -15564,8 +15730,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 Schema82 } from "effect";
-var jsonValue5 = (value) => Schema82.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+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);
 var errorDetail = (error5) => {
   switch (error5._tag) {
     case "ToolNotRegistered":
@@ -15881,7 +16047,7 @@ var {
   usageReportedEvent: usageReportedEvent2
 } = AgentLoopEvents;
 
-class AgentLoopWaitRequested extends Schema83.TaggedErrorClass()("AgentLoopWaitRequested", {
+class AgentLoopWaitRequested extends Schema84.TaggedErrorClass()("AgentLoopWaitRequested", {
   wait_id: exports_ids_schema.WaitId,
   tool_call: exports_tool_schema.Call,
   suspension: exports_agent_event.AgentSuspended,
@@ -15891,7 +16057,7 @@ class AgentLoopWaitRequested extends Schema83.TaggedErrorClass()("AgentLoopWaitR
 
 class Service61 extends Context64.Service()("@relayfx/runtime/agent/agent-loop-service/Service") {
 }
-var jsonValue6 = (value) => Schema83.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
+var jsonValue6 = (value) => Schema84.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var toolNames = (agent) => HashSet7.fromIterable(agent.tool_names);
 var turnPolicyFromSnapshot = (snapshot2) => {
   switch (snapshot2.kind) {
@@ -15983,7 +16149,7 @@ var runStructuredTurn = Effect93.fn("AgentLoop.runStructuredTurn")(function* (la
     prompt: STRUCTURED_TURN_PROMPT,
     schema: registration.schema,
     objectName: "output"
-  })).pipe(Effect93.mapError((error5) => Schema83.is(AgentLoopError)(error5) ? error5 : loopError(error5, sequence)));
+  })).pipe(Effect93.mapError((error5) => Schema84.is(AgentLoopError)(error5) ? error5 : loopError(error5, sequence)));
   return jsonValue6(response.value);
 });
 var loopError = (error5, nextEventSequence5) => AgentLoopError.make({
@@ -16017,8 +16183,8 @@ var appendCompactionCommittedEvent = Effect93.fn("AgentLoop.appendCompactionComm
 });
 var toolFromDefinition = (definition) => AiTool2.dynamic(definition.name, {
   description: definition.description,
-  parameters: Schema83.make(exports_tool_schema.parametersSchema(definition.input_schema).ast),
-  success: Schema83.Unknown,
+  parameters: Schema84.make(exports_tool_schema.parametersSchema(definition.input_schema).ast),
+  success: Schema84.Unknown,
   ...definition.needs_approval === undefined ? {} : { needsApproval: definition.needs_approval }
 });
 var toolkitFromRegistered = (registered) => Toolkit2.make(...registered.map((tool3) => toolFromDefinition(tool3.definition)));
@@ -16048,7 +16214,7 @@ var restoreHistory = Effect93.fn("AgentLoop.restoreHistory")(function* (chats, i
   }
   return history;
 });
-var promptEquivalence = Schema83.toEquivalence(Prompt6.Prompt);
+var promptEquivalence = Schema84.toEquivalence(Prompt6.Prompt);
 var reconcileCompactionCheckpoint = Effect93.fn("AgentLoop.reconcileCompactionCheckpoint")(function* (sessions, chats, input, restoredHistory, onCheckpointCommitted, failOnMismatch = false) {
   if (input.sessionId === undefined)
     return restoredHistory;
@@ -16140,7 +16306,7 @@ var restoreContextEpoch = Effect93.fn("AgentLoop.restoreContextEpoch")(function*
   return { baseline: epoch.baseline, dynamicSourceIds: epoch.dynamicSourceIds };
 });
 var mapBatonRunError = (error5, current2) => {
-  if (Schema83.is(exports_agent_event.AgentSuspended)(error5)) {
+  if (Schema84.is(exports_agent_event.AgentSuspended)(error5)) {
     return AgentLoopWaitRequested.make({
       wait_id: exports_ids_schema.WaitId.make(error5.token),
       tool_call: {
@@ -16153,29 +16319,29 @@ var mapBatonRunError = (error5, current2) => {
     });
   }
   let message;
-  if (Schema83.is(exports_agent_event.AgentError)(error5))
+  if (Schema84.is(exports_agent_event.AgentError)(error5))
     message = error5.message;
-  else if (Schema83.is(exports_agent_event.ResumeMismatch)(error5))
+  else if (Schema84.is(exports_agent_event.ResumeMismatch)(error5))
     message = `Resume mismatch: ${error5.reason}`;
-  else if (Schema83.is(exports_turn_policy.TurnPolicyError)(error5))
+  else if (Schema84.is(exports_turn_policy.TurnPolicyError)(error5))
     message = error5.message;
-  else if (Schema83.is(exports_agent_event.TurnPolicyStopped)(error5))
+  else if (Schema84.is(exports_agent_event.TurnPolicyStopped)(error5))
     message = `Turn policy stopped at turn ${error5.turn}`;
-  else if (Schema83.is(exports_agent_event.TurnLimitExceeded)(error5))
+  else if (Schema84.is(exports_agent_event.TurnLimitExceeded)(error5))
     message = "Tool call turn limit exceeded";
-  else if (Schema83.is(exports_agent_event.MiddlewareViolation)(error5))
+  else if (Schema84.is(exports_agent_event.MiddlewareViolation)(error5))
     message = `ModelMiddleware violation at turn ${error5.turn}: ${error5.detail}`;
-  else if (Schema83.is(exports_agent_event.DuplicateToolCallId)(error5))
+  else if (Schema84.is(exports_agent_event.DuplicateToolCallId)(error5))
     message = `Duplicate tool call id: ${error5.id}`;
-  else if (Schema83.is(exports_agent_event.ProgressOverflowError)(error5))
+  else if (Schema84.is(exports_agent_event.ProgressOverflow)(error5))
     message = `Tool progress overflow: ${error5.toolCallId}`;
-  else if (Schema83.is(exports_agent_event.ToolNameCollision)(error5))
+  else if (Schema84.is(exports_agent_event.ToolNameCollision)(error5))
     message = `Tool name collision: ${error5.name}`;
-  else if (Schema83.is(AiError3.AiError)(error5))
+  else if (Schema84.is(AiError3.AiError)(error5))
     message = error5.message;
-  else if (Schema83.is(exports_model_registry.LanguageModelNotRegistered)(error5))
+  else if (Schema84.is(exports_model_registry.LanguageModelNotRegistered)(error5))
     message = `Language model not registered: ${error5.provider}/${error5.model}`;
-  else if (Schema83.is(exports_tool_executor.FrameworkFailure)(error5))
+  else if (Schema84.is(exports_tool_executor.FrameworkFailure)(error5))
     message = error5.message;
   else {
     const exhaustive = error5;
@@ -16183,14 +16349,14 @@ var mapBatonRunError = (error5, current2) => {
   }
   return AgentLoopError.make({ message, baton_failure: error5, next_event_sequence: current2 });
 };
-var isBatonRunError = (error5) => Schema83.is(exports_agent_event.AgentSuspended)(error5) || Schema83.is(exports_agent_event.ResumeMismatch)(error5) || Schema83.is(exports_turn_policy.TurnPolicyError)(error5) || Schema83.is(exports_agent_event.TurnPolicyStopped)(error5) || Schema83.is(exports_agent_event.TurnLimitExceeded)(error5) || Schema83.is(exports_agent_event.MiddlewareViolation)(error5) || Schema83.is(exports_agent_event.DuplicateToolCallId)(error5) || Schema83.is(exports_agent_event.ProgressOverflowError)(error5) || Schema83.is(exports_agent_event.ToolNameCollision)(error5) || Schema83.is(exports_agent_event.AgentError)(error5) || Schema83.is(AiError3.AiError)(error5) || Schema83.is(exports_model_registry.LanguageModelNotRegistered)(error5) || Schema83.is(exports_tool_executor.FrameworkFailure)(error5);
+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 mapBoundaryError = (errorOrCurrent, current2, failureClassification) => {
   if (current2 === undefined) {
     const sequence = errorOrCurrent;
     return (error6) => mapBoundaryError(error6, sequence);
   }
   const error5 = errorOrCurrent;
-  if (Schema83.is(AgentLoopError)(error5) || Schema83.is(AgentLoopWaitRequested)(error5) || Schema83.is(AgentLoopBudgetExceeded)(error5))
+  if (Schema84.is(AgentLoopError)(error5) || Schema84.is(AgentLoopWaitRequested)(error5) || Schema84.is(AgentLoopBudgetExceeded)(error5))
     return error5;
   const mapped = isBatonRunError(error5) ? mapBatonRunError(error5, current2) : loopError(error5, current2);
   return mapped._tag === "AgentLoopError" && failureClassification === "context-overflow" ? AgentLoopError.make({
@@ -16336,6 +16502,7 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
         startedAt: input.startedAt,
         eventSequence: input.eventSequence
       });
+      const approvalsLayer = input.agent.permission_rules === undefined ? layer53 : Layer75.empty;
       const steeringLayer = input.steeringEnabled !== true ? Layer75.empty : Option24.isNone(steeringRepository) ? yield* AgentLoopError.make({
         message: "Execution steering requires SteeringRepository in context",
         next_event_sequence: input.eventSequence + 1
@@ -16351,6 +16518,8 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
       const memory = input.memorySubjectId === undefined ? undefined : { key: { agent: input.agent.name, subject: input.memorySubjectId } };
       const restoredEpoch = durableHistory !== undefined && Option24.isSome(contextEpochs) ? yield* restoreContextEpoch(contextEpochs.value, input) : undefined;
       const freshSessionHistory = durableHistory !== undefined || input.sessionId === undefined || Option24.isNone(sessionRepository) ? undefined : yield* sessionRepository.value.path({ sessionId: input.sessionId }).pipe(Effect93.mapError((error5) => loopError(error5, input.eventSequence + 1)), Effect93.map((path2) => path2.length === 0 ? undefined : exports_session.buildContext(path2)));
+      const sessionWriter = input.sessionId === undefined || Option24.isNone(sessionRepository) ? undefined : yield* sessionRepository.value.get(input.sessionId).pipe(Effect93.mapError((error5) => loopError(error5, input.eventSequence + 1)), Effect93.map((record2) => record2?.writer === undefined ? undefined : { executionId: input.executionId, epoch: record2.writer.epoch }));
+      const sessionOwnerToken = sessionWriter === undefined ? undefined : `${sessionWriter.executionId}#${sessionWriter.epoch}`;
       const { options, instructionsLayer } = durableHistory === undefined ? yield* assembler.assemble({ agent: input.agent, tools: definitions2, input: input.input }).pipe(Effect93.mapError((error5) => loopError(error5, input.eventSequence + 1)), Effect93.flatMap((assembled) => Effect93.gen(function* () {
         const epoch = { baseline: assembled.system, dynamicSourceIds: [] };
         if (Option24.isSome(contextEpochs))
@@ -16360,6 +16529,7 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
             prompt: assembled.prompt,
             ...freshSessionHistory === undefined ? {} : { history: freshSessionHistory },
             sessionId: input.sessionId ?? input.executionId,
+            ...sessionOwnerToken === undefined ? {} : { sessionOwnerToken },
             ...memory === undefined ? {} : { memory }
           },
           instructionsLayer: freshSessionHistory === undefined ? layerFromEpoch(epoch) : Layer75.empty
@@ -16370,7 +16540,8 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
           prompt: [],
           ...memory === undefined ? {} : { memory },
           ...resumeSuspension === undefined ? {} : { resume: { suspension: resumeSuspension } },
-          sessionId: input.sessionId ?? input.executionId
+          sessionId: input.sessionId ?? input.executionId,
+          ...sessionOwnerToken === undefined ? {} : { sessionOwnerToken }
         },
         instructionsLayer: restoredEpoch === undefined ? Layer75.empty : layerFromEpoch(restoredEpoch)
       };
@@ -16516,9 +16687,10 @@ var make12 = (layerOptions) => Effect93.gen(function* () {
       const runFold = Effect93.scoped(Effect93.gen(function* () {
         const base = withToolCallDecodeResilience(yield* LanguageModel.LanguageModel, definitions2.map((definition) => definition.name), toolCallDecodeMaxRetries, (classification) => Ref19.set(lastModelFailureClassification, classification));
         const sessionStore = input.sessionId !== undefined && Option24.isSome(sessionRepository) ? yield* make5(input.sessionId, input.sessionEntryScope ?? input.executionId, {
-          onCheckpointCommitted: (result) => onCheckpointCommitted(result).pipe(Effect93.orDie)
+          onCheckpointCommitted: (result) => onCheckpointCommitted(result).pipe(Effect93.orDie),
+          ...sessionWriter === undefined ? {} : { writer: sessionWriter }
         }).pipe(Effect93.provideService(exports_session_repository.Service, sessionRepository.value)) : undefined;
-        const foldContext = yield* Layer75.build(Layer75.mergeAll(executorLayer, handlerLayer, layer53, exports_model_middleware.identityLayer, instructionsLayer, permissionsLayer, steeringLayer));
+        const foldContext = yield* Layer75.build(Layer75.mergeAll(executorLayer, handlerLayer, approvalsLayer, exports_model_middleware.layerIdentity, instructionsLayer, permissionsLayer, steeringLayer));
         const folded = exports_agent.stream(agent, batonOptions).pipe(Stream13.runFoldEffect(() => ({
           text: "",
           transcript: undefined,
@@ -16570,7 +16742,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 Schema84 } from "effect";
+import { Schema as Schema85 } from "effect";
 var Start = Rpc.make("start", {
   payload: StartInput,
   success: StartResult,
@@ -16578,12 +16750,12 @@ var Start = Rpc.make("start", {
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var SignalWait = Rpc.make("signalWait", {
   payload: SignalWaitInput,
-  success: Schema84.Void,
+  success: Schema85.Void,
   error: ExecutionWorkflowFailed
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var Dispatch = Rpc.make("dispatch", {
   payload: StartInput,
-  success: Schema84.Void,
+  success: Schema85.Void,
   error: ExecutionWorkflowError
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var Cancel = Rpc.make("cancel", {
@@ -16606,10 +16778,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 Schema85, 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 Schema86, Stream as Stream14 } from "effect";
 
-class ExecutionWatchError extends Schema85.TaggedErrorClass()("ExecutionWatchError", {
-  message: Schema85.String
+class ExecutionWatchError extends Schema86.TaggedErrorClass()("ExecutionWatchError", {
+  message: Schema86.String
 }) {
 }
 
@@ -16657,20 +16829,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 Schema86 } from "effect";
-class ResidentKindNotFound extends Schema86.TaggedErrorClass()("ResidentKindNotFound", {
+import { Context as Context66, Effect as Effect95, Layer as Layer77, Schema as Schema87 } from "effect";
+class ResidentKindNotFound extends Schema87.TaggedErrorClass()("ResidentKindNotFound", {
   kind: exports_ids_schema.ResidentKindName
 }) {
 }
 
-class ResidentKindInvalid extends Schema86.TaggedErrorClass()("ResidentKindInvalid", {
+class ResidentKindInvalid extends Schema87.TaggedErrorClass()("ResidentKindInvalid", {
   kind: exports_ids_schema.ResidentKindName,
-  message: Schema86.String
+  message: Schema87.String
 }) {
 }
 
-class ResidentRegistryError extends Schema86.TaggedErrorClass()("ResidentRegistryError", {
-  message: Schema86.String
+class ResidentRegistryError extends Schema87.TaggedErrorClass()("ResidentRegistryError", {
+  message: Schema87.String
 }) {
 }
 
@@ -16702,21 +16874,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 Schema87 } from "effect";
-class ResidentDestroyed extends Schema87.TaggedErrorClass()("ResidentDestroyed", {
+import { Context as Context67, Effect as Effect96, Function as Function16, Layer as Layer78, Schema as Schema88 } from "effect";
+class ResidentDestroyed extends Schema88.TaggedErrorClass()("ResidentDestroyed", {
   kind: exports_ids_schema.ResidentKindName,
   key: exports_ids_schema.ResidentKey
 }) {
 }
 
-class ResidentNotFound2 extends Schema87.TaggedErrorClass()("ResidentNotFound", {
+class ResidentNotFound2 extends Schema88.TaggedErrorClass()("ResidentNotFound", {
   kind: exports_ids_schema.ResidentKindName,
   key: exports_ids_schema.ResidentKey
 }) {
 }
 
-class ResidentServiceError extends Schema87.TaggedErrorClass()("ResidentServiceError", {
-  message: Schema87.String
+class ResidentServiceError extends Schema88.TaggedErrorClass()("ResidentServiceError", {
+  message: Schema88.String
 }) {
 }
 
@@ -16819,9 +16991,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 Schema88, Stream as Stream15 } from "effect";
-class SessionStreamError extends Schema88.TaggedErrorClass()("SessionStreamError", {
-  message: Schema88.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 Schema89, Stream as Stream15 } from "effect";
+class SessionStreamError extends Schema89.TaggedErrorClass()("SessionStreamError", {
+  message: Schema89.String
 }) {
 }
 
@@ -16854,15 +17026,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 Schema89 } from "effect";
-class SchedulerError extends Schema89.TaggedErrorClass()("SchedulerError", {
-  message: Schema89.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 Schema90 } from "effect";
+class SchedulerError extends Schema90.TaggedErrorClass()("SchedulerError", {
+  message: Schema90.String
 }) {
 }
 
-class ScheduleCronInvalid extends Schema89.TaggedErrorClass()("ScheduleCronInvalid", {
-  cron_expr: Schema89.String,
-  message: Schema89.String
+class ScheduleCronInvalid extends Schema90.TaggedErrorClass()("ScheduleCronInvalid", {
+  cron_expr: Schema90.String,
+  message: Schema90.String
 }) {
 }
 
@@ -17017,25 +17189,25 @@ var runOnce2 = Effect98.fn("SchedulerService.runOnce.call")(function* () {
 });
 
 // ../runtime/src/runner/runner-runtime-service.ts
-var DatabaseMode = Schema90.Literals(["sql", "pg", "mysql", "sqlite", "memory"]).annotate({
+var DatabaseMode = Schema91.Literals(["sql", "pg", "mysql", "sqlite", "memory"]).annotate({
   identifier: "Relay.RunnerRuntime.DatabaseMode"
 });
-var ReadinessStatus = Schema90.Struct({
+var ReadinessStatus = Schema91.Struct({
   database: DatabaseMode,
-  cluster: Schema90.Literal("ready"),
-  workflow: Schema90.Literals(["ready", "client"]),
-  executionEntity: Schema90.Literals(["registered", "client"])
+  cluster: Schema91.Literal("ready"),
+  workflow: Schema91.Literals(["ready", "client"]),
+  executionEntity: Schema91.Literals(["registered", "client"])
 }).annotate({ identifier: "Relay.RunnerRuntime.ReadinessStatus" });
 
-class RunnerRuntimeError extends Schema90.TaggedErrorClass()("RunnerRuntimeError", {
-  message: Schema90.String
+class RunnerRuntimeError extends Schema91.TaggedErrorClass()("RunnerRuntimeError", {
+  message: Schema91.String
 }) {
 }
 
-class ClusterConfigMismatch extends Schema90.TaggedErrorClass()("ClusterConfigMismatch", {
-  field: Schema90.String,
-  expected: Schema90.String,
-  actual: Schema90.String
+class ClusterConfigMismatch extends Schema91.TaggedErrorClass()("ClusterConfigMismatch", {
+  field: Schema91.String,
+  expected: Schema91.String,
+  actual: Schema91.String
 }) {
 }
 
@@ -17049,7 +17221,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(Schema90.String), "RELAY_CLUSTER_SHARD_GROUPS").pipe(Config8.withDefault(["default", "execution"]));
+var clusterShardGroups = Config8.schema(Config8.Array(Schema91.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* () {
@@ -17380,24 +17552,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 Schema91 } 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 Schema92 } from "effect";
 import { dual as dual2 } from "effect/Function";
 
-class UnsupportedOperation extends Schema91.TaggedErrorClass()("UnsupportedWorkflowOperation", { operation_id: exports_ids_schema.WorkflowOperationId, kind: Schema91.String }) {
+class UnsupportedOperation extends Schema92.TaggedErrorClass()("UnsupportedWorkflowOperation", { operation_id: exports_ids_schema.WorkflowOperationId, kind: Schema92.String }) {
 }
 
-class PinnedDefinitionNotFound extends Schema91.TaggedErrorClass()("PinnedWorkflowDefinitionNotFound", { execution_id: exports_ids_schema.ExecutionId }) {
+class PinnedDefinitionNotFound extends Schema92.TaggedErrorClass()("PinnedWorkflowDefinitionNotFound", { execution_id: exports_ids_schema.ExecutionId }) {
 }
 
-class PinnedDefinitionMismatch extends Schema91.TaggedErrorClass()("PinnedWorkflowDefinitionMismatch", { execution_id: exports_ids_schema.ExecutionId }) {
+class PinnedDefinitionMismatch extends Schema92.TaggedErrorClass()("PinnedWorkflowDefinitionMismatch", { execution_id: exports_ids_schema.ExecutionId }) {
 }
 
-class WorkflowRuntimeError extends Schema91.TaggedErrorClass()("WorkflowRuntimeError", {
-  message: Schema91.String
+class WorkflowRuntimeError extends Schema92.TaggedErrorClass()("WorkflowRuntimeError", {
+  message: Schema92.String
 }) {
 }
 
-class WorkflowJoinPolicyNotSatisfied extends Schema91.TaggedErrorClass()("WorkflowJoinPolicyNotSatisfied", { policy: Schema91.String }) {
+class WorkflowJoinPolicyNotSatisfied extends Schema92.TaggedErrorClass()("WorkflowJoinPolicyNotSatisfied", { policy: Schema92.String }) {
 }
 var runtimeError2 = (error5) => WorkflowRuntimeError.make({ message: String(error5) });
 var mapRuntimeError2 = Effect100.mapError(runtimeError2);
@@ -17410,13 +17582,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 Schema91.TaggedErrorClass()("WorkflowCancelled", {}) {
+class WorkflowCancelled extends Schema92.TaggedErrorClass()("WorkflowCancelled", {}) {
 }
 
-class WorkflowBudgetExceeded extends Schema91.TaggedErrorClass()("WorkflowBudgetExceeded", { operation_id: exports_ids_schema.WorkflowOperationId }) {
+class WorkflowBudgetExceeded extends Schema92.TaggedErrorClass()("WorkflowBudgetExceeded", { operation_id: exports_ids_schema.WorkflowOperationId }) {
 }
 
-class WorkflowJoining extends Schema91.TaggedErrorClass()("WorkflowJoining", {
+class WorkflowJoining extends Schema92.TaggedErrorClass()("WorkflowJoining", {
   fan_out_id: exports_ids_schema.ChildFanOutId
 }) {
 }
@@ -17671,7 +17843,7 @@ var run6 = Effect100.fn("WorkflowDefinitionRuntime.run")(function* (executionId)
         break;
       }
       case "cancellation":
-        output2 = yield* execute(operation.operation).pipe(Effect100.catchIf(Schema91.is(WorkflowCancelled), () => operation.on_cancel === undefined ? Effect100.fail(WorkflowCancelled.make()) : execute(operation.on_cancel)));
+        output2 = yield* execute(operation.operation).pipe(Effect100.catchIf(Schema92.is(WorkflowCancelled), () => operation.on_cancel === undefined ? Effect100.fail(WorkflowCancelled.make()) : execute(operation.on_cancel)));
         break;
       case "compensation":
         output2 = yield* execute(operation.operation);
@@ -17718,7 +17890,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) && Schema91.is(WorkflowJoining)(failure2.value))
+    if (Option27.isSome(failure2) && Schema92.is(WorkflowJoining)(failure2.value))
       return yield* result;
     const currentRun = yield* repository.inspect(executionId);
     if (currentRun?.status === "cancelled") {
@@ -17789,12 +17961,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 Schema99 } from "effect";
+import { Cause as Cause5, Context as Context74, Effect as Effect112, Layer as Layer86, Option as Option31, Schema as Schema100 } 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 Schema92 } from "effect";
-var RuntimeConfigurationCategory = Schema92.Literals([
+import { Cause as Cause4, Function as Function17, Schema as Schema93 } from "effect";
+var RuntimeConfigurationCategory = Schema93.Literals([
   "missing-http-client",
   "provider-config",
   "model-registration",
@@ -17802,31 +17974,31 @@ var RuntimeConfigurationCategory = Schema92.Literals([
   "database-config",
   "unknown-host-layer"
 ]);
-var RuntimeConfigurationScope = Schema92.Literals(["host-layer", "database-client"]);
+var RuntimeConfigurationScope = Schema93.Literals(["host-layer", "database-client"]);
 
-class RuntimeHostLayerFailure extends Schema92.TaggedErrorClass()("RuntimeHostLayerFailure", { category: RuntimeConfigurationCategory }) {
+class RuntimeHostLayerFailure extends Schema93.TaggedErrorClass()("RuntimeHostLayerFailure", { category: RuntimeConfigurationCategory }) {
 }
-var SafeCauseReason = Schema92.TaggedUnion({
+var SafeCauseReason = Schema93.TaggedUnion({
   Fail: {
     category: RuntimeConfigurationCategory,
-    errorTag: Schema92.Literals(["RuntimeHostLayerFailure", "UnknownTypedFailure"])
+    errorTag: Schema93.Literals(["RuntimeHostLayerFailure", "UnknownTypedFailure"])
   },
-  Die: { defectTag: Schema92.Literal("UnknownDefect") },
+  Die: { defectTag: Schema93.Literal("UnknownDefect") },
   Interrupt: {}
 });
-var SafeCause = Schema92.Struct({
-  reasons: Schema92.Array(SafeCauseReason).check(Schema92.isMaxLength(16)),
-  truncated: Schema92.Boolean
+var SafeCause = Schema93.Struct({
+  reasons: Schema93.Array(SafeCauseReason).check(Schema93.isMaxLength(16)),
+  truncated: Schema93.Boolean
 });
 
-class RuntimeConfigurationError extends Schema92.TaggedErrorClass()("RuntimeConfigurationError", {
+class RuntimeConfigurationError extends Schema93.TaggedErrorClass()("RuntimeConfigurationError", {
   category: RuntimeConfigurationCategory,
   scope: RuntimeConfigurationScope,
   cause: SafeCause
 }) {
 }
 var typedFailure = (error5) => {
-  if (Schema92.is(RuntimeHostLayerFailure)(error5)) {
+  if (Schema93.is(RuntimeHostLayerFailure)(error5)) {
     return { _tag: "Fail", category: error5.category, errorTag: "RuntimeHostLayerFailure" };
   }
   return { _tag: "Fail", category: "unknown-host-layer", errorTag: "UnknownTypedFailure" };
@@ -17845,11 +18017,11 @@ var safeCause = (cause) => {
 var normalizeAcquisitionCauseImpl = (cause, scope, preserve) => {
   const summary = safeCause(cause);
   return Cause4.map(cause, (error5) => {
-    if (Schema92.is(RuntimeConfigurationError)(error5) || preserve !== undefined && preserve(error5))
+    if (Schema93.is(RuntimeConfigurationError)(error5) || preserve !== undefined && preserve(error5))
       return error5;
     const reason = typedFailure(error5);
     return RuntimeConfigurationError.make({
-      category: Schema92.is(RuntimeHostLayerFailure)(error5) ? reason.category : scope === "database-client" ? "database-config" : "unknown-host-layer",
+      category: Schema93.is(RuntimeHostLayerFailure)(error5) ? reason.category : scope === "database-client" ? "database-config" : "unknown-host-layer",
       scope,
       cause: summary
     });
@@ -17871,16 +18043,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 Schema98, Stream as Stream17 } from "effect";
+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 { 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 Schema93 } from "effect";
+import { Context as Context72, Effect as Effect101, Function as Function18, Layer as Layer83, Schema as Schema94 } from "effect";
 
-class RuntimeCapabilityUnavailable extends Schema93.TaggedErrorClass()("RuntimeCapabilityUnavailable", {
-  capability: Schema93.Literals(["fan-out", "workflow-definition"]),
-  role: Schema93.Literals(["embedded", "runner", "client"]),
-  nextAction: Schema93.Literals(["enable-embedded-capability", "use-embedded-runtime"])
+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"])
 }) {
 }
 
@@ -17898,7 +18070,7 @@ var layer64 = Function18.dual(2, (role, capabilities) => Layer83.succeed(Service
 }));
 
 // src/client-baton-agent.ts
-import { Effect as Effect102, Schema as Schema94 } from "effect";
+import { Effect as Effect102, Schema as Schema95 } from "effect";
 var isRegisterBatonAgentInput = (input) => ("agent" in input);
 var toolRefsFromBatonAgent = (agent) => Object.values(agent.toolkit.tools).map((tool3) => ({ name: tool3.name }));
 var modelSelectionFromBatonAgent = (selection) => ({
@@ -17906,9 +18078,9 @@ var modelSelectionFromBatonAgent = (selection) => ({
   model: selection.model,
   ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
 });
-var decodeBatonAgentName = (name) => Schema94.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 : Schema94.decodeUnknownEffect(exports_shared_schema.Metadata)(metadata11).pipe(Effect102.mapError(() => ClientError.make({ message: "Baton agent metadata must be JSON metadata" })));
-var decodeBatonMemorySubject = (subject) => Schema94.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect102.mapError(() => ClientError.make({ message: "Baton agent memory subject must be a MemorySubjectId" })));
+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 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);
@@ -18017,10 +18189,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 Schema95 } from "effect";
+import { Option as Option28, Schema as Schema96 } 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(Schema95.decodeUnknownOption(EventLogCursorNotFound)(error5), {
+var toStreamError = (error5) => Option28.match(Schema96.decodeUnknownOption(EventLogCursorNotFound)(error5), {
   onNone: () => toClientError(error5),
   onSome: (cursorError) => cursorError
 });
@@ -18151,8 +18323,8 @@ var childStartInput = (input, accepted2, pin, definition, createdAt, parentWaitI
 var childRunInternals = { childStartInput, internalSpawnChildRunInput };
 
 // src/client-execution-payloads.ts
-import { Effect as Effect105, Schema as Schema96 } from "effect";
-var encodeExecutionCursor = (cursor) => Schema96.encodeEffect(exports_pagination_schema.ExecutionCursorCodec)({ id: cursor.id, at: cursor.updatedAt }).pipe(Effect105.mapError(toClientError));
+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));
 var executionIdFromIdempotencyKey = (idempotencyKey) => exports_ids_schema.ExecutionId.make(`execution:${idempotencyKey}`);
 var metadataWithIdempotencyKey = (metadata11, idempotencyKey) => ({
   ...metadata11,
@@ -18269,9 +18441,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 Schema97 } from "effect";
+import { Effect as Effect108, Schema as Schema98 } from "effect";
 var toolWaitId = (executionId, callId) => Identifiers.waitId("tool", executionId, callId);
-var acceptedWaitOutcome = (wait) => Schema97.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect108.mapError(toClientError));
+var acceptedWaitOutcome = (wait) => Schema98.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));
@@ -18552,7 +18724,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 Schema98.decodeUnknownOption(Schema98.UnknownFromJsonString)(text);
+  return Schema99.decodeUnknownOption(Schema99.UnknownFromJsonString)(text);
 };
 var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
   const makeExecutionClient = yield* client;
@@ -18632,7 +18804,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
         status: "queued",
         metadata: { operation: "envelope-send" },
         createdAt
-      }).pipe(Effect109.catchIf(Schema98.is(exports_execution_repository.DuplicateExecution), () => Effect109.void), Effect109.mapError(toClientError));
+      }).pipe(Effect109.catchIf(Schema99.is(exports_execution_repository.DuplicateExecution), () => Effect109.void), Effect109.mapError(toClientError));
     }
     const maxSequence3 = yield* eventLog.maxSequence(executionId).pipe(Effect109.mapError(toClientError));
     return yield* envelopes.send({
@@ -18851,7 +19023,16 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
         content: input.content,
         createdAt: input.created_at
       }).pipe(Effect109.mapError(toClientError));
-      return { execution_id: record2.executionId, kind: record2.kind, sequence: record2.sequence };
+      return {
+        execution_id: record2.executionId,
+        kind: record2.kind,
+        sequence: record2.sequence,
+        steering_message_id: exports_execution_schema.steeringMessageId({
+          execution_id: record2.executionId,
+          kind: record2.kind,
+          sequence: record2.sequence
+        })
+      };
     }),
     getExecution: getExecutionOperation,
     inspectExecution: inspectExecutionOperation,
@@ -18869,7 +19050,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* Schema98.decodeEffect(exports_pagination_schema.ExecutionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema99.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 },
@@ -18919,13 +19100,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* Schema98.decodeEffect(exports_pagination_schema.SessionCursorCodec)(input.cursor).pipe(Effect109.map(({ id, at }) => ({ id, updatedAt: at })));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema99.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* Schema98.encodeEffect(exports_pagination_schema.SessionCursorCodec)({
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema99.encodeEffect(exports_pagination_schema.SessionCursorCodec)({
         id: result.nextCursor.id,
         at: result.nextCursor.updatedAt
       });
@@ -18938,7 +19119,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* Schema98.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* Schema99.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 },
@@ -19009,7 +19190,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* Schema98.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect109.mapError(toClientError));
+      const encoded = yield* Schema99.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)) {
@@ -19056,7 +19237,7 @@ var layerFromRuntime3 = Layer84.effect(Service, Effect109.gen(function* () {
           message: "reply carried no decodable content"
         });
       }
-      return yield* Schema98.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect109.mapError((issue) => CommandReplyInvalid.make({
+      return yield* Schema99.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect109.mapError((issue) => CommandReplyInvalid.make({
         command: input.command.name,
         wait_id: outcome.wait_id,
         message: errorMessage2(issue)
@@ -19097,14 +19278,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) => Schema98.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
+    }).pipe(Effect109.mapError((error5) => Schema99.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) => Schema98.is(StateVersionConflict3)(error5) ? StateVersionConflict.make(error5) : toClientError(error5)))),
+    }).pipe(Effect109.mapError((error5) => Schema99.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 },
@@ -19363,77 +19544,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 = Schema99.Literals(["pg", "mysql", "sqlite"]);
+var Dialect2 = Schema100.Literals(["pg", "mysql", "sqlite"]);
 
-class NotificationFailure extends Schema99.TaggedErrorClass()("NotificationFailure", {
-  reason: Schema99.String
+class NotificationFailure extends Schema100.TaggedErrorClass()("NotificationFailure", {
+  reason: Schema100.String
 }) {
 }
 
-class ClusterFailure extends Schema99.TaggedErrorClass()("ClusterFailure", {
-  reason: Schema99.String
+class ClusterFailure extends Schema100.TaggedErrorClass()("ClusterFailure", {
+  reason: Schema100.String
 }) {
 }
 
-class SqlFailure extends Schema99.TaggedErrorClass()("SqlFailure", {
-  category: Schema99.Literals(["connection", "statement", "unknown"]),
-  operation: Schema99.Literals(["acquire", "migrate", "verify", "notify", "readiness"]),
-  retryable: Schema99.Boolean
+class SqlFailure extends Schema100.TaggedErrorClass()("SqlFailure", {
+  category: Schema100.Literals(["connection", "statement", "unknown"]),
+  operation: Schema100.Literals(["acquire", "migrate", "verify", "notify", "readiness"]),
+  retryable: Schema100.Boolean
 }) {
 }
-var SqlDialect = Schema99.Literals(["sqlite", "pg", "mysql", "mssql", "clickhouse"]);
+var SqlDialect = Schema100.Literals(["sqlite", "pg", "mysql", "mssql", "clickhouse"]);
 
-class DatabaseDialectMismatch extends Schema99.TaggedErrorClass()("DatabaseDialectMismatch", { expected: Dialect2, actual: SqlDialect }) {
+class DatabaseDialectMismatch extends Schema100.TaggedErrorClass()("DatabaseDialectMismatch", { expected: Dialect2, actual: SqlDialect }) {
 }
 
-class DatabaseAlreadyOwned extends Schema99.TaggedErrorClass()("DatabaseAlreadyOwned", {
+class DatabaseAlreadyOwned extends Schema100.TaggedErrorClass()("DatabaseAlreadyOwned", {
   databaseIdentity: DatabaseIdentity
 }) {
 }
 
-class UnsupportedTopology extends Schema99.TaggedErrorClass()("UnsupportedTopology", {
-  reason: Schema99.String
+class UnsupportedTopology extends Schema100.TaggedErrorClass()("UnsupportedTopology", {
+  reason: Schema100.String
 }) {
 }
 
-class MigratorError extends Schema99.TaggedErrorClass()("MigratorError", {
-  reason: Schema99.String
+class MigratorError extends Schema100.TaggedErrorClass()("MigratorError", {
+  reason: Schema100.String
 }) {
 }
 
-class SchemaHeadMismatch extends Schema99.TaggedErrorClass()("SchemaHeadMismatch", {
-  expected: Schema99.String,
-  actual: Schema99.String
+class SchemaHeadMismatch extends Schema100.TaggedErrorClass()("SchemaHeadMismatch", {
+  expected: Schema100.String,
+  actual: Schema100.String
 }) {
 }
 
-class HostUnavailable extends Schema99.TaggedErrorClass()("HostUnavailable", {
-  host: Schema99.String,
-  reason: Schema99.String
+class HostUnavailable extends Schema100.TaggedErrorClass()("HostUnavailable", {
+  host: Schema100.String,
+  reason: Schema100.String
 }) {
 }
-var RuntimeTopologyCause = Schema99.Union([
+var RuntimeTopologyCause = Schema100.Union([
   ClusterFailure,
   DatabaseDialectMismatch,
   DatabaseAlreadyOwned,
   UnsupportedTopology
 ]);
-var RuntimeMigrationCause = Schema99.Union([
+var RuntimeMigrationCause = Schema100.Union([
   SqlFailure,
   MigratorError,
   SchemaHeadMismatch
 ]);
-var RuntimeReadinessCause = Schema99.Union([
+var RuntimeReadinessCause = Schema100.Union([
   SqlFailure,
   NotificationFailure,
   ClusterFailure,
   HostUnavailable
 ]);
 
-class RuntimeTopologyError extends Schema99.TaggedErrorClass()("RuntimeTopologyError", {
+class RuntimeTopologyError extends Schema100.TaggedErrorClass()("RuntimeTopologyError", {
   dialect: Dialect2,
-  role: Schema99.Literals(["embedded", "runner", "client"]),
-  nextAction: Schema99.Literals([
+  role: Schema100.Literals(["embedded", "runner", "client"]),
+  nextAction: Schema100.Literals([
     "use-embedded",
     "use-postgres-or-mysql",
     "use-client-constructor",
@@ -19444,39 +19625,39 @@ class RuntimeTopologyError extends Schema99.TaggedErrorClass()("RuntimeTopologyE
 }) {
 }
 
-class RuntimeMigrationError extends Schema99.TaggedErrorClass()("RuntimeMigrationError", {
+class RuntimeMigrationError extends Schema100.TaggedErrorClass()("RuntimeMigrationError", {
   dialect: Dialect2,
-  phase: Schema99.Literals(["apply", "verify"]),
-  nextAction: Schema99.Literals(["retry", "inspect-schema", "run-compatible-release"]),
+  phase: Schema100.Literals(["apply", "verify"]),
+  nextAction: Schema100.Literals(["retry", "inspect-schema", "run-compatible-release"]),
   cause: RuntimeMigrationCause
 }) {
 }
 
-class RuntimeReadinessError extends Schema99.TaggedErrorClass()("RuntimeReadinessError", {
-  phase: Schema99.Literals(["database", "notification", "cluster", "hosts"]),
+class RuntimeReadinessError extends Schema100.TaggedErrorClass()("RuntimeReadinessError", {
+  phase: Schema100.Literals(["database", "notification", "cluster", "hosts"]),
   cause: RuntimeReadinessCause
 }) {
 }
-var RuntimeCapabilityStatus = Schema99.Union([
-  Schema99.Struct({
-    enabled: Schema99.Literal(false),
-    source: Schema99.Literals(["local-host", "role-unavailable"]),
-    health: Schema99.Literal("not-applicable")
+var RuntimeCapabilityStatus = Schema100.Union([
+  Schema100.Struct({
+    enabled: Schema100.Literal(false),
+    source: Schema100.Literals(["local-host", "role-unavailable"]),
+    health: Schema100.Literal("not-applicable")
   }),
-  Schema99.Struct({
-    enabled: Schema99.Literal(true),
-    source: Schema99.Literal("local-host"),
-    health: Schema99.Literals(["healthy", "unhealthy"])
+  Schema100.Struct({
+    enabled: Schema100.Literal(true),
+    source: Schema100.Literal("local-host"),
+    health: Schema100.Literals(["healthy", "unhealthy"])
   })
 ]);
-var ReadinessStatus2 = Schema99.Struct({
-  ready: Schema99.Literal(true),
-  role: Schema99.Literals(["embedded", "runner", "client"]),
+var ReadinessStatus2 = Schema100.Struct({
+  ready: Schema100.Literal(true),
+  role: Schema100.Literals(["embedded", "runner", "client"]),
   dialect: Dialect2,
   databaseIdentity: DatabaseIdentity,
-  schemaHead: Schema99.String,
-  notification: Schema99.Literals(["pg-listen-notify", "polling", "in-process"]),
-  capabilities: Schema99.Struct({
+  schemaHead: Schema100.String,
+  notification: Schema100.Literals(["pg-listen-notify", "polling", "in-process"]),
+  capabilities: Schema100.Struct({
     fanOut: RuntimeCapabilityStatus,
     workflowDefinition: RuntimeCapabilityStatus
   })
@@ -19490,7 +19671,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) => Schema99.is(RuntimeConfigurationError)(error5) || Schema99.is(RuntimeTopologyError)(error5) || Schema99.is(RuntimeMigrationError)(error5))))));
+}) : error5), "host-layer", (error5) => Schema100.is(RuntimeConfigurationError)(error5) || Schema100.is(RuntimeTopologyError)(error5) || Schema100.is(RuntimeMigrationError)(error5))))));
 var actualDialect = (sql) => sql.onDialectOrElse({
   sqlite: () => "sqlite",
   pg: () => "pg",