@relayfx/sdk 0.2.12 → 0.2.14

package/dist/{index-236a3f4t.js → index-gb7d1wfm.js}

@@ -8,6 +8,7 @@ import {
   exports_child_execution_repository,
   exports_child_fan_out_repository,
   exports_child_fan_out_runtime,
+  exports_child_fan_out_transition_service,
   exports_child_orchestration_schema,
   exports_child_run_service,
   exports_cluster_registry_repository,
@@ -29,7 +30,9 @@ import {
   exports_ids_schema,
   exports_inbox_repository,
   exports_inbox_schema,
+  exports_language_model_service,
   exports_presence_service,
+  exports_runner_runtime_service,
   exports_schedule_repository,
   exports_schedule_schema,
   exports_scheduler_service,
@@ -41,6 +44,7 @@ import {
   exports_state_schema,
   exports_steering_repository,
   exports_tool_call_repository,
+  exports_tool_runtime_service,
   exports_tool_schema,
   exports_tool_transition_coordinator,
   exports_topic_service,
@@ -48,7 +52,7 @@ import {
   exports_wait_service,
   exports_wait_signal,
   exports_workflow_definition_repository
-} from "./index-33d4k6kk.js";
+} from "./index-9q3yh32k.js";
 
 // src/operation.ts
 var exports_operation = {};
@@ -795,36 +799,60 @@ __export(exports_client, {
   askEntity: () => askEntity,
   ackEnvelopeReady: () => ackEnvelopeReady,
   WaitKindMismatch: () => WaitKindMismatch,
-  Service: () => Service,
+  Service: () => Service2,
   ExecutionNotFound: () => ExecutionNotFound,
   EventLogCursorNotFound: () => EventLogCursorNotFound,
   EntityNamespaceReserved: () => EntityNamespaceReserved,
   ClientError: () => ClientError
 });
-import { Clock, Context, Effect, Layer, Option, Schema as Schema3, SchemaGetter, SchemaIssue, Stream } from "effect";
+import { Clock, Context as Context2, Effect as Effect2, Layer as Layer2, Option, Schema as Schema4, SchemaGetter, SchemaIssue, Stream } from "effect";
 import { EntityId, ShardId, Sharding, ShardingConfig } from "effect/unstable/cluster";
-class ClientError extends Schema3.TaggedErrorClass()("ClientError", {
-  message: Schema3.String
+// src/runtime-capability-policy.ts
+import { Context, Effect, Layer, Schema as Schema3 } from "effect";
+
+class RuntimeCapabilityUnavailable extends Schema3.TaggedErrorClass()("RuntimeCapabilityUnavailable", {
+  capability: Schema3.Literals(["fan-out", "workflow-definition"]),
+  role: Schema3.Literals(["embedded", "runner", "client"]),
+  nextAction: Schema3.Literals(["enable-embedded-capability", "use-embedded-runtime"])
 }) {
 }
 
-class ExecutionNotFound extends Schema3.TaggedErrorClass()("ExecutionNotFound", {
+class Service extends Context.Service()("@relayfx/sdk/RuntimeCapabilityPolicy") {
+}
+var layer = (role, capabilities) => Layer.succeed(Service, {
+  admit: (capability) => {
+    const enabled = capability === "fan-out" ? capabilities.fanOut : capabilities.workflowDefinition;
+    return enabled ? Effect.void : Effect.fail(new RuntimeCapabilityUnavailable({
+      capability,
+      role,
+      nextAction: role === "embedded" ? "enable-embedded-capability" : "use-embedded-runtime"
+    }));
+  }
+});
+
+// src/client.ts
+class ClientError extends Schema4.TaggedErrorClass()("ClientError", {
+  message: Schema4.String
+}) {
+}
+
+class ExecutionNotFound extends Schema4.TaggedErrorClass()("ExecutionNotFound", {
   execution_id: exports_ids_schema.ExecutionId
 }) {
 }
 
-class EntityNamespaceReserved extends Schema3.TaggedErrorClass()("EntityNamespaceReserved", { id: Schema3.String, message: Schema3.String }) {
+class EntityNamespaceReserved extends Schema4.TaggedErrorClass()("EntityNamespaceReserved", { id: Schema4.String, message: Schema4.String }) {
 }
 
-class WaitKindMismatch extends Schema3.TaggedErrorClass()("WaitKindMismatch", {
+class WaitKindMismatch extends Schema4.TaggedErrorClass()("WaitKindMismatch", {
   wait_id: exports_ids_schema.WaitId,
-  expected: Schema3.String,
-  actual: Schema3.String,
-  message: Schema3.String
+  expected: Schema4.String,
+  actual: Schema4.String,
+  message: Schema4.String
 }) {
 }
 
-class Service extends Context.Service()("@relayfx/sdk/Client") {
+class Service2 extends Context2.Service()("@relayfx/sdk/Client") {
 }
 var followTerminalStatus = (type) => type === "execution.completed" ? "completed" : type === "execution.failed" ? "failed" : type === "execution.cancelled" ? "cancelled" : undefined;
 var followReconnectDelayMillis = (attempt) => Math.min(100 * 2 ** (attempt - 1), 5000);
@@ -836,8 +864,8 @@ var followStopped = (reason, cursor) => ({
 var followExecutionFrom = (dependencies) => (input) => {
   const maxReconnects = input.max_reconnects ?? 10;
   const stopModes = input.stop_on_wait_modes;
-  const inspect = Effect.suspend(() => dependencies.inspectExecution(input.execution_id)).pipe(Effect.catchTag("ExecutionNotFound", (error) => new ClientError({ message: `execution ${error.execution_id} not found` })));
-  const reconcile = (state, message) => Stream.unwrap(Effect.gen(function* () {
+  const inspect = Effect2.suspend(() => dependencies.inspectExecution(input.execution_id)).pipe(Effect2.catchTag("ExecutionNotFound", (error) => new ClientError({ message: `execution ${error.execution_id} not found` })));
+  const reconcile = (state, message) => Stream.unwrap(Effect2.gen(function* () {
     const inspection = yield* inspect;
     const terminal = followTerminalStatus(`execution.${inspection.status}`);
     if (terminal !== undefined) {
@@ -854,9 +882,9 @@ var followExecutionFrom = (dependencies) => (input) => {
     }
     state.attempts += 1;
     const reconnecting = { _tag: "reconnecting", message, attempt: state.attempts };
-    return Stream.make(reconnecting).pipe(Stream.concat(Stream.fromEffect(Effect.sleep(followReconnectDelayMillis(state.attempts))).pipe(Stream.drain)), Stream.concat(Stream.suspend(() => connect(state))));
+    return Stream.make(reconnecting).pipe(Stream.concat(Stream.fromEffect(Effect2.sleep(followReconnectDelayMillis(state.attempts))).pipe(Stream.drain)), Stream.concat(Stream.suspend(() => connect(state))));
   }));
-  const itemsFor = (state, event) => Effect.gen(function* () {
+  const itemsFor = (state, event) => Effect2.gen(function* () {
     if (event.sequence <= state.sequence)
       return [];
     state.sequence = event.sequence;
@@ -872,7 +900,7 @@ var followExecutionFrom = (dependencies) => (input) => {
     if (stopModes !== undefined && event.type === "wait.created") {
       const mode = event.data?.mode;
       if (typeof mode === "string" && stopModes.includes(mode)) {
-        const inspection = yield* dependencies.inspectExecution(input.execution_id).pipe(Effect.catchTag("ExecutionNotFound", () => Effect.succeed(undefined)));
+        const inspection = yield* dependencies.inspectExecution(input.execution_id).pipe(Effect2.catchTag("ExecutionNotFound", () => Effect2.succeed(undefined)));
         const actionable = inspection?.waiting_on.find((wait) => wait.state === "open" && wait.wait_id === event.data?.wait_id);
         if (actionable !== undefined) {
           items.push(followStopped({ _tag: "actionable_wait", wait: actionable }, state.cursor));
@@ -885,7 +913,7 @@ var followExecutionFrom = (dependencies) => (input) => {
     execution_id: input.execution_id,
     ...state.cursor === undefined ? {} : { after_cursor: state.cursor }
   }).pipe(Stream.flatMap((event) => Stream.fromEffect(itemsFor(state, event)).pipe(Stream.flatMap((items) => Stream.fromIterable(items)))), Stream.catchTag("EventLogCursorNotFound", (error) => !state.emitted && input.after_cursor !== undefined ? Stream.fail(error) : reconcile(state, `cursor ${error.cursor} was not found`)), Stream.catchTag("ClientError", (error) => reconcile(state, `stream failed: ${error.message}`)), Stream.concat(Stream.suspend(() => reconcile(state, "stream ended before a terminal event"))));
-  return Stream.unwrap(Effect.gen(function* () {
+  return Stream.unwrap(Effect2.gen(function* () {
     const existing = yield* dependencies.getExecution(input.execution_id);
     if (existing === undefined) {
       return Stream.fail(new ClientError({ message: `execution ${input.execution_id} not found` }));
@@ -911,7 +939,7 @@ var errorMessage = (error) => {
   return String(error);
 };
 var toClientError = (error) => new ClientError({ message: errorMessage(error) });
-var rejectReserved = (id, prefix) => id.startsWith(prefix) ? Effect.fail(new EntityNamespaceReserved({ id, message: "start entities via Client.getOrCreateEntity" })) : Effect.void;
+var rejectReserved = (id, prefix) => id.startsWith(prefix) ? Effect2.fail(new EntityNamespaceReserved({ id, message: "start entities via Client.getOrCreateEntity" })) : Effect2.void;
 var replyValueFrom = (content) => {
   if (content === undefined || content.length === 0)
     return Option.none();
@@ -927,30 +955,30 @@ var replyValueFrom = (content) => {
     return Option.none();
   }
 };
-var toStreamError = (error) => Option.match(Schema3.decodeUnknownOption(EventLogCursorNotFound)(error), {
+var toStreamError = (error) => Option.match(Schema4.decodeUnknownOption(EventLogCursorNotFound)(error), {
   onNone: () => toClientError(error),
   onSome: (cursorError) => cursorError
 });
 var malformedCursor = (wire) => new SchemaIssue.InvalidValue(Option.some(wire), { message: "Malformed pagination cursor" });
-var decodeCursorFields = (wire) => Effect.gen(function* () {
-  const decoded = yield* Effect.try({
+var decodeCursorFields = (wire) => Effect2.gen(function* () {
+  const decoded = yield* Effect2.try({
     try: () => globalThis.atob(wire),
     catch: () => malformedCursor(wire)
   });
   const separator = decoded.indexOf(":");
   if (separator === -1)
-    return yield* Effect.fail(malformedCursor(wire));
+    return yield* Effect2.fail(malformedCursor(wire));
   const updatedAt = Number(decoded.slice(0, separator));
   if (!Number.isFinite(updatedAt))
-    return yield* Effect.fail(malformedCursor(wire));
+    return yield* Effect2.fail(malformedCursor(wire));
   return { updatedAt, id: decoded.slice(separator + 1) };
 });
-var ExecutionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema3.decodeTo(Schema3.Struct({ updatedAt: Schema3.Int, id: exports_ids_schema.ExecutionId }), {
+var ExecutionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema4.decodeTo(Schema4.Struct({ updatedAt: Schema4.Int, id: exports_ids_schema.ExecutionId }), {
   decode: SchemaGetter.transformOrFail((wire) => decodeCursorFields(wire)),
   encode: SchemaGetter.transform((cursor) => globalThis.btoa(`${cursor.updatedAt}:${cursor.id}`))
 })).annotate({ identifier: "Relay.Client.ExecutionCursor" });
-var encodeExecutionCursor = (cursor) => Schema3.encodeEffect(ExecutionCursorFromString)(cursor).pipe(Effect.mapError(toClientError));
-var SessionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema3.decodeTo(Schema3.Struct({ updatedAt: Schema3.Int, id: exports_ids_schema.SessionId }), {
+var encodeExecutionCursor = (cursor) => Schema4.encodeEffect(ExecutionCursorFromString)(cursor).pipe(Effect2.mapError(toClientError));
+var SessionCursorFromString = exports_shared_schema.NonEmptyString.pipe(Schema4.decodeTo(Schema4.Struct({ updatedAt: Schema4.Int, id: exports_ids_schema.SessionId }), {
   decode: SchemaGetter.transformOrFail((wire) => decodeCursorFields(wire)),
   encode: SchemaGetter.transform((cursor) => globalThis.btoa(`${cursor.updatedAt}:${cursor.id}`))
 })).annotate({ identifier: "Relay.Client.SessionCursor" });
@@ -1059,10 +1087,10 @@ var modelSelectionFromBatonAgent = (selection) => ({
   model: selection.model,
   ...selection.registrationKey === undefined ? {} : { registration_key: selection.registrationKey }
 });
-var decodeBatonAgentName = (name) => Schema3.decodeUnknownEffect(exports_shared_schema.NonEmptyString)(name).pipe(Effect.mapError(() => new ClientError({ message: "Baton agent name must not be blank" })));
-var decodeBatonAgentMetadata = (metadata) => metadata === undefined ? Effect.succeed(undefined) : Schema3.decodeUnknownEffect(exports_shared_schema.Metadata)(metadata).pipe(Effect.mapError(() => new ClientError({ message: "Baton agent metadata must be JSON metadata" })));
-var decodeBatonMemorySubject = (subject) => Schema3.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect.mapError(() => new ClientError({ message: "Baton agent memory subject must be a MemorySubjectId" })));
-var metadataFromBatonAgent = Effect.fn("Client.metadataFromBatonAgent")(function* (input) {
+var decodeBatonAgentName = (name) => Schema4.decodeUnknownEffect(exports_shared_schema.NonEmptyString)(name).pipe(Effect2.mapError(() => new ClientError({ message: "Baton agent name must not be blank" })));
+var decodeBatonAgentMetadata = (metadata) => metadata === undefined ? Effect2.succeed(undefined) : Schema4.decodeUnknownEffect(exports_shared_schema.Metadata)(metadata).pipe(Effect2.mapError(() => new ClientError({ message: "Baton agent metadata must be JSON metadata" })));
+var decodeBatonMemorySubject = (subject) => Schema4.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(subject).pipe(Effect2.mapError(() => new ClientError({ message: "Baton agent memory subject must be a MemorySubjectId" })));
+var metadataFromBatonAgent = Effect2.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);
   const metadata = {
@@ -1074,35 +1102,35 @@ var metadataFromBatonAgent = Effect.fn("Client.metadataFromBatonAgent")(function
 });
 var modelSelectionFromRegisterInput = (input) => {
   if (input.model !== undefined)
-    return Effect.succeed(input.model);
+    return Effect2.succeed(input.model);
   if (input.agent.model !== undefined)
-    return Effect.succeed(modelSelectionFromBatonAgent(input.agent.model));
-  return Effect.fail(new ClientError({ message: "Client.registerAgent requires model or agent.model" }));
+    return Effect2.succeed(modelSelectionFromBatonAgent(input.agent.model));
+  return Effect2.fail(new ClientError({ message: "Client.registerAgent requires model or agent.model" }));
 };
 var batonTurnPolicyInvalid = (detail) => new ClientError({ message: `Baton agent turn policy is not durably portable: ${detail}` });
-var turnPolicySnapshotFromBaton = Effect.fn("Client.turnPolicySnapshotFromBaton")(function* (snapshot) {
+var turnPolicySnapshotFromBaton = Effect2.fn("Client.turnPolicySnapshotFromBaton")(function* (snapshot) {
   let nodes = 0;
-  const visit = (current, depth) => Effect.gen(function* () {
+  const visit = (current, depth) => Effect2.gen(function* () {
     if (typeof current !== "object" || current === null || Array.isArray(current)) {
-      return yield* Effect.fail(batonTurnPolicyInvalid("snapshot nodes must be objects"));
+      return yield* Effect2.fail(batonTurnPolicyInvalid("snapshot nodes must be objects"));
     }
     const node = current;
     nodes += 1;
     if (depth > exports_agent_schema.maxTurnPolicySnapshotDepth) {
-      return yield* Effect.fail(batonTurnPolicyInvalid(`depth exceeds ${exports_agent_schema.maxTurnPolicySnapshotDepth}`));
+      return yield* Effect2.fail(batonTurnPolicyInvalid(`depth exceeds ${exports_agent_schema.maxTurnPolicySnapshotDepth}`));
     }
     if (nodes > exports_agent_schema.maxTurnPolicySnapshotNodes) {
-      return yield* Effect.fail(batonTurnPolicyInvalid(`node count exceeds ${exports_agent_schema.maxTurnPolicySnapshotNodes}`));
+      return yield* Effect2.fail(batonTurnPolicyInvalid(`node count exceeds ${exports_agent_schema.maxTurnPolicySnapshotNodes}`));
     }
     switch (node._tag) {
       case "Recurs":
         if (typeof node.count !== "number" || !Number.isInteger(node.count) || node.count < 0) {
-          return yield* Effect.fail(batonTurnPolicyInvalid("recurs count must be a non-negative integer"));
+          return yield* Effect2.fail(batonTurnPolicyInvalid("recurs count must be a non-negative integer"));
         }
         return { kind: "recurs", count: node.count };
       case "UntilToolCall":
         if (typeof node.name !== "string" || node.name.trim().length === 0) {
-          return yield* Effect.fail(batonTurnPolicyInvalid("until-tool-call name must not be blank"));
+          return yield* Effect2.fail(batonTurnPolicyInvalid("until-tool-call name must not be blank"));
         }
         return { kind: "until-tool-call", name: node.name };
       case "Both":
@@ -1112,17 +1140,17 @@ var turnPolicySnapshotFromBaton = Effect.fn("Client.turnPolicySnapshotFromBaton"
           second: yield* visit(node.second, depth + 1)
         };
       default:
-        return yield* Effect.fail(batonTurnPolicyInvalid("snapshot tag is not recognized"));
+        return yield* Effect2.fail(batonTurnPolicyInvalid("snapshot tag is not recognized"));
     }
   });
   return yield* visit(snapshot, 1);
 });
-var turnPolicyFieldsFromRegisterInput = Effect.fn("Client.turnPolicyFieldsFromRegisterInput")(function* (input) {
+var turnPolicyFieldsFromRegisterInput = Effect2.fn("Client.turnPolicyFieldsFromRegisterInput")(function* (input) {
   if (input.max_tool_turns !== undefined)
     return { max_tool_turns: input.max_tool_turns };
   const snapshot = input.agent.policy.snapshot;
   if (snapshot === undefined) {
-    return yield* Effect.fail(batonTurnPolicyInvalid("opaque policies require an explicit max_tool_turns replacement"));
+    return yield* Effect2.fail(batonTurnPolicyInvalid("opaque policies require an explicit max_tool_turns replacement"));
   }
   const durable = yield* turnPolicySnapshotFromBaton(snapshot);
   if (durable.kind === "recurs" && durable.count === 8)
@@ -1131,7 +1159,7 @@ var turnPolicyFieldsFromRegisterInput = Effect.fn("Client.turnPolicyFieldsFromRe
     return { max_tool_turns: durable.count };
   return { turn_policy: durable };
 });
-var registerAgentPayload = Effect.fn("Client.registerAgentPayload")(function* (input) {
+var registerAgentPayload = Effect2.fn("Client.registerAgentPayload")(function* (input) {
   if (!isRegisterBatonAgentInput(input))
     return exports_agent_schema.define(input);
   const name = yield* decodeBatonAgentName(input.agent.name);
@@ -1210,10 +1238,10 @@ var toToolWorkLease = (lease) => ({
   idempotency_key: lease.idempotencyKey
 });
 var toolWaitId = (callId) => exports_ids_schema.WaitId.make(`wait:tool:${callId}`);
-var acceptedWaitOutcome = (wait) => Schema3.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect.mapError(toClientError));
-var resolveToolOutcomeWait = Effect.fn("Client.resolveToolOutcomeWait")(function* (waits, eventLog, call, outcome, completedAt) {
+var acceptedWaitOutcome = (wait) => Schema4.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect2.mapError(toClientError));
+var resolveToolOutcomeWait = Effect2.fn("Client.resolveToolOutcomeWait")(function* (waits, eventLog, call, outcome, completedAt) {
   const waitId = call.waitId ?? toolWaitId(call.call.id);
-  const wait = yield* waits.get(waitId).pipe(Effect.mapError(toClientError));
+  const wait = yield* waits.get(waitId).pipe(Effect2.mapError(toClientError));
   if (wait === undefined)
     return yield* new ClientError({ message: `Tool wait not found: ${waitId}` });
   if (wait.executionId !== call.executionId) {
@@ -1235,7 +1263,7 @@ var resolveToolOutcomeWait = Effect.fn("Client.resolveToolOutcomeWait")(function
     resolvedAt: completedAt,
     eventSequence,
     metadata: { kind: "tool-placement", external_outcome: outcome }
-  }).pipe(Effect.mapError(toClientError));
+  }).pipe(Effect2.mapError(toClientError));
   if (!resolved.transitioned) {
     const accepted = yield* acceptedWaitOutcome(resolved.wait);
     if (exports_shared_schema.canonicalString(accepted) !== exports_shared_schema.canonicalString(outcome)) {
@@ -1244,14 +1272,14 @@ var resolveToolOutcomeWait = Effect.fn("Client.resolveToolOutcomeWait")(function
   }
   return resolved.wait;
 });
-var signalToolOutcome = Effect.fn("Client.signalToolOutcome")(function* (executionRepository, makeExecutionClient, wait, signaledAt) {
+var signalToolOutcome = Effect2.fn("Client.signalToolOutcome")(function* (executionRepository, makeExecutionClient, wait, signaledAt) {
   yield* exports_wait_signal.signalWorkflowWait({
     makeExecutionClient,
     executionId: wait.executionId,
     waitId: wait.id,
     state: "resolved",
     signaledAt
-  }).pipe(Effect.provideService(exports_execution_repository.Service, executionRepository), Effect.mapError(toClientError));
+  }).pipe(Effect2.provideService(exports_execution_repository.Service, executionRepository), Effect2.mapError(toClientError));
 });
 var toReady = (record) => ({
   id: record.id,
@@ -1266,8 +1294,8 @@ var toLease = (record) => ({
   worker_id: record.claimOwner ?? "unclaimed",
   claim_expires_at: record.claimExpiresAt ?? record.updatedAt
 });
-var nextEventSequence = Effect.fn("Client.nextEventSequence")(function* (eventLog, executionId) {
-  const max = yield* eventLog.maxSequence(executionId).pipe(Effect.mapError(toClientError));
+var nextEventSequence = Effect2.fn("Client.nextEventSequence")(function* (eventLog, executionId) {
+  const max = yield* eventLog.maxSequence(executionId).pipe(Effect2.mapError(toClientError));
   return max === undefined ? 0 : max + 1;
 });
 var waitSemanticKind = (wait) => wait.mode === "child" ? "child" : typeof wait.metadata.kind === "string" && wait.metadata.kind.length > 0 ? wait.metadata.kind : "general";
@@ -1275,8 +1303,8 @@ var terminalChildStatus = (metadata) => {
   const status = metadata?.child_status;
   return status === "completed" || status === "failed" || status === "cancelled";
 };
-var wakeRuntime = Effect.fn("Client.wakeRuntime")(function* (waits, eventLog, executionRepository, makeExecutionClient, input, accepts) {
-  const wait = yield* waits.get(input.wait_id).pipe(Effect.mapError(toClientError));
+var wakeRuntime = Effect2.fn("Client.wakeRuntime")(function* (waits, eventLog, executionRepository, makeExecutionClient, input, accepts) {
+  const wait = yield* waits.get(input.wait_id).pipe(Effect2.mapError(toClientError));
   if (wait === undefined)
     return yield* new ClientError({ message: `Wait not found: ${input.wait_id}` });
   const kind = waitSemanticKind(wait);
@@ -1305,17 +1333,17 @@ var wakeRuntime = Effect.fn("Client.wakeRuntime")(function* (waits, eventLog, ex
     resolvedAt: input.signaled_at,
     eventSequence,
     metadata: wakeMetadata(input)
-  }).pipe(Effect.mapError(toClientError)) : input.state === "timed_out" ? yield* waits.timeout({
+  }).pipe(Effect2.mapError(toClientError)) : input.state === "timed_out" ? yield* waits.timeout({
     waitId: input.wait_id,
     timedOutAt: input.signaled_at,
     eventSequence,
     metadata: wakeMetadata(input)
-  }).pipe(Effect.mapError(toClientError)) : yield* waits.cancel({
+  }).pipe(Effect2.mapError(toClientError)) : yield* waits.cancel({
     waitId: input.wait_id,
     cancelledAt: input.signaled_at,
     eventSequence,
     metadata: wakeMetadata(input)
-  }).pipe(Effect.mapError(toClientError));
+  }).pipe(Effect2.mapError(toClientError));
   if (result.transitioned) {
     yield* exports_wait_signal.signalWorkflowWait({
       makeExecutionClient,
@@ -1323,7 +1351,7 @@ var wakeRuntime = Effect.fn("Client.wakeRuntime")(function* (waits, eventLog, ex
       waitId: result.wait.id,
       state: input.state,
       signaledAt: input.signaled_at
-    }).pipe(Effect.provideService(exports_execution_repository.Service, executionRepository), Effect.mapError(toClientError));
+    }).pipe(Effect2.provideService(exports_execution_repository.Service, executionRepository), Effect2.mapError(toClientError));
   }
   return {
     wait_id: result.wait.id,
@@ -1332,7 +1360,6 @@ var wakeRuntime = Effect.fn("Client.wakeRuntime")(function* (waits, eventLog, ex
   };
 });
 var childJoinWaitId = (childExecutionId) => exports_ids_schema.WaitId.make(`wait:child:${childExecutionId}`);
-var childSessionId = (childExecutionId) => exports_ids_schema.SessionId.make(`session:child:${childExecutionId}`);
 var childSpawnFingerprintKey = "relay_child_spawn_fingerprint";
 var childExecutionIdForSpawn = (input) => input.child_execution_id ?? exports_ids_schema.ChildExecutionId.make(`${input.execution_id}:child:${input.address_id}`);
 var parentContextFromDefinition = (definition, fingerprint) => ({
@@ -1370,7 +1397,7 @@ var childSpawnFingerprint = (record) => {
   const fingerprint = parentMetadata[childSpawnFingerprintKey];
   return typeof fingerprint === "string" ? fingerprint : undefined;
 };
-var createChildJoinWait = Effect.fn("Client.createChildJoinWait")(function* (waits, eventLog, input, accepted, createdAt) {
+var createChildJoinWait = Effect2.fn("Client.createChildJoinWait")(function* (waits, eventLog, input, accepted, createdAt) {
   const waitId = childJoinWaitId(accepted.child_execution_id);
   const eventSequence = yield* nextEventSequence(eventLog, input.execution_id);
   yield* waits.createDetached({
@@ -1384,12 +1411,12 @@ var createChildJoinWait = Effect.fn("Client.createChildJoinWait")(function* (wai
     },
     eventSequence,
     createdAt
-  }).pipe(Effect.mapError(toClientError));
+  }).pipe(Effect2.mapError(toClientError));
   return waitId;
 });
-var reconcileExistingChildSpawn = Effect.fn("Client.reconcileExistingChildSpawn")(function* (childExecutions, waits, eventLog, input) {
+var reconcileExistingChildSpawn = Effect2.fn("Client.reconcileExistingChildSpawn")(function* (childExecutions, waits, eventLog, input) {
   const childExecutionId = childExecutionIdForSpawn(input);
-  const existing = yield* childExecutions.get(childExecutionId).pipe(Effect.mapError(toClientError));
+  const existing = yield* childExecutions.get(childExecutionId).pipe(Effect2.mapError(toClientError));
   if (existing === undefined)
     return;
   if (existing.executionId !== input.execution_id || existing.addressId !== input.address_id || childSpawnFingerprint(existing) !== exports_shared_schema.canonicalString(input)) {
@@ -1398,13 +1425,13 @@ var reconcileExistingChildSpawn = Effect.fn("Client.reconcileExistingChildSpawn"
   const spawned = yield* eventLog.findByCursor({
     executionId: input.execution_id,
     cursor: `${input.execution_id}:child:${childExecutionId}:spawned`
-  }).pipe(Effect.mapError(toClientError));
+  }).pipe(Effect2.mapError(toClientError));
   if (Option.isNone(spawned)) {
     return yield* new ClientError({ message: `Child spawn event missing: ${childExecutionId}` });
   }
   const parentWaitId = input.wait === true ? childJoinWaitId(childExecutionId) : undefined;
   if (parentWaitId !== undefined) {
-    const wait = yield* waits.get(parentWaitId).pipe(Effect.mapError(toClientError));
+    const wait = yield* waits.get(parentWaitId).pipe(Effect2.mapError(toClientError));
     if (wait === undefined) {
       return yield* new ClientError({ message: `Child join wait missing: ${childExecutionId}` });
     }
@@ -1415,8 +1442,8 @@ var reconcileExistingChildSpawn = Effect.fn("Client.reconcileExistingChildSpawn"
     parentWaitId
   };
 });
-var parentDefinitionPin = Effect.fn("Client.parentDefinitionPin")(function* (executionRepository, executionId) {
-  const record = yield* executionRepository.get(executionId).pipe(Effect.mapError(toClientError));
+var parentDefinitionPin = Effect2.fn("Client.parentDefinitionPin")(function* (executionRepository, executionId) {
+  const record = yield* executionRepository.get(executionId).pipe(Effect2.mapError(toClientError));
   if (record === undefined) {
     return yield* new ClientError({ message: `Execution not found: ${executionId}` });
   }
@@ -1433,7 +1460,7 @@ var parentDefinitionPin = Effect.fn("Client.parentDefinitionPin")(function* (exe
 var childStartInput = (input, accepted, pin, definition, createdAt, parentWaitId) => ({
   execution_id: exports_ids_schema.ExecutionId.make(accepted.child_execution_id),
   root_address_id: input.address_id,
-  session_id: childSessionId(accepted.child_execution_id),
+  session_id: exports_execution_schema.childSessionId(accepted.child_execution_id),
   input: input.input === undefined ? [] : [...input.input],
   event_sequence: 0,
   started_at: createdAt,
@@ -1448,7 +1475,7 @@ var childStartInput = (input, accepted, pin, definition, createdAt, parentWaitId
     ...parentWaitId === undefined ? {} : { parent_wait_id: parentWaitId }
   }
 });
-var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
+var layerFromRuntime = Layer2.effect(Service2, Effect2.gen(function* () {
   const makeExecutionClient = yield* exports_execution_entity.client;
   const executions = yield* exports_execution_service.Service;
   const envelopes = yield* exports_envelope_service.Service;
@@ -1478,28 +1505,29 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
   const skillRegistry = yield* exports_skill_registry_service.Service;
   const toolTransitions = yield* exports_tool_transition_coordinator.Service;
   const workflows = yield* exports_workflow_definition_repository.Service;
-  const workflowRuntime = yield* Effect.serviceOption(exports_definition_runtime.Service);
-  const childFanOutRuntime = yield* Effect.serviceOption(exports_child_fan_out_runtime.Service);
-  const schemaRegistry = yield* Effect.serviceOption(exports_schema_registry_service.Service);
-  const coordinateToolTransition = (effect) => toolTransitions.coordinate(effect).pipe(Effect.mapError(toClientError));
-  const coordinateChildSpawn = (effect) => toolTransitions.coordinate(effect).pipe(Effect.mapError(toClientError));
-  const cancelFanOut = Effect.fn("Client.runtime.cancelFanOut")(function* (input) {
+  const workflowRuntime = yield* Effect2.serviceOption(exports_definition_runtime.Service);
+  const childFanOutRuntime = yield* Effect2.serviceOption(exports_child_fan_out_runtime.Service);
+  const runtimeCapabilityPolicy = yield* Effect2.serviceOption(Service);
+  const schemaRegistry = yield* Effect2.serviceOption(exports_schema_registry_service.Service);
+  const coordinateToolTransition = (effect) => toolTransitions.coordinate(effect).pipe(Effect2.mapError(toClientError));
+  const coordinateChildSpawn = (effect) => toolTransitions.coordinate(effect).pipe(Effect2.mapError(toClientError));
+  const cancelFanOut = Effect2.fn("Client.runtime.cancelFanOut")(function* (input) {
     if (Option.isSome(childFanOutRuntime)) {
-      const fanOut = yield* childFanOutRuntime.value.cancel(input.fan_out_id, input.cancelled_at, input.reason ?? "child fan-out cancelled").pipe(Effect.mapError(toClientError));
+      const fanOut = yield* childFanOutRuntime.value.cancel(input.fan_out_id, input.cancelled_at, input.reason ?? "child fan-out cancelled").pipe(Effect2.mapError(toClientError));
       if (fanOut === undefined)
         return yield* new ClientError({ message: `Child fan-out not found: ${input.fan_out_id}` });
       return { fan_out: fanOut };
     }
-    const result = yield* childFanOuts.cancel(input.fan_out_id, input.cancelled_at).pipe(Effect.mapError(toClientError));
+    const result = yield* childFanOuts.cancel(input.fan_out_id, input.cancelled_at).pipe(Effect2.mapError(toClientError));
     if (result === undefined)
       return yield* new ClientError({ message: `Child fan-out not found: ${input.fan_out_id}` });
-    yield* Effect.forEach(result.activeChildExecutionIds, (childId) => makeExecutionClient(exports_ids_schema.ExecutionId.make(childId)).cancel({
+    yield* Effect2.forEach(result.activeChildExecutionIds, (childId) => makeExecutionClient(exports_ids_schema.ExecutionId.make(childId)).cancel({
       execution_id: exports_ids_schema.ExecutionId.make(childId),
       cancelled_at: input.cancelled_at,
       reason: input.reason ?? "child fan-out cancelled"
-    }).pipe(Effect.mapError(toClientError)), { discard: true });
+    }).pipe(Effect2.mapError(toClientError)), { discard: true });
     if (result.transitioned) {
-      const max = yield* eventLog.maxSequence(result.fanOut.parent_execution_id).pipe(Effect.mapError(toClientError));
+      const max = yield* eventLog.maxSequence(result.fanOut.parent_execution_id).pipe(Effect2.mapError(toClientError));
       yield* exports_event_log_service.appendIdempotentTo(eventLog, {
         id: exports_ids_schema.EventId.make(`event:${result.fanOut.parent_execution_id}:fan-out:${input.fan_out_id}:terminal`),
         execution_id: result.fanOut.parent_execution_id,
@@ -1508,26 +1536,26 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
         cursor: `${result.fanOut.parent_execution_id}:fan-out:${input.fan_out_id}:terminal`,
         data: { fan_out_id: input.fan_out_id, state: "cancelled" },
         created_at: input.cancelled_at
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }
     return { fan_out: result.fanOut };
   });
-  const sendEnvelope = Effect.fn("Client.runtime.send")(function* (input) {
+  const sendEnvelope = Effect2.fn("Client.runtime.send")(function* (input) {
     const identity = input.idempotency_key ?? input.correlation_key ?? `${input.from}:${input.to}`;
     const executionId = exports_ids_schema.ExecutionId.make(input.correlation_key ?? `execution:send:${identity}`);
     const envelopeId = exports_ids_schema.EnvelopeId.make(`${executionId}:envelope:${identity}`);
     const createdAt = yield* Clock.currentTimeMillis;
-    const maxSequence = yield* eventLog.maxSequence(executionId).pipe(Effect.mapError(toClientError));
+    const maxSequence = yield* eventLog.maxSequence(executionId).pipe(Effect2.mapError(toClientError));
     return yield* envelopes.send({
       envelopeId,
       executionId,
       input,
       eventSequence: maxSequence === undefined ? 0 : maxSequence + 1,
       createdAt
-    }).pipe(Effect.mapError(toClientError));
+    }).pipe(Effect2.mapError(toClientError));
   });
-  const waitOutcomeFrom = Effect.fn("Client.runtime.waitOutcome")(function* (wait) {
-    const reply = wait.state === "resolved" ? yield* envelopeReady.getEnvelope(exports_ids_schema.EnvelopeId.make(`envelope:reply:${wait.id}`)).pipe(Effect.mapError(toClientError)) : undefined;
+  const waitOutcomeFrom = Effect2.fn("Client.runtime.waitOutcome")(function* (wait) {
+    const reply = wait.state === "resolved" ? yield* envelopeReady.getEnvelope(exports_ids_schema.EnvelopeId.make(`envelope:reply:${wait.id}`)).pipe(Effect2.mapError(toClientError)) : undefined;
     return {
       wait_id: wait.id,
       state: wait.state,
@@ -1535,22 +1563,22 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       ...Object.keys(wait.metadata).length === 0 ? {} : { metadata: wait.metadata }
     };
   });
-  const awaitWaitOperation = Effect.fn("Client.runtime.awaitWait")(function* (input) {
-    const current = yield* envelopeReady.getWait(input.wait_id).pipe(Effect.mapError(toClientError));
+  const awaitWaitOperation = Effect2.fn("Client.runtime.awaitWait")(function* (input) {
+    const current = yield* envelopeReady.getWait(input.wait_id).pipe(Effect2.mapError(toClientError));
     if (current === undefined) {
       return yield* new ClientError({ message: `wait ${input.wait_id} not found` });
     }
     if (current.state !== "open")
       return yield* waitOutcomeFrom(current);
-    yield* eventLog.stream({ executionId: input.execution_id }).pipe(Stream.filter((event) => (event.type === "wait.woken" || event.type === "wait.timed_out" || event.type === "wait.cancelled") && event.data?.wait_id === input.wait_id), Stream.take(1), Stream.runDrain, Effect.mapError(toClientError));
-    const terminal = yield* envelopeReady.getWait(input.wait_id).pipe(Effect.mapError(toClientError));
+    yield* eventLog.stream({ executionId: input.execution_id }).pipe(Stream.filter((event) => (event.type === "wait.woken" || event.type === "wait.timed_out" || event.type === "wait.cancelled") && event.data?.wait_id === input.wait_id), Stream.take(1), Stream.runDrain, Effect2.mapError(toClientError));
+    const terminal = yield* envelopeReady.getWait(input.wait_id).pipe(Effect2.mapError(toClientError));
     if (terminal === undefined || terminal.state === "open") {
       return yield* new ClientError({ message: `wait ${input.wait_id} did not reach a terminal state` });
     }
     return yield* waitOutcomeFrom(terminal);
   });
-  const getExecutionOperation = Effect.fn("Client.runtime.getExecution")(function* (id) {
-    const record = yield* executionRepository.get(id).pipe(Effect.mapError(toClientError));
+  const getExecutionOperation = Effect2.fn("Client.runtime.getExecution")(function* (id) {
+    const record = yield* executionRepository.get(id).pipe(Effect2.mapError(toClientError));
     return record === undefined ? undefined : toExecutionView(record);
   });
   const streamExecutionOperation = (input) => executions.stream({
@@ -1558,16 +1586,16 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
     ...input.after_cursor === undefined ? {} : { afterCursor: input.after_cursor },
     ...input.limit === undefined ? {} : { limit: input.limit }
   }).pipe(Stream.mapError(toStreamError));
-  const inspectExecutionOperation = Effect.fn("Client.runtime.inspectExecution")(function* (executionId) {
-    const execution = yield* executionRepository.get(executionId).pipe(Effect.mapError(toClientError));
+  const inspectExecutionOperation = Effect2.fn("Client.runtime.inspectExecution")(function* (executionId) {
+    const execution = yield* executionRepository.get(executionId).pipe(Effect2.mapError(toClientError));
     if (execution === undefined)
       return yield* new ExecutionNotFound({ execution_id: executionId });
-    const openWaits = yield* envelopeReady.listAllWaits({ executionId, state: "open" }).pipe(Effect.mapError(toClientError));
-    const calls = yield* toolCalls.listCalls(executionId).pipe(Effect.mapError(toClientError));
-    const pendingChunks = yield* Effect.forEach(calls, (call) => toolCalls.getResult(call.call.id).pipe(Effect.mapError(toClientError), Effect.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
-    const children = yield* childExecutions.listByExecution(executionId).pipe(Effect.mapError(toClientError));
-    const maxSequence = yield* eventLog.maxSequence(executionId).pipe(Effect.mapError(toClientError));
-    const lastEvent = maxSequence === undefined ? undefined : yield* eventLog.findBySequence({ executionId, sequence: maxSequence }).pipe(Effect.mapError(toClientError), Effect.map(Option.getOrUndefined));
+    const openWaits = yield* envelopeReady.listAllWaits({ executionId, state: "open" }).pipe(Effect2.mapError(toClientError));
+    const calls = yield* toolCalls.listCalls(executionId).pipe(Effect2.mapError(toClientError));
+    const pendingChunks = yield* Effect2.forEach(calls, (call) => toolCalls.getResult(call.call.id).pipe(Effect2.mapError(toClientError), Effect2.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
+    const children = yield* childExecutions.listByExecution(executionId).pipe(Effect2.mapError(toClientError));
+    const maxSequence = yield* eventLog.maxSequence(executionId).pipe(Effect2.mapError(toClientError));
+    const lastEvent = maxSequence === undefined ? undefined : yield* eventLog.findBySequence({ executionId, sequence: maxSequence }).pipe(Effect2.mapError(toClientError), Effect2.map(Option.getOrUndefined));
     return {
       execution_id: execution.id,
       status: execution.status,
@@ -1577,108 +1605,110 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       ...lastEvent === undefined ? {} : { last_event_cursor: lastEvent.cursor }
     };
   });
-  return Service.of({
-    registerEntityKind: (input) => entityRegistry.registerKind(input).pipe(Effect.mapError(toClientError)),
+  return Service2.of({
+    registerEntityKind: (input) => entityRegistry.registerKind(input).pipe(Effect2.mapError(toClientError)),
     getOrCreateEntity: (input) => entities.getOrCreate({
       kind: input.kind,
       key: input.key,
       createdAt: input.created_at,
       ...input.input === undefined ? {} : { input: input.input },
       ...input.metadata === undefined ? {} : { metadata: input.metadata }
-    }).pipe(Effect.mapError(toClientError)),
-    getEntity: (input) => entities.get(input).pipe(Effect.mapError(toClientError)),
+    }).pipe(Effect2.mapError(toClientError)),
+    getEntity: (input) => entities.get(input).pipe(Effect2.mapError(toClientError)),
     destroyEntity: (input) => entities.destroy({
       kind: input.kind,
       key: input.key,
       destroyedAt: input.destroyed_at,
       ...input.reason === undefined ? {} : { reason: input.reason }
-    }).pipe(Effect.mapError(toClientError)),
+    }).pipe(Effect2.mapError(toClientError)),
     listEntities: (input) => entities.list({
       ...input.kind === undefined ? {} : { kind: input.kind },
       ...input.after_kind === undefined ? {} : { afterKind: input.after_kind },
       ...input.after_key === undefined ? {} : { afterKey: input.after_key },
       ...input.limit === undefined ? {} : { limit: input.limit }
-    }).pipe(Effect.mapError(toClientError)),
-    registerWorkflowDefinition: Effect.fn("Client.runtime.registerWorkflowDefinition")(function* (input) {
-      return { record: yield* workflows.register(input).pipe(Effect.mapError(toClientError)) };
+    }).pipe(Effect2.mapError(toClientError)),
+    registerWorkflowDefinition: Effect2.fn("Client.runtime.registerWorkflowDefinition")(function* (input) {
+      return { record: yield* workflows.register(input).pipe(Effect2.mapError(toClientError)) };
     }),
-    getWorkflowDefinitionRevision: Effect.fn("Client.runtime.getWorkflowDefinitionRevision")(function* (id, revision) {
-      return yield* workflows.get(id, revision).pipe(Effect.mapError(toClientError));
+    getWorkflowDefinitionRevision: Effect2.fn("Client.runtime.getWorkflowDefinitionRevision")(function* (id, revision) {
+      return yield* workflows.get(id, revision).pipe(Effect2.mapError(toClientError));
     }),
-    listWorkflowDefinitionRevisions: Effect.fn("Client.runtime.listWorkflowDefinitionRevisions")(function* (id) {
-      return { records: yield* workflows.list(id).pipe(Effect.mapError(toClientError)) };
+    listWorkflowDefinitionRevisions: Effect2.fn("Client.runtime.listWorkflowDefinitionRevisions")(function* (id) {
+      return { records: yield* workflows.list(id).pipe(Effect2.mapError(toClientError)) };
     }),
-    startWorkflowRun: Effect.fn("Client.runtime.startWorkflowRun")(function* (input) {
+    startWorkflowRun: Effect2.fn("Client.runtime.startWorkflowRun")(function* (input) {
+      if (Option.isSome(runtimeCapabilityPolicy))
+        yield* runtimeCapabilityPolicy.value.admit("workflow-definition");
       return yield* Option.match(workflowRuntime, {
         onNone: () => workflows.start(input),
         onSome: (runtime) => runtime.start(input)
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    inspectWorkflowRun: Effect.fn("Client.runtime.inspectWorkflowRun")(function* (id) {
+    inspectWorkflowRun: Effect2.fn("Client.runtime.inspectWorkflowRun")(function* (id) {
       return yield* Option.match(workflowRuntime, {
         onNone: () => workflows.inspect(id),
         onSome: (runtime) => runtime.inspect(id)
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    replayWorkflowRun: Effect.fn("Client.runtime.replayWorkflowRun")(function* (id) {
+    replayWorkflowRun: Effect2.fn("Client.runtime.replayWorkflowRun")(function* (id) {
       return yield* Option.match(workflowRuntime, {
         onNone: () => workflows.listLifecycle(id),
         onSome: (runtime) => runtime.replay(id)
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    cancelWorkflowRun: Effect.fn("Client.runtime.cancelWorkflowRun")(function* (id) {
+    cancelWorkflowRun: Effect2.fn("Client.runtime.cancelWorkflowRun")(function* (id) {
       return yield* Option.match(workflowRuntime, {
-        onNone: () => workflows.cancel(id),
+        onNone: () => workflows.cancel(id).pipe(Effect2.map((result) => result.record)),
         onSome: (runtime) => runtime.cancel(id)
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    registerAgent: Effect.fn("Client.runtime.registerAgent")(function* (input) {
+    registerAgent: Effect2.fn("Client.runtime.registerAgent")(function* (input) {
       const payload = yield* registerAgentPayload(input);
-      const registered = yield* agentRegistry.register(payload).pipe(Effect.mapError(toClientError));
+      const registered = yield* agentRegistry.register(payload).pipe(Effect2.mapError(toClientError));
       if (input.address !== undefined) {
-        yield* addressBook.register(input.address, { kind: "local-agent", route_key: payload.id }).pipe(Effect.mapError(toClientError));
+        yield* addressBook.register(input.address, { kind: "local-agent", route_key: payload.id }).pipe(Effect2.mapError(toClientError));
       }
       return registered;
     }),
-    registerAgentDefinition: Effect.fn("Client.runtime.registerAgentDefinition")(function* (input) {
-      return yield* agentRegistry.register(input).pipe(Effect.mapError(toClientError));
+    registerAgentDefinition: Effect2.fn("Client.runtime.registerAgentDefinition")(function* (input) {
+      return yield* agentRegistry.register(input).pipe(Effect2.mapError(toClientError));
     }),
-    getAgentDefinition: Effect.fn("Client.runtime.getAgentDefinition")(function* (id) {
-      return yield* agentRegistry.get(id).pipe(Effect.mapError(toClientError));
+    getAgentDefinition: Effect2.fn("Client.runtime.getAgentDefinition")(function* (id) {
+      return yield* agentRegistry.get(id).pipe(Effect2.mapError(toClientError));
     }),
-    listAgentDefinitions: Effect.fn("Client.runtime.listAgentDefinitions")(function* () {
-      return yield* agentRegistry.list().pipe(Effect.mapError(toClientError));
+    listAgentDefinitions: Effect2.fn("Client.runtime.listAgentDefinitions")(function* () {
+      return yield* agentRegistry.list().pipe(Effect2.mapError(toClientError));
     }),
-    listAgentDefinitionRevisions: Effect.fn("Client.runtime.listAgentDefinitionRevisions")(function* (id) {
-      return yield* agentRegistry.listRevisions(id).pipe(Effect.mapError(toClientError));
+    listAgentDefinitionRevisions: Effect2.fn("Client.runtime.listAgentDefinitionRevisions")(function* (id) {
+      return yield* agentRegistry.listRevisions(id).pipe(Effect2.mapError(toClientError));
     }),
-    getSkillDefinition: Effect.fn("Client.runtime.getSkillDefinition")(function* (id) {
-      return yield* skillRegistry.get(id).pipe(Effect.mapError(toClientError));
+    getSkillDefinition: Effect2.fn("Client.runtime.getSkillDefinition")(function* (id) {
+      return yield* skillRegistry.get(id).pipe(Effect2.mapError(toClientError));
     }),
-    listSkillDefinitions: Effect.fn("Client.runtime.listSkillDefinitions")(function* () {
-      return yield* skillRegistry.list().pipe(Effect.mapError(toClientError));
+    listSkillDefinitions: Effect2.fn("Client.runtime.listSkillDefinitions")(function* () {
+      return yield* skillRegistry.list().pipe(Effect2.mapError(toClientError));
     }),
-    listSkillDefinitionRevisions: Effect.fn("Client.runtime.listSkillDefinitionRevisions")(function* (id) {
-      return yield* skillRegistry.listRevisions(id).pipe(Effect.mapError(toClientError));
+    listSkillDefinitionRevisions: Effect2.fn("Client.runtime.listSkillDefinitionRevisions")(function* (id) {
+      return yield* skillRegistry.listRevisions(id).pipe(Effect2.mapError(toClientError));
     }),
-    registerAddressBookRoute: Effect.fn("Client.runtime.registerAddressBookRoute")(function* (input) {
+    registerAddressBookRoute: Effect2.fn("Client.runtime.registerAddressBookRoute")(function* (input) {
       yield* rejectReserved(input.address_id, "address:entity:");
-      return yield* addressBook.register(input.address_id, input.route).pipe(Effect.mapError(toClientError));
+      return yield* addressBook.register(input.address_id, input.route).pipe(Effect2.mapError(toClientError));
     }),
-    getAddressBookRoute: Effect.fn("Client.runtime.getAddressBookRoute")(function* (id) {
-      return yield* addressBook.get(id).pipe(Effect.mapError(toClientError));
+    getAddressBookRoute: Effect2.fn("Client.runtime.getAddressBookRoute")(function* (id) {
+      return yield* addressBook.get(id).pipe(Effect2.mapError(toClientError));
     }),
-    listAddressBookRoutes: Effect.fn("Client.runtime.listAddressBookRoutes")(function* () {
-      return yield* addressBook.list().pipe(Effect.mapError(toClientError));
+    listAddressBookRoutes: Effect2.fn("Client.runtime.listAddressBookRoutes")(function* () {
+      return yield* addressBook.list().pipe(Effect2.mapError(toClientError));
     }),
-    startExecution: Effect.fn("Client.runtime.startExecution")(function* (input) {
+    startExecution: Effect2.fn("Client.runtime.startExecution")(function* (input) {
       yield* rejectReserved(input.execution_id, "execution:entity:");
       if (input.session_id !== undefined)
         yield* rejectReserved(input.session_id, "session:entity:");
       const client = makeExecutionClient(input.execution_id);
-      return yield* client.start(input).pipe(Effect.mapError(toClientError));
+      return yield* client.start(input).pipe(Effect2.mapError(toClientError));
     }),
-    startExecutionByAddress: Effect.fn("Client.runtime.startExecutionByAddress")(function* (input) {
+    startExecutionByAddress: Effect2.fn("Client.runtime.startExecutionByAddress")(function* (input) {
       yield* rejectReserved(input.idempotency_key, "entity:");
       if (input.execution_id !== undefined)
         yield* rejectReserved(input.execution_id, "execution:entity:");
@@ -1686,25 +1716,25 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
         yield* rejectReserved(input.session_id, "session:entity:");
       const payload = startExecutionByAddressPayload(input);
       const client = makeExecutionClient(payload.execution_id);
-      return yield* client.start(payload).pipe(Effect.mapError(toClientError));
+      return yield* client.start(payload).pipe(Effect2.mapError(toClientError));
     }),
-    startExecutionByAgentDefinition: Effect.fn("Client.runtime.startExecutionByAgentDefinition")(function* (input) {
+    startExecutionByAgentDefinition: Effect2.fn("Client.runtime.startExecutionByAgentDefinition")(function* (input) {
       yield* rejectReserved(input.idempotency_key, "entity:");
       if (input.execution_id !== undefined)
         yield* rejectReserved(input.execution_id, "execution:entity:");
       if (input.session_id !== undefined)
         yield* rejectReserved(input.session_id, "session:entity:");
-      const definition = yield* agentRegistry.getRevision({ id: input.agent_id, revision: input.agent_revision }).pipe(Effect.mapError(toClientError));
+      const definition = yield* agentRegistry.getRevision({ id: input.agent_id, revision: input.agent_revision }).pipe(Effect2.mapError(toClientError));
       if (definition === undefined) {
-        return yield* Effect.fail(new ClientError({ message: `Agent revision not found: ${input.agent_id}@${input.agent_revision}` }));
+        return yield* Effect2.fail(new ClientError({ message: `Agent revision not found: ${input.agent_id}@${input.agent_revision}` }));
       }
       const payload = startExecutionByAgentDefinitionPayload(input, definition);
       const client = makeExecutionClient(payload.execution_id);
-      return yield* client.start(payload).pipe(Effect.mapError(toClientError));
+      return yield* client.start(payload).pipe(Effect2.mapError(toClientError));
     }),
-    cancelExecution: Effect.fn("Client.runtime.cancelExecution")(function* (input) {
-      const fanOuts = yield* childFanOuts.listNonTerminal(input.execution_id).pipe(Effect.mapError(toClientError));
-      yield* Effect.forEach(fanOuts, (fanOut) => cancelFanOut({
+    cancelExecution: Effect2.fn("Client.runtime.cancelExecution")(function* (input) {
+      const fanOuts = yield* childFanOuts.listNonTerminal(input.execution_id).pipe(Effect2.mapError(toClientError));
+      yield* Effect2.forEach(fanOuts, (fanOut) => cancelFanOut({
         fan_out_id: fanOut.fan_out_id,
         cancelled_at: input.cancelled_at,
         ...input.reason === undefined ? {} : { reason: input.reason }
@@ -1714,10 +1744,10 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
         execution_id: input.execution_id,
         cancelled_at: input.cancelled_at,
         ...input.reason === undefined ? {} : { reason: input.reason }
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    steer: Effect.fn("Client.runtime.steer")(function* (input) {
-      const execution = yield* executionRepository.get(input.execution_id).pipe(Effect.mapError(toClientError));
+    steer: Effect2.fn("Client.runtime.steer")(function* (input) {
+      const execution = yield* executionRepository.get(input.execution_id).pipe(Effect2.mapError(toClientError));
       if (execution === undefined) {
         return yield* new ClientError({ message: `Execution not found: ${input.execution_id}` });
       }
@@ -1729,7 +1759,7 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
         kind: input.kind,
         content: input.content,
         createdAt: input.created_at
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
       return { execution_id: record.executionId, kind: record.kind, sequence: record.sequence };
     }),
     getExecution: getExecutionOperation,
@@ -1739,104 +1769,104 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       inspectExecution: inspectExecutionOperation,
       streamExecution: streamExecutionOperation
     }),
-    listWaits: Effect.fn("Client.runtime.listWaits")(function* (input) {
+    listWaits: Effect2.fn("Client.runtime.listWaits")(function* (input) {
       const records = yield* envelopeReady.listWaits({
         ...input.state === undefined ? {} : { state: input.state },
         ...input.execution_id === undefined ? {} : { executionId: input.execution_id },
         ...input.limit === undefined ? {} : { limit: input.limit }
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
       return records.map(toWaitView);
     }),
-    listExecutions: Effect.fn("Client.runtime.listExecutions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema3.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect.mapError(toClientError));
+    listExecutions: Effect2.fn("Client.runtime.listExecutions")(function* (input) {
+      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect2.mapError(toClientError));
       const result = yield* executionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.status === undefined ? {} : { status: input.status },
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
-      }).pipe(Effect.mapError(toClientError));
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema3.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect2.mapError(toClientError));
       return {
         records: result.records.map(toConversationSummary),
         ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
       };
     }),
-    subscribeTopic: Effect.fn("Client.runtime.subscribeTopic")(function* (input) {
+    subscribeTopic: Effect2.fn("Client.runtime.subscribeTopic")(function* (input) {
       return yield* topicService.subscribe({
         topicAddressId: input.topic_address_id,
         subscriberExecutionId: input.subscriber_execution_id,
         ...input.metadata === undefined ? {} : { metadata: input.metadata }
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    unsubscribeTopic: Effect.fn("Client.runtime.unsubscribeTopic")(function* (input) {
+    unsubscribeTopic: Effect2.fn("Client.runtime.unsubscribeTopic")(function* (input) {
       return yield* topicService.unsubscribe({
         topicAddressId: input.topic_address_id,
         subscriberExecutionId: input.subscriber_execution_id
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    publishTopic: Effect.fn("Client.runtime.publishTopic")(function* (input) {
+    publishTopic: Effect2.fn("Client.runtime.publishTopic")(function* (input) {
       return yield* topicService.publish({
         topicAddressId: input.topic_address_id,
         from: input.from,
         content: input.content,
         ...input.metadata === undefined ? {} : { metadata: input.metadata },
         ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key }
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    listTopicSubscriptions: Effect.fn("Client.runtime.listTopicSubscriptions")(function* (input) {
+    listTopicSubscriptions: Effect2.fn("Client.runtime.listTopicSubscriptions")(function* (input) {
       return yield* topicService.list({
         ...input.topic_address_id === undefined ? {} : { topicAddressId: input.topic_address_id },
         ...input.subscriber_execution_id === undefined ? {} : { subscriberExecutionId: input.subscriber_execution_id }
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    listInboxMessages: Effect.fn("Client.runtime.listInboxMessages")(function* (input) {
+    listInboxMessages: Effect2.fn("Client.runtime.listInboxMessages")(function* (input) {
       return yield* inboxRepository.list({
         executionId: input.execution_id,
         ...input.include_consumed === undefined ? {} : { includeConsumed: input.include_consumed },
         ...input.after_sequence === undefined ? {} : { afterSequence: input.after_sequence },
         ...input.limit === undefined ? {} : { limit: input.limit }
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
     }),
-    listSessions: Effect.fn("Client.runtime.listSessions")(function* (input) {
-      const cursor = input.cursor === undefined ? undefined : yield* Schema3.decodeEffect(SessionCursorFromString)(input.cursor).pipe(Effect.mapError(toClientError));
+    listSessions: Effect2.fn("Client.runtime.listSessions")(function* (input) {
+      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(SessionCursorFromString)(input.cursor).pipe(Effect2.mapError(toClientError));
       const result = yield* sessionRepository.list({
         ...input.root_address_id === undefined ? {} : { rootAddressId: input.root_address_id },
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
-      }).pipe(Effect.mapError(toClientError));
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema3.encodeEffect(SessionCursorFromString)(result.nextCursor).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(SessionCursorFromString)(result.nextCursor).pipe(Effect2.mapError(toClientError));
       return {
         records: result.records.map(toSessionSummary),
         ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
       };
     }),
-    getSession: Effect.fn("Client.runtime.getSession")(function* (input) {
-      const session = yield* sessionRepository.get(input.session_id).pipe(Effect.mapError(toClientError));
+    getSession: Effect2.fn("Client.runtime.getSession")(function* (input) {
+      const session = yield* sessionRepository.get(input.session_id).pipe(Effect2.mapError(toClientError));
       if (session === undefined)
         return yield* new ClientError({ message: `Session not found: ${input.session_id}` });
-      const cursor = input.cursor === undefined ? undefined : yield* Schema3.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect.mapError(toClientError));
+      const cursor = input.cursor === undefined ? undefined : yield* Schema4.decodeEffect(ExecutionCursorFromString)(input.cursor).pipe(Effect2.mapError(toClientError));
       const result = yield* executionRepository.list({
         sessionId: input.session_id,
         ...input.limit === undefined ? {} : { limit: input.limit },
         ...cursor === undefined ? {} : { cursor }
-      }).pipe(Effect.mapError(toClientError));
-      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema3.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
+      const nextCursor = result.nextCursor === undefined ? undefined : yield* Schema4.encodeEffect(ExecutionCursorFromString)(result.nextCursor).pipe(Effect2.mapError(toClientError));
       return {
         session: toSessionSummary(session),
         executions: result.records.map(toConversationSummary),
         ...nextCursor === undefined ? {} : { next_cursor: nextCursor }
       };
     }),
-    replayExecution: Effect.fn("Client.runtime.replayExecution")(function* (input) {
+    replayExecution: Effect2.fn("Client.runtime.replayExecution")(function* (input) {
       const events = yield* eventLog.replay({
         executionId: input.execution_id,
         ...input.after_cursor === undefined ? {} : { afterCursor: input.after_cursor },
         ...input.limit === undefined ? {} : { limit: input.limit }
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
       return { events };
     }),
-    listRunners: Effect.fn("Client.runtime.listRunners")(function* () {
-      const runners = yield* clusterRegistry.listRunners().pipe(Effect.mapError(toClientError));
+    listRunners: Effect2.fn("Client.runtime.listRunners")(function* () {
+      const runners = yield* clusterRegistry.listRunners().pipe(Effect2.mapError(toClientError));
       return {
         runners: runners.map((runner) => ({
           address: runner.address,
@@ -1847,9 +1877,9 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
         total_shards: shardingConfig.shardsPerGroup * shardingConfig.availableShardGroups.length
       };
     }),
-    routeExecution: Effect.fn("Client.runtime.routeExecution")(function* (executionId) {
+    routeExecution: Effect2.fn("Client.runtime.routeExecution")(function* (executionId) {
       const shard = ShardId.toString(sharding.getShardId(EntityId.make(executionId), "execution"));
-      const owner = yield* clusterRegistry.lockOwner(shard).pipe(Effect.mapError(toClientError));
+      const owner = yield* clusterRegistry.lockOwner(shard).pipe(Effect2.mapError(toClientError));
       const runnerAddress = owner ?? null;
       const self = Option.map(shardingConfig.runnerAddress, (address) => `${address.host}:${address.port}`);
       return {
@@ -1860,12 +1890,12 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       };
     }),
     send: sendEnvelope,
-    askEntity: Effect.fn("Client.runtime.askEntity")(function* (input) {
-      const instance = yield* entities.get({ kind: input.kind, key: input.key }).pipe(Effect.mapError(toClientError));
+    askEntity: Effect2.fn("Client.runtime.askEntity")(function* (input) {
+      const instance = yield* entities.get({ kind: input.kind, key: input.key }).pipe(Effect2.mapError(toClientError));
       if (instance === undefined || instance.status === "destroyed") {
         return yield* new EntityNotFound({ kind: input.kind, key: input.key });
       }
-      const encoded = yield* Schema3.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect.mapError(toClientError));
+      const encoded = yield* Schema4.encodeUnknownEffect(input.command.input)(input.input).pipe(Effect2.mapError(toClientError));
       const inputRef = inputSchemaRef(input.command.name);
       const outputRef = outputSchemaRef(input.command.name);
       if (Option.isSome(schemaRegistry)) {
@@ -1912,7 +1942,7 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
           message: "reply carried no decodable content"
         });
       }
-      return yield* Schema3.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect.mapError((issue) => new CommandReplyInvalid({
+      return yield* Schema4.decodeUnknownEffect(input.command.output)(replyValue.value).pipe(Effect2.mapError((issue) => new CommandReplyInvalid({
         command: input.command.name,
         wait_id: outcome.wait_id,
         message: errorMessage(issue)
@@ -1934,49 +1964,49 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
       ...input.session_id === undefined ? {} : { sessionId: input.session_id },
       ...input.status === undefined ? {} : { status: input.status },
       ...input.limit === undefined ? {} : { limit: input.limit }
-    }).pipe(Stream.mapEffect((change) => change._tag === "snapshot" ? change.nextCursor === undefined ? Effect.succeed({
+    }).pipe(Stream.mapEffect((change) => change._tag === "snapshot" ? change.nextCursor === undefined ? Effect2.succeed({
       _tag: "snapshot",
       records: change.records.map(toConversationSummary)
-    }) : encodeExecutionCursor(change.nextCursor).pipe(Effect.map((next_cursor) => ({
+    }) : encodeExecutionCursor(change.nextCursor).pipe(Effect2.map((next_cursor) => ({
       _tag: "snapshot",
       records: change.records.map(toConversationSummary),
       next_cursor
-    }))) : Effect.succeed({
+    }))) : Effect2.succeed({
       _tag: "upsert",
       record: toConversationSummary(change.record)
     })), Stream.mapError(toClientError)),
-    getEntityState: Effect.fn("Client.runtime.getEntityState")((input) => executionState.getRecord(input.execution_id, input.key).pipe(Effect.mapError(toClientError))),
-    putEntityState: Effect.fn("Client.runtime.putEntityState")((input) => executionState.put({
+    getEntityState: Effect2.fn("Client.runtime.getEntityState")((input) => executionState.getRecord(input.execution_id, input.key).pipe(Effect2.mapError(toClientError))),
+    putEntityState: Effect2.fn("Client.runtime.putEntityState")((input) => executionState.put({
       executionId: input.execution_id,
       key: exports_execution_state_service.key(input.key, exports_shared_schema.JsonValue),
       value: input.value,
       ...input.expected_version === undefined ? {} : { expectedVersion: input.expected_version },
       ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
       updatedAt: input.updated_at
-    }).pipe(Effect.mapError((error) => error instanceof exports_execution_state_service.StateVersionConflict ? error : toClientError(error)))),
-    deleteEntityState: Effect.fn("Client.runtime.deleteEntityState")((input) => executionState.remove({
+    }).pipe(Effect2.mapError((error) => error instanceof exports_execution_state_service.StateVersionConflict ? error : toClientError(error)))),
+    deleteEntityState: Effect2.fn("Client.runtime.deleteEntityState")((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(Effect.mapError((error) => error instanceof exports_execution_state_service.StateVersionConflict ? error : toClientError(error)))),
-    listEntityState: Effect.fn("Client.runtime.listEntityState")((input) => executionState.list({
+    }).pipe(Effect2.mapError((error) => error instanceof exports_execution_state_service.StateVersionConflict ? error : toClientError(error)))),
+    listEntityState: Effect2.fn("Client.runtime.listEntityState")((input) => executionState.list({
       executionId: input.execution_id,
       ...input.prefix === undefined ? {} : { prefix: input.prefix },
       ...input.after_key === undefined ? {} : { afterKey: input.after_key },
       ...input.limit === undefined ? {} : { limit: input.limit }
-    }).pipe(Effect.mapError(toClientError))),
-    getPresence: (scope) => presence.list(scope).pipe(Effect.mapError(toClientError)),
+    }).pipe(Effect2.mapError(toClientError))),
+    getPresence: (scope) => presence.list(scope).pipe(Effect2.mapError(toClientError)),
     watchPresence: (scope) => presence.watch(scope).pipe(Stream.mapError(toClientError)),
-    wake: Effect.fn("Client.runtime.wake")(function* (input) {
+    wake: Effect2.fn("Client.runtime.wake")(function* (input) {
       return yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, input);
     }),
-    listPendingApprovals: Effect.fn("Client.runtime.listPendingApprovals")(function* (input) {
-      const records = yield* envelopeReady.listWaits({ executionId: input.execution_id, state: "open" }).pipe(Effect.mapError(toClientError));
+    listPendingApprovals: Effect2.fn("Client.runtime.listPendingApprovals")(function* (input) {
+      const records = yield* envelopeReady.listWaits({ executionId: input.execution_id, state: "open" }).pipe(Effect2.mapError(toClientError));
       return { approvals: records.filter(isToolApprovalWait).map(toPendingToolApproval) };
     }),
-    resolveToolApproval: Effect.fn("Client.runtime.resolveToolApproval")(function* (input) {
+    resolveToolApproval: Effect2.fn("Client.runtime.resolveToolApproval")(function* (input) {
       return yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, {
         wait_id: input.wait_id,
         state: "resolved",
@@ -1987,7 +2017,7 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
         }
       }, "tool-approval");
     }),
-    resolvePermission: Effect.fn("Client.runtime.resolvePermission")(function* (input) {
+    resolvePermission: Effect2.fn("Client.runtime.resolvePermission")(function* (input) {
       return yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, {
         wait_id: input.wait_id,
         state: "resolved",
@@ -1998,18 +2028,18 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
         }
       }, "tool-permission");
     }),
-    listPendingToolCalls: Effect.fn("Client.runtime.listPendingToolCalls")(function* (input) {
+    listPendingToolCalls: Effect2.fn("Client.runtime.listPendingToolCalls")(function* (input) {
       const openWaits = yield* envelopeReady.listAllWaits({
         state: "open",
         ...input.execution_id === undefined ? {} : { executionId: input.execution_id }
-      }).pipe(Effect.mapError(toClientError));
-      const records = yield* Effect.forEach(openWaits.filter((wait) => wait.metadata.kind === "tool-placement"), (wait) => toolCalls.getCall(exports_ids_schema.ToolCallId.make(String(wait.metadata.tool_call_id ?? ""))).pipe(Effect.mapError(toClientError), Effect.map((call) => call?.placement.kind === "client" && call.state === "waiting" ? toPendingToolCall(call) : undefined)));
+      }).pipe(Effect2.mapError(toClientError));
+      const records = yield* Effect2.forEach(openWaits.filter((wait) => wait.metadata.kind === "tool-placement"), (wait) => toolCalls.getCall(exports_ids_schema.ToolCallId.make(String(wait.metadata.tool_call_id ?? ""))).pipe(Effect2.mapError(toClientError), Effect2.map((call) => call?.placement.kind === "client" && call.state === "waiting" ? toPendingToolCall(call) : undefined)));
       const sorted = records.filter((record) => record !== undefined).toSorted((left, right) => left.requested_at - right.requested_at || left.call.id.localeCompare(right.call.id));
       return { tool_calls: input.limit === undefined ? sorted : sorted.slice(0, input.limit) };
     }),
-    fulfillToolCall: Effect.fn("Client.runtime.fulfillToolCall")(function* (input) {
-      const coordinated = yield* coordinateToolTransition(Effect.gen(function* () {
-        const call = yield* toolCalls.getCall(input.tool_call_id).pipe(Effect.mapError(toClientError));
+    fulfillToolCall: Effect2.fn("Client.runtime.fulfillToolCall")(function* (input) {
+      const coordinated = yield* coordinateToolTransition(Effect2.gen(function* () {
+        const call = yield* toolCalls.getCall(input.tool_call_id).pipe(Effect2.mapError(toClientError));
         if (call === undefined || call.executionId !== input.execution_id || call.placement.kind !== "client") {
           return yield* new ClientError({ message: `Client tool call not found: ${input.tool_call_id}` });
         }
@@ -2019,24 +2049,24 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
           callId: input.tool_call_id,
           outcome: input.outcome,
           submittedAt: input.fulfilled_at
-        }).pipe(Effect.mapError(toClientError));
+        }).pipe(Effect2.mapError(toClientError));
         return { wait, accepted };
       }));
       yield* signalToolOutcome(executionRepository, makeExecutionClient, coordinated.wait, input.fulfilled_at);
       return toToolOutcomeAccepted(coordinated.accepted);
     }),
-    claimToolWork: Effect.fn("Client.runtime.claimToolWork")(function* (input) {
+    claimToolWork: Effect2.fn("Client.runtime.claimToolWork")(function* (input) {
       const lease = yield* coordinateToolTransition(toolCalls.claimRemote({
         queue: input.queue,
         workerId: input.worker_id,
         now: input.now,
         claimExpiresAt: input.claim_expires_at
-      }).pipe(Effect.mapError(toClientError)));
+      }).pipe(Effect2.mapError(toClientError)));
       return lease === undefined ? null : toToolWorkLease(lease);
     }),
-    completeToolWork: Effect.fn("Client.runtime.completeToolWork")(function* (input) {
-      const coordinated = yield* coordinateToolTransition(Effect.gen(function* () {
-        const call = yield* toolCalls.getCall(input.tool_call_id).pipe(Effect.mapError(toClientError));
+    completeToolWork: Effect2.fn("Client.runtime.completeToolWork")(function* (input) {
+      const coordinated = yield* coordinateToolTransition(Effect2.gen(function* () {
+        const call = yield* toolCalls.getCall(input.tool_call_id).pipe(Effect2.mapError(toClientError));
         const active = call !== undefined && call.placement.kind === "remote" && call.state === "running" && call.activeAttemptId === input.attempt_id && call.claimOwner === input.worker_id && call.claimExpiresAt !== undefined && call.claimExpiresAt > input.completed_at;
         const acceptedRetry = call !== undefined && call.placement.kind === "remote" && call.state === "submitted" && call.activeAttemptId === input.attempt_id && call.externalOutcome !== undefined;
         if (call === undefined || !active && !acceptedRetry) {
@@ -2049,13 +2079,13 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
           workerId: input.worker_id,
           outcome: input.outcome,
           submittedAt: input.completed_at
-        }).pipe(Effect.mapError(toClientError));
+        }).pipe(Effect2.mapError(toClientError));
         return { wait, accepted };
       }));
       yield* signalToolOutcome(executionRepository, makeExecutionClient, coordinated.wait, input.completed_at);
       return toToolOutcomeAccepted(coordinated.accepted);
     }),
-    releaseToolWork: Effect.fn("Client.runtime.releaseToolWork")(function* (input) {
+    releaseToolWork: Effect2.fn("Client.runtime.releaseToolWork")(function* (input) {
       const call = yield* coordinateToolTransition(toolCalls.releaseRemote({
         callId: input.tool_call_id,
         attemptId: input.attempt_id,
@@ -2063,94 +2093,96 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
         releasedAt: input.released_at,
         nextAvailableAt: input.next_available_at,
         ...input.error === undefined ? {} : { error: input.error }
-      }).pipe(Effect.mapError(toClientError)));
+      }).pipe(Effect2.mapError(toClientError)));
       return {
         tool_call_id: call.call.id,
         state: "waiting",
         next_available_at: call.availableAt
       };
     }),
-    listToolAttempts: Effect.fn("Client.runtime.listToolAttempts")(function* (input) {
-      const attempts = yield* toolCalls.listAttempts(input.tool_call_id).pipe(Effect.mapError(toClientError));
+    listToolAttempts: Effect2.fn("Client.runtime.listToolAttempts")(function* (input) {
+      const attempts = yield* toolCalls.listAttempts(input.tool_call_id).pipe(Effect2.mapError(toClientError));
       return { attempts: attempts.map(toToolAttempt) };
     }),
-    submitInboundEnvelope: Effect.fn("Client.runtime.submitInboundEnvelope")(function* (input) {
-      const envelope = yield* executions.send(input.envelope).pipe(Effect.mapError(toClientError));
+    submitInboundEnvelope: Effect2.fn("Client.runtime.submitInboundEnvelope")(function* (input) {
+      const envelope = yield* executions.send(input.envelope).pipe(Effect2.mapError(toClientError));
       const wakeResult = yield* wakeRuntime(waits, eventLog, executionRepository, makeExecutionClient, input.wake);
       return { envelope, wake: wakeResult };
     }),
-    spawnChildRun: Effect.fn("Client.runtime.spawnChildRun")(function* (input) {
+    spawnChildRun: Effect2.fn("Client.runtime.spawnChildRun")(function* (input) {
       const pin = yield* parentDefinitionPin(executionRepository, input.execution_id);
       const createdAt = yield* Clock.currentTimeMillis;
       const internal = internalSpawnChildRunInput(input, pin, createdAt);
-      const context = yield* exports_child_run_service.resolveForDispatch(internal).pipe(Effect.mapError((error) => new ClientError({ message: error._tag })));
-      const definition = yield* exports_child_run_service.childDefinition(pin.agentSnapshot, context).pipe(Effect.mapError((error) => new ClientError({ message: error._tag })));
-      const coordinated = yield* coordinateChildSpawn(Effect.gen(function* () {
+      const context = yield* exports_child_run_service.resolveForDispatch(internal).pipe(Effect2.mapError((error) => new ClientError({ message: error._tag })));
+      const definition = yield* exports_child_run_service.childDefinition(pin.agentSnapshot, context).pipe(Effect2.mapError((error) => new ClientError({ message: error._tag })));
+      const coordinated = yield* coordinateChildSpawn(Effect2.gen(function* () {
         const existing = yield* reconcileExistingChildSpawn(childExecutions, waits, eventLog, input);
         if (existing !== undefined)
           return existing;
-        const accepted = yield* executions.spawnChildRun(internal).pipe(Effect.mapError(toClientError));
+        const accepted = yield* executions.spawnChildRun(internal).pipe(Effect2.mapError(toClientError));
         const parentWaitId = input.wait === true ? yield* createChildJoinWait(waits, eventLog, internal, accepted, createdAt) : undefined;
         return { accepted, createdAt, parentWaitId };
-      })).pipe(Effect.catch((error) => error.message === "DuplicateChildExecution" ? coordinateChildSpawn(reconcileExistingChildSpawn(childExecutions, waits, eventLog, input).pipe(Effect.flatMap((existing) => existing === undefined ? Effect.fail(new ClientError({ message: `Child execution retry missing: ${input.execution_id}` })) : Effect.succeed(existing)))) : Effect.fail(error)));
+      })).pipe(Effect2.catch((error) => error.message === "DuplicateChildExecution" ? coordinateChildSpawn(reconcileExistingChildSpawn(childExecutions, waits, eventLog, input).pipe(Effect2.flatMap((existing) => existing === undefined ? Effect2.fail(new ClientError({ message: `Child execution retry missing: ${input.execution_id}` })) : Effect2.succeed(existing)))) : Effect2.fail(error)));
       const startPayload = childStartInput(internal, coordinated.accepted, pin, definition, coordinated.createdAt, coordinated.parentWaitId);
       const client = makeExecutionClient(startPayload.execution_id);
-      yield* client.dispatch(startPayload).pipe(Effect.mapError(toClientError));
+      yield* client.dispatch(startPayload).pipe(Effect2.mapError(toClientError));
       return coordinated.accepted;
     }),
-    createChildFanOut: Effect.fn("Client.runtime.createChildFanOut")(function* (input) {
+    createChildFanOut: Effect2.fn("Client.runtime.createChildFanOut")(function* (input) {
+      if (Option.isSome(runtimeCapabilityPolicy))
+        yield* runtimeCapabilityPolicy.value.admit("fan-out");
       if (Option.isNone(childFanOutRuntime)) {
         return yield* new ClientError({
           message: "Child fan-out runtime unavailable; provide ChildFanOutRuntime.Service to Client.layerFromRuntime"
         });
       }
-      return yield* childFanOutRuntime.value.create(input).pipe(Effect.mapError(toClientError));
+      return yield* childFanOutRuntime.value.create(input).pipe(Effect2.mapError(toClientError));
     }),
-    cancelChildFanOut: Effect.fn("Client.runtime.cancelChildFanOut")(function* (input) {
+    cancelChildFanOut: Effect2.fn("Client.runtime.cancelChildFanOut")(function* (input) {
       return yield* cancelFanOut(input);
     }),
-    inspectChildFanOut: Effect.fn("Client.runtime.inspectChildFanOut")(function* (input) {
+    inspectChildFanOut: Effect2.fn("Client.runtime.inspectChildFanOut")(function* (input) {
       const fanOut = yield* Option.match(childFanOutRuntime, {
         onNone: () => childFanOuts.get(input.fan_out_id),
         onSome: (runtime) => runtime.inspect(input.fan_out_id)
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
       return { fan_out: fanOut ?? null };
     }),
-    claimEnvelopeReady: Effect.fn("Client.runtime.claimEnvelopeReady")(function* (input) {
+    claimEnvelopeReady: Effect2.fn("Client.runtime.claimEnvelopeReady")(function* (input) {
       return yield* envelopeReady.claimReady({
         routeType: input.route_type,
         ...input.route_key === undefined ? {} : { routeKey: input.route_key },
         workerId: input.worker_id,
         now: input.now,
         claimExpiresAt: input.claim_expires_at
-      }).pipe(Effect.map((record) => record === undefined ? null : toLease(record)), Effect.mapError(toClientError));
+      }).pipe(Effect2.map((record) => record === undefined ? null : toLease(record)), Effect2.mapError(toClientError));
     }),
-    ackEnvelopeReady: Effect.fn("Client.runtime.ackEnvelopeReady")(function* (input) {
+    ackEnvelopeReady: Effect2.fn("Client.runtime.ackEnvelopeReady")(function* (input) {
       return yield* envelopeReady.ackReady({
         id: input.envelope_ready_id,
         workerId: input.worker_id,
         now: input.acknowledged_at
-      }).pipe(Effect.map((record) => ({
+      }).pipe(Effect2.map((record) => ({
         envelope_ready_id: record.id,
         state: "acknowledged",
         acknowledged_at: record.acknowledgedAt ?? input.acknowledged_at
-      })), Effect.mapError(toClientError));
+      })), Effect2.mapError(toClientError));
     }),
-    releaseEnvelopeReady: Effect.fn("Client.runtime.releaseEnvelopeReady")(function* (input) {
+    releaseEnvelopeReady: Effect2.fn("Client.runtime.releaseEnvelopeReady")(function* (input) {
       return yield* envelopeReady.releaseReady({
         id: input.envelope_ready_id,
         workerId: input.worker_id,
         nextAvailableAt: input.next_available_at,
         ...input.error === undefined ? {} : { error: input.error }
-      }).pipe(Effect.map((record) => ({
+      }).pipe(Effect2.map((record) => ({
         envelope_ready_id: record.id,
         state: "ready",
         next_available_at: record.availableAt
-      })), Effect.mapError(toClientError));
+      })), Effect2.mapError(toClientError));
     }),
-    createSchedule: Effect.fn("Client.runtime.createSchedule")(function* (input) {
+    createSchedule: Effect2.fn("Client.runtime.createSchedule")(function* (input) {
       if (input.cron_expr !== undefined) {
-        yield* exports_scheduler_service.parseCron(input.cron_expr).pipe(Effect.mapError(toClientError));
+        yield* exports_scheduler_service.parseCron(input.cron_expr).pipe(Effect2.mapError(toClientError));
       }
       const createdAt = yield* Clock.currentTimeMillis;
       const schedule = yield* schedules.create({
@@ -2165,287 +2197,603 @@ var layerFromRuntime = Layer.effect(Service, Effect.gen(function* () {
         ...input.input === undefined ? {} : { input: input.input },
         ...input.idempotency_key === undefined ? {} : { idempotencyKey: input.idempotency_key },
         ...input.metadata === undefined ? {} : { metadata: input.metadata }
-      }).pipe(Effect.mapError(toClientError));
+      }).pipe(Effect2.mapError(toClientError));
       return { schedule };
     }),
-    cancelSchedule: Effect.fn("Client.runtime.cancelSchedule")(function* (input) {
-      const schedule = yield* schedules.cancel({ id: input.schedule_id, cancelledAt: input.cancelled_at }).pipe(Effect.mapError(toClientError));
+    cancelSchedule: Effect2.fn("Client.runtime.cancelSchedule")(function* (input) {
+      const schedule = yield* schedules.cancel({ id: input.schedule_id, cancelledAt: input.cancelled_at }).pipe(Effect2.mapError(toClientError));
       return { schedule };
     }),
-    listSchedules: Effect.fn("Client.runtime.listSchedules")(function* (input) {
-      const records = yield* schedules.list(input.state === undefined ? {} : { state: input.state }).pipe(Effect.mapError(toClientError));
+    listSchedules: Effect2.fn("Client.runtime.listSchedules")(function* (input) {
+      const records = yield* schedules.list(input.state === undefined ? {} : { state: input.state }).pipe(Effect2.mapError(toClientError));
       return { schedules: records };
     })
   });
 }));
-var testLayer = (implementation) => Layer.succeed(Service, Service.of({
+var testLayer = (implementation) => Layer2.succeed(Service2, Service2.of({
   ...implementation,
   followExecution: implementation.followExecution ?? followExecutionFrom({
     getExecution: implementation.getExecution,
     inspectExecution: implementation.inspectExecution,
     streamExecution: implementation.streamExecution
   }),
-  registerEntityKind: implementation.registerEntityKind ?? ((input) => Effect.succeed(input)),
-  getOrCreateEntity: implementation.getOrCreateEntity ?? (() => Effect.fail(new ClientError({ message: "Entity service unavailable" }))),
-  getEntity: implementation.getEntity ?? (() => Effect.succeed(undefined)),
-  destroyEntity: implementation.destroyEntity ?? (() => Effect.fail(new ClientError({ message: "Entity service unavailable" }))),
-  listEntities: implementation.listEntities ?? (() => Effect.succeed([])),
+  registerEntityKind: implementation.registerEntityKind ?? ((input) => Effect2.succeed(input)),
+  getOrCreateEntity: implementation.getOrCreateEntity ?? (() => Effect2.fail(new ClientError({ message: "Entity service unavailable" }))),
+  getEntity: implementation.getEntity ?? (() => Effect2.succeed(undefined)),
+  destroyEntity: implementation.destroyEntity ?? (() => Effect2.fail(new ClientError({ message: "Entity service unavailable" }))),
+  listEntities: implementation.listEntities ?? (() => Effect2.succeed([])),
   streamSession: implementation.streamSession ?? (() => Stream.empty),
   watchExecutions: implementation.watchExecutions ?? (() => Stream.empty),
-  getPresence: implementation.getPresence ?? ((scope) => Effect.succeed({ scope, entries: [], observed_at: 0 })),
+  getPresence: implementation.getPresence ?? ((scope) => Effect2.succeed({ scope, entries: [], observed_at: 0 })),
   watchPresence: implementation.watchPresence ?? (() => Stream.empty),
-  registerWorkflowDefinition: implementation.registerWorkflowDefinition ?? (() => Effect.die("registerWorkflowDefinition not implemented")),
-  getWorkflowDefinitionRevision: implementation.getWorkflowDefinitionRevision ?? (() => Effect.die("getWorkflowDefinitionRevision not implemented")),
-  listWorkflowDefinitionRevisions: implementation.listWorkflowDefinitionRevisions ?? (() => Effect.die("listWorkflowDefinitionRevisions not implemented")),
-  startWorkflowRun: implementation.startWorkflowRun ?? (() => Effect.die("startWorkflowRun not implemented")),
-  inspectWorkflowRun: implementation.inspectWorkflowRun ?? (() => Effect.die("inspectWorkflowRun not implemented")),
-  replayWorkflowRun: implementation.replayWorkflowRun ?? (() => Effect.die("replayWorkflowRun not implemented")),
-  cancelWorkflowRun: implementation.cancelWorkflowRun ?? (() => Effect.die("cancelWorkflowRun not implemented"))
+  registerWorkflowDefinition: implementation.registerWorkflowDefinition ?? (() => Effect2.die("registerWorkflowDefinition not implemented")),
+  getWorkflowDefinitionRevision: implementation.getWorkflowDefinitionRevision ?? (() => Effect2.die("getWorkflowDefinitionRevision not implemented")),
+  listWorkflowDefinitionRevisions: implementation.listWorkflowDefinitionRevisions ?? (() => Effect2.die("listWorkflowDefinitionRevisions not implemented")),
+  startWorkflowRun: implementation.startWorkflowRun ?? (() => Effect2.die("startWorkflowRun not implemented")),
+  inspectWorkflowRun: implementation.inspectWorkflowRun ?? (() => Effect2.die("inspectWorkflowRun not implemented")),
+  replayWorkflowRun: implementation.replayWorkflowRun ?? (() => Effect2.die("replayWorkflowRun not implemented")),
+  cancelWorkflowRun: implementation.cancelWorkflowRun ?? (() => Effect2.die("cancelWorkflowRun not implemented"))
 }));
-var registerAgentDefinition = Effect.fn("Client.registerAgentDefinition.call")(function* (input) {
-  const service = yield* Service;
+var registerAgentDefinition = Effect2.fn("Client.registerAgentDefinition.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.registerAgentDefinition(input);
 });
-var registerEntityKind = Effect.fn("Client.registerEntityKind.call")(function* (input) {
-  const service = yield* Service;
+var registerEntityKind = Effect2.fn("Client.registerEntityKind.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.registerEntityKind(input);
 });
-var getOrCreateEntity = Effect.fn("Client.getOrCreateEntity.call")(function* (input) {
-  const service = yield* Service;
+var getOrCreateEntity = Effect2.fn("Client.getOrCreateEntity.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.getOrCreateEntity(input);
 });
-var getEntity = Effect.fn("Client.getEntity.call")(function* (input) {
-  const service = yield* Service;
+var getEntity = Effect2.fn("Client.getEntity.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.getEntity(input);
 });
-var destroyEntity = Effect.fn("Client.destroyEntity.call")(function* (input) {
-  const service = yield* Service;
+var destroyEntity = Effect2.fn("Client.destroyEntity.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.destroyEntity(input);
 });
-var listEntities = Effect.fn("Client.listEntities.call")(function* (input) {
-  const service = yield* Service;
+var listEntities = Effect2.fn("Client.listEntities.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listEntities(input);
 });
-var registerAgent = Effect.fn("Client.registerAgent.call")(function* (input) {
-  const service = yield* Service;
+var registerAgent = Effect2.fn("Client.registerAgent.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.registerAgent(input);
 });
-var getAgentDefinition = Effect.fn("Client.getAgentDefinition.call")(function* (id) {
-  const service = yield* Service;
+var getAgentDefinition = Effect2.fn("Client.getAgentDefinition.call")(function* (id) {
+  const service = yield* Service2;
   return yield* service.getAgentDefinition(id);
 });
-var listAgentDefinitions = Effect.fn("Client.listAgentDefinitions.call")(function* () {
-  const service = yield* Service;
+var listAgentDefinitions = Effect2.fn("Client.listAgentDefinitions.call")(function* () {
+  const service = yield* Service2;
   return yield* service.listAgentDefinitions();
 });
-var listAgentDefinitionRevisions = Effect.fn("Client.listAgentDefinitionRevisions.call")(function* (id) {
-  const service = yield* Service;
+var listAgentDefinitionRevisions = Effect2.fn("Client.listAgentDefinitionRevisions.call")(function* (id) {
+  const service = yield* Service2;
   return yield* service.listAgentDefinitionRevisions(id);
 });
-var getSkillDefinition = Effect.fn("Client.getSkillDefinition.call")(function* (id) {
-  const service = yield* Service;
+var getSkillDefinition = Effect2.fn("Client.getSkillDefinition.call")(function* (id) {
+  const service = yield* Service2;
   return yield* service.getSkillDefinition(id);
 });
-var listSkillDefinitions = Effect.fn("Client.listSkillDefinitions.call")(function* () {
-  const service = yield* Service;
+var listSkillDefinitions = Effect2.fn("Client.listSkillDefinitions.call")(function* () {
+  const service = yield* Service2;
   return yield* service.listSkillDefinitions();
 });
-var listSkillDefinitionRevisions = Effect.fn("Client.listSkillDefinitionRevisions.call")(function* (id) {
-  const service = yield* Service;
+var listSkillDefinitionRevisions = Effect2.fn("Client.listSkillDefinitionRevisions.call")(function* (id) {
+  const service = yield* Service2;
   return yield* service.listSkillDefinitionRevisions(id);
 });
-var registerAddressBookRoute = Effect.fn("Client.registerAddressBookRoute.call")(function* (input) {
-  const service = yield* Service;
+var registerAddressBookRoute = Effect2.fn("Client.registerAddressBookRoute.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.registerAddressBookRoute(input);
 });
-var getAddressBookRoute = Effect.fn("Client.getAddressBookRoute.call")(function* (id) {
-  const service = yield* Service;
+var getAddressBookRoute = Effect2.fn("Client.getAddressBookRoute.call")(function* (id) {
+  const service = yield* Service2;
   return yield* service.getAddressBookRoute(id);
 });
-var listAddressBookRoutes = Effect.fn("Client.listAddressBookRoutes.call")(function* () {
-  const service = yield* Service;
+var listAddressBookRoutes = Effect2.fn("Client.listAddressBookRoutes.call")(function* () {
+  const service = yield* Service2;
   return yield* service.listAddressBookRoutes();
 });
-var startExecution = Effect.fn("Client.startExecution.call")(function* (input) {
-  const service = yield* Service;
+var startExecution = Effect2.fn("Client.startExecution.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.startExecution(input);
 });
-var startExecutionByAddress = Effect.fn("Client.startExecutionByAddress.call")(function* (input) {
-  const service = yield* Service;
+var startExecutionByAddress = Effect2.fn("Client.startExecutionByAddress.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.startExecutionByAddress(input);
 });
-var startExecutionByAgentDefinition = Effect.fn("Client.startExecutionByAgentDefinition.call")(function* (input) {
-  const service = yield* Service;
+var startExecutionByAgentDefinition = Effect2.fn("Client.startExecutionByAgentDefinition.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.startExecutionByAgentDefinition(input);
 });
-var cancelExecution = Effect.fn("Client.cancelExecution.call")(function* (input) {
-  const service = yield* Service;
+var cancelExecution = Effect2.fn("Client.cancelExecution.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.cancelExecution(input);
 });
-var steer = Effect.fn("Client.steer.call")(function* (input) {
-  const service = yield* Service;
+var steer = Effect2.fn("Client.steer.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.steer(input);
 });
-var getExecution = Effect.fn("Client.getExecution.call")(function* (id) {
-  const service = yield* Service;
+var getExecution = Effect2.fn("Client.getExecution.call")(function* (id) {
+  const service = yield* Service2;
   return yield* service.getExecution(id);
 });
-var listExecutions = Effect.fn("Client.listExecutions.call")(function* (input) {
-  const service = yield* Service;
+var listExecutions = Effect2.fn("Client.listExecutions.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listExecutions(input);
 });
-var listSessions = Effect.fn("Client.listSessions.call")(function* (input) {
-  const service = yield* Service;
+var listSessions = Effect2.fn("Client.listSessions.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listSessions(input);
 });
-var getSession = Effect.fn("Client.getSession.call")(function* (input) {
-  const service = yield* Service;
+var getSession = Effect2.fn("Client.getSession.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.getSession(input);
 });
-var listWaits = Effect.fn("Client.listWaits.call")(function* (input) {
-  const service = yield* Service;
+var listWaits = Effect2.fn("Client.listWaits.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listWaits(input);
 });
-var replayExecution = Effect.fn("Client.replayExecution.call")(function* (input) {
-  const service = yield* Service;
+var replayExecution = Effect2.fn("Client.replayExecution.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.replayExecution(input);
 });
-var listRunners = Effect.fn("Client.listRunners.call")(function* () {
-  const service = yield* Service;
+var listRunners = Effect2.fn("Client.listRunners.call")(function* () {
+  const service = yield* Service2;
   return yield* service.listRunners();
 });
-var routeExecution = Effect.fn("Client.routeExecution.call")(function* (executionId) {
-  const service = yield* Service;
+var routeExecution = Effect2.fn("Client.routeExecution.call")(function* (executionId) {
+  const service = yield* Service2;
   return yield* service.routeExecution(executionId);
 });
-var subscribeTopic = Effect.fn("Client.subscribeTopic.call")(function* (input) {
-  const service = yield* Service;
+var subscribeTopic = Effect2.fn("Client.subscribeTopic.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.subscribeTopic(input);
 });
-var unsubscribeTopic = Effect.fn("Client.unsubscribeTopic.call")(function* (input) {
-  const service = yield* Service;
+var unsubscribeTopic = Effect2.fn("Client.unsubscribeTopic.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.unsubscribeTopic(input);
 });
-var publishTopic = Effect.fn("Client.publishTopic.call")(function* (input) {
-  const service = yield* Service;
+var publishTopic = Effect2.fn("Client.publishTopic.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.publishTopic(input);
 });
-var listTopicSubscriptions = Effect.fn("Client.listTopicSubscriptions.call")(function* (input) {
-  const service = yield* Service;
+var listTopicSubscriptions = Effect2.fn("Client.listTopicSubscriptions.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listTopicSubscriptions(input);
 });
-var listInboxMessages = Effect.fn("Client.listInboxMessages.call")(function* (input) {
-  const service = yield* Service;
+var listInboxMessages = Effect2.fn("Client.listInboxMessages.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listInboxMessages(input);
 });
-var inspectExecution = Effect.fn("Client.inspectExecution.call")(function* (executionId) {
-  const service = yield* Service;
+var inspectExecution = Effect2.fn("Client.inspectExecution.call")(function* (executionId) {
+  const service = yield* Service2;
   return yield* service.inspectExecution(executionId);
 });
-var send = Effect.fn("Client.send.call")(function* (input) {
-  const service = yield* Service;
+var send = Effect2.fn("Client.send.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.send(input);
 });
-var streamExecution = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.streamExecution(input))));
-var followExecution = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.followExecution(input))));
-var streamSession = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.streamSession(input))));
-var watchExecutions = (input) => Stream.unwrap(Service.pipe(Effect.map((service) => service.watchExecutions(input))));
-var getPresence = Effect.fn("Client.getPresence.call")(function* (scope) {
-  const service = yield* Service;
+var streamExecution = (input) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.streamExecution(input))));
+var followExecution = (input) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.followExecution(input))));
+var streamSession = (input) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.streamSession(input))));
+var watchExecutions = (input) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.watchExecutions(input))));
+var getPresence = Effect2.fn("Client.getPresence.call")(function* (scope) {
+  const service = yield* Service2;
   return yield* service.getPresence(scope);
 });
-var watchPresence = (scope) => Stream.unwrap(Service.pipe(Effect.map((service) => service.watchPresence(scope))));
-var wake = Effect.fn("Client.wake.call")(function* (input) {
-  const service = yield* Service;
+var watchPresence = (scope) => Stream.unwrap(Service2.pipe(Effect2.map((service) => service.watchPresence(scope))));
+var wake = Effect2.fn("Client.wake.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.wake(input);
 });
-var listPendingApprovals = Effect.fn("Client.listPendingApprovals.call")(function* (input) {
-  const service = yield* Service;
+var listPendingApprovals = Effect2.fn("Client.listPendingApprovals.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listPendingApprovals(input);
 });
-var resolveToolApproval = Effect.fn("Client.resolveToolApproval.call")(function* (input) {
-  const service = yield* Service;
+var resolveToolApproval = Effect2.fn("Client.resolveToolApproval.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.resolveToolApproval(input);
 });
-var resolvePermission = Effect.fn("Client.resolvePermission.call")(function* (input) {
-  const service = yield* Service;
+var resolvePermission = Effect2.fn("Client.resolvePermission.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.resolvePermission(input);
 });
-var listPendingToolCalls = Effect.fn("Client.listPendingToolCalls.call")(function* (input) {
-  const service = yield* Service;
+var listPendingToolCalls = Effect2.fn("Client.listPendingToolCalls.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listPendingToolCalls(input);
 });
-var fulfillToolCall = Effect.fn("Client.fulfillToolCall.call")(function* (input) {
-  const service = yield* Service;
+var fulfillToolCall = Effect2.fn("Client.fulfillToolCall.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.fulfillToolCall(input);
 });
-var claimToolWork = Effect.fn("Client.claimToolWork.call")(function* (input) {
-  const service = yield* Service;
+var claimToolWork = Effect2.fn("Client.claimToolWork.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.claimToolWork(input);
 });
-var completeToolWork = Effect.fn("Client.completeToolWork.call")(function* (input) {
-  const service = yield* Service;
+var completeToolWork = Effect2.fn("Client.completeToolWork.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.completeToolWork(input);
 });
-var releaseToolWork = Effect.fn("Client.releaseToolWork.call")(function* (input) {
-  const service = yield* Service;
+var releaseToolWork = Effect2.fn("Client.releaseToolWork.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.releaseToolWork(input);
 });
-var listToolAttempts = Effect.fn("Client.listToolAttempts.call")(function* (input) {
-  const service = yield* Service;
+var listToolAttempts = Effect2.fn("Client.listToolAttempts.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listToolAttempts(input);
 });
-var submitInboundEnvelope = Effect.fn("Client.submitInboundEnvelope.call")(function* (input) {
-  const service = yield* Service;
+var submitInboundEnvelope = Effect2.fn("Client.submitInboundEnvelope.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.submitInboundEnvelope(input);
 });
-var spawnChildRun = Effect.fn("Client.spawnChildRun.call")(function* (input) {
-  const service = yield* Service;
+var spawnChildRun = Effect2.fn("Client.spawnChildRun.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.spawnChildRun(input);
 });
-var createChildFanOut = Effect.fn("Client.createChildFanOut.call")(function* (input) {
-  const service = yield* Service;
+var createChildFanOut = Effect2.fn("Client.createChildFanOut.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.createChildFanOut(input);
 });
-var cancelChildFanOut = Effect.fn("Client.cancelChildFanOut.call")(function* (input) {
-  const service = yield* Service;
+var cancelChildFanOut = Effect2.fn("Client.cancelChildFanOut.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.cancelChildFanOut(input);
 });
-var inspectChildFanOut = Effect.fn("Client.inspectChildFanOut.call")(function* (input) {
-  const service = yield* Service;
+var inspectChildFanOut = Effect2.fn("Client.inspectChildFanOut.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.inspectChildFanOut(input);
 });
-var claimEnvelopeReady = Effect.fn("Client.claimEnvelopeReady.call")(function* (input) {
-  const service = yield* Service;
+var claimEnvelopeReady = Effect2.fn("Client.claimEnvelopeReady.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.claimEnvelopeReady(input);
 });
-var ackEnvelopeReady = Effect.fn("Client.ackEnvelopeReady.call")(function* (input) {
-  const service = yield* Service;
+var ackEnvelopeReady = Effect2.fn("Client.ackEnvelopeReady.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.ackEnvelopeReady(input);
 });
-var releaseEnvelopeReady = Effect.fn("Client.releaseEnvelopeReady.call")(function* (input) {
-  const service = yield* Service;
+var releaseEnvelopeReady = Effect2.fn("Client.releaseEnvelopeReady.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.releaseEnvelopeReady(input);
 });
-var createSchedule = Effect.fn("Client.createSchedule.call")(function* (input) {
-  const service = yield* Service;
+var createSchedule = Effect2.fn("Client.createSchedule.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.createSchedule(input);
 });
-var cancelSchedule = Effect.fn("Client.cancelSchedule.call")(function* (input) {
-  const service = yield* Service;
+var cancelSchedule = Effect2.fn("Client.cancelSchedule.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.cancelSchedule(input);
 });
-var listSchedules = Effect.fn("Client.listSchedules.call")(function* (input) {
-  const service = yield* Service;
+var listSchedules = Effect2.fn("Client.listSchedules.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.listSchedules(input);
 });
-var askEntity = Effect.fn("Client.askEntity.call")(function* (input) {
-  const service = yield* Service;
+var askEntity = Effect2.fn("Client.askEntity.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.askEntity(input);
 });
-var awaitWait = Effect.fn("Client.awaitWait.call")(function* (input) {
-  const service = yield* Service;
+var awaitWait = Effect2.fn("Client.awaitWait.call")(function* (input) {
+  const service = yield* Service2;
   return yield* service.awaitWait(input);
 });
 
-export { exports_operation, exports_command, Service, exports_client };
+// src/runtime.ts
+var exports_runtime = {};
+__export(exports_runtime, {
+  makeDatabaseIdentity: () => makeDatabaseIdentity,
+  layerRunner: () => layerRunner,
+  layerEmbedded: () => layerEmbedded,
+  layerClient: () => layerClient,
+  UnsupportedTopology: () => UnsupportedTopology,
+  SqlFailure: () => SqlFailure,
+  SqlDialect: () => SqlDialect,
+  Service: () => Service4,
+  SchemaHeadMismatch: () => SchemaHeadMismatch,
+  RuntimeTopologyError: () => RuntimeTopologyError,
+  RuntimeTopologyCause: () => RuntimeTopologyCause,
+  RuntimeReadinessError: () => RuntimeReadinessError,
+  RuntimeReadinessCause: () => RuntimeReadinessCause,
+  RuntimeMigrationError: () => RuntimeMigrationError,
+  RuntimeMigrationCause: () => RuntimeMigrationCause,
+  RuntimeDatabase: () => exports_runtime_database,
+  RuntimeConfigurationError: () => RuntimeConfigurationError,
+  RuntimeConfigurationCause: () => RuntimeConfigurationCause,
+  RuntimeCapabilityUnavailable: () => RuntimeCapabilityUnavailable,
+  NotificationFailure: () => NotificationFailure,
+  MigratorError: () => MigratorError,
+  HostUnavailable: () => HostUnavailable,
+  HostLayerError: () => HostLayerError,
+  Dialect: () => Dialect,
+  DatabaseIdentity: () => DatabaseIdentity,
+  DatabaseDialectMismatch: () => DatabaseDialectMismatch,
+  DatabaseDialect: () => DatabaseDialect,
+  DatabaseAlreadyOwned: () => DatabaseAlreadyOwned,
+  ConfigFailure: () => ConfigFailure,
+  ClusterFailure: () => ClusterFailure
+});
+import { Cause, Context as Context4, Effect as Effect3, Layer as Layer3, Schema as Schema5 } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+
+// src/runtime-database.ts
+var exports_runtime_database = {};
+__export(exports_runtime_database, {
+  Service: () => Service3,
+  Dialect: () => Dialect
+});
+import { Context as Context3 } from "effect";
+
+class Service3 extends Context3.Service()("@relayfx/sdk/RuntimeDatabase") {
+}
+
+// src/runtime.ts
+var DatabaseIdentity = Schema5.NonEmptyString.pipe(Schema5.brand("@relayfx/sdk/DatabaseIdentity"));
+var makeDatabaseIdentity = Schema5.decodeUnknownSync(DatabaseIdentity);
+var Dialect = Schema5.Literals(["pg", "mysql", "sqlite"]);
+var DatabaseDialect = Symbol("@relayfx/sdk/DatabaseDialect");
+
+class HostLayerError extends Schema5.TaggedErrorClass()("HostLayerError", {
+  service: Schema5.String,
+  reason: Schema5.String
+}) {
+}
+
+class ConfigFailure extends Schema5.TaggedErrorClass()("ConfigFailure", {
+  reason: Schema5.String
+}) {
+}
+
+class NotificationFailure extends Schema5.TaggedErrorClass()("NotificationFailure", {
+  reason: Schema5.String
+}) {
+}
+
+class ClusterFailure extends Schema5.TaggedErrorClass()("ClusterFailure", {
+  reason: Schema5.String
+}) {
+}
+
+class SqlFailure extends Schema5.TaggedErrorClass()("SqlFailure", {
+  category: Schema5.Literals(["connection", "statement", "unknown"]),
+  operation: Schema5.Literals(["acquire", "migrate", "verify", "notify", "readiness"]),
+  retryable: Schema5.Boolean
+}) {
+}
+var SqlDialect = Schema5.Literals(["sqlite", "pg", "mysql", "mssql", "clickhouse"]);
+
+class DatabaseDialectMismatch extends Schema5.TaggedErrorClass()("DatabaseDialectMismatch", { expected: Dialect, actual: SqlDialect }) {
+}
+
+class DatabaseAlreadyOwned extends Schema5.TaggedErrorClass()("DatabaseAlreadyOwned", {
+  databaseIdentity: DatabaseIdentity
+}) {
+}
+
+class UnsupportedTopology extends Schema5.TaggedErrorClass()("UnsupportedTopology", {
+  reason: Schema5.String
+}) {
+}
+
+class MigratorError extends Schema5.TaggedErrorClass()("MigratorError", {
+  reason: Schema5.String
+}) {
+}
+
+class SchemaHeadMismatch extends Schema5.TaggedErrorClass()("SchemaHeadMismatch", {
+  expected: Schema5.String,
+  actual: Schema5.String
+}) {
+}
+
+class HostUnavailable extends Schema5.TaggedErrorClass()("HostUnavailable", {
+  host: Schema5.String,
+  reason: Schema5.String
+}) {
+}
+var RuntimeConfigurationCause = Schema5.Union([
+  ConfigFailure,
+  HostLayerError
+]);
+var RuntimeTopologyCause = Schema5.Union([
+  ClusterFailure,
+  DatabaseDialectMismatch,
+  DatabaseAlreadyOwned,
+  UnsupportedTopology
+]);
+var RuntimeMigrationCause = Schema5.Union([
+  SqlFailure,
+  MigratorError,
+  SchemaHeadMismatch
+]);
+var RuntimeReadinessCause = Schema5.Union([
+  SqlFailure,
+  NotificationFailure,
+  ClusterFailure,
+  HostUnavailable
+]);
+
+class RuntimeConfigurationError extends Schema5.TaggedErrorClass()("RuntimeConfigurationError", {
+  setting: Schema5.String,
+  nextAction: Schema5.Literals(["provide-setting", "provide-host-layer"]),
+  cause: RuntimeConfigurationCause
+}) {
+}
+
+class RuntimeTopologyError extends Schema5.TaggedErrorClass()("RuntimeTopologyError", {
+  dialect: Dialect,
+  role: Schema5.Literals(["embedded", "runner", "client"]),
+  nextAction: Schema5.Literals([
+    "use-embedded",
+    "use-postgres-or-mysql",
+    "use-client-constructor",
+    "reuse-runtime",
+    "use-different-database"
+  ]),
+  cause: RuntimeTopologyCause
+}) {
+}
+
+class RuntimeMigrationError extends Schema5.TaggedErrorClass()("RuntimeMigrationError", {
+  dialect: Dialect,
+  phase: Schema5.Literals(["apply", "verify"]),
+  nextAction: Schema5.Literals(["retry", "inspect-schema", "run-compatible-release"]),
+  cause: RuntimeMigrationCause
+}) {
+}
+
+class RuntimeReadinessError extends Schema5.TaggedErrorClass()("RuntimeReadinessError", {
+  phase: Schema5.Literals(["database", "notification", "cluster", "hosts"]),
+  cause: RuntimeReadinessCause
+}) {
+}
+
+class Service4 extends Context4.Service()("@relayfx/sdk/Runtime") {
+}
+var isAcquisitionError = (error) => typeof error === "object" && error !== null && ("_tag" in error) && (error._tag === "RuntimeConfigurationError" || error._tag === "RuntimeTopologyError" || error._tag === "RuntimeMigrationError");
+var normalizeHost = (layer2, role, dialect) => {
+  const normalize = (error) => {
+    if (isAcquisitionError(error))
+      return error;
+    if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "ClusterConfigMismatch") {
+      const clusterFailure = new ClusterFailure({ reason: "cluster configuration is incompatible" });
+      Object.defineProperty(clusterFailure, "originalCause", { value: error, enumerable: false });
+      return new RuntimeTopologyError({
+        dialect,
+        role,
+        nextAction: role === "embedded" ? "use-embedded" : "use-different-database",
+        cause: clusterFailure
+      });
+    }
+    const hostFailure = new HostLayerError({
+      service: "Runtime host graph",
+      reason: "host layer acquisition failed"
+    });
+    Object.defineProperty(hostFailure, "originalCause", { value: error, enumerable: false });
+    return new RuntimeConfigurationError({
+      setting: "host layers",
+      nextAction: "provide-host-layer",
+      cause: hostFailure
+    });
+  };
+  return layer2.pipe(Layer3.catchCause((cause) => {
+    if (Cause.hasInterrupts(cause))
+      return Layer3.unwrap(Effect3.failCause(Cause.map(cause, normalize)));
+    return Layer3.unwrap(Effect3.fail(normalize(Cause.squash(cause))));
+  }));
+};
+var actualDialect = (sql) => sql.onDialectOrElse({
+  sqlite: () => "sqlite",
+  pg: () => "pg",
+  mysql: () => "mysql",
+  mssql: () => "mssql",
+  clickhouse: () => "clickhouse",
+  orElse: () => "clickhouse"
+});
+var ambientDatabaseLayer = Layer3.effect(SqlClient, SqlClient);
+var validatedDatabase = (databaseLayer, role) => {
+  const validatedService = Layer3.effect(Service3, Effect3.gen(function* () {
+    const database = yield* Service3;
+    const sql = yield* SqlClient;
+    const actual = actualDialect(sql);
+    if (actual !== database.dialect) {
+      return yield* new RuntimeTopologyError({
+        dialect: database.dialect,
+        role,
+        nextAction: role === "embedded" ? "use-different-database" : "use-postgres-or-mysql",
+        cause: new DatabaseDialectMismatch({ expected: database.dialect, actual })
+      });
+    }
+    if (database.dialect === "sqlite") {
+      yield* database.acquireSchema;
+    } else {
+      yield* database.verifySchema;
+    }
+    return database;
+  }));
+  const sqlLayer = Layer3.effect(SqlClient, SqlClient);
+  return Layer3.merge(sqlLayer, validatedService).pipe(Layer3.provide(databaseLayer));
+};
+var runtimeServiceLayer = (role, capabilities) => Layer3.effect(Service4, Effect3.gen(function* () {
+  const database = yield* Service3;
+  const runner = yield* exports_runner_runtime_service.Service;
+  return Service4.of({
+    readiness: runner.check().pipe(Effect3.mapError((error) => {
+      const cause = new SqlFailure({ category: "unknown", operation: "readiness", retryable: false });
+      Object.defineProperty(cause, "originalCause", { value: error, enumerable: false });
+      return new RuntimeReadinessError({ phase: "database", cause });
+    }), Effect3.as({
+      ready: true,
+      role,
+      dialect: database.dialect,
+      databaseIdentity: database.databaseIdentity,
+      schemaHead: database.schemaHead,
+      notification: database.notification,
+      capabilities: {
+        fanOut: capabilities.fanOut ? { enabled: true, source: "local-host", health: "healthy" } : {
+          enabled: false,
+          source: role === "embedded" ? "local-host" : "role-unavailable",
+          health: "not-applicable"
+        },
+        workflowDefinition: capabilities.workflowDefinition ? { enabled: true, source: "local-host", health: "healthy" } : {
+          enabled: false,
+          source: role === "embedded" ? "local-host" : "role-unavailable",
+          health: "not-applicable"
+        }
+      }
+    }))
+  });
+}));
+var publicGraph = (runner, databaseLayer, role, capabilities = { fanOut: false, workflowDefinition: false }) => {
+  const database = validatedDatabase(databaseLayer, role);
+  const graph = runner.pipe(Layer3.provideMerge(database));
+  const policy = layer(role, capabilities);
+  return Layer3.merge(Layer3.fresh(layerFromRuntime).pipe(Layer3.provideMerge(policy)), runtimeServiceLayer(role, capabilities)).pipe(Layer3.provide(graph));
+};
+var withHosts = (runner, options) => {
+  const childHost = options.childFanOutHandlersLayer === undefined ? Layer3.empty : exports_child_fan_out_runtime.layerFromRuntime.pipe(Layer3.provide(options.childFanOutHandlersLayer), Layer3.provide(exports_child_fan_out_transition_service.layer), Layer3.provide(runner));
+  const workflowHost = options.workflowDefinitionHandlersLayer === undefined ? Layer3.empty : exports_definition_runtime.layerFromRuntime.pipe(Layer3.provide(options.workflowDefinitionHandlersLayer), Layer3.provideMerge(childHost), Layer3.provide(runner));
+  return Layer3.mergeAll(runner, childHost, workflowHost);
+};
+var layerEmbedded = (options) => {
+  const runner = exports_runner_runtime_service.layerWithServices({
+    databaseLayer: ambientDatabaseLayer,
+    languageModelLayer: options.languageModelLayer,
+    toolRuntimeLayer: options.toolRuntimeLayer,
+    embeddingModelLayer: options.embeddingModelLayer,
+    blobStoreLayer: options.blobStoreLayer,
+    artifactStoreLayer: options.artifactStoreLayer,
+    promptAssemblerLayer: options.promptAssemblerLayer,
+    schemaRegistryLayer: options.schemaRegistryLayer
+  });
+  return normalizeHost(publicGraph(withHosts(runner, options), options.databaseLayer, "embedded", {
+    fanOut: options.childFanOutHandlersLayer !== undefined,
+    workflowDefinition: options.workflowDefinitionHandlersLayer !== undefined
+  }), "embedded", options.databaseLayer[DatabaseDialect]);
+};
+var layerRunner = (options) => {
+  const runner = exports_runner_runtime_service.layerWithServicesMultiNode({
+    databaseLayer: ambientDatabaseLayer,
+    languageModelLayer: options.languageModelLayer,
+    toolRuntimeLayer: options.toolRuntimeLayer,
+    embeddingModelLayer: options.embeddingModelLayer,
+    blobStoreLayer: options.blobStoreLayer,
+    artifactStoreLayer: options.artifactStoreLayer,
+    promptAssemblerLayer: options.promptAssemblerLayer,
+    schemaRegistryLayer: options.schemaRegistryLayer,
+    cluster: options.cluster
+  });
+  return normalizeHost(publicGraph(runner, options.databaseLayer, "runner"), "runner", options.databaseLayer[DatabaseDialect]);
+};
+var layerClient = (options) => {
+  const runner = exports_runner_runtime_service.layerWithServicesMultiNodeClientOnly({
+    databaseLayer: ambientDatabaseLayer,
+    languageModelLayer: exports_language_model_service.layer(),
+    toolRuntimeLayer: exports_tool_runtime_service.layer(),
+    cluster: options.cluster
+  });
+  return normalizeHost(publicGraph(runner, options.databaseLayer, "client"), "client", options.databaseLayer[DatabaseDialect]);
+};
+
+export { exports_operation, exports_command, Service2 as Service, exports_client, exports_runtime_database, makeDatabaseIdentity, DatabaseDialect, ConfigFailure, SqlFailure, DatabaseAlreadyOwned, MigratorError, SchemaHeadMismatch, RuntimeConfigurationError, RuntimeTopologyError, RuntimeMigrationError, exports_runtime };