@relayfx/sdk 0.3.5 → 0.3.7

package/dist/{index-cq8t8ka1.js → index-8awt651b.js}

@@ -16,7 +16,7 @@ import {
   exports_tool_executor,
   exports_tool_output,
   exports_turn_policy
-} from "./index-8fpd6kvj.js";
+} from "./index-t5bbk8cp.js";
 import {
   ClientError,
   CommandReplyInvalid,
@@ -51,7 +51,7 @@ import {
   followExecutionFrom,
   inputSchemaRef,
   outputSchemaRef
-} from "./index-cyfx5y3r.js";
+} from "./index-pw46cfne.js";
 import {
   __export
 } from "./index-nb39b5ae.js";
@@ -717,7 +717,7 @@ __export(exports_tool_runtime, {
 });
 
 // ../runtime/src/tool/tool-runtime-contract.ts
-import { Context as Context10, Layer as Layer10, Schema as Schema10 } from "effect";
+import { Context as Context10, Effect as Effect10, Layer as Layer10, Schema as Schema10 } from "effect";
 
 class ToolNotRegistered extends Schema10.TaggedErrorClass()("ToolNotRegistered", {
   tool_name: exports_shared_schema.NonEmptyString
@@ -755,7 +755,7 @@ class ToolCallInfo extends Context10.Service()("@relayfx/runtime/tool/tool-runti
 
 class Service12 extends Context10.Service()("@relayfx/runtime/tool/tool-runtime-contract/Service") {
 }
-var testLayer8 = (implementation) => Layer10.succeed(Service12, Service12.of(implementation));
+var testLayer8 = (implementation) => Layer10.succeed(Service12, Service12.of({ ...implementation, prepare: implementation.prepare ?? (() => Effect10.void) }));
 // ../store-sql/src/address/address-book-repository.ts
 var exports_address_book_repository = {};
 __export(exports_address_book_repository, {
@@ -3175,6 +3175,7 @@ __export(exports_execution_event_repository, {
   findByCursor: () => findByCursor,
   executionEventsChannel: () => executionEventsChannel,
   appendedSignals: () => appendedSignals,
+  appendNext: () => appendNext,
   append: () => append,
   Service: () => Service25,
   ExecutionEventRow: () => ExecutionEventRow,
@@ -3183,7 +3184,7 @@ __export(exports_execution_event_repository, {
   ExecutionEventCursorNotFound: () => ExecutionEventCursorNotFound,
   DuplicateExecutionEvent: () => DuplicateExecutionEvent
 });
-import { Context as Context23, Effect as Effect24, Filter, Layer as Layer23, Option as Option2, PubSub as PubSub2, Schema as Schema22, Stream as Stream2 } from "effect";
+import { Context as Context23, Effect as Effect24, Filter, Layer as Layer23, Option as Option2, PubSub as PubSub2, Schema as Schema22, Semaphore as Semaphore2, Stream as Stream2 } from "effect";
 import { SqlClient as SqlClient13 } from "effect/unstable/sql/SqlClient";
 
 // ../store-sql/src/database/notification-bus.ts
@@ -3319,6 +3320,7 @@ var duplicateError = (input) => DuplicateExecutionEvent.make({
   sequence: input.sequence,
   cursor: input.cursor
 });
+var hasSamePayload = (existing, input) => existing.id === input.id && existing.execution_id === input.execution_id && existing.child_execution_id === input.child_execution_id && existing.type === input.type && existing.cursor === input.cursor && exports_shared_schema.canonicalEquals(existing.content ?? null, input.content ?? null) && exports_shared_schema.canonicalEquals(existing.data ?? {}, input.data ?? {});
 var assertAppendable = (events, input) => {
   const duplicate = events.find((event) => event.sequence === input.sequence || event.cursor === input.cursor);
   if (duplicate !== undefined) {
@@ -3382,15 +3384,15 @@ var layer18 = Layer23.effect(Service25, Effect24.gen(function* () {
         ${timestampParam(sql, input.created_at)}
       )
     `;
-  const insertEvent = sql.onDialectOrElse({
-    mysql: () => (tenantId, input) => sql.withTransaction(Effect24.gen(function* () {
-      yield* insertStatement(tenantId, input);
-      return yield* selectByCursor(tenantId, input.cursor);
-    })),
-    orElse: () => (tenantId, input) => sql`
-        ${insertStatement(tenantId, input)}
-        RETURNING ${columns}
-      `
+  const lockExecution = (tenantId, executionId) => sql.onDialectOrElse({
+    mysql: () => sql`UPDATE relay_executions SET updated_at=updated_at WHERE tenant_id=${tenantId} AND id=${executionId}`.pipe(Effect24.andThen(sql`SELECT id FROM relay_executions WHERE tenant_id=${tenantId} AND id=${executionId}`)),
+    orElse: () => sql`UPDATE relay_executions SET updated_at=updated_at WHERE tenant_id=${tenantId} AND id=${executionId} RETURNING id`
+  });
+  const lockExistingExecution = Effect24.fn("ExecutionEventRepository.lockExistingExecution")(function* (tenantId, executionId) {
+    const rows = yield* lockExecution(tenantId, executionId);
+    if (rows[0] === undefined) {
+      return yield* ExecutionEventRepositoryError.make({ message: `Execution not found: ${executionId}` });
+    }
   });
   const listConditions = (tenantId, input) => [
     sql`tenant_id = ${tenantId}`,
@@ -3407,28 +3409,68 @@ var layer18 = Layer23.effect(Service25, Effect24.gen(function* () {
   const decodeEvents = (rows) => Effect24.forEach(rows, decodeRow7).pipe(Effect24.map((decoded) => decoded.map(toEvent)));
   const append = Effect24.fn("ExecutionEventRepository.append")(function* (input) {
     const tenantId = yield* current();
-    const previousRows = yield* selectLatest(tenantId, input.execution_id).pipe(Effect24.mapError(toRepositoryError8));
-    const previous = previousRows[0] === undefined ? undefined : toEvent(yield* decodeRow7(previousRows[0]));
-    if (previous !== undefined && input.sequence === previous.sequence) {
-      return yield* duplicateError(input);
-    }
-    if (previous !== undefined && input.sequence < previous.sequence) {
-      return yield* ExecutionEventOrderViolation.make({
-        execution_id: input.execution_id,
-        sequence: input.sequence,
-        previous_sequence: previous.sequence
-      });
-    }
-    const duplicateCursorRows = yield* selectByCursor(tenantId, input.cursor).pipe(Effect24.mapError(toRepositoryError8));
-    if (duplicateCursorRows[0] !== undefined) {
-      return yield* duplicateError(input);
-    }
-    const rows = yield* insertEvent(tenantId, input).pipe(Effect24.mapError(toRepositoryError8));
-    const row = rows[0];
-    if (row === undefined) {
-      return yield* ExecutionEventRepositoryError.make({ message: "Execution event append returned no row" });
-    }
-    return toEvent(yield* decodeRow7(row));
+    return yield* sql.withTransaction(Effect24.gen(function* () {
+      yield* lockExistingExecution(tenantId, input.execution_id);
+      const previousRows = yield* selectLatest(tenantId, input.execution_id);
+      const previous = previousRows[0] === undefined ? undefined : toEvent(yield* decodeRow7(previousRows[0]));
+      if (previous !== undefined && input.sequence === previous.sequence)
+        return yield* duplicateError(input);
+      if (previous !== undefined && input.sequence < previous.sequence) {
+        return yield* ExecutionEventOrderViolation.make({
+          execution_id: input.execution_id,
+          sequence: input.sequence,
+          previous_sequence: previous.sequence
+        });
+      }
+      const duplicateCursorRows = yield* selectByCursor(tenantId, input.cursor);
+      if (duplicateCursorRows[0] !== undefined)
+        return yield* duplicateError(input);
+      yield* insertStatement(tenantId, input);
+      const rows = yield* selectByCursor(tenantId, input.cursor);
+      const row = rows[0];
+      if (row === undefined) {
+        return yield* ExecutionEventRepositoryError.make({ message: "Execution event append returned no row" });
+      }
+      return toEvent(yield* decodeRow7(row));
+    })).pipe(Effect24.mapError((error) => Schema22.is(DuplicateExecutionEvent)(error) || Schema22.is(ExecutionEventOrderViolation)(error) ? error : toRepositoryError8(error)));
+  });
+  const appendNext = Effect24.fn("ExecutionEventRepository.appendNext")(function* (input) {
+    const tenantId = yield* current();
+    return yield* sql.withTransaction(Effect24.gen(function* () {
+      yield* lockExistingExecution(tenantId, input.execution_id);
+      const existingRows = yield* selectByCursor(tenantId, input.cursor);
+      const existingRow = existingRows[0];
+      if (existingRow !== undefined) {
+        const existing = toEvent(yield* decodeRow7(existingRow));
+        if (hasSamePayload(existing, input))
+          return { event: existing, inserted: false };
+        return yield* duplicateError({ ...input, sequence: existing.sequence });
+      }
+      const sequenceRows = yield* sql`
+            SELECT COALESCE(MAX(sequence), -1) + 1 AS value
+            FROM relay_execution_events
+            WHERE tenant_id = ${tenantId} AND execution_id = ${input.execution_id}
+          `;
+      const sequenceRow = sequenceRows[0];
+      if (sequenceRow === undefined) {
+        return yield* ExecutionEventRepositoryError.make({
+          message: "Execution event sequence query returned no row"
+        });
+      }
+      const decodedSequence = yield* decodeAggregate(sequenceRow);
+      const { minimumSequence, ...eventInput } = input;
+      const event = {
+        ...eventInput,
+        sequence: Math.max(Number(decodedSequence.value), minimumSequence ?? 0)
+      };
+      yield* insertStatement(tenantId, event);
+      const rows = yield* selectByCursor(tenantId, input.cursor);
+      const row = rows[0];
+      if (row === undefined) {
+        return yield* ExecutionEventRepositoryError.make({ message: "Execution event append returned no row" });
+      }
+      return { event: toEvent(yield* decodeRow7(row)), inserted: true };
+    })).pipe(Effect24.mapError((error) => Schema22.is(DuplicateExecutionEvent)(error) ? error : toRepositoryError8(error)));
   });
   const list4 = Effect24.fn("ExecutionEventRepository.list")(function* (input) {
     const tenantId = yield* current();
@@ -3608,6 +3650,7 @@ var layer18 = Layer23.effect(Service25, Effect24.gen(function* () {
   return Service25.of({
     signalTransport: bus.transport,
     append,
+    appendNext,
     list: list4,
     findBySequenceOrCursor,
     findByCursor,
@@ -3624,14 +3667,47 @@ var layer18 = Layer23.effect(Service25, Effect24.gen(function* () {
 var layerWithBus = layer18.pipe(Layer23.provide(layerFromDialect));
 var memoryLayer16 = Layer23.effect(Service25, Effect24.gen(function* () {
   const events = new Map;
+  const locks = new Map;
   const signals = yield* PubSub2.unbounded();
+  const lockFor = Effect24.fn("ExecutionEventRepository.memory.lockFor")(function* (executionId) {
+    const candidate = yield* Semaphore2.make(1);
+    return yield* Effect24.sync(() => {
+      const existing = locks.get(executionId);
+      if (existing !== undefined)
+        return existing;
+      locks.set(executionId, candidate);
+      return candidate;
+    });
+  });
   return Service25.of({
     signalTransport: "in-process",
     append: Effect24.fn("ExecutionEventRepository.memory.append")(function* (input) {
-      const executionEvents = events.get(input.execution_id) ?? [];
-      yield* assertAppendable(executionEvents, input);
-      yield* Effect24.sync(() => events.set(input.execution_id, [...executionEvents, input]));
-      return input;
+      const lock = yield* lockFor(input.execution_id);
+      return yield* lock.withPermits(1)(Effect24.gen(function* () {
+        const executionEvents = events.get(input.execution_id) ?? [];
+        yield* assertAppendable(executionEvents, input);
+        yield* Effect24.sync(() => events.set(input.execution_id, [...executionEvents, input]));
+        return input;
+      }));
+    }),
+    appendNext: Effect24.fn("ExecutionEventRepository.memory.appendNext")(function* (input) {
+      const lock = yield* lockFor(input.execution_id);
+      return yield* lock.withPermits(1)(Effect24.gen(function* () {
+        const executionEvents = events.get(input.execution_id) ?? [];
+        const existing = executionEvents.find((event2) => event2.cursor === input.cursor);
+        if (existing !== undefined) {
+          if (hasSamePayload(existing, input))
+            return { event: existing, inserted: false };
+          return yield* duplicateError({ ...input, sequence: existing.sequence });
+        }
+        const { minimumSequence, ...eventInput } = input;
+        const event = {
+          ...eventInput,
+          sequence: Math.max(executionEvents.reduce((maximum, item) => Math.max(maximum, item.sequence), -1) + 1, minimumSequence ?? 0)
+        };
+        yield* Effect24.sync(() => events.set(input.execution_id, [...executionEvents, event]));
+        return { event, inserted: true };
+      }));
     }),
     list: Effect24.fn("ExecutionEventRepository.memory.list")(function* (input) {
       const executionEvents = events.get(input.executionId) ?? [];
@@ -3696,12 +3772,17 @@ var memoryLayer16 = Layer23.effect(Service25, Effect24.gen(function* () {
 }));
 var testLayer20 = (implementation) => Layer23.succeed(Service25, Service25.of({
   ...implementation,
+  appendNext: implementation.appendNext ?? ((input) => implementation.append({ ...input, sequence: 0 }).pipe(Effect24.map((event) => ({ event, inserted: true })), Effect24.catchTag("ExecutionEventOrderViolation", (error) => ExecutionEventRepositoryError.make({ message: String(error) })))),
   page: implementation.page ?? (() => Effect24.succeed({ events: [], hasMore: false }))
 }));
 var append = Effect24.fn("ExecutionEventRepository.append.call")(function* (input) {
   const repository = yield* Service25;
   return yield* repository.append(input);
 });
+var appendNext = Effect24.fn("ExecutionEventRepository.appendNext.call")(function* (input) {
+  const repository = yield* Service25;
+  return yield* repository.appendNext(input);
+});
 var list4 = Effect24.fn("ExecutionEventRepository.list.call")(function* (input) {
   const repository = yield* Service25;
   return yield* repository.list(input);
@@ -4409,7 +4490,7 @@ var layer20 = Layer25.effect(Service27, Effect26.gen(function* () {
 }));
 var testLayer22 = (implementation) => Layer25.succeed(Service27, Service27.of(implementation));
 // ../store-sql/src/idempotency/idempotency-repository.ts
-import { Context as Context26, Effect as Effect27, HashMap, Layer as Layer26, Option as Option5, Ref as Ref5, Schema as Schema25, Semaphore as Semaphore2 } from "effect";
+import { Context as Context26, Effect as Effect27, HashMap, Layer as Layer26, Option as Option5, Ref as Ref5, Schema as Schema25, Semaphore as Semaphore3 } from "effect";
 import { SqlClient as SqlClient16 } from "effect/unstable/sql/SqlClient";
 class IdempotencyRepositoryError extends Schema25.TaggedErrorClass()("IdempotencyRepositoryError", {
   message: Schema25.String
@@ -4528,7 +4609,7 @@ var layer21 = Layer26.effect(Service28, Effect27.gen(function* () {
 }));
 var memoryLayer19 = Layer26.effect(Service28, Effect27.gen(function* () {
   const records = yield* Ref5.make(HashMap.empty());
-  const semaphore = Semaphore2.makeUnsafe(1);
+  const semaphore = Semaphore3.makeUnsafe(1);
   const runOnce = Effect27.fn("IdempotencyRepository.memory.runOnce")(function* (input, create4) {
     return yield* semaphore.withPermits(1)(Effect27.gen(function* () {
       const id = operationId(input);
@@ -4623,9 +4704,13 @@ var consumeMessage = (message, input) => Object.assign({}, message, { drain_id:
 var layer22 = Layer27.effect(Service29, Effect28.gen(function* () {
   const sql = yield* SqlClient17;
   const lockExecution = sql.onDialectOrElse({
-    pg: () => (tenant, executionId) => sql`SELECT pg_advisory_xact_lock(hashtext(${`${tenant}:${executionId}:inbox`}))`.pipe(Effect28.asVoid),
-    mysql: () => (tenant, executionId) => sql`SELECT id FROM relay_executions WHERE tenant_id=${tenant} AND id=${executionId} FOR UPDATE`.pipe(Effect28.asVoid),
-    orElse: () => () => Effect28.void
+    mysql: () => (tenant, executionId) => sql`UPDATE relay_executions SET updated_at=updated_at WHERE tenant_id=${tenant} AND id=${executionId}`.pipe(Effect28.andThen(sql`SELECT id FROM relay_executions WHERE tenant_id=${tenant} AND id=${executionId}`)),
+    orElse: () => (tenant, executionId) => sql`UPDATE relay_executions SET updated_at=updated_at WHERE tenant_id=${tenant} AND id=${executionId} RETURNING id`
+  });
+  const lockExistingExecution = Effect28.fn("InboxRepository.lockExistingExecution")(function* (tenant, executionId) {
+    const rows = yield* lockExecution(tenant, executionId);
+    if (rows[0] === undefined)
+      return yield* InboxRepositoryError.make({ message: `Execution not found: ${executionId}` });
   });
   const appendEvent = (tenant, input, type, id, cursor, data) => Effect28.gen(function* () {
     const rows = yield* sql`SELECT COALESCE(MAX(sequence), -1) + 1 AS next_sequence FROM relay_execution_events WHERE tenant_id=${tenant} AND execution_id=${input.executionId}`;
@@ -4642,7 +4727,7 @@ var layer22 = Layer27.effect(Service29, Effect28.gen(function* () {
   const deliver = Effect28.fn("InboxRepository.deliver")(function* (input) {
     const tenant = yield* current();
     return yield* sql.withTransaction(Effect28.gen(function* () {
-      yield* lockExecution(tenant, input.executionId);
+      yield* lockExistingExecution(tenant, input.executionId);
       if (input.idempotencyKey !== undefined) {
         const found = yield* sql`SELECT ${sql.literal(columns)} FROM relay_inbox_messages WHERE tenant_id=${tenant} AND execution_id=${input.executionId} AND idempotency_key=${input.idempotencyKey}`;
         if (found[0] !== undefined)
@@ -4671,7 +4756,7 @@ var layer22 = Layer27.effect(Service29, Effect28.gen(function* () {
   const drain = Effect28.fn("InboxRepository.drain")(function* (input) {
     const tenant = yield* current();
     return yield* sql.withTransaction(Effect28.gen(function* () {
-      yield* lockExecution(tenant, input.executionId);
+      yield* lockExistingExecution(tenant, input.executionId);
       const old = yield* sql`SELECT message_sequences_json FROM relay_inbox_drains WHERE tenant_id=${tenant} AND execution_id=${input.executionId} AND drain_id=${input.drainId}`;
       let sequences;
       if (old[0] !== undefined)
@@ -6819,7 +6904,7 @@ __export(exports_skill_definition_repository, {
   Service: () => Service36,
   ExecutionSkillPinRow: () => ExecutionSkillPinRow
 });
-import { Context as Context34, Effect as Effect35, HashSet, Layer as Layer34, Schema as Schema33, Semaphore as Semaphore3 } from "effect";
+import { Context as Context34, Effect as Effect35, HashSet, Layer as Layer34, Schema as Schema33, Semaphore as Semaphore4 } from "effect";
 import { SqlClient as SqlClient24 } from "effect/unstable/sql/SqlClient";
 class SkillDefinitionRepositoryError extends Schema33.TaggedErrorClass()("SkillDefinitionRepositoryError", {
   message: Schema33.String
@@ -7108,7 +7193,7 @@ var layer29 = Layer34.effect(Service36, Effect35.gen(function* () {
   return Service36.of({ put: put3, get: get10, getRevision: getRevision2, list: list11, listRevisions: listRevisions2, pinExecution, listPins, getPinned });
 }));
 var memoryLayer27 = Layer34.sync(Service36, () => {
-  const semaphore = Semaphore3.makeUnsafe(1);
+  const semaphore = Semaphore4.makeUnsafe(1);
   const records = new Map;
   const revisions = new Map;
   const pins = new Map;
@@ -9622,7 +9707,8 @@ var afterSequence = (events, input) => {
   return Effect41.succeed(cursorEvent.sequence);
 };
 var replayAfter = (events, input, sequence) => events.filter((event) => event.execution_id === input.executionId).filter((event) => sequence === undefined || event.sequence > sequence).toSorted((left, right) => left.sequence - right.sequence).slice(0, limitOf(input));
-var sameEvent = (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.sequence === right.sequence && left.cursor === right.cursor && exports_shared_schema.canonicalEquals(left.content ?? null, right.content ?? null) && exports_shared_schema.canonicalEquals(left.data ?? {}, right.data ?? {});
+var sameEventPayload = (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 && exports_shared_schema.canonicalEquals(left.content ?? null, right.content ?? null) && exports_shared_schema.canonicalEquals(left.data ?? {}, right.data ?? {});
+var sameEvent = (left, right) => left.sequence === right.sequence && sameEventPayload(left, right);
 var findExisting = (events, input) => events.find((event) => event.cursor === input.cursor || event.sequence === input.sequence);
 var duplicateEventError = (input) => EventLogError.make({ message: `DuplicateExecutionEvent:${input.execution_id}:${input.sequence}` });
 var orderViolationError = (input, previous) => EventLogError.make({
@@ -9727,6 +9813,20 @@ var layerFromRepository = Layer39.effect(Service41, Effect41.gen(function* () {
       yield* recordEventAppended(event.type);
       return event;
     }),
+    appendNext: Effect41.fn("EventLog.repository.appendNext")(function* (input) {
+      yield* Effect41.annotateCurrentSpan({
+        "relay.execution.id": input.execution_id,
+        "relay.event.id": input.id,
+        "relay.event.type": input.type
+      });
+      const result = yield* repository.appendNext(input).pipe(Effect41.mapError(mapRepositoryAppendError));
+      if (result.inserted) {
+        yield* PubSub5.publish(pubsub, result.event);
+        yield* repository.notifyAppended(result.event).pipe(Effect41.catch((error5) => Effect41.logWarning("EventLog append notify failed", error5)));
+        yield* recordEventAppended(result.event.type);
+      }
+      return result.event;
+    }),
     replay: Effect41.fn("EventLog.repository.replay")(function* (input) {
       yield* Effect41.annotateCurrentSpan("relay.execution.id", input.executionId);
       const replay = yield* loadReplay(input);
@@ -9783,6 +9883,34 @@ var memoryLayer32 = Layer39.effect(Service41, Effect41.gen(function* () {
       yield* recordEventAppended(input.type);
       return input;
     }),
+    appendNext: Effect41.fn("EventLog.memory.appendNext")(function* (input) {
+      const result = yield* Ref10.modify((store) => {
+        const existing = HashMap2.get(store, input.execution_id).pipe(Option6.getOrElse(() => []));
+        const duplicate = existing.find((event2) => event2.cursor === input.cursor);
+        if (duplicate !== undefined) {
+          const candidate = { ...input, sequence: duplicate.sequence };
+          if (!sameEvent(duplicate, candidate))
+            return [{ _tag: "error", error: duplicateEventError(candidate) }, store];
+          return [{ _tag: "event", event: duplicate, inserted: false }, store];
+        }
+        const { minimumSequence, ...eventInput } = input;
+        const event = {
+          ...eventInput,
+          sequence: Math.max((existing.at(-1)?.sequence ?? -1) + 1, minimumSequence ?? 0)
+        };
+        return [
+          { _tag: "event", event, inserted: true },
+          HashMap2.set(store, input.execution_id, [...existing, event])
+        ];
+      })(events);
+      if (result._tag === "error")
+        return yield* result.error;
+      if (result.inserted) {
+        yield* PubSub5.publish(pubsub, result.event);
+        yield* recordEventAppended(result.event.type);
+      }
+      return result.event;
+    }),
     replay: Effect41.fn("EventLog.memory.replay")(function* (input) {
       yield* Effect41.annotateCurrentSpan("relay.execution.id", input.executionId);
       const replay = yield* loadReplay(input);
@@ -9827,18 +9955,28 @@ var memoryLayer32 = Layer39.effect(Service41, Effect41.gen(function* () {
     })
   });
 }));
-var appendIdempotentTo = Function6.dual(2, (eventLog, input) => eventLog.append(input).pipe(Effect41.catchTag("EventLogError", (error5) => eventLog.findBySequenceOrCursor({
-  executionId: input.execution_id,
-  sequence: input.sequence,
-  cursor: input.cursor
-}).pipe(Effect41.flatMap((existing) => Option6.match(existing, {
+var appendIdempotentTo = Function6.dual(2, (eventLog, input) => eventLog.appendNext({
+  id: input.id,
+  execution_id: input.execution_id,
+  ...input.child_execution_id === undefined ? {} : { child_execution_id: input.child_execution_id },
+  type: input.type,
+  cursor: input.cursor,
+  ...input.content === undefined ? {} : { content: input.content },
+  ...input.data === undefined ? {} : { data: input.data },
+  created_at: input.created_at,
+  minimumSequence: input.sequence
+}).pipe(Effect41.catchTag("EventLogError", (error5) => eventLog.findByCursor({ executionId: input.execution_id, cursor: input.cursor }).pipe(Effect41.flatMap(Option6.match({
   onNone: () => Effect41.fail(error5),
-  onSome: (event) => sameEvent(event, input) ? Effect41.succeed(event) : Effect41.fail(error5)
+  onSome: (event) => sameEventPayload(event, input) ? Effect41.succeed(event) : Effect41.fail(error5)
 })), Effect41.mapError(() => error5)))));
 var append3 = Effect41.fn("EventLog.append.call")(function* (input) {
   const service = yield* Service41;
   return yield* service.append(input);
 });
+var appendNext2 = Effect41.fn("EventLog.appendNext.call")(function* (input) {
+  const service = yield* Service41;
+  return yield* service.appendNext(input);
+});
 var appendIdempotent = Effect41.fn("EventLog.appendIdempotent.call")(function* (input) {
   const service = yield* Service41;
   return yield* appendIdempotentTo(service, input);
@@ -9978,7 +10116,7 @@ var createTimeoutSchedule = Effect42.fn("WaitService.createTimeoutSchedule")(fun
 var complete = Effect42.fn("WaitService.complete")(function* (repository, eventLog, input, event) {
   const result = yield* repository.completeWait(input).pipe(Effect42.mapError(mapRepositoryError2));
   if (result.transitioned) {
-    yield* eventLog.append(event(result.wait)).pipe(Effect42.mapError(mapEventLogError));
+    yield* appendIdempotentTo(eventLog, event(result.wait)).pipe(Effect42.mapError(mapEventLogError));
   }
   return result;
 });
@@ -9998,7 +10136,7 @@ var layer34 = Layer40.effect(Service42, Effect42.gen(function* () {
       }
       yield* repository.acceptEnvelope({ envelope: input.envelope, waitId: input.waitId }).pipe(Effect42.mapError((error5) => WaitServiceError.make({ message: error5.message })));
       const wait = yield* repository.getWait(input.waitId).pipe(Effect42.mapError((error5) => WaitServiceError.make({ message: error5.message })), Effect42.flatMap((record2) => record2 === undefined ? Effect42.fail(WaitServiceError.make({ message: `Wait ${input.waitId} was not persisted` })) : Effect42.succeed(record2)));
-      yield* eventLog.append(waitCreatedEvent(input, wait)).pipe(Effect42.mapError(mapEventLogError));
+      yield* appendIdempotentTo(eventLog, waitCreatedEvent(input, wait)).pipe(Effect42.mapError(mapEventLogError));
       if (input.envelope.wait.timeout !== undefined) {
         yield* createTimeoutSchedule(schedules, input.waitId, wait, input.envelope.wait.timeout);
       }
@@ -10018,7 +10156,7 @@ var layer34 = Layer40.effect(Service42, Effect42.gen(function* () {
         ...input.correlationKey === undefined ? {} : { correlationKey: input.correlationKey },
         ...input.metadata === undefined ? {} : { metadata: input.metadata }
       }).pipe(Effect42.mapError((error5) => WaitServiceError.make({ message: error5.message })));
-      yield* eventLog.append(waitCreatedEvent(input, wait)).pipe(Effect42.mapError(mapEventLogError));
+      yield* appendIdempotentTo(eventLog, waitCreatedEvent(input, wait)).pipe(Effect42.mapError(mapEventLogError));
       if (input.timeout !== undefined) {
         yield* createTimeoutSchedule(schedules, input.waitId, wait, input.timeout);
       }
@@ -10083,6 +10221,13 @@ var cancel3 = Effect42.fn("WaitService.cancel.call")(function* (input) {
   const service = yield* Service42;
   return yield* service.cancel(input);
 });
+// ../runtime/src/tool/tool-runtime-identifiers.ts
+var scopedPart = (value) => encodeURIComponent(value);
+var toolScope = (executionId, toolCallId) => `${scopedPart(executionId)}:${scopedPart(toolCallId)}`;
+var eventId = (executionId, toolCallId, kind) => exports_ids_schema.EventId.make(`event:${toolScope(executionId, toolCallId)}:${kind}`);
+var waitId = (kind, executionId, toolCallId) => exports_ids_schema.WaitId.make(`wait:${kind}:${toolScope(executionId, toolCallId)}`);
+var Identifiers = { eventId, waitId };
+
 // ../runtime/src/tool/tool-runtime-service.ts
 var permissionNames = (permissions) => HashSet3.fromIterable(permissions.map((permission) => permission.name));
 var requiredPermissionNames = (tool) => tool.requiredPermissions ?? tool.definition.permissions.map((permission) => permission.name);
@@ -10117,7 +10262,7 @@ var preserveToolError = (toolName, error5) => {
 };
 var preserveRecordResultError = (error5) => error5._tag === "ToolRuntimeError" ? error5 : mapRepositoryError3(error5);
 var requestedEvent = (input) => ({
-  id: exports_ids_schema.EventId.make(`event:${input.call.id}:tool-requested`),
+  id: Identifiers.eventId(input.executionId, input.call.id, "tool-requested"),
   execution_id: input.executionId,
   type: "tool.call.requested",
   sequence: input.eventSequence,
@@ -10129,13 +10274,19 @@ 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.canonicalEquals(left.data ?? {}, right.data ?? {});
-var ensureToolEvent = (eventLog, event) => eventLog.findByCursor({ executionId: event.execution_id, cursor: event.cursor }).pipe(Effect43.mapError(mapEventLogError2), Effect43.flatMap(Option8.match({
-  onNone: () => appendIdempotentTo(eventLog, event).pipe(Effect43.mapError(mapEventLogError2), Effect43.asVoid),
-  onSome: (existing) => sameToolEventPayload(existing, event) ? Effect43.void : Effect43.fail(ToolRuntimeError.make({ message: "EventLogError" }))
-})));
+var ensureToolEvent = (eventLog, event) => eventLog.appendNext({
+  id: event.id,
+  execution_id: event.execution_id,
+  ...event.child_execution_id === undefined ? {} : { child_execution_id: event.child_execution_id },
+  type: event.type,
+  cursor: event.cursor,
+  ...event.content === undefined ? {} : { content: event.content },
+  ...event.data === undefined ? {} : { data: event.data },
+  created_at: event.created_at,
+  minimumSequence: event.sequence
+}).pipe(Effect43.mapError(mapEventLogError2), Effect43.asVoid);
 var resultEvent = (input, result, sequence) => ({
-  id: exports_ids_schema.EventId.make(`event:${input.call.id}:tool-result`),
+  id: Identifiers.eventId(input.executionId, input.call.id, "tool-result"),
   execution_id: input.executionId,
   type: "tool.result.received",
   sequence,
@@ -10204,11 +10355,11 @@ var finalToolResult = (tool, input, idempotencyKey) => Effect43.gen(function* ()
     output: jsonValue2(output)
   };
 });
-var approvalWaitId = (input) => exports_ids_schema.WaitId.make(`wait:approval:${input.call.id}`);
-var permissionWaitId = (input) => exports_ids_schema.WaitId.make(`wait:permission:${input.call.id}`);
+var approvalWaitId = (input) => Identifiers.waitId("approval", input.executionId, input.call.id);
+var permissionWaitId = (input) => Identifiers.waitId("permission", input.executionId, input.call.id);
 var mapWaitServiceError = (error5) => ToolRuntimeError.make({ message: error5.message });
-var approvalRequestedEvent = (input, waitId) => ({
-  id: exports_ids_schema.EventId.make(`event:${input.call.id}:approval-requested`),
+var approvalRequestedEvent = (input, waitId2) => ({
+  id: Identifiers.eventId(input.executionId, input.call.id, "approval-requested"),
   execution_id: input.executionId,
   type: "tool.approval.requested",
   sequence: input.eventSequence + 2,
@@ -10216,13 +10367,13 @@ var approvalRequestedEvent = (input, waitId) => ({
   data: {
     tool_call_id: input.call.id,
     tool_name: input.call.name,
-    wait_id: waitId,
+    wait_id: waitId2,
     input: input.call.input
   },
   created_at: input.createdAt + 2
 });
 var approvalResolvedEvent = (input, wait, approved) => ({
-  id: exports_ids_schema.EventId.make(`event:${input.call.id}:approval-resolved`),
+  id: Identifiers.eventId(input.executionId, input.call.id, "approval-resolved"),
   execution_id: input.executionId,
   type: "tool.approval.resolved",
   sequence: input.eventSequence + 1,
@@ -10237,14 +10388,14 @@ var approvalResolvedEvent = (input, wait, approved) => ({
   created_at: input.createdAt + 1
 });
 var deniedReason = (state) => state === "timed_out" ? "Tool approval timed out" : state === "cancelled" ? "Tool approval cancelled" : "Tool approval denied";
-var waitRequested = (input, waitId) => Effect43.fail(ToolExecutionWaitRequested.make({ tool_name: input.call.name, wait_id: waitId }));
+var waitRequested = (input, waitId2) => Effect43.fail(ToolExecutionWaitRequested.make({ tool_name: input.call.name, wait_id: waitId2 }));
 var hasPermissionApprovalBypass = (waits, input) => waits.get(permissionWaitId(input)).pipe(Effect43.mapError(mapWaitServiceError), Effect43.map((wait) => wait !== undefined && wait.state === "resolved" && wait.metadata.kind === "tool-permission" && wait.metadata.tool_call_id === input.call.id && wait.metadata.tool_name === input.call.name && (wait.metadata.answer === "Approved" || wait.metadata.answer === "Always")));
 var resolveApproval = (waits, eventLog, input) => Effect43.gen(function* () {
-  const waitId = approvalWaitId(input);
-  const existing = yield* waits.get(waitId).pipe(Effect43.mapError(mapWaitServiceError));
+  const waitId2 = approvalWaitId(input);
+  const existing = yield* waits.get(waitId2).pipe(Effect43.mapError(mapWaitServiceError));
   if (existing === undefined) {
     yield* waits.createDetached({
-      waitId,
+      waitId: waitId2,
       executionId: input.executionId,
       mode: "event",
       correlationKey: input.call.id,
@@ -10257,11 +10408,12 @@ var resolveApproval = (waits, eventLog, input) => Effect43.gen(function* () {
       eventSequence: input.eventSequence + 1,
       createdAt: input.createdAt
     }).pipe(Effect43.mapError(mapWaitServiceError));
-    yield* appendIdempotentTo(eventLog, approvalRequestedEvent(input, waitId)).pipe(Effect43.mapError(mapEventLogError2));
-    return yield* waitRequested(input, waitId);
+    yield* appendIdempotentTo(eventLog, approvalRequestedEvent(input, waitId2)).pipe(Effect43.mapError(mapEventLogError2));
+    return yield* waitRequested(input, waitId2);
   }
   if (existing.state === "open") {
-    return yield* waitRequested(input, waitId);
+    yield* appendIdempotentTo(eventLog, approvalRequestedEvent({ ...input, createdAt: existing.createdAt }, waitId2)).pipe(Effect43.mapError(mapEventLogError2));
+    return yield* waitRequested(input, waitId2);
   }
   const approved = existing.state === "resolved" && existing.metadata.approved === true;
   yield* appendIdempotentTo(eventLog, approvalResolvedEvent(input, existing, approved)).pipe(Effect43.mapError(mapEventLogError2));
@@ -10276,8 +10428,9 @@ var recordRequested = (repository, eventLog, input, tool) => repository.ensureCa
   placement: tool.placement ?? { kind: "local" },
   createdAt: input.createdAt
 }).pipe(Effect43.mapError(mapRepositoryError3), Effect43.tap((call) => ensureToolEvent(eventLog, requestedEvent({ ...input, createdAt: call.createdAt }))));
-var repairResultEvent = (eventLog, input, record2) => eventLog.maxSequence(input.executionId).pipe(Effect43.mapError(mapEventLogError2), Effect43.flatMap((max) => ensureToolEvent(eventLog, resultEvent({ ...input, createdAt: record2.createdAt - 1 }, record2.result, (max ?? input.eventSequence) + 1))));
-var recordReceived = (repository, eventLog, input, result) => repository.recordResult({ executionId: input.executionId, result, createdAt: input.createdAt + 1 }).pipe(Effect43.catchTag("DuplicateToolResult", () => repository.getResult(input.executionId, result.call_id).pipe(Effect43.mapError(mapRepositoryError3), Effect43.flatMap((existing) => existing === undefined ? Effect43.fail(ToolRuntimeError.make({ message: "DuplicateToolResult" })) : Effect43.succeed(existing)))), Effect43.mapError(preserveRecordResultError), Effect43.flatMap((record2) => eventLog.maxSequence(input.executionId).pipe(Effect43.mapError(mapEventLogError2), Effect43.flatMap((max) => appendIdempotentTo(eventLog, resultEvent(input, record2.result, (max ?? input.eventSequence) + 1)).pipe(Effect43.mapError(mapEventLogError2))), Effect43.as(record2.result))));
+var repairResultEvent = (eventLog, input, record2) => ensureToolEvent(eventLog, resultEvent({ ...input, createdAt: record2.createdAt - 1 }, record2.result, input.eventSequence + 1));
+var persistReceived = (repository, input, result) => repository.recordResult({ executionId: input.executionId, result, createdAt: input.createdAt + 1 }).pipe(Effect43.catchTag("DuplicateToolResult", () => repository.getResult(input.executionId, result.call_id).pipe(Effect43.mapError(mapRepositoryError3), Effect43.flatMap((existing) => existing === undefined ? Effect43.fail(ToolRuntimeError.make({ message: "DuplicateToolResult" })) : Effect43.succeed(existing)))), Effect43.mapError(preserveRecordResultError));
+var recordReceived = (eventLog, input, record2) => ensureToolEvent(eventLog, resultEvent({ ...input, createdAt: record2.createdAt - 1 }, record2.result, input.eventSequence + 1)).pipe(Effect43.as(record2.result));
 var nonEmptyName = (name) => Schema40.decodeUnknownSync(exports_shared_schema.NonEmptyString)(name);
 var needsApprovalFromEffectTool = (tool) => tool.needsApproval === undefined ? undefined : typeof tool.needsApproval === "boolean" ? tool.needsApproval : true;
 var definitionFromEffectTool = (modelTool, options) => ({
@@ -10356,7 +10509,7 @@ var placedTool = (modelTool, placement, options = {}) => ({
 });
 var clientTool = Function7.dual((args) => args.length > 1 || args.length === 1 && typeof args[0] === "object" && args[0] !== null && ("name" in args[0]), (modelTool, options = {}) => placedTool(modelTool, { kind: "client" }, options));
 var remoteTool = Function7.dual(2, (modelTool, options) => placedTool(modelTool, { kind: "remote", queue: options.queue }, options));
-var placementWaitId = (input) => exports_ids_schema.WaitId.make(`wait:tool:${input.call.id}`);
+var placementWaitId = (input) => Identifiers.waitId("tool", input.executionId, input.call.id);
 var placementFailureResult = (input, message) => ({
   call_id: input.call.id,
   output: null,
@@ -10376,11 +10529,11 @@ var externalOutcomeResult = (call, input) => {
   return Schema40.decodeUnknownEffect(exports_tool_schema.resultSchema(call.definition.output_schema))(call.externalOutcome.output).pipe(Effect43.map((output) => ({ call_id: input.call.id, output: jsonValue2(output) })), Effect43.catch((error5) => Effect43.succeed(placementFailureResult(input, `invalid ${placement} result: ${error5.message}`))));
 };
 var runExternalTool = (repository, waits, call, input) => Effect43.gen(function* () {
-  const waitId = placementWaitId(input);
-  let wait = yield* waits.get(waitId).pipe(Effect43.mapError(mapWaitServiceError));
+  const waitId2 = placementWaitId(input);
+  let wait = yield* waits.get(waitId2).pipe(Effect43.mapError(mapWaitServiceError));
   if (wait === undefined) {
     wait = yield* waits.createDetached({
-      waitId,
+      waitId: waitId2,
       executionId: input.executionId,
       mode: "event",
       correlationKey: input.call.id,
@@ -10397,12 +10550,12 @@ var runExternalTool = (repository, waits, call, input) => Effect43.gen(function*
   const waitingCall = call.state === "requested" ? yield* repository.prepareExternalWait({
     executionId: input.executionId,
     callId: input.call.id,
-    waitId,
+    waitId: waitId2,
     availableAt: input.createdAt,
     updatedAt: input.createdAt
   }).pipe(Effect43.mapError(mapRepositoryError3)) : call;
   if (wait.state === "open")
-    return yield* waitRequested(input, waitId);
+    return yield* waitRequested(input, waitId2);
   if (wait.state === "timed_out")
     return placementFailureResult(input, "Tool execution timed out");
   if (wait.state === "cancelled")
@@ -10424,7 +10577,25 @@ var makeService = (initialTools) => Effect43.gen(function* () {
     register: Effect43.fn("ToolRuntime.register")((registeredTool) => registerTool(tools, registeredTool)),
     definitions: Ref11.get(tools).pipe(Effect43.map((registry) => Chunk.toReadonlyArray(Chunk.map(registry, (registeredTool) => registeredTool.definition)))),
     registeredTools: Ref11.get(tools).pipe(Effect43.map(Chunk.toReadonlyArray)),
+    prepare: Effect43.fn("ToolRuntime.prepare")(function* (input) {
+      const stored = yield* Ref11.get(tools);
+      const registry = (input.extraTools ?? []).reduce(upsertTool, stored);
+      const registeredTool = Chunk.findFirst(registry, sameToolName(input.call.name)).pipe(Option8.getOrUndefined);
+      if (registeredTool === undefined)
+        return yield* ToolNotRegistered.make({ tool_name: input.call.name });
+      yield* ensureAllowed(registeredTool, input);
+      yield* validateInput(registeredTool, input);
+      yield* recordRequested(repository, eventLog, input, registeredTool);
+      if (input.onRequested !== undefined)
+        yield* input.onRequested;
+    }),
     run: Effect43.fn("ToolRuntime.run")(function* (input) {
+      let settlementSequence;
+      const beginSettlement = Effect43.suspend(() => {
+        if (settlementSequence !== undefined)
+          return Effect43.succeed(settlementSequence);
+        return (input.beforeSettlement ?? Effect43.succeed(input.eventSequence)).pipe(Effect43.tap((sequence) => Effect43.sync(() => settlementSequence = sequence)));
+      });
       const stored = yield* Ref11.get(tools);
       const registry = (input.extraTools ?? []).reduce(upsertTool, stored);
       const registeredTool = Chunk.findFirst(registry, sameToolName(input.call.name)).pipe(Option8.getOrUndefined);
@@ -10435,8 +10606,11 @@ var makeService = (initialTools) => Effect43.gen(function* () {
         yield* ensureAllowed(registeredTool, input);
         yield* validateInput(registeredTool, input);
         const call = yield* recordRequested(repository, eventLog, input, registeredTool);
+        if (input.onRequested !== undefined)
+          yield* input.onRequested;
         const existingResult = yield* repository.getResult(input.executionId, input.call.id).pipe(Effect43.mapError(mapRepositoryError3));
         if (existingResult !== undefined) {
+          yield* beginSettlement;
           yield* repairResultEvent(eventLog, input, existingResult);
           return existingResult.result;
         }
@@ -10444,26 +10618,46 @@ var makeService = (initialTools) => Effect43.gen(function* () {
         if (registeredTool.definition.needs_approval === true) {
           const bypass = yield* hasPermissionApprovalBypass(waits, input);
           if (!bypass) {
-            const decision = yield* resolveApproval(waits, eventLog, input);
-            effectiveInput = { ...input, eventSequence: input.eventSequence + 2, createdAt: input.createdAt + 2 };
+            const sequence = yield* beginSettlement;
+            effectiveInput = {
+              ...input,
+              eventSequence: sequence,
+              createdAt: input.createdAt + sequence - input.eventSequence
+            };
+            const decision = yield* resolveApproval(waits, eventLog, effectiveInput);
+            effectiveInput = {
+              ...effectiveInput,
+              eventSequence: effectiveInput.eventSequence + 1,
+              createdAt: effectiveInput.createdAt + 1
+            };
             if (decision._tag === "denied") {
-              const denied = yield* recordReceived(repository, eventLog, effectiveInput, {
+              const deniedRecord = yield* persistReceived(repository, effectiveInput, {
                 call_id: input.call.id,
                 output: null,
                 error: decision.reason
               });
+              const denied = yield* recordReceived(eventLog, effectiveInput, deniedRecord);
               yield* recordToolCall(input.call.name, "denied");
               return denied;
             }
           }
         }
-        const rawResult = call.placement.kind === "client" || call.placement.kind === "remote" ? yield* runExternalTool(repository, waits, call, effectiveInput) : yield* repository.beginAttempt({
+        const executeHandler = call.placement.kind === "client" || call.placement.kind === "remote" ? runExternalTool(repository, waits, call, effectiveInput) : repository.beginAttempt({
           executionId: input.executionId,
           callId: input.call.id,
           startedAt: effectiveInput.createdAt
         }).pipe(Effect43.mapError(mapRepositoryError3), Effect43.flatMap(() => finalToolResult(registeredTool, effectiveInput, call.idempotencyKey)), Effect43.catchTag("ToolExecutionFailed", (error5) => Effect43.succeed(placementFailureResult(input, error5.message))));
-        const result = input.transformResult === undefined || rawResult.error !== undefined ? rawResult : yield* input.transformResult(rawResult);
-        const received = yield* recordReceived(repository, eventLog, effectiveInput, result);
+        const record2 = yield* Effect43.uninterruptibleMask((restore) => restore(executeHandler).pipe(Effect43.flatMap((rawResult) => input.transformResult === undefined || rawResult.error !== undefined ? Effect43.succeed(rawResult) : input.transformResult(rawResult)), Effect43.flatMap((result2) => persistReceived(repository, effectiveInput, result2))));
+        const result = record2.result;
+        if (effectiveInput === input) {
+          const sequence = yield* beginSettlement;
+          effectiveInput = {
+            ...input,
+            eventSequence: sequence,
+            createdAt: input.createdAt + sequence - input.eventSequence
+          };
+        }
+        const received = yield* recordReceived(eventLog, effectiveInput, record2);
         yield* recordToolCall(input.call.name, result.error === undefined ? "success" : "failure");
         return received;
       }).pipe(Effect43.tapError((error5) => recordToolCall(input.call.name, error5._tag === "ToolExecutionWaitRequested" ? "wait" : error5._tag === "ToolPermissionDenied" ? "denied" : "failure")));
@@ -11462,10 +11656,10 @@ var presetMap = (agent) => new Map(Object.entries(agent.child_run_presets ?? {})
     ...preset.metadata === undefined ? {} : { metadata: preset.metadata }
   }
 ]));
-var createJoinWait = Effect52.fn("SpawnChildRunTool.createJoinWait")(function* (config, input, id, waitId, createdAt) {
+var createJoinWait = Effect52.fn("SpawnChildRunTool.createJoinWait")(function* (config, input, id, waitId2, createdAt) {
   const eventSequence = yield* nextEventSequence(config.eventLog, input.execution_id);
   yield* config.waits.createDetached({
-    waitId,
+    waitId: waitId2,
     executionId: input.execution_id,
     mode: "child",
     correlationKey: id,
@@ -11477,7 +11671,7 @@ var createJoinWait = Effect52.fn("SpawnChildRunTool.createJoinWait")(function* (
     createdAt
   }).pipe(Effect52.mapError(mapWaitError));
 });
-var dispatchChild = Effect52.fn("SpawnChildRunTool.dispatchChild")(function* (config, input, id, definition, waitId) {
+var dispatchChild = Effect52.fn("SpawnChildRunTool.dispatchChild")(function* (config, input, id, definition, waitId2) {
   yield* config.dispatch({
     executionId: exports_ids_schema.ExecutionId.make(id),
     rootAddressId: input.address_id,
@@ -11493,7 +11687,7 @@ var dispatchChild = Effect52.fn("SpawnChildRunTool.dispatchChild")(function* (co
     metadata: {
       parent_execution_id: input.execution_id,
       child_execution_id: id,
-      parent_wait_id: waitId
+      parent_wait_id: waitId2
     }
   }).pipe(Effect52.mapError((error5) => ToolRuntimeError.make({ message: String(error5) })));
 });
@@ -11517,10 +11711,10 @@ var run3 = Effect52.fn("SpawnChildRunTool.run")(function* (config, activeToolNam
   if (enforceStaticOrDynamic)
     yield* ensureStaticOrDynamic(input);
   const id = childExecutionId(context);
-  const waitId = childWaitId(id);
-  const existingWait = yield* config.waits.get(waitId).pipe(Effect52.mapError(mapWaitError));
+  const waitId2 = childWaitId(id);
+  const existingWait = yield* config.waits.get(waitId2).pipe(Effect52.mapError(mapWaitError));
   if (existingWait?.state === "open") {
-    return yield* ToolExecutionWaitRequested.make({ tool_name: activeToolName, wait_id: waitId });
+    return yield* ToolExecutionWaitRequested.make({ tool_name: activeToolName, wait_id: waitId2 });
   }
   if (existingWait !== undefined)
     return yield* resultFromTerminal(config, id, existingWait);
@@ -11550,9 +11744,9 @@ var run3 = Effect52.fn("SpawnChildRunTool.run")(function* (config, activeToolNam
       createdAt: context.createdAt + 1
     }).pipe(Effect52.mapError((error5) => mapChildRunError(activeToolName, error5)));
   }
-  yield* createJoinWait(config, spawn, id, waitId, context.createdAt + 2);
-  yield* dispatchChild(config, spawn, id, definition, waitId);
-  return yield* ToolExecutionWaitRequested.make({ tool_name: activeToolName, wait_id: waitId });
+  yield* createJoinWait(config, spawn, id, waitId2, context.createdAt + 2);
+  yield* dispatchChild(config, spawn, id, definition, waitId2);
+  return yield* ToolExecutionWaitRequested.make({ tool_name: activeToolName, wait_id: waitId2 });
 });
 var registeredTool = (config) => tool(toolName, {
   description: "Spawn a durable child run and wait for its terminal output.",
@@ -11904,7 +12098,7 @@ var registeredTools2 = (state) => [
 ];
 
 // ../runtime/src/session/session-store-service.ts
-import { Clock as Clock9, Context as Context51, Effect as Effect57, Function as Function12, Layer as Layer52, Ref as Ref13, Semaphore as Semaphore4 } from "effect";
+import { Clock as Clock9, Context as Context51, Effect as Effect57, Function as Function12, Layer as Layer52, Ref as Ref13, Semaphore as Semaphore5 } from "effect";
 
 class Service51 extends Context51.Service()("@relayfx/runtime/session/session-store-service/Service") {
 }
@@ -12046,7 +12240,7 @@ var toAppendInput = (input) => {
 var make4 = Effect57.fn("RelaySessionStore.make")(function* (sessionId, entryScope = "default", makeOptions) {
   const repository = yield* exports_session_repository.Service;
   const state = yield* Ref13.make(undefined);
-  const lock = yield* Semaphore4.make(1);
+  const lock = yield* Semaphore5.make(1);
   const entryPrefix = `${sessionId}:entry:${entryScope}:`;
   const initialState = Effect57.fn("RelaySessionStore.initialState")(function* (input) {
     const current2 = yield* Ref13.get(state);
@@ -13022,13 +13216,13 @@ var layer47 = Layer58.effect(Service57, Effect63.gen(function* () {
 }));
 
 // ../runtime/src/tool/tool-transition-coordinator.ts
-import { Context as Context58, Effect as Effect64, Layer as Layer59, Semaphore as Semaphore5 } from "effect";
+import { Context as Context58, Effect as Effect64, Layer as Layer59, Semaphore as Semaphore6 } from "effect";
 import { SqlClient as SqlClient29 } from "effect/unstable/sql/SqlClient";
 
 class Service58 extends Context58.Service()("@relayfx/runtime/tool/tool-transition-coordinator/Service") {
 }
 var make6 = Effect64.gen(function* () {
-  const semaphore = yield* Semaphore5.make(1);
+  const semaphore = yield* Semaphore6.make(1);
   return Service58.of({
     coordinate: (effect) => semaphore.withPermit(effect)
   });
@@ -13036,7 +13230,7 @@ var make6 = Effect64.gen(function* () {
 var memoryLayer41 = Layer59.effect(Service58, make6);
 var sqlLayer = Layer59.effect(Service58, Effect64.gen(function* () {
   const sql = yield* SqlClient29;
-  const semaphore = yield* Semaphore5.make(1);
+  const semaphore = yield* Semaphore6.make(1);
   return Service58.of({
     coordinate: (effect) => semaphore.withPermit(sql.withTransaction(effect))
   });
@@ -13353,9 +13547,9 @@ var ActivityNames = {
   accept: `${StartExecutionWorkflowName}/Accept`,
   cancel: (turn) => `${StartExecutionWorkflowName}/Cancel/${turn}`,
   checkCancel: (turn) => `${StartExecutionWorkflowName}/CheckCancel/${turn}`,
-  loadWaitBeforeSleep: (waitId) => `${StartExecutionWorkflowName}/LoadWaitBeforeSleep/${waitId}`,
-  loadWaitAfterWake: (waitId) => `${StartExecutionWorkflowName}/LoadWaitAfterWake/${waitId}`,
-  markWaiting: (waitId) => `${StartExecutionWorkflowName}/MarkWaiting/${waitId}`,
+  loadWaitBeforeSleep: (waitId2) => `${StartExecutionWorkflowName}/LoadWaitBeforeSleep/${waitId2}`,
+  loadWaitAfterWake: (waitId2) => `${StartExecutionWorkflowName}/LoadWaitAfterWake/${waitId2}`,
+  markWaiting: (waitId2) => `${StartExecutionWorkflowName}/MarkWaiting/${waitId2}`,
   ensureWorkspace: `${StartExecutionWorkflowName}/EnsureWorkspace`,
   suspendWorkspace: (key4) => `${StartExecutionWorkflowName}/SuspendWorkspace/${key4}`,
   resumeWorkspace: (key4) => `${StartExecutionWorkflowName}/ResumeWorkspace/${key4}`,
@@ -13410,7 +13604,7 @@ var mapChildExecutionRepositoryError = (error5) => ExecutionWorkflowFailed.make(
 var mapSkillRegistryError = (error5) => ExecutionWorkflowFailed.make({ message: error5.message });
 var mapEventLogError6 = (error5) => ExecutionWorkflowFailed.make({ message: error5._tag });
 var mapWorkspaceError = (error5) => ExecutionWorkflowFailed.make({ message: error5._tag });
-var waitSignal = (waitId) => DurableDeferred.make(`Relay/Execution/Wait/${waitId}`, {
+var waitSignal = (waitId2) => DurableDeferred.make(`Relay/Execution/Wait/${waitId2}`, {
   success: WaitSignal,
   error: ExecutionWorkflowFailed
 });
@@ -13484,8 +13678,8 @@ var acceptExecution = (input) => Activity.make({
 });
 var terminalExecutionStatuses = new Set(["completed", "failed", "cancelled"]);
 var waitIdFromRecord = (record2) => {
-  const waitId = record2.metadata.wait_id;
-  return typeof waitId === "string" ? exports_ids_schema.WaitId.make(waitId) : undefined;
+  const waitId2 = record2.metadata.wait_id;
+  return typeof waitId2 === "string" ? exports_ids_schema.WaitId.make(waitId2) : undefined;
 };
 var prepareCancellation = Effect67.fn("ExecutionWorkflow.prepareCancellation")(function* (input) {
   const repository = yield* exports_execution_repository.Service;
@@ -13633,11 +13827,11 @@ var loadCancellationRequested = (input, turn) => Activity.make({
     return record2?.metadata?.cancellation_requested === true;
   })
 });
-var loadWait = (name, waitId) => Activity.make({
+var loadWait = (name, waitId2) => Activity.make({
   name,
   success: Schema61.UndefinedOr(WaitSnapshot),
   error: ExecutionWorkflowFailed,
-  execute: get11(waitId).pipe(Effect67.map((record2) => record2 === undefined ? undefined : toWaitSnapshot(record2)), Effect67.mapError(mapWaitError2))
+  execute: get11(waitId2).pipe(Effect67.map((record2) => record2 === undefined ? undefined : toWaitSnapshot(record2)), Effect67.mapError(mapWaitError2))
 });
 var markWaiting = (input, repository, wait) => Activity.make({
   name: ActivityNames.markWaiting(wait.id),
@@ -13757,7 +13951,7 @@ var failWorkspace = (input, error5) => fail({
 }).pipe(Effect67.catch(() => Effect67.void));
 var attachWorkspace = (input) => attach({ executionId: input.execution_id, now: input.started_at }).pipe(Effect67.mapError(mapWorkspaceError));
 var sessionEntryScope = Function13.dual(2, (input, turn) => `${input.execution_id}:${workflowGenerationForStart(input)}:complete:${turn}`);
-var completeExecution = (input, waitId, waitState, workspaceRuntimeLayer, turn, pendingSuspension) => Activity.make({
+var completeExecution = (input, waitId2, waitState, workspaceRuntimeLayer, turn, pendingSuspension) => Activity.make({
   name: ActivityNames.complete(turn),
   success: exports_execution_schema.Execution,
   error: ExecutionWorkflowFailed,
@@ -13811,8 +14005,8 @@ var completeExecution = (input, waitId, waitState, workspaceRuntimeLayer, turn,
     const program = activeProgram.pipe(Effect67.map((result) => ({
       metadata: {
         ...result.metadata,
-        ...waitId === undefined ? {} : { wait_id: waitId },
-        ...waitId === undefined || waitState === undefined ? {} : { wait_state: waitState }
+        ...waitId2 === undefined ? {} : { wait_id: waitId2 },
+        ...waitId2 === undefined || waitState === undefined ? {} : { wait_state: waitState }
       },
       nextEventSequence: result.nextEventSequence
     })), Effect67.catchTag("AgentLoopWaitRequested", (wait) => Effect67.succeed({
@@ -13906,8 +14100,8 @@ var terminalOutput = (execution) => {
   const output = execution.metadata?.model_output;
   return typeof output === "string" ? [exports_content_schema.text(output)] : [];
 };
-var missingWait = (waitId) => ExecutionWorkflowFailed.make({ message: `Wait not found: ${waitId}` });
-var stillOpen = (waitId) => ExecutionWorkflowFailed.make({ message: `Wait remained open after wake: ${waitId}` });
+var missingWait = (waitId2) => ExecutionWorkflowFailed.make({ message: `Wait not found: ${waitId2}` });
+var stillOpen = (waitId2) => ExecutionWorkflowFailed.make({ message: `Wait remained open after wake: ${waitId2}` });
 var resolveWaitState = Effect67.fn("ExecutionWorkflow.resolveWaitState")(function* (input, repository) {
   if (input.wait_id === undefined)
     return;
@@ -13930,32 +14124,32 @@ var resolveWaitState = Effect67.fn("ExecutionWorkflow.resolveWaitState")(functio
   return afterTerminal;
 });
 var waitIdFromExecution = (execution) => {
-  const waitId = execution.metadata?.wait_id;
-  return typeof waitId === "string" ? exports_ids_schema.WaitId.make(waitId) : undefined;
+  const waitId2 = execution.metadata?.wait_id;
+  return typeof waitId2 === "string" ? exports_ids_schema.WaitId.make(waitId2) : undefined;
 };
 var pendingSuspensionFromExecution = (execution) => {
   const pending = execution.metadata?.pending_agent_suspension;
   return Schema61.decodeUnknownOption(exports_agent_event.AgentSuspended)(pending).pipe(Option15.getOrUndefined);
 };
-var finishCancelledWait = Effect67.fn("ExecutionWorkflow.finishCancelledWait")(function* (startInput, turn, waitId) {
+var finishCancelledWait = Effect67.fn("ExecutionWorkflow.finishCancelledWait")(function* (startInput, turn, waitId2) {
   const cancelled = yield* cancelExecution(startInput, turn, "wait cancelled");
   yield* releaseWorkspace(startInput);
   yield* notifyParent(startInput, "cancelled", []);
   return {
     execution_id: cancelled.id,
     status: cancelled.status,
-    wait_id: waitId,
+    wait_id: waitId2,
     wait_state: "cancelled",
     ...cancelled.metadata === undefined ? {} : { metadata: cancelled.metadata }
   };
 });
-var continueAsNew = (startInput, turn, waitId, pendingSuspension) => Activity.make({
+var continueAsNew = (startInput, turn, waitId2, pendingSuspension) => Activity.make({
   name: ActivityNames.continueAsNew(turn),
   success: StartResult,
   error: ExecutionWorkflowError,
   execute: StartExecutionWorkflow.execute({
     ...startInput,
-    wait_id: waitId,
+    wait_id: waitId2,
     resume_suspension: pendingSuspension,
     workflow_generation: workflowGenerationForStart(startInput) + 1
   })
@@ -14016,8 +14210,8 @@ var runWorkflow = Effect67.fn("ExecutionWorkflow.run")(function* (input) {
         break;
       if (turn >= maxWaitTurns)
         return yield* ExecutionWorkflowFailed.make({ message: "Agent wait turn limit exceeded" });
-      const waitId = waitIdFromExecution(execution);
-      if (waitId === undefined)
+      const waitId2 = waitIdFromExecution(execution);
+      if (waitId2 === undefined)
         return yield* ExecutionWorkflowFailed.make({ message: "Waiting execution missing wait id" });
       pendingSuspension = pendingSuspensionFromExecution(execution);
       if (pendingSuspension === undefined) {
@@ -14027,14 +14221,14 @@ var runWorkflow = Effect67.fn("ExecutionWorkflow.run")(function* (input) {
         yield* failIncompatibleCheckpoint(startInput, error5);
         return yield* error5;
       }
-      activeWaitId = waitId;
-      waitState = yield* resolveWaitState({ ...startInput, wait_id: waitId }, repository);
+      activeWaitId = waitId2;
+      waitState = yield* resolveWaitState({ ...startInput, wait_id: waitId2 }, repository);
       if (waitState === "cancelled") {
-        return yield* finishCancelledWait(startInput, turn + 1, waitId);
+        return yield* finishCancelledWait(startInput, turn + 1, waitId2);
       }
       turn += 1;
       if (continueAsNewAfterTurns !== undefined && turn >= continueAsNewAfterTurns) {
-        return yield* continueAsNew(startInput, turn, waitId, pendingSuspension);
+        return yield* continueAsNew(startInput, turn, waitId2, pendingSuspension);
       }
     }
     yield* releaseWorkspace(startInput);
@@ -14053,11 +14247,11 @@ var awaitCanonicalSettledResult = Effect67.fn("ExecutionWorkflow.awaitCanonicalS
     until: (record2) => record2?.status === "waiting" || record2 !== undefined && terminalExecutionStatuses.has(record2.status)
   }));
   const canonicalWaitId = execution?.metadata?.wait_id;
-  const waitId = typeof canonicalWaitId === "string" ? exports_ids_schema.WaitId.make(canonicalWaitId) : input.wait_id;
+  const waitId2 = typeof canonicalWaitId === "string" ? exports_ids_schema.WaitId.make(canonicalWaitId) : input.wait_id;
   const result = {
     execution_id: input.execution_id,
     status: execution?.status ?? "waiting",
-    ...waitId === undefined ? {} : { wait_id: waitId },
+    ...waitId2 === undefined ? {} : { wait_id: waitId2 },
     ...execution?.metadata === undefined ? {} : { metadata: execution.metadata }
   };
   return result;
@@ -14095,14 +14289,14 @@ var startRequest = Effect67.fn("ExecutionWorkflow.startRequest")(function* (inpu
     }
     const workflowExecutionId2 = yield* activeWorkflowExecutionIdForExecution(input.execution_id);
     const existingWaitId = existing.metadata?.wait_id;
-    const waitId = typeof existingWaitId === "string" ? exports_ids_schema.WaitId.make(existingWaitId) : undefined;
-    if (existing.status === "waiting" && waitId !== undefined) {
-      const wait = yield* get11(waitId).pipe(Effect67.mapError(mapWaitError2));
+    const waitId2 = typeof existingWaitId === "string" ? exports_ids_schema.WaitId.make(existingWaitId) : undefined;
+    if (existing.status === "waiting" && waitId2 !== undefined) {
+      const wait = yield* get11(waitId2).pipe(Effect67.mapError(mapWaitError2));
       const state = wait === undefined ? undefined : terminalWaitState(toWaitSnapshot(wait));
       if (state !== undefined) {
         yield* signalWait({
           workflow_execution_id: workflowExecutionId2,
-          wait_id: waitId,
+          wait_id: waitId2,
           state,
           signaled_at: wait?.resolvedAt ?? input.started_at
         });
@@ -14241,9 +14435,9 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service62, Effect69.gen(f
       const findOpenByCorrelation = envelopes.findOpenByCorrelation;
       const wait = findOpenByCorrelation === undefined ? undefined : yield* findOpenByCorrelation(input.executionId, `inbox:${input.executionId}`).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: input.executionId, message: error5.message })));
       if (wait?.state === "open") {
-        const waitId = wait.id;
+        const waitId2 = wait.id;
         const sequence = yield* nextSequence(eventLog, input.executionId).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: input.executionId, message: error5._tag })));
-        const transition3 = yield* waits.wake({ waitId, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({
+        const transition3 = yield* waits.wake({ waitId: waitId2, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({
           execution_id: input.executionId,
           message: error5._tag === "WaitNotFound" ? error5.wait_id : error5.message
         })));
@@ -14269,14 +14463,14 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service62, Effect69.gen(f
     }),
     undrainedCount: (id) => repository.countUndrained(id).pipe(Effect69.mapError((error5) => InboxServiceError.make({ message: error5.message }))),
     reply: Effect69.fn("InboxService.reply")(function* (input) {
-      const waitId = exports_ids_schema.WaitId.make(input.replyToken);
-      const wait = yield* waits.get(waitId).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
+      const waitId2 = exports_ids_schema.WaitId.make(input.replyToken);
+      const wait = yield* waits.get(waitId2).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
       if (wait === undefined || wait.state !== "open" || wait.envelopeId === undefined)
         return yield* InboxReplyTokenInvalid.make({ reply_token: input.replyToken });
       const original = yield* envelopes.getEnvelope(wait.envelopeId).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
       if (original === undefined)
         return yield* InboxReplyTokenInvalid.make({ reply_token: input.replyToken });
-      const envelopeId = exports_ids_schema.EnvelopeId.make(`envelope:reply:${waitId}`);
+      const envelopeId = exports_ids_schema.EnvelopeId.make(`envelope:reply:${waitId2}`);
       yield* envelopes.acceptEnvelope({
         envelope: {
           id: envelopeId,
@@ -14289,7 +14483,7 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service62, Effect69.gen(f
         }
       }).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: wait.executionId, message: error5.message })));
       const sequence = yield* nextSequence(eventLog, wait.executionId).pipe(Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: wait.executionId, message: error5._tag })));
-      const transition3 = yield* waits.wake({ waitId, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
+      const transition3 = yield* waits.wake({ waitId: waitId2, resolvedAt: input.createdAt, eventSequence: sequence }).pipe(Effect69.mapError(() => InboxReplyTokenInvalid.make({ reply_token: input.replyToken })));
       if (!transition3.transitioned)
         return yield* InboxReplyTokenInvalid.make({ reply_token: input.replyToken });
       if (signalDependencies !== undefined) {
@@ -14301,7 +14495,7 @@ var makeLayer = (signalDependencies) => Layer63.effect(Service62, Effect69.gen(f
           signaledAt: input.createdAt
         }).pipe(Effect69.provideService(exports_execution_repository.Service, signalDependencies.executionRepository), Effect69.mapError((error5) => InboxDeliveryError.make({ execution_id: wait.executionId, message: String(error5) })));
       }
-      return { envelope_id: envelopeId, execution_id: wait.executionId, wait_id: waitId };
+      return { envelope_id: envelopeId, execution_id: wait.executionId, wait_id: waitId2 };
     })
   });
 }));
@@ -14454,8 +14648,8 @@ var registeredTool4 = (config) => tool(toolName4, {
   requiredPermissions: [permissionName4],
   metadata: { relay_core_tool: true },
   run: (input, context) => Effect72.gen(function* () {
-    const waitId = exports_ids_schema.WaitId.make(`wait:inbox:${context.call.id}`);
-    const existing = yield* config.waits.get(waitId).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
+    const waitId2 = exports_ids_schema.WaitId.make(`wait:inbox:${context.call.id}`);
+    const existing = yield* config.waits.get(waitId2).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
     const drain2 = () => config.inbox.drain({ executionId: context.executionId, drainId: context.call.id }).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
     if (existing?.state === "timed_out")
       return { status: "timed_out", messages: [] };
@@ -14464,7 +14658,7 @@ var registeredTool4 = (config) => tool(toolName4, {
       return { status: "messages", messages: drained.map(project) };
     }
     if (existing?.state === "open")
-      return yield* ToolExecutionWaitRequested.make({ tool_name: toolName4, wait_id: waitId });
+      return yield* ToolExecutionWaitRequested.make({ tool_name: toolName4, wait_id: waitId2 });
     const count = yield* config.inbox.undrainedCount(context.executionId).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
     if (count > 0) {
       const drained = yield* drain2();
@@ -14472,7 +14666,7 @@ var registeredTool4 = (config) => tool(toolName4, {
     }
     if (existing === undefined)
       yield* config.waits.createDetached({
-        waitId,
+        waitId: waitId2,
         executionId: context.executionId,
         mode: "event",
         correlationKey: `inbox:${context.executionId}`,
@@ -14482,13 +14676,13 @@ var registeredTool4 = (config) => tool(toolName4, {
       }).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })));
     if ((yield* config.inbox.undrainedCount(context.executionId).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5.message })))) > 0) {
       const sequence = yield* config.eventLog.maxSequence(context.executionId).pipe(Effect72.map((value) => (value ?? -1) + 1), Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5._tag })));
-      const transition3 = yield* config.waits.wake({ waitId, resolvedAt: context.createdAt, eventSequence: sequence }).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5._tag })));
+      const transition3 = yield* config.waits.wake({ waitId: waitId2, resolvedAt: context.createdAt, eventSequence: sequence }).pipe(Effect72.mapError((error5) => ToolRuntimeError.make({ message: error5._tag })));
       if (transition3.transitioned) {
         const drained = yield* drain2();
         return { status: "messages", messages: drained.map(project) };
       }
     }
-    return yield* ToolExecutionWaitRequested.make({ tool_name: toolName4, wait_id: waitId });
+    return yield* ToolExecutionWaitRequested.make({ tool_name: toolName4, wait_id: waitId2 });
   })
 });
 
@@ -14669,18 +14863,18 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
       });
       const envelope = envelopeFrom(input);
       const ready = readyFor(input, route);
-      const waitId = waitIdFor(input);
+      const waitId2 = waitIdFor(input);
       const replayed = yield* repository.getEnvelope(envelope.id).pipe(Effect74.mapError(mapRepositoryError11));
       if (replayed !== undefined) {
         if (route.kind === "local-execution" && inbox._tag === "Some" && input.input.idempotency_key !== undefined) {
-          if (waitId !== undefined) {
-            yield* inbox.value.ensureReplyWait({ envelope, waitId }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
+          if (waitId2 !== undefined) {
+            yield* inbox.value.ensureReplyWait({ envelope, waitId: waitId2 }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
           }
           yield* inbox.value.deliver({
             executionId: exports_ids_schema.ExecutionId.make(route.route_key),
             envelope,
             idempotencyKey: input.input.idempotency_key,
-            ...waitId === undefined ? {} : { replyWaitId: waitId },
+            ...waitId2 === undefined ? {} : { replyWaitId: waitId2 },
             eventSequence: input.eventSequence,
             createdAt: input.createdAt
           }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
@@ -14688,7 +14882,7 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
         const recorded = {
           envelope_id: envelope.id,
           execution_id: envelope.execution_id,
-          ...waitId === undefined ? {} : { wait_id: waitId }
+          ...waitId2 === undefined ? {} : { wait_id: waitId2 }
         };
         return Object.defineProperty(recorded, "route_kind", { value: route.kind });
       }
@@ -14701,17 +14895,17 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
           envelope,
           acceptance: {
             envelope,
-            ...waitId === undefined ? {} : { waitId }
+            ...waitId2 === undefined ? {} : { waitId: waitId2 }
           },
           ...input.input.idempotency_key === undefined ? {} : { idempotencyKey: input.input.idempotency_key },
-          ...waitId === undefined ? {} : { replyWaitId: waitId },
+          ...waitId2 === undefined ? {} : { replyWaitId: waitId2 },
           eventSequence: input.eventSequence,
           createdAt: input.createdAt
         }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
         accepted2 = {
           envelope_id: envelope.id,
           execution_id: envelope.execution_id,
-          ...waitId === undefined ? {} : { wait_id: waitId }
+          ...waitId2 === undefined ? {} : { wait_id: waitId2 }
         };
         if (delivery.deduplicated) {
           return Object.defineProperty(accepted2, "route_kind", { value: route.kind });
@@ -14719,7 +14913,7 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
       } else {
         accepted2 = yield* repository.acceptEnvelope({
           envelope,
-          ...waitId === undefined ? {} : { waitId },
+          ...waitId2 === undefined ? {} : { waitId: waitId2 },
           ...ready === undefined ? {} : { ready }
         }).pipe(Effect74.mapError(mapRepositoryError11));
       }
@@ -14728,8 +14922,8 @@ var layer52 = Layer65.effect(Service64, Effect74.gen(function* () {
       if (ready !== undefined) {
         yield* appendIdempotentTo(eventLog, readyEvent(input, ready)).pipe(Effect74.mapError(mapEventLogError7));
       }
-      if (route.kind === "local-execution" && inbox._tag === "Some" && waitId !== undefined) {
-        yield* inbox.value.ensureReplyWait({ envelope, waitId }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
+      if (route.kind === "local-execution" && inbox._tag === "Some" && waitId2 !== undefined) {
+        yield* inbox.value.ensureReplyWait({ envelope, waitId: waitId2 }).pipe(Effect74.mapError((error5) => EnvelopeServiceError.make({ message: error5.message })));
       }
       yield* recordEnvelopeSent(route.kind);
       return Object.defineProperty(accepted2, "route_kind", { value: route.kind });
@@ -14795,9 +14989,9 @@ var layerFromEpoch = (epoch) => exports_instructions.layer(epoch.baseline.length
 // ../runtime/src/agent/relay-permissions.ts
 import { Clock as Clock15, Effect as Effect76, Layer as Layer67, Option as Option16, Schema as Schema69 } from "effect";
 var jsonValue3 = (value) => Schema69.decodeUnknownSync(exports_shared_schema.JsonValue)(value === undefined ? null : value);
-var waitIdForToolCall = (toolCallId) => exports_ids_schema.WaitId.make(`wait:permission:${toolCallId}`);
+var waitIdForToolCall = (executionId, toolCallId) => Identifiers.waitId("permission", executionId, toolCallId);
 var fallbackToolCallId = (request) => `${request.agentName}:${request.turn}:${request.tool}`;
-var tokenFor = (request) => waitIdForToolCall(request.toolCallId ?? fallbackToolCallId(request));
+var tokenFor = (executionId, request) => waitIdForToolCall(executionId, request.toolCallId ?? fallbackToolCallId(request));
 var matchingRule = (rules, tool3, params) => {
   let matched;
   for (const rule of rules) {
@@ -14806,7 +15000,7 @@ var matchingRule = (rules, tool3, params) => {
   }
   return matched;
 };
-var staticDecision = (ruleset, request) => {
+var staticDecision = (executionId, ruleset, request) => {
   const rule = matchingRule(ruleset.rules, request.tool, request.params);
   const level = rule?.level ?? ruleset.fallback ?? "ask";
   switch (level) {
@@ -14818,7 +15012,7 @@ var staticDecision = (ruleset, request) => {
         ...rule?.reason === undefined ? {} : { reason: rule.reason }
       };
     case "ask":
-      return { _tag: "Ask", token: tokenFor(request) };
+      return { _tag: "Ask", token: tokenFor(executionId, request) };
   }
 };
 var evaluateDecision = Effect76.fn("RelayPermissions.evaluateDecision")(function* (config, request) {
@@ -14834,10 +15028,10 @@ var evaluateDecision = Effect76.fn("RelayPermissions.evaluateDecision")(function
           ...rule.reason === undefined ? {} : { reason: rule.reason }
         };
       case "ask":
-        return { _tag: "Ask", token: tokenFor(request) };
+        return { _tag: "Ask", token: tokenFor(config.executionId, request) };
     }
   }
-  return staticDecision(config.ruleset, request);
+  return staticDecision(config.executionId, config.ruleset, request);
 });
 var permissionError = (message) => exports_permissions.PermissionError.make({ message });
 var createdAtForSequence = (config, sequence) => config.startedAt + sequence - config.eventSequence;
@@ -14849,18 +15043,18 @@ var allocateEventSequence = Effect76.fn("RelayPermissions.allocateEventSequence"
   return sequence;
 });
 var resetAllocatorToLog = (config) => config.allocator.current.pipe(Effect76.flatMap((current2) => nextLoggedSequence(config.eventLog, config.executionId, current2)), Effect76.flatMap(config.allocator.resetTo));
-var permissionRequestedCursor = (config, pending, waitId) => `${config.executionId}:permission:${pending.toolCallId ?? waitId}:requested`;
+var permissionRequestedCursor = (config, pending, waitId2) => `${config.executionId}:permission:${pending.toolCallId ?? waitId2}:requested`;
 var permissionResolvedCursor = (config, pending, wait) => `${config.executionId}:permission:${pending.toolCallId ?? wait.id}:resolved`;
-var permissionRequestedEvent = (config, pending, waitId, sequence) => ({
-  id: exports_ids_schema.EventId.make(`event:${pending.toolCallId ?? waitId}:permission-requested`),
+var permissionRequestedEvent = (config, pending, waitId2, sequence) => ({
+  id: Identifiers.eventId(config.executionId, pending.toolCallId ?? waitId2, "permission-requested"),
   execution_id: config.executionId,
   type: "permission.ask.requested",
   sequence,
-  cursor: permissionRequestedCursor(config, pending, waitId),
+  cursor: permissionRequestedCursor(config, pending, waitId2),
   data: {
     tool_call_id: pending.toolCallId ?? pending.token,
     tool_name: pending.tool,
-    wait_id: waitId,
+    wait_id: waitId2,
     input: jsonValue3(pending.params),
     agent_name: pending.agentName,
     scope: config.scope
@@ -14887,7 +15081,7 @@ var answerForWait = (wait) => {
   return { _tag: "Denied", reason: "Permission denied" };
 };
 var permissionResolvedEvent = (config, pending, wait, answer, sequence) => ({
-  id: exports_ids_schema.EventId.make(`event:${pending.toolCallId ?? wait.id}:permission-resolved`),
+  id: Identifiers.eventId(config.executionId, pending.toolCallId ?? wait.id, "permission-resolved"),
   execution_id: config.executionId,
   type: "permission.ask.resolved",
   sequence,
@@ -14907,19 +15101,19 @@ var appendPermissionEvent = (config, event) => appendIdempotentTo(config.eventLo
   onNone: () => Effect76.fail(permissionError(error5.message)),
   onSome: (prior) => samePermissionEvent(prior, event) ? Effect76.succeed(prior) : Effect76.fail(permissionError(error5.message))
 })))), Effect76.mapError((error5) => permissionError(error5.message)), Effect76.tap(() => resetAllocatorToLog(config)));
-var ensurePermissionRequestedEvent = Effect76.fn("RelayPermissions.ensurePermissionRequestedEvent")(function* (config, pending, waitId) {
-  const cursor = permissionRequestedCursor(config, pending, waitId);
+var ensurePermissionRequestedEvent = Effect76.fn("RelayPermissions.ensurePermissionRequestedEvent")(function* (config, pending, waitId2) {
+  const cursor = permissionRequestedCursor(config, pending, waitId2);
   const existing = yield* findEventByCursor(config, cursor);
   if (Option16.isSome(existing))
     return;
   const requestedSequence = yield* allocateEventSequence(config);
-  yield* appendPermissionEvent(config, permissionRequestedEvent(config, pending, waitId, requestedSequence));
+  yield* appendPermissionEvent(config, permissionRequestedEvent(config, pending, waitId2, requestedSequence));
 });
 var createAsk = Effect76.fn("RelayPermissions.createAsk")(function* (config, pending) {
-  const waitId = exports_ids_schema.WaitId.make(pending.token);
+  const waitId2 = exports_ids_schema.WaitId.make(pending.token);
   const waitSequence = yield* allocateEventSequence(config);
   yield* config.waits.createDetached({
-    waitId,
+    waitId: waitId2,
     executionId: config.executionId,
     mode: "event",
     correlationKey: pending.toolCallId ?? pending.token,
@@ -14934,17 +15128,17 @@ var createAsk = Effect76.fn("RelayPermissions.createAsk")(function* (config, pen
     eventSequence: waitSequence,
     createdAt: createdAtForSequence(config, waitSequence)
   }).pipe(Effect76.mapError((error5) => permissionError(error5.message)));
-  yield* ensurePermissionRequestedEvent(config, pending, waitId);
+  yield* ensurePermissionRequestedEvent(config, pending, waitId2);
 });
 var awaitAnswer = Effect76.fn("RelayPermissions.awaitAnswer")(function* (config, pending) {
-  const waitId = exports_ids_schema.WaitId.make(pending.token);
-  const existing = yield* config.waits.get(waitId).pipe(Effect76.mapError((error5) => permissionError(error5.message)));
+  const waitId2 = exports_ids_schema.WaitId.make(pending.token);
+  const existing = yield* config.waits.get(waitId2).pipe(Effect76.mapError((error5) => permissionError(error5.message)));
   if (existing === undefined) {
     yield* createAsk(config, pending);
     return Option16.none();
   }
   if (existing.state === "open") {
-    yield* ensurePermissionRequestedEvent(config, pending, waitId);
+    yield* ensurePermissionRequestedEvent(config, pending, waitId2);
     return Option16.none();
   }
   const answer = answerForWait(existing);
@@ -15056,7 +15250,7 @@ var layer55 = (config) => Layer68.succeed(exports_steering.Steering, exports_ste
 }));
 
 // ../runtime/src/agent/relay-tool-executor.ts
-import { Effect as Effect78, Layer as Layer69, Option as Option17, Schema as Schema71 } from "effect";
+import { Deferred as Deferred3, Effect as Effect78, Layer as Layer69, Option as Option17, Schema as Schema71 } from "effect";
 var jsonValue5 = (value) => Schema71.decodeUnknownSync(exports_shared_schema.JsonValue)(value);
 var errorDetail = (error5) => {
   switch (error5._tag) {
@@ -15084,47 +15278,103 @@ var boundResult = (config, result) => {
     return Effect78.succeed(result);
   return exports_tool_output.bound({ _tag: "Success", result: result.output, encodedResult: result.output }, { toolCallId: result.call_id, maxBytes: config.toolOutputMaxBytes }).pipe(Effect78.map((bounded) => ({ ...result, output: jsonValue5(bounded.encodedResult) })));
 };
-var make8 = (config) => ({
-  execute: (request) => Effect78.gen(function* () {
-    const first = yield* config.allocator.current;
-    const call = {
-      id: exports_ids_schema.ToolCallId.make(request.call.id),
-      name: request.call.name,
-      input: jsonValue5(request.call.params)
-    };
-    const resumed = config.resumedToolCallId === call.id;
-    const existingRequest = resumed ? yield* hasRequestedEvent(config, call.id) : false;
-    const eventSequence = existingRequest ? first - 1 : first;
-    return yield* config.toolRuntime.run({
-      executionId: config.executionId,
-      call,
-      permissions: config.permissions,
-      eventSequence,
-      createdAt: config.startedAt + eventSequence - config.eventSequence,
-      ...config.extraTools === undefined ? {} : { extraTools: config.extraTools },
-      transformResult: (result) => boundResult(config, result)
-    }).pipe(Effect78.flatMap((result) => nextLoggedSequence2(config.eventLog, config.executionId, existingRequest ? first + 1 : first + 2).pipe(Effect78.flatMap(config.allocator.resetTo), Effect78.as(result.error === undefined ? { _tag: "Success", result: result.output, encodedResult: result.output } : {
-      _tag: "DomainFailure",
-      failure: result.error,
-      encodedFailure: result.error
-    }))), Effect78.catch((error5) => nextLoggedSequence2(config.eventLog, config.executionId, first).pipe(Effect78.flatMap(config.allocator.resetTo), Effect78.flatMap(() => {
-      if (error5._tag === "ToolExecutionWaitRequested") {
-        return Effect78.succeed({ _tag: "Suspend", token: error5.wait_id });
-      }
-      if (error5._tag === "ToolExecutionFailed") {
-        const failure2 = `${error5._tag}: ${errorDetail(error5)}`;
-        return Effect78.succeed({ _tag: "DomainFailure", failure: failure2, encodedFailure: failure2 });
-      }
-      const stage = error5._tag === "ToolPermissionDenied" ? "authorization" : error5._tag === "ToolInputInvalid" ? "decode-input" : error5._tag === "ToolNotRegistered" ? "missing-handler" : "handler";
-      return Effect78.fail(exports_tool_executor.FrameworkFailure.make({
-        stage,
-        tool: call.name,
-        message: `${error5._tag}: ${errorDetail(error5)}`
-      }));
-    }))));
-  })
+var batchKey = (request) => `${request.turn}:${request.toolCallBatch.calls.map((call) => call.id).join(":")}`;
+var gateKey = (turn, toolCallIndex) => `${turn}:${toolCallIndex}`;
+var gateFor = (gates, key4) => {
+  const existing = gates.get(key4);
+  if (existing !== undefined)
+    return existing;
+  const created = Deferred3.makeUnsafe();
+  gates.set(key4, created);
+  return created;
+};
+var callFrom = (call) => ({
+  id: exports_ids_schema.ToolCallId.make(call.id),
+  name: call.name,
+  input: jsonValue5(call.params)
+});
+var frameworkFailure = (call, error5) => {
+  const stage = error5._tag === "ToolPermissionDenied" ? "authorization" : error5._tag === "ToolInputInvalid" ? "decode-input" : error5._tag === "ToolNotRegistered" ? "missing-handler" : "handler";
+  return exports_tool_executor.FrameworkFailure.make({
+    stage,
+    tool: call.name,
+    message: `${error5._tag}: ${errorDetail(error5)}`
+  });
+};
+var make8 = (config) => Effect78.sync(() => {
+  const prepared = new Map;
+  const settled = new Map;
+  const awaitPrevious = (gates, request) => {
+    if (request.toolCallIndex === 0 || config.resumedToolCallId === request.call.id)
+      return Effect78.void;
+    return Deferred3.await(gateFor(gates, gateKey(request.turn, request.toolCallIndex - 1)));
+  };
+  const completeSettlement = (request) => Deferred3.succeed(gateFor(settled, gateKey(request.turn, request.toolCallIndex)), undefined).pipe(Effect78.asVoid);
+  return exports_tool_executor.ToolExecutor.of({
+    execute: (request) => {
+      const key4 = batchKey(request);
+      const existingPreparation = prepared.get(key4);
+      const preparation = existingPreparation ?? Deferred3.makeUnsafe();
+      if (existingPreparation === undefined)
+        prepared.set(key4, preparation);
+      const prepareBatch = existingPreparation === undefined ? Effect78.gen(function* () {
+        const first = yield* config.allocator.current;
+        yield* Effect78.forEach(request.toolCallBatch.calls.entries(), ([toolCallIndex, batchCall]) => {
+          const call = callFrom(batchCall);
+          const eventSequence = first + toolCallIndex;
+          return config.toolRuntime.prepare({
+            executionId: config.executionId,
+            call,
+            permissions: config.permissions,
+            eventSequence,
+            createdAt: config.startedAt + eventSequence - config.eventSequence,
+            ...config.extraTools === undefined ? {} : { extraTools: config.extraTools }
+          }).pipe(Effect78.mapError((error5) => frameworkFailure(call, error5)));
+        });
+        const next = yield* nextLoggedSequence2(config.eventLog, config.executionId, first);
+        yield* config.allocator.advanceTo(next);
+        return next;
+      }).pipe(Effect78.exit, Effect78.flatMap((exit) => Deferred3.done(preparation, exit)), Effect78.andThen(Deferred3.await(preparation)), Effect78.uninterruptible) : Deferred3.await(preparation);
+      return Effect78.gen(function* () {
+        yield* prepareBatch;
+        let settlementSequence;
+        const beginSettlement = Effect78.suspend(() => {
+          if (settlementSequence !== undefined)
+            return Effect78.succeed(settlementSequence);
+          return awaitPrevious(settled, request).pipe(Effect78.andThen(config.allocator.current), Effect78.map((sequence) => sequence - 1), Effect78.tap((sequence) => Effect78.sync(() => settlementSequence = sequence)));
+        });
+        const first = yield* config.allocator.current;
+        const call = callFrom(request.call);
+        const existingRequest = yield* hasRequestedEvent(config, call.id);
+        const eventSequence = existingRequest ? first - 1 : first;
+        return yield* config.toolRuntime.run({
+          executionId: config.executionId,
+          call,
+          permissions: config.permissions,
+          eventSequence,
+          createdAt: config.startedAt + eventSequence - config.eventSequence,
+          ...config.extraTools === undefined ? {} : { extraTools: config.extraTools },
+          beforeSettlement: beginSettlement,
+          transformResult: (result) => boundResult(config, result)
+        }).pipe(Effect78.flatMap((result) => nextLoggedSequence2(config.eventLog, config.executionId, existingRequest ? first + 1 : first + 2).pipe(Effect78.flatMap(config.allocator.advanceTo), Effect78.as(result.error === undefined ? { _tag: "Success", result: result.output, encodedResult: result.output } : {
+          _tag: "DomainFailure",
+          failure: result.error,
+          encodedFailure: result.error
+        }))), Effect78.catch((error5) => beginSettlement.pipe(Effect78.asVoid, Effect78.andThen(nextLoggedSequence2(config.eventLog, config.executionId, first)), Effect78.flatMap(config.allocator.advanceTo), Effect78.flatMap(() => {
+          if (error5._tag === "ToolExecutionWaitRequested") {
+            return Effect78.succeed({ _tag: "Suspend", token: error5.wait_id });
+          }
+          if (error5._tag === "ToolExecutionFailed") {
+            const failure2 = `${error5._tag}: ${errorDetail(error5)}`;
+            return Effect78.succeed({ _tag: "DomainFailure", failure: failure2, encodedFailure: failure2 });
+          }
+          return Effect78.fail(frameworkFailure(call, error5));
+        }))), Effect78.tap((outcome) => outcome._tag === "Suspend" ? Effect78.void : completeSettlement(request)), Effect78.onInterrupt(() => completeSettlement(request)));
+      });
+    }
+  });
 });
-var layer56 = (config) => Layer69.succeed(exports_tool_executor.ToolExecutor, exports_tool_executor.ToolExecutor.of(make8(config)));
+var layer56 = (config) => Layer69.effect(exports_tool_executor.ToolExecutor, make8(config));
 
 // ../runtime/src/agent/relay-tool-output.ts
 import { Effect as Effect79, Function as Function14, Layer as Layer70, Option as Option18 } from "effect";
@@ -15175,6 +15425,7 @@ import { Effect as Effect80, Ref as Ref17 } from "effect";
 var make10 = (first) => Ref17.make(first).pipe(Effect80.map((ref) => ({
   allocate: (count) => Ref17.getAndUpdate(ref, (value) => value + count),
   current: Ref17.get(ref),
+  advanceTo: (sequence) => Ref17.update(ref, (current2) => Math.max(current2, sequence)),
   resetTo: (sequence) => Ref17.set(ref, sequence)
 })));
 
@@ -15411,7 +15662,7 @@ var loopError = (error5, nextEventSequence5) => AgentLoopError.make({
   message: error5 instanceof Error ? `${error5.name}: ${error5.message}` : String(error5),
   next_event_sequence: nextEventSequence5
 });
-var appendEvent = (eventLog, event, nextEventSequence5) => appendIdempotentTo(eventLog, event).pipe(Effect81.mapError((error5) => loopError(error5, nextEventSequence5)));
+var appendEvent = (eventLog, allocator, event, nextEventSequence5) => appendIdempotentTo(eventLog, event).pipe(Effect81.tap((appended) => allocator.advanceTo(appended.sequence + 1)), Effect81.mapError((error5) => loopError(error5, nextEventSequence5)));
 var compactionCommittedCursor = (executionId, checkpointId2) => `execution:${executionId}:agent-compaction:${checkpointId2}:committed`;
 var appendCompactionCommittedEvent = Effect81.fn("AgentLoop.appendCompactionCommittedEvent")(function* (eventLog, allocator, input, checkpoint) {
   if (input.sessionId === undefined)
@@ -15426,7 +15677,7 @@ var appendCompactionCommittedEvent = Effect81.fn("AgentLoop.appendCompactionComm
     session_id: input.sessionId,
     summary_present: checkpoint.summary !== undefined
   };
-  yield* appendEvent(eventLog, {
+  yield* appendEvent(eventLog, allocator, {
     id: exports_ids_schema.EventId.make(`event:${input.executionId}:agent-compaction:${checkpoint.id}:committed`),
     execution_id: input.executionId,
     type: "agent.compaction.committed",
@@ -15712,7 +15963,10 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
       const definitions2 = registered.map((tool3) => tool3.definition);
       yield* validateToolInputSchemaDigests(input, definitions2);
       const toolCallDecodeMaxRetries = yield* toolCallDecodeMaxRetriesConfig.pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1)));
-      yield* appendEvent(eventLog, inputPreparedEvent(input, definitions2), input.eventSequence + 1);
+      const durableMaxSequence = yield* eventLog.maxSequence(input.executionId).pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1)));
+      const nextEventSequence5 = Math.max(input.eventSequence + 1, (durableMaxSequence ?? -1) + 1);
+      const allocator = yield* make10(nextEventSequence5);
+      yield* appendEvent(eventLog, allocator, inputPreparedEvent(input, definitions2), input.eventSequence + 1);
       const toolOutputMaxBytes = yield* effectiveToolOutputMaxBytes(input);
       const compactionPolicy = input.agent.compaction_policy;
       const configuredCompactionOptions = compactionOptions(input.agent);
@@ -15736,9 +15990,6 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
         input: jsonValue6(resumeSuspension.tool_params)
       };
       const storedHistory = resumeToolCall === undefined ? yield* loadStoredHistory(chats, input) : yield* restoreHistory(chats, input);
-      const durableMaxSequence = yield* eventLog.maxSequence(input.executionId).pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1)));
-      const nextEventSequence5 = Math.max(input.eventSequence + 1, (durableMaxSequence ?? -1) + 1);
-      const allocator = yield* make10(nextEventSequence5);
       const onCheckpointCommitted = (result) => appendCompactionCommittedEvent(eventLog, allocator, input, result.checkpoint).pipe(Effect81.andThen(layerOptions?.onCheckpointCommitted?.(result) ?? Effect81.void));
       const durableHistory = Option19.isNone(sessionRepository) ? storedHistory : yield* reconcileCompactionCheckpoint(sessionRepository.value, chats, input, storedHistory, onCheckpointCommitted, resumeSuspension === undefined);
       const continuingDurableHistory = durableHistory !== undefined;
@@ -15798,7 +16049,8 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
       const agent = exports_agent.make({
         name: input.agent.name,
         toolkit,
-        policy: turnPolicyFromDefinition(input.agent)
+        policy: turnPolicyFromDefinition(input.agent),
+        ...input.agent.tool_execution === undefined ? {} : { toolExecution: input.agent.tool_execution }
       });
       if (toolOutputMaxBytes !== undefined && Option19.isNone(blobStore)) {
         return yield* AgentLoopError.make({
@@ -15860,7 +16112,7 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
       const tokenBudget = input.agent.token_budget;
       const enforceBudget = (state) => tokenBudget === undefined || state.tokensUsed < tokenBudget ? Effect81.void : Effect81.gen(function* () {
         const budgetSequence = yield* allocator.allocate(1);
-        yield* appendEvent(eventLog, budgetExceededEvent(input, state.tokensUsed, tokenBudget, budgetSequence), budgetSequence + 1);
+        yield* appendEvent(eventLog, allocator, budgetExceededEvent(input, state.tokensUsed, tokenBudget, budgetSequence), budgetSequence + 1);
         return yield* AgentLoopBudgetExceeded.make({
           tokens_used: state.tokensUsed,
           token_budget: tokenBudget,
@@ -15874,13 +16126,13 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
             if (part.type === "text-delta") {
               const sequence = yield* allocator.allocate(1);
               const deltaIndex = sequence - input.eventSequence - 1;
-              yield* appendEvent(eventLog, outputDeltaEvent(input, part, deltaIndex), sequence + 1);
+              yield* appendEvent(eventLog, allocator, outputDeltaEvent(input, part, deltaIndex), sequence + 1);
               return { ...state, text: `${state.text}${part.delta}` };
             }
             if (part.type === "reasoning" || part.type === "reasoning-delta") {
               const sequence = yield* allocator.allocate(1);
               const deltaIndex = sequence - input.eventSequence - 1;
-              yield* appendEvent(eventLog, reasoningDeltaEvent(input, part, deltaIndex), sequence + 1);
+              yield* appendEvent(eventLog, allocator, reasoningDeltaEvent(input, part, deltaIndex), sequence + 1);
               return state;
             }
             if (part.type === "tool-params-start") {
@@ -15889,7 +16141,7 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
             if (part.type === "tool-params-delta") {
               const sequence = yield* allocator.allocate(1);
               const deltaIndex = state.toolCallDeltaIndexes[part.id] ?? 0;
-              yield* appendEvent(eventLog, toolCallDeltaEvent(input, part, state.toolCallNames[part.id], sequence, deltaIndex), sequence + 1);
+              yield* appendEvent(eventLog, allocator, toolCallDeltaEvent(input, part, state.toolCallNames[part.id], sequence, deltaIndex), sequence + 1);
               return {
                 ...state,
                 toolCallDeltaIndexes: { ...state.toolCallDeltaIndexes, [part.id]: deltaIndex + 1 }
@@ -15898,7 +16150,7 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
             if (part.type === "finish") {
               const finish = part;
               const sequence = yield* allocator.allocate(1);
-              yield* appendEvent(eventLog, usageReportedEvent(input, finish, sequence), sequence + 1);
+              yield* appendEvent(eventLog, allocator, usageReportedEvent(input, finish, sequence), sequence + 1);
               yield* recordModelUsage({
                 provider: input.agent.model.provider,
                 model: input.agent.model.model,
@@ -15966,7 +16218,7 @@ var make11 = (layerOptions) => Effect81.gen(function* () {
       const schemaRef = input.agent.output_schema_ref;
       const structuredOutput = schemaRef === undefined || finalState.transcript === undefined ? undefined : yield* Chat.fromPrompt(finalState.transcript).pipe(Effect81.flatMap((chat) => runStructuredTurn(languageModels, schemas, chat, input, schemaRef, completedSequence + 1)));
       const structuredPart = structuredOutput === undefined || schemaRef === undefined ? [] : [{ type: "structured", value: structuredOutput, schema_ref: schemaRef }];
-      yield* appendEvent(eventLog, outputCompletedEvent(input, [...completedContent(finalState.text), ...structuredPart], finalState.text, completedSequence, structuredOutput), completedSequence + 1);
+      yield* appendEvent(eventLog, allocator, outputCompletedEvent(input, [...completedContent(finalState.text), ...structuredPart], finalState.text, completedSequence, structuredOutput), completedSequence + 1);
       return {
         metadata: {
           model_output: finalState.text,
@@ -16344,16 +16596,16 @@ var make12 = Effect86.gen(function* () {
     }).pipe(Effect86.mapError(toSchedulerError));
   }).pipe(Effect86.withSpan("SchedulerService.dispatchStartExecution"));
   const dispatchWaitTransition = (schedule, now) => Effect86.gen(function* () {
-    const waitId = schedule.wait_id;
-    if (waitId === undefined) {
+    const waitId2 = schedule.wait_id;
+    if (waitId2 === undefined) {
       return yield* SchedulerError.make({ message: `Schedule ${schedule.id} is missing wait_id` });
     }
-    const wait = yield* waits.get(waitId).pipe(Effect86.mapError(toSchedulerError));
+    const wait = yield* waits.get(waitId2).pipe(Effect86.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(Effect86.mapError(toSchedulerError)) : yield* waits.timeout({ waitId, timedOutAt: now, eventSequence, metadata: metadata11 }).pipe(Effect86.mapError(toSchedulerError));
+    const result = schedule.target_kind === "wake-wait" ? yield* waits.wake({ waitId: waitId2, resolvedAt: now, eventSequence, metadata: metadata11 }).pipe(Effect86.mapError(toSchedulerError)) : yield* waits.timeout({ waitId: waitId2, timedOutAt: now, eventSequence, metadata: metadata11 }).pipe(Effect86.mapError(toSchedulerError));
     if (!result.transitioned)
       return;
     yield* signalWorkflowWait({
@@ -17530,6 +17782,7 @@ var registerAgentPayload = Effect90.fn("Client.registerAgentPayload")(function*
     ...input.permission_rules === undefined ? {} : { permission_rules: input.permission_rules },
     ...input.compaction_policy === undefined ? {} : { compaction_policy: input.compaction_policy },
     ...turnPolicy,
+    ...input.agent.toolExecution === undefined ? {} : { tool_execution: input.agent.toolExecution },
     ...input.max_wait_turns === undefined ? {} : { max_wait_turns: input.max_wait_turns },
     ...input.token_budget === undefined ? {} : { token_budget: input.token_budget },
     ...input.child_run_presets === undefined ? {} : { child_run_presets: input.child_run_presets },
@@ -17590,13 +17843,13 @@ var toToolWorkLease = (lease) => ({
   claim_expires_at: lease.claimExpiresAt,
   idempotency_key: lease.idempotencyKey
 });
-var toolWaitId = (callId) => exports_ids_schema.WaitId.make(`wait:tool:${callId}`);
+var toolWaitId = (executionId, callId) => Identifiers.waitId("tool", executionId, callId);
 var acceptedWaitOutcome = (wait) => Schema83.decodeUnknownEffect(exports_tool_schema.ExternalOutcome)(wait.metadata.external_outcome).pipe(Effect90.mapError(toClientError));
 var resolveToolOutcomeWait = Effect90.fn("Client.resolveToolOutcomeWait")(function* (waits, eventLog, call, outcome, completedAt) {
-  const waitId = call.waitId ?? toolWaitId(call.call.id);
-  const wait = yield* waits.get(waitId).pipe(Effect90.mapError(toClientError));
+  const waitId2 = call.waitId ?? toolWaitId(call.executionId, call.call.id);
+  const wait = yield* waits.get(waitId2).pipe(Effect90.mapError(toClientError));
   if (wait === undefined)
-    return yield* ClientError.make({ message: `Tool wait not found: ${waitId}` });
+    return yield* ClientError.make({ message: `Tool wait not found: ${waitId2}` });
   if (wait.executionId !== call.executionId) {
     return yield* ClientError.make({ message: `Tool wait does not match call: ${call.call.id}` });
   }
@@ -17612,7 +17865,7 @@ var resolveToolOutcomeWait = Effect90.fn("Client.resolveToolOutcomeWait")(functi
   }
   const eventSequence = yield* nextEventSequence6(eventLog, call.executionId);
   const resolved = yield* waits.wake({
-    waitId,
+    waitId: waitId2,
     resolvedAt: completedAt,
     eventSequence,
     metadata: { kind: "tool-placement", external_outcome: outcome }
@@ -17757,10 +18010,10 @@ var childSpawnFingerprint = (record2) => {
   return typeof fingerprint === "string" ? fingerprint : undefined;
 };
 var createChildJoinWait = Effect90.fn("Client.createChildJoinWait")(function* (waits, eventLog, input, accepted2, createdAt) {
-  const waitId = childJoinWaitId(accepted2.child_execution_id);
+  const waitId2 = childJoinWaitId(accepted2.child_execution_id);
   const eventSequence = yield* nextEventSequence6(eventLog, input.execution_id);
   yield* waits.createDetached({
-    waitId,
+    waitId: waitId2,
     executionId: input.execution_id,
     mode: "child",
     correlationKey: accepted2.child_execution_id,
@@ -17771,7 +18024,7 @@ var createChildJoinWait = Effect90.fn("Client.createChildJoinWait")(function* (w
     eventSequence,
     createdAt
   }).pipe(Effect90.mapError(toClientError));
-  return waitId;
+  return waitId2;
 });
 var reconcileExistingChildSpawn = Effect90.fn("Client.reconcileExistingChildSpawn")(function* (childExecutions, waits, eventLog, input) {
   const childExecutionId3 = childExecutionIdForSpawn(input);
@@ -17904,6 +18157,16 @@ var layerFromRuntime3 = Layer80.effect(Service, Effect90.gen(function* () {
     const executionId = exports_ids_schema.ExecutionId.make(input.correlation_key ?? `execution:send:${identity2}`);
     const envelopeId = exports_ids_schema.EnvelopeId.make(`${executionId}:envelope:${identity2}`);
     const createdAt = yield* Clock19.currentTimeMillis;
+    const execution = yield* executionRepository.get(executionId).pipe(Effect90.mapError(toClientError));
+    if (execution === undefined) {
+      yield* executionRepository.create({
+        id: executionId,
+        rootAddressId: input.from,
+        status: "queued",
+        metadata: { operation: "envelope-send" },
+        createdAt
+      }).pipe(Effect90.catchIf(Schema83.is(exports_execution_repository.DuplicateExecution), () => Effect90.void), Effect90.mapError(toClientError));
+    }
     const maxSequence3 = yield* eventLog.maxSequence(executionId).pipe(Effect90.mapError(toClientError));
     return yield* envelopes.send({
       envelopeId,