@relayfx/sdk 0.3.4 → 0.3.5

package/dist/{index-01rpd00m.js → index-cq8t8ka1.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-cyfx5y3r.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;
@@ -10272,7 +10277,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) => ({
@@ -10390,6 +10395,7 @@ 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,
     availableAt: input.createdAt,
@@ -10429,7 +10435,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 +10457,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");
@@ -17941,7 +17951,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 +18417,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 +18450,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 +18458,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 +18472,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 +18487,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) {