@relayfx/sdk 0.0.48 → 0.0.50

package/dist/ai.js

@@ -62,6 +62,7 @@ __export(exports_ids_schema, {
   WorkspaceLeaseId: () => WorkspaceLeaseId,
   WaitId: () => WaitId,
   ToolCallId: () => ToolCallId,
+  ToolAttemptId: () => ToolAttemptId,
   TenantId: () => TenantId,
   SystemTenantId: () => SystemTenantId,
   SnapshotRef: () => SnapshotRef,
@@ -104,6 +105,7 @@ var WorkspaceSnapshotId = id("Relay.WorkspaceSnapshotId");
 var WorkspaceRef = id("Relay.WorkspaceRef");
 var SnapshotRef = id("Relay.SnapshotRef");
 var ToolCallId = id("Relay.ToolCallId");
+var ToolAttemptId = id("Relay.ToolAttemptId");
 var WaitId = id("Relay.WaitId");
 var ScheduleId = id("Relay.ScheduleId");
 var EventId = id("Relay.EventId");
@@ -170,9 +172,12 @@ var RouteList = Schema3.Struct({
 // ../schema/src/agent-schema.ts
 var exports_agent_schema = {};
 __export(exports_agent_schema, {
+  maxTurnPolicySnapshotNodes: () => maxTurnPolicySnapshotNodes,
+  maxTurnPolicySnapshotDepth: () => maxTurnPolicySnapshotDepth,
   define: () => define,
   defaultMaxWaitTurns: () => defaultMaxWaitTurns,
   defaultMaxToolTurns: () => defaultMaxToolTurns,
+  TurnPolicySnapshot: () => TurnPolicySnapshot,
   ToolInputSchemaDigests: () => ToolInputSchemaDigests,
   RegisterDefinitionPayload: () => RegisterDefinitionPayload,
   PermissionRuleset: () => PermissionRuleset,
@@ -195,12 +200,19 @@ import { Schema as Schema5 } from "effect";
 // ../schema/src/tool-schema.ts
 var exports_tool_schema = {};
 __export(exports_tool_schema, {
+  resultSchema: () => resultSchema,
   parametersSchema: () => parametersSchema,
+  WorkerId: () => WorkerId,
   RuntimeRequirement: () => RuntimeRequirement,
   Result: () => Result,
+  PlacementKey: () => PlacementKey,
+  Placement: () => Placement,
   Permission: () => Permission,
+  ExternalOutcome: () => ExternalOutcome,
   Definition: () => Definition,
-  Call: () => Call
+  CallState: () => CallState,
+  Call: () => Call,
+  AttemptState: () => AttemptState
 });
 import { JsonSchema, Schema as Schema4, SchemaRepresentation } from "effect";
 var Permission = Schema4.Struct({
@@ -214,6 +226,38 @@ var RuntimeRequirement = Schema4.Union([
     mode: Schema4.Literals(["read", "write", "exec"])
   })
 ]).annotate({ identifier: "Relay.Tool.RuntimeRequirement" });
+var PlacementKey = NonEmptyString.check(Schema4.isMaxLength(191)).annotate({
+  identifier: "Relay.Tool.PlacementKey"
+});
+var WorkerId = NonEmptyString.check(Schema4.isMaxLength(191)).annotate({
+  identifier: "Relay.Tool.WorkerId"
+});
+var Placement = Schema4.Union([
+  Schema4.Struct({ kind: Schema4.Literal("local") }),
+  Schema4.Struct({ kind: Schema4.Literal("client") }),
+  Schema4.Struct({ kind: Schema4.Literal("remote"), queue: PlacementKey }),
+  Schema4.Struct({ kind: Schema4.Literal("mcp"), server_id: PlacementKey })
+]).annotate({ identifier: "Relay.Tool.Placement" });
+var ExternalOutcome = Schema4.Union([
+  Schema4.Struct({ kind: Schema4.Literal("success"), output: JsonValue }),
+  Schema4.Struct({ kind: Schema4.Literal("failure"), message: Schema4.String })
+]).annotate({ identifier: "Relay.Tool.ExternalOutcome" });
+var CallState = Schema4.Literals([
+  "requested",
+  "waiting",
+  "running",
+  "submitted",
+  "completed",
+  "failed"
+]).annotate({ identifier: "Relay.Tool.CallState" });
+var AttemptState = Schema4.Literals([
+  "running",
+  "completed",
+  "failed",
+  "released",
+  "expired",
+  "abandoned"
+]).annotate({ identifier: "Relay.Tool.AttemptState" });
 var Definition = Schema4.Struct({
   name: NonEmptyString,
   description: Schema4.String,
@@ -274,6 +318,19 @@ var parametersSchema = (inputSchema) => {
     return Schema4.Unknown;
   }
 };
+var resultSchema = (outputSchema) => {
+  if (outputSchema === true || isJsonObject(outputSchema) && Object.keys(outputSchema).length === 0) {
+    return Schema4.Unknown;
+  }
+  if (outputSchema === false)
+    return Schema4.Never;
+  try {
+    const schema = SchemaRepresentation.toSchema(SchemaRepresentation.fromJsonSchemaDocument(JsonSchema.fromSchemaDraft2020_12(outputSchema)));
+    return schema.ast._tag === "Unknown" ? Schema4.Never : schema;
+  } catch {
+    return Schema4.Never;
+  }
+};
 
 // ../schema/src/agent-schema.ts
 var DefinitionRevision = Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1)).annotate({
@@ -318,9 +375,56 @@ var PermissionRuleset = Schema5.Struct({
 var ToolInputSchemaDigests = Schema5.Record(Schema5.String, Schema5.String).annotate({
   identifier: "Relay.Agent.ToolInputSchemaDigests"
 });
+var RecursTurnPolicySnapshot = Schema5.Struct({
+  kind: Schema5.Literals(["recurs"]),
+  count: Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(0))
+});
+var UntilToolCallTurnPolicySnapshot = Schema5.Struct({
+  kind: Schema5.Literals(["until-tool-call"]),
+  name: NonEmptyString
+});
+var maxTurnPolicySnapshotDepth = 16;
+var maxTurnPolicySnapshotNodes = 64;
+var turnPolicySnapshotNodeCount = Schema5.makeFilter((input) => {
+  let nodes = 0;
+  const pending = [input];
+  while (pending.length > 0) {
+    const snapshot = pending.pop();
+    if (snapshot === undefined)
+      continue;
+    nodes += 1;
+    if (nodes > maxTurnPolicySnapshotNodes) {
+      return `turn policy snapshot node count exceeds ${maxTurnPolicySnapshotNodes}`;
+    }
+    if (snapshot.kind === "both")
+      pending.push(snapshot.second, snapshot.first);
+  }
+  return;
+});
+var turnPolicySnapshotLeaf = Schema5.Union([RecursTurnPolicySnapshot, UntilToolCallTurnPolicySnapshot]);
+var makeTurnPolicySnapshotTree = () => {
+  let tree = turnPolicySnapshotLeaf;
+  for (let depth = 2;depth <= maxTurnPolicySnapshotDepth; depth += 1) {
+    const child = tree;
+    tree = Schema5.Union([
+      RecursTurnPolicySnapshot,
+      UntilToolCallTurnPolicySnapshot,
+      Schema5.Struct({
+        kind: Schema5.Literals(["both"]),
+        first: child,
+        second: child
+      })
+    ]);
+    if (depth < maxTurnPolicySnapshotDepth) {
+      tree = tree.annotate({ identifier: `Relay.Agent.TurnPolicySnapshot.Depth${depth}` });
+    }
+  }
+  return tree;
+};
+var TurnPolicySnapshot = makeTurnPolicySnapshotTree().check(turnPolicySnapshotNodeCount).annotate({ identifier: "Relay.Agent.TurnPolicySnapshot" });
 var defaultMaxToolTurns = 8;
 var defaultMaxWaitTurns = 8;
-var Definition2 = Schema5.Struct({
+var DefinitionSchema = Schema5.Struct({
   name: NonEmptyString,
   instructions: Schema5.optionalKey(Schema5.String),
   model: ModelSelection,
@@ -328,6 +432,7 @@ var Definition2 = Schema5.Struct({
   permissions: Schema5.Array(Permission),
   skill_definition_ids: Schema5.optionalKey(Schema5.Array(SkillDefinitionId)),
   permission_rules: Schema5.optionalKey(PermissionRuleset),
+  turn_policy: Schema5.optionalKey(TurnPolicySnapshot),
   max_tool_turns: Schema5.optionalKey(Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1))),
   max_wait_turns: Schema5.optionalKey(Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(0))),
   token_budget: Schema5.optionalKey(Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1))),
@@ -336,6 +441,7 @@ var Definition2 = Schema5.Struct({
   output_schema_ref: Schema5.optionalKey(Schema5.String),
   metadata: Schema5.optionalKey(Metadata)
 }).annotate({ identifier: "Relay.Agent.Definition" });
+var Definition2 = DefinitionSchema;
 var define = (input) => ({
   id: input.id,
   definition: {
@@ -346,6 +452,7 @@ var define = (input) => ({
     permissions: input.permissions,
     ...input.skill_definition_ids === undefined ? {} : { skill_definition_ids: input.skill_definition_ids },
     ...input.permission_rules === undefined ? {} : { permission_rules: input.permission_rules },
+    ...input.turn_policy === undefined ? {} : { turn_policy: input.turn_policy },
     ...input.max_tool_turns === undefined ? {} : { max_tool_turns: input.max_tool_turns },
     ...input.max_wait_turns === undefined ? {} : { max_wait_turns: input.max_wait_turns },
     ...input.token_budget === undefined ? {} : { token_budget: input.token_budget },
@@ -1469,8 +1576,9 @@ __export(exports_child_execution_repository, {
   ChildExecutionRepositoryError: () => ChildExecutionRepositoryError,
   ChildExecutionNotFound: () => ChildExecutionNotFound
 });
-import { Context as Context6, Effect as Effect6, Layer as Layer6, Schema as Schema16 } from "effect";
+import { Context as Context6, Effect as Effect6, Layer as Layer6, Predicate, Schema as Schema16 } from "effect";
 import { SqlClient as SqlClient5 } from "effect/unstable/sql/SqlClient";
+import { isSqlError } from "effect/unstable/sql/SqlError";
 class ChildExecutionRepositoryError extends Schema16.TaggedErrorClass()("ChildExecutionRepositoryError", {
   message: Schema16.String
 }) {
@@ -1508,6 +1616,16 @@ var toRecord3 = (row) => ({
   updatedAt: fromDbTimestamp(row.updated_at)
 });
 var toRepositoryError4 = (error) => new ChildExecutionRepositoryError({ message: String(error) });
+var isDuplicateConstraint = (error) => {
+  if (!isSqlError(error))
+    return false;
+  if (error.reason._tag === "UniqueViolation")
+    return true;
+  if (error.reason._tag !== "ConstraintError")
+    return false;
+  const cause = error.reason.cause;
+  return Predicate.hasProperty(cause, "code") && (cause.code === "SQLITE_CONSTRAINT_PRIMARYKEY" || cause.code === 1555) || Predicate.hasProperty(cause, "errno") && cause.errno === 1555;
+};
 var decodeRow4 = (row) => Schema16.decodeUnknownEffect(ChildExecutionRow)(row).pipe(Effect6.mapError(toRepositoryError4));
 var layer6 = Layer6.effect(Service6, Effect6.gen(function* () {
   const sql2 = yield* SqlClient5;
@@ -1561,10 +1679,7 @@ var layer6 = Layer6.effect(Service6, Effect6.gen(function* () {
   });
   const create = Effect6.fn("ChildExecutionRepository.create")(function* (input) {
     const tenantId = yield* current();
-    const existing = yield* selectByKey(tenantId, input.id).pipe(Effect6.mapError(toRepositoryError4));
-    if (existing[0] !== undefined)
-      return yield* Effect6.fail(new DuplicateChildExecution({ id: input.id }));
-    const rows = yield* insertChildExecution(tenantId, input).pipe(Effect6.mapError(toRepositoryError4));
+    const rows = yield* insertChildExecution(tenantId, input).pipe(Effect6.mapError((error) => isDuplicateConstraint(error) ? new DuplicateChildExecution({ id: input.id }) : toRepositoryError4(error)));
     const row = rows[0];
     if (row === undefined) {
       return yield* Effect6.fail(new ChildExecutionRepositoryError({ message: "Child execution insert returned no row" }));
@@ -1582,7 +1697,7 @@ var layer6 = Layer6.effect(Service6, Effect6.gen(function* () {
         SELECT ${columns}
         FROM relay_child_executions
         WHERE tenant_id = ${tenantId} AND execution_id = ${executionId}
-        ORDER BY created_at ASC
+        ORDER BY created_at ASC, id ASC
       `.pipe(Effect6.mapError(toRepositoryError4));
     const decoded = yield* Effect6.forEach(rows, decodeRow4);
     return decoded.map(toRecord3);
@@ -1619,7 +1734,7 @@ var memoryLayer4 = Layer6.sync(Service6, () => {
       return yield* Effect6.sync(() => records.get(id2));
     }),
     listByExecution: Effect6.fn("ChildExecutionRepository.memory.listByExecution")(function* (executionId) {
-      return yield* Effect6.sync(() => [...records.values()].filter((record) => record.executionId === executionId).toSorted((left, right) => left.createdAt - right.createdAt));
+      return yield* Effect6.sync(() => [...records.values()].filter((record) => record.executionId === executionId).toSorted((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id)));
     }),
     updateStatus: Effect6.fn("ChildExecutionRepository.memory.updateStatus")(function* (input) {
       const existing = records.get(input.id);
@@ -1885,6 +2000,7 @@ __export(exports_envelope_repository, {
   releaseReady: () => releaseReady,
   memoryLayer: () => memoryLayer7,
   listWaits: () => listWaits,
+  listAllWaits: () => listAllWaits,
   layer: () => layer9,
   getWait: () => getWait,
   getEnvelope: () => getEnvelope,
@@ -2150,6 +2266,25 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
     }
     return records;
   });
+  const listAllWaits = Effect9.fn("EnvelopeRepository.listAllWaits")(function* (input) {
+    const tenantId = yield* current();
+    const conditions = [
+      sql2`tenant_id = ${tenantId}`,
+      ...input.executionId === undefined ? [] : [sql2`execution_id = ${input.executionId}`],
+      ...input.state === undefined ? [] : [sql2`state = ${input.state}`]
+    ];
+    const rows = yield* sql2`
+        SELECT ${waitColumns}
+        FROM relay_waits
+        WHERE ${sql2.and(conditions)}
+        ORDER BY created_at DESC, id DESC
+      `.pipe(Effect9.mapError(toRepositoryError6));
+    const records = [];
+    for (const row of rows) {
+      records.push(toWaitRecord(yield* decodeWaitRow(row)));
+    }
+    return records;
+  });
   const claimablePredicate = (input) => sql2.or([
     sql2.and([sql2`state = 'ready'`, sql2`available_at <= ${ts(input.now)}`]),
     sql2.and([sql2`state = 'claimed'`, sql2`claim_expires_at IS NOT NULL`, sql2`claim_expires_at <= ${ts(input.now)}`])
@@ -2370,6 +2505,7 @@ var layer9 = Layer9.effect(Service9, Effect9.gen(function* () {
     getWait,
     createWait,
     listWaits,
+    listAllWaits,
     claimReady,
     releaseReady,
     ackReady,
@@ -2454,6 +2590,9 @@ var memoryLayer7 = Layer9.sync(Service9, () => {
     listWaits: Effect9.fn("EnvelopeRepository.memory.listWaits")(function* (input) {
       return yield* Effect9.sync(() => [...waits.values()].filter((record2) => (input.executionId === undefined || record2.executionId === input.executionId) && (input.state === undefined || record2.state === input.state)).toSorted(compareWaitsDesc).slice(0, listWaitsLimit(input)));
     }),
+    listAllWaits: Effect9.fn("EnvelopeRepository.memory.listAllWaits")(function* (input) {
+      return yield* Effect9.sync(() => [...waits.values()].filter((record2) => (input.executionId === undefined || record2.executionId === input.executionId) && (input.state === undefined || record2.state === input.state)).toSorted(compareWaitsDesc));
+    }),
     claimReady: Effect9.fn("EnvelopeRepository.memory.claimReady")(function* (input) {
       const candidate = [...readyRows.values()].filter((row) => row.routeType === input.routeType && (input.routeKey === undefined || row.routeKey === input.routeKey) && (row.state === "ready" && row.availableAt <= input.now || row.state === "claimed" && row.claimExpiresAt !== undefined && row.claimExpiresAt <= input.now)).toSorted((a, b) => a.availableAt - b.availableAt || a.createdAt - b.createdAt)[0];
       if (candidate === undefined)
@@ -2543,6 +2682,10 @@ var listWaits = Effect9.fn("EnvelopeRepository.listWaits.call")(function* (input
   const repository = yield* Service9;
   return yield* repository.listWaits(input);
 });
+var listAllWaits = Effect9.fn("EnvelopeRepository.listAllWaits.call")(function* (input) {
+  const repository = yield* Service9;
+  return yield* repository.listAllWaits(input);
+});
 var claimReady = Effect9.fn("EnvelopeRepository.claimReady.call")(function* (input) {
   const repository = yield* Service9;
   return yield* repository.claimReady(input);
@@ -2577,6 +2720,7 @@ __export(exports_execution_event_repository, {
   layer: () => layer10,
   findFirstByTypeAfterSequence: () => findFirstByTypeAfterSequence,
   findBySequenceOrCursor: () => findBySequenceOrCursor,
+  findBySequence: () => findBySequence,
   findByCursor: () => findByCursor,
   executionEventsChannel: () => executionEventsChannel,
   appendedSignals: () => appendedSignals,
@@ -2865,6 +3009,17 @@ var layer10 = Layer11.effect(Service11, Effect11.gen(function* () {
     const row = rows[0];
     return row === undefined ? Option2.none() : Option2.some(toEvent(yield* decodeRow6(row)));
   });
+  const findBySequence = Effect11.fn("ExecutionEventRepository.findBySequence")(function* (input) {
+    const tenantId = yield* current();
+    const rows = yield* sql2`
+        SELECT ${columns}
+        FROM relay_execution_events
+        WHERE tenant_id = ${tenantId} AND execution_id = ${input.executionId} AND sequence = ${input.sequence}
+        LIMIT 1
+      `.pipe(Effect11.mapError(toRepositoryError7));
+    const row = rows[0];
+    return row === undefined ? Option2.none() : Option2.some(toEvent(yield* decodeRow6(row)));
+  });
   const findFirstByTypeAfterSequence = Effect11.fn("ExecutionEventRepository.findFirstByTypeAfterSequence")(function* (input) {
     const tenantId = yield* current();
     const rows = yield* sql2`
@@ -2942,6 +3097,7 @@ var layer10 = Layer11.effect(Service11, Effect11.gen(function* () {
     list: list4,
     findBySequenceOrCursor,
     findByCursor,
+    findBySequence,
     findFirstByTypeAfterSequence,
     maxSequence,
     sumUsage,
@@ -2981,6 +3137,11 @@ var memoryLayer8 = Layer11.sync(Service11, () => {
       const event = executionEvents.find((item) => item.cursor === input.cursor);
       return Effect11.succeed(event === undefined ? Option2.none() : Option2.some(event));
     }),
+    findBySequence: Effect11.fn("ExecutionEventRepository.memory.findBySequence")((input) => {
+      const executionEvents = events.get(input.executionId) ?? [];
+      const event = executionEvents.find((item) => item.sequence === input.sequence);
+      return Effect11.succeed(event === undefined ? Option2.none() : Option2.some(event));
+    }),
     findFirstByTypeAfterSequence: Effect11.fn("ExecutionEventRepository.memory.findFirstByTypeAfterSequence")((input) => {
       const executionEvents = events.get(input.executionId) ?? [];
       const event = executionEvents.find((item) => item.type === input.type && item.sequence > input.afterSequence);
@@ -3019,6 +3180,10 @@ var findByCursor = Effect11.fn("ExecutionEventRepository.findByCursor.call")(fun
   const repository = yield* Service11;
   return yield* repository.findByCursor(input);
 });
+var findBySequence = Effect11.fn("ExecutionEventRepository.findBySequence.call")(function* (input) {
+  const repository = yield* Service11;
+  return yield* repository.findBySequence(input);
+});
 var findFirstByTypeAfterSequence = Effect11.fn("ExecutionEventRepository.findFirstByTypeAfterSequence.call")(function* (input) {
   const repository = yield* Service11;
   return yield* repository.findFirstByTypeAfterSequence(input);
@@ -3980,6 +4145,7 @@ __export(exports_relay_schema, {
   relayWaits: () => relayWaits,
   relayToolResults: () => relayToolResults,
   relayToolCalls: () => relayToolCalls,
+  relayToolAttempts: () => relayToolAttempts,
   relaySteeringMessages: () => relaySteeringMessages,
   relaySteeringDrains: () => relaySteeringDrains,
   relaySkillDefinitions: () => relaySkillDefinitions,
@@ -4380,11 +4546,44 @@ var relayToolCalls = pgTable("relay_tool_calls", {
   executionId: text2("execution_id").$type().notNull(),
   name: text2("name").notNull(),
   inputJson: jsonb("input_json").notNull(),
+  definitionJson: jsonb("definition_json").$type(),
+  placementKind: text2("placement_kind").$type().notNull().default("local"),
+  placementKey: text2("placement_key"),
+  state: text2("state").$type().notNull().default("requested"),
+  waitId: text2("wait_id").$type(),
+  idempotencyKey: text2("idempotency_key").notNull(),
+  availableAt: timestamp("available_at", { withTimezone: true }).notNull().defaultNow(),
+  activeAttemptId: text2("active_attempt_id").$type(),
+  claimOwner: text2("claim_owner"),
+  claimedAt: timestamp("claimed_at", { withTimezone: true }),
+  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+  externalOutcomeJson: jsonb("external_outcome_json").$type(),
+  externalOutcomeAt: timestamp("external_outcome_at", { withTimezone: true }),
   metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
 }, (table) => [
   primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_tool_calls" }),
-  index("idx_relay_tool_calls_execution").on(table.tenantId, table.executionId, table.createdAt)
+  index("idx_relay_tool_calls_execution").on(table.tenantId, table.executionId, table.createdAt),
+  index("idx_relay_tool_calls_remote_claim").on(table.tenantId, table.placementKind, table.placementKey, table.state, table.availableAt, table.createdAt, table.id),
+  index("idx_relay_tool_calls_stale_claim").on(table.tenantId, table.state, table.claimExpiresAt),
+  index("idx_relay_tool_calls_client_pending").on(table.tenantId, table.placementKind, table.state, table.createdAt, table.id)
+]);
+var relayToolAttempts = pgTable("relay_tool_attempts", {
+  tenantId: tenantId(),
+  id: text2("id").$type().notNull(),
+  toolCallId: text2("tool_call_id").$type().notNull(),
+  attemptNumber: integer("attempt_number").notNull(),
+  state: text2("state").$type().notNull(),
+  workerId: text2("worker_id"),
+  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+  error: text2("error"),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  completedAt: timestamp("completed_at", { withTimezone: true })
+}, (table) => [
+  primaryKey({ columns: [table.tenantId, table.toolCallId, table.id], name: "pk_relay_tool_attempts" }),
+  uniqueIndex("uq_relay_tool_attempts_number").on(table.tenantId, table.toolCallId, table.attemptNumber),
+  index("idx_relay_tool_attempts_call").on(table.tenantId, table.toolCallId, table.attemptNumber)
 ]);
 var relayToolResults = pgTable("relay_tool_results", {
   tenantId: tenantId(),
@@ -6344,24 +6543,40 @@ var drainUnconsumed = Effect20.fn("SteeringRepository.drainUnconsumed.call")(fun
 // ../store-sql/src/tool/tool-call-repository.ts
 var exports_tool_call_repository = {};
 __export(exports_tool_call_repository, {
+  toolCallIdempotencyKey: () => toolCallIdempotencyKey,
   testLayer: () => testLayer18,
+  releaseRemote: () => releaseRemote,
   recordResult: () => recordResult,
   recordCall: () => recordCall,
+  prepareExternalWait: () => prepareExternalWait,
   memoryLayer: () => memoryLayer18,
   listCalls: () => listCalls,
+  listAttempts: () => listAttempts,
   layer: () => layer20,
   getResult: () => getResult,
   getCall: () => getCall,
+  failOpenForExecution: () => failOpenForExecution,
+  ensureCall: () => ensureCall,
+  claimRemote: () => claimRemote,
+  beginAttempt: () => beginAttempt,
+  acceptRemoteOutcome: () => acceptRemoteOutcome,
+  acceptClientOutcome: () => acceptClientOutcome,
   ToolResultRow: () => ToolResultRow,
+  ToolOutcomeConflict: () => ToolOutcomeConflict,
+  ToolClaimRejected: () => ToolClaimRejected,
+  ToolCallTransitionRejected: () => ToolCallTransitionRejected,
   ToolCallRow: () => ToolCallRow,
   ToolCallRepositoryError: () => ToolCallRepositoryError,
   ToolCallNotFound: () => ToolCallNotFound,
+  ToolCallConflict: () => ToolCallConflict,
+  ToolAttemptRow: () => ToolAttemptRow,
   Service: () => Service21,
   DuplicateToolResult: () => DuplicateToolResult,
   DuplicateToolCall: () => DuplicateToolCall
 });
 import { Context as Context21, Effect as Effect21, Layer as Layer21, Schema as Schema30 } from "effect";
 import { SqlClient as SqlClient20 } from "effect/unstable/sql/SqlClient";
+import { isSqlError as isSqlError2 } from "effect/unstable/sql/SqlError";
 class ToolCallRepositoryError extends Schema30.TaggedErrorClass()("ToolCallRepositoryError", {
   message: Schema30.String
 }) {
@@ -6382,6 +6597,30 @@ class DuplicateToolResult extends Schema30.TaggedErrorClass()("DuplicateToolResu
 }) {
 }
 
+class ToolCallConflict extends Schema30.TaggedErrorClass()("ToolCallConflict", {
+  id: exports_ids_schema.ToolCallId
+}) {
+}
+
+class ToolCallTransitionRejected extends Schema30.TaggedErrorClass()("ToolCallTransitionRejected", {
+  id: exports_ids_schema.ToolCallId,
+  message: Schema30.String
+}) {
+}
+
+class ToolOutcomeConflict extends Schema30.TaggedErrorClass()("ToolOutcomeConflict", {
+  id: exports_ids_schema.ToolCallId
+}) {
+}
+
+class ToolClaimRejected extends Schema30.TaggedErrorClass()("ToolClaimRejected", {
+  message: Schema30.String
+}) {
+}
+var lengthPrefixed = (value) => `${[...value].length}:${value}`;
+var toolCallIdempotencyKey = (tenantId2, executionId, callId) => `tool:${lengthPrefixed(tenantId2)}:${lengthPrefixed(executionId)}:${lengthPrefixed(callId)}`;
+var toolAttemptId = (attemptNumber) => exports_ids_schema.ToolAttemptId.make(`tool-attempt:${attemptNumber}`);
+
 class Service21 extends Context21.Service()("@relayfx/store-sql/ToolCallRepository") {
 }
 var ToolCallRow = Schema30.Struct({
@@ -6389,9 +6628,34 @@ var ToolCallRow = Schema30.Struct({
   execution_id: Schema30.String,
   name: Schema30.String,
   input_json: Schema30.Unknown,
+  definition_json: Schema30.NullishOr(Schema30.Unknown),
+  placement_kind: Schema30.String,
+  placement_key: Schema30.NullishOr(Schema30.String),
+  state: Schema30.String,
+  wait_id: Schema30.NullishOr(Schema30.String),
+  idempotency_key: Schema30.String,
+  available_at: Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number]),
+  active_attempt_id: Schema30.NullishOr(Schema30.String),
+  claim_owner: Schema30.NullishOr(Schema30.String),
+  claimed_at: Schema30.NullishOr(Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number])),
+  claim_expires_at: Schema30.NullishOr(Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number])),
+  external_outcome_json: Schema30.NullishOr(Schema30.Unknown),
+  external_outcome_at: Schema30.NullishOr(Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number])),
   metadata_json: Schema30.Unknown,
-  created_at: Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number])
+  created_at: Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number]),
+  updated_at: Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number])
 }).annotate({ identifier: "Relay.ToolCall.Row" });
+var ToolAttemptRow = Schema30.Struct({
+  id: Schema30.String,
+  tool_call_id: Schema30.String,
+  attempt_number: Schema30.Union([Schema30.Number, Schema30.String, Schema30.BigInt]),
+  state: Schema30.String,
+  worker_id: Schema30.NullishOr(Schema30.String),
+  claim_expires_at: Schema30.NullishOr(Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number])),
+  error: Schema30.NullishOr(Schema30.String),
+  created_at: Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number]),
+  completed_at: Schema30.NullishOr(Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number]))
+}).annotate({ identifier: "Relay.ToolAttempt.Row" });
 var ToolResultRow = Schema30.Struct({
   tool_call_id: Schema30.String,
   output_json: Schema30.Unknown,
@@ -6400,15 +6664,46 @@ var ToolResultRow = Schema30.Struct({
   created_at: Schema30.Union([Schema30.Date, Schema30.String, Schema30.Number])
 }).annotate({ identifier: "Relay.ToolResult.Row" });
 var metadata8 = (input) => input ?? {};
-var toCallRecord = (row) => ({
-  executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
-  call: {
-    id: exports_ids_schema.ToolCallId.make(row.id),
-    name: row.name,
-    input: decodeJson(row.input_json),
-    metadata: decodeJson(row.metadata_json)
-  },
-  createdAt: fromDbTimestamp(row.created_at)
+var normalizeCall = (call) => ({ ...call, metadata: metadata8(call.metadata) });
+var sameCallIdentity = (left, right) => exports_shared_schema.canonicalString(normalizeCall(left)) === exports_shared_schema.canonicalString(normalizeCall(right));
+var placementFromRow = (row) => Schema30.decodeUnknownSync(exports_tool_schema.Placement)(row.placement_kind === "remote" ? { kind: "remote", queue: row.placement_key } : row.placement_kind === "mcp" ? { kind: "mcp", server_id: row.placement_key } : { kind: row.placement_kind });
+var toCallRecord = (row) => {
+  const definition = row.definition_json === null || row.definition_json === undefined ? undefined : Schema30.decodeUnknownSync(exports_tool_schema.Definition)(decodeJson(row.definition_json));
+  const outcome = row.external_outcome_json === null || row.external_outcome_json === undefined ? undefined : Schema30.decodeUnknownSync(exports_tool_schema.ExternalOutcome)(decodeJson(row.external_outcome_json));
+  return {
+    executionId: exports_ids_schema.ExecutionId.make(row.execution_id),
+    call: normalizeCall({
+      id: exports_ids_schema.ToolCallId.make(row.id),
+      name: row.name,
+      input: decodeJson(row.input_json),
+      metadata: decodeJson(row.metadata_json)
+    }),
+    ...definition === undefined ? {} : { definition },
+    placement: placementFromRow(row),
+    state: Schema30.decodeUnknownSync(exports_tool_schema.CallState)(row.state),
+    ...row.wait_id === null || row.wait_id === undefined ? {} : { waitId: exports_ids_schema.WaitId.make(row.wait_id) },
+    idempotencyKey: row.idempotency_key,
+    availableAt: fromDbTimestamp(row.available_at),
+    ...row.active_attempt_id === null || row.active_attempt_id === undefined ? {} : { activeAttemptId: exports_ids_schema.ToolAttemptId.make(row.active_attempt_id) },
+    ...row.claim_owner === null || row.claim_owner === undefined ? {} : { claimOwner: row.claim_owner },
+    ...row.claimed_at === null || row.claimed_at === undefined ? {} : { claimedAt: fromDbTimestamp(row.claimed_at) },
+    ...row.claim_expires_at === null || row.claim_expires_at === undefined ? {} : { claimExpiresAt: fromDbTimestamp(row.claim_expires_at) },
+    ...outcome === undefined ? {} : { externalOutcome: outcome },
+    ...row.external_outcome_at === null || row.external_outcome_at === undefined ? {} : { externalOutcomeAt: fromDbTimestamp(row.external_outcome_at) },
+    createdAt: fromDbTimestamp(row.created_at),
+    updatedAt: fromDbTimestamp(row.updated_at)
+  };
+};
+var toAttemptRecord = (row) => ({
+  id: exports_ids_schema.ToolAttemptId.make(row.id),
+  callId: exports_ids_schema.ToolCallId.make(row.tool_call_id),
+  attemptNumber: Number(row.attempt_number),
+  state: Schema30.decodeUnknownSync(exports_tool_schema.AttemptState)(row.state),
+  ...row.worker_id === null || row.worker_id === undefined ? {} : { workerId: row.worker_id },
+  ...row.claim_expires_at === null || row.claim_expires_at === undefined ? {} : { claimExpiresAt: fromDbTimestamp(row.claim_expires_at) },
+  ...row.error === null || row.error === undefined ? {} : { error: row.error },
+  createdAt: fromDbTimestamp(row.created_at),
+  ...row.completed_at === null || row.completed_at === undefined ? {} : { completedAt: fromDbTimestamp(row.completed_at) }
 });
 var toResultRecord = (row) => ({
   result: {
@@ -6422,9 +6717,44 @@ var toResultRecord = (row) => ({
 var toRepositoryError17 = (error) => new ToolCallRepositoryError({ message: String(error) });
 var decodeCallRow = (row) => Schema30.decodeUnknownEffect(ToolCallRow)(row).pipe(Effect21.mapError(toRepositoryError17));
 var decodeResultRow = (row) => Schema30.decodeUnknownEffect(ToolResultRow)(row).pipe(Effect21.mapError(toRepositoryError17));
+var decodeAttemptRow = (row) => Schema30.decodeUnknownEffect(ToolAttemptRow)(row).pipe(Effect21.mapError(toRepositoryError17));
 var layer20 = Layer21.effect(Service21, Effect21.gen(function* () {
   const sql3 = yield* SqlClient20;
-  const callColumns = sql3.literal(["id", "execution_id", "name", "input_json", "metadata_json", "created_at"].join(", "));
+  const ts = (millis) => timestampParam(sql3, millis);
+  const repositoryTransaction = (effect) => sql3.withTransaction(effect).pipe(Effect21.catchTag("SqlError", (error) => Effect21.fail(toRepositoryError17(error))));
+  const callColumns = sql3.literal([
+    "id",
+    "execution_id",
+    "name",
+    "input_json",
+    "definition_json",
+    "placement_kind",
+    "placement_key",
+    "state",
+    "wait_id",
+    "idempotency_key",
+    "available_at",
+    "active_attempt_id",
+    "claim_owner",
+    "claimed_at",
+    "claim_expires_at",
+    "external_outcome_json",
+    "external_outcome_at",
+    "metadata_json",
+    "created_at",
+    "updated_at"
+  ].join(", "));
+  const attemptColumns = sql3.literal([
+    "id",
+    "tool_call_id",
+    "attempt_number",
+    "state",
+    "worker_id",
+    "claim_expires_at",
+    "error",
+    "created_at",
+    "completed_at"
+  ].join(", "));
   const resultColumns = sql3.literal(["tool_call_id", "output_json", "error", "metadata_json", "created_at"].join(", "));
   const selectCallByKey = (tenantId2, id2) => sql3`
       SELECT ${callColumns}
@@ -6436,8 +6766,8 @@ var layer20 = Layer21.effect(Service21, Effect21.gen(function* () {
       FROM relay_tool_results
       WHERE tenant_id = ${tenantId2} AND tool_call_id = ${callId}
     `;
-  const insertCallStatement = (tenantId2, input) => sql3`
-      INSERT INTO relay_tool_calls (
+  const insertCallBody = (tenantId2, input, definition, placement = { kind: "local" }) => sql3`
+      (
         tenant_id, ${callColumns}
       )
       VALUES (
@@ -6446,17 +6776,43 @@ var layer20 = Layer21.effect(Service21, Effect21.gen(function* () {
         ${input.executionId},
         ${input.call.name},
         ${encodeJson(input.call.input)},
+        ${definition === undefined ? null : encodeJson(definition)},
+        ${placement.kind},
+        ${placement.kind === "remote" ? placement.queue : placement.kind === "mcp" ? placement.server_id : null},
+        'requested',
+        ${null},
+        ${toolCallIdempotencyKey(tenantId2, input.executionId, input.call.id)},
+        ${ts(input.createdAt)},
+        ${null},
+        ${null},
+        ${null},
+        ${null},
+        ${null},
+        ${null},
         ${encodeJson(metadata8(input.call.metadata))},
-        ${timestampParam(sql3, input.createdAt)}
+        ${ts(input.createdAt)},
+        ${ts(input.createdAt)}
       )
     `;
+  const insertCallStatement = (tenantId2, input, definition, placement) => sql3`
+      INSERT INTO relay_tool_calls ${insertCallBody(tenantId2, input, definition, placement)}
+    `;
+  const insertCallIgnore = sql3.onDialectOrElse({
+    mysql: () => (tenantId2, input, definition, placement) => sql3`
+        INSERT IGNORE INTO relay_tool_calls ${insertCallBody(tenantId2, input, definition, placement)}
+      `,
+    orElse: () => (tenantId2, input, definition, placement) => sql3`
+        INSERT INTO relay_tool_calls ${insertCallBody(tenantId2, input, definition, placement)}
+        ON CONFLICT (tenant_id, id) DO NOTHING
+      `
+  });
   const insertCall = sql3.onDialectOrElse({
-    mysql: () => (tenantId2, input) => sql3.withTransaction(Effect21.gen(function* () {
-      yield* insertCallStatement(tenantId2, input);
+    mysql: () => (tenantId2, input, definition, placement) => sql3.withTransaction(Effect21.gen(function* () {
+      yield* insertCallStatement(tenantId2, input, definition, placement);
       return yield* selectCallByKey(tenantId2, input.call.id);
     })),
-    orElse: () => (tenantId2, input) => sql3`
-        ${insertCallStatement(tenantId2, input)}
+    orElse: () => (tenantId2, input, definition, placement) => sql3`
+        ${insertCallStatement(tenantId2, input, definition, placement)}
         RETURNING ${callColumns}
       `
   });
@@ -6473,16 +6829,407 @@ var layer20 = Layer21.effect(Service21, Effect21.gen(function* () {
         ${timestampParam(sql3, input.createdAt)}
       )
     `;
-  const insertResult = sql3.onDialectOrElse({
-    mysql: () => (tenantId2, input) => sql3.withTransaction(Effect21.gen(function* () {
-      yield* insertResultStatement(tenantId2, input);
-      return yield* selectResultByKey(tenantId2, input.result.call_id);
-    })),
+  const selectAttempts = (tenantId2, callId) => sql3`
+      SELECT ${attemptColumns}
+      FROM relay_tool_attempts
+      WHERE tenant_id = ${tenantId2} AND tool_call_id = ${callId}
+      ORDER BY attempt_number ASC
+    `;
+  const lockedCallRows = sql3.onDialectOrElse({
+    pg: () => (tenantId2, callId) => sql3`
+        ${selectCallByKey(tenantId2, callId)}
+        FOR UPDATE
+      `,
+    mysql: () => (tenantId2, callId) => sql3`
+        ${selectCallByKey(tenantId2, callId)}
+        FOR UPDATE
+      `,
+    orElse: () => selectCallByKey
+  });
+  const decodeCall = Effect21.fn("ToolCallRepository.decodeCall")(function* (row) {
+    const decoded = yield* decodeCallRow(row);
+    return yield* Effect21.try({ try: () => toCallRecord(decoded), catch: toRepositoryError17 });
+  });
+  const decodeAttempt = Effect21.fn("ToolCallRepository.decodeAttempt")(function* (row) {
+    const decoded = yield* decodeAttemptRow(row);
+    return yield* Effect21.try({ try: () => toAttemptRecord(decoded), catch: toRepositoryError17 });
+  });
+  const readLockedCall = Effect21.fn("ToolCallRepository.readLockedCall")(function* (tenantId2, callId) {
+    const rows = yield* lockedCallRows(tenantId2, callId).pipe(Effect21.mapError(toRepositoryError17));
+    if (rows[0] === undefined)
+      return yield* Effect21.fail(new ToolCallNotFound({ id: callId }));
+    return yield* decodeCall(rows[0]);
+  });
+  const readAttempts = Effect21.fn("ToolCallRepository.readAttempts")(function* (tenantId2, callId) {
+    const rows = yield* selectAttempts(tenantId2, callId).pipe(Effect21.mapError(toRepositoryError17));
+    return yield* Effect21.forEach(rows, decodeAttempt);
+  });
+  const nextAttemptNumber = Effect21.fn("ToolCallRepository.nextAttemptNumber")(function* (tenantId2, callId) {
+    const rows = yield* sql3`
+        SELECT COALESCE(MAX(attempt_number), 0) AS max_attempt
+        FROM relay_tool_attempts
+        WHERE tenant_id = ${tenantId2} AND tool_call_id = ${callId}
+      `.pipe(Effect21.mapError(toRepositoryError17));
+    const max = Number(rows[0]?.max_attempt ?? 0);
+    return max + 1;
+  });
+  const insertAttemptNumber = Effect21.fn("ToolCallRepository.insertAttemptNumber")(function* (tenantId2, callId, attemptNumber, createdAt, workerId, claimExpiresAt) {
+    const attemptId = toolAttemptId(attemptNumber);
+    yield* sql3`
+        INSERT INTO relay_tool_attempts (
+          tenant_id, id, tool_call_id, attempt_number, state, worker_id, claim_expires_at,
+          error, created_at, completed_at
+        )
+        VALUES (
+          ${tenantId2}, ${attemptId}, ${callId}, ${attemptNumber}, 'running', ${workerId ?? null},
+          ${claimExpiresAt === undefined ? null : ts(claimExpiresAt)}, ${null}, ${ts(createdAt)}, ${null}
+        )
+      `.pipe(Effect21.mapError(toRepositoryError17));
+    return {
+      id: attemptId,
+      callId,
+      attemptNumber,
+      state: "running",
+      ...workerId === undefined ? {} : { workerId },
+      ...claimExpiresAt === undefined ? {} : { claimExpiresAt },
+      createdAt
+    };
+  });
+  const insertAttempt = Effect21.fn("ToolCallRepository.insertAttempt")(function* (tenantId2, callId, createdAt, workerId, claimExpiresAt) {
+    const attemptNumber = yield* nextAttemptNumber(tenantId2, callId);
+    return yield* insertAttemptNumber(tenantId2, callId, attemptNumber, createdAt, workerId, claimExpiresAt);
+  });
+  const loadAttempt = Effect21.fn("ToolCallRepository.loadAttempt")(function* (tenantId2, callId, attemptId) {
+    const rows = yield* sql3`
+        SELECT ${attemptColumns}
+        FROM relay_tool_attempts
+        WHERE tenant_id = ${tenantId2} AND tool_call_id = ${callId} AND id = ${attemptId}
+      `.pipe(Effect21.mapError(toRepositoryError17));
+    return rows[0] === undefined ? undefined : yield* decodeAttempt(rows[0]);
+  });
+  const completeAttempt = Effect21.fn("ToolCallRepository.completeAttempt")(function* (tenantId2, callId, attemptId, state, completedAt, error) {
+    yield* sql3`
+        UPDATE relay_tool_attempts
+        SET state = ${state}, error = ${error ?? null}, completed_at = ${ts(completedAt)}
+        WHERE tenant_id = ${tenantId2} AND tool_call_id = ${callId} AND id = ${attemptId} AND state = 'running'
+      `.pipe(Effect21.mapError(toRepositoryError17));
+    const attempt = yield* loadAttempt(tenantId2, callId, attemptId);
+    if (attempt === undefined) {
+      return yield* Effect21.fail(new ToolCallRepositoryError({ message: `Tool attempt not found: ${attemptId}` }));
+    }
+    return attempt;
+  });
+  const ensureCall = Effect21.fn("ToolCallRepository.ensureCall")(function* (input) {
+    const tenantId2 = yield* current();
+    return yield* sql3.withTransaction(Effect21.gen(function* () {
+      yield* insertCallIgnore(tenantId2, input, input.definition, input.placement);
+      const rows = yield* lockedCallRows(tenantId2, input.call.id);
+      if (rows[0] === undefined)
+        return yield* Effect21.fail(new ToolCallNotFound({ id: input.call.id }));
+      const existing = yield* decodeCall(rows[0]);
+      if (existing.executionId !== input.executionId || !sameCallIdentity(existing.call, input.call) || exports_shared_schema.canonicalString(existing.definition) !== exports_shared_schema.canonicalString(input.definition) || exports_shared_schema.canonicalString(existing.placement) !== exports_shared_schema.canonicalString(input.placement)) {
+        return yield* Effect21.fail(new ToolCallConflict({ id: input.call.id }));
+      }
+      if (existing.definition === undefined) {
+        return yield* Effect21.fail(new ToolCallRepositoryError({ message: "Tool call insert returned no row" }));
+      }
+      return existing;
+    })).pipe(Effect21.retry({ times: 3, while: (error) => isSqlError2(error) && error.isRetryable }), Effect21.catchTag("SqlError", (error) => Effect21.fail(toRepositoryError17(error))));
+  });
+  const prepareExternalWait = Effect21.fn("ToolCallRepository.prepareExternalWait")(function* (input) {
+    const tenantId2 = yield* current();
+    return yield* repositoryTransaction(Effect21.gen(function* () {
+      const call = yield* readLockedCall(tenantId2, input.callId);
+      if (call.placement.kind !== "client" && call.placement.kind !== "remote") {
+        return yield* Effect21.fail(new ToolCallTransitionRejected({ id: input.callId, message: "Tool placement is not external" }));
+      }
+      if (call.state === "waiting" && call.waitId === input.waitId)
+        return call;
+      if (call.state !== "requested") {
+        return yield* Effect21.fail(new ToolCallTransitionRejected({ id: input.callId, message: `Call is ${call.state}` }));
+      }
+      yield* sql3`
+            UPDATE relay_tool_calls
+            SET state = 'waiting', wait_id = ${input.waitId}, available_at = ${ts(input.availableAt)},
+                updated_at = ${ts(input.updatedAt)}
+            WHERE tenant_id = ${tenantId2} AND id = ${input.callId} AND state = 'requested'
+          `.pipe(Effect21.mapError(toRepositoryError17));
+      return yield* readLockedCall(tenantId2, input.callId);
+    }));
+  });
+  const beginAttempt = Effect21.fn("ToolCallRepository.beginAttempt")(function* (input) {
+    const tenantId2 = yield* current();
+    return yield* repositoryTransaction(Effect21.gen(function* () {
+      const call = yield* readLockedCall(tenantId2, input.callId);
+      if (call.placement.kind !== "local" && call.placement.kind !== "mcp") {
+        return yield* Effect21.fail(new ToolCallTransitionRejected({ id: input.callId, message: "Tool placement is not immediate" }));
+      }
+      if (call.state === "completed" || call.state === "failed") {
+        return yield* Effect21.fail(new ToolCallTransitionRejected({ id: input.callId, message: `Call is ${call.state}` }));
+      }
+      if (call.activeAttemptId !== undefined) {
+        yield* completeAttempt(tenantId2, input.callId, call.activeAttemptId, "abandoned", input.startedAt);
+      }
+      const attempt = yield* insertAttempt(tenantId2, input.callId, input.startedAt);
+      yield* sql3`
+            UPDATE relay_tool_calls
+            SET state = 'running', active_attempt_id = ${attempt.id}, updated_at = ${ts(input.startedAt)}
+            WHERE tenant_id = ${tenantId2} AND id = ${input.callId}
+          `.pipe(Effect21.mapError(toRepositoryError17));
+      return attempt;
+    }));
+  });
+  const acceptClientOutcome = Effect21.fn("ToolCallRepository.acceptClientOutcome")(function* (input) {
+    const tenantId2 = yield* current();
+    return yield* repositoryTransaction(Effect21.gen(function* () {
+      const call = yield* readLockedCall(tenantId2, input.callId);
+      if (call.executionId !== input.executionId || call.placement.kind !== "client") {
+        return yield* Effect21.fail(new ToolCallTransitionRejected({ id: input.callId, message: "Client outcome does not match the call" }));
+      }
+      if (call.externalOutcome !== undefined) {
+        if (exports_shared_schema.canonicalString(call.externalOutcome) !== exports_shared_schema.canonicalString(input.outcome)) {
+          return yield* Effect21.fail(new ToolOutcomeConflict({ id: input.callId }));
+        }
+        if (call.activeAttemptId === undefined) {
+          return yield* Effect21.fail(new ToolCallTransitionRejected({ id: input.callId, message: "Accepted attempt is missing" }));
+        }
+        const attempt2 = yield* loadAttempt(tenantId2, input.callId, call.activeAttemptId);
+        if (attempt2 === undefined) {
+          return yield* Effect21.fail(new ToolCallTransitionRejected({ id: input.callId, message: "Accepted attempt is missing" }));
+        }
+        return { call, attempt: attempt2, duplicate: true };
+      }
+      if (call.state !== "waiting") {
+        return yield* Effect21.fail(new ToolCallTransitionRejected({ id: input.callId, message: `Call is ${call.state}` }));
+      }
+      const running = yield* insertAttempt(tenantId2, input.callId, input.submittedAt);
+      const attempt = yield* completeAttempt(tenantId2, input.callId, running.id, input.outcome.kind === "success" ? "completed" : "failed", input.submittedAt, input.outcome.kind === "failure" ? input.outcome.message : undefined);
+      yield* sql3`
+            UPDATE relay_tool_calls
+            SET state = 'submitted', active_attempt_id = ${attempt.id},
+                external_outcome_json = ${encodeJson(input.outcome)},
+                external_outcome_at = ${ts(input.submittedAt)}, updated_at = ${ts(input.submittedAt)}
+            WHERE tenant_id = ${tenantId2} AND id = ${input.callId}
+          `.pipe(Effect21.mapError(toRepositoryError17));
+      const updated = yield* readLockedCall(tenantId2, input.callId);
+      return { call: updated, attempt, duplicate: false };
+    }));
+  });
+  const claimCandidate = (tenantId2, input) => sql3`
+      SELECT id
+      FROM relay_tool_calls
+      WHERE tenant_id = ${tenantId2} AND placement_kind = 'remote' AND placement_key = ${input.queue}
+        AND state = 'waiting' AND available_at <= ${ts(input.now)}
+      ORDER BY available_at ASC, created_at ASC, id ASC
+      LIMIT 1
+    `;
+  const selectClaimCandidate = sql3.onDialectOrElse({
+    pg: () => (tenantId2, input) => sql3`
+        ${claimCandidate(tenantId2, input)}
+        FOR UPDATE SKIP LOCKED
+      `,
+    mysql: () => (tenantId2, input) => sql3`
+        ${claimCandidate(tenantId2, input)}
+        FOR UPDATE SKIP LOCKED
+      `,
+    orElse: () => claimCandidate
+  });
+  const claimCall = sql3.onDialectOrElse({
+    mysql: () => (tenantId2, callId, attemptId, input) => sql3`
+          UPDATE relay_tool_calls
+          SET state = 'running', active_attempt_id = ${attemptId}, claim_owner = ${input.workerId},
+              claimed_at = ${ts(input.now)}, claim_expires_at = ${ts(input.claimExpiresAt)},
+              updated_at = ${ts(input.now)}
+          WHERE tenant_id = ${tenantId2} AND id = ${callId} AND state = 'waiting'
+            AND available_at <= ${ts(input.now)}
+        `.pipe(Effect21.as([{ id: callId }])),
+    orElse: () => (tenantId2, callId, attemptId, input) => sql3`
+        UPDATE relay_tool_calls
+        SET state = 'running', active_attempt_id = ${attemptId}, claim_owner = ${input.workerId},
+            claimed_at = ${ts(input.now)}, claim_expires_at = ${ts(input.claimExpiresAt)},
+            updated_at = ${ts(input.now)}
+        WHERE tenant_id = ${tenantId2} AND id = ${callId} AND state = 'waiting'
+          AND available_at <= ${ts(input.now)}
+        RETURNING id
+      `
+  });
+  const claimRemote = Effect21.fn("ToolCallRepository.claimRemote")(function* (input) {
+    if (input.claimExpiresAt <= input.now) {
+      return yield* Effect21.fail(new ToolClaimRejected({ message: "Claim expiry must be after now" }));
+    }
+    const tenantId2 = yield* current();
+    return yield* repositoryTransaction(Effect21.gen(function* () {
+      const expired = yield* sql3`
+            SELECT id, active_attempt_id
+            FROM relay_tool_calls
+            WHERE tenant_id = ${tenantId2} AND placement_kind = 'remote' AND placement_key = ${input.queue}
+              AND state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ${ts(input.now)}
+          `.pipe(Effect21.mapError(toRepositoryError17));
+      for (const row of expired) {
+        if (row.active_attempt_id !== null && row.active_attempt_id !== undefined) {
+          yield* completeAttempt(tenantId2, exports_ids_schema.ToolCallId.make(row.id), exports_ids_schema.ToolAttemptId.make(row.active_attempt_id), "expired", input.now);
+        }
+        yield* sql3`
+              UPDATE relay_tool_calls
+              SET state = 'waiting', active_attempt_id = NULL, claim_owner = NULL, claimed_at = NULL,
+                  claim_expires_at = NULL, updated_at = ${ts(input.now)}
+              WHERE tenant_id = ${tenantId2} AND id = ${row.id} AND state = 'running'
+            `.pipe(Effect21.mapError(toRepositoryError17));
+      }
+      const candidates = yield* selectClaimCandidate(tenantId2, input).pipe(Effect21.mapError(toRepositoryError17));
+      const candidate = candidates[0];
+      if (candidate?.id === undefined)
+        return;
+      const callId = exports_ids_schema.ToolCallId.make(candidate.id);
+      const call = yield* readLockedCall(tenantId2, callId);
+      if (call.definition === undefined || call.placement.kind !== "remote") {
+        return yield* Effect21.fail(new ToolCallTransitionRejected({ id: callId, message: "Remote call definition snapshot is missing" }));
+      }
+      const attemptNumber = yield* nextAttemptNumber(tenantId2, callId);
+      const attemptId = toolAttemptId(attemptNumber);
+      const claimed = yield* claimCall(tenantId2, callId, attemptId, input).pipe(Effect21.mapError(toRepositoryError17));
+      if (claimed[0] === undefined)
+        return;
+      const attempt = yield* insertAttemptNumber(tenantId2, callId, attemptNumber, input.now, input.workerId, input.claimExpiresAt);
+      const updated = yield* readLockedCall(tenantId2, callId);
+      if (updated.definition === undefined || updated.placement.kind !== "remote") {
+        return yield* Effect21.fail(new ToolCallTransitionRejected({ id: callId, message: "Remote call definition snapshot is missing" }));
+      }
+      return {
+        call: { ...updated, definition: updated.definition },
+        attempt,
+        queue: updated.placement.queue,
+        workerId: input.workerId,
+        claimExpiresAt: input.claimExpiresAt,
+        idempotencyKey: updated.idempotencyKey
+      };
+    }));
+  });
+  const releaseRemote = Effect21.fn("ToolCallRepository.releaseRemote")(function* (input) {
+    const tenantId2 = yield* current();
+    return yield* repositoryTransaction(Effect21.gen(function* () {
+      const call = yield* readLockedCall(tenantId2, input.callId);
+      if (call.placement.kind !== "remote" || call.state !== "running" || call.activeAttemptId !== input.attemptId || call.claimOwner !== input.workerId || call.claimExpiresAt === undefined || call.claimExpiresAt <= input.releasedAt) {
+        return yield* Effect21.fail(new ToolClaimRejected({ message: "Remote claim is not active" }));
+      }
+      yield* completeAttempt(tenantId2, input.callId, input.attemptId, "released", input.releasedAt, input.error);
+      yield* sql3`
+            UPDATE relay_tool_calls
+            SET state = 'waiting', available_at = ${ts(input.nextAvailableAt)}, active_attempt_id = NULL,
+                claim_owner = NULL, claimed_at = NULL, claim_expires_at = NULL,
+                updated_at = ${ts(input.releasedAt)}
+            WHERE tenant_id = ${tenantId2} AND id = ${input.callId}
+          `.pipe(Effect21.mapError(toRepositoryError17));
+      return yield* readLockedCall(tenantId2, input.callId);
+    }));
+  });
+  const acceptRemoteOutcome = Effect21.fn("ToolCallRepository.acceptRemoteOutcome")(function* (input) {
+    const tenantId2 = yield* current();
+    return yield* repositoryTransaction(Effect21.gen(function* () {
+      const call = yield* readLockedCall(tenantId2, input.callId);
+      if (call.externalOutcome !== undefined) {
+        if (exports_shared_schema.canonicalString(call.externalOutcome) !== exports_shared_schema.canonicalString(input.outcome)) {
+          return yield* Effect21.fail(new ToolOutcomeConflict({ id: input.callId }));
+        }
+        if (call.activeAttemptId !== input.attemptId) {
+          return yield* Effect21.fail(new ToolClaimRejected({ message: "Remote attempt was not accepted" }));
+        }
+        const attempt2 = yield* loadAttempt(tenantId2, input.callId, input.attemptId);
+        if (attempt2 === undefined || attempt2.callId !== input.callId || attempt2.workerId !== input.workerId) {
+          return yield* Effect21.fail(new ToolClaimRejected({ message: "Remote attempt was not accepted" }));
+        }
+        return { call, attempt: attempt2, duplicate: true };
+      }
+      if (call.placement.kind !== "remote" || call.state !== "running" || call.activeAttemptId !== input.attemptId || call.claimOwner !== input.workerId || call.claimExpiresAt === undefined || call.claimExpiresAt <= input.submittedAt) {
+        return yield* Effect21.fail(new ToolClaimRejected({ message: "Remote claim is not active" }));
+      }
+      const attempt = yield* completeAttempt(tenantId2, input.callId, input.attemptId, input.outcome.kind === "success" ? "completed" : "failed", input.submittedAt, input.outcome.kind === "failure" ? input.outcome.message : undefined);
+      yield* sql3`
+            UPDATE relay_tool_calls
+            SET state = 'submitted', external_outcome_json = ${encodeJson(input.outcome)},
+                external_outcome_at = ${ts(input.submittedAt)}, claim_owner = NULL, claimed_at = NULL,
+                claim_expires_at = NULL, updated_at = ${ts(input.submittedAt)}
+            WHERE tenant_id = ${tenantId2} AND id = ${input.callId}
+          `.pipe(Effect21.mapError(toRepositoryError17));
+      const updated = yield* readLockedCall(tenantId2, input.callId);
+      return { call: updated, attempt, duplicate: false };
+    }));
+  });
+  const listAttempts = Effect21.fn("ToolCallRepository.listAttempts")(function* (callId) {
+    const tenantId2 = yield* current();
+    return yield* readAttempts(tenantId2, callId);
+  });
+  const selectOpenCalls = sql3.onDialectOrElse({
+    pg: () => (tenantId2, input) => sql3`
+        SELECT ${callColumns}
+        FROM relay_tool_calls
+        WHERE tenant_id = ${tenantId2} AND execution_id = ${input.executionId}
+          AND state NOT IN ('submitted', 'completed', 'failed')
+        ORDER BY created_at ASC, id ASC
+        FOR UPDATE
+      `,
+    mysql: () => (tenantId2, input) => sql3`
+        SELECT ${callColumns}
+        FROM relay_tool_calls
+        WHERE tenant_id = ${tenantId2} AND execution_id = ${input.executionId}
+          AND state NOT IN ('submitted', 'completed', 'failed')
+        ORDER BY created_at ASC, id ASC
+        FOR UPDATE
+      `,
     orElse: () => (tenantId2, input) => sql3`
-        ${insertResultStatement(tenantId2, input)}
-        RETURNING ${resultColumns}
+        SELECT ${callColumns}
+        FROM relay_tool_calls
+        WHERE tenant_id = ${tenantId2} AND execution_id = ${input.executionId}
+          AND state NOT IN ('submitted', 'completed', 'failed')
+        ORDER BY created_at ASC, id ASC
       `
   });
+  const failCall = sql3.onDialectOrElse({
+    mysql: () => (tenantId2, callId, failedAt) => sql3`
+          UPDATE relay_tool_calls
+          SET state = 'failed', claim_owner = NULL, claimed_at = NULL, claim_expires_at = NULL,
+              updated_at = ${ts(failedAt)}
+          WHERE tenant_id = ${tenantId2} AND id = ${callId} AND state NOT IN ('submitted', 'completed', 'failed')
+        `.pipe(Effect21.as([{ id: callId }])),
+    orElse: () => (tenantId2, callId, failedAt) => sql3`
+        UPDATE relay_tool_calls
+        SET state = 'failed', claim_owner = NULL, claimed_at = NULL, claim_expires_at = NULL,
+            updated_at = ${ts(failedAt)}
+        WHERE tenant_id = ${tenantId2} AND id = ${callId} AND state NOT IN ('submitted', 'completed', 'failed')
+        RETURNING id
+      `
+  });
+  const failOpenForExecution = Effect21.fn("ToolCallRepository.failOpenForExecution")(function* (input) {
+    const tenantId2 = yield* current();
+    return yield* repositoryTransaction(Effect21.gen(function* () {
+      const rows = yield* selectOpenCalls(tenantId2, input).pipe(Effect21.mapError(toRepositoryError17));
+      const open = yield* Effect21.forEach(rows, decodeCall);
+      const selected = input.callIds === undefined ? undefined : new Set(input.callIds);
+      const failed = [];
+      for (const call of open) {
+        if (selected !== undefined && !selected.has(call.call.id))
+          continue;
+        const transitioned = yield* failCall(tenantId2, call.call.id, input.failedAt).pipe(Effect21.mapError(toRepositoryError17));
+        if (transitioned[0] === undefined)
+          continue;
+        if (call.activeAttemptId !== undefined) {
+          const attempt = yield* loadAttempt(tenantId2, call.call.id, call.activeAttemptId);
+          if (attempt?.state === "running") {
+            yield* completeAttempt(tenantId2, call.call.id, call.activeAttemptId, "failed", input.failedAt, input.message);
+          }
+        }
+        const existingResult = yield* selectResultByKey(tenantId2, call.call.id).pipe(Effect21.mapError(toRepositoryError17));
+        if (existingResult[0] === undefined) {
+          yield* insertResultStatement(tenantId2, {
+            result: { call_id: call.call.id, output: null, error: input.message },
+            createdAt: input.failedAt
+          }).pipe(Effect21.mapError(toRepositoryError17));
+        }
+        failed.push(yield* readLockedCall(tenantId2, call.call.id));
+      }
+      return failed;
+    }));
+  });
   const recordCall = Effect21.fn("ToolCallRepository.recordCall")(function* (input) {
     const tenantId2 = yield* current();
     const existing = yield* selectCallByKey(tenantId2, input.call.id).pipe(Effect21.mapError(toRepositoryError17));
@@ -6493,12 +7240,12 @@ var layer20 = Layer21.effect(Service21, Effect21.gen(function* () {
     if (row === undefined) {
       return yield* Effect21.fail(new ToolCallRepositoryError({ message: "Tool call insert returned no row" }));
     }
-    return toCallRecord(yield* decodeCallRow(row));
+    return yield* decodeCall(row);
   });
   const getCall = Effect21.fn("ToolCallRepository.getCall")(function* (id2) {
     const tenantId2 = yield* current();
     const rows = yield* selectCallByKey(tenantId2, id2).pipe(Effect21.mapError(toRepositoryError17));
-    return rows[0] === undefined ? undefined : toCallRecord(yield* decodeCallRow(rows[0]));
+    return rows[0] === undefined ? undefined : yield* decodeCall(rows[0]);
   });
   const listCalls = Effect21.fn("ToolCallRepository.listCalls")(function* (executionId) {
     const tenantId2 = yield* current();
@@ -6506,71 +7253,428 @@ var layer20 = Layer21.effect(Service21, Effect21.gen(function* () {
         SELECT ${callColumns}
         FROM relay_tool_calls
         WHERE tenant_id = ${tenantId2} AND execution_id = ${executionId}
-        ORDER BY created_at ASC
+        ORDER BY created_at ASC, id ASC
       `.pipe(Effect21.mapError(toRepositoryError17));
-    const decoded = yield* Effect21.forEach(rows, decodeCallRow);
-    return decoded.map(toCallRecord);
+    return yield* Effect21.forEach(rows, decodeCall);
   });
   const recordResult = Effect21.fn("ToolCallRepository.recordResult")(function* (input) {
     const tenantId2 = yield* current();
-    const callRows = yield* selectCallByKey(tenantId2, input.result.call_id).pipe(Effect21.mapError(toRepositoryError17));
-    if (callRows[0] === undefined)
-      return yield* Effect21.fail(new ToolCallNotFound({ id: input.result.call_id }));
-    const existing = yield* selectResultByKey(tenantId2, input.result.call_id).pipe(Effect21.mapError(toRepositoryError17));
-    if (existing[0] !== undefined) {
-      return yield* Effect21.fail(new DuplicateToolResult({ call_id: input.result.call_id }));
-    }
-    const rows = yield* insertResult(tenantId2, input).pipe(Effect21.mapError(toRepositoryError17));
-    const row = rows[0];
-    if (row === undefined) {
-      return yield* Effect21.fail(new ToolCallRepositoryError({ message: "Tool result insert returned no row" }));
-    }
-    return toResultRecord(yield* decodeResultRow(row));
+    return yield* repositoryTransaction(Effect21.gen(function* () {
+      const call = yield* readLockedCall(tenantId2, input.result.call_id);
+      const existing = yield* selectResultByKey(tenantId2, input.result.call_id).pipe(Effect21.mapError(toRepositoryError17));
+      if (existing[0] !== undefined) {
+        return yield* Effect21.fail(new DuplicateToolResult({ call_id: input.result.call_id }));
+      }
+      yield* insertResultStatement(tenantId2, input).pipe(Effect21.mapError(toRepositoryError17));
+      if (call.activeAttemptId !== undefined) {
+        const attempt = yield* loadAttempt(tenantId2, input.result.call_id, call.activeAttemptId);
+        if (attempt?.state === "running") {
+          yield* completeAttempt(tenantId2, input.result.call_id, call.activeAttemptId, input.result.error === undefined ? "completed" : "failed", input.createdAt, input.result.error);
+        }
+      }
+      yield* sql3`
+            UPDATE relay_tool_calls
+            SET state = ${input.result.error === undefined ? "completed" : "failed"},
+                claim_owner = NULL, claimed_at = NULL, claim_expires_at = NULL,
+                updated_at = ${ts(input.createdAt)}
+            WHERE tenant_id = ${tenantId2} AND id = ${input.result.call_id}
+          `.pipe(Effect21.mapError(toRepositoryError17));
+      const rows = yield* selectResultByKey(tenantId2, input.result.call_id).pipe(Effect21.mapError(toRepositoryError17));
+      if (rows[0] === undefined) {
+        return yield* Effect21.fail(new ToolCallRepositoryError({ message: "Tool result insert returned no row" }));
+      }
+      return toResultRecord(yield* decodeResultRow(rows[0]));
+    }));
   });
   const getResult = Effect21.fn("ToolCallRepository.getResult")(function* (callId) {
     const tenantId2 = yield* current();
     const rows = yield* selectResultByKey(tenantId2, callId).pipe(Effect21.mapError(toRepositoryError17));
     return rows[0] === undefined ? undefined : toResultRecord(yield* decodeResultRow(rows[0]));
   });
-  return Service21.of({ recordCall, getCall, listCalls, recordResult, getResult });
+  return Service21.of({
+    ensureCall,
+    recordCall,
+    getCall,
+    listCalls,
+    recordResult,
+    getResult,
+    prepareExternalWait,
+    beginAttempt,
+    acceptClientOutcome,
+    claimRemote,
+    releaseRemote,
+    acceptRemoteOutcome,
+    listAttempts,
+    failOpenForExecution
+  });
 }));
 var memoryLayer18 = Layer21.sync(Service21, () => {
   const calls = new Map;
+  const callTenants = new Map;
   const results = new Map;
+  const attempts = new Map;
+  const key2 = (tenantId2, callId) => exports_shared_schema.canonicalString([tenantId2, callId]);
+  const same = (left, right) => exports_shared_schema.canonicalString(left) === exports_shared_schema.canonicalString(right);
+  const callRecord = (tenantId2, input, definition, placement = { kind: "local" }) => ({
+    executionId: input.executionId,
+    call: normalizeCall(input.call),
+    ...definition === undefined ? {} : { definition },
+    placement,
+    state: "requested",
+    idempotencyKey: toolCallIdempotencyKey(tenantId2, input.executionId, input.call.id),
+    availableAt: input.createdAt,
+    createdAt: input.createdAt,
+    updatedAt: input.createdAt
+  });
+  const attemptsFor = (tenantId2, callId) => attempts.get(key2(tenantId2, callId)) ?? [];
+  const replaceAttempt = (tenantId2, attempt) => {
+    const callAttempts = attemptsFor(tenantId2, attempt.callId);
+    attempts.set(key2(tenantId2, attempt.callId), callAttempts.map((existing) => existing.id === attempt.id ? attempt : existing));
+  };
+  const appendAttempt = (tenantId2, callId, createdAt, options = {}) => {
+    const callAttempts = attemptsFor(tenantId2, callId);
+    const attemptNumber = callAttempts.length + 1;
+    const attempt = {
+      id: toolAttemptId(attemptNumber),
+      callId,
+      attemptNumber,
+      state: "running",
+      ...options.workerId === undefined ? {} : { workerId: options.workerId },
+      ...options.claimExpiresAt === undefined ? {} : { claimExpiresAt: options.claimExpiresAt },
+      createdAt
+    };
+    attempts.set(key2(tenantId2, callId), [...callAttempts, attempt]);
+    return attempt;
+  };
+  const requireCall = (tenantId2, callId) => {
+    const record2 = calls.get(key2(tenantId2, callId));
+    return record2 === undefined ? Effect21.fail(new ToolCallNotFound({ id: callId })) : Effect21.succeed(record2);
+  };
+  const transitionRejected = (id2, message) => Effect21.fail(new ToolCallTransitionRejected({ id: id2, message }));
   return Service21.of({
+    ensureCall: Effect21.fn("ToolCallRepository.memory.ensureCall")(function* (input) {
+      const tenantId2 = yield* current();
+      const storageKey = key2(tenantId2, input.call.id);
+      const existing = calls.get(storageKey);
+      if (existing !== undefined) {
+        if (existing.executionId !== input.executionId || !sameCallIdentity(existing.call, input.call) || !same(existing.definition, input.definition) || !same(existing.placement, input.placement)) {
+          return yield* Effect21.fail(new ToolCallConflict({ id: input.call.id }));
+        }
+        return existing;
+      }
+      const record2 = callRecord(tenantId2, input, input.definition, input.placement);
+      calls.set(storageKey, record2);
+      callTenants.set(storageKey, tenantId2);
+      return record2;
+    }),
     recordCall: Effect21.fn("ToolCallRepository.memory.recordCall")(function* (input) {
-      if (calls.has(input.call.id))
+      const tenantId2 = yield* current();
+      const storageKey = key2(tenantId2, input.call.id);
+      if (calls.has(storageKey))
         return yield* Effect21.fail(new DuplicateToolCall({ id: input.call.id }));
-      const record2 = {
-        executionId: input.executionId,
-        call: input.call,
-        createdAt: input.createdAt
-      };
-      yield* Effect21.sync(() => calls.set(input.call.id, record2));
+      const record2 = callRecord(tenantId2, input);
+      calls.set(storageKey, record2);
+      callTenants.set(storageKey, tenantId2);
+      return record2;
+    }),
+    getCall: Effect21.fn("ToolCallRepository.memory.getCall")(function* (id2) {
+      const tenantId2 = yield* current();
+      return calls.get(key2(tenantId2, id2));
+    }),
+    listCalls: Effect21.fn("ToolCallRepository.memory.listCalls")(function* (executionId) {
+      const tenantId2 = yield* current();
+      return [...calls.entries()].filter(([storageKey, record2]) => callTenants.get(storageKey) === tenantId2 && record2.executionId === executionId).map(([, record2]) => record2).toSorted((a, b) => a.createdAt - b.createdAt || a.call.id.localeCompare(b.call.id));
+    }),
+    recordResult: Effect21.fn("ToolCallRepository.memory.recordResult")(function* (input) {
+      const tenantId2 = yield* current();
+      const storageKey = key2(tenantId2, input.result.call_id);
+      const call = calls.get(storageKey);
+      if (call === undefined)
+        return yield* Effect21.fail(new ToolCallNotFound({ id: input.result.call_id }));
+      if (results.has(storageKey)) {
+        return yield* Effect21.fail(new DuplicateToolResult({ call_id: input.result.call_id }));
+      }
+      if (call.activeAttemptId !== undefined) {
+        const active = attemptsFor(tenantId2, input.result.call_id).find((attempt) => attempt.id === call.activeAttemptId);
+        if (active?.state === "running") {
+          replaceAttempt(tenantId2, {
+            ...active,
+            state: input.result.error === undefined ? "completed" : "failed",
+            ...input.result.error === undefined ? {} : { error: input.result.error },
+            completedAt: input.createdAt
+          });
+        }
+      }
+      const record2 = { result: input.result, createdAt: input.createdAt };
+      results.set(storageKey, record2);
+      calls.set(storageKey, {
+        ...call,
+        state: input.result.error === undefined ? "completed" : "failed",
+        updatedAt: input.createdAt
+      });
       return record2;
     }),
-    getCall: Effect21.fn("ToolCallRepository.memory.getCall")(function* (id2) {
-      return yield* Effect21.sync(() => calls.get(id2));
+    getResult: Effect21.fn("ToolCallRepository.memory.getResult")(function* (callId) {
+      const tenantId2 = yield* current();
+      return results.get(key2(tenantId2, callId));
+    }),
+    prepareExternalWait: Effect21.fn("ToolCallRepository.memory.prepareExternalWait")(function* (input) {
+      const tenantId2 = yield* current();
+      const call = yield* requireCall(tenantId2, input.callId);
+      if (call.placement.kind !== "client" && call.placement.kind !== "remote") {
+        return yield* transitionRejected(input.callId, "Tool placement is not external");
+      }
+      if (call.state === "waiting" && call.waitId === input.waitId)
+        return call;
+      if (call.state !== "requested")
+        return yield* transitionRejected(input.callId, `Call is ${call.state}`);
+      const updated = {
+        ...call,
+        state: "waiting",
+        waitId: input.waitId,
+        availableAt: input.availableAt,
+        updatedAt: input.updatedAt
+      };
+      calls.set(key2(tenantId2, input.callId), updated);
+      return updated;
+    }),
+    beginAttempt: Effect21.fn("ToolCallRepository.memory.beginAttempt")(function* (input) {
+      const tenantId2 = yield* current();
+      const call = yield* requireCall(tenantId2, input.callId);
+      if (call.placement.kind !== "local" && call.placement.kind !== "mcp") {
+        return yield* transitionRejected(input.callId, "Tool placement is not immediate");
+      }
+      if (call.state === "completed" || call.state === "failed") {
+        return yield* transitionRejected(input.callId, `Call is ${call.state}`);
+      }
+      if (call.activeAttemptId !== undefined) {
+        const active = attemptsFor(tenantId2, input.callId).find((attempt2) => attempt2.id === call.activeAttemptId);
+        if (active?.state === "running") {
+          replaceAttempt(tenantId2, { ...active, state: "abandoned", completedAt: input.startedAt });
+        }
+      }
+      const attempt = appendAttempt(tenantId2, input.callId, input.startedAt);
+      calls.set(key2(tenantId2, input.callId), {
+        ...call,
+        state: "running",
+        activeAttemptId: attempt.id,
+        updatedAt: input.startedAt
+      });
+      return attempt;
+    }),
+    acceptClientOutcome: Effect21.fn("ToolCallRepository.memory.acceptClientOutcome")(function* (input) {
+      const tenantId2 = yield* current();
+      const call = yield* requireCall(tenantId2, input.callId);
+      if (call.executionId !== input.executionId || call.placement.kind !== "client") {
+        return yield* transitionRejected(input.callId, "Client outcome does not match the call");
+      }
+      if (call.externalOutcome !== undefined) {
+        if (!same(call.externalOutcome, input.outcome)) {
+          return yield* Effect21.fail(new ToolOutcomeConflict({ id: input.callId }));
+        }
+        const attempt2 = attemptsFor(tenantId2, input.callId).find((item) => item.id === call.activeAttemptId);
+        if (attempt2 === undefined)
+          return yield* transitionRejected(input.callId, "Accepted attempt is missing");
+        return { call, attempt: attempt2, duplicate: true };
+      }
+      if (call.state !== "waiting")
+        return yield* transitionRejected(input.callId, `Call is ${call.state}`);
+      const running = appendAttempt(tenantId2, input.callId, input.submittedAt);
+      const attempt = {
+        ...running,
+        state: input.outcome.kind === "success" ? "completed" : "failed",
+        ...input.outcome.kind === "failure" ? { error: input.outcome.message } : {},
+        completedAt: input.submittedAt
+      };
+      replaceAttempt(tenantId2, attempt);
+      const updated = {
+        ...call,
+        state: "submitted",
+        activeAttemptId: attempt.id,
+        externalOutcome: input.outcome,
+        externalOutcomeAt: input.submittedAt,
+        updatedAt: input.submittedAt
+      };
+      calls.set(key2(tenantId2, input.callId), updated);
+      return { call: updated, attempt, duplicate: false };
+    }),
+    claimRemote: Effect21.fn("ToolCallRepository.memory.claimRemote")(function* (input) {
+      const tenantId2 = yield* current();
+      if (input.claimExpiresAt <= input.now) {
+        return yield* Effect21.fail(new ToolClaimRejected({ message: "Claim expiry must be after now" }));
+      }
+      for (const [storageKey, call] of calls) {
+        if (callTenants.get(storageKey) !== tenantId2 || call.placement.kind !== "remote" || call.state !== "running" || call.claimExpiresAt === undefined || call.claimExpiresAt > input.now) {
+          continue;
+        }
+        const active = attemptsFor(tenantId2, call.call.id).find((attempt2) => attempt2.id === call.activeAttemptId);
+        if (active?.state === "running") {
+          replaceAttempt(tenantId2, { ...active, state: "expired", completedAt: input.now });
+        }
+        calls.set(storageKey, {
+          ...call,
+          state: "waiting",
+          activeAttemptId: undefined,
+          claimOwner: undefined,
+          claimedAt: undefined,
+          claimExpiresAt: undefined,
+          updatedAt: input.now
+        });
+      }
+      const candidate = [...calls.entries()].filter(([storageKey, call]) => callTenants.get(storageKey) === tenantId2 && call.placement.kind === "remote" && call.placement.queue === input.queue && call.state === "waiting" && call.availableAt <= input.now).map(([, call]) => call).toSorted((left, right) => left.availableAt - right.availableAt || left.createdAt - right.createdAt || left.call.id.localeCompare(right.call.id))[0];
+      if (candidate === undefined)
+        return;
+      if (candidate.definition === undefined) {
+        return yield* transitionRejected(candidate.call.id, "Remote call definition snapshot is missing");
+      }
+      const attempt = appendAttempt(tenantId2, candidate.call.id, input.now, {
+        workerId: input.workerId,
+        claimExpiresAt: input.claimExpiresAt
+      });
+      const updated = {
+        ...candidate,
+        definition: candidate.definition,
+        state: "running",
+        activeAttemptId: attempt.id,
+        claimOwner: input.workerId,
+        claimedAt: input.now,
+        claimExpiresAt: input.claimExpiresAt,
+        updatedAt: input.now
+      };
+      calls.set(key2(tenantId2, candidate.call.id), updated);
+      return {
+        call: updated,
+        attempt,
+        queue: input.queue,
+        workerId: input.workerId,
+        claimExpiresAt: input.claimExpiresAt,
+        idempotencyKey: updated.idempotencyKey
+      };
+    }),
+    releaseRemote: Effect21.fn("ToolCallRepository.memory.releaseRemote")(function* (input) {
+      const tenantId2 = yield* current();
+      const call = yield* requireCall(tenantId2, input.callId);
+      const valid = call.placement.kind === "remote" && call.state === "running" && call.activeAttemptId === input.attemptId && call.claimOwner === input.workerId && call.claimExpiresAt !== undefined && call.claimExpiresAt > input.releasedAt;
+      if (!valid)
+        return yield* Effect21.fail(new ToolClaimRejected({ message: "Remote claim is not active" }));
+      const attempt = attemptsFor(tenantId2, input.callId).find((item) => item.id === input.attemptId);
+      if (attempt === undefined)
+        return yield* transitionRejected(input.callId, "Remote attempt is missing");
+      replaceAttempt(tenantId2, {
+        ...attempt,
+        state: "released",
+        ...input.error === undefined ? {} : { error: input.error },
+        completedAt: input.releasedAt
+      });
+      const updated = {
+        ...call,
+        state: "waiting",
+        availableAt: input.nextAvailableAt,
+        activeAttemptId: undefined,
+        claimOwner: undefined,
+        claimedAt: undefined,
+        claimExpiresAt: undefined,
+        updatedAt: input.releasedAt
+      };
+      calls.set(key2(tenantId2, input.callId), updated);
+      return updated;
+    }),
+    acceptRemoteOutcome: Effect21.fn("ToolCallRepository.memory.acceptRemoteOutcome")(function* (input) {
+      const tenantId2 = yield* current();
+      const call = yield* requireCall(tenantId2, input.callId);
+      if (call.externalOutcome !== undefined) {
+        if (!same(call.externalOutcome, input.outcome)) {
+          return yield* Effect21.fail(new ToolOutcomeConflict({ id: input.callId }));
+        }
+        if (call.activeAttemptId !== input.attemptId) {
+          return yield* Effect21.fail(new ToolClaimRejected({ message: "Remote attempt was not accepted" }));
+        }
+        const attempt2 = attemptsFor(tenantId2, input.callId).find((item) => item.id === input.attemptId);
+        if (attempt2 === undefined || attempt2.callId !== input.callId || attempt2.workerId !== input.workerId) {
+          return yield* Effect21.fail(new ToolClaimRejected({ message: "Remote attempt was not accepted" }));
+        }
+        return { call, attempt: attempt2, duplicate: true };
+      }
+      const valid = call.placement.kind === "remote" && call.state === "running" && call.activeAttemptId === input.attemptId && call.claimOwner === input.workerId && call.claimExpiresAt !== undefined && call.claimExpiresAt > input.submittedAt;
+      if (!valid)
+        return yield* Effect21.fail(new ToolClaimRejected({ message: "Remote claim is not active" }));
+      const running = attemptsFor(tenantId2, input.callId).find((item) => item.id === input.attemptId);
+      if (running === undefined)
+        return yield* transitionRejected(input.callId, "Remote attempt is missing");
+      const attempt = {
+        ...running,
+        state: input.outcome.kind === "success" ? "completed" : "failed",
+        ...input.outcome.kind === "failure" ? { error: input.outcome.message } : {},
+        completedAt: input.submittedAt
+      };
+      replaceAttempt(tenantId2, attempt);
+      const updated = {
+        ...call,
+        state: "submitted",
+        externalOutcome: input.outcome,
+        externalOutcomeAt: input.submittedAt,
+        claimOwner: undefined,
+        claimedAt: undefined,
+        claimExpiresAt: undefined,
+        updatedAt: input.submittedAt
+      };
+      calls.set(key2(tenantId2, input.callId), updated);
+      return { call: updated, attempt, duplicate: false };
     }),
-    listCalls: Effect21.fn("ToolCallRepository.memory.listCalls")(function* (executionId) {
-      return yield* Effect21.sync(() => [...calls.values()].filter((record2) => record2.executionId === executionId).toSorted((a, b) => a.createdAt - b.createdAt));
+    listAttempts: Effect21.fn("ToolCallRepository.memory.listAttempts")(function* (callId) {
+      const tenantId2 = yield* current();
+      return attemptsFor(tenantId2, callId);
     }),
-    recordResult: Effect21.fn("ToolCallRepository.memory.recordResult")(function* (input) {
-      if (!calls.has(input.result.call_id))
-        return yield* Effect21.fail(new ToolCallNotFound({ id: input.result.call_id }));
-      if (results.has(input.result.call_id)) {
-        return yield* Effect21.fail(new DuplicateToolResult({ call_id: input.result.call_id }));
+    failOpenForExecution: Effect21.fn("ToolCallRepository.memory.failOpenForExecution")(function* (input) {
+      const tenantId2 = yield* current();
+      const failed = [];
+      for (const [storageKey, call] of calls) {
+        if (callTenants.get(storageKey) !== tenantId2 || call.executionId !== input.executionId || input.callIds !== undefined && !input.callIds.includes(call.call.id) || call.state === "submitted" || call.state === "completed" || call.state === "failed") {
+          continue;
+        }
+        if (call.activeAttemptId !== undefined) {
+          const active = attemptsFor(tenantId2, call.call.id).find((attempt) => attempt.id === call.activeAttemptId);
+          if (active?.state === "running") {
+            replaceAttempt(tenantId2, {
+              ...active,
+              state: "failed",
+              error: input.message,
+              completedAt: input.failedAt
+            });
+          }
+        }
+        const updated = {
+          ...call,
+          state: "failed",
+          claimOwner: undefined,
+          claimedAt: undefined,
+          claimExpiresAt: undefined,
+          updatedAt: input.failedAt
+        };
+        calls.set(storageKey, updated);
+        results.set(storageKey, {
+          result: { call_id: call.call.id, output: null, error: input.message },
+          createdAt: input.failedAt
+        });
+        failed.push(updated);
       }
-      const record2 = { result: input.result, createdAt: input.createdAt };
-      yield* Effect21.sync(() => results.set(input.result.call_id, record2));
-      return record2;
-    }),
-    getResult: Effect21.fn("ToolCallRepository.memory.getResult")(function* (callId) {
-      return yield* Effect21.sync(() => results.get(callId));
+      return failed.toSorted((left, right) => left.createdAt - right.createdAt || left.call.id.localeCompare(right.call.id));
     })
   });
 });
-var testLayer18 = (implementation) => Layer21.succeed(Service21, Service21.of(implementation));
+var unsupportedTestOperation = (operation) => Effect21.fail(new ToolCallRepositoryError({ message: `ToolCallRepository.testLayer does not implement ${operation}` }));
+var testLayer18 = (implementation) => Layer21.succeed(Service21, Service21.of({
+  ensureCall: () => unsupportedTestOperation("ensureCall"),
+  prepareExternalWait: () => unsupportedTestOperation("prepareExternalWait"),
+  beginAttempt: () => unsupportedTestOperation("beginAttempt"),
+  acceptClientOutcome: () => unsupportedTestOperation("acceptClientOutcome"),
+  claimRemote: () => unsupportedTestOperation("claimRemote"),
+  releaseRemote: () => unsupportedTestOperation("releaseRemote"),
+  acceptRemoteOutcome: () => unsupportedTestOperation("acceptRemoteOutcome"),
+  listAttempts: () => unsupportedTestOperation("listAttempts"),
+  failOpenForExecution: () => unsupportedTestOperation("failOpenForExecution"),
+  ...implementation
+}));
 var recordCall = Effect21.fn("ToolCallRepository.recordCall.call")(function* (input) {
   const repository = yield* Service21;
   return yield* repository.recordCall(input);
@@ -6591,6 +7695,42 @@ var getResult = Effect21.fn("ToolCallRepository.getResult.call")(function* (call
   const repository = yield* Service21;
   return yield* repository.getResult(callId);
 });
+var ensureCall = Effect21.fn("ToolCallRepository.ensureCall.call")(function* (input) {
+  const repository = yield* Service21;
+  return yield* repository.ensureCall(input);
+});
+var prepareExternalWait = Effect21.fn("ToolCallRepository.prepareExternalWait.call")(function* (input) {
+  const repository = yield* Service21;
+  return yield* repository.prepareExternalWait(input);
+});
+var beginAttempt = Effect21.fn("ToolCallRepository.beginAttempt.call")(function* (input) {
+  const repository = yield* Service21;
+  return yield* repository.beginAttempt(input);
+});
+var acceptClientOutcome = Effect21.fn("ToolCallRepository.acceptClientOutcome.call")(function* (input) {
+  const repository = yield* Service21;
+  return yield* repository.acceptClientOutcome(input);
+});
+var claimRemote = Effect21.fn("ToolCallRepository.claimRemote.call")(function* (input) {
+  const repository = yield* Service21;
+  return yield* repository.claimRemote(input);
+});
+var releaseRemote = Effect21.fn("ToolCallRepository.releaseRemote.call")(function* (input) {
+  const repository = yield* Service21;
+  return yield* repository.releaseRemote(input);
+});
+var acceptRemoteOutcome = Effect21.fn("ToolCallRepository.acceptRemoteOutcome.call")(function* (input) {
+  const repository = yield* Service21;
+  return yield* repository.acceptRemoteOutcome(input);
+});
+var listAttempts = Effect21.fn("ToolCallRepository.listAttempts.call")(function* (callId) {
+  const repository = yield* Service21;
+  return yield* repository.listAttempts(callId);
+});
+var failOpenForExecution = Effect21.fn("ToolCallRepository.failOpenForExecution.call")(function* (input) {
+  const repository = yield* Service21;
+  return yield* repository.failOpenForExecution(input);
+});
 // ../store-sql/src/workspace/workspace-lease-repository.ts
 var exports_workspace_lease_repository = {};
 __export(exports_workspace_lease_repository, {
@@ -7285,6 +8425,7 @@ __export(exports_tool_runtime_service, {
   tool: () => tool,
   testLayer: () => testLayer23,
   run: () => run,
+  remoteTool: () => remoteTool,
   registeredTools: () => registeredTools,
   register: () => register2,
   memoryLayerFromToolkit: () => memoryLayerFromToolkit,
@@ -7293,6 +8434,7 @@ __export(exports_tool_runtime_service, {
   layer: () => layer23,
   dynamicTool: () => dynamicTool,
   definitions: () => definitions,
+  clientTool: () => clientTool,
   ToolRuntimeError: () => ToolRuntimeError,
   ToolPermissionDenied: () => ToolPermissionDenied,
   ToolNotRegistered: () => ToolNotRegistered,
@@ -7317,6 +8459,7 @@ __export(exports_event_log_service, {
   layerFromRepository: () => layerFromRepository2,
   findFirstByTypeAfterSequence: () => findFirstByTypeAfterSequence2,
   findBySequenceOrCursor: () => findBySequenceOrCursor2,
+  findBySequence: () => findBySequence2,
   findByCursor: () => findByCursor2,
   appendIdempotentTo: () => appendIdempotentTo,
   appendIdempotent: () => appendIdempotent,
@@ -7472,6 +8615,7 @@ var layerFromRepository2 = Layer24.effect(Service24, Effect26.gen(function* () {
     stream: (input) => Stream3.unwrap(loadReplay(input).pipe(Effect26.map(({ history, sequence }) => Stream3.fromIterable(history).pipe(Stream3.concat(liveTail(repository, pubsub, input, history.at(-1)?.sequence ?? sequence, pollInterval).pipe(Stream3.takeUntil(isTerminal))))))),
     findBySequenceOrCursor: Effect26.fn("EventLog.repository.findBySequenceOrCursor")((input) => repository.findBySequenceOrCursor(input).pipe(Effect26.mapError(mapRepositoryFindError))),
     findByCursor: Effect26.fn("EventLog.repository.findByCursor")((input) => repository.findByCursor(input).pipe(Effect26.mapError(mapRepositoryFindError))),
+    findBySequence: Effect26.fn("EventLog.repository.findBySequence")((input) => repository.findBySequence(input).pipe(Effect26.mapError(mapRepositoryFindError))),
     findFirstByTypeAfterSequence: Effect26.fn("EventLog.repository.findFirstByTypeAfterSequence")((input) => repository.findFirstByTypeAfterSequence(input).pipe(Effect26.mapError(mapRepositoryFindError))),
     maxSequence: Effect26.fn("EventLog.repository.maxSequence")((executionId) => repository.maxSequence(executionId).pipe(Effect26.mapError(mapRepositoryFindError))),
     sumUsage: Effect26.fn("EventLog.repository.sumUsage")((executionId) => repository.sumUsage(executionId).pipe(Effect26.mapError(mapRepositoryFindError)))
@@ -7531,6 +8675,11 @@ var memoryLayer21 = Layer24.effect(Service24, Effect26.gen(function* () {
       const event = executionEvents.find((item) => item.cursor === input.cursor);
       return event === undefined ? Option4.none() : Option4.some(event);
     }),
+    findBySequence: Effect26.fn("EventLog.memory.findBySequence")(function* (input) {
+      const executionEvents = yield* allEvents(input.executionId);
+      const event = executionEvents.find((item) => item.sequence === input.sequence);
+      return event === undefined ? Option4.none() : Option4.some(event);
+    }),
     findFirstByTypeAfterSequence: Effect26.fn("EventLog.memory.findFirstByTypeAfterSequence")(function* (input) {
       const executionEvents = yield* allEvents(input.executionId);
       const event = executionEvents.find((item) => item.type === input.type && item.sequence > input.afterSequence);
@@ -7575,6 +8724,10 @@ var findByCursor2 = Effect26.fn("EventLog.findByCursor.call")(function* (input)
   const service = yield* Service24;
   return yield* service.findByCursor(input);
 });
+var findBySequence2 = Effect26.fn("EventLog.findBySequence.call")(function* (input) {
+  const service = yield* Service24;
+  return yield* service.findBySequence(input);
+});
 var findFirstByTypeAfterSequence2 = Effect26.fn("EventLog.findFirstByTypeAfterSequence.call")(function* (input) {
   const service = yield* Service24;
   return yield* service.findFirstByTypeAfterSequence(input);
@@ -7890,6 +9043,11 @@ var requestedEvent = (input) => ({
   },
   created_at: input.createdAt
 });
+var sameToolEventPayload = (left, right) => left.id === right.id && left.execution_id === right.execution_id && left.child_execution_id === right.child_execution_id && left.type === right.type && left.cursor === right.cursor && left.created_at === right.created_at && exports_shared_schema.canonicalString(left.data ?? {}) === exports_shared_schema.canonicalString(right.data ?? {});
+var ensureToolEvent = (eventLog, event) => eventLog.findByCursor({ executionId: event.execution_id, cursor: event.cursor }).pipe(Effect28.mapError(mapEventLogError2), Effect28.flatMap(Option6.match({
+  onNone: () => appendIdempotentTo(eventLog, event).pipe(Effect28.mapError(mapEventLogError2), Effect28.asVoid),
+  onSome: (existing) => sameToolEventPayload(existing, event) ? Effect28.void : Effect28.fail(new ToolRuntimeError({ message: "EventLogError" }))
+})));
 var resultEvent = (input, result) => ({
   id: exports_ids_schema.EventId.make(`event:${input.call.id}:tool-result`),
   execution_id: input.executionId,
@@ -7941,13 +9099,17 @@ var runHandledToolkitTool = (toolkit, name, input) => toolkit.handle(name, input
   onNone: () => Effect28.fail("Tool handler did not produce a final result"),
   onSome: (result) => result.isFailure ? Effect28.fail(result.result) : Effect28.succeed(jsonValue(result.encodedResult))
 })));
-var finalToolResult = (tool, input) => Effect28.gen(function* () {
+var finalToolResult = (tool, input, idempotencyKey) => Effect28.gen(function* () {
+  if (tool.run === undefined) {
+    return yield* Effect28.fail(new ToolRuntimeError({ message: `Tool ${tool.definition.name} has no local handler` }));
+  }
   const context = {
     executionId: input.executionId,
     call: input.call,
     permissions: input.permissions,
     eventSequence: input.eventSequence,
-    createdAt: input.createdAt
+    createdAt: input.createdAt,
+    idempotencyKey
   };
   const callInfo = ToolCallInfo.of(context);
   const output = yield* tool.run(input.call.input, context).pipe(Effect28.provideService(ToolCallInfo, callInfo), Effect28.mapError((error) => preserveToolError(input.call.name, error)));
@@ -8021,11 +9183,17 @@ var resolveApproval = (waits, eventLog, input) => Effect28.gen(function* () {
     return { _tag: "approved" };
   return { _tag: "denied", reason: deniedReason(existing.state) };
 });
-var recordRequested = (repository, eventLog, input) => repository.getCall(input.call.id).pipe(Effect28.mapError(mapRepositoryError4), Effect28.flatMap((existing) => {
-  if (existing !== undefined)
-    return Effect28.void;
-  return repository.recordCall({ executionId: input.executionId, call: input.call, createdAt: input.createdAt }).pipe(Effect28.mapError(mapRepositoryError4), Effect28.flatMap(() => appendIdempotentTo(eventLog, requestedEvent(input)).pipe(Effect28.mapError(mapEventLogError2))), Effect28.asVoid);
-}));
+var recordRequested = (repository, eventLog, input, tool) => repository.ensureCall({
+  executionId: input.executionId,
+  call: input.call,
+  definition: tool.definition,
+  placement: tool.placement ?? { kind: "local" },
+  createdAt: input.createdAt
+}).pipe(Effect28.mapError(mapRepositoryError4), Effect28.tap((call) => ensureToolEvent(eventLog, requestedEvent({ ...input, createdAt: call.createdAt }))));
+var repairResultEvent = (eventLog, input, record2) => {
+  const event = resultEvent({ ...input, createdAt: record2.createdAt - 1 }, record2.result);
+  return ensureToolEvent(eventLog, event);
+};
 var recordReceived = (repository, eventLog, input, result) => repository.recordResult({ result, createdAt: input.createdAt + 1 }).pipe(Effect28.catchTag("DuplicateToolResult", () => repository.getResult(result.call_id).pipe(Effect28.mapError(mapRepositoryError4), Effect28.flatMap((existing) => existing === undefined ? Effect28.fail(new ToolRuntimeError({ message: "DuplicateToolResult" })) : Effect28.succeed(existing)))), Effect28.mapError(preserveRecordResultError), Effect28.flatMap((record2) => appendIdempotentTo(eventLog, resultEvent(input, record2.result)).pipe(Effect28.mapError(mapEventLogError2), Effect28.as(record2.result))));
 var nonEmptyName = (name) => Schema35.decodeUnknownSync(exports_shared_schema.NonEmptyString)(name);
 var needsApprovalFromEffectTool = (tool) => tool.needsApproval === undefined ? undefined : typeof tool.needsApproval === "boolean" ? tool.needsApproval : true;
@@ -8046,6 +9214,7 @@ var registeredToolFromToolkit = (toolkit, modelTool, options = {}) => {
   return {
     definition: definitionFromEffectTool(modelTool, { ...toolOptions, needsApproval }),
     tool: modelTool,
+    ...toolOptions.placement === undefined ? {} : { placement: toolOptions.placement },
     ...toolOptions.requiredPermissions === undefined ? {} : { requiredPermissions: toolOptions.requiredPermissions },
     validateInput: (input) => Schema35.decodeUnknownEffect(parametersSchemaFromEffectTool(modelTool))(input).pipe(Effect28.mapError((error) => new ToolInputInvalid({ tool_name: modelTool.name, message: error.message })), Effect28.asVoid),
     run: (input) => runHandledToolkitTool(toolkit, modelTool.name, input)
@@ -8064,6 +9233,7 @@ var tool = (name, options) => {
   return {
     definition,
     tool: effectTool,
+    ...options.placement === undefined ? {} : { placement: options.placement },
     ...options.requiredPermissions === undefined ? {} : { requiredPermissions: options.requiredPermissions },
     validateInput: (input) => Schema35.decodeUnknownEffect(options.input)(input).pipe(Effect28.mapError((error) => new ToolInputInvalid({ tool_name: name, message: error.message })), Effect28.asVoid),
     run: (input, context) => Schema35.decodeUnknownEffect(options.input)(input).pipe(Effect28.flatMap((decoded) => options.run(decoded, context)), Effect28.flatMap(Schema35.encodeUnknownEffect(options.output)), Effect28.map(jsonValue))
@@ -8089,10 +9259,78 @@ var dynamicTool = (name, options) => {
       ...options.metadata === undefined ? {} : { metadata: options.metadata }
     },
     tool: modelTool,
+    ...options.placement === undefined ? {} : { placement: options.placement },
     ...options.requiredPermissions === undefined ? {} : { requiredPermissions: options.requiredPermissions },
     run: options.run
   };
 };
+var placedTool = (modelTool, placement, options = {}) => ({
+  definition: definitionFromEffectTool(modelTool, options),
+  tool: modelTool,
+  placement,
+  ...options.requiredPermissions === undefined ? {} : { requiredPermissions: options.requiredPermissions },
+  validateInput: (input) => Schema35.decodeUnknownEffect(parametersSchemaFromEffectTool(modelTool))(input).pipe(Effect28.mapError((error) => new ToolInputInvalid({ tool_name: modelTool.name, message: error.message })), Effect28.asVoid)
+});
+var clientTool = (modelTool, options = {}) => placedTool(modelTool, { kind: "client" }, options);
+var remoteTool = (modelTool, options) => placedTool(modelTool, { kind: "remote", queue: options.queue }, options);
+var placementWaitId = (input) => exports_ids_schema.WaitId.make(`wait:tool:${input.call.id}`);
+var placementFailureResult = (input, message) => ({
+  call_id: input.call.id,
+  output: null,
+  error: message
+});
+var externalOutcomeResult = (call, input) => {
+  if (call.definition === undefined) {
+    return Effect28.fail(new ToolRuntimeError({ message: "Tool call definition snapshot is missing" }));
+  }
+  if (call.externalOutcome === undefined) {
+    return Effect28.fail(new ToolRuntimeError({ message: "Resolved tool wait has no mirrored external outcome" }));
+  }
+  if (call.externalOutcome.kind === "failure") {
+    return Effect28.succeed(placementFailureResult(input, call.externalOutcome.message));
+  }
+  const placement = call.placement.kind;
+  return Schema35.decodeUnknownEffect(exports_tool_schema.resultSchema(call.definition.output_schema))(call.externalOutcome.output).pipe(Effect28.map((output) => ({ call_id: input.call.id, output: jsonValue(output) })), Effect28.catch((error) => Effect28.succeed(placementFailureResult(input, `invalid ${placement} result: ${error.message}`))));
+};
+var runExternalTool = (repository, waits, call, input) => Effect28.gen(function* () {
+  const waitId = placementWaitId(input);
+  let wait = yield* waits.get(waitId).pipe(Effect28.mapError(mapWaitServiceError));
+  if (wait === undefined) {
+    wait = yield* waits.createDetached({
+      waitId,
+      executionId: input.executionId,
+      mode: "event",
+      correlationKey: input.call.id,
+      metadata: {
+        kind: "tool-placement",
+        tool_call_id: input.call.id,
+        tool_name: input.call.name,
+        placement: call.placement
+      },
+      eventSequence: input.eventSequence + 1,
+      createdAt: input.createdAt
+    }).pipe(Effect28.mapError(mapWaitServiceError));
+  }
+  const waitingCall = call.state === "requested" ? yield* repository.prepareExternalWait({
+    callId: input.call.id,
+    waitId,
+    availableAt: input.createdAt,
+    updatedAt: input.createdAt
+  }).pipe(Effect28.mapError(mapRepositoryError4)) : call;
+  if (wait.state === "open")
+    return yield* waitRequested(input, waitId);
+  if (wait.state === "timed_out")
+    return placementFailureResult(input, "Tool execution timed out");
+  if (wait.state === "cancelled")
+    return placementFailureResult(input, "Tool execution cancelled");
+  const repairedCall = waitingCall.externalOutcome === undefined && waitingCall.placement.kind === "client" ? yield* Schema35.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect28.mapError((error) => new ToolRuntimeError({ message: error.message })), Effect28.flatMap((outcome) => repository.acceptClientOutcome({
+    executionId: input.executionId,
+    callId: input.call.id,
+    outcome,
+    submittedAt: wait.resolvedAt ?? input.createdAt
+  }).pipe(Effect28.mapError(mapRepositoryError4), Effect28.map((accepted2) => accepted2.call)))) : waitingCall;
+  return yield* externalOutcomeResult(repairedCall, input);
+});
 var makeService = (initialTools) => Effect28.gen(function* () {
   const repository = yield* exports_tool_call_repository.Service;
   const eventLog = yield* Service24;
@@ -8109,13 +9347,15 @@ var makeService = (initialTools) => Effect28.gen(function* () {
       if (registeredTool === undefined) {
         return yield* Effect28.fail(new ToolNotRegistered({ tool_name: input.call.name }));
       }
-      const existingResult = yield* repository.getResult(input.call.id).pipe(Effect28.mapError(mapRepositoryError4));
-      if (existingResult !== undefined)
-        return existingResult.result;
       return yield* Effect28.gen(function* () {
         yield* ensureAllowed(registeredTool, input);
         yield* validateInput(registeredTool, input);
-        yield* recordRequested(repository, eventLog, input);
+        const call = yield* recordRequested(repository, eventLog, input, registeredTool);
+        const existingResult = yield* repository.getResult(input.call.id).pipe(Effect28.mapError(mapRepositoryError4));
+        if (existingResult !== undefined) {
+          yield* repairResultEvent(eventLog, input, existingResult);
+          return existingResult.result;
+        }
         let effectiveInput = input;
         if (registeredTool.definition.needs_approval === true) {
           const bypass = yield* hasPermissionApprovalBypass(waits, input);
@@ -8133,7 +9373,7 @@ var makeService = (initialTools) => Effect28.gen(function* () {
             }
           }
         }
-        const rawResult = yield* finalToolResult(registeredTool, effectiveInput);
+        const rawResult = call.placement.kind === "client" || call.placement.kind === "remote" ? yield* runExternalTool(repository, waits, call, effectiveInput) : yield* repository.beginAttempt({ callId: input.call.id, startedAt: effectiveInput.createdAt }).pipe(Effect28.mapError(mapRepositoryError4), Effect28.flatMap(() => finalToolResult(registeredTool, effectiveInput, call.idempotencyKey)), Effect28.catchTag("ToolExecutionFailed", (error) => Effect28.succeed(placementFailureResult(input, error.message))));
         const result = input.transformResult === undefined || rawResult.error !== undefined ? rawResult : yield* input.transformResult(rawResult);
         const received = yield* recordReceived(repository, eventLog, effectiveInput, result);
         yield* recordToolCall(input.call.name, result.error === undefined ? "success" : "failure");
@@ -8213,12 +9453,53 @@ var firstDuplicate = (values) => {
 };
 var missingFrom = (values, allowed) => values.find((value) => !HashSet4.has(allowed, value));
 var transferToolName = (name) => `transfer_to_${name.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "")}`;
+var validateTurnPolicySnapshot = Effect29.fn("AgentRegistry.validateTurnPolicySnapshot")(function* (snapshot) {
+  if (snapshot === undefined)
+    return;
+  const decoded = yield* Schema36.decodeUnknownEffect(exports_agent_schema.TurnPolicySnapshot)(snapshot).pipe(Effect29.mapError(() => new AgentDefinitionInvalid({ message: "definition.turn_policy must be a valid turn policy snapshot" })));
+  let nodes = 0;
+  const pending = [
+    { snapshot: decoded, depth: 1 }
+  ];
+  while (pending.length > 0) {
+    const current2 = pending.pop();
+    if (current2 === undefined)
+      continue;
+    nodes += 1;
+    if (current2.depth > exports_agent_schema.maxTurnPolicySnapshotDepth) {
+      return yield* Effect29.fail(new AgentDefinitionInvalid({
+        message: `definition.turn_policy depth exceeds ${exports_agent_schema.maxTurnPolicySnapshotDepth}`
+      }));
+    }
+    if (nodes > exports_agent_schema.maxTurnPolicySnapshotNodes) {
+      return yield* Effect29.fail(new AgentDefinitionInvalid({
+        message: `definition.turn_policy node count exceeds ${exports_agent_schema.maxTurnPolicySnapshotNodes}`
+      }));
+    }
+    switch (current2.snapshot.kind) {
+      case "recurs":
+        if (!Number.isInteger(current2.snapshot.count) || current2.snapshot.count < 0) {
+          return yield* Effect29.fail(new AgentDefinitionInvalid({
+            message: "definition.turn_policy recurs count must be a non-negative integer"
+          }));
+        }
+        break;
+      case "until-tool-call":
+        yield* requireText(current2.snapshot.name, "definition.turn_policy until-tool-call name");
+        break;
+      case "both":
+        pending.push({ snapshot: current2.snapshot.second, depth: current2.depth + 1 }, { snapshot: current2.snapshot.first, depth: current2.depth + 1 });
+        break;
+    }
+  }
+});
 var validateDefinition = Effect29.fn("AgentRegistry.validateDefinition")(function* (definition) {
   yield* requireText(definition.name, "definition.name");
   yield* requireOptionalText(definition.instructions, "definition.instructions");
   yield* requireText(definition.model.provider, "definition.model.provider");
   yield* requireText(definition.model.model, "definition.model.model");
   yield* requireOptionalText(definition.output_schema_ref, "definition.output_schema_ref");
+  yield* validateTurnPolicySnapshot(definition.turn_policy);
   for (const toolName of definition.tool_names) {
     yield* requireText(toolName, "definition.tool_names[]");
   }
@@ -8420,7 +9701,7 @@ __export(exports_agent_loop_service, {
   testLayer: () => testLayer46,
   run: () => run3,
   mapBoundaryError: () => mapBoundaryError,
-  layer: () => layer44,
+  layer: () => layer45,
   Service: () => Service41,
   STRUCTURED_TURN_PROMPT: () => STRUCTURED_TURN_PROMPT,
   AgentLoopWaitRequested: () => AgentLoopWaitRequested,
@@ -8428,7 +9709,7 @@ __export(exports_agent_loop_service, {
   AgentLoopBudgetExceeded: () => AgentLoopBudgetExceeded
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/agent.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/agent.ts
 var exports_agent = {};
 __export(exports_agent, {
   streamObject: () => streamObject,
@@ -8439,9 +9720,9 @@ __export(exports_agent, {
   defaultObjectPrompt: () => defaultObjectPrompt
 });
 import { Cause as Cause3, Effect as Effect46, Fiber, Option as Option16, Queue as Queue2, Ref as Ref11, Schema as Schema48, Stream as Stream7 } from "effect";
-import { Chat, LanguageModel as LanguageModel4, Prompt as Prompt4, Response as Response3, Telemetry, Tokenizer as Tokenizer2, Tool as Tool4, Toolkit as Toolkit3 } from "effect/unstable/ai";
+import { Chat, LanguageModel as LanguageModel4, Prompt as Prompt4, Response as Response3, Telemetry, Tokenizer as Tokenizer2, Tool as Tool3, Toolkit as Toolkit3 } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/agent-event.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/agent-event.ts
 var exports_agent_event = {};
 __export(exports_agent_event, {
   addUsage: () => addUsage,
@@ -8498,7 +9779,7 @@ class AgentSuspended extends Schema38.TaggedErrorClass()("@batonfx/core/AgentSus
 }) {
 }
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/approvals.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/approvals.ts
 var exports_approvals = {};
 __export(exports_approvals, {
   testLayer: () => testLayer26,
@@ -8514,25 +9795,30 @@ var autoApprove = Layer29.succeed(Approvals, Approvals.of({ check: () => Effect3
 var denyAll = Layer29.succeed(Approvals, Approvals.of({ check: () => Effect31.succeed({ _tag: "Denied" }) }));
 var testLayer26 = (implementation) => Layer29.succeed(Approvals, Approvals.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/compaction.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/compaction.ts
 var exports_compaction = {};
 __export(exports_compaction, {
   truncate: () => truncate,
+  toolOutputBound: () => toolOutputBound,
   testLayer: () => testLayer29,
+  structuredSummary: () => structuredSummary,
+  strategy: () => strategy,
   make: () => make2,
   layer: () => layer26,
+  keepRecent: () => keepRecent,
   isContextOverflow: () => isContextOverflow,
   defaultStrategy: () => defaultStrategy,
   SUMMARY_TEMPLATE: () => SUMMARY_TEMPLATE,
   DEFAULT_RESERVE_TOKENS: () => DEFAULT_RESERVE_TOKENS,
   DEFAULT_KEEP_RECENT_TOKENS: () => DEFAULT_KEEP_RECENT_TOKENS,
   CompactionError: () => CompactionError,
-  Compaction: () => Compaction
+  Compaction: () => Compaction,
+  AgentSummary: () => AgentSummary
 });
 import { Context as Context32, Effect as Effect34, Layer as Layer32, Option as Option10, Schema as Schema41 } from "effect";
 import { LanguageModel, Prompt as Prompt3, Tokenizer, Toolkit as Toolkit2 } from "effect/unstable/ai";
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/session.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/session.ts
 var exports_session = {};
 __export(exports_session, {
   testLayer: () => testLayer27,
@@ -8705,7 +9991,7 @@ var memoryLayer24 = Layer30.effect(SessionStore, Ref7.make(initialState).pipe(Ef
 }))));
 var testLayer27 = (implementation) => Layer30.succeed(SessionStore, SessionStore.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/tool-output.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/tool-output.ts
 var exports_tool_output = {};
 __export(exports_tool_output, {
   testLayer: () => testLayer28,
@@ -8765,7 +10051,7 @@ var bound = (result, options) => Effect33.gen(function* () {
   return { _tag: "Success", result: output, encodedResult: output };
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/compaction.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/compaction.ts
 var DEFAULT_RESERVE_TOKENS = 16384;
 var DEFAULT_KEEP_RECENT_TOKENS = 20000;
 var SUMMARY_TEMPLATE = `Summarize the conversation so another agent can continue seamlessly.
@@ -8783,6 +10069,13 @@ Use Markdown with these sections:
 ## Critical Context
 
 Do not mention that context was compacted.`;
+var AgentSummary = Schema41.Struct({
+  goal: Schema41.String,
+  facts: Schema41.Array(Schema41.String),
+  decisions: Schema41.Array(Schema41.String),
+  openQuestions: Schema41.Array(Schema41.String),
+  toolFindings: Schema41.Array(Schema41.String)
+});
 
 class CompactionError extends Schema41.TaggedErrorClass()("@batonfx/core/CompactionError", {
   message: Schema41.String,
@@ -8796,6 +10089,27 @@ var serialized2 = (value) => {
   const json = JSON.stringify(value);
   return json === undefined ? String(value) : json;
 };
+var safeNonNegativeInteger = (name, value) => {
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new TypeError(`${name} must be a non-negative safe integer`);
+  return value;
+};
+var markdownList = (items) => items.length === 0 ? "- None" : items.map((item) => `- ${item}`).join(`
+`);
+var renderAgentSummary = (summary) => [
+  `## Goal
+${summary.goal}`,
+  `## Facts
+${markdownList(summary.facts)}`,
+  `## Decisions
+${markdownList(summary.decisions)}`,
+  `## Open Questions
+${markdownList(summary.openQuestions)}`,
+  `## Tool Findings
+${markdownList(summary.toolFindings)}`
+].join(`
+
+`);
 var APPROX_CHARS_PER_TOKEN = 4;
 var estimateTokens = (text3) => Math.ceil(text3.length / APPROX_CHARS_PER_TOKEN);
 var estimateEntryTokens = (entry) => estimateTokens(serialized2(entry));
@@ -8856,7 +10170,7 @@ var summaryPrompt = (template, prompt) => Prompt3.make(`${template}
 Conversation to summarize:
 ${serialized2(prompt.content)}`);
 var systemMessages = (entries) => entries.flatMap((entry) => entry._tag === "Message" && entry.message.role === "system" ? [entry.message] : []);
-var compactedHistory = (summary, head, recent) => Prompt3.concat(Prompt3.fromMessages([...systemMessages(head), checkpointMessage2(summary)]), buildContext(recent));
+var compactedHistory = (summary, head, recent) => Prompt3.concat(Prompt3.fromMessages([...systemMessages(head), checkpointMessage2(summary)]), recent);
 var normalizeUsage = (usage, options) => ({
   contextTokens: Number.isFinite(usage.contextTokens) ? usage.contextTokens : 0,
   contextWindow: Number.isFinite(usage.contextWindow) ? usage.contextWindow : options.contextWindow ?? Number.POSITIVE_INFINITY,
@@ -8900,38 +10214,77 @@ var defaultStrategy = (options = {}) => ({
     return options.summaryModel === undefined ? effect : effect.pipe(Effect34.provide(options.summaryModel));
   }
 });
-var make2 = (strategy, options = {}) => ({
+var strategy = (parts, base = defaultStrategy()) => parts.reduce((current2, part) => ({
+  shouldCompact: part.shouldCompact ?? current2.shouldCompact,
+  cut: part.cut ?? current2.cut,
+  summarize: part.summarize ?? current2.summarize,
+  ...part.toolOutputMaxBytes !== undefined ? { toolOutputMaxBytes: part.toolOutputMaxBytes } : current2.toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes: current2.toolOutputMaxBytes },
+  ...part.keepRecentTokens !== undefined ? { keepRecentTokens: part.keepRecentTokens } : current2.keepRecentTokens === undefined ? {} : { keepRecentTokens: current2.keepRecentTokens }
+}), base);
+var toolOutputBound = (options) => ({
+  toolOutputMaxBytes: safeNonNegativeInteger("ToolOutputBoundOptions.maxBytes", options.maxBytes)
+});
+var keepRecent = (options) => ({
+  keepRecentTokens: safeNonNegativeInteger("KeepRecentOptions.tokens", options.tokens)
+});
+var structuredSummary = (options = {}) => ({
+  summarize: (plan2, request) => {
+    const effect = Effect34.gen(function* () {
+      const head = buildContext(plan2.head);
+      const [compactedHead] = request.toolOutputMaxBytes === undefined ? [head, false] : yield* microcompactPrompt(head, request.toolOutputMaxBytes);
+      const prompt = summaryPrompt(options.summaryPrompt ?? SUMMARY_TEMPLATE, compactedHead);
+      const model = yield* LanguageModel.LanguageModel;
+      return yield* model.generateObject({
+        prompt,
+        schema: AgentSummary,
+        objectName: options.objectName ?? "AgentSummary",
+        toolChoice: "none"
+      }).pipe(Effect34.map((response) => renderAgentSummary(response.value)), Effect34.mapError((error) => new CompactionError({ message: String(error), cause: error })));
+    });
+    return options.summaryModel === undefined ? effect : effect.pipe(Effect34.provide(options.summaryModel));
+  }
+});
+var make2 = (compactionStrategy, options = {}) => ({
   maybeCompact: (input) => Effect34.gen(function* () {
     const usage = normalizeUsage(input.usage, options);
-    const shouldCompact = input.overflow || strategy.shouldCompact(usage);
+    const shouldCompact = input.overflow || compactionStrategy.shouldCompact(usage);
     if (!shouldCompact)
       return Option10.none();
     let history = input.history;
     let prompt = input.prompt;
     let changed = false;
-    if (input.toolOutputMaxBytes !== undefined) {
-      const [compactedHistoryPrompt, historyChanged] = yield* microcompactPrompt(history, input.toolOutputMaxBytes);
-      const [compactedPrompt, promptChanged] = yield* microcompactPrompt(prompt, input.toolOutputMaxBytes);
+    const toolOutputMaxBytes = input.toolOutputMaxBytes ?? compactionStrategy.toolOutputMaxBytes;
+    if (toolOutputMaxBytes !== undefined) {
+      const [compactedHistoryPrompt, historyChanged] = yield* microcompactPrompt(history, toolOutputMaxBytes);
+      const [compactedPrompt, promptChanged] = yield* microcompactPrompt(prompt, toolOutputMaxBytes);
       history = compactedHistoryPrompt;
       prompt = compactedPrompt;
       changed = historyChanged || promptChanged;
       if (changed && fits(history, prompt, usage))
         return Option10.some(makeMicrocompact(history, prompt));
     }
-    const plan2 = strategy.cut(input.path ?? [], options.keepRecentTokens ?? DEFAULT_KEEP_RECENT_TOKENS);
+    const plan2 = compactionStrategy.cut(input.path ?? [], compactionStrategy.keepRecentTokens ?? options.keepRecentTokens ?? DEFAULT_KEEP_RECENT_TOKENS);
     if (Option10.isNone(plan2))
       return changed ? Option10.some(makeMicrocompact(history, prompt)) : Option10.none();
-    const summary = yield* strategy.summarize(plan2.value, { ...input, history, prompt, usage });
+    const summary = yield* compactionStrategy.summarize(plan2.value, {
+      ...input,
+      history,
+      prompt,
+      usage,
+      ...toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes }
+    });
+    const recent = buildContext(plan2.value.recent);
+    const [compactedRecent] = toolOutputMaxBytes === undefined ? [recent, false] : yield* microcompactPrompt(recent, toolOutputMaxBytes);
     return Option10.some({
       _tag: "Summarize",
-      history: compactedHistory(summary, plan2.value.head, plan2.value.recent),
+      history: compactedHistory(summary, plan2.value.head, compactedRecent),
       prompt,
       summary,
       firstKeptEntryId: plan2.value.firstKeptEntryId
     });
   })
 });
-var layer26 = (options = {}, strategy = defaultStrategy(options)) => Layer32.succeed(Compaction, Compaction.of(make2(strategy, options)));
+var layer26 = (options = {}, providedStrategy = options.strategy ?? defaultStrategy(options)) => Layer32.succeed(Compaction, Compaction.of(make2(providedStrategy, options)));
 var truncate = (maxTokens) => ({
   maybeCompact: (input) => Effect34.gen(function* () {
     const usage = input.usage;
@@ -8948,7 +10301,7 @@ var truncate = (maxTokens) => ({
 var testLayer29 = (implementation) => Layer32.succeed(Compaction, Compaction.of(implementation));
 var isContextOverflow = (error) => /context|token|prompt/i.test(error instanceof Error ? `${error.name}: ${error.message}` : String(error)) && /overflow|exceed|exceeded|maximum|too large|too long|length/i.test(error instanceof Error ? `${error.name}: ${error.message}` : String(error));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/instructions.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/instructions.ts
 var exports_instructions = {};
 __export(exports_instructions, {
   testLayer: () => testLayer30,
@@ -8997,7 +10350,7 @@ var renderUpdate = (epoch, context) => Effect35.gen(function* () {
 var layer27 = (sources) => Layer33.succeed(Instructions, Instructions.of({ sources: [...sources] }));
 var testLayer30 = (implementation) => Layer33.succeed(Instructions, Instructions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/memory.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/memory.ts
 var exports_memory = {};
 __export(exports_memory, {
   testLayer: () => testLayer31,
@@ -9028,7 +10381,7 @@ var merge = (first, second) => ({
 var noopLayer = Layer34.succeed(Memory, Memory.of(noop));
 var testLayer31 = (implementation) => Layer34.succeed(Memory, Memory.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/model-middleware.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/model-middleware.ts
 var exports_model_middleware = {};
 __export(exports_model_middleware, {
   layer: () => layer28,
@@ -9042,7 +10395,7 @@ class ModelMiddleware extends Context35.Service()("@batonfx/core/ModelMiddleware
 var identityLayer = Layer35.succeed(ModelMiddleware, []);
 var layer28 = (middleware) => Layer35.succeed(ModelMiddleware, middleware);
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/model-registry.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/model-registry.ts
 var exports_model_registry = {};
 __export(exports_model_registry, {
   testLayer: () => testLayer32,
@@ -9131,7 +10484,7 @@ var provide = (selection, effect) => Effect38.gen(function* () {
   return yield* service.provide(selection, effect);
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/model-resilience.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/model-resilience.ts
 var exports_model_resilience = {};
 __export(exports_model_resilience, {
   testLayer: () => testLayer33,
@@ -9177,7 +10530,7 @@ var apply = (model, resilience) => ({
   }).pipe(Stream5.retry(retryStreamSchedule(resilience)))
 });
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/permissions.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/permissions.ts
 var exports_permissions = {};
 __export(exports_permissions, {
   testLayer: () => testLayer34,
@@ -9307,12 +10660,14 @@ var ruleStoreMemory = (initialRules = []) => Layer38.effect(RuleStore, Ref10.mak
 var ruleStoreTestLayer = (implementation) => Layer38.succeed(RuleStore, RuleStore.of(implementation));
 var testLayer34 = (implementation) => Layer38.succeed(Permissions, Permissions.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/skill-source.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/skill-source.ts
 var exports_skill_source = {};
 __export(exports_skill_source, {
   testLayer: () => testLayer35,
   selectListings: () => selectListings,
+  merge: () => merge2,
   makeListing: () => makeListing,
+  layer: () => layer31,
   fromSkills: () => fromSkills,
   empty: () => empty,
   SkillSourceError: () => SkillSourceError,
@@ -9327,7 +10682,7 @@ class SkillSourceError extends Schema45.TaggedErrorClass()("@batonfx/core/SkillS
   cause: Schema45.optionalKey(Schema45.Defect())
 }) {
 }
-var DESCRIPTION_CAP = 1536;
+var DESCRIPTION_CAP = 1024;
 
 class SkillSource extends Context39.Service()("@batonfx/core/SkillSource") {
 }
@@ -9342,6 +10697,25 @@ var fromSkills = (skills) => {
 };
 var empty = fromSkills([]);
 var testLayer35 = (implementation) => Layer39.succeed(SkillSource, SkillSource.of(implementation));
+var merge2 = (sources) => ({
+  all: Effect41.forEach(sources, (source) => source.all).pipe(Effect41.map((groups) => {
+    const byName = new Map;
+    for (const skills of groups) {
+      for (const skill of skills)
+        byName.set(skill.frontmatter.name, skill);
+    }
+    return [...byName.values()];
+  })),
+  get: (name) => Effect41.gen(function* () {
+    for (const source of sources.toReversed()) {
+      const found = yield* source.get(name);
+      if (found !== undefined)
+        return found;
+    }
+    return;
+  })
+});
+var layer31 = (sources) => Layer39.effect(SkillSource, Effect41.forEach(sources, (source) => source).pipe(Effect41.map((built) => SkillSource.of(merge2(built)))));
 var estimatedTokens = (listing) => Math.ceil(listing.length / 4);
 var usageRank = (skill, recentlyUsed) => {
   const index2 = recentlyUsed.indexOf(skill.frontmatter.name);
@@ -9365,11 +10739,11 @@ var selectListings = (skills, budgetTokens, recentlyUsed) => {
   return selected;
 };
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/steering.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/steering.ts
 var exports_steering = {};
 __export(exports_steering, {
   testLayer: () => testLayer36,
-  layer: () => layer31,
+  layer: () => layer32,
   SteeringQueueFull: () => SteeringQueueFull,
   Steering: () => Steering
 });
@@ -9388,8 +10762,8 @@ var resolvePolicy = (policy, mode) => ({
   ...policy?.capacity === undefined ? {} : { capacity: policy.capacity },
   onFull: policy?.onFull ?? "fail"
 });
-var queueStrategy = (strategy) => {
-  switch (strategy) {
+var queueStrategy = (strategy2) => {
+  switch (strategy2) {
     case "drop-oldest":
       return "sliding";
     case "drop-newest":
@@ -9410,7 +10784,7 @@ var drainOne = (queue) => Effect42.sync(() => {
   return taken === undefined || !Exit.isSuccess(taken) ? [] : [taken.value];
 });
 var drain = (queue, mode) => mode === "all" ? Queue.clear(queue) : drainOne(queue);
-var layer31 = (options = {}) => Layer40.effect(Steering, Effect42.gen(function* () {
+var layer32 = (options = {}) => Layer40.effect(Steering, Effect42.gen(function* () {
   const steeringQueue = yield* makeQueue("steering", resolvePolicy(options.steering, "all"));
   const followUpQueue = yield* makeQueue("followUp", resolvePolicy(options.followUp, "one-at-a-time"));
   return Steering.of({
@@ -9422,7 +10796,7 @@ var layer31 = (options = {}) => Layer40.effect(Steering, Effect42.gen(function*
 }));
 var testLayer36 = (implementation) => Layer40.succeed(Steering, Steering.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/tool-context.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/tool-context.ts
 var exports_tool_context = {};
 __export(exports_tool_context, {
   testLayer: () => testLayer37,
@@ -9440,7 +10814,7 @@ var layerDefault = Layer41.sync(ToolContext, () => ToolContext.of({
 }));
 var testLayer37 = (implementation) => Layer41.succeed(ToolContext, ToolContext.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/tool-executor.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/tool-executor.ts
 var exports_tool_executor = {};
 __export(exports_tool_executor, {
   testLayer: () => testLayer38,
@@ -9566,7 +10940,7 @@ function router(routes) {
 }
 var testLayer38 = (implementation) => Layer42.succeed(ToolExecutor, ToolExecutor.of(implementation));
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/turn-policy.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/turn-policy.ts
 var exports_turn_policy = {};
 __export(exports_turn_policy, {
   untilToolCall: () => untilToolCall,
@@ -9585,8 +10959,14 @@ var decision = {
   stop: { _tag: "Stop" }
 };
 var make4 = (decide) => ({ decide });
-var recurs = (n) => make4((info) => Effect45.succeed(info.turn < n + 1 ? decision.continue() : decision.stop));
-var untilToolCall = (name) => make4((info) => Effect45.succeed(info.pendingToolResults.some((result) => result.name === name) ? decision.stop : decision.continue()));
+var recurs = (n) => ({
+  decide: (info) => Effect45.succeed(info.turn < n + 1 ? decision.continue() : decision.stop),
+  ...Number.isFinite(n) ? { snapshot: { _tag: "Recurs", count: n } } : {}
+});
+var untilToolCall = (name) => ({
+  decide: (info) => Effect45.succeed(info.pendingToolResults.some((result) => result.name === name) ? decision.stop : decision.continue()),
+  snapshot: { _tag: "UntilToolCall", name }
+});
 var mergeOverrides = (first, second) => {
   if (first === undefined)
     return second;
@@ -9594,18 +10974,21 @@ var mergeOverrides = (first, second) => {
     return first;
   return { ...first, ...second };
 };
-var both = (first, second) => make4((info) => Effect45.gen(function* () {
-  const left = yield* first.decide(info);
-  if (left._tag === "Stop")
-    return decision.stop;
-  const right = yield* second.decide(info);
-  if (right._tag === "Stop")
-    return decision.stop;
-  return decision.continue(mergeOverrides(left.overrides, right.overrides));
-}));
+var both = (first, second) => ({
+  decide: (info) => Effect45.gen(function* () {
+    const left = yield* first.decide(info);
+    if (left._tag === "Stop")
+      return decision.stop;
+    const right = yield* second.decide(info);
+    if (right._tag === "Stop")
+      return decision.stop;
+    return decision.continue(mergeOverrides(left.overrides, right.overrides));
+  }),
+  ...first.snapshot === undefined || second.snapshot === undefined ? {} : { snapshot: { _tag: "Both", first: first.snapshot, second: second.snapshot } }
+});
 var defaultPolicy = recurs(8);
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/agent.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/agent.ts
 function make5(nameOrOptions, options = {}) {
   const resolved = typeof nameOrOptions === "string" ? { ...options, name: nameOrOptions } : nameOrOptions;
   return {
@@ -9628,7 +11011,7 @@ var steeringDrainedEvent = (turn, queue, messages) => ({
 var skillListingBudgetTokens = 2048;
 var activateSkillToolName = "activate_skill";
 var activateSkillParameters = Schema48.Struct({ name: Schema48.String });
-var activateSkillTool = Tool4.make(activateSkillToolName, {
+var activateSkillTool = Tool3.make(activateSkillToolName, {
   description: "Load the full body for one listed Baton skill by name before applying that skill.",
   parameters: activateSkillParameters,
   success: Schema48.Struct({
@@ -10302,13 +11685,13 @@ var generateObject = (agent, options) => Stream7.runFold(streamObject(agent, opt
     })
   })
 })));
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/agent-tool.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/agent-tool.ts
 var exports_agent_tool = {};
 __export(exports_agent_tool, {
   asTool: () => asTool
 });
 import { Cause as Cause4, Effect as Effect47, Schema as Schema49 } from "effect";
-import { Tool as Tool5, Toolkit as Toolkit4 } from "effect/unstable/ai";
+import { Tool as Tool4, Toolkit as Toolkit4 } from "effect/unstable/ai";
 var defaultParameters = Schema49.Struct({ prompt: Schema49.String });
 var errorMessage2 = (error) => {
   if (error instanceof AgentSuspended) {
@@ -10338,7 +11721,7 @@ var asTool = (agent, options = {}) => {
   const success2 = options.success ?? Schema49.String;
   const toPrompt = options.toPrompt ?? ((params) => params.prompt);
   const fromResult = options.fromResult ?? ((result) => result.text);
-  const tool2 = Tool5.make(name, {
+  const tool2 = Tool4.make(name, {
     ...options.description === undefined ? {} : { description: options.description },
     parameters,
     success: success2,
@@ -10357,7 +11740,7 @@ var asTool = (agent, options = {}) => {
   });
   return lazyHandled(toolkit, name, handler);
 };
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/guardrail.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/guardrail.ts
 var exports_guardrail = {};
 __export(exports_guardrail, {
   validateInput: () => validateInput2,
@@ -10437,7 +11820,7 @@ var redactOutput = (options) => ({
 var filterOutput = (keep) => ({
   transformPart: (part, context) => Effect48.succeed(part.type === "tool-call" || keep(part, context) ? Option17.some(part) : Option17.none())
 });
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/handoff.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/handoff.ts
 var exports_handoff = {};
 __export(exports_handoff, {
   transferTool: () => transferTool,
@@ -10501,7 +11884,7 @@ var supervisor = (options) => {
   };
 };
 
-// ../../node_modules/.bun/@batonfx+core@0.3.7/node_modules/@batonfx/core/src/index.ts
+// ../../node_modules/.bun/@batonfx+core@0.4.0/node_modules/@batonfx/core/src/index.ts
 import {
   AiError as AiError3,
   Chat as Chat2,
@@ -10514,7 +11897,7 @@ import {
   ResponseIdTracker,
   Telemetry as Telemetry2,
   Tokenizer as Tokenizer3,
-  Tool as Tool7,
+  Tool as Tool6,
   Toolkit as Toolkit6
 } from "effect/unstable/ai";
 
@@ -10530,7 +11913,7 @@ __export(exports_child_run_service, {
   spawnDynamic: () => spawnDynamic,
   resolveForDispatch: () => resolveForDispatch,
   memoryLayer: () => memoryLayer26,
-  layer: () => layer32,
+  layer: () => layer33,
   childDefinition: () => childDefinition,
   StaticChildRunPresetNotFound: () => StaticChildRunPresetNotFound,
   Service: () => Service31,
@@ -10755,7 +12138,7 @@ var persistChild = Effect51.fn("ChildRunService.persistChild")(function* (reposi
   yield* eventLog.append(spawnedEvent(input, kind, context, presetName, workspaceRef)).pipe(Effect51.mapError(mapEventLogError3));
   return acceptedOutput(input);
 });
-var layer32 = Layer45.effect(Service31, Effect51.gen(function* () {
+var layer33 = Layer45.effect(Service31, Effect51.gen(function* () {
   const repository = yield* exports_child_execution_repository.Service;
   const eventLog = yield* Service24;
   return Service31.of({
@@ -10789,7 +12172,7 @@ var layer32 = Layer45.effect(Service31, Effect51.gen(function* () {
     })
   });
 }));
-var memoryLayer26 = layer32.pipe(Layer45.provide(exports_child_execution_repository.memoryLayer), Layer45.provide(memoryLayer21));
+var memoryLayer26 = layer33.pipe(Layer45.provide(exports_child_execution_repository.memoryLayer), Layer45.provide(memoryLayer21));
 var testLayer39 = (implementation) => Layer45.succeed(Service31, Service31.of(implementation));
 var agentContextFromSchema = (input) => ({
   toolNames: input.tool_names,
@@ -10831,6 +12214,10 @@ var childDefinition = (parentDefinition, context) => context.model === undefined
   tool_names: [...context.toolNames],
   permissions: parentDefinition.permissions.filter((permission) => context.permissions.includes(permission.name)),
   child_run_presets: {},
+  ...parentDefinition.turn_policy === undefined ? {} : { turn_policy: parentDefinition.turn_policy },
+  ...parentDefinition.max_tool_turns === undefined ? {} : { max_tool_turns: parentDefinition.max_tool_turns },
+  ...parentDefinition.max_wait_turns === undefined ? {} : { max_wait_turns: parentDefinition.max_wait_turns },
+  ...parentDefinition.token_budget === undefined ? {} : { token_budget: parentDefinition.token_budget },
   ...context.instructions === undefined ? {} : { instructions: context.instructions },
   ...context.outputSchemaRef === undefined ? {} : { output_schema_ref: context.outputSchemaRef }
 });
@@ -11094,14 +12481,14 @@ var resolveDefault = (registrations2, options) => {
   }
   return registrations2.length === 1 ? registrations2[0] : undefined;
 };
-var registrationFromLayer2 = (input) => Model3.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect53.map((layer33) => toRegistration({
+var registrationFromLayer2 = (input) => Model3.make(input.provider, input.model, input.layer).captureRequirements.pipe(Effect53.map((layer34) => toRegistration({
   provider: input.provider,
   model: input.model,
   ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
-  layer: layer33,
+  layer: layer34,
   ...input.metadata === undefined ? {} : { metadata: input.metadata }
 })));
-var layer33 = (initialRegistrations = [], options) => Layer46.effect(Service32, Effect53.gen(function* () {
+var layer34 = (initialRegistrations = [], options) => Layer46.effect(Service32, Effect53.gen(function* () {
   const registry = yield* Ref13.make([...initialRegistrations]);
   const register5 = Effect53.fn("EmbeddingModelService.register")(function* (input) {
     const registration = toRegistration(input);
@@ -11130,8 +12517,8 @@ var layer33 = (initialRegistrations = [], options) => Layer46.effect(Service32,
   };
   return Service32.of({ register: register5, registrations: registrations2, provide: provide2, provideDefault, provideForAgent });
 }));
-var layerFromRegistrationEffects2 = (registrations2, options) => Layer46.unwrap(Effect53.all(registrations2).pipe(Effect53.map((items) => layer33(items, options))));
-var memoryLayer27 = layer33;
+var layerFromRegistrationEffects2 = (registrations2, options) => Layer46.unwrap(Effect53.all(registrations2).pipe(Effect53.map((items) => layer34(items, options))));
+var memoryLayer27 = layer34;
 var words = (input) => input.toLowerCase().match(/[a-z0-9]+/g) ?? [];
 var hashWord = (word) => {
   let hash = 2166136261;
@@ -11312,7 +12699,7 @@ var batonLayer = Layer47.effect(exports_memory.Memory, Effect54.gen(function* ()
   const service = yield* Service33;
   return exports_memory.Memory.of(service);
 }));
-var layer34 = (options) => batonLayer.pipe(Layer47.provideMerge(serviceLayer(options)));
+var layer35 = (options) => batonLayer.pipe(Layer47.provideMerge(serviceLayer(options)));
 var recall = Effect54.fn("MemoryService.recall.call")(function* (input) {
   const service = yield* Service33;
   return yield* service.recall(input);
@@ -11337,7 +12724,7 @@ __export(exports_language_model_service, {
   provide: () => provide2,
   memoryLayer: () => memoryLayer28,
   layerFromRegistrationEffects: () => layerFromRegistrationEffects3,
-  layer: () => layer35,
+  layer: () => layer36,
   Service: () => Service34,
   LanguageModelNotRegistered: () => LanguageModelNotRegistered2
 });
@@ -11352,7 +12739,7 @@ var toSelection = (selection) => ({
 class Service34 extends Context47.Service()("@relayfx/runtime/LanguageModelService") {
 }
 var registrationFromLayer3 = exports_model_registry.registrationFromLayer;
-var layer35 = (initialRegistrations = [], options) => Layer48.effect(Service34, Effect55.gen(function* () {
+var layer36 = (initialRegistrations = [], options) => Layer48.effect(Service34, Effect55.gen(function* () {
   const registry = yield* exports_model_registry.Service;
   return Service34.of({
     register: (input) => registry.register(input),
@@ -11361,8 +12748,8 @@ var layer35 = (initialRegistrations = [], options) => Layer48.effect(Service34,
     provideForAgent: (agent, effect) => registry.provide(toSelection(agent.model), effect)
   });
 })).pipe(Layer48.provide(exports_model_registry.layer(initialRegistrations, options)));
-var layerFromRegistrationEffects3 = (registrations3, options) => Layer48.unwrap(Effect55.all(registrations3).pipe(Effect55.map((items) => layer35(items, options))));
-var memoryLayer28 = layer35;
+var layerFromRegistrationEffects3 = (registrations3, options) => Layer48.unwrap(Effect55.all(registrations3).pipe(Effect55.map((items) => layer36(items, options))));
+var memoryLayer28 = layer36;
 var testLayer40 = (implementation) => Layer48.succeed(Service34, Service34.of(implementation));
 var register6 = Effect55.fn("LanguageModelService.register.call")(function* (input) {
   const service = yield* Service34;
@@ -11387,7 +12774,7 @@ __export(exports_model_call_policy, {
   testLayer: () => testLayer41,
   noRetryLayer: () => noRetryLayer,
   make: () => make7,
-  layer: () => layer36,
+  layer: () => layer37,
   defaultSchedule: () => defaultSchedule,
   defaultClassify: () => defaultClassify2,
   Service: () => Service35
@@ -11404,8 +12791,8 @@ var make7 = (input) => ({
   classify: input?.classify ?? defaultClassify2,
   retrySchedule: input?.retrySchedule ?? defaultSchedule
 });
-var layer36 = (input) => Layer49.succeed(Service35, Service35.of(make7(input)));
-var noRetryLayer = layer36({ retrySchedule: Schedule4.recurs(0) });
+var layer37 = (input) => Layer49.succeed(Service35, Service35.of(make7(input)));
+var noRetryLayer = layer37({ retrySchedule: Schedule4.recurs(0) });
 var testLayer41 = (implementation) => Layer49.succeed(Service35, Service35.of(implementation));
 
 // ../runtime/src/schema-registry/schema-registry-service.ts
@@ -11416,7 +12803,7 @@ __export(exports_schema_registry_service, {
   registrations: () => registrations4,
   register: () => register7,
   memoryLayer: () => memoryLayer29,
-  layer: () => layer37,
+  layer: () => layer38,
   Service: () => Service36,
   SchemaRefNotRegistered: () => SchemaRefNotRegistered
 });
@@ -11433,7 +12820,7 @@ var upsertRegistration2 = (registry, registration) => {
     return [...registry, registration];
   return registry.map((item) => item.ref === registration.ref ? registration : item);
 };
-var layer37 = (initialRegistrations = []) => Layer50.effect(Service36, Effect56.gen(function* () {
+var layer38 = (initialRegistrations = []) => Layer50.effect(Service36, Effect56.gen(function* () {
   const registry = yield* Ref14.make(initialRegistrations.reduce(upsertRegistration2, []));
   const register7 = Effect56.fn("SchemaRegistry.register")(function* (registration) {
     yield* Ref14.update(registry, (items) => upsertRegistration2(items, registration));
@@ -11449,7 +12836,7 @@ var layer37 = (initialRegistrations = []) => Layer50.effect(Service36, Effect56.
   });
   return Service36.of({ register: register7, registrations: registrations4, resolve: resolve4 });
 }));
-var memoryLayer29 = layer37;
+var memoryLayer29 = layer38;
 var testLayer42 = (implementation) => Layer50.succeed(Service36, Service36.of(implementation));
 var register7 = Effect56.fn("SchemaRegistry.register.call")(function* (registration) {
   const service = yield* Service36;
@@ -11738,7 +13125,7 @@ var put3 = Effect58.fn("BlobStore.put.call")(function* (input) {
 var exports_prompt_assembler_service = {};
 __export(exports_prompt_assembler_service, {
   testLayer: () => testLayer45,
-  layer: () => layer38,
+  layer: () => layer39,
   defaultLayerWithStores: () => defaultLayerWithStores,
   defaultLayer: () => defaultLayer,
   contentToPromptPart: () => contentToPromptPart,
@@ -11898,7 +13285,7 @@ var defaultLayerWithStores = Layer54.effect(Service40, Effect60.gen(function* ()
   return Service40.of(makeDefaultInterface(blobs, artifacts));
 }));
 var defaultLayer = defaultLayerWithStores.pipe(Layer54.provide(Layer54.mergeAll(passthroughLayer, passthroughLayer2)));
-var layer38 = (implementation) => Layer54.succeed(Service40, Service40.of(implementation));
+var layer39 = (implementation) => Layer54.succeed(Service40, Service40.of(implementation));
 var testLayer45 = (implementation) => Layer54.succeed(Service40, Service40.of(implementation));
 var assemble = Effect60.fn("PromptAssembler.assemble.call")(function* (input) {
   const service = yield* Service40;
@@ -11906,7 +13293,7 @@ var assemble = Effect60.fn("PromptAssembler.assemble.call")(function* (input) {
 });
 
 // ../runtime/src/agent/relay-approvals.ts
-var layer39 = exports_approvals.autoApprove;
+var layer40 = exports_approvals.autoApprove;
 
 // ../runtime/src/agent/relay-compaction.ts
 import { Clock as Clock5, Effect as Effect61, Layer as Layer55 } from "effect";
@@ -11918,11 +13305,10 @@ var defaultOptions = (options) => ({
   ...options?.reserveTokens === undefined ? {} : { reserveTokens: options.reserveTokens },
   ...options?.keepRecentTokens === undefined ? {} : { keepRecentTokens: options.keepRecentTokens }
 });
-var strategy = (config) => {
-  const base = exports_compaction.defaultStrategy(defaultOptions(config.options));
+var strategy2 = (config) => {
+  const base = config.strategy ?? exports_compaction.defaultStrategy(defaultOptions(config.options));
   return {
-    shouldCompact: base.shouldCompact,
-    cut: base.cut,
+    ...base,
     summarize: (plan2, request) => {
       const id2 = checkpointId({
         executionId: config.executionId,
@@ -11952,7 +13338,7 @@ var strategy = (config) => {
     }
   };
 };
-var make9 = (config) => exports_compaction.make(strategy(config), defaultOptions(config.options));
+var make9 = (config) => exports_compaction.make(strategy2(config), defaultOptions(config.options));
 
 // ../runtime/src/agent/relay-instructions.ts
 var layerFromEpoch = (epoch) => exports_instructions.layer(epoch.baseline.length === 0 ? [] : [exports_instructions.staticSource("relay:context-epoch", epoch.baseline)]);
@@ -12133,7 +13519,7 @@ var rememberRule = Effect62.fn("RelayPermissions.rememberRule")(function* (confi
     createdAt
   }).pipe(Effect62.mapError((error) => permissionError(error.message)));
 });
-var layer40 = (config) => Layer56.mergeAll(Layer56.succeed(exports_permissions.Permissions, exports_permissions.Permissions.of({
+var layer41 = (config) => Layer56.mergeAll(Layer56.succeed(exports_permissions.Permissions, exports_permissions.Permissions.of({
   evaluate: (request) => evaluateDecision(config, request),
   await: (pending) => awaitAnswer(config, pending)
 })), Layer56.succeed(exports_permissions.RuleStore, exports_permissions.RuleStore.of({
@@ -12213,7 +13599,7 @@ var append4 = (config, kind, message) => Clock7.currentTimeMillis.pipe(Effect63.
   content: contentFromMessage(message),
   createdAt
 })), Effect63.asVoid);
-var layer41 = (config) => Layer57.succeed(exports_steering.Steering, exports_steering.Steering.of({
+var layer42 = (config) => Layer57.succeed(exports_steering.Steering, exports_steering.Steering.of({
   steer: (message) => append4(config, "steering", message).pipe(Effect63.orDie),
   followUp: (message) => append4(config, "follow_up", message).pipe(Effect63.orDie),
   takeSteering: () => drain2(config, "steering", "all").pipe(Effect63.orDie),
@@ -12274,7 +13660,7 @@ var make10 = (config) => ({
     }))))));
   })
 });
-var layer42 = (config) => Layer58.succeed(exports_tool_executor.ToolExecutor, exports_tool_executor.ToolExecutor.of(make10(config)));
+var layer43 = (config) => Layer58.succeed(exports_tool_executor.ToolExecutor, exports_tool_executor.ToolExecutor.of(make10(config)));
 
 // ../runtime/src/agent/relay-tool-output.ts
 import { Effect as Effect65, Layer as Layer59, Option as Option21 } from "effect";
@@ -12318,7 +13704,7 @@ var store = (blobStore, toolCallId, content) => {
 var make11 = (blobStore) => ({
   put: (toolCallId, content) => store(blobStore, toolCallId, content)
 });
-var layer43 = Layer59.effect(exports_tool_output.ToolOutputStore, Service38.pipe(Effect65.map((blobStore) => exports_tool_output.ToolOutputStore.of(make11(blobStore)))));
+var layer44 = Layer59.effect(exports_tool_output.ToolOutputStore, Service38.pipe(Effect65.map((blobStore) => exports_tool_output.ToolOutputStore.of(make11(blobStore)))));
 
 // ../runtime/src/agent/sequence-allocator.ts
 import { Effect as Effect66, Ref as Ref17 } from "effect";
@@ -12353,6 +13739,20 @@ class Service41 extends Context54.Service()("@relayfx/runtime/AgentLoop") {
 }
 var jsonValue6 = (value) => Schema63.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var toolNames = (agent) => HashSet6.fromIterable(agent.tool_names);
+var turnPolicyFromSnapshot = (snapshot2) => {
+  switch (snapshot2.kind) {
+    case "recurs":
+      return exports_turn_policy.recurs(snapshot2.count);
+    case "until-tool-call":
+      return exports_turn_policy.untilToolCall(snapshot2.name);
+    case "both":
+      return exports_turn_policy.both(turnPolicyFromSnapshot(snapshot2.first), turnPolicyFromSnapshot(snapshot2.second));
+  }
+};
+var turnPolicyFromDefinition = (agent) => {
+  const cap = exports_turn_policy.recurs(agent.max_tool_turns ?? exports_agent_schema.defaultMaxToolTurns);
+  return agent.turn_policy === undefined ? cap : exports_turn_policy.both(cap, turnPolicyFromSnapshot(agent.turn_policy));
+};
 var availableRegisteredTools = (agent, registered) => {
   const names = toolNames(agent);
   return registered.filter((tool2) => tool2.definition.name !== toolName && HashSet6.has(names, tool2.definition.name));
@@ -12666,7 +14066,7 @@ var compactionOptionsFromAgentMetadata = Effect67.fn("AgentLoop.compactionOption
   };
 });
 var effectiveCompactionOptions = (input) => input.compaction !== undefined ? Effect67.succeed(input.compaction ?? undefined) : compactionOptionsFromAgentMetadata(input);
-var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
+var layer45 = Layer60.effect(Service41, Effect67.gen(function* () {
   const eventLog = yield* Service24;
   const languageModels = yield* Service34;
   const tools = yield* Service26;
@@ -12709,7 +14109,7 @@ var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
       const permissionsLayer = input.agent.permission_rules === undefined ? Layer60.empty : Option22.isNone(permissionRules) || Option22.isNone(waits) ? yield* Effect67.fail(new AgentLoopError({
         message: "Execution permission rules require PermissionRuleRepository and WaitService in context",
         next_event_sequence: input.eventSequence + 1
-      })) : layer40({
+      })) : layer41({
         ruleset: input.agent.permission_rules,
         repository: permissionRules.value,
         waits: waits.value,
@@ -12724,7 +14124,7 @@ var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
       const steeringLayer = input.steeringEnabled !== true ? Layer60.empty : Option22.isNone(steeringRepository) ? yield* Effect67.fail(new AgentLoopError({
         message: "Execution steering requires SteeringRepository in context",
         next_event_sequence: input.eventSequence + 1
-      })) : layer41({
+      })) : layer42({
         repository: steeringRepository.value,
         eventLog,
         allocator,
@@ -12764,7 +14164,7 @@ var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
       const agent = exports_agent.make({
         name: input.agent.name,
         toolkit,
-        policy: exports_turn_policy.recurs(input.agent.max_tool_turns ?? exports_agent_schema.defaultMaxToolTurns)
+        policy: turnPolicyFromDefinition(input.agent)
       });
       if (toolOutputMaxBytes !== undefined && Option22.isNone(blobStore)) {
         return yield* Effect67.fail(new AgentLoopError({
@@ -12796,7 +14196,7 @@ var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
         ...toolOutputMaxBytes === undefined ? {} : { toolOutputMaxBytes },
         ...batonCompaction === undefined ? {} : { compaction: batonCompaction }
       };
-      const executorLayer = layer42({
+      const executorLayer = layer43({
         toolRuntime: tools,
         eventLog,
         allocator,
@@ -12882,7 +14282,7 @@ var layer44 = Layer60.effect(Service41, Effect67.gen(function* () {
       const runFold = Effect67.gen(function* () {
         const base = yield* LanguageModel6.LanguageModel;
         const sessionStore = input.sessionId !== undefined && Option22.isSome(sessionRepository) ? yield* make8(input.sessionId, input.sessionEntryScope ?? input.executionId).pipe(Effect67.provideService(exports_session_repository.Service, sessionRepository.value)) : undefined;
-        const folded = exports_agent.stream(agent, batonOptions).pipe(Stream8.runFoldEffect(() => ({ text: "", transcript: undefined, turn: undefined, tokensUsed: seededTokens }), foldEvent), Effect67.provideService(LanguageModel6.LanguageModel, base), Effect67.provideService(exports_model_resilience.ModelResilience, policy), Effect67.provide(executorLayer), Effect67.provide(handlerLayer), Effect67.provide(layer39), Effect67.provide(exports_model_middleware.identityLayer), Effect67.provide(instructionsLayer), Effect67.provide(permissionsLayer), Effect67.provide(steeringLayer));
+        const folded = exports_agent.stream(agent, batonOptions).pipe(Stream8.runFoldEffect(() => ({ text: "", transcript: undefined, turn: undefined, tokensUsed: seededTokens }), foldEvent), Effect67.provideService(LanguageModel6.LanguageModel, base), Effect67.provideService(exports_model_resilience.ModelResilience, policy), Effect67.provide(executorLayer), Effect67.provide(handlerLayer), Effect67.provide(layer40), Effect67.provide(exports_model_middleware.identityLayer), Effect67.provide(instructionsLayer), Effect67.provide(permissionsLayer), Effect67.provide(steeringLayer));
         const withToolOutput = toolOutputStore === undefined ? folded : folded.pipe(Effect67.provideService(exports_tool_output.ToolOutputStore, toolOutputStore));
         const withCompaction = compactionService === undefined ? withToolOutput : withToolOutput.pipe(Effect67.provideService(exports_compaction.Compaction, compactionService));
         const withSession = sessionStore === undefined ? withCompaction : withCompaction.pipe(Effect67.provideService(exports_session.SessionStore, sessionStore));
@@ -12919,11 +14319,12 @@ var run3 = Effect67.fn("AgentLoop.run.call")(function* (input) {
 // ../runtime/src/cluster/execution-entity.ts
 var exports_execution_entity = {};
 __export(exports_execution_entity, {
-  layer: () => layer49,
+  layer: () => layer50,
   entity: () => entity,
   client: () => client2,
   Start: () => Start,
   SignalWait: () => SignalWait,
+  Dispatch: () => Dispatch,
   Cancel: () => Cancel
 });
 import { ClusterSchema, Entity } from "effect/unstable/cluster";
@@ -12941,7 +14342,8 @@ __export(exports_execution_workflow, {
   sessionEntryScope: () => sessionEntryScope,
   resume: () => resume3,
   poll: () => poll,
-  layer: () => layer48,
+  layer: () => layer49,
+  dispatchRequest: () => dispatchRequest,
   cancelRequest: () => cancelRequest,
   activeWorkflowExecutionIdForExecution: () => activeWorkflowExecutionIdForExecution,
   WaitSnapshot: () => WaitSnapshot,
@@ -12959,7 +14361,7 @@ __export(exports_execution_workflow, {
   ActivityNameTemplates: () => ActivityNameTemplates
 });
 import { Activity, DurableDeferred, Workflow } from "effect/unstable/workflow";
-import { Effect as Effect73, Exit as Exit2, Option as Option26, Schema as Schema69 } from "effect";
+import { Effect as Effect74, Exit as Exit2, Option as Option26, Schema as Schema69 } from "effect";
 
 // ../runtime/src/child/parent-notifier-service.ts
 import { Context as Context55, Effect as Effect68, Layer as Layer61, Option as Option23, Ref as Ref19, Schema as Schema64 } from "effect";
@@ -13058,7 +14460,7 @@ __export(exports_skill_registry_service, {
   listRevisions: () => listRevisions4,
   listPins: () => listPins2,
   list: () => list12,
-  layer: () => layer45,
+  layer: () => layer46,
   getRevision: () => getRevision4,
   getPinned: () => getPinned2,
   get: () => get13,
@@ -13139,7 +14541,7 @@ var toBatonSkill = (pin) => {
   };
 };
 var sourceError = (error) => new exports_skill_source.SkillSourceError({ source: "relay.skill_registry", message: error.message });
-var layer45 = Layer62.effect(Service43, Effect69.gen(function* () {
+var layer46 = Layer62.effect(Service43, Effect69.gen(function* () {
   const repository = yield* exports_skill_definition_repository.Service;
   return Service43.of({
     register: Effect69.fn("SkillRegistry.register")(function* (input) {
@@ -13237,7 +14639,7 @@ __export(exports_execution_service, {
   send: () => send,
   run: () => run4,
   memoryLayer: () => memoryLayer32,
-  layer: () => layer46,
+  layer: () => layer47,
   cancel: () => cancel3,
   accept: () => accept,
   Service: () => Service44,
@@ -13268,7 +14670,7 @@ var toExecution = (record2) => ({
 });
 var mapRepositoryError9 = (error) => new ExecutionServiceError({ message: error._tag });
 var mapEventLogError4 = (error) => new ExecutionServiceError({ message: error._tag });
-var mapChildRunError2 = (error) => new ExecutionServiceError({ message: error._tag });
+var mapChildRunError2 = (error) => new ExecutionServiceError({ message: error._tag === "ChildRunServiceError" ? error.message : error._tag });
 var childExecutionId2 = (input) => input.child_execution_id ?? exports_ids_schema.ChildExecutionId.make(`${input.execution_id}:child:${input.address_id}`);
 var hasCompleteAgentDefinitionPin2 = (input) => {
   const present = [input.agentId !== undefined, input.agentRevision !== undefined, input.agentSnapshot !== undefined];
@@ -13416,7 +14818,7 @@ var updateStatus2 = Effect70.fn("ExecutionService.updateStatus")(function* (repo
   }).pipe(Effect70.mapError(mapRepositoryError9));
   return toExecution(record2);
 });
-var layer46 = Layer63.effect(Service44, Effect70.gen(function* () {
+var layer47 = Layer63.effect(Service44, Effect70.gen(function* () {
   const repository = yield* exports_execution_repository.Service;
   const eventLog = yield* Service24;
   const childRuns = yield* Service31;
@@ -13538,7 +14940,7 @@ var layer46 = Layer63.effect(Service44, Effect70.gen(function* () {
     stream: (input) => eventLog.stream(input).pipe(Stream9.take(input.limit ?? 1000), Stream9.mapError((error) => mapEventLogError4(error)))
   });
 }));
-var memoryLayer32 = layer46.pipe(Layer63.provide(layer32), Layer63.provide(exports_execution_repository.memoryLayer), Layer63.provide(exports_session_repository.memoryLayer), Layer63.provide(exports_child_execution_repository.memoryLayer), Layer63.provide(memoryLayer21), Layer63.provide(ShardingConfig.layer({ runnerAddress: Option24.none() })));
+var memoryLayer32 = layer47.pipe(Layer63.provide(layer33), Layer63.provide(exports_execution_repository.memoryLayer), Layer63.provide(exports_session_repository.memoryLayer), Layer63.provide(exports_child_execution_repository.memoryLayer), Layer63.provide(memoryLayer21), Layer63.provide(ShardingConfig.layer({ runnerAddress: Option24.none() })));
 var testLayer48 = (implementation) => Layer63.succeed(Service44, Service44.of(implementation));
 var accept = Effect70.fn("ExecutionService.accept.call")(function* (input) {
   const service = yield* Service44;
@@ -13562,37 +14964,69 @@ var spawnChildRun = Effect70.fn("ExecutionService.spawnChildRun.call")(function*
 });
 var stream3 = (input) => Stream9.unwrap(Service44.pipe(Effect70.map((service) => service.stream(input))));
 
+// ../runtime/src/tool/tool-transition-coordinator.ts
+var exports_tool_transition_coordinator = {};
+__export(exports_tool_transition_coordinator, {
+  sqlLayer: () => sqlLayer,
+  memoryLayer: () => memoryLayer33,
+  coordinate: () => coordinate,
+  Service: () => Service45
+});
+import { Context as Context58, Effect as Effect71, Layer as Layer64, Semaphore as Semaphore4 } from "effect";
+import { SqlClient as SqlClient22 } from "effect/unstable/sql/SqlClient";
+
+class Service45 extends Context58.Service()("@relayfx/runtime/ToolTransitionCoordinator") {
+}
+var make14 = Effect71.gen(function* () {
+  const semaphore = yield* Semaphore4.make(1);
+  return Service45.of({
+    coordinate: (effect) => semaphore.withPermit(effect)
+  });
+});
+var memoryLayer33 = Layer64.effect(Service45, make14);
+var sqlLayer = Layer64.effect(Service45, Effect71.gen(function* () {
+  const sql3 = yield* SqlClient22;
+  const semaphore = yield* Semaphore4.make(1);
+  return Service45.of({
+    coordinate: (effect) => semaphore.withPermit(sql3.withTransaction(effect))
+  });
+}));
+var coordinate = Effect71.fn("ToolTransitionCoordinator.coordinate")(function* (effect) {
+  const service = yield* Service45;
+  return yield* service.coordinate(effect);
+});
+
 // ../runtime/src/workspace/workspace-planner-service.ts
-import { Context as Context59, Effect as Effect72, HashSet as HashSet7, Layer as Layer65, Option as Option25, Schema as Schema68 } from "effect";
+import { Context as Context60, Effect as Effect73, HashSet as HashSet7, Layer as Layer66, Option as Option25, Schema as Schema68 } from "effect";
 
 // ../runtime/src/workspace/workspace-runtime-service.ts
-import { Context as Context58, Effect as Effect71, Layer as Layer64, Schema as Schema67 } from "effect";
+import { Context as Context59, Effect as Effect72, Layer as Layer65, Schema as Schema67 } from "effect";
 
 class WorkspaceRuntimeError extends Schema67.TaggedErrorClass()("WorkspaceRuntimeError", {
   message: Schema67.String
 }) {
 }
 
-class Service45 extends Context58.Service()("@relayfx/runtime/WorkspaceRuntime") {
+class Service46 extends Context59.Service()("@relayfx/runtime/WorkspaceRuntime") {
 }
 var mapRuntimeError = (error) => new WorkspaceRuntimeError({
   message: error._tag === "WorkspaceNotFound" ? `Workspace not found: ${error.sandbox_ref}` : error.message
 });
-var layerFromHandle = (handle) => Layer64.succeed(Service45, Service45.of({
-  readFile: Effect71.fn("WorkspaceRuntime.readFile")((path2) => handle.readFile(path2).pipe(Effect71.mapError(mapRuntimeError))),
-  writeFile: Effect71.fn("WorkspaceRuntime.writeFile")((path2, content) => handle.writeFile(path2, content).pipe(Effect71.mapError(mapRuntimeError))),
-  exec: Effect71.fn("WorkspaceRuntime.exec")((input) => handle.exec(input).pipe(Effect71.mapError((error) => new WorkspaceRuntimeError({ message: error.message }))))
+var layerFromHandle = (handle) => Layer65.succeed(Service46, Service46.of({
+  readFile: Effect72.fn("WorkspaceRuntime.readFile")((path2) => handle.readFile(path2).pipe(Effect72.mapError(mapRuntimeError))),
+  writeFile: Effect72.fn("WorkspaceRuntime.writeFile")((path2, content) => handle.writeFile(path2, content).pipe(Effect72.mapError(mapRuntimeError))),
+  exec: Effect72.fn("WorkspaceRuntime.exec")((input) => handle.exec(input).pipe(Effect72.mapError((error) => new WorkspaceRuntimeError({ message: error.message }))))
 }));
-var readFile = Effect71.fn("WorkspaceRuntime.readFile.call")(function* (path2) {
-  const service = yield* Service45;
+var readFile = Effect72.fn("WorkspaceRuntime.readFile.call")(function* (path2) {
+  const service = yield* Service46;
   return yield* service.readFile(path2);
 });
-var writeFile = Effect71.fn("WorkspaceRuntime.writeFile.call")(function* (path2, content) {
-  const service = yield* Service45;
+var writeFile = Effect72.fn("WorkspaceRuntime.writeFile.call")(function* (path2, content) {
+  const service = yield* Service46;
   return yield* service.writeFile(path2, content);
 });
-var exec = Effect71.fn("WorkspaceRuntime.exec.call")(function* (input) {
-  const service = yield* Service45;
+var exec = Effect72.fn("WorkspaceRuntime.exec.call")(function* (input) {
+  const service = yield* Service46;
   return yield* service.exec(input);
 });
 
@@ -13612,7 +15046,7 @@ class WorkspacePlannerError extends Schema68.TaggedErrorClass()("WorkspacePlanne
 }) {
 }
 
-class Service46 extends Context59.Service()("@relayfx/runtime/WorkspacePlanner") {
+class Service47 extends Context60.Service()("@relayfx/runtime/WorkspacePlanner") {
 }
 var selectedToolNames = (agent) => HashSet7.fromIterable(agent.tool_names);
 var selectedDefinitions = (input) => {
@@ -13624,11 +15058,11 @@ var needsWorkspace = (input) => selectedDefinitions(input).some(requiresWorkspac
 var leaseId = (executionId) => exports_ids_schema.WorkspaceLeaseId.make(`workspace-lease:${executionId}`);
 var mapRepositoryError10 = (error) => new WorkspacePlannerError({ message: error._tag });
 var mapEventLogError5 = (error) => new WorkspacePlannerError({ message: error._tag });
-var providerOrMissing = (executionId) => Effect72.serviceOption(Service30).pipe(Effect72.flatMap((provider) => Option25.match(provider, {
-  onNone: () => Effect72.fail(new WorkspaceRuntimeMissing({ execution_id: executionId })),
-  onSome: Effect72.succeed
+var providerOrMissing = (executionId) => Effect73.serviceOption(Service30).pipe(Effect73.flatMap((provider) => Option25.match(provider, {
+  onNone: () => Effect73.fail(new WorkspaceRuntimeMissing({ execution_id: executionId })),
+  onSome: Effect73.succeed
 })));
-var nextEventSequence3 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect72.map((max) => max === undefined ? 0 : max + 1), Effect72.catch(() => Effect72.succeed(0)));
+var nextEventSequence3 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect73.map((max) => max === undefined ? 0 : max + 1), Effect73.catch(() => Effect73.succeed(0)));
 var workspaceEvent = (type, lease, sequence, createdAt) => ({
   id: exports_ids_schema.EventId.make(`event:${lease.execution_id}:workspace:${type}:${sequence}`),
   execution_id: lease.execution_id,
@@ -13644,7 +15078,7 @@ var workspaceEvent = (type, lease, sequence, createdAt) => ({
   },
   created_at: createdAt
 });
-var appendWorkspaceEvent = (eventLog, type, lease, sequence, createdAt) => appendIdempotentTo(eventLog, workspaceEvent(type, lease, sequence, createdAt)).pipe(Effect72.mapError(mapEventLogError5), Effect72.asVoid);
+var appendWorkspaceEvent = (eventLog, type, lease, sequence, createdAt) => appendIdempotentTo(eventLog, workspaceEvent(type, lease, sequence, createdAt)).pipe(Effect73.mapError(mapEventLogError5), Effect73.asVoid);
 var providerAcquireSpec = (input) => ({
   executionId: input.executionId,
   ...input.request === undefined ? {} : { request: input.request }
@@ -13661,50 +15095,50 @@ var planResult = (lease, handle) => ({
   runtimeLayer: layerFromHandle(handle)
 });
 var missingRef = (executionId) => new WorkspaceLeaseMissingRef({ execution_id: executionId });
-var ensureFromExisting = Effect72.fn("WorkspacePlanner.ensureFromExisting")(function* (repository, eventLog, provider, lease, input) {
+var ensureFromExisting = Effect73.fn("WorkspacePlanner.ensureFromExisting")(function* (repository, eventLog, provider, lease, input) {
   if (lease.sandbox_ref === undefined) {
     const handle2 = yield* provider.acquire(providerAcquireSpec(input));
-    const running2 = yield* repository.markRunning({ executionId: input.executionId, sandboxRef: handle2.ref, updatedAt: input.now }).pipe(Effect72.mapError(mapRepositoryError10));
+    const running2 = yield* repository.markRunning({ executionId: input.executionId, sandboxRef: handle2.ref, updatedAt: input.now }).pipe(Effect73.mapError(mapRepositoryError10));
     const sequence2 = yield* nextEventSequence3(eventLog, input.executionId);
     yield* appendWorkspaceEvent(eventLog, "workspace.lease.acquired", running2, sequence2, input.now);
     return planResult(running2, handle2);
   }
   const handle = yield* provider.resume(lease.sandbox_ref);
-  const running = yield* repository.markResumed({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect72.mapError(mapRepositoryError10));
+  const running = yield* repository.markResumed({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect73.mapError(mapRepositoryError10));
   const sequence = yield* nextEventSequence3(eventLog, input.executionId);
   yield* appendWorkspaceEvent(eventLog, "workspace.resumed", running, sequence, input.now);
   return planResult(running, handle);
 });
-var layer47 = Layer65.effect(Service46, Effect72.gen(function* () {
+var layer48 = Layer66.effect(Service47, Effect73.gen(function* () {
   const repository = yield* exports_workspace_lease_repository.Service;
   const eventLog = yield* Service24;
-  return Service46.of({
-    ensure: Effect72.fn("WorkspacePlanner.ensure")(function* (input) {
+  return Service47.of({
+    ensure: Effect73.fn("WorkspacePlanner.ensure")(function* (input) {
       if (!needsWorkspace(input))
         return;
       const provider = yield* providerOrMissing(input.executionId);
-      const existing = yield* repository.getByExecution(input.executionId).pipe(Effect72.mapError(mapRepositoryError10));
+      const existing = yield* repository.getByExecution(input.executionId).pipe(Effect73.mapError(mapRepositoryError10));
       if (existing !== undefined && existing.status !== "released" && existing.status !== "failed") {
         return yield* ensureFromExisting(repository, eventLog, provider, existing, input);
       }
-      const planned = yield* repository.plan(planInput(input, provider)).pipe(Effect72.mapError(mapRepositoryError10));
+      const planned = yield* repository.plan(planInput(input, provider)).pipe(Effect73.mapError(mapRepositoryError10));
       let sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.lease.planned", planned, sequence, input.now);
       const handle = yield* provider.acquire(providerAcquireSpec(input));
-      const running = yield* repository.markRunning({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect72.mapError(mapRepositoryError10));
+      const running = yield* repository.markRunning({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect73.mapError(mapRepositoryError10));
       sequence += 1;
       yield* appendWorkspaceEvent(eventLog, "workspace.lease.acquired", running, sequence, input.now);
       return planResult(running, handle);
     }),
-    suspend: Effect72.fn("WorkspacePlanner.suspend")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect72.mapError(mapRepositoryError10));
+    suspend: Effect73.fn("WorkspacePlanner.suspend")(function* (input) {
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect73.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       if (lease.sandbox_ref === undefined)
-        return yield* Effect72.fail(missingRef(input.executionId));
+        return yield* Effect73.fail(missingRef(input.executionId));
       const provider = yield* providerOrMissing(input.executionId);
       if (!provider.capabilities.can_suspend && !provider.capabilities.persistent_by_default) {
-        return yield* Effect72.fail(new WorkspaceCapabilityUnsupported({
+        return yield* Effect73.fail(new WorkspaceCapabilityUnsupported({
           capability: "suspend",
           provider_key: provider.providerKey
         }));
@@ -13712,84 +15146,84 @@ var layer47 = Layer65.effect(Service46, Effect72.gen(function* () {
       if (provider.capabilities.can_suspend) {
         yield* provider.suspend(lease.sandbox_ref);
       }
-      const suspended2 = yield* repository.markSuspended({ executionId: input.executionId, updatedAt: input.now }).pipe(Effect72.mapError(mapRepositoryError10));
+      const suspended2 = yield* repository.markSuspended({ executionId: input.executionId, updatedAt: input.now }).pipe(Effect73.mapError(mapRepositoryError10));
       const sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.suspended", suspended2, sequence, input.now);
       return suspended2;
     }),
-    resume: Effect72.fn("WorkspacePlanner.resume")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect72.mapError(mapRepositoryError10));
+    resume: Effect73.fn("WorkspacePlanner.resume")(function* (input) {
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect73.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       if (lease.sandbox_ref === undefined)
-        return yield* Effect72.fail(missingRef(input.executionId));
+        return yield* Effect73.fail(missingRef(input.executionId));
       const provider = yield* providerOrMissing(input.executionId);
       const handle = yield* provider.resume(lease.sandbox_ref);
-      const running = yield* repository.markResumed({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect72.mapError(mapRepositoryError10));
+      const running = yield* repository.markResumed({ executionId: input.executionId, sandboxRef: handle.ref, updatedAt: input.now }).pipe(Effect73.mapError(mapRepositoryError10));
       const sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.resumed", running, sequence, input.now);
       return planResult(running, handle);
     }),
-    attach: Effect72.fn("WorkspacePlanner.attach")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect72.mapError(mapRepositoryError10));
+    attach: Effect73.fn("WorkspacePlanner.attach")(function* (input) {
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect73.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       if (lease.sandbox_ref === undefined)
-        return yield* Effect72.fail(missingRef(input.executionId));
+        return yield* Effect73.fail(missingRef(input.executionId));
       const provider = yield* providerOrMissing(input.executionId);
       const handle = yield* provider.resume(lease.sandbox_ref);
       return planResult(lease, handle);
     }),
-    release: Effect72.fn("WorkspacePlanner.release")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect72.mapError(mapRepositoryError10));
+    release: Effect73.fn("WorkspacePlanner.release")(function* (input) {
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect73.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       if (lease.sandbox_ref === undefined)
-        return yield* Effect72.fail(missingRef(input.executionId));
+        return yield* Effect73.fail(missingRef(input.executionId));
       const provider = yield* providerOrMissing(input.executionId);
       yield* provider.destroy(lease.sandbox_ref);
-      const released = yield* repository.markReleased({ executionId: input.executionId, updatedAt: input.now }).pipe(Effect72.mapError(mapRepositoryError10));
+      const released = yield* repository.markReleased({ executionId: input.executionId, updatedAt: input.now }).pipe(Effect73.mapError(mapRepositoryError10));
       const sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.lease.released", released, sequence, input.now);
       return released;
     }),
-    fail: Effect72.fn("WorkspacePlanner.fail")(function* (input) {
-      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect72.mapError(mapRepositoryError10));
+    fail: Effect73.fn("WorkspacePlanner.fail")(function* (input) {
+      const lease = yield* repository.getByExecution(input.executionId).pipe(Effect73.mapError(mapRepositoryError10));
       if (lease === undefined || lease.status === "released" || lease.status === "failed")
         return;
       const failed = yield* repository.markFailed({
         executionId: input.executionId,
         updatedAt: input.now,
         ...input.metadata === undefined ? {} : { metadata: input.metadata }
-      }).pipe(Effect72.mapError(mapRepositoryError10));
+      }).pipe(Effect73.mapError(mapRepositoryError10));
       const sequence = yield* nextEventSequence3(eventLog, input.executionId);
       yield* appendWorkspaceEvent(eventLog, "workspace.lease.failed", failed, sequence, input.now);
       return failed;
     })
   });
 }));
-var ensure2 = Effect72.fn("WorkspacePlanner.ensure.call")(function* (input) {
-  const service = yield* Service46;
+var ensure2 = Effect73.fn("WorkspacePlanner.ensure.call")(function* (input) {
+  const service = yield* Service47;
   return yield* service.ensure(input);
 });
-var suspend2 = Effect72.fn("WorkspacePlanner.suspend.call")(function* (input) {
-  const service = yield* Service46;
+var suspend2 = Effect73.fn("WorkspacePlanner.suspend.call")(function* (input) {
+  const service = yield* Service47;
   return yield* service.suspend(input);
 });
-var resume2 = Effect72.fn("WorkspacePlanner.resume.call")(function* (input) {
-  const service = yield* Service46;
+var resume2 = Effect73.fn("WorkspacePlanner.resume.call")(function* (input) {
+  const service = yield* Service47;
   return yield* service.resume(input);
 });
-var attach = Effect72.fn("WorkspacePlanner.attach.call")(function* (input) {
-  const service = yield* Service46;
+var attach = Effect73.fn("WorkspacePlanner.attach.call")(function* (input) {
+  const service = yield* Service47;
   return yield* service.attach(input);
 });
-var release2 = Effect72.fn("WorkspacePlanner.release.call")(function* (input) {
-  const service = yield* Service46;
+var release2 = Effect73.fn("WorkspacePlanner.release.call")(function* (input) {
+  const service = yield* Service47;
   return yield* service.release(input);
 });
-var fail = Effect72.fn("WorkspacePlanner.fail.call")(function* (input) {
-  const service = yield* Service46;
+var fail = Effect73.fn("WorkspacePlanner.fail.call")(function* (input) {
+  const service = yield* Service47;
   return yield* service.fail(input);
 });
 
@@ -13936,17 +15370,17 @@ var resolveLocalAgentTarget = (addressId) => Activity.make({
   name: ActivityNames.resolveLocalAgent,
   success: LocalAgentTarget,
   error: ExecutionWorkflowFailed,
-  execute: resolveLocalAgent(addressId).pipe(Effect73.mapError(mapAddressResolutionError))
+  execute: resolveLocalAgent(addressId).pipe(Effect74.mapError(mapAddressResolutionError))
 });
-var resolveStartInput = Effect73.fn("ExecutionWorkflow.resolveStartInput")(function* (input) {
+var resolveStartInput = Effect74.fn("ExecutionWorkflow.resolveStartInput")(function* (input) {
   const pinCount = agentDefinitionPinCount(input);
   if (input.agent_tool_input_schema_digests !== undefined && pinCount !== 3) {
-    return yield* Effect73.fail(invalidAgentDefinitionDigestPin());
+    return yield* Effect74.fail(invalidAgentDefinitionDigestPin());
   }
   if (pinCount === 3)
     return input;
   if (pinCount > 0)
-    return yield* Effect73.fail(invalidAgentDefinitionPin());
+    return yield* Effect74.fail(invalidAgentDefinitionPin());
   const target = yield* resolveLocalAgentTarget(input.root_address_id);
   return {
     ...input,
@@ -13960,7 +15394,7 @@ var acceptExecution = (input) => Activity.make({
   name: ActivityNames.accept,
   success: exports_execution_schema.Execution,
   error: ExecutionWorkflowFailed,
-  execute: Effect73.gen(function* () {
+  execute: Effect74.gen(function* () {
     const accepted2 = yield* accept({
       executionId: input.execution_id,
       rootAddressId: input.root_address_id,
@@ -13972,13 +15406,13 @@ var acceptExecution = (input) => Activity.make({
       ...input.agent_snapshot === undefined ? {} : { agentSnapshot: input.agent_snapshot },
       ...input.agent_tool_input_schema_digests === undefined ? {} : { agentToolInputSchemaDigests: input.agent_tool_input_schema_digests },
       ...input.metadata === undefined ? {} : { metadata: input.metadata }
-    }).pipe(Effect73.mapError(mapExecutionError));
+    }).pipe(Effect74.mapError(mapExecutionError));
     const skillDefinitionIds = input.agent_snapshot?.skill_definition_ids ?? [];
     if (skillDefinitionIds.length > 0) {
       yield* pinExecution2({
         execution_id: input.execution_id,
         skill_definition_ids: skillDefinitionIds
-      }).pipe(Effect73.mapError(mapSkillRegistryError));
+      }).pipe(Effect74.mapError(mapSkillRegistryError));
     }
     return accepted2;
   })
@@ -13988,50 +15422,109 @@ var waitIdFromRecord = (record2) => {
   const waitId = record2.metadata.wait_id;
   return typeof waitId === "string" ? exports_ids_schema.WaitId.make(waitId) : undefined;
 };
-var openChildStatuses = new Set(["queued", "running", "waiting"]);
-var childCancelReason = "parent cancelled";
-var cancelChildExecution = Effect73.fn("ExecutionWorkflow.cancelChildExecution")(function* (executionId, cancelledAt) {
+var prepareCancellation = Effect74.fn("ExecutionWorkflow.prepareCancellation")(function* (input) {
   const repository = yield* exports_execution_repository.Service;
-  const record2 = yield* repository.get(executionId).pipe(Effect73.mapError(mapRepositoryError11));
-  if (record2 === undefined || terminalExecutionStatuses.has(record2.status))
-    return;
-  if (record2.status === "waiting") {
-    const waitId = waitIdFromRecord(record2);
-    if (waitId === undefined) {
-      return yield* Effect73.fail(new ExecutionWorkflowFailed({ message: `Waiting execution missing wait id: ${record2.id}` }));
+  const waits = yield* exports_envelope_repository.Service;
+  const toolCalls2 = yield* exports_tool_call_repository.Service;
+  const coordinator = yield* Service45;
+  const eventLog = yield* Service24;
+  return yield* coordinator.coordinate(Effect74.gen(function* () {
+    const record2 = yield* repository.get(input.execution_id).pipe(Effect74.mapError(mapRepositoryError11));
+    if (record2 === undefined) {
+      return yield* Effect74.fail(new ExecutionWorkflowFailed({ message: `Execution not found: ${input.execution_id}` }));
     }
-    const eventLog = yield* Service24;
-    const eventSequence = yield* nextEventSequence4(eventLog, record2.id);
-    const result = yield* cancel2({
-      waitId,
-      cancelledAt,
-      eventSequence,
-      metadata: { reason: childCancelReason }
-    }).pipe(Effect73.mapError(mapWaitError2));
-    if (result.transitioned) {
-      yield* signalWait({
-        workflow_execution_id: yield* workflowExecutionIdForExecution(record2.id, workflowGenerationFromRecord(record2)),
-        wait_id: waitId,
-        state: "cancelled",
-        signaled_at: cancelledAt
-      });
+    if (terminalExecutionStatuses.has(record2.status)) {
+      return { record: record2, status: record2.status, signals: [], terminalNoop: true };
     }
-    return;
-  }
-  yield* repository.transition({
-    id: record2.id,
-    status: record2.status,
-    updatedAt: cancelledAt,
-    metadata: {
-      ...record2.metadata,
-      cancellation_requested: true,
-      cancellation_reason: childCancelReason
+    const records = yield* waits.listAllWaits({ executionId: record2.id }).pipe(Effect74.mapError((error) => new ExecutionWorkflowFailed({ message: error._tag })));
+    const currentWaitId = record2.status === "waiting" ? waitIdFromRecord(record2) : undefined;
+    if (record2.status === "waiting" && currentWaitId === undefined) {
+      return yield* Effect74.fail(new ExecutionWorkflowFailed({ message: `Waiting execution missing wait id: ${record2.id}` }));
+    }
+    const signals = [];
+    const cancelledCallIds = [];
+    let currentWaitState;
+    for (const wait of records) {
+      const isCurrent = wait.id === currentWaitId;
+      const isToolWait = wait.metadata.kind === "tool-placement";
+      if (wait.state === "open" && (isCurrent || isToolWait)) {
+        const eventSequence = yield* nextEventSequence4(eventLog, record2.id);
+        const result = yield* cancel2({
+          waitId: wait.id,
+          cancelledAt: input.cancelled_at,
+          eventSequence,
+          metadata: { reason: input.reason ?? "Execution cancelled" }
+        }).pipe(Effect74.mapError(mapWaitError2));
+        if (result.wait.state === "cancelled") {
+          signals.push({ waitId: wait.id, state: "cancelled" });
+          if (isToolWait && typeof wait.metadata.tool_call_id === "string") {
+            cancelledCallIds.push(exports_ids_schema.ToolCallId.make(wait.metadata.tool_call_id));
+          }
+        }
+        if (isCurrent && result.wait.state !== "open")
+          currentWaitState = result.wait.state;
+        continue;
+      }
+      if (isToolWait && wait.state === "cancelled" && typeof wait.metadata.tool_call_id === "string") {
+        cancelledCallIds.push(exports_ids_schema.ToolCallId.make(wait.metadata.tool_call_id));
+      }
+      if (isCurrent && wait.state !== "open") {
+        currentWaitState = wait.state;
+        signals.push({ waitId: wait.id, state: wait.state });
+      }
     }
-  }).pipe(Effect73.mapError(mapRepositoryError11));
+    const immediateCallIds = yield* toolCalls2.listCalls(record2.id).pipe(Effect74.mapError((error) => new ExecutionWorkflowFailed({ message: error._tag })), Effect74.map((calls) => calls.filter((call) => call.placement.kind === "local" || call.placement.kind === "mcp").map((call) => call.call.id)));
+    yield* toolCalls2.failOpenForExecution({
+      executionId: record2.id,
+      callIds: [...cancelledCallIds, ...immediateCallIds],
+      message: "Tool execution cancelled",
+      failedAt: input.cancelled_at
+    }).pipe(Effect74.mapError((error) => new ExecutionWorkflowFailed({ message: error._tag })));
+    const updated = yield* repository.transition({
+      id: record2.id,
+      status: record2.status,
+      updatedAt: input.cancelled_at,
+      metadata: {
+        ...record2.metadata,
+        cancellation_requested: true,
+        ...input.reason === undefined ? {} : { cancellation_reason: input.reason }
+      }
+    }).pipe(Effect74.mapError(mapRepositoryError11));
+    return {
+      record: updated,
+      status: currentWaitState === "cancelled" ? "cancelled" : updated.status,
+      signals,
+      terminalNoop: false
+    };
+  })).pipe(Effect74.mapError((error) => error instanceof ExecutionWorkflowFailed ? error : new ExecutionWorkflowFailed({ message: "Tool cancellation transaction failed" })));
+});
+var signalPreparedCancellation = Effect74.fn("ExecutionWorkflow.signalPreparedCancellation")(function* (prepared, signaledAt) {
+  for (const pending of prepared.signals) {
+    yield* signalWait({
+      workflow_execution_id: yield* workflowExecutionIdForExecution(prepared.record.id, workflowGenerationFromRecord(prepared.record)),
+      wait_id: pending.waitId,
+      state: pending.state,
+      signaled_at: signaledAt
+    });
+  }
 });
-var cancelOpenChildren = Effect73.fn("ExecutionWorkflow.cancelOpenChildren")(function* (executionId, cancelledAt) {
-  const children = yield* exports_child_execution_repository.listByExecution(executionId).pipe(Effect73.mapError(mapChildExecutionRepositoryError));
-  yield* Effect73.forEach(children.filter((child) => openChildStatuses.has(child.status)), (child) => Effect73.gen(function* () {
+var openChildStatuses = new Set(["queued", "running", "waiting"]);
+var childCancelReason = "parent cancelled";
+var cancelChildExecution = Effect74.fn("ExecutionWorkflow.cancelChildExecution")(function* (executionId, cancelledAt) {
+  const repository = yield* exports_execution_repository.Service;
+  const record2 = yield* repository.get(executionId).pipe(Effect74.mapError(mapRepositoryError11));
+  if (record2 === undefined)
+    return;
+  const prepared = yield* prepareCancellation({
+    execution_id: executionId,
+    cancelled_at: cancelledAt,
+    reason: childCancelReason
+  });
+  yield* signalPreparedCancellation(prepared, cancelledAt);
+});
+var cancelOpenChildren = Effect74.fn("ExecutionWorkflow.cancelOpenChildren")(function* (executionId, cancelledAt) {
+  const children = yield* exports_child_execution_repository.listByExecution(executionId).pipe(Effect74.mapError(mapChildExecutionRepositoryError));
+  yield* Effect74.forEach(children.filter((child) => openChildStatuses.has(child.status)), (child) => Effect74.gen(function* () {
     yield* exports_child_execution_repository.updateStatus({
       id: child.id,
       status: "cancelled",
@@ -14042,7 +15535,7 @@ var cancelOpenChildren = Effect73.fn("ExecutionWorkflow.cancelOpenChildren")(fun
         cancellation_reason: childCancelReason,
         cancellation_requested_at: cancelledAt
       }
-    }).pipe(Effect73.mapError(mapChildExecutionRepositoryError));
+    }).pipe(Effect74.mapError(mapChildExecutionRepositoryError));
     yield* cancelChildExecution(exports_ids_schema.ExecutionId.make(child.id), cancelledAt);
   }), { discard: true });
 });
@@ -14050,7 +15543,7 @@ var cancelExecution = (input, turn, reason) => Activity.make({
   name: ActivityNames.cancel(turn),
   success: exports_execution_schema.Execution,
   error: ExecutionWorkflowFailed,
-  execute: Effect73.gen(function* () {
+  execute: Effect74.gen(function* () {
     yield* cancelOpenChildren(input.execution_id, input.completed_at);
     const eventLog = yield* Service24;
     const eventSequence = yield* nextEventSequence4(eventLog, input.execution_id);
@@ -14059,16 +15552,16 @@ var cancelExecution = (input, turn, reason) => Activity.make({
       eventSequence,
       cancelledAt: input.completed_at,
       reason
-    }).pipe(Effect73.mapError(mapExecutionError));
+    }).pipe(Effect74.mapError(mapExecutionError));
   })
 });
 var loadCancellationRequested = (input, turn) => Activity.make({
   name: ActivityNames.checkCancel(turn),
   success: Schema69.Boolean,
   error: ExecutionWorkflowFailed,
-  execute: Effect73.gen(function* () {
+  execute: Effect74.gen(function* () {
     const repository = yield* exports_execution_repository.Service;
-    const record2 = yield* repository.get(input.execution_id).pipe(Effect73.mapError(mapRepositoryError11));
+    const record2 = yield* repository.get(input.execution_id).pipe(Effect74.mapError(mapRepositoryError11));
     return record2?.metadata?.cancellation_requested === true;
   })
 });
@@ -14076,7 +15569,7 @@ var loadWait = (name, waitId) => Activity.make({
   name,
   success: Schema69.UndefinedOr(WaitSnapshot),
   error: ExecutionWorkflowFailed,
-  execute: get11(waitId).pipe(Effect73.map((record2) => record2 === undefined ? undefined : toWaitSnapshot(record2)), Effect73.mapError(mapWaitError2))
+  execute: get11(waitId).pipe(Effect74.map((record2) => record2 === undefined ? undefined : toWaitSnapshot(record2)), Effect74.mapError(mapWaitError2))
 });
 var markWaiting = (input, repository, wait) => Activity.make({
   name: ActivityNames.markWaiting(wait.id),
@@ -14091,7 +15584,7 @@ var markWaiting = (input, repository, wait) => Activity.make({
       wait_state: wait.state,
       ...generationMetadata(workflowGenerationForStart(input))
     }
-  }).pipe(Effect73.mapError(mapRepositoryError11), Effect73.map((record2) => ({
+  }).pipe(Effect74.mapError(mapRepositoryError11), Effect74.map((record2) => ({
     id: record2.id,
     root_address_id: record2.rootAddressId,
     ...record2.sessionId === undefined ? {} : { session_id: record2.sessionId },
@@ -14130,26 +15623,26 @@ var metadataSetting = (input, key2) => {
 var executionMetadataSetting = (input, key2) => hasMetadataKey(input.metadata, key2) ? input.metadata?.[key2] : undefined;
 var decodeOptionalNumberSetting = (value, key2, valid) => {
   if (value === undefined)
-    return Effect73.succeed(undefined);
+    return Effect74.succeed(undefined);
   if (value === null || value === false)
-    return Effect73.succeed(null);
+    return Effect74.succeed(null);
   if (typeof value === "number" && Number.isFinite(value) && valid(value))
-    return Effect73.succeed(value);
-  return Effect73.fail(new ExecutionWorkflowFailed({ message: `${key2} metadata value is invalid` }));
+    return Effect74.succeed(value);
+  return Effect74.fail(new ExecutionWorkflowFailed({ message: `${key2} metadata value is invalid` }));
 };
-var optionalNumberForStart = (input, key2, valid) => decodeOptionalNumberSetting(metadataSetting(input, key2), key2, valid).pipe(Effect73.map((value) => value === null ? undefined : value));
+var optionalNumberForStart = (input, key2, valid) => decodeOptionalNumberSetting(metadataSetting(input, key2), key2, valid).pipe(Effect74.map((value) => value === null ? undefined : value));
 var continueAsNewAfterTurnsForStart = (input) => optionalNumberForStart(input, continueAsNewAfterTurnsMetadataKey, (value) => Number.isInteger(value) && value > 0);
 var toolOutputMaxBytesForStart = (input) => decodeOptionalNumberSetting(metadataSetting(input, toolOutputMaxBytesMetadataKey), toolOutputMaxBytesMetadataKey, (value) => value >= 0);
 var decodeCompactionEnabled = (value) => {
   if (value === undefined)
-    return Effect73.succeed(undefined);
+    return Effect74.succeed(undefined);
   if (value === null || value === false)
-    return Effect73.succeed(null);
+    return Effect74.succeed(null);
   if (value === true)
-    return Effect73.succeed(true);
-  return Effect73.fail(new ExecutionWorkflowFailed({ message: "compaction_enabled metadata value must be true or false" }));
+    return Effect74.succeed(true);
+  return Effect74.fail(new ExecutionWorkflowFailed({ message: "compaction_enabled metadata value must be true or false" }));
 };
-var compactionForStart = Effect73.fn("ExecutionWorkflow.compactionForStart")(function* (input) {
+var compactionForStart = Effect74.fn("ExecutionWorkflow.compactionForStart")(function* (input) {
   const executionEnabled = yield* decodeCompactionEnabled(executionMetadataSetting(input, compactionEnabledMetadataKey));
   if (executionEnabled === null)
     return null;
@@ -14165,8 +15658,8 @@ var compactionForStart = Effect73.fn("ExecutionWorkflow.compactionForStart")(fun
     ...keepRecentTokens === undefined ? {} : { keepRecentTokens }
   };
 });
-var decodeMemorySubject = (value) => typeof value === "string" ? Schema69.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(value).pipe(Effect73.mapError(() => new ExecutionWorkflowFailed({ message: `Invalid memory_subject_id metadata value: ${value}` }))) : Effect73.fail(new ExecutionWorkflowFailed({ message: "memory_subject_id metadata value must be a string" }));
-var memorySubjectForStart = Effect73.fn("ExecutionWorkflow.memorySubjectForStart")(function* (input) {
+var decodeMemorySubject = (value) => typeof value === "string" ? Schema69.decodeUnknownEffect(exports_ids_schema.MemorySubjectId)(value).pipe(Effect74.mapError(() => new ExecutionWorkflowFailed({ message: `Invalid memory_subject_id metadata value: ${value}` }))) : Effect74.fail(new ExecutionWorkflowFailed({ message: "memory_subject_id metadata value must be a string" }));
+var memorySubjectForStart = Effect74.fn("ExecutionWorkflow.memorySubjectForStart")(function* (input) {
   const executionSubject = memorySubjectFromMetadata(input.metadata);
   if (executionSubject !== undefined)
     return yield* decodeMemorySubject(executionSubject);
@@ -14180,21 +15673,21 @@ var steeringEnabledForStart = (input) => {
     return executionSetting === true;
   return steeringMetadataValue(input.agent_snapshot?.metadata) === true;
 };
-var nextEventSequence4 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect73.map((max) => max === undefined ? 0 : max + 1), Effect73.mapError(mapEventLogError6));
+var nextEventSequence4 = (eventLog, executionId) => eventLog.maxSequence(executionId).pipe(Effect74.map((max) => max === undefined ? 0 : max + 1), Effect74.mapError(mapEventLogError6));
 var ensureWorkspace = (input) => Activity.make({
   name: ActivityNames.ensureWorkspace,
   success: Schema69.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
-  execute: Effect73.gen(function* () {
+  execute: Effect74.gen(function* () {
     if (input.agent_snapshot === undefined)
-      return yield* Effect73.fail(missingAgentSnapshot());
+      return yield* Effect74.fail(missingAgentSnapshot());
     const tools = yield* Service26;
     const plan2 = yield* ensure2({
       executionId: input.execution_id,
       agent: input.agent_snapshot,
       toolDefinitions: yield* tools.definitions,
       now: input.started_at
-    }).pipe(Effect73.mapError(mapWorkspaceError));
+    }).pipe(Effect74.mapError(mapWorkspaceError));
     return plan2?.lease;
   })
 });
@@ -14202,34 +15695,34 @@ var suspendWorkspace = (input, key2) => Activity.make({
   name: ActivityNames.suspendWorkspace(key2),
   success: Schema69.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
-  execute: suspend2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect73.mapError(mapWorkspaceError))
+  execute: suspend2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect74.mapError(mapWorkspaceError))
 });
 var resumeWorkspace = (input, key2) => Activity.make({
   name: ActivityNames.resumeWorkspace(key2),
   success: Schema69.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
-  execute: resume2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect73.map((plan2) => plan2?.lease), Effect73.mapError(mapWorkspaceError))
+  execute: resume2({ executionId: input.execution_id, now: input.started_at }).pipe(Effect74.map((plan2) => plan2?.lease), Effect74.mapError(mapWorkspaceError))
 });
 var releaseWorkspace = (input) => Activity.make({
   name: ActivityNames.releaseWorkspace,
   success: Schema69.UndefinedOr(exports_workspace_schema.WorkspaceLeaseRecord),
   error: ExecutionWorkflowFailed,
-  execute: release2({ executionId: input.execution_id, now: input.completed_at }).pipe(Effect73.mapError(mapWorkspaceError))
+  execute: release2({ executionId: input.execution_id, now: input.completed_at }).pipe(Effect74.mapError(mapWorkspaceError))
 });
 var failWorkspace = (input, error) => fail({
   executionId: input.execution_id,
   now: input.completed_at,
   metadata: { message: error.message }
-}).pipe(Effect73.catch(() => Effect73.void));
-var attachWorkspace = (input) => attach({ executionId: input.execution_id, now: input.started_at }).pipe(Effect73.mapError(mapWorkspaceError));
+}).pipe(Effect74.catch(() => Effect74.void));
+var attachWorkspace = (input) => attach({ executionId: input.execution_id, now: input.started_at }).pipe(Effect74.mapError(mapWorkspaceError));
 var sessionEntryScope = (input, turn) => `${input.execution_id}:${workflowGenerationForStart(input)}:complete:${turn}`;
 var completeExecution = (input, waitId, waitState, workspaceRuntimeLayer, turn, pendingToolCall) => Activity.make({
   name: ActivityNames.complete(turn),
   success: exports_execution_schema.Execution,
   error: ExecutionWorkflowFailed,
-  execute: Effect73.gen(function* () {
+  execute: Effect74.gen(function* () {
     if (input.agent_snapshot === undefined)
-      return yield* Effect73.fail(missingAgentSnapshot());
+      return yield* Effect74.fail(missingAgentSnapshot());
     const agentLoop = yield* Service41;
     const eventLog = yield* Service24;
     const runEventSequence = yield* nextEventSequence4(eventLog, input.execution_id);
@@ -14268,18 +15761,18 @@ var completeExecution = (input, waitId, waitState, workspaceRuntimeLayer, turn,
         agent_snapshot: child.agentSnapshot,
         ...child.agentToolInputSchemaDigests === undefined ? {} : { agent_tool_input_schema_digests: child.agentToolInputSchemaDigests },
         metadata: child.metadata
-      }, { discard: true }).pipe(Effect73.asVoid)
+      }, { discard: true }).pipe(Effect74.asVoid)
     });
-    const skillLoopProgram = skillDefinitionIds.length === 0 ? loopProgram : loopProgram.pipe(Effect73.provideService(exports_skill_source.SkillSource, yield* sourceForExecution(input.execution_id).pipe(Effect73.mapError((error) => new ExecutionWorkflowFailed({ message: error.message })))));
-    const workspaceLoopProgram = workspaceRuntimeLayer === undefined ? skillLoopProgram : skillLoopProgram.pipe(Effect73.provide(workspaceRuntimeLayer));
-    const program = workspaceLoopProgram.pipe(Effect73.map((result) => ({
+    const skillLoopProgram = skillDefinitionIds.length === 0 ? loopProgram : loopProgram.pipe(Effect74.provideService(exports_skill_source.SkillSource, yield* sourceForExecution(input.execution_id).pipe(Effect74.mapError((error) => new ExecutionWorkflowFailed({ message: error.message })))));
+    const workspaceLoopProgram = workspaceRuntimeLayer === undefined ? skillLoopProgram : skillLoopProgram.pipe(Effect74.provide(workspaceRuntimeLayer));
+    const program = workspaceLoopProgram.pipe(Effect74.map((result) => ({
       metadata: {
         ...result.metadata,
         ...waitId === undefined ? {} : { wait_id: waitId },
         ...waitId === undefined || waitState === undefined ? {} : { wait_state: waitState }
       },
       nextEventSequence: result.nextEventSequence
-    })), Effect73.catchTag("AgentLoopWaitRequested", (wait) => Effect73.succeed({
+    })), Effect74.catchTag("AgentLoopWaitRequested", (wait) => Effect74.succeed({
       _tag: "waiting",
       waitId: wait.wait_id,
       metadata: {
@@ -14289,14 +15782,14 @@ var completeExecution = (input, waitId, waitState, workspaceRuntimeLayer, turn,
         ...generationMetadata(workflowGenerationForStart(input))
       },
       nextEventSequence: wait.next_event_sequence
-    })), Effect73.mapError(mapAgentLoopError));
+    })), Effect74.mapError(mapAgentLoopError));
     return yield* run4({
       executionId: input.execution_id,
       eventSequence: runEventSequence,
       startedAt: input.started_at,
       completedAt: input.completed_at,
       program
-    }).pipe(Effect73.mapError(mapExecutionError));
+    }).pipe(Effect74.mapError(mapExecutionError));
   })
 });
 var childDispatchContext = (input) => {
@@ -14315,11 +15808,11 @@ var loadChildCancellationRequested = (input) => Activity.make({
   name: ActivityNames.checkQueuedChildCancellation,
   success: Schema69.Boolean,
   error: ExecutionWorkflowFailed,
-  execute: Effect73.gen(function* () {
+  execute: Effect74.gen(function* () {
     const context = childDispatchContext(input);
     if (context === undefined)
       return false;
-    const child = yield* exports_child_execution_repository.get(context.childExecutionId).pipe(Effect73.mapError(mapChildExecutionRepositoryError));
+    const child = yield* exports_child_execution_repository.get(context.childExecutionId).pipe(Effect74.mapError(mapChildExecutionRepositoryError));
     return child?.status === "cancelled" || child?.metadata.cancellation_requested === true;
   })
 });
@@ -14327,8 +15820,8 @@ var notifyParentActivity = (input, context, status, output) => Activity.make({
   name: ActivityNames.notifyParent(status),
   success: Schema69.Void,
   error: ExecutionWorkflowFailed,
-  execute: Effect73.gen(function* () {
-    const notifier = yield* Effect73.serviceOption(Service42);
+  execute: Effect74.gen(function* () {
+    const notifier = yield* Effect74.serviceOption(Service42);
     if (Option26.isNone(notifier))
       return;
     yield* notifier.value.notify({
@@ -14338,12 +15831,12 @@ var notifyParentActivity = (input, context, status, output) => Activity.make({
       status,
       output,
       notifiedAt: input.completed_at
-    }).pipe(Effect73.mapError((error) => new ExecutionWorkflowFailed({ message: error.message })));
+    }).pipe(Effect74.mapError((error) => new ExecutionWorkflowFailed({ message: error.message })));
   })
 });
 var notifyParent = (input, status, output) => {
   const context = childDispatchContext(input);
-  return context === undefined ? Effect73.void : notifyParentActivity(input, context, status, output);
+  return context === undefined ? Effect74.void : notifyParentActivity(input, context, status, output);
 };
 var terminalOutput = (execution) => {
   const output = execution.metadata?.model_output;
@@ -14351,12 +15844,12 @@ var terminalOutput = (execution) => {
 };
 var missingWait = (waitId) => new ExecutionWorkflowFailed({ message: `Wait not found: ${waitId}` });
 var stillOpen = (waitId) => new ExecutionWorkflowFailed({ message: `Wait remained open after wake: ${waitId}` });
-var resolveWaitState = Effect73.fn("ExecutionWorkflow.resolveWaitState")(function* (input, repository) {
+var resolveWaitState = Effect74.fn("ExecutionWorkflow.resolveWaitState")(function* (input, repository) {
   if (input.wait_id === undefined)
     return;
   const before = yield* loadWait(ActivityNames.loadWaitBeforeSleep(input.wait_id), input.wait_id);
   if (before === undefined)
-    return yield* Effect73.fail(missingWait(input.wait_id));
+    return yield* Effect74.fail(missingWait(input.wait_id));
   const beforeTerminal = terminalWaitState(before);
   if (beforeTerminal !== undefined)
     return beforeTerminal;
@@ -14366,10 +15859,10 @@ var resolveWaitState = Effect73.fn("ExecutionWorkflow.resolveWaitState")(functio
   yield* resumeWorkspace(input, input.wait_id);
   const after = yield* loadWait(ActivityNames.loadWaitAfterWake(input.wait_id), input.wait_id);
   if (after === undefined)
-    return yield* Effect73.fail(missingWait(input.wait_id));
+    return yield* Effect74.fail(missingWait(input.wait_id));
   const afterTerminal = terminalWaitState(after);
   if (afterTerminal === undefined)
-    return yield* Effect73.fail(stillOpen(input.wait_id));
+    return yield* Effect74.fail(stillOpen(input.wait_id));
   return afterTerminal;
 });
 var waitIdFromExecution = (execution) => {
@@ -14380,7 +15873,7 @@ var pendingToolCallFromExecution = (execution) => {
   const pending = execution.metadata?.pending_tool_call;
   return Schema69.decodeUnknownOption(exports_tool_schema.Call)(pending).pipe(Option26.getOrUndefined);
 };
-var finishCancelledWait = Effect73.fn("ExecutionWorkflow.finishCancelledWait")(function* (startInput, turn, waitId) {
+var finishCancelledWait = Effect74.fn("ExecutionWorkflow.finishCancelledWait")(function* (startInput, turn, waitId) {
   const cancelled = yield* cancelExecution(startInput, turn, "wait cancelled");
   yield* releaseWorkspace(startInput);
   yield* notifyParent(startInput, "cancelled", []);
@@ -14403,7 +15896,7 @@ var continueAsNew = (startInput, turn, waitId, pendingToolCall) => Activity.make
     workflow_generation: workflowGenerationForStart(startInput) + 1
   })
 });
-var runWorkflow = Effect73.fn("ExecutionWorkflow.run")(function* (input) {
+var runWorkflow = Effect74.fn("ExecutionWorkflow.run")(function* (input) {
   const repository = yield* exports_execution_repository.Service;
   const startInput = yield* resolveStartInput(input);
   const generation = workflowGenerationForStart(startInput);
@@ -14420,7 +15913,7 @@ var runWorkflow = Effect73.fn("ExecutionWorkflow.run")(function* (input) {
       ...cancelled.metadata === undefined ? {} : { metadata: cancelled.metadata }
     };
   }
-  return yield* Effect73.gen(function* () {
+  return yield* Effect74.gen(function* () {
     if (generation === 0)
       yield* ensureWorkspace(startInput);
     let activeWaitId = startInput.wait_id;
@@ -14451,13 +15944,13 @@ var runWorkflow = Effect73.fn("ExecutionWorkflow.run")(function* (input) {
       if (execution.status !== "waiting")
         break;
       if (turn >= maxWaitTurns)
-        return yield* Effect73.fail(new ExecutionWorkflowFailed({ message: "Agent wait turn limit exceeded" }));
+        return yield* Effect74.fail(new ExecutionWorkflowFailed({ message: "Agent wait turn limit exceeded" }));
       const waitId = waitIdFromExecution(execution);
       if (waitId === undefined)
-        return yield* Effect73.fail(new ExecutionWorkflowFailed({ message: "Waiting execution missing wait id" }));
+        return yield* Effect74.fail(new ExecutionWorkflowFailed({ message: "Waiting execution missing wait id" }));
       pendingToolCall = pendingToolCallFromExecution(execution);
       if (pendingToolCall === undefined) {
-        return yield* Effect73.fail(new ExecutionWorkflowFailed({ message: "Waiting execution missing pending tool call" }));
+        return yield* Effect74.fail(new ExecutionWorkflowFailed({ message: "Waiting execution missing pending tool call" }));
       }
       activeWaitId = waitId;
       waitState = yield* resolveWaitState({ ...startInput, wait_id: waitId }, repository);
@@ -14478,7 +15971,7 @@ var runWorkflow = Effect73.fn("ExecutionWorkflow.run")(function* (input) {
       ...waitState === undefined ? {} : { wait_state: waitState },
       ...execution.metadata === undefined ? {} : { metadata: execution.metadata }
     };
-  }).pipe(Effect73.catch((error) => failWorkspace(startInput, error).pipe(Effect73.flatMap(() => notifyParent(startInput, "failed", [])), Effect73.flatMap(() => Effect73.fail(error)))));
+  }).pipe(Effect74.catch((error) => failWorkspace(startInput, error).pipe(Effect74.flatMap(() => notifyParent(startInput, "failed", [])), Effect74.flatMap(() => Effect74.fail(error)))));
 });
 var waitingResult = (input) => ({
   execution_id: input.execution_id,
@@ -14486,69 +15979,36 @@ var waitingResult = (input) => ({
   ...input.wait_id === undefined ? {} : { wait_id: input.wait_id },
   metadata: input.wait_id === undefined ? {} : { wait_id: input.wait_id, wait_state: "open" }
 });
-var awaitStartResult = Effect73.fn("ExecutionWorkflow.awaitStartResult")(function* (input, workflowExecutionId) {
-  const result = yield* StartExecutionWorkflow.poll(workflowExecutionId).pipe(Effect73.tap((pollResult) => Option26.isSome(pollResult) ? Effect73.void : Effect73.yieldNow), Effect73.repeat({ times: 31, until: Option26.isSome }));
+var awaitStartResult = Effect74.fn("ExecutionWorkflow.awaitStartResult")(function* (input, workflowExecutionId) {
+  const result = yield* StartExecutionWorkflow.poll(workflowExecutionId).pipe(Effect74.tap((pollResult) => Option26.isSome(pollResult) ? Effect74.void : Effect74.yieldNow), Effect74.repeat({ times: 31, until: Option26.isSome }));
   if (Option26.isSome(result)) {
     if (result.value._tag === "Suspended")
       return waitingResult(input);
     if (Exit2.isSuccess(result.value.exit))
       return result.value.exit.value;
-    return yield* Effect73.fail(new ExecutionWorkflowFailed({ message: "Execution workflow failed" }));
+    return yield* Effect74.fail(new ExecutionWorkflowFailed({ message: "Execution workflow failed" }));
   }
   return waitingResult(input);
 });
-var layer48 = StartExecutionWorkflow.toLayer(runWorkflow);
+var layer49 = StartExecutionWorkflow.toLayer(runWorkflow);
 var start = (input, options) => StartExecutionWorkflow.execute(input, options);
-var startRequest = Effect73.fn("ExecutionWorkflow.startRequest")(function* (input) {
+var startRequest = Effect74.fn("ExecutionWorkflow.startRequest")(function* (input) {
   if (input.wait_id === undefined)
     return yield* start(input);
   const workflowExecutionId = yield* start(input, { discard: true });
   return yield* awaitStartResult(input, workflowExecutionId);
 });
-var cancelRequest = Effect73.fn("ExecutionWorkflow.cancelRequest")(function* (input) {
-  const repository = yield* exports_execution_repository.Service;
-  const record2 = yield* repository.get(input.execution_id).pipe(Effect73.mapError(mapRepositoryError11));
-  if (record2 === undefined) {
-    return yield* Effect73.fail(new ExecutionWorkflowFailed({ message: `Execution not found: ${input.execution_id}` }));
-  }
-  if (terminalExecutionStatuses.has(record2.status)) {
-    return { execution_id: record2.id, status: record2.status };
-  }
-  yield* cancelOpenChildren(record2.id, input.cancelled_at);
-  if (record2.status === "waiting") {
-    const waitId = waitIdFromRecord(record2);
-    if (waitId === undefined) {
-      return yield* Effect73.fail(new ExecutionWorkflowFailed({ message: `Waiting execution missing wait id: ${record2.id}` }));
-    }
-    const eventLog = yield* Service24;
-    const eventSequence = yield* nextEventSequence4(eventLog, record2.id);
-    const result = yield* cancel2({
-      waitId,
-      cancelledAt: input.cancelled_at,
-      eventSequence,
-      ...input.reason === undefined ? {} : { metadata: { reason: input.reason } }
-    }).pipe(Effect73.mapError(mapWaitError2));
-    if (result.transitioned) {
-      yield* signalWait({
-        workflow_execution_id: yield* workflowExecutionIdForExecution(record2.id, workflowGenerationFromRecord(record2)),
-        wait_id: waitId,
-        state: "cancelled",
-        signaled_at: input.cancelled_at
-      });
-    }
-    return { execution_id: record2.id, status: "cancelled" };
+var dispatchRequest = Effect74.fn("ExecutionWorkflow.dispatchRequest")(function* (input) {
+  yield* start(input, { discard: true });
+});
+var cancelRequest = Effect74.fn("ExecutionWorkflow.cancelRequest")(function* (input) {
+  const prepared = yield* prepareCancellation(input);
+  if (prepared.terminalNoop) {
+    return { execution_id: prepared.record.id, status: prepared.status };
   }
-  yield* repository.transition({
-    id: record2.id,
-    status: record2.status,
-    updatedAt: input.cancelled_at,
-    metadata: {
-      ...record2.metadata,
-      cancellation_requested: true,
-      ...input.reason === undefined ? {} : { cancellation_reason: input.reason }
-    }
-  }).pipe(Effect73.mapError(mapRepositoryError11));
-  return { execution_id: record2.id, status: record2.status };
+  yield* signalPreparedCancellation(prepared, input.cancelled_at);
+  yield* cancelOpenChildren(prepared.record.id, input.cancelled_at);
+  return { execution_id: prepared.record.id, status: prepared.status };
 });
 var poll = (executionId) => StartExecutionWorkflow.poll(executionId);
 var resume3 = (executionId) => StartExecutionWorkflow.resume(executionId);
@@ -14562,12 +16022,12 @@ var workflowExecutionIdForExecution = (executionId, workflowGeneration = 0) => S
   completed_at: 0,
   workflow_generation: workflowGeneration
 });
-var activeWorkflowExecutionIdForExecution = Effect73.fn("ExecutionWorkflow.activeWorkflowExecutionIdForExecution")(function* (executionId) {
+var activeWorkflowExecutionIdForExecution = Effect74.fn("ExecutionWorkflow.activeWorkflowExecutionIdForExecution")(function* (executionId) {
   const repository = yield* exports_execution_repository.Service;
-  const record2 = yield* repository.get(executionId).pipe(Effect73.mapError(mapRepositoryError11));
+  const record2 = yield* repository.get(executionId).pipe(Effect74.mapError(mapRepositoryError11));
   return yield* workflowExecutionIdForExecution(executionId, record2 === undefined ? 0 : workflowGenerationFromRecord(record2));
 });
-var signalWait = Effect73.fn("ExecutionWorkflow.signalWait")(function* (input) {
+var signalWait = Effect74.fn("ExecutionWorkflow.signalWait")(function* (input) {
   const deferred = waitSignal(input.wait_id);
   const token = DurableDeferred.tokenFromExecutionId(deferred, {
     workflow: StartExecutionWorkflow,
@@ -14595,14 +16055,25 @@ var SignalWait = Rpc.make("signalWait", {
   success: Schema70.Void,
   error: ExecutionWorkflowFailed
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
+var Dispatch = Rpc.make("dispatch", {
+  payload: StartInput,
+  success: Schema70.Void,
+  error: ExecutionWorkflowFailed
+}).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
 var Cancel = Rpc.make("cancel", {
   payload: CancelExecutionInput,
   success: CancelExecutionResult,
   error: ExecutionWorkflowFailed
 }).annotate(ClusterSchema.Persisted, true).annotate(ClusterSchema.Uninterruptible, "server");
-var entity = Entity.make("Relay/Execution", [Start, SignalWait, Cancel]).annotate(ClusterSchema.ShardGroup, () => "execution");
-var layer49 = entity.toLayer(entity.of({
+var entity = Entity.make("Relay/Execution", [
+  Start,
+  Dispatch,
+  SignalWait,
+  Cancel
+]).annotate(ClusterSchema.ShardGroup, () => "execution");
+var layer50 = entity.toLayer(entity.of({
   start: (request) => startRequest(request.payload),
+  dispatch: (request) => dispatchRequest(request.payload),
   signalWait: (request) => signalWait(request.payload),
   cancel: (request) => cancelRequest(request.payload)
 }), { concurrency: "unbounded" });
@@ -14612,15 +16083,15 @@ var exports_envelope_service = {};
 __export(exports_envelope_service, {
   testLayer: () => testLayer49,
   send: () => send2,
-  memoryLayer: () => memoryLayer33,
-  layer: () => layer50,
-  Service: () => Service47,
+  memoryLayer: () => memoryLayer34,
+  layer: () => layer51,
+  Service: () => Service48,
   EnvelopeServiceError: () => EnvelopeServiceError,
   EnvelopeRouteUnavailable: () => EnvelopeRouteUnavailable,
   EnvelopeRouteDeferred: () => EnvelopeRouteDeferred,
   EnvelopeAddressNotFound: () => EnvelopeAddressNotFound
 });
-import { Context as Context60, Effect as Effect74, Layer as Layer67, Schema as Schema71 } from "effect";
+import { Context as Context61, Effect as Effect75, Layer as Layer68, Schema as Schema71 } from "effect";
 class EnvelopeAddressNotFound extends Schema71.TaggedErrorClass()("EnvelopeAddressNotFound", {
   address_id: exports_ids_schema.AddressId
 }) {
@@ -14643,7 +16114,7 @@ class EnvelopeServiceError extends Schema71.TaggedErrorClass()("EnvelopeServiceE
 }) {
 }
 
-class Service47 extends Context60.Service()("@relayfx/runtime/EnvelopeService") {
+class Service48 extends Context61.Service()("@relayfx/runtime/EnvelopeService") {
 }
 var mapAddressBookError2 = (error) => {
   if (error._tag === "AddressNotFound")
@@ -14727,20 +16198,20 @@ var readyEvent = (input, ready) => ({
   },
   created_at: input.createdAt + 2
 });
-var layer50 = Layer67.effect(Service47, Effect74.gen(function* () {
+var layer51 = Layer68.effect(Service48, Effect75.gen(function* () {
   const addressBook = yield* Service23;
   const repository = yield* exports_envelope_repository.Service;
   const eventLog = yield* Service24;
-  return Service47.of({
-    send: Effect74.fn("EnvelopeService.send")(function* (input) {
-      yield* Effect74.annotateCurrentSpan({
+  return Service48.of({
+    send: Effect75.fn("EnvelopeService.send")(function* (input) {
+      yield* Effect75.annotateCurrentSpan({
         "relay.envelope.id": input.envelopeId,
         "relay.execution.id": input.executionId,
         "relay.address.from": input.input.from,
         "relay.address.to": input.input.to
       });
-      const route2 = yield* addressBook.resolve(input.input.to).pipe(Effect74.mapError(mapAddressBookError2));
-      yield* Effect74.annotateCurrentSpan({
+      const route2 = yield* addressBook.resolve(input.input.to).pipe(Effect75.mapError(mapAddressBookError2));
+      yield* Effect75.annotateCurrentSpan({
         "relay.route.kind": route2.kind,
         "relay.route.key": route2.route_key
       });
@@ -14751,21 +16222,21 @@ var layer50 = Layer67.effect(Service47, Effect74.gen(function* () {
         envelope,
         ...waitId === undefined ? {} : { waitId },
         ...ready === undefined ? {} : { ready }
-      }).pipe(Effect74.mapError(mapRepositoryError12));
-      yield* eventLog.append(acceptedEvent2(input)).pipe(Effect74.mapError(mapEventLogError7));
-      yield* eventLog.append(routedEvent(input, route2)).pipe(Effect74.mapError(mapEventLogError7));
+      }).pipe(Effect75.mapError(mapRepositoryError12));
+      yield* eventLog.append(acceptedEvent2(input)).pipe(Effect75.mapError(mapEventLogError7));
+      yield* eventLog.append(routedEvent(input, route2)).pipe(Effect75.mapError(mapEventLogError7));
       if (ready !== undefined) {
-        yield* eventLog.append(readyEvent(input, ready)).pipe(Effect74.mapError(mapEventLogError7));
+        yield* eventLog.append(readyEvent(input, ready)).pipe(Effect75.mapError(mapEventLogError7));
       }
       yield* recordEnvelopeSent(route2.kind);
       return accepted2;
     })
   });
 }));
-var memoryLayer33 = (routes = []) => layer50.pipe(Layer67.provide(memoryLayer20(routes)), Layer67.provide(exports_envelope_repository.memoryLayer), Layer67.provide(memoryLayer21));
-var testLayer49 = (implementation) => Layer67.succeed(Service47, Service47.of(implementation));
-var send2 = Effect74.fn("EnvelopeService.send.call")(function* (input) {
-  const service = yield* Service47;
+var memoryLayer34 = (routes = []) => layer51.pipe(Layer68.provide(memoryLayer20(routes)), Layer68.provide(exports_envelope_repository.memoryLayer), Layer68.provide(memoryLayer21));
+var testLayer49 = (implementation) => Layer68.succeed(Service48, Service48.of(implementation));
+var send2 = Effect75.fn("EnvelopeService.send.call")(function* (input) {
+  const service = yield* Service48;
   return yield* service.send(input);
 });
 // ../runtime/src/runner/runner-runtime-service.ts
@@ -14784,20 +16255,20 @@ __export(exports_runner_runtime_service, {
   layerWithLanguageModelService: () => layerWithLanguageModelService,
   layerWithClient: () => layerWithClient,
   layerWith: () => layerWith,
-  layer: () => layer52,
+  layer: () => layer53,
   clusterShardingConfigLayer: () => clusterShardingConfigLayer,
   clusterLayerHttpClientOnly: () => clusterLayerHttpClientOnly,
   clusterLayerHttp: () => clusterLayerHttp,
   check: () => check2,
   assertRunnerAddressAvailable: () => assertRunnerAddressAvailable,
   assertClusterConfig: () => assertClusterConfig,
-  Service: () => Service49,
+  Service: () => Service50,
   RunnerRuntimeError: () => RunnerRuntimeError,
   ReadinessStatus: () => ReadinessStatus,
   DatabaseMode: () => DatabaseMode,
   ClusterConfigMismatch: () => ClusterConfigMismatch
 });
-import { Config as Config5, Context as Context62, Crypto as Crypto4, Duration as Duration5, Effect as Effect77, Layer as Layer69, Option as Option27, Schema as Schema73, Stream as Stream10 } from "effect";
+import { Config as Config5, Context as Context63, Crypto as Crypto4, Duration as Duration5, Effect as Effect78, Layer as Layer70, Option as Option27, Schema as Schema73, Stream as Stream10 } from "effect";
 import {
   ClusterWorkflowEngine,
   HttpRunner,
@@ -14812,7 +16283,7 @@ import {
   SqlRunnerStorage
 } from "effect/unstable/cluster";
 import { FetchHttpClient } from "effect/unstable/http";
-import { SqlClient as SqlClient22 } from "effect/unstable/sql/SqlClient";
+import { SqlClient as SqlClient23 } from "effect/unstable/sql/SqlClient";
 import { RpcSerialization } from "effect/unstable/rpc";
 import { WorkflowEngine } from "effect/unstable/workflow";
 import { LanguageModel as LanguageModel7 } from "effect/unstable/ai";
@@ -14826,24 +16297,24 @@ __export(exports_scheduler_service, {
   runOnce: () => runOnce2,
   pollIntervalMillisConfig: () => pollIntervalMillisConfig,
   parseCron: () => parseCron,
-  memoryLayer: () => memoryLayer34,
-  make: () => make14,
-  layer: () => layer51,
+  memoryLayer: () => memoryLayer35,
+  make: () => make15,
+  layer: () => layer52,
   enabledConfig: () => enabledConfig,
   claimTtlMillisConfig: () => claimTtlMillisConfig,
-  Service: () => Service48,
+  Service: () => Service49,
   SchedulerError: () => SchedulerError,
   ScheduleCronInvalid: () => ScheduleCronInvalid
 });
-import { Clock as Clock10, Config as Config4, Context as Context61, Cron, Duration as Duration4, Effect as Effect76, Layer as Layer68, Random, Result as Result3, Schema as Schema72 } from "effect";
+import { Clock as Clock10, Config as Config4, Context as Context62, Cron, Duration as Duration4, Effect as Effect77, Layer as Layer69, Random, Result as Result3, Schema as Schema72 } from "effect";
 
 // ../runtime/src/wait/wait-signal.ts
 var exports_wait_signal = {};
 __export(exports_wait_signal, {
   signalWorkflowWait: () => signalWorkflowWait
 });
-import { Effect as Effect75 } from "effect";
-var signalWorkflowWait = Effect75.fn("WaitSignal.signalWorkflowWait")(function* (input) {
+import { Effect as Effect76 } from "effect";
+var signalWorkflowWait = Effect76.fn("WaitSignal.signalWorkflowWait")(function* (input) {
   const workflowExecutionId2 = yield* activeWorkflowExecutionIdForExecution(input.executionId);
   const client3 = input.makeExecutionClient(input.executionId);
   yield* client3.signalWait({
@@ -14866,7 +16337,7 @@ class ScheduleCronInvalid extends Schema72.TaggedErrorClass()("ScheduleCronInval
 }) {
 }
 
-class Service48 extends Context61.Service()("@relayfx/runtime/SchedulerService") {
+class Service49 extends Context62.Service()("@relayfx/runtime/SchedulerService") {
 }
 var pollIntervalMillisConfig = Config4.int("RELAY_SCHEDULER_POLL_INTERVAL_MILLIS").pipe(Config4.withDefault(1000));
 var claimTtlMillisConfig = Config4.int("RELAY_SCHEDULER_CLAIM_TTL_MILLIS").pipe(Config4.withDefault(30000));
@@ -14875,7 +16346,7 @@ var processWorkerId = `scheduler:${globalThis.crypto.randomUUID()}`;
 var workerIdConfig = Config4.string("RELAY_SCHEDULER_WORKER_ID").pipe(Config4.withDefault(processWorkerId));
 var parseCron = (cronExpr) => {
   const parsed = Cron.parse(cronExpr);
-  return Result3.isFailure(parsed) ? Effect76.fail(new ScheduleCronInvalid({ cron_expr: cronExpr, message: String(parsed.failure) })) : Effect76.succeed(parsed.success);
+  return Result3.isFailure(parsed) ? Effect77.fail(new ScheduleCronInvalid({ cron_expr: cronExpr, message: String(parsed.failure) })) : Effect77.succeed(parsed.success);
 };
 var startIdempotencyKey = (schedule) => `schedule:${schedule.id}:${schedule.next_run_at}`;
 var errorMessage3 = (error) => {
@@ -14891,11 +16362,11 @@ var dispatchMetadata = (schedule) => ({
   source: "schedule",
   schedule_id: schedule.id
 });
-var nextEventSequence5 = Effect76.fn("SchedulerService.nextEventSequence")(function* (eventLog, executionId) {
-  const max = yield* eventLog.maxSequence(executionId).pipe(Effect76.mapError(toSchedulerError));
+var nextEventSequence5 = Effect77.fn("SchedulerService.nextEventSequence")(function* (eventLog, executionId) {
+  const max = yield* eventLog.maxSequence(executionId).pipe(Effect77.mapError(toSchedulerError));
   return max === undefined ? 0 : max + 1;
 });
-var make14 = Effect76.gen(function* () {
+var make15 = Effect77.gen(function* () {
   const schedules = yield* exports_schedule_repository.Service;
   const waits = yield* Service25;
   const eventLog = yield* Service24;
@@ -14904,10 +16375,10 @@ var make14 = Effect76.gen(function* () {
   const workerId = yield* workerIdConfig;
   const claimTtlMillis = yield* claimTtlMillisConfig;
   const pollIntervalMillis = yield* pollIntervalMillisConfig;
-  const dispatchStartExecution = (schedule, now) => Effect76.gen(function* () {
+  const dispatchStartExecution = (schedule, now) => Effect77.gen(function* () {
     const addressId = schedule.address_id;
     if (addressId === undefined) {
-      return yield* Effect76.fail(new SchedulerError({ message: `Schedule ${schedule.id} is missing address_id` }));
+      return yield* Effect77.fail(new SchedulerError({ message: `Schedule ${schedule.id} is missing address_id` }));
     }
     const idempotencyKey = startIdempotencyKey(schedule);
     const executionId = exports_ids_schema.ExecutionId.make(`execution:${idempotencyKey}`);
@@ -14924,19 +16395,19 @@ var make14 = Effect76.gen(function* () {
         ...dispatchMetadata(schedule),
         idempotency_key: idempotencyKey
       }
-    }).pipe(Effect76.mapError(toSchedulerError));
-  }).pipe(Effect76.withSpan("SchedulerService.dispatchStartExecution"));
-  const dispatchWaitTransition = (schedule, now) => Effect76.gen(function* () {
+    }).pipe(Effect77.mapError(toSchedulerError));
+  }).pipe(Effect77.withSpan("SchedulerService.dispatchStartExecution"));
+  const dispatchWaitTransition = (schedule, now) => Effect77.gen(function* () {
     const waitId = schedule.wait_id;
     if (waitId === undefined) {
-      return yield* Effect76.fail(new SchedulerError({ message: `Schedule ${schedule.id} is missing wait_id` }));
+      return yield* Effect77.fail(new SchedulerError({ message: `Schedule ${schedule.id} is missing wait_id` }));
     }
-    const wait = yield* waits.get(waitId).pipe(Effect76.mapError(toSchedulerError));
+    const wait = yield* waits.get(waitId).pipe(Effect77.mapError(toSchedulerError));
     if (wait === undefined || wait.state !== "open")
       return;
     const eventSequence = yield* nextEventSequence5(eventLog, wait.executionId);
     const metadata11 = dispatchMetadata(schedule);
-    const result = schedule.target_kind === "wake-wait" ? yield* waits.wake({ waitId, resolvedAt: now, eventSequence, metadata: metadata11 }).pipe(Effect76.mapError(toSchedulerError)) : yield* waits.timeout({ waitId, timedOutAt: now, eventSequence, metadata: metadata11 }).pipe(Effect76.mapError(toSchedulerError));
+    const result = schedule.target_kind === "wake-wait" ? yield* waits.wake({ waitId, resolvedAt: now, eventSequence, metadata: metadata11 }).pipe(Effect77.mapError(toSchedulerError)) : yield* waits.timeout({ waitId, timedOutAt: now, eventSequence, metadata: metadata11 }).pipe(Effect77.mapError(toSchedulerError));
     if (!result.transitioned)
       return;
     yield* signalWorkflowWait({
@@ -14945,19 +16416,19 @@ var make14 = Effect76.gen(function* () {
       waitId: result.wait.id,
       state: schedule.target_kind === "wake-wait" ? "resolved" : "timed_out",
       signaledAt: now
-    }).pipe(Effect76.provideService(exports_execution_repository.Service, executionRepository), Effect76.mapError(toSchedulerError));
-  }).pipe(Effect76.withSpan("SchedulerService.dispatchWaitTransition"));
+    }).pipe(Effect77.provideService(exports_execution_repository.Service, executionRepository), Effect77.mapError(toSchedulerError));
+  }).pipe(Effect77.withSpan("SchedulerService.dispatchWaitTransition"));
   const dispatch = (schedule, now) => schedule.target_kind === "start-execution" ? dispatchStartExecution(schedule, now) : dispatchWaitTransition(schedule, now);
-  const nextCronRunAt = (schedule, now) => Effect76.gen(function* () {
+  const nextCronRunAt = (schedule, now) => Effect77.gen(function* () {
     if (schedule.kind !== "cron")
       return;
     if (schedule.cron_expr === undefined) {
-      return yield* Effect76.fail(new SchedulerError({ message: `Schedule ${schedule.id} is missing cron_expr` }));
+      return yield* Effect77.fail(new SchedulerError({ message: `Schedule ${schedule.id} is missing cron_expr` }));
     }
-    const cron = yield* parseCron(schedule.cron_expr).pipe(Effect76.mapError(toSchedulerError));
+    const cron = yield* parseCron(schedule.cron_expr).pipe(Effect77.mapError(toSchedulerError));
     return Cron.next(cron, new Date(now)).getTime();
-  }).pipe(Effect76.withSpan("SchedulerService.nextCronRunAt"));
-  const settle = (schedule, now) => dispatch(schedule, now).pipe(Effect76.flatMap(() => nextCronRunAt(schedule, now)), Effect76.matchEffect({
+  }).pipe(Effect77.withSpan("SchedulerService.nextCronRunAt"));
+  const settle = (schedule, now) => dispatch(schedule, now).pipe(Effect77.flatMap(() => nextCronRunAt(schedule, now)), Effect77.matchEffect({
     onSuccess: (nextRunAt) => schedules.ack({
       id: schedule.id,
       workerId,
@@ -14970,45 +16441,45 @@ var make14 = Effect76.gen(function* () {
       nextAvailableAt: now + pollIntervalMillis,
       error: error.message
     })
-  }), Effect76.catchTag("ScheduleClaimMismatch", () => Effect76.void), Effect76.mapError(toSchedulerError), Effect76.withSpan("SchedulerService.settle"));
-  const runOnce2 = Effect76.gen(function* () {
+  }), Effect77.catchTag("ScheduleClaimMismatch", () => Effect77.void), Effect77.mapError(toSchedulerError), Effect77.withSpan("SchedulerService.settle"));
+  const runOnce2 = Effect77.gen(function* () {
     let dispatched = 0;
     while (true) {
       const now = yield* Clock10.currentTimeMillis;
-      const claimed = yield* schedules.claimDue({ workerId, now, claimExpiresAt: now + claimTtlMillis }).pipe(Effect76.mapError(toSchedulerError));
+      const claimed = yield* schedules.claimDue({ workerId, now, claimExpiresAt: now + claimTtlMillis }).pipe(Effect77.mapError(toSchedulerError));
       if (claimed === undefined)
         return dispatched;
       yield* settle(claimed, now);
       dispatched += 1;
     }
-  }).pipe(Effect76.withSpan("SchedulerService.runOnce"));
-  return Service48.of({ runOnce: runOnce2 });
+  }).pipe(Effect77.withSpan("SchedulerService.runOnce"));
+  return Service49.of({ runOnce: runOnce2 });
 });
-var jitteredSleep = (pollIntervalMillis) => Effect76.gen(function* () {
+var jitteredSleep = (pollIntervalMillis) => Effect77.gen(function* () {
   const jitter = yield* Random.nextBetween(0.8, 1.2);
-  yield* Effect76.sleep(Duration4.millis(pollIntervalMillis * jitter));
+  yield* Effect77.sleep(Duration4.millis(pollIntervalMillis * jitter));
 });
-var pollLoop = (service, pollIntervalMillis) => Effect76.gen(function* () {
+var pollLoop = (service, pollIntervalMillis) => Effect77.gen(function* () {
   while (true) {
-    const dispatched = yield* service.runOnce.pipe(Effect76.catch((error) => Effect76.logWarning("relay scheduler poll failed", { message: error.message }).pipe(Effect76.as(0))));
+    const dispatched = yield* service.runOnce.pipe(Effect77.catch((error) => Effect77.logWarning("relay scheduler poll failed", { message: error.message }).pipe(Effect77.as(0))));
     if (dispatched === 0) {
       yield* jitteredSleep(pollIntervalMillis);
     }
   }
 });
-var layer51 = Layer68.effect(Service48, Effect76.gen(function* () {
-  const service = yield* make14;
+var layer52 = Layer69.effect(Service49, Effect77.gen(function* () {
+  const service = yield* make15;
   const enabled2 = yield* enabledConfig;
   const pollIntervalMillis = yield* pollIntervalMillisConfig;
   if (enabled2) {
-    yield* Effect76.forkScoped(pollLoop(service, pollIntervalMillis));
+    yield* Effect77.forkScoped(pollLoop(service, pollIntervalMillis));
   }
   return service;
 }));
-var memoryLayer34 = Layer68.effect(Service48, make14);
-var testLayer50 = (implementation) => Layer68.succeed(Service48, Service48.of(implementation));
-var runOnce2 = Effect76.fn("SchedulerService.runOnce.call")(function* () {
-  const service = yield* Service48;
+var memoryLayer35 = Layer69.effect(Service49, make15);
+var testLayer50 = (implementation) => Layer69.succeed(Service49, Service49.of(implementation));
+var runOnce2 = Effect77.fn("SchedulerService.runOnce.call")(function* () {
+  const service = yield* Service49;
   return yield* service.runOnce;
 });
 
@@ -15035,20 +16506,20 @@ class ClusterConfigMismatch extends Schema73.TaggedErrorClass()("ClusterConfigMi
 }) {
 }
 
-class Service49 extends Context62.Service()("@relayfx/runtime/RunnerRuntime") {
+class Service50 extends Context63.Service()("@relayfx/runtime/RunnerRuntime") {
 }
 var shardingConfig = {
   availableShardGroups: ["default", "execution"],
   assignedShardGroups: ["default", "execution"]
 };
-var memoryClusterLayer = Sharding.layer.pipe(Layer69.provideMerge(Runners.layerNoop), Layer69.provideMerge(MessageStorage.layerMemory), Layer69.provide([RunnerStorage.layerMemory, RunnerHealth.layerNoop]), Layer69.provideMerge(ShardingConfig2.layer(shardingConfig)));
+var memoryClusterLayer = Sharding.layer.pipe(Layer70.provideMerge(Runners.layerNoop), Layer70.provideMerge(MessageStorage.layerMemory), Layer70.provide([RunnerStorage.layerMemory, RunnerHealth.layerNoop]), Layer70.provideMerge(ShardingConfig2.layer(shardingConfig)));
 var clusterHost = Config5.string("RELAY_CLUSTER_HOST").pipe(Config5.withDefault("localhost"));
 var clusterPort = Config5.int("RELAY_CLUSTER_PORT").pipe(Config5.withDefault(34431));
 var clusterShardsPerGroup = Config5.int("RELAY_CLUSTER_SHARDS_PER_GROUP").pipe(Config5.withDefault(300));
 var clusterShardGroups = Config5.schema(Config5.Array(Schema73.String), "RELAY_CLUSTER_SHARD_GROUPS").pipe(Config5.withDefault(["default", "execution"]));
 var runnerAddressKey = (address) => `${address.host}:${address.port}`;
 var runnerAddressEquals = (left, right) => left.host === right.host && left.port === right.port;
-var shardingConfigFromEnv = () => Layer69.effect(ShardingConfig2.ShardingConfig, Effect77.gen(function* () {
+var shardingConfigFromEnv = () => Layer70.effect(ShardingConfig2.ShardingConfig, Effect78.gen(function* () {
   const host = yield* clusterHost;
   const port = yield* clusterPort;
   const shardsPerGroup = yield* clusterShardsPerGroup;
@@ -15073,14 +16544,14 @@ var clusterShardingConfigLayer = (options) => ShardingConfig2.layer({
   ...options.shardLockExpiration !== undefined && { shardLockExpiration: options.shardLockExpiration }
 });
 var runnerAddressPreflightTimeout = Duration5.seconds(5);
-var assertRunnerAddressAvailable = Effect77.fn("RunnerRuntime.assertRunnerAddressAvailable")(function* (options = {}) {
+var assertRunnerAddressAvailable = Effect78.fn("RunnerRuntime.assertRunnerAddressAvailable")(function* (options = {}) {
   const config = yield* ShardingConfig2.ShardingConfig;
   if (Option27.isNone(config.runnerAddress)) {
     return;
   }
   const storage = yield* RunnerStorage.RunnerStorage;
   const localAddress = config.runnerAddress.value;
-  const runners = yield* storage.getRunners.pipe(Effect77.mapError((error) => new ClusterConfigMismatch({
+  const runners = yield* storage.getRunners.pipe(Effect78.mapError((error) => new ClusterConfigMismatch({
     field: "runnerAddress",
     expected: `${runnerAddressKey(localAddress)} available`,
     actual: `registry unavailable: ${String(error)}`
@@ -15088,7 +16559,7 @@ var assertRunnerAddressAvailable = Effect77.fn("RunnerRuntime.assertRunnerAddres
   const collision = runners.find(([runner, healthy]) => healthy && runnerAddressEquals(runner.address, localAddress));
   if (collision === undefined)
     return;
-  const reachable = options.isAddressReachable === undefined ? false : yield* options.isAddressReachable(collision[0].address).pipe(Effect77.timeoutOption(runnerAddressPreflightTimeout), Effect77.map(Option27.getOrElse(() => false)));
+  const reachable = options.isAddressReachable === undefined ? false : yield* options.isAddressReachable(collision[0].address).pipe(Effect78.timeoutOption(runnerAddressPreflightTimeout), Effect78.map(Option27.getOrElse(() => false)));
   if (reachable) {
     return yield* new ClusterConfigMismatch({
       field: "runnerAddress",
@@ -15097,14 +16568,14 @@ var assertRunnerAddressAvailable = Effect77.fn("RunnerRuntime.assertRunnerAddres
     });
   }
 });
-var runnerAddressPreflightHttpLayer = Layer69.effectDiscard(Effect77.gen(function* () {
+var runnerAddressPreflightHttpLayer = Layer70.effectDiscard(Effect78.gen(function* () {
   const runners = yield* Runners.Runners;
   yield* assertRunnerAddressAvailable({
-    isAddressReachable: (address) => runners.ping(address).pipe(Effect77.as(true), Effect77.catch(() => Effect77.succeed(false)))
+    isAddressReachable: (address) => runners.ping(address).pipe(Effect78.as(true), Effect78.catch(() => Effect78.succeed(false)))
   });
-})).pipe(Layer69.provide(Runners.layerRpc), Layer69.provide(HttpRunner.layerClientProtocolHttpDefault), Layer69.provide(RpcSerialization.layerNdjson), Layer69.provide(FetchHttpClient.layer));
-var sqlClusterLayer = Sharding.layer.pipe(Layer69.provideMerge(runnerAddressPreflightHttpLayer), Layer69.provideMerge(Runners.layerNoop), Layer69.provideMerge(SqlMessageStorage.layer), Layer69.provide([Layer69.orDie(SqlRunnerStorage.layer), RunnerHealth.layerNoop]), Layer69.provideMerge(shardingConfigFromEnv()));
-var clusterLayerHttp = (options) => HttpRunner.layerHttp.pipe(Layer69.provideMerge(runnerAddressPreflightHttpLayer), Layer69.provideMerge(SqlMessageStorage.layer), Layer69.provide([Layer69.orDie(SqlRunnerStorage.layer), RunnerHealth.layerNoop]), Layer69.provide(RpcSerialization.layerNdjson), Layer69.provide(FetchHttpClient.layer), Layer69.provideMerge(clusterShardingConfigLayer({
+})).pipe(Layer70.provide(Runners.layerRpc), Layer70.provide(HttpRunner.layerClientProtocolHttpDefault), Layer70.provide(RpcSerialization.layerNdjson), Layer70.provide(FetchHttpClient.layer));
+var sqlClusterLayer = Sharding.layer.pipe(Layer70.provideMerge(runnerAddressPreflightHttpLayer), Layer70.provideMerge(Runners.layerNoop), Layer70.provideMerge(SqlMessageStorage.layer), Layer70.provide([Layer70.orDie(SqlRunnerStorage.layer), RunnerHealth.layerNoop]), Layer70.provideMerge(shardingConfigFromEnv()));
+var clusterLayerHttp = (options) => HttpRunner.layerHttp.pipe(Layer70.provideMerge(runnerAddressPreflightHttpLayer), Layer70.provideMerge(SqlMessageStorage.layer), Layer70.provide([Layer70.orDie(SqlRunnerStorage.layer), RunnerHealth.layerNoop]), Layer70.provide(RpcSerialization.layerNdjson), Layer70.provide(FetchHttpClient.layer), Layer70.provideMerge(clusterShardingConfigLayer({
   runnerAddress: Option27.some(RunnerAddress.make(options.runnerHost, options.rpcPort)),
   assignedShardGroups: options.assignedShardGroups,
   availableShardGroups: options.availableShardGroups,
@@ -15113,7 +16584,7 @@ var clusterLayerHttp = (options) => HttpRunner.layerHttp.pipe(Layer69.provideMer
   shardLockExpiration: options.shardLockExpiration,
   shardLockDisableAdvisory: options.shardLockDisableAdvisory
 })));
-var clusterLayerHttpClientOnly = (options = {}) => HttpRunner.layerHttpClientOnly.pipe(Layer69.provideMerge(SqlMessageStorage.layer), Layer69.provide(Layer69.orDie(SqlRunnerStorage.layer)), Layer69.provide(RpcSerialization.layerNdjson), Layer69.provide(FetchHttpClient.layer), Layer69.provideMerge(clusterShardingConfigLayer({
+var clusterLayerHttpClientOnly = (options = {}) => HttpRunner.layerHttpClientOnly.pipe(Layer70.provideMerge(SqlMessageStorage.layer), Layer70.provide(Layer70.orDie(SqlRunnerStorage.layer)), Layer70.provide(RpcSerialization.layerNdjson), Layer70.provide(FetchHttpClient.layer), Layer70.provideMerge(clusterShardingConfigLayer({
   runnerAddress: Option27.none(),
   assignedShardGroups: [],
   availableShardGroups: options.availableShardGroups,
@@ -15122,7 +16593,7 @@ var clusterLayerHttpClientOnly = (options = {}) => HttpRunner.layerHttpClientOnl
   shardLockExpiration: options.shardLockExpiration,
   shardLockDisableAdvisory: options.shardLockDisableAdvisory
 })));
-var assertClusterConfig = Effect77.fn("RunnerRuntime.assertClusterConfig")(function* (expected) {
+var assertClusterConfig = Effect78.fn("RunnerRuntime.assertClusterConfig")(function* (expected) {
   const config = yield* ShardingConfig2.ShardingConfig;
   if (config.shardsPerGroup !== expected.shardsPerGroup) {
     return yield* new ClusterConfigMismatch({
@@ -15137,15 +16608,15 @@ var assertClusterConfig = Effect77.fn("RunnerRuntime.assertClusterConfig")(funct
     return yield* new ClusterConfigMismatch({ field: "availableShardGroups", expected: want, actual });
   }
 });
-var sqlRepositoryLayer = Layer69.mergeAll(exports_address_book_repository.layer, exports_agent_chat_repository.layer, exports_agent_definition_repository.layer, exports_child_execution_repository.layer, exports_cluster_registry_repository.layer, exports_compaction_repository.layer, exports_context_epoch_repository.layer, exports_execution_repository.layer, exports_envelope_repository.layer, exports_execution_event_repository.layerWithBus, exports_memory_repository.layer, exports_permission_rule_repository.layer, exports_schedule_repository.layer, exports_session_repository.layer, exports_skill_definition_repository.layer, exports_steering_repository.layer, exports_tool_call_repository.layer, exports_workspace_lease_repository.layer);
-var memoryRepositoryLayer = Layer69.mergeAll(exports_address_book_repository.memoryLayer, exports_agent_chat_repository.memoryLayer, exports_agent_definition_repository.memoryLayer, exports_child_execution_repository.memoryLayer, exports_cluster_registry_repository.memoryLayer, exports_compaction_repository.memoryLayer, exports_context_epoch_repository.memoryLayer, exports_execution_repository.memoryLayer, exports_envelope_repository.memoryLayer, exports_execution_event_repository.memoryLayer, exports_memory_repository.memoryLayer, exports_permission_rule_repository.memoryLayer, exports_schedule_repository.memoryLayer, exports_session_repository.memoryLayer, exports_skill_definition_repository.memoryLayer, exports_steering_repository.memoryLayer, exports_tool_call_repository.memoryLayer, exports_workspace_lease_repository.memoryLayer);
-var testCryptoLayer = Layer69.succeed(Crypto4.Crypto, Crypto4.make({
+var sqlRepositoryLayer = Layer70.mergeAll(exports_address_book_repository.layer, exports_agent_chat_repository.layer, exports_agent_definition_repository.layer, exports_child_execution_repository.layer, exports_cluster_registry_repository.layer, exports_compaction_repository.layer, exports_context_epoch_repository.layer, exports_execution_repository.layer, exports_envelope_repository.layer, exports_execution_event_repository.layerWithBus, exports_memory_repository.layer, exports_permission_rule_repository.layer, exports_schedule_repository.layer, exports_session_repository.layer, exports_skill_definition_repository.layer, exports_steering_repository.layer, exports_tool_call_repository.layer, exports_workspace_lease_repository.layer);
+var memoryRepositoryLayer = Layer70.mergeAll(exports_address_book_repository.memoryLayer, exports_agent_chat_repository.memoryLayer, exports_agent_definition_repository.memoryLayer, exports_child_execution_repository.memoryLayer, exports_cluster_registry_repository.memoryLayer, exports_compaction_repository.memoryLayer, exports_context_epoch_repository.memoryLayer, exports_execution_repository.memoryLayer, exports_envelope_repository.memoryLayer, exports_execution_event_repository.memoryLayer, exports_memory_repository.memoryLayer, exports_permission_rule_repository.memoryLayer, exports_schedule_repository.memoryLayer, exports_session_repository.memoryLayer, exports_skill_definition_repository.memoryLayer, exports_steering_repository.memoryLayer, exports_tool_call_repository.memoryLayer, exports_workspace_lease_repository.memoryLayer);
+var testCryptoLayer = Layer70.succeed(Crypto4.Crypto, Crypto4.make({
   randomBytes: (size) => new Uint8Array(size),
-  digest: (algorithm, data) => Effect77.promise(() => globalThis.crypto.subtle.digest(algorithm, data).then((buffer) => new Uint8Array(buffer)))
+  digest: (algorithm, data) => Effect78.promise(() => globalThis.crypto.subtle.digest(algorithm, data).then((buffer) => new Uint8Array(buffer)))
 }));
-var executionServiceLayer = layer46.pipe(Layer69.provideMerge(layer32));
-var addressResolutionLayerWith = (toolRuntimeLayer) => layer25.pipe(Layer69.provideMerge(layerFromRepository), Layer69.provideMerge(layer24.pipe(Layer69.provideMerge(toolRuntimeLayer))));
-var parentNotifierLayer = Layer69.effect(Service42, Effect77.gen(function* () {
+var executionServiceLayer = layer47.pipe(Layer70.provideMerge(layer33));
+var addressResolutionLayerWith = (toolRuntimeLayer) => layer25.pipe(Layer70.provideMerge(layerFromRepository), Layer70.provideMerge(layer24.pipe(Layer70.provideMerge(toolRuntimeLayer))));
+var parentNotifierLayer = Layer70.effect(Service42, Effect78.gen(function* () {
   const makeExecutionClient = yield* client2;
   const executionRepository = yield* exports_execution_repository.Service;
   return yield* make13({
@@ -15155,24 +16626,24 @@ var parentNotifierLayer = Layer69.effect(Service42, Effect77.gen(function* () {
       waitId: input.waitId,
       state: "resolved",
       signaledAt: input.signaledAt
-    }).pipe(Effect77.provideService(exports_execution_repository.Service, executionRepository))
+    }).pipe(Effect78.provideService(exports_execution_repository.Service, executionRepository))
   });
 }));
-var agentLoopLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer) => layer44.pipe(Layer69.provideMerge(toolRuntimeLayer), Layer69.provideMerge(layer32), Layer69.provideMerge(layer36()), Layer69.provideMerge(promptAssemblerLayer), Layer69.provideMerge(schemaRegistryLayer));
-var runtimeServicesLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer) => Layer69.mergeAll(addressResolutionLayerWith(toolRuntimeLayer), layer45, executionServiceLayer, agentLoopLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer), layer47, parentNotifierLayer).pipe(Layer69.provideMerge(layer22), Layer69.provideMerge(layerFromRepository2));
-var workflowLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer) => layer48.pipe(Layer69.provideMerge(runtimeServicesLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer)));
-var workflowAndEntityLayerWith = (toolRuntimeLayer, schedulerLayer, promptAssemblerLayer, schemaRegistryLayer) => Layer69.mergeAll(layer49, schedulerLayer).pipe(Layer69.provideMerge(workflowLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer)));
-var makeService2 = (database, checkDatabase) => Effect77.gen(function* () {
+var agentLoopLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer) => layer45.pipe(Layer70.provideMerge(toolRuntimeLayer), Layer70.provideMerge(layer33), Layer70.provideMerge(layer37()), Layer70.provideMerge(promptAssemblerLayer), Layer70.provideMerge(schemaRegistryLayer));
+var runtimeServicesLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer) => Layer70.mergeAll(addressResolutionLayerWith(toolRuntimeLayer), layer46, executionServiceLayer, agentLoopLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer), layer48, parentNotifierLayer, toolTransitionCoordinatorLayer).pipe(Layer70.provideMerge(layer22), Layer70.provideMerge(layerFromRepository2));
+var workflowLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer) => layer49.pipe(Layer70.provideMerge(runtimeServicesLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer)));
+var workflowAndEntityLayerWith = (toolRuntimeLayer, schedulerLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer) => Layer70.mergeAll(layer50, schedulerLayer).pipe(Layer70.provideMerge(workflowLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer)));
+var makeService2 = (database, checkDatabase) => Effect78.gen(function* () {
   const sharding = yield* Sharding.Sharding;
   const workflow = yield* WorkflowEngine.WorkflowEngine;
   const makeClient = yield* client2;
-  return Service49.of({
-    check: Effect77.fn("RunnerRuntime.check")(function* () {
-      yield* Effect77.annotateCurrentSpan("relay.database.mode", database);
+  return Service50.of({
+    check: Effect78.fn("RunnerRuntime.check")(function* () {
+      yield* Effect78.annotateCurrentSpan("relay.database.mode", database);
       yield* checkDatabase;
-      yield* Effect77.sync(() => sharding);
-      yield* Effect77.sync(() => workflow);
-      yield* Effect77.sync(() => makeClient);
+      yield* Effect78.sync(() => sharding);
+      yield* Effect78.sync(() => workflow);
+      yield* Effect78.sync(() => makeClient);
       yield* recordRunnerReadinessChecked(database);
       return {
         database,
@@ -15183,9 +16654,9 @@ var makeService2 = (database, checkDatabase) => Effect77.gen(function* () {
     })
   });
 });
-var checkLayer = (database, checkDatabase) => Layer69.effect(Service49, makeService2(database, checkDatabase));
-var memoryCheckLayer = checkLayer("memory", Effect77.void);
-var detectDialect = Effect77.serviceOption(SqlClient22).pipe(Effect77.map(Option27.match({
+var checkLayer = (database, checkDatabase) => Layer70.effect(Service50, makeService2(database, checkDatabase));
+var memoryCheckLayer = checkLayer("memory", Effect78.void);
+var detectDialect = Effect78.serviceOption(SqlClient23).pipe(Effect78.map(Option27.match({
   onNone: () => "sql",
   onSome: (sqlClient) => sqlClient.onDialectOrElse({
     pg: () => "pg",
@@ -15194,31 +16665,31 @@ var detectDialect = Effect77.serviceOption(SqlClient22).pipe(Effect77.map(Option
     orElse: () => "sql"
   })
 })));
-var databaseHealthCheck = Effect77.gen(function* () {
-  const database = yield* Effect77.serviceOption(exports_database_service.Service);
+var databaseHealthCheck = Effect78.gen(function* () {
+  const database = yield* Effect78.serviceOption(exports_database_service.Service);
   if (Option27.isSome(database)) {
-    return exports_database_service.check().pipe(Effect77.mapError((error) => new RunnerRuntimeError({ message: String(error) })), Effect77.provideService(exports_database_service.Service, database.value));
+    return exports_database_service.check().pipe(Effect78.mapError((error) => new RunnerRuntimeError({ message: String(error) })), Effect78.provideService(exports_database_service.Service, database.value));
   }
-  const sqlClient = yield* Effect77.serviceOption(SqlClient22);
+  const sqlClient = yield* Effect78.serviceOption(SqlClient23);
   if (Option27.isSome(sqlClient)) {
-    return sqlClient.value`select 1 as ok`.pipe(Effect77.asVoid, Effect77.mapError((error) => new RunnerRuntimeError({ message: String(error) })));
+    return sqlClient.value`select 1 as ok`.pipe(Effect78.asVoid, Effect78.mapError((error) => new RunnerRuntimeError({ message: String(error) })));
   }
-  return Effect77.void;
+  return Effect78.void;
 });
-var sqlCheckLayer = Layer69.effect(Service49, Effect77.gen(function* () {
+var sqlCheckLayer = Layer70.effect(Service50, Effect78.gen(function* () {
   const dialect2 = yield* detectDialect;
   const checkDatabase = yield* databaseHealthCheck;
   return yield* makeService2(dialect2, checkDatabase);
 }));
-var makeClientService = (database, checkDatabase) => Effect77.gen(function* () {
+var makeClientService = (database, checkDatabase) => Effect78.gen(function* () {
   const sharding = yield* Sharding.Sharding;
   const makeClient = yield* client2;
-  return Service49.of({
-    check: Effect77.fn("RunnerRuntime.check")(function* () {
-      yield* Effect77.annotateCurrentSpan("relay.database.mode", database);
+  return Service50.of({
+    check: Effect78.fn("RunnerRuntime.check")(function* () {
+      yield* Effect78.annotateCurrentSpan("relay.database.mode", database);
       yield* checkDatabase;
-      yield* Effect77.sync(() => sharding);
-      yield* Effect77.sync(() => makeClient);
+      yield* Effect78.sync(() => sharding);
+      yield* Effect78.sync(() => makeClient);
       yield* recordRunnerReadinessChecked(database);
       return {
         database,
@@ -15229,20 +16700,20 @@ var makeClientService = (database, checkDatabase) => Effect77.gen(function* () {
     })
   });
 });
-var memoryClientCheckLayer = Layer69.effect(Service49, makeClientService("memory", Effect77.void));
-var multiNodeDialectGuard = Layer69.effectDiscard(Effect77.gen(function* () {
+var memoryClientCheckLayer = Layer70.effect(Service50, makeClientService("memory", Effect78.void));
+var multiNodeDialectGuard = Layer70.effectDiscard(Effect78.gen(function* () {
   const dialect2 = yield* detectDialect;
   if (dialect2 === "sqlite") {
-    return yield* Effect77.die(new Error("SQLite supports single-process topologies only; multi-node cluster composition requires Postgres or MySQL"));
+    return yield* Effect78.die(new Error("SQLite supports single-process topologies only; multi-node cluster composition requires Postgres or MySQL"));
   }
 }));
-var sqlClientCheckLayer = Layer69.effect(Service49, Effect77.gen(function* () {
+var sqlClientCheckLayer = Layer70.effect(Service50, Effect78.gen(function* () {
   const dialect2 = yield* detectDialect;
   const checkDatabase = yield* databaseHealthCheck;
   return yield* makeClientService(dialect2, checkDatabase);
 }));
-var deterministicTestModelLayer = Layer69.effect(LanguageModel7.LanguageModel, LanguageModel7.make({
-  generateText: () => Effect77.succeed([{ type: "text", text: "deterministic test response" }]),
+var deterministicTestModelLayer = Layer70.effect(LanguageModel7.LanguageModel, LanguageModel7.make({
+  generateText: () => Effect78.succeed([{ type: "text", text: "deterministic test response" }]),
   streamText: () => Stream10.make({ type: "text-delta", id: "text", delta: "deterministic test response" })
 }));
 var testLanguageModelLayer = layerFromRegistrationEffects3([
@@ -15253,57 +16724,60 @@ var testLanguageModelLayer = layerFromRegistrationEffects3([
   })
 ]);
 var testEmbeddingModelLayer = deterministicTestLayer();
-var defaultPromptAssemblerLayer = (blobStoreLayer = passthroughLayer, artifactStoreLayer = passthroughLayer2) => defaultLayerWithStores.pipe(Layer69.provide(Layer69.mergeAll(blobStoreLayer, artifactStoreLayer)));
+var defaultPromptAssemblerLayer = (blobStoreLayer = passthroughLayer, artifactStoreLayer = passthroughLayer2) => defaultLayerWithStores.pipe(Layer70.provide(Layer70.mergeAll(blobStoreLayer, artifactStoreLayer)));
 var layerWith = (options) => {
   const blobStoreLayer = options.blobStoreLayer ?? passthroughLayer;
   const artifactStoreLayer = options.artifactStoreLayer ?? passthroughLayer2;
   const promptAssemblerLayer = options.promptAssemblerLayer ?? defaultPromptAssemblerLayer(blobStoreLayer, artifactStoreLayer);
-  const schemaRegistryLayer = options.schemaRegistryLayer ?? layer37();
+  const schemaRegistryLayer = options.schemaRegistryLayer ?? layer38();
   const embeddingModelLayer = options.embeddingModelLayer ?? memoryLayer27();
-  const memoryLayer35 = layer34().pipe(Layer69.provideMerge(embeddingModelLayer));
-  const clusterContextLayer = Layer69.mergeAll(options.languageModelLayer, memoryLayer35, blobStoreLayer, artifactStoreLayer, promptAssemblerLayer, schemaRegistryLayer);
-  const clusterLayer = options.clusterLayer.pipe(Layer69.provide(clusterContextLayer));
-  return Layer69.mergeAll(options.checkLayer, workflowAndEntityLayerWith(options.toolRuntimeLayer, options.schedulerLayer, promptAssemblerLayer, schemaRegistryLayer)).pipe(Layer69.provideMerge(options.languageModelLayer), Layer69.provide(memoryLayer35), Layer69.provideMerge(ClusterWorkflowEngine.layer), Layer69.provideMerge(clusterLayer), Layer69.provideMerge(options.repositoryLayer), Layer69.provideMerge(blobStoreLayer), Layer69.provideMerge(artifactStoreLayer));
+  const memoryLayer36 = layer35().pipe(Layer70.provideMerge(embeddingModelLayer));
+  const clusterContextLayer = Layer70.mergeAll(options.languageModelLayer, memoryLayer36, blobStoreLayer, artifactStoreLayer, promptAssemblerLayer, schemaRegistryLayer);
+  const clusterLayer = options.clusterLayer.pipe(Layer70.provide(clusterContextLayer));
+  return Layer70.mergeAll(options.checkLayer, workflowAndEntityLayerWith(options.toolRuntimeLayer, options.schedulerLayer, promptAssemblerLayer, schemaRegistryLayer, options.toolTransitionCoordinatorLayer)).pipe(Layer70.provideMerge(options.languageModelLayer), Layer70.provide(memoryLayer36), Layer70.provideMerge(ClusterWorkflowEngine.layer), Layer70.provideMerge(clusterLayer), Layer70.provideMerge(options.repositoryLayer), Layer70.provideMerge(blobStoreLayer), Layer70.provideMerge(artifactStoreLayer));
 };
 var layerWithClient = (options) => {
   const blobStoreLayer = options.blobStoreLayer ?? passthroughLayer;
   const artifactStoreLayer = options.artifactStoreLayer ?? passthroughLayer2;
   const promptAssemblerLayer = options.promptAssemblerLayer ?? defaultPromptAssemblerLayer(blobStoreLayer, artifactStoreLayer);
-  const schemaRegistryLayer = options.schemaRegistryLayer ?? layer37();
+  const schemaRegistryLayer = options.schemaRegistryLayer ?? layer38();
   const embeddingModelLayer = options.embeddingModelLayer ?? memoryLayer27();
-  const memoryLayer35 = layer34().pipe(Layer69.provideMerge(embeddingModelLayer));
-  return Layer69.mergeAll(options.checkLayer, runtimeServicesLayerWith(options.toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer)).pipe(Layer69.provideMerge(options.languageModelLayer), Layer69.provide(memoryLayer35), Layer69.provideMerge(options.clusterLayer), Layer69.provideMerge(options.repositoryLayer), Layer69.provideMerge(blobStoreLayer), Layer69.provideMerge(artifactStoreLayer));
+  const memoryLayer36 = layer35().pipe(Layer70.provideMerge(embeddingModelLayer));
+  return Layer70.mergeAll(options.checkLayer, runtimeServicesLayerWith(options.toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, options.toolTransitionCoordinatorLayer)).pipe(Layer70.provideMerge(options.languageModelLayer), Layer70.provide(memoryLayer36), Layer70.provideMerge(options.clusterLayer), Layer70.provideMerge(options.repositoryLayer), Layer70.provideMerge(blobStoreLayer), Layer70.provideMerge(artifactStoreLayer));
 };
 var layerWithServices = (options) => layerWith({
+  toolTransitionCoordinatorLayer: sqlLayer,
   checkLayer: sqlCheckLayer,
   clusterLayer: sqlClusterLayer,
-  repositoryLayer: options.databaseLayer === undefined ? sqlRepositoryLayer : sqlRepositoryLayer.pipe(Layer69.provideMerge(options.databaseLayer)),
+  repositoryLayer: options.databaseLayer === undefined ? sqlRepositoryLayer : sqlRepositoryLayer.pipe(Layer70.provideMerge(options.databaseLayer)),
   languageModelLayer: options.languageModelLayer,
   embeddingModelLayer: options.embeddingModelLayer,
   toolRuntimeLayer: options.toolRuntimeLayer,
-  schedulerLayer: layer51,
+  schedulerLayer: layer52,
   promptAssemblerLayer: options.promptAssemblerLayer,
   blobStoreLayer: options.blobStoreLayer,
   artifactStoreLayer: options.artifactStoreLayer,
   schemaRegistryLayer: options.schemaRegistryLayer
 });
 var layerWithServicesMultiNode = (options) => layerWith({
-  checkLayer: Layer69.mergeAll(sqlCheckLayer, multiNodeDialectGuard),
+  toolTransitionCoordinatorLayer: sqlLayer,
+  checkLayer: Layer70.mergeAll(sqlCheckLayer, multiNodeDialectGuard),
   clusterLayer: clusterLayerHttp(options.cluster),
-  repositoryLayer: options.databaseLayer === undefined ? sqlRepositoryLayer : sqlRepositoryLayer.pipe(Layer69.provideMerge(options.databaseLayer)),
+  repositoryLayer: options.databaseLayer === undefined ? sqlRepositoryLayer : sqlRepositoryLayer.pipe(Layer70.provideMerge(options.databaseLayer)),
   languageModelLayer: options.languageModelLayer,
   embeddingModelLayer: options.embeddingModelLayer,
   toolRuntimeLayer: options.toolRuntimeLayer,
-  schedulerLayer: layer51,
+  schedulerLayer: layer52,
   promptAssemblerLayer: options.promptAssemblerLayer,
   blobStoreLayer: options.blobStoreLayer,
   artifactStoreLayer: options.artifactStoreLayer,
   schemaRegistryLayer: options.schemaRegistryLayer
 });
 var layerWithServicesMultiNodeClientOnly = (options) => layerWithClient({
-  checkLayer: Layer69.mergeAll(sqlClientCheckLayer, multiNodeDialectGuard),
+  toolTransitionCoordinatorLayer: sqlLayer,
+  checkLayer: Layer70.mergeAll(sqlClientCheckLayer, multiNodeDialectGuard),
   clusterLayer: clusterLayerHttpClientOnly(options.cluster ?? {}),
-  repositoryLayer: options.databaseLayer === undefined ? sqlRepositoryLayer : sqlRepositoryLayer.pipe(Layer69.provideMerge(options.databaseLayer)),
+  repositoryLayer: options.databaseLayer === undefined ? sqlRepositoryLayer : sqlRepositoryLayer.pipe(Layer70.provideMerge(options.databaseLayer)),
   languageModelLayer: options.languageModelLayer,
   embeddingModelLayer: options.embeddingModelLayer,
   toolRuntimeLayer: options.toolRuntimeLayer,
@@ -15313,53 +16787,57 @@ var layerWithServicesMultiNodeClientOnly = (options) => layerWithClient({
   schemaRegistryLayer: options.schemaRegistryLayer
 });
 var layerWithLanguageModelService = (options) => layerWithServices({ ...options, toolRuntimeLayer: layer23() });
-var layer52 = layerWithServices({
+var layer53 = layerWithServices({
   databaseLayer: exports_database_service.layerFromPgClient,
   languageModelLayer: memoryLayer28(),
   embeddingModelLayer: memoryLayer27(),
   toolRuntimeLayer: layer23()
 });
 var testLayerWithServices = (options) => layerWith({
+  toolTransitionCoordinatorLayer: memoryLayer33,
   checkLayer: memoryCheckLayer,
   clusterLayer: memoryClusterLayer,
   repositoryLayer: memoryRepositoryLayer,
   languageModelLayer: options.languageModelLayer,
   embeddingModelLayer: options.embeddingModelLayer ?? testEmbeddingModelLayer,
   toolRuntimeLayer: options.toolRuntimeLayer,
-  schedulerLayer: memoryLayer34
-}).pipe(Layer69.provideMerge(testCryptoLayer));
+  schedulerLayer: memoryLayer35
+}).pipe(Layer70.provideMerge(testCryptoLayer));
 var testLayerWithLanguageModelService = (languageModelLayer) => testLayerWithServices({ languageModelLayer, toolRuntimeLayer: layer23() });
 var testLayer51 = testLayerWithServices({
   languageModelLayer: testLanguageModelLayer,
   toolRuntimeLayer: layer23()
 });
 var testClientLayer = layerWithClient({
+  toolTransitionCoordinatorLayer: memoryLayer33,
   checkLayer: memoryClientCheckLayer,
   clusterLayer: memoryClusterLayer,
   repositoryLayer: memoryRepositoryLayer,
   languageModelLayer: testLanguageModelLayer,
   embeddingModelLayer: testEmbeddingModelLayer,
   toolRuntimeLayer: layer23()
-}).pipe(Layer69.provideMerge(testCryptoLayer));
+}).pipe(Layer70.provideMerge(testCryptoLayer));
 var testLayerWithDatabaseCheck = (databaseLayer) => layerWith({
+  toolTransitionCoordinatorLayer: memoryLayer33,
   checkLayer: sqlCheckLayer,
   clusterLayer: memoryClusterLayer,
   repositoryLayer: memoryRepositoryLayer,
   languageModelLayer: testLanguageModelLayer,
   embeddingModelLayer: testEmbeddingModelLayer,
   toolRuntimeLayer: layer23(),
-  schedulerLayer: memoryLayer34
-}).pipe(Layer69.provide(databaseLayer), Layer69.provideMerge(testCryptoLayer));
+  schedulerLayer: memoryLayer35
+}).pipe(Layer70.provide(databaseLayer), Layer70.provideMerge(testCryptoLayer));
 var testClientLayerWithDatabaseCheck = (databaseLayer) => layerWithClient({
+  toolTransitionCoordinatorLayer: memoryLayer33,
   checkLayer: sqlClientCheckLayer,
   clusterLayer: memoryClusterLayer,
   repositoryLayer: memoryRepositoryLayer,
   languageModelLayer: testLanguageModelLayer,
   embeddingModelLayer: testEmbeddingModelLayer,
   toolRuntimeLayer: layer23()
-}).pipe(Layer69.provide(databaseLayer), Layer69.provideMerge(testCryptoLayer));
-var check2 = Effect77.fn("RunnerRuntime.check.call")(function* () {
-  const service = yield* Service49;
+}).pipe(Layer70.provide(databaseLayer), Layer70.provideMerge(testCryptoLayer));
+var check2 = Effect78.fn("RunnerRuntime.check.call")(function* () {
+  const service = yield* Service50;
   return yield* service.check();
 });
 // ../runtime/src/workflow/activity-version-registry.ts
@@ -15375,7 +16853,7 @@ __export(exports_activity_version_registry, {
   ActivityManifestChange: () => ActivityManifestChange,
   ActivityManifest: () => ActivityManifest
 });
-import { Crypto as Crypto5, Effect as Effect78, Schema as Schema74 } from "effect";
+import { Crypto as Crypto5, Effect as Effect79, Schema as Schema74 } from "effect";
 var generatedFrom = "@relayfx/runtime/ExecutionWorkflow";
 var ActivityManifestEntry = Schema74.Struct({
   name: Schema74.String,
@@ -15533,13 +17011,13 @@ var canonical = (value) => {
 };
 var canonicalStringify = (value) => JSON.stringify(canonical(value));
 var hex2 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-var signatureHash = Effect78.fn("ActivityVersionRegistry.signatureHash")(function* (input, success2, error) {
+var signatureHash = Effect79.fn("ActivityVersionRegistry.signatureHash")(function* (input, success2, error) {
   const crypto = yield* Crypto5.Crypto;
   const payload = new TextEncoder().encode(canonicalStringify({ input, success: success2, error }));
   const digest = yield* crypto.digest("SHA-256", payload);
   return hex2(digest);
 });
-var manifestEntry = Effect78.fn("ActivityVersionRegistry.manifestEntry")(function* (contract) {
+var manifestEntry = Effect79.fn("ActivityVersionRegistry.manifestEntry")(function* (contract) {
   const input = schemaJson(contract.input);
   const success2 = schemaJson(contract.success);
   const error = schemaJson(contract.error);
@@ -15549,8 +17027,8 @@ var manifestEntry = Effect78.fn("ActivityVersionRegistry.manifestEntry")(functio
     signature_hash
   };
 });
-var currentManifest = Effect78.fn("ActivityVersionRegistry.currentManifest")(function* () {
-  const activities = yield* Effect78.forEach(contracts.toSorted((left, right) => left.name.localeCompare(right.name)), manifestEntry);
+var currentManifest = Effect79.fn("ActivityVersionRegistry.currentManifest")(function* () {
+  const activities = yield* Effect79.forEach(contracts.toSorted((left, right) => left.name.localeCompare(right.name)), manifestEntry);
   return {
     version: 1,
     generated_from: generatedFrom,
@@ -15604,11 +17082,11 @@ var evaluateGuard = (input) => {
     additive_changes: diff.additive
   };
 };
-var guard = Effect78.fn("ActivityVersionRegistry.guard")(function* (input) {
+var guard = Effect79.fn("ActivityVersionRegistry.guard")(function* (input) {
   const result = evaluateGuard(input);
   if (result.status === "pass")
     return result;
-  return yield* Effect78.fail(new ActivityManifestGuardFailed({
+  return yield* Effect79.fail(new ActivityManifestGuardFailed({
     message: `Activity replay contract changed while ${result.waiting_executions} waiting executions exist`,
     result
   }));
@@ -15638,9 +17116,9 @@ __export(exports_language_model_registration, {
   anthropic: () => anthropic
 });
 
-// ../../node_modules/.bun/@batonfx+providers@0.3.7/node_modules/@batonfx/providers/src/anthropic.ts
+// ../../node_modules/.bun/@batonfx+providers@0.4.0/node_modules/@batonfx/providers/src/anthropic.ts
 import { AnthropicClient, AnthropicLanguageModel } from "@effect/ai-anthropic";
-import { Layer as Layer70 } from "effect";
+import { Layer as Layer71 } from "effect";
 import { FetchHttpClient as FetchHttpClient2 } from "effect/unstable/http";
 var anthropic = (input) => exports_model_registry.registrationFromLayer({
   provider: "anthropic",
@@ -15653,16 +17131,16 @@ var anthropic = (input) => exports_model_registry.registrationFromLayer({
   ...input.metadata === undefined ? {} : { metadata: input.metadata }
 });
 var anthropicClientLayerConfig = AnthropicClient.layerConfig;
-var withAnthropic = (options) => exports_model_registry.layerFromRegistrationEffects([anthropic(options)]).pipe(Layer70.provide(AnthropicClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer70.provide(FetchHttpClient2.layer));
-// ../../node_modules/.bun/@batonfx+providers@0.3.7/node_modules/@batonfx/providers/src/deterministic.ts
+var withAnthropic = (options) => exports_model_registry.layerFromRegistrationEffects([anthropic(options)]).pipe(Layer71.provide(AnthropicClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer71.provide(FetchHttpClient2.layer));
+// ../../node_modules/.bun/@batonfx+providers@0.4.0/node_modules/@batonfx/providers/src/deterministic.ts
 import { OpenAiClient as OpenAiClient3 } from "@effect/ai-openai";
-import { Effect as Effect79, Layer as Layer72, Option as Option28, Stream as Stream11 } from "effect";
+import { Effect as Effect80, Layer as Layer73, Option as Option28, Stream as Stream11 } from "effect";
 import { LanguageModel as LanguageModel8, Response as Response7 } from "effect/unstable/ai";
 import { FetchHttpClient as FetchHttpClient4 } from "effect/unstable/http";
 
-// ../../node_modules/.bun/@batonfx+providers@0.3.7/node_modules/@batonfx/providers/src/openai.ts
+// ../../node_modules/.bun/@batonfx+providers@0.4.0/node_modules/@batonfx/providers/src/openai.ts
 import { OpenAiClient as OpenAiClient2, OpenAiLanguageModel } from "@effect/ai-openai";
-import { Layer as Layer71 } from "effect";
+import { Layer as Layer72 } from "effect";
 import { FetchHttpClient as FetchHttpClient3 } from "effect/unstable/http";
 var openAi = (input) => exports_model_registry.registrationFromLayer({
   provider: "openai",
@@ -15675,11 +17153,11 @@ var openAi = (input) => exports_model_registry.registrationFromLayer({
   ...input.metadata === undefined ? {} : { metadata: input.metadata }
 });
 var openAiClientLayerConfig2 = OpenAiClient2.layerConfig;
-var withOpenAi = (options) => exports_model_registry.layerFromRegistrationEffects([openAi(options)]).pipe(Layer71.provide(OpenAiClient2.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer71.provide(FetchHttpClient3.layer));
+var withOpenAi = (options) => exports_model_registry.layerFromRegistrationEffects([openAi(options)]).pipe(Layer72.provide(OpenAiClient2.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer72.provide(FetchHttpClient3.layer));
 
-// ../../node_modules/.bun/@batonfx+providers@0.3.7/node_modules/@batonfx/providers/src/deterministic.ts
-var deterministicModelLayer = Layer72.effect(LanguageModel8.LanguageModel, LanguageModel8.make({
-  generateText: () => Effect79.succeed([{ type: "text", text: "deterministic response" }]),
+// ../../node_modules/.bun/@batonfx+providers@0.4.0/node_modules/@batonfx/providers/src/deterministic.ts
+var deterministicModelLayer = Layer73.effect(LanguageModel8.LanguageModel, LanguageModel8.make({
+  generateText: () => Effect80.succeed([{ type: "text", text: "deterministic response" }]),
   streamText: () => Stream11.make(Response7.makePart("text-delta", { id: "text", delta: "deterministic response" }))
 }));
 var deterministicModel = (input = {}) => exports_model_registry.registrationFromLayer({
@@ -15690,20 +17168,20 @@ var deterministicModel = (input = {}) => exports_model_registry.registrationFrom
   ...input.metadata === undefined ? {} : { metadata: input.metadata }
 });
 var withDeterministic = (input = {}) => exports_model_registry.layerFromRegistrationEffects([deterministicModel(input)]);
-var withOpenAiOrDeterministic = (options) => Layer72.unwrap(Effect79.gen(function* () {
+var withOpenAiOrDeterministic = (options) => Layer73.unwrap(Effect80.gen(function* () {
   const deterministic = yield* deterministicModel({
     provider: options.fallbackProvider ?? "deterministic",
     model: options.fallbackModel
   });
-  const openAiRegistration = yield* openAi(options).pipe(Effect79.provide(OpenAiClient3.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Effect79.provide(FetchHttpClient4.layer), Effect79.asSome, Effect79.catchTag("ConfigError", () => Effect79.succeedNone));
+  const openAiRegistration = yield* openAi(options).pipe(Effect80.provide(OpenAiClient3.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Effect80.provide(FetchHttpClient4.layer), Effect80.asSome, Effect80.catchTag("ConfigError", () => Effect80.succeedNone));
   return exports_model_registry.layer([
     deterministic,
     ...Option28.isSome(openAiRegistration) ? [openAiRegistration.value] : []
   ]);
 }));
-// ../../node_modules/.bun/@batonfx+providers@0.3.7/node_modules/@batonfx/providers/src/openai-compat.ts
+// ../../node_modules/.bun/@batonfx+providers@0.4.0/node_modules/@batonfx/providers/src/openai-compat.ts
 import { OpenAiClient as OpenAiClient4, OpenAiLanguageModel as OpenAiLanguageModel2 } from "@effect/ai-openai-compat";
-import { Config as Config8, Layer as Layer73 } from "effect";
+import { Config as Config8, Layer as Layer74 } from "effect";
 import { FetchHttpClient as FetchHttpClient5 } from "effect/unstable/http";
 var openAiCompatible = (input) => exports_model_registry.registrationFromLayer({
   provider: input.provider ?? "openai-compatible",
@@ -15721,10 +17199,10 @@ var clientLayerConfig = (options) => OpenAiClient4.layerConfig({
   ...options.apiKey === undefined ? {} : { apiKey: options.apiKey },
   ...options.baseUrl === undefined ? {} : { apiUrl: Config8.succeed(options.baseUrl) }
 });
-var withOpenAiCompatible = (options) => exports_model_registry.layerFromRegistrationEffects([openAiCompatible(options)]).pipe(Layer73.provide(clientLayerConfig(options)), Layer73.provide(FetchHttpClient5.layer));
-// ../../node_modules/.bun/@batonfx+providers@0.3.7/node_modules/@batonfx/providers/src/openrouter.ts
+var withOpenAiCompatible = (options) => exports_model_registry.layerFromRegistrationEffects([openAiCompatible(options)]).pipe(Layer74.provide(clientLayerConfig(options)), Layer74.provide(FetchHttpClient5.layer));
+// ../../node_modules/.bun/@batonfx+providers@0.4.0/node_modules/@batonfx/providers/src/openrouter.ts
 import { OpenRouterClient, OpenRouterLanguageModel } from "@effect/ai-openrouter";
-import { Layer as Layer74 } from "effect";
+import { Layer as Layer75 } from "effect";
 import { FetchHttpClient as FetchHttpClient6 } from "effect/unstable/http";
 var openRouter = (input) => exports_model_registry.registrationFromLayer({
   provider: "openrouter",
@@ -15737,7 +17215,7 @@ var openRouter = (input) => exports_model_registry.registrationFromLayer({
   ...input.metadata === undefined ? {} : { metadata: input.metadata }
 });
 var openRouterClientLayerConfig = OpenRouterClient.layerConfig;
-var withOpenRouter = (options) => exports_model_registry.layerFromRegistrationEffects([openRouter(options)]).pipe(Layer74.provide(OpenRouterClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer74.provide(FetchHttpClient6.layer));
+var withOpenRouter = (options) => exports_model_registry.layerFromRegistrationEffects([openRouter(options)]).pipe(Layer75.provide(OpenRouterClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer75.provide(FetchHttpClient6.layer));
 // src/ai.ts
 var relayAiPackage = "@relayfx/sdk/ai";
 export {
@@ -15747,7 +17225,7 @@ export {
   exports_tool_output as ToolOutput,
   exports_tool_executor as ToolExecutor,
   exports_tool_context as ToolContext,
-  Tool7 as Tool,
+  Tool6 as Tool,
   Tokenizer3 as Tokenizer,
   Telemetry2 as Telemetry,
   exports_steering as Steering,