@relayfx/sdk 0.3.4 → 0.3.6

package/dist/{index-01rpd00m.js → index-e02krw55.js}

@@ -16,7 +16,7 @@ import {
   exports_tool_executor,
   exports_tool_output,
   exports_turn_policy
-} from "./index-25gwk9tj.js";
+} from "./index-8fpd6kvj.js";
 import {
   ClientError,
   CommandReplyInvalid,
@@ -51,7 +51,7 @@ import {
   followExecutionFrom,
   inputSchemaRef,
   outputSchemaRef
-} from "./index-cphmds30.js";
+} from "./index-mtvz1bjn.js";
 import {
   __export
 } from "./index-nb39b5ae.js";
@@ -7679,9 +7679,10 @@ var MaxAttemptRow = Schema35.Struct({
 });
 var ExpiredCallRow = Schema35.Struct({
   id: Schema35.String,
+  execution_id: Schema35.String,
   active_attempt_id: Schema35.NullishOr(Schema35.String)
 });
-var IdRow = Schema35.Struct({ id: Schema35.String });
+var IdRow = Schema35.Struct({ id: Schema35.String, execution_id: Schema35.String });
 var metadata8 = (input) => input ?? {};
 var normalizeCall = (call) => ({ ...call, metadata: metadata8(call.metadata) });
 var sameCallIdentity = (left, right) => exports_shared_schema.canonicalEquals(normalizeCall(left), normalizeCall(right));
@@ -7776,15 +7777,15 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
     "completed_at"
   ].join(", "));
   const resultColumns = sql.literal(["tool_call_id", "output_json", "error", "metadata_json", "created_at"].join(", "));
-  const selectCallByKey = (tenantId, id) => sql`
+  const selectCallByKey = (tenantId, executionId, id) => sql`
       SELECT ${callColumns}
       FROM relay_tool_calls
-      WHERE tenant_id = ${tenantId} AND id = ${id}
+      WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND id = ${id}
     `;
-  const selectResultByKey = (tenantId, callId) => sql`
+  const selectResultByKey = (tenantId, executionId, callId) => sql`
       SELECT ${resultColumns}
       FROM relay_tool_results
-      WHERE tenant_id = ${tenantId} AND tool_call_id = ${callId}
+      WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND tool_call_id = ${callId}
     `;
   const insertCallBody = (tenantId, input, definition, placement = { kind: "local" }) => sql`
       (
@@ -7823,13 +7824,13 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
       `,
     orElse: () => (tenantId, input, definition, placement) => sql`
         INSERT INTO relay_tool_calls ${insertCallBody(tenantId, input, definition, placement)}
-        ON CONFLICT (tenant_id, id) DO NOTHING
+        ON CONFLICT (tenant_id, execution_id, id) DO NOTHING
       `
   });
   const insertCall = sql.onDialectOrElse({
     mysql: () => (tenantId, input, definition, placement) => sql.withTransaction(Effect37.gen(function* () {
       yield* insertCallStatement(tenantId, input, definition, placement);
-      return yield* selectCallByKey(tenantId, input.call.id);
+      return yield* selectCallByKey(tenantId, input.executionId, input.call.id);
     })),
     orElse: () => (tenantId, input, definition, placement) => sql`
         ${insertCallStatement(tenantId, input, definition, placement)}
@@ -7838,10 +7839,11 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
   });
   const insertResultStatement = (tenantId, input) => sql`
       INSERT INTO relay_tool_results (
-        tenant_id, ${resultColumns}
+        tenant_id, execution_id, ${resultColumns}
       )
       VALUES (
         ${tenantId},
+        ${input.executionId},
         ${input.result.call_id},
         ${encodeJson(input.result.output)},
         ${input.result.error ?? null},
@@ -7849,19 +7851,19 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
         ${timestampParam(sql, input.createdAt)}
       )
     `;
-  const selectAttempts = (tenantId, callId) => sql`
+  const selectAttempts = (tenantId, executionId, callId) => sql`
       SELECT ${attemptColumns}
       FROM relay_tool_attempts
-      WHERE tenant_id = ${tenantId} AND tool_call_id = ${callId}
+      WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND tool_call_id = ${callId}
       ORDER BY attempt_number ASC
     `;
   const lockedCallRows = sql.onDialectOrElse({
-    pg: () => (tenantId, callId) => sql`
-        ${selectCallByKey(tenantId, callId)}
+    pg: () => (tenantId, executionId, callId) => sql`
+        ${selectCallByKey(tenantId, executionId, callId)}
         FOR UPDATE
       `,
-    mysql: () => (tenantId, callId) => sql`
-        ${selectCallByKey(tenantId, callId)}
+    mysql: () => (tenantId, executionId, callId) => sql`
+        ${selectCallByKey(tenantId, executionId, callId)}
         FOR UPDATE
       `,
     orElse: () => selectCallByKey
@@ -7874,35 +7876,35 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
     const decoded = yield* decodeAttemptRow(row);
     return yield* Effect37.try({ try: () => toAttemptRecord(decoded), catch: toRepositoryError17 });
   });
-  const readLockedCall = Effect37.fn("ToolCallRepository.readLockedCall")(function* (tenantId, callId) {
-    const rows = yield* lockedCallRows(tenantId, callId).pipe(Effect37.mapError(toRepositoryError17));
+  const readLockedCall = Effect37.fn("ToolCallRepository.readLockedCall")(function* (tenantId, executionId, callId) {
+    const rows = yield* lockedCallRows(tenantId, executionId, callId).pipe(Effect37.mapError(toRepositoryError17));
     if (rows[0] === undefined)
       return yield* ToolCallNotFound.make({ id: callId });
     return yield* decodeCall(rows[0]);
   });
-  const readAttempts = Effect37.fn("ToolCallRepository.readAttempts")(function* (tenantId, callId) {
-    const rows = yield* selectAttempts(tenantId, callId).pipe(Effect37.mapError(toRepositoryError17));
+  const readAttempts = Effect37.fn("ToolCallRepository.readAttempts")(function* (tenantId, executionId, callId) {
+    const rows = yield* selectAttempts(tenantId, executionId, callId).pipe(Effect37.mapError(toRepositoryError17));
     return yield* Effect37.forEach(rows, decodeAttempt);
   });
-  const nextAttemptNumber = Effect37.fn("ToolCallRepository.nextAttemptNumber")(function* (tenantId, callId) {
+  const nextAttemptNumber = Effect37.fn("ToolCallRepository.nextAttemptNumber")(function* (tenantId, executionId, callId) {
     const rows = yield* sql`
         SELECT COALESCE(MAX(attempt_number), 0) AS max_attempt
         FROM relay_tool_attempts
-        WHERE tenant_id = ${tenantId} AND tool_call_id = ${callId}
+        WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND tool_call_id = ${callId}
       `.pipe(Effect37.mapError(toRepositoryError17));
     const row = yield* decodeMaxAttemptRow(rows[0]);
     const max = Number(row?.max_attempt ?? 0);
     return max + 1;
   });
-  const insertAttemptNumber = Effect37.fn("ToolCallRepository.insertAttemptNumber")(function* (tenantId, callId, attemptNumber, createdAt, workerId, claimExpiresAt) {
+  const insertAttemptNumber = Effect37.fn("ToolCallRepository.insertAttemptNumber")(function* (tenantId, executionId, callId, attemptNumber, createdAt, workerId, claimExpiresAt) {
     const attemptId = toolAttemptId(attemptNumber);
     yield* sql`
         INSERT INTO relay_tool_attempts (
-          tenant_id, id, tool_call_id, attempt_number, state, worker_id, claim_expires_at,
+          tenant_id, execution_id, id, tool_call_id, attempt_number, state, worker_id, claim_expires_at,
           error, created_at, completed_at
         )
         VALUES (
-          ${tenantId}, ${attemptId}, ${callId}, ${attemptNumber}, 'running', ${workerId ?? null},
+          ${tenantId}, ${executionId}, ${attemptId}, ${callId}, ${attemptNumber}, 'running', ${workerId ?? null},
           ${claimExpiresAt === undefined ? null : ts(claimExpiresAt)}, ${null}, ${ts(createdAt)}, ${null}
         )
       `.pipe(Effect37.mapError(toRepositoryError17));
@@ -7916,25 +7918,25 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
       createdAt
     };
   });
-  const insertAttempt = Effect37.fn("ToolCallRepository.insertAttempt")(function* (tenantId, callId, createdAt, workerId, claimExpiresAt) {
-    const attemptNumber = yield* nextAttemptNumber(tenantId, callId);
-    return yield* insertAttemptNumber(tenantId, callId, attemptNumber, createdAt, workerId, claimExpiresAt);
+  const insertAttempt = Effect37.fn("ToolCallRepository.insertAttempt")(function* (tenantId, executionId, callId, createdAt, workerId, claimExpiresAt) {
+    const attemptNumber = yield* nextAttemptNumber(tenantId, executionId, callId);
+    return yield* insertAttemptNumber(tenantId, executionId, callId, attemptNumber, createdAt, workerId, claimExpiresAt);
   });
-  const loadAttempt = Effect37.fn("ToolCallRepository.loadAttempt")(function* (tenantId, callId, attemptId) {
+  const loadAttempt = Effect37.fn("ToolCallRepository.loadAttempt")(function* (tenantId, executionId, callId, attemptId) {
     const rows = yield* sql`
         SELECT ${attemptColumns}
         FROM relay_tool_attempts
-        WHERE tenant_id = ${tenantId} AND tool_call_id = ${callId} AND id = ${attemptId}
+        WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND tool_call_id = ${callId} AND id = ${attemptId}
       `.pipe(Effect37.mapError(toRepositoryError17));
     return rows[0] === undefined ? undefined : yield* decodeAttempt(rows[0]);
   });
-  const completeAttempt = Effect37.fn("ToolCallRepository.completeAttempt")(function* (tenantId, callId, attemptId, state, completedAt, error5) {
+  const completeAttempt = Effect37.fn("ToolCallRepository.completeAttempt")(function* (tenantId, executionId, callId, attemptId, state, completedAt, error5) {
     yield* sql`
         UPDATE relay_tool_attempts
         SET state = ${state}, error = ${error5 ?? null}, completed_at = ${ts(completedAt)}
-        WHERE tenant_id = ${tenantId} AND tool_call_id = ${callId} AND id = ${attemptId} AND state = 'running'
+        WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND tool_call_id = ${callId} AND id = ${attemptId} AND state = 'running'
       `.pipe(Effect37.mapError(toRepositoryError17));
-    const attempt = yield* loadAttempt(tenantId, callId, attemptId);
+    const attempt = yield* loadAttempt(tenantId, executionId, callId, attemptId);
     if (attempt === undefined) {
       return yield* ToolCallRepositoryError.make({ message: `Tool attempt not found: ${attemptId}` });
     }
@@ -7944,7 +7946,7 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
     const tenantId = yield* current();
     return yield* sql.withTransaction(Effect37.gen(function* () {
       yield* insertCallIgnore(tenantId, input, input.definition, input.placement);
-      const rows = yield* lockedCallRows(tenantId, input.call.id);
+      const rows = yield* lockedCallRows(tenantId, input.executionId, input.call.id);
       if (rows[0] === undefined)
         return yield* ToolCallNotFound.make({ id: input.call.id });
       const existing = yield* decodeCall(rows[0]);
@@ -7960,7 +7962,7 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
   const prepareExternalWait = Effect37.fn("ToolCallRepository.prepareExternalWait")(function* (input) {
     const tenantId = yield* current();
     return yield* repositoryTransaction(Effect37.gen(function* () {
-      const call = yield* readLockedCall(tenantId, input.callId);
+      const call = yield* readLockedCall(tenantId, input.executionId, input.callId);
       if (call.placement.kind !== "client" && call.placement.kind !== "remote") {
         return yield* ToolCallTransitionRejected.make({
           id: input.callId,
@@ -7976,15 +7978,15 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
             UPDATE relay_tool_calls
             SET state = 'waiting', wait_id = ${input.waitId}, available_at = ${ts(input.availableAt)},
                 updated_at = ${ts(input.updatedAt)}
-            WHERE tenant_id = ${tenantId} AND id = ${input.callId} AND state = 'requested'
+            WHERE tenant_id = ${tenantId} AND execution_id = ${input.executionId} AND id = ${input.callId} AND state = 'requested'
           `.pipe(Effect37.mapError(toRepositoryError17));
-      return yield* readLockedCall(tenantId, input.callId);
+      return yield* readLockedCall(tenantId, input.executionId, input.callId);
     }));
   });
   const beginAttempt = Effect37.fn("ToolCallRepository.beginAttempt")(function* (input) {
     const tenantId = yield* current();
     return yield* repositoryTransaction(Effect37.gen(function* () {
-      const call = yield* readLockedCall(tenantId, input.callId);
+      const call = yield* readLockedCall(tenantId, input.executionId, input.callId);
       if (call.placement.kind !== "local" && call.placement.kind !== "mcp") {
         return yield* ToolCallTransitionRejected.make({
           id: input.callId,
@@ -7995,13 +7997,13 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
         return yield* ToolCallTransitionRejected.make({ id: input.callId, message: `Call is ${call.state}` });
       }
       if (call.activeAttemptId !== undefined) {
-        yield* completeAttempt(tenantId, input.callId, call.activeAttemptId, "abandoned", input.startedAt);
+        yield* completeAttempt(tenantId, input.executionId, input.callId, call.activeAttemptId, "abandoned", input.startedAt);
       }
-      const attempt = yield* insertAttempt(tenantId, input.callId, input.startedAt);
+      const attempt = yield* insertAttempt(tenantId, input.executionId, input.callId, input.startedAt);
       yield* sql`
             UPDATE relay_tool_calls
             SET state = 'running', active_attempt_id = ${attempt.id}, updated_at = ${ts(input.startedAt)}
-            WHERE tenant_id = ${tenantId} AND id = ${input.callId}
+            WHERE tenant_id = ${tenantId} AND execution_id = ${input.executionId} AND id = ${input.callId}
           `.pipe(Effect37.mapError(toRepositoryError17));
       return attempt;
     }));
@@ -8009,7 +8011,7 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
   const acceptClientOutcome = Effect37.fn("ToolCallRepository.acceptClientOutcome")(function* (input) {
     const tenantId = yield* current();
     return yield* repositoryTransaction(Effect37.gen(function* () {
-      const call = yield* readLockedCall(tenantId, input.callId);
+      const call = yield* readLockedCall(tenantId, input.executionId, input.callId);
       if (call.executionId !== input.executionId || call.placement.kind !== "client") {
         return yield* ToolCallTransitionRejected.make({
           id: input.callId,
@@ -8026,7 +8028,7 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
             message: "Accepted attempt is missing"
           });
         }
-        const attempt2 = yield* loadAttempt(tenantId, input.callId, call.activeAttemptId);
+        const attempt2 = yield* loadAttempt(tenantId, input.executionId, input.callId, call.activeAttemptId);
         if (attempt2 === undefined) {
           return yield* ToolCallTransitionRejected.make({
             id: input.callId,
@@ -8038,21 +8040,21 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
       if (call.state !== "waiting") {
         return yield* ToolCallTransitionRejected.make({ id: input.callId, message: `Call is ${call.state}` });
       }
-      const running = yield* insertAttempt(tenantId, input.callId, input.submittedAt);
-      const attempt = yield* completeAttempt(tenantId, input.callId, running.id, input.outcome.kind === "success" ? "completed" : "failed", input.submittedAt, input.outcome.kind === "failure" ? input.outcome.message : undefined);
+      const running = yield* insertAttempt(tenantId, input.executionId, input.callId, input.submittedAt);
+      const attempt = yield* completeAttempt(tenantId, input.executionId, input.callId, running.id, input.outcome.kind === "success" ? "completed" : "failed", input.submittedAt, input.outcome.kind === "failure" ? input.outcome.message : undefined);
       yield* sql`
             UPDATE relay_tool_calls
             SET state = 'submitted', active_attempt_id = ${attempt.id},
                 external_outcome_json = ${encodeJson(input.outcome)},
                 external_outcome_at = ${ts(input.submittedAt)}, updated_at = ${ts(input.submittedAt)}
-            WHERE tenant_id = ${tenantId} AND id = ${input.callId}
+            WHERE tenant_id = ${tenantId} AND execution_id = ${input.executionId} AND id = ${input.callId}
           `.pipe(Effect37.mapError(toRepositoryError17));
-      const updated = yield* readLockedCall(tenantId, input.callId);
+      const updated = yield* readLockedCall(tenantId, input.executionId, input.callId);
       return { call: updated, attempt, duplicate: false };
     }));
   });
   const claimCandidate = (tenantId, input) => sql`
-      SELECT id
+      SELECT execution_id, id
       FROM relay_tool_calls
       WHERE tenant_id = ${tenantId} AND placement_kind = 'remote' AND placement_key = ${input.queue}
         AND state = 'waiting' AND available_at <= ${ts(input.now)}
@@ -8071,20 +8073,20 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
     orElse: () => claimCandidate
   });
   const claimCall = sql.onDialectOrElse({
-    mysql: () => (tenantId, callId, attemptId, input) => sql`
+    mysql: () => (tenantId, executionId, callId, attemptId, input) => sql`
           UPDATE relay_tool_calls
           SET state = 'running', active_attempt_id = ${attemptId}, claim_owner = ${input.workerId},
               claimed_at = ${ts(input.now)}, claim_expires_at = ${ts(input.claimExpiresAt)},
               updated_at = ${ts(input.now)}
-          WHERE tenant_id = ${tenantId} AND id = ${callId} AND state = 'waiting'
+          WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND id = ${callId} AND state = 'waiting'
             AND available_at <= ${ts(input.now)}
         `.pipe(Effect37.as([{ id: callId }])),
-    orElse: () => (tenantId, callId, attemptId, input) => sql`
+    orElse: () => (tenantId, executionId, callId, attemptId, input) => sql`
         UPDATE relay_tool_calls
         SET state = 'running', active_attempt_id = ${attemptId}, claim_owner = ${input.workerId},
             claimed_at = ${ts(input.now)}, claim_expires_at = ${ts(input.claimExpiresAt)},
             updated_at = ${ts(input.now)}
-        WHERE tenant_id = ${tenantId} AND id = ${callId} AND state = 'waiting'
+        WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND id = ${callId} AND state = 'waiting'
           AND available_at <= ${ts(input.now)}
         RETURNING id
       `
@@ -8096,21 +8098,22 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
     const tenantId = yield* current();
     return yield* repositoryTransaction(Effect37.gen(function* () {
       const expiredRows = yield* sql`
-            SELECT id, active_attempt_id
+            SELECT execution_id, id, active_attempt_id
             FROM relay_tool_calls
             WHERE tenant_id = ${tenantId} AND placement_kind = 'remote' AND placement_key = ${input.queue}
               AND state = 'running' AND claim_expires_at IS NOT NULL AND claim_expires_at <= ${ts(input.now)}
           `.pipe(Effect37.mapError(toRepositoryError17));
       const expired = yield* Schema35.decodeUnknownEffect(Schema35.Array(ExpiredCallRow))(expiredRows).pipe(Effect37.mapError(toRepositoryError17));
       for (const row of expired) {
+        const executionId2 = exports_ids_schema.ExecutionId.make(row.execution_id);
         if (row.active_attempt_id !== null && row.active_attempt_id !== undefined) {
-          yield* completeAttempt(tenantId, exports_ids_schema.ToolCallId.make(row.id), exports_ids_schema.ToolAttemptId.make(row.active_attempt_id), "expired", input.now);
+          yield* completeAttempt(tenantId, executionId2, exports_ids_schema.ToolCallId.make(row.id), exports_ids_schema.ToolAttemptId.make(row.active_attempt_id), "expired", input.now);
         }
         yield* sql`
               UPDATE relay_tool_calls
               SET state = 'waiting', active_attempt_id = NULL, claim_owner = NULL, claimed_at = NULL,
                   claim_expires_at = NULL, updated_at = ${ts(input.now)}
-              WHERE tenant_id = ${tenantId} AND id = ${row.id} AND state = 'running'
+              WHERE tenant_id = ${tenantId} AND execution_id = ${executionId2} AND id = ${row.id} AND state = 'running'
             `.pipe(Effect37.mapError(toRepositoryError17));
       }
       const candidateRows = yield* selectClaimCandidate(tenantId, input).pipe(Effect37.mapError(toRepositoryError17));
@@ -8118,21 +8121,22 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
       const candidate = candidates[0];
       if (candidate === undefined)
         return;
+      const executionId = exports_ids_schema.ExecutionId.make(candidate.execution_id);
       const callId = exports_ids_schema.ToolCallId.make(candidate.id);
-      const call = yield* readLockedCall(tenantId, callId);
+      const call = yield* readLockedCall(tenantId, executionId, callId);
       if (call.definition === undefined || call.placement.kind !== "remote") {
         return yield* ToolCallTransitionRejected.make({
           id: callId,
           message: "Remote call definition snapshot is missing"
         });
       }
-      const attemptNumber = yield* nextAttemptNumber(tenantId, callId);
+      const attemptNumber = yield* nextAttemptNumber(tenantId, executionId, callId);
       const attemptId = toolAttemptId(attemptNumber);
-      const claimed = yield* claimCall(tenantId, callId, attemptId, input).pipe(Effect37.mapError(toRepositoryError17));
+      const claimed = yield* claimCall(tenantId, executionId, callId, attemptId, input).pipe(Effect37.mapError(toRepositoryError17));
       if (claimed[0] === undefined)
         return;
-      const attempt = yield* insertAttemptNumber(tenantId, callId, attemptNumber, input.now, input.workerId, input.claimExpiresAt);
-      const updated = yield* readLockedCall(tenantId, callId);
+      const attempt = yield* insertAttemptNumber(tenantId, executionId, callId, attemptNumber, input.now, input.workerId, input.claimExpiresAt);
+      const updated = yield* readLockedCall(tenantId, executionId, callId);
       if (updated.definition === undefined || updated.placement.kind !== "remote") {
         return yield* ToolCallTransitionRejected.make({
           id: callId,
@@ -8152,25 +8156,25 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
   const releaseRemote = Effect37.fn("ToolCallRepository.releaseRemote")(function* (input) {
     const tenantId = yield* current();
     return yield* repositoryTransaction(Effect37.gen(function* () {
-      const call = yield* readLockedCall(tenantId, input.callId);
+      const call = yield* readLockedCall(tenantId, input.executionId, input.callId);
       if (call.placement.kind !== "remote" || call.state !== "running" || call.activeAttemptId !== input.attemptId || call.claimOwner !== input.workerId || call.claimExpiresAt === undefined || call.claimExpiresAt <= input.releasedAt) {
         return yield* ToolClaimRejected.make({ message: "Remote claim is not active" });
       }
-      yield* completeAttempt(tenantId, input.callId, input.attemptId, "released", input.releasedAt, input.error);
+      yield* completeAttempt(tenantId, input.executionId, input.callId, input.attemptId, "released", input.releasedAt, input.error);
       yield* sql`
             UPDATE relay_tool_calls
             SET state = 'waiting', available_at = ${ts(input.nextAvailableAt)}, active_attempt_id = NULL,
                 claim_owner = NULL, claimed_at = NULL, claim_expires_at = NULL,
                 updated_at = ${ts(input.releasedAt)}
-            WHERE tenant_id = ${tenantId} AND id = ${input.callId}
+            WHERE tenant_id = ${tenantId} AND execution_id = ${input.executionId} AND id = ${input.callId}
           `.pipe(Effect37.mapError(toRepositoryError17));
-      return yield* readLockedCall(tenantId, input.callId);
+      return yield* readLockedCall(tenantId, input.executionId, input.callId);
     }));
   });
   const acceptRemoteOutcome = Effect37.fn("ToolCallRepository.acceptRemoteOutcome")(function* (input) {
     const tenantId = yield* current();
     return yield* repositoryTransaction(Effect37.gen(function* () {
-      const call = yield* readLockedCall(tenantId, input.callId);
+      const call = yield* readLockedCall(tenantId, input.executionId, input.callId);
       if (call.externalOutcome !== undefined) {
         if (!exports_shared_schema.canonicalEquals(call.externalOutcome, input.outcome)) {
           return yield* ToolOutcomeConflict.make({ id: input.callId });
@@ -8178,7 +8182,7 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
         if (call.activeAttemptId !== input.attemptId) {
           return yield* ToolClaimRejected.make({ message: "Remote attempt was not accepted" });
         }
-        const attempt2 = yield* loadAttempt(tenantId, input.callId, input.attemptId);
+        const attempt2 = yield* loadAttempt(tenantId, input.executionId, input.callId, input.attemptId);
         if (attempt2 === undefined || attempt2.callId !== input.callId || attempt2.workerId !== input.workerId) {
           return yield* ToolClaimRejected.make({ message: "Remote attempt was not accepted" });
         }
@@ -8187,21 +8191,21 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
       if (call.placement.kind !== "remote" || call.state !== "running" || call.activeAttemptId !== input.attemptId || call.claimOwner !== input.workerId || call.claimExpiresAt === undefined || call.claimExpiresAt <= input.submittedAt) {
         return yield* ToolClaimRejected.make({ message: "Remote claim is not active" });
       }
-      const attempt = yield* completeAttempt(tenantId, input.callId, input.attemptId, input.outcome.kind === "success" ? "completed" : "failed", input.submittedAt, input.outcome.kind === "failure" ? input.outcome.message : undefined);
+      const attempt = yield* completeAttempt(tenantId, input.executionId, input.callId, input.attemptId, input.outcome.kind === "success" ? "completed" : "failed", input.submittedAt, input.outcome.kind === "failure" ? input.outcome.message : undefined);
       yield* sql`
             UPDATE relay_tool_calls
             SET state = 'submitted', external_outcome_json = ${encodeJson(input.outcome)},
                 external_outcome_at = ${ts(input.submittedAt)}, claim_owner = NULL, claimed_at = NULL,
                 claim_expires_at = NULL, updated_at = ${ts(input.submittedAt)}
-            WHERE tenant_id = ${tenantId} AND id = ${input.callId}
+            WHERE tenant_id = ${tenantId} AND execution_id = ${input.executionId} AND id = ${input.callId}
           `.pipe(Effect37.mapError(toRepositoryError17));
-      const updated = yield* readLockedCall(tenantId, input.callId);
+      const updated = yield* readLockedCall(tenantId, input.executionId, input.callId);
       return { call: updated, attempt, duplicate: false };
     }));
   });
-  const listAttempts = Effect37.fn("ToolCallRepository.listAttempts")(function* (callId) {
+  const listAttempts = Effect37.fn("ToolCallRepository.listAttempts")(function* (executionId, callId) {
     const tenantId = yield* current();
-    return yield* readAttempts(tenantId, callId);
+    return yield* readAttempts(tenantId, executionId, callId);
   });
   const selectOpenCalls = sql.onDialectOrElse({
     pg: () => (tenantId, input) => sql`
@@ -8229,17 +8233,17 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
       `
   });
   const failCall = sql.onDialectOrElse({
-    mysql: () => (tenantId, callId, failedAt) => sql`
+    mysql: () => (tenantId, executionId, callId, failedAt) => sql`
           UPDATE relay_tool_calls
           SET state = 'failed', claim_owner = NULL, claimed_at = NULL, claim_expires_at = NULL,
               updated_at = ${ts(failedAt)}
-          WHERE tenant_id = ${tenantId} AND id = ${callId} AND state NOT IN ('submitted', 'completed', 'failed')
+          WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND id = ${callId} AND state NOT IN ('submitted', 'completed', 'failed')
         `.pipe(Effect37.as([{ id: callId }])),
-    orElse: () => (tenantId, callId, failedAt) => sql`
+    orElse: () => (tenantId, executionId, callId, failedAt) => sql`
         UPDATE relay_tool_calls
         SET state = 'failed', claim_owner = NULL, claimed_at = NULL, claim_expires_at = NULL,
             updated_at = ${ts(failedAt)}
-        WHERE tenant_id = ${tenantId} AND id = ${callId} AND state NOT IN ('submitted', 'completed', 'failed')
+        WHERE tenant_id = ${tenantId} AND execution_id = ${executionId} AND id = ${callId} AND state NOT IN ('submitted', 'completed', 'failed')
         RETURNING id
       `
   });
@@ -8253,30 +8257,31 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
       for (const call of open) {
         if (selected !== undefined && !selected.has(call.call.id))
           continue;
-        const transitioned = yield* failCall(tenantId, call.call.id, input.failedAt).pipe(Effect37.mapError(toRepositoryError17));
+        const transitioned = yield* failCall(tenantId, input.executionId, call.call.id, input.failedAt).pipe(Effect37.mapError(toRepositoryError17));
         if (transitioned[0] === undefined)
           continue;
         if (call.activeAttemptId !== undefined) {
-          const attempt = yield* loadAttempt(tenantId, call.call.id, call.activeAttemptId);
+          const attempt = yield* loadAttempt(tenantId, input.executionId, call.call.id, call.activeAttemptId);
           if (attempt?.state === "running") {
-            yield* completeAttempt(tenantId, call.call.id, call.activeAttemptId, "failed", input.failedAt, input.message);
+            yield* completeAttempt(tenantId, input.executionId, call.call.id, call.activeAttemptId, "failed", input.failedAt, input.message);
           }
         }
-        const existingResult = yield* selectResultByKey(tenantId, call.call.id).pipe(Effect37.mapError(toRepositoryError17));
+        const existingResult = yield* selectResultByKey(tenantId, input.executionId, call.call.id).pipe(Effect37.mapError(toRepositoryError17));
         if (existingResult[0] === undefined) {
           yield* insertResultStatement(tenantId, {
+            executionId: input.executionId,
             result: { call_id: call.call.id, output: null, error: input.message },
             createdAt: input.failedAt
           }).pipe(Effect37.mapError(toRepositoryError17));
         }
-        failed.push(yield* readLockedCall(tenantId, call.call.id));
+        failed.push(yield* readLockedCall(tenantId, input.executionId, call.call.id));
       }
       return failed;
     }));
   });
   const recordCall = Effect37.fn("ToolCallRepository.recordCall")(function* (input) {
     const tenantId = yield* current();
-    const existing = yield* selectCallByKey(tenantId, input.call.id).pipe(Effect37.mapError(toRepositoryError17));
+    const existing = yield* selectCallByKey(tenantId, input.executionId, input.call.id).pipe(Effect37.mapError(toRepositoryError17));
     if (existing[0] !== undefined)
       return yield* DuplicateToolCall.make({ id: input.call.id });
     const rows = yield* insertCall(tenantId, input).pipe(Effect37.mapError(toRepositoryError17));
@@ -8286,9 +8291,9 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
     }
     return yield* decodeCall(row);
   });
-  const getCall = Effect37.fn("ToolCallRepository.getCall")(function* (id) {
+  const getCall = Effect37.fn("ToolCallRepository.getCall")(function* (executionId, id) {
     const tenantId = yield* current();
-    const rows = yield* selectCallByKey(tenantId, id).pipe(Effect37.mapError(toRepositoryError17));
+    const rows = yield* selectCallByKey(tenantId, executionId, id).pipe(Effect37.mapError(toRepositoryError17));
     return rows[0] === undefined ? undefined : yield* decodeCall(rows[0]);
   });
   const listCalls = Effect37.fn("ToolCallRepository.listCalls")(function* (executionId) {
@@ -8304,16 +8309,16 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
   const recordResult = Effect37.fn("ToolCallRepository.recordResult")(function* (input) {
     const tenantId = yield* current();
     return yield* repositoryTransaction(Effect37.gen(function* () {
-      const call = yield* readLockedCall(tenantId, input.result.call_id);
-      const existing = yield* selectResultByKey(tenantId, input.result.call_id).pipe(Effect37.mapError(toRepositoryError17));
+      const call = yield* readLockedCall(tenantId, input.executionId, input.result.call_id);
+      const existing = yield* selectResultByKey(tenantId, input.executionId, input.result.call_id).pipe(Effect37.mapError(toRepositoryError17));
       if (existing[0] !== undefined) {
         return yield* DuplicateToolResult.make({ call_id: input.result.call_id });
       }
       yield* insertResultStatement(tenantId, input).pipe(Effect37.mapError(toRepositoryError17));
       if (call.activeAttemptId !== undefined) {
-        const attempt = yield* loadAttempt(tenantId, input.result.call_id, call.activeAttemptId);
+        const attempt = yield* loadAttempt(tenantId, input.executionId, input.result.call_id, call.activeAttemptId);
         if (attempt?.state === "running") {
-          yield* completeAttempt(tenantId, input.result.call_id, call.activeAttemptId, input.result.error === undefined ? "completed" : "failed", input.createdAt, input.result.error);
+          yield* completeAttempt(tenantId, input.executionId, input.result.call_id, call.activeAttemptId, input.result.error === undefined ? "completed" : "failed", input.createdAt, input.result.error);
         }
       }
       yield* sql`
@@ -8321,18 +8326,18 @@ var layer31 = Layer36.effect(Service38, Effect37.gen(function* () {
             SET state = ${input.result.error === undefined ? "completed" : "failed"},
                 claim_owner = NULL, claimed_at = NULL, claim_expires_at = NULL,
                 updated_at = ${ts(input.createdAt)}
-            WHERE tenant_id = ${tenantId} AND id = ${input.result.call_id}
+            WHERE tenant_id = ${tenantId} AND execution_id = ${input.executionId} AND id = ${input.result.call_id}
           `.pipe(Effect37.mapError(toRepositoryError17));
-      const rows = yield* selectResultByKey(tenantId, input.result.call_id).pipe(Effect37.mapError(toRepositoryError17));
+      const rows = yield* selectResultByKey(tenantId, input.executionId, input.result.call_id).pipe(Effect37.mapError(toRepositoryError17));
       if (rows[0] === undefined) {
         return yield* ToolCallRepositoryError.make({ message: "Tool result insert returned no row" });
       }
       return toResultRecord(yield* decodeResultRow(rows[0]));
     }));
   });
-  const getResult = Effect37.fn("ToolCallRepository.getResult")(function* (callId) {
+  const getResult = Effect37.fn("ToolCallRepository.getResult")(function* (executionId, callId) {
     const tenantId = yield* current();
-    const rows = yield* selectResultByKey(tenantId, callId).pipe(Effect37.mapError(toRepositoryError17));
+    const rows = yield* selectResultByKey(tenantId, executionId, callId).pipe(Effect37.mapError(toRepositoryError17));
     return rows[0] === undefined ? undefined : toResultRecord(yield* decodeResultRow(rows[0]));
   });
   return Service38.of({
@@ -8357,7 +8362,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
   const callTenants = new Map;
   const results = new Map;
   const attempts = new Map;
-  const key3 = (tenantId, callId) => exports_shared_schema.canonicalString([tenantId, callId]);
+  const key3 = (tenantId, executionId, callId) => exports_shared_schema.canonicalString([tenantId, executionId, callId]);
   const same = (left, right) => exports_shared_schema.canonicalEquals(left, right);
   const callRecord = (tenantId, input, definition, placement = { kind: "local" }) => ({
     executionId: input.executionId,
@@ -8370,13 +8375,13 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
     createdAt: input.createdAt,
     updatedAt: input.createdAt
   });
-  const attemptsFor = (tenantId, callId) => attempts.get(key3(tenantId, callId)) ?? [];
-  const replaceAttempt = (tenantId, attempt) => {
-    const callAttempts = attemptsFor(tenantId, attempt.callId);
-    attempts.set(key3(tenantId, attempt.callId), callAttempts.map((existing) => existing.id === attempt.id ? attempt : existing));
+  const attemptsFor = (tenantId, executionId, callId) => attempts.get(key3(tenantId, executionId, callId)) ?? [];
+  const replaceAttempt = (tenantId, executionId, attempt) => {
+    const callAttempts = attemptsFor(tenantId, executionId, attempt.callId);
+    attempts.set(key3(tenantId, executionId, attempt.callId), callAttempts.map((existing) => existing.id === attempt.id ? attempt : existing));
   };
-  const appendAttempt = (tenantId, callId, createdAt, options = {}) => {
-    const callAttempts = attemptsFor(tenantId, callId);
+  const appendAttempt = (tenantId, executionId, callId, createdAt, options = {}) => {
+    const callAttempts = attemptsFor(tenantId, executionId, callId);
     const attemptNumber = callAttempts.length + 1;
     const attempt = {
       id: toolAttemptId(attemptNumber),
@@ -8387,18 +8392,18 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
       ...options.claimExpiresAt === undefined ? {} : { claimExpiresAt: options.claimExpiresAt },
       createdAt
     };
-    attempts.set(key3(tenantId, callId), [...callAttempts, attempt]);
+    attempts.set(key3(tenantId, executionId, callId), [...callAttempts, attempt]);
     return attempt;
   };
-  const requireCall = (tenantId, callId) => {
-    const record2 = calls.get(key3(tenantId, callId));
+  const requireCall = (tenantId, executionId, callId) => {
+    const record2 = calls.get(key3(tenantId, executionId, callId));
     return record2 === undefined ? Effect37.fail(ToolCallNotFound.make({ id: callId })) : Effect37.succeed(record2);
   };
   const transitionRejected = (id, message) => Effect37.fail(ToolCallTransitionRejected.make({ id, message }));
   return Service38.of({
     ensureCall: Effect37.fn("ToolCallRepository.memory.ensureCall")(function* (input) {
       const tenantId = yield* current();
-      const storageKey = key3(tenantId, input.call.id);
+      const storageKey = key3(tenantId, input.executionId, input.call.id);
       const existing = calls.get(storageKey);
       if (existing !== undefined) {
         if (existing.executionId !== input.executionId || !sameCallIdentity(existing.call, input.call) || !same(existing.definition, input.definition) || !same(existing.placement, input.placement)) {
@@ -8413,7 +8418,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
     }),
     recordCall: Effect37.fn("ToolCallRepository.memory.recordCall")(function* (input) {
       const tenantId = yield* current();
-      const storageKey = key3(tenantId, input.call.id);
+      const storageKey = key3(tenantId, input.executionId, input.call.id);
       if (calls.has(storageKey))
         return yield* DuplicateToolCall.make({ id: input.call.id });
       const record2 = callRecord(tenantId, input);
@@ -8421,9 +8426,9 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
       callTenants.set(storageKey, tenantId);
       return record2;
     }),
-    getCall: Effect37.fn("ToolCallRepository.memory.getCall")(function* (id) {
+    getCall: Effect37.fn("ToolCallRepository.memory.getCall")(function* (executionId, id) {
       const tenantId = yield* current();
-      return calls.get(key3(tenantId, id));
+      return calls.get(key3(tenantId, executionId, id));
     }),
     listCalls: Effect37.fn("ToolCallRepository.memory.listCalls")(function* (executionId) {
       const tenantId = yield* current();
@@ -8431,7 +8436,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
     }),
     recordResult: Effect37.fn("ToolCallRepository.memory.recordResult")(function* (input) {
       const tenantId = yield* current();
-      const storageKey = key3(tenantId, input.result.call_id);
+      const storageKey = key3(tenantId, input.executionId, input.result.call_id);
       const call = calls.get(storageKey);
       if (call === undefined)
         return yield* ToolCallNotFound.make({ id: input.result.call_id });
@@ -8439,9 +8444,9 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         return yield* DuplicateToolResult.make({ call_id: input.result.call_id });
       }
       if (call.activeAttemptId !== undefined) {
-        const active = attemptsFor(tenantId, input.result.call_id).find((attempt) => attempt.id === call.activeAttemptId);
+        const active = attemptsFor(tenantId, input.executionId, input.result.call_id).find((attempt) => attempt.id === call.activeAttemptId);
         if (active?.state === "running") {
-          replaceAttempt(tenantId, {
+          replaceAttempt(tenantId, input.executionId, {
             ...active,
             state: input.result.error === undefined ? "completed" : "failed",
             ...input.result.error === undefined ? {} : { error: input.result.error },
@@ -8458,13 +8463,13 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
       });
       return record2;
     }),
-    getResult: Effect37.fn("ToolCallRepository.memory.getResult")(function* (callId) {
+    getResult: Effect37.fn("ToolCallRepository.memory.getResult")(function* (executionId, callId) {
       const tenantId = yield* current();
-      return results.get(key3(tenantId, callId));
+      return results.get(key3(tenantId, executionId, callId));
     }),
     prepareExternalWait: Effect37.fn("ToolCallRepository.memory.prepareExternalWait")(function* (input) {
       const tenantId = yield* current();
-      const call = yield* requireCall(tenantId, input.callId);
+      const call = yield* requireCall(tenantId, input.executionId, input.callId);
       if (call.placement.kind !== "client" && call.placement.kind !== "remote") {
         return yield* transitionRejected(input.callId, "Tool placement is not external");
       }
@@ -8479,12 +8484,12 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         availableAt: input.availableAt,
         updatedAt: input.updatedAt
       };
-      calls.set(key3(tenantId, input.callId), updated);
+      calls.set(key3(tenantId, input.executionId, input.callId), updated);
       return updated;
     }),
     beginAttempt: Effect37.fn("ToolCallRepository.memory.beginAttempt")(function* (input) {
       const tenantId = yield* current();
-      const call = yield* requireCall(tenantId, input.callId);
+      const call = yield* requireCall(tenantId, input.executionId, input.callId);
       if (call.placement.kind !== "local" && call.placement.kind !== "mcp") {
         return yield* transitionRejected(input.callId, "Tool placement is not immediate");
       }
@@ -8492,13 +8497,13 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         return yield* transitionRejected(input.callId, `Call is ${call.state}`);
       }
       if (call.activeAttemptId !== undefined) {
-        const active = attemptsFor(tenantId, input.callId).find((attempt2) => attempt2.id === call.activeAttemptId);
+        const active = attemptsFor(tenantId, input.executionId, input.callId).find((attempt2) => attempt2.id === call.activeAttemptId);
         if (active?.state === "running") {
-          replaceAttempt(tenantId, { ...active, state: "abandoned", completedAt: input.startedAt });
+          replaceAttempt(tenantId, input.executionId, { ...active, state: "abandoned", completedAt: input.startedAt });
         }
       }
-      const attempt = appendAttempt(tenantId, input.callId, input.startedAt);
-      calls.set(key3(tenantId, input.callId), {
+      const attempt = appendAttempt(tenantId, input.executionId, input.callId, input.startedAt);
+      calls.set(key3(tenantId, input.executionId, input.callId), {
         ...call,
         state: "running",
         activeAttemptId: attempt.id,
@@ -8508,7 +8513,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
     }),
     acceptClientOutcome: Effect37.fn("ToolCallRepository.memory.acceptClientOutcome")(function* (input) {
       const tenantId = yield* current();
-      const call = yield* requireCall(tenantId, input.callId);
+      const call = yield* requireCall(tenantId, input.executionId, input.callId);
       if (call.executionId !== input.executionId || call.placement.kind !== "client") {
         return yield* transitionRejected(input.callId, "Client outcome does not match the call");
       }
@@ -8516,21 +8521,21 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         if (!same(call.externalOutcome, input.outcome)) {
           return yield* ToolOutcomeConflict.make({ id: input.callId });
         }
-        const attempt2 = attemptsFor(tenantId, input.callId).find((item) => item.id === call.activeAttemptId);
+        const attempt2 = attemptsFor(tenantId, input.executionId, input.callId).find((item) => item.id === call.activeAttemptId);
         if (attempt2 === undefined)
           return yield* transitionRejected(input.callId, "Accepted attempt is missing");
         return { call, attempt: attempt2, duplicate: true };
       }
       if (call.state !== "waiting")
         return yield* transitionRejected(input.callId, `Call is ${call.state}`);
-      const running = appendAttempt(tenantId, input.callId, input.submittedAt);
+      const running = appendAttempt(tenantId, input.executionId, input.callId, input.submittedAt);
       const attempt = {
         ...running,
         state: input.outcome.kind === "success" ? "completed" : "failed",
         ...input.outcome.kind === "failure" ? { error: input.outcome.message } : {},
         completedAt: input.submittedAt
       };
-      replaceAttempt(tenantId, attempt);
+      replaceAttempt(tenantId, input.executionId, attempt);
       const updated = {
         ...call,
         state: "submitted",
@@ -8539,7 +8544,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         externalOutcomeAt: input.submittedAt,
         updatedAt: input.submittedAt
       };
-      calls.set(key3(tenantId, input.callId), updated);
+      calls.set(key3(tenantId, input.executionId, input.callId), updated);
       return { call: updated, attempt, duplicate: false };
     }),
     claimRemote: Effect37.fn("ToolCallRepository.memory.claimRemote")(function* (input) {
@@ -8551,9 +8556,9 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         if (callTenants.get(storageKey) !== tenantId || call.placement.kind !== "remote" || call.state !== "running" || call.claimExpiresAt === undefined || call.claimExpiresAt > input.now) {
           continue;
         }
-        const active = attemptsFor(tenantId, call.call.id).find((attempt2) => attempt2.id === call.activeAttemptId);
+        const active = attemptsFor(tenantId, call.executionId, call.call.id).find((attempt2) => attempt2.id === call.activeAttemptId);
         if (active?.state === "running") {
-          replaceAttempt(tenantId, { ...active, state: "expired", completedAt: input.now });
+          replaceAttempt(tenantId, call.executionId, { ...active, state: "expired", completedAt: input.now });
         }
         calls.set(storageKey, {
           ...call,
@@ -8571,7 +8576,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
       if (candidate.definition === undefined) {
         return yield* transitionRejected(candidate.call.id, "Remote call definition snapshot is missing");
       }
-      const attempt = appendAttempt(tenantId, candidate.call.id, input.now, {
+      const attempt = appendAttempt(tenantId, candidate.executionId, candidate.call.id, input.now, {
         workerId: input.workerId,
         claimExpiresAt: input.claimExpiresAt
       });
@@ -8585,7 +8590,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         claimExpiresAt: input.claimExpiresAt,
         updatedAt: input.now
       };
-      calls.set(key3(tenantId, candidate.call.id), updated);
+      calls.set(key3(tenantId, candidate.executionId, candidate.call.id), updated);
       return {
         call: updated,
         attempt,
@@ -8597,14 +8602,14 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
     }),
     releaseRemote: Effect37.fn("ToolCallRepository.memory.releaseRemote")(function* (input) {
       const tenantId = yield* current();
-      const call = yield* requireCall(tenantId, input.callId);
+      const call = yield* requireCall(tenantId, input.executionId, input.callId);
       const valid = call.placement.kind === "remote" && call.state === "running" && call.activeAttemptId === input.attemptId && call.claimOwner === input.workerId && call.claimExpiresAt !== undefined && call.claimExpiresAt > input.releasedAt;
       if (!valid)
         return yield* ToolClaimRejected.make({ message: "Remote claim is not active" });
-      const attempt = attemptsFor(tenantId, input.callId).find((item) => item.id === input.attemptId);
+      const attempt = attemptsFor(tenantId, input.executionId, input.callId).find((item) => item.id === input.attemptId);
       if (attempt === undefined)
         return yield* transitionRejected(input.callId, "Remote attempt is missing");
-      replaceAttempt(tenantId, {
+      replaceAttempt(tenantId, input.executionId, {
         ...attempt,
         state: "released",
         ...input.error === undefined ? {} : { error: input.error },
@@ -8620,12 +8625,12 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         claimExpiresAt: undefined,
         updatedAt: input.releasedAt
       };
-      calls.set(key3(tenantId, input.callId), updated);
+      calls.set(key3(tenantId, input.executionId, input.callId), updated);
       return updated;
     }),
     acceptRemoteOutcome: Effect37.fn("ToolCallRepository.memory.acceptRemoteOutcome")(function* (input) {
       const tenantId = yield* current();
-      const call = yield* requireCall(tenantId, input.callId);
+      const call = yield* requireCall(tenantId, input.executionId, input.callId);
       if (call.externalOutcome !== undefined) {
         if (!same(call.externalOutcome, input.outcome)) {
           return yield* ToolOutcomeConflict.make({ id: input.callId });
@@ -8633,7 +8638,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         if (call.activeAttemptId !== input.attemptId) {
           return yield* ToolClaimRejected.make({ message: "Remote attempt was not accepted" });
         }
-        const attempt2 = attemptsFor(tenantId, input.callId).find((item) => item.id === input.attemptId);
+        const attempt2 = attemptsFor(tenantId, input.executionId, input.callId).find((item) => item.id === input.attemptId);
         if (attempt2 === undefined || attempt2.callId !== input.callId || attempt2.workerId !== input.workerId) {
           return yield* ToolClaimRejected.make({ message: "Remote attempt was not accepted" });
         }
@@ -8642,7 +8647,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
       const valid = call.placement.kind === "remote" && call.state === "running" && call.activeAttemptId === input.attemptId && call.claimOwner === input.workerId && call.claimExpiresAt !== undefined && call.claimExpiresAt > input.submittedAt;
       if (!valid)
         return yield* ToolClaimRejected.make({ message: "Remote claim is not active" });
-      const running = attemptsFor(tenantId, input.callId).find((item) => item.id === input.attemptId);
+      const running = attemptsFor(tenantId, input.executionId, input.callId).find((item) => item.id === input.attemptId);
       if (running === undefined)
         return yield* transitionRejected(input.callId, "Remote attempt is missing");
       const attempt = {
@@ -8651,7 +8656,7 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         ...input.outcome.kind === "failure" ? { error: input.outcome.message } : {},
         completedAt: input.submittedAt
       };
-      replaceAttempt(tenantId, attempt);
+      replaceAttempt(tenantId, input.executionId, attempt);
       const updated = {
         ...call,
         state: "submitted",
@@ -8662,12 +8667,12 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
         claimExpiresAt: undefined,
         updatedAt: input.submittedAt
       };
-      calls.set(key3(tenantId, input.callId), updated);
+      calls.set(key3(tenantId, input.executionId, input.callId), updated);
       return { call: updated, attempt, duplicate: false };
     }),
-    listAttempts: Effect37.fn("ToolCallRepository.memory.listAttempts")(function* (callId) {
+    listAttempts: Effect37.fn("ToolCallRepository.memory.listAttempts")(function* (executionId, callId) {
       const tenantId = yield* current();
-      return attemptsFor(tenantId, callId);
+      return attemptsFor(tenantId, executionId, callId);
     }),
     failOpenForExecution: Effect37.fn("ToolCallRepository.memory.failOpenForExecution")(function* (input) {
       const tenantId = yield* current();
@@ -8677,9 +8682,9 @@ var memoryLayer29 = Layer36.sync(Service38, () => {
           continue;
         }
         if (call.activeAttemptId !== undefined) {
-          const active = attemptsFor(tenantId, call.call.id).find((attempt) => attempt.id === call.activeAttemptId);
+          const active = attemptsFor(tenantId, input.executionId, call.call.id).find((attempt) => attempt.id === call.activeAttemptId);
           if (active?.state === "running") {
-            replaceAttempt(tenantId, {
+            replaceAttempt(tenantId, input.executionId, {
               ...active,
               state: "failed",
               error: input.message,
@@ -8723,9 +8728,9 @@ var recordCall = Effect37.fn("ToolCallRepository.recordCall.call")(function* (in
   const repository = yield* Service38;
   return yield* repository.recordCall(input);
 });
-var getCall = Effect37.fn("ToolCallRepository.getCall.call")(function* (id) {
+var getCall = Effect37.fn("ToolCallRepository.getCall.call")(function* (executionId, id) {
   const repository = yield* Service38;
-  return yield* repository.getCall(id);
+  return yield* repository.getCall(executionId, id);
 });
 var listCalls = Effect37.fn("ToolCallRepository.listCalls.call")(function* (executionId) {
   const repository = yield* Service38;
@@ -8735,9 +8740,9 @@ var recordResult = Effect37.fn("ToolCallRepository.recordResult.call")(function*
   const repository = yield* Service38;
   return yield* repository.recordResult(input);
 });
-var getResult = Effect37.fn("ToolCallRepository.getResult.call")(function* (callId) {
+var getResult = Effect37.fn("ToolCallRepository.getResult.call")(function* (executionId, callId) {
   const repository = yield* Service38;
-  return yield* repository.getResult(callId);
+  return yield* repository.getResult(executionId, callId);
 });
 var ensureCall = Effect37.fn("ToolCallRepository.ensureCall.call")(function* (input) {
   const repository = yield* Service38;
@@ -8767,9 +8772,9 @@ var acceptRemoteOutcome = Effect37.fn("ToolCallRepository.acceptRemoteOutcome.ca
   const repository = yield* Service38;
   return yield* repository.acceptRemoteOutcome(input);
 });
-var listAttempts = Effect37.fn("ToolCallRepository.listAttempts.call")(function* (callId) {
+var listAttempts = Effect37.fn("ToolCallRepository.listAttempts.call")(function* (executionId, callId) {
   const repository = yield* Service38;
-  return yield* repository.listAttempts(callId);
+  return yield* repository.listAttempts(executionId, callId);
 });
 var failOpenForExecution = Effect37.fn("ToolCallRepository.failOpenForExecution.call")(function* (input) {
   const repository = yield* Service38;
@@ -10078,6 +10083,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);
@@ -10112,7 +10124,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,
@@ -10130,7 +10142,7 @@ var ensureToolEvent = (eventLog, event) => eventLog.findByCursor({ executionId:
   onSome: (existing) => sameToolEventPayload(existing, event) ? Effect43.void : Effect43.fail(ToolRuntimeError.make({ message: "EventLogError" }))
 })));
 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,
@@ -10199,11 +10211,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,
@@ -10211,13 +10223,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,
@@ -10232,14 +10244,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,
@@ -10252,11 +10264,11 @@ 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);
+    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));
@@ -10272,7 +10284,7 @@ var recordRequested = (repository, eventLog, input, tool) => repository.ensureCa
   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({ result, createdAt: input.createdAt + 1 }).pipe(Effect43.catchTag("DuplicateToolResult", () => repository.getResult(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 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 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) => ({
@@ -10351,7 +10363,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,
@@ -10371,11 +10383,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,
@@ -10390,13 +10402,14 @@ var runExternalTool = (repository, waits, call, input) => Effect43.gen(function*
     }).pipe(Effect43.mapError(mapWaitServiceError));
   }
   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")
@@ -10429,7 +10442,7 @@ var makeService = (initialTools) => Effect43.gen(function* () {
         yield* ensureAllowed(registeredTool, input);
         yield* validateInput(registeredTool, input);
         const call = yield* recordRequested(repository, eventLog, input, registeredTool);
-        const existingResult = yield* repository.getResult(input.call.id).pipe(Effect43.mapError(mapRepositoryError3));
+        const existingResult = yield* repository.getResult(input.executionId, input.call.id).pipe(Effect43.mapError(mapRepositoryError3));
         if (existingResult !== undefined) {
           yield* repairResultEvent(eventLog, input, existingResult);
           return existingResult.result;
@@ -10451,7 +10464,11 @@ var makeService = (initialTools) => Effect43.gen(function* () {
             }
           }
         }
-        const rawResult = call.placement.kind === "client" || call.placement.kind === "remote" ? yield* runExternalTool(repository, waits, call, effectiveInput) : yield* repository.beginAttempt({ callId: input.call.id, startedAt: effectiveInput.createdAt }).pipe(Effect43.mapError(mapRepositoryError3), Effect43.flatMap(() => finalToolResult(registeredTool, effectiveInput, call.idempotencyKey)), Effect43.catchTag("ToolExecutionFailed", (error5) => Effect43.succeed(placementFailureResult(input, error5.message))));
+        const rawResult = call.placement.kind === "client" || call.placement.kind === "remote" ? yield* runExternalTool(repository, waits, call, effectiveInput) : yield* 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);
         yield* recordToolCall(input.call.name, result.error === undefined ? "success" : "failure");
@@ -11452,10 +11469,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,
@@ -11467,7 +11484,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,
@@ -11483,7 +11500,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) })));
 });
@@ -11507,10 +11524,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);
@@ -11540,9 +11557,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.",
@@ -13343,9 +13360,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}`,
@@ -13400,7 +13417,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
 });
@@ -13474,8 +13491,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;
@@ -13623,11 +13640,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),
@@ -13747,7 +13764,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,
@@ -13801,8 +13818,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({
@@ -13896,8 +13913,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;
@@ -13920,32 +13937,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
   })
@@ -14006,8 +14023,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) {
@@ -14017,14 +14034,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);
@@ -14043,11 +14060,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;
@@ -14085,14 +14102,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
         });
@@ -14231,9 +14248,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
         })));
@@ -14259,14 +14276,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,
@@ -14279,7 +14296,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) {
@@ -14291,7 +14308,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 };
     })
   });
 }));
@@ -14444,8 +14461,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: [] };
@@ -14454,7 +14471,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();
@@ -14462,7 +14479,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}`,
@@ -14472,13 +14489,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 });
   })
 });
 
@@ -14659,18 +14676,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 })));
@@ -14678,7 +14695,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 });
       }
@@ -14691,17 +14708,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 });
@@ -14709,7 +14726,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));
       }
@@ -14718,8 +14735,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 });
@@ -14785,9 +14802,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) {
@@ -14796,7 +14813,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) {
@@ -14808,7 +14825,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) {
@@ -14824,10 +14841,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;
@@ -14839,18 +14856,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
@@ -14877,7 +14894,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,
@@ -14897,19 +14914,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,
@@ -14924,17 +14941,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);
@@ -16334,16 +16351,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({
@@ -17580,13 +17597,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}` });
   }
@@ -17602,7 +17619,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 }
@@ -17747,10 +17764,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,
@@ -17761,7 +17778,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);
@@ -17941,7 +17958,7 @@ var layerFromRuntime3 = Layer80.effect(Service, Effect90.gen(function* () {
       return yield* ExecutionNotFound.make({ execution_id: executionId });
     const openWaits = yield* envelopeReady.listAllWaits({ executionId, state: "open" }).pipe(Effect90.mapError(toClientError));
     const calls = yield* toolCalls2.listCalls(executionId).pipe(Effect90.mapError(toClientError));
-    const pendingChunks = yield* Effect90.forEach(calls, (call) => toolCalls2.getResult(call.call.id).pipe(Effect90.mapError(toClientError), Effect90.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
+    const pendingChunks = yield* Effect90.forEach(calls, (call) => toolCalls2.getResult(call.executionId, call.call.id).pipe(Effect90.mapError(toClientError), Effect90.map((result) => result === undefined ? [toToolCallSummary(call)] : [])));
     const children = yield* childExecutions.listByExecution(executionId).pipe(Effect90.mapError(toClientError));
     const maxSequence3 = yield* eventLog.maxSequence(executionId).pipe(Effect90.mapError(toClientError));
     const lastEvent = maxSequence3 === undefined ? undefined : yield* eventLog.findBySequence({ executionId, sequence: maxSequence3 }).pipe(Effect90.mapError(toClientError), Effect90.map(Option23.getOrUndefined));
@@ -18407,13 +18424,13 @@ var layerFromRuntime3 = Layer80.effect(Service, Effect90.gen(function* () {
         state: "open",
         ...input.execution_id === undefined ? {} : { executionId: input.execution_id }
       }).pipe(Effect90.mapError(toClientError));
-      const records = yield* Effect90.forEach(openWaits.filter((wait) => wait.metadata.kind === "tool-placement"), (wait) => toolCalls2.getCall(exports_ids_schema.ToolCallId.make(String(wait.metadata.tool_call_id ?? ""))).pipe(Effect90.mapError(toClientError), Effect90.map((call) => call?.placement.kind === "client" && call.state === "waiting" ? toPendingToolCall(call) : undefined)));
+      const records = yield* Effect90.forEach(openWaits.filter((wait) => wait.metadata.kind === "tool-placement"), (wait) => toolCalls2.getCall(wait.executionId, exports_ids_schema.ToolCallId.make(String(wait.metadata.tool_call_id ?? ""))).pipe(Effect90.mapError(toClientError), Effect90.map((call) => call?.placement.kind === "client" && call.state === "waiting" ? toPendingToolCall(call) : undefined)));
       const sorted = records.filter((record2) => record2 !== undefined).toSorted((left, right) => left.requested_at - right.requested_at || left.call.id.localeCompare(right.call.id));
       return { tool_calls: input.limit === undefined ? sorted : sorted.slice(0, input.limit) };
     }),
     fulfillToolCall: Effect90.fn("Client.runtime.fulfillToolCall")(function* (input) {
       const coordinated = yield* coordinateToolTransition(Effect90.gen(function* () {
-        const call = yield* toolCalls2.getCall(input.tool_call_id).pipe(Effect90.mapError(toClientError));
+        const call = yield* toolCalls2.getCall(input.execution_id, input.tool_call_id).pipe(Effect90.mapError(toClientError));
         if (call === undefined || call.executionId !== input.execution_id || call.placement.kind !== "client") {
           return yield* ClientError.make({ message: `Client tool call not found: ${input.tool_call_id}` });
         }
@@ -18440,7 +18457,7 @@ var layerFromRuntime3 = Layer80.effect(Service, Effect90.gen(function* () {
     }),
     completeToolWork: Effect90.fn("Client.runtime.completeToolWork")(function* (input) {
       const coordinated = yield* coordinateToolTransition(Effect90.gen(function* () {
-        const call = yield* toolCalls2.getCall(input.tool_call_id).pipe(Effect90.mapError(toClientError));
+        const call = yield* toolCalls2.getCall(input.execution_id, input.tool_call_id).pipe(Effect90.mapError(toClientError));
         const active = call !== undefined && call.placement.kind === "remote" && call.state === "running" && call.activeAttemptId === input.attempt_id && call.claimOwner === input.worker_id && call.claimExpiresAt !== undefined && call.claimExpiresAt > input.completed_at;
         const acceptedRetry = call !== undefined && call.placement.kind === "remote" && call.state === "submitted" && call.activeAttemptId === input.attempt_id && call.externalOutcome !== undefined;
         if (call === undefined || !active && !acceptedRetry) {
@@ -18448,6 +18465,7 @@ var layerFromRuntime3 = Layer80.effect(Service, Effect90.gen(function* () {
         }
         const wait = yield* resolveToolOutcomeWait(waits, eventLog, call, input.outcome, input.completed_at);
         const accepted2 = yield* toolCalls2.acceptRemoteOutcome({
+          executionId: input.execution_id,
           callId: input.tool_call_id,
           attemptId: input.attempt_id,
           workerId: input.worker_id,
@@ -18461,6 +18479,7 @@ var layerFromRuntime3 = Layer80.effect(Service, Effect90.gen(function* () {
     }),
     releaseToolWork: Effect90.fn("Client.runtime.releaseToolWork")(function* (input) {
       const call = yield* coordinateToolTransition(toolCalls2.releaseRemote({
+        executionId: input.execution_id,
         callId: input.tool_call_id,
         attemptId: input.attempt_id,
         workerId: input.worker_id,
@@ -18475,7 +18494,7 @@ var layerFromRuntime3 = Layer80.effect(Service, Effect90.gen(function* () {
       };
     }),
     listToolAttempts: Effect90.fn("Client.runtime.listToolAttempts")(function* (input) {
-      const attempts = yield* toolCalls2.listAttempts(input.tool_call_id).pipe(Effect90.mapError(toClientError));
+      const attempts = yield* toolCalls2.listAttempts(input.execution_id, input.tool_call_id).pipe(Effect90.mapError(toClientError));
       return { attempts: attempts.map(toToolAttempt) };
     }),
     submitInboundEnvelope: Effect90.fn("Client.runtime.submitInboundEnvelope")(function* (input) {