@relayfx/sdk 0.3.3 → 0.3.5

package/dist/{index-8pa5e2yn.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");
@@ -15467,11 +15477,24 @@ var reconcileCompactionCheckpoint = Effect81.fn("AgentLoop.reconcileCompactionCh
   const checkpoint = path2.at(-1);
   if (checkpoint?._tag !== "Compaction" || checkpoint.version !== 2)
     return restoredHistory;
+  const entryScope = input.sessionEntryScope ?? input.executionId;
+  if (!checkpoint.id.startsWith(`${input.sessionId}:entry:${entryScope}:`))
+    return restoredHistory;
+  const result = {
+    _tag: "AlreadyPresent",
+    checkpoint,
+    leafId: checkpoint.id
+  };
+  const repaired = exports_session.buildContext(path2);
+  if (restoredHistory === undefined) {
+    yield* persistTranscript(chats, input, repaired);
+    yield* onCheckpointCommitted(result);
+    return repaired;
+  }
   const before = exports_session.buildContext(path2.slice(0, -1));
   if (!promptEquivalence2(before, restoredHistory)) {
-    const repaired2 = exports_session.buildContext(path2);
-    if (promptEquivalence2(repaired2, restoredHistory)) {
-      yield* onCheckpointCommitted(checkpoint);
+    if (promptEquivalence2(repaired, restoredHistory)) {
+      yield* onCheckpointCommitted(result);
       return restoredHistory;
     }
     if (!failOnMismatch)
@@ -15481,9 +15504,8 @@ var reconcileCompactionCheckpoint = Effect81.fn("AgentLoop.reconcileCompactionCh
       next_event_sequence: input.eventSequence + 1
     });
   }
-  const repaired = exports_session.buildContext(path2);
   yield* persistTranscript(chats, input, repaired);
-  yield* onCheckpointCommitted(checkpoint);
+  yield* onCheckpointCommitted(result);
   return repaired;
 });
 var toolCallDecodeMaxRetriesConfig = Config4.int("RELAY_AGENT_TOOL_CALL_DECODE_MAX_RETRIES").pipe(Config4.withDefault(2));
@@ -15631,7 +15653,7 @@ var compactionOptions = (agent) => agent.compaction_policy === undefined ? undef
   reserveTokens: agent.compaction_policy.reserve_tokens,
   keepRecentTokens: agent.compaction_policy.keep_recent_tokens
 };
-var layer58 = Layer71.effect(Service61, Effect81.gen(function* () {
+var make11 = (layerOptions) => Effect81.gen(function* () {
   const eventLog = yield* Service41;
   const languageModels = yield* Service8;
   const tools = yield* Service12;
@@ -15714,12 +15736,12 @@ var layer58 = Layer71.effect(Service61, Effect81.gen(function* () {
         input: jsonValue6(resumeSuspension.tool_params)
       };
       const storedHistory = resumeToolCall === undefined ? yield* loadStoredHistory(chats, input) : yield* restoreHistory(chats, input);
-      const continuingDurableHistory = storedHistory !== undefined;
-      const durableMaxSequence = continuingDurableHistory ? yield* eventLog.maxSequence(input.executionId).pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1))) : undefined;
+      const durableMaxSequence = yield* eventLog.maxSequence(input.executionId).pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1)));
       const nextEventSequence5 = Math.max(input.eventSequence + 1, (durableMaxSequence ?? -1) + 1);
       const allocator = yield* make10(nextEventSequence5);
-      const onCheckpointCommitted = (checkpoint) => appendCompactionCommittedEvent(eventLog, allocator, input, checkpoint);
-      const durableHistory = storedHistory === undefined || Option19.isNone(sessionRepository) ? storedHistory : yield* reconcileCompactionCheckpoint(sessionRepository.value, chats, input, storedHistory, onCheckpointCommitted, resumeSuspension === undefined);
+      const onCheckpointCommitted = (result) => appendCompactionCommittedEvent(eventLog, allocator, input, result.checkpoint).pipe(Effect81.andThen(layerOptions?.onCheckpointCommitted?.(result) ?? Effect81.void));
+      const durableHistory = Option19.isNone(sessionRepository) ? storedHistory : yield* reconcileCompactionCheckpoint(sessionRepository.value, chats, input, storedHistory, onCheckpointCommitted, resumeSuspension === undefined);
+      const continuingDurableHistory = durableHistory !== undefined;
       const permissionsLayer = input.agent.permission_rules === undefined ? Layer71.empty : Option19.isNone(permissionRules) || Option19.isNone(waits) ? yield* AgentLoopError.make({
         message: "Execution permission rules require PermissionRuleRepository and WaitService in context",
         next_event_sequence: input.eventSequence + 1
@@ -15749,6 +15771,7 @@ var layer58 = Layer71.effect(Service61, Effect81.gen(function* () {
       const seededTokens = continuingDurableHistory ? yield* eventLog.sumUsage(input.executionId).pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1))) : 0;
       const memory = input.memorySubjectId === undefined ? undefined : { key: { agent: input.agent.name, subject: input.memorySubjectId } };
       const restoredEpoch = durableHistory !== undefined && Option19.isSome(contextEpochs) ? yield* restoreContextEpoch(contextEpochs.value, input) : undefined;
+      const freshSessionHistory = durableHistory !== undefined || input.sessionId === undefined || Option19.isNone(sessionRepository) ? undefined : yield* sessionRepository.value.path({ sessionId: input.sessionId }).pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1)), Effect81.map((path2) => path2.length === 0 ? undefined : exports_session.buildContext(path2)));
       const { options, instructionsLayer } = durableHistory === undefined ? yield* assembler.assemble({ agent: input.agent, tools: definitions2, input: input.input }).pipe(Effect81.mapError((error5) => loopError(error5, input.eventSequence + 1)), Effect81.flatMap((assembled) => Effect81.gen(function* () {
         const epoch = { baseline: assembled.system, dynamicSourceIds: [] };
         if (Option19.isSome(contextEpochs))
@@ -15756,10 +15779,11 @@ var layer58 = Layer71.effect(Service61, Effect81.gen(function* () {
         return {
           options: {
             prompt: assembled.prompt,
+            ...freshSessionHistory === undefined ? {} : { history: freshSessionHistory },
             sessionId: input.sessionId ?? input.executionId,
             ...memory === undefined ? {} : { memory }
           },
-          instructionsLayer: layerFromEpoch(epoch)
+          instructionsLayer: freshSessionHistory === undefined ? layerFromEpoch(epoch) : Layer71.empty
         };
       }))) : {
         options: {
@@ -15910,7 +15934,7 @@ var layer58 = Layer71.effect(Service61, Effect81.gen(function* () {
       const runFold = Effect81.scoped(Effect81.gen(function* () {
         const base = withToolCallDecodeResilience(yield* LanguageModel.LanguageModel, definitions2.map((definition) => definition.name), toolCallDecodeMaxRetries, (classification) => Ref18.set(lastModelFailureClassification, classification));
         const sessionStore = input.sessionId !== undefined && Option19.isSome(sessionRepository) ? yield* make4(input.sessionId, input.sessionEntryScope ?? input.executionId, {
-          onCheckpointCommitted: (result) => onCheckpointCommitted(result.checkpoint).pipe(Effect81.orDie)
+          onCheckpointCommitted: (result) => onCheckpointCommitted(result).pipe(Effect81.orDie)
         }).pipe(Effect81.provideService(exports_session_repository.Service, sessionRepository.value)) : undefined;
         const foldContext = yield* Layer71.build(Layer71.mergeAll(executorLayer, handlerLayer, layer53, exports_model_middleware.identityLayer, instructionsLayer, permissionsLayer, steeringLayer));
         const folded = exports_agent.stream(agent, batonOptions).pipe(Stream9.runFoldEffect(() => ({
@@ -15952,7 +15976,9 @@ var layer58 = Layer71.effect(Service61, Effect81.gen(function* () {
       };
     })
   });
-}));
+});
+var layerWith = (layerOptions) => Layer71.effect(Service61, make11(layerOptions));
+var layer58 = layerWith();
 var run5 = Effect81.fn("AgentLoop.run.call")(function* (input) {
   const service = yield* Service61;
   return yield* service.run(input);
@@ -16285,7 +16311,7 @@ var nextEventSequence5 = Effect86.fn("SchedulerService.nextEventSequence")(funct
   const max = yield* eventLog.maxSequence(executionId).pipe(Effect86.mapError(toSchedulerError));
   return max === undefined ? 0 : max + 1;
 });
-var make11 = Effect86.gen(function* () {
+var make12 = Effect86.gen(function* () {
   const schedules = yield* exports_schedule_repository.Service;
   const waits = yield* Service42;
   const eventLog = yield* Service41;
@@ -16393,7 +16419,7 @@ var pollLoop = (service, pollIntervalMillis) => Effect86.gen(function* () {
   }
 });
 var layer62 = Layer76.effect(Service69, Effect86.gen(function* () {
-  const service = yield* make11;
+  const service = yield* make12;
   const enabled3 = yield* enabledConfig;
   const pollIntervalMillis = yield* pollIntervalMillisConfig;
   if (enabled3) {
@@ -16401,7 +16427,7 @@ var layer62 = Layer76.effect(Service69, Effect86.gen(function* () {
   }
   return service;
 }));
-var memoryLayer45 = Layer76.effect(Service69, make11);
+var memoryLayer45 = Layer76.effect(Service69, make12);
 var runOnce2 = Effect86.fn("SchedulerService.runOnce.call")(function* () {
   const service = yield* Service69;
   return yield* service.runOnce;
@@ -16556,8 +16582,8 @@ var parentNotifierLayer = Layer77.effect(Service54, Effect87.gen(function* () {
     }).pipe(Effect87.provideService(exports_execution_repository.Service, executionRepository))
   });
 }));
-var agentLoopLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer) => layer58.pipe(Layer77.provideMerge(toolRuntimeLayer), Layer77.provideMerge(layer40), Layer77.provideMerge(layer42()), Layer77.provideMerge(promptAssemblerLayer), Layer77.provideMerge(schemaRegistryLayer));
-var runtimeServicesLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer) => {
+var agentLoopLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, options) => layerWith(options).pipe(Layer77.provideMerge(toolRuntimeLayer), Layer77.provideMerge(layer40), Layer77.provideMerge(layer42()), Layer77.provideMerge(promptAssemblerLayer), Layer77.provideMerge(schemaRegistryLayer));
+var runtimeServicesLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer, agentLoopOptions) => {
   const inboxLayer = Layer77.unwrap(Effect87.gen(function* () {
     const makeExecutionClient = yield* client;
     const executionRepository = yield* exports_execution_repository.Service;
@@ -16565,13 +16591,13 @@ var runtimeServicesLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRe
   }));
   const envelopeLayer = layer52.pipe(Layer77.provideMerge(layerFromRepository3), Layer77.provideMerge(inboxLayer));
   const topicLayer = layer51.pipe(Layer77.provideMerge(inboxLayer));
-  const agentLayer = agentLoopLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer).pipe(Layer77.provideMerge(inboxLayer), Layer77.provideMerge(envelopeLayer), Layer77.provideMerge(topicLayer));
+  const agentLayer = agentLoopLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, agentLoopOptions).pipe(Layer77.provideMerge(inboxLayer), Layer77.provideMerge(envelopeLayer), Layer77.provideMerge(topicLayer));
   const entityRegistryLayer = layer60.pipe(Layer77.provideMerge(layer39));
   const entityInstanceLayer = layer61.pipe(Layer77.provideMerge(entityRegistryLayer), Layer77.provideMerge(layerFromRepository3), Layer77.provideMerge(layerFromRepository));
   return Layer77.mergeAll(addressResolutionLayerWith(toolRuntimeLayer), layer45, executionServiceLayer, layerFromServices, layerFromServices2, layerFromRepository2, agentLayer, layer48, parentNotifierLayer, inboxLayer, envelopeLayer, topicLayer, entityRegistryLayer, toolTransitionCoordinatorLayer, layer47).pipe(Layer77.provideMerge(entityInstanceLayer), Layer77.provideMerge(layer38), Layer77.provideMerge(layer34), Layer77.provideMerge(layerFromRepository));
 };
-var workflowLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer) => layer49.pipe(Layer77.provideMerge(runtimeServicesLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer)));
-var workflowAndEntityLayerWith = (toolRuntimeLayer, schedulerLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer) => Layer77.mergeAll(layer59, schedulerLayer).pipe(Layer77.provideMerge(workflowLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer)));
+var workflowLayerWith = (toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer, agentLoopOptions) => layer49.pipe(Layer77.provideMerge(runtimeServicesLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer, agentLoopOptions)));
+var workflowAndEntityLayerWith = (toolRuntimeLayer, schedulerLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer, agentLoopOptions) => Layer77.mergeAll(layer59, schedulerLayer).pipe(Layer77.provideMerge(workflowLayerWith(toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, toolTransitionCoordinatorLayer, agentLoopOptions)));
 var makeService2 = (database, checkDatabase) => Effect87.gen(function* () {
   const sharding = yield* Sharding.Sharding;
   const workflow = yield* WorkflowEngine2.WorkflowEngine;
@@ -16660,7 +16686,7 @@ var testLanguageModelLayer = layerFromRegistrationEffects2([
 ]).pipe(Layer77.orDie);
 var testEmbeddingModelLayer = deterministicTestLayer();
 var defaultPromptAssemblerLayer = (blobStoreLayer = passthroughLayer2, artifactStoreLayer = passthroughLayer) => defaultLayerWithStores.pipe(Layer77.provide(Layer77.mergeAll(blobStoreLayer, artifactStoreLayer)));
-var layerWith = (options) => {
+var layerWith2 = (options) => {
   const blobStoreLayer = options.blobStoreLayer ?? passthroughLayer2;
   const artifactStoreLayer = options.artifactStoreLayer ?? passthroughLayer;
   const promptAssemblerLayer = options.promptAssemblerLayer ?? defaultPromptAssemblerLayer(blobStoreLayer, artifactStoreLayer);
@@ -16669,7 +16695,7 @@ var layerWith = (options) => {
   const memoryLayer46 = layer41().pipe(Layer77.provideMerge(embeddingModelLayer));
   const clusterContextLayer = Layer77.mergeAll(options.languageModelLayer, memoryLayer46, blobStoreLayer, artifactStoreLayer, promptAssemblerLayer, schemaRegistryLayer);
   const clusterLayer = options.clusterLayer.pipe(Layer77.provide(clusterContextLayer));
-  return Layer77.mergeAll(options.checkLayer, workflowAndEntityLayerWith(options.toolRuntimeLayer, options.schedulerLayer, promptAssemblerLayer, schemaRegistryLayer, options.toolTransitionCoordinatorLayer)).pipe(Layer77.provideMerge(options.languageModelLayer), Layer77.provide(memoryLayer46), Layer77.provideMerge(ClusterWorkflowEngine.layer), Layer77.provideMerge(clusterLayer), Layer77.provideMerge(options.repositoryLayer), Layer77.provideMerge(blobStoreLayer), Layer77.provideMerge(artifactStoreLayer));
+  return Layer77.mergeAll(options.checkLayer, workflowAndEntityLayerWith(options.toolRuntimeLayer, options.schedulerLayer, promptAssemblerLayer, schemaRegistryLayer, options.toolTransitionCoordinatorLayer, options.onCheckpointCommitted === undefined ? undefined : { onCheckpointCommitted: options.onCheckpointCommitted })).pipe(Layer77.provideMerge(options.languageModelLayer), Layer77.provide(memoryLayer46), Layer77.provideMerge(ClusterWorkflowEngine.layer), Layer77.provideMerge(clusterLayer), Layer77.provideMerge(options.repositoryLayer), Layer77.provideMerge(blobStoreLayer), Layer77.provideMerge(artifactStoreLayer));
 };
 var layerWithClient = (options) => {
   const blobStoreLayer = options.blobStoreLayer ?? passthroughLayer2;
@@ -16681,7 +16707,7 @@ var layerWithClient = (options) => {
   return Layer77.mergeAll(options.checkLayer, runtimeServicesLayerWith(options.toolRuntimeLayer, promptAssemblerLayer, schemaRegistryLayer, options.toolTransitionCoordinatorLayer)).pipe(Layer77.provideMerge(options.languageModelLayer), Layer77.provide(memoryLayer46), Layer77.provideMerge(options.clusterLayer), Layer77.provideMerge(options.repositoryLayer), Layer77.provideMerge(blobStoreLayer), Layer77.provideMerge(artifactStoreLayer));
 };
 var layerWithServices = (options) => {
-  const runtime = layerWith({
+  const runtime = layerWith2({
     toolTransitionCoordinatorLayer: sqlLayer,
     checkLayer: sqlCheckLayer,
     clusterLayer: sqlClusterLayer,
@@ -16693,12 +16719,13 @@ var layerWithServices = (options) => {
     promptAssemblerLayer: options.promptAssemblerLayer,
     blobStoreLayer: options.blobStoreLayer,
     artifactStoreLayer: options.artifactStoreLayer,
-    schemaRegistryLayer: options.schemaRegistryLayer
+    schemaRegistryLayer: options.schemaRegistryLayer,
+    ...options.onCheckpointCommitted === undefined ? {} : { onCheckpointCommitted: options.onCheckpointCommitted }
   });
   return runtime.pipe(Layer77.provide(options.databaseLayer));
 };
 var layerWithServicesMultiNode = (options) => {
-  const runtime = layerWith({
+  const runtime = layerWith2({
     toolTransitionCoordinatorLayer: sqlLayer,
     checkLayer: Layer77.mergeAll(sqlCheckLayer, multiNodeDialectGuard),
     clusterLayer: clusterLayerHttp(options.cluster),
@@ -16710,7 +16737,8 @@ var layerWithServicesMultiNode = (options) => {
     promptAssemblerLayer: options.promptAssemblerLayer,
     blobStoreLayer: options.blobStoreLayer,
     artifactStoreLayer: options.artifactStoreLayer,
-    schemaRegistryLayer: options.schemaRegistryLayer
+    schemaRegistryLayer: options.schemaRegistryLayer,
+    ...options.onCheckpointCommitted === undefined ? {} : { onCheckpointCommitted: options.onCheckpointCommitted }
   });
   return runtime.pipe(Layer77.provide(options.databaseLayer));
 };
@@ -16730,7 +16758,7 @@ var layerWithServicesMultiNodeClientOnly = (options) => {
   });
   return runtime.pipe(Layer77.provide(options.databaseLayer));
 };
-var layer63 = layerWith({
+var layer63 = layerWith2({
   toolTransitionCoordinatorLayer: sqlLayer,
   checkLayer: sqlCheckLayer,
   clusterLayer: sqlClusterLayer,
@@ -16740,7 +16768,7 @@ var layer63 = layerWith({
   toolRuntimeLayer: layer35(),
   schedulerLayer: layer62
 });
-var testLayerWithServices = (options) => layerWith({
+var testLayerWithServices = (options) => layerWith2({
   toolTransitionCoordinatorLayer: memoryLayer41,
   checkLayer: memoryCheckLayer,
   clusterLayer: memoryClusterLayer,
@@ -17923,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));
@@ -18389,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}` });
         }
@@ -18422,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) {
@@ -18430,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,
@@ -18443,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,
@@ -18457,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) {
@@ -18574,7 +18604,7 @@ class Service73 extends Context73.Service()("@relayfx/sdk/runtime-database/Servi
 // src/runtime-database-owner.ts
 import { Effect as Effect91, Layer as Layer81 } from "effect";
 var internals = new WeakMap;
-var make12 = (value) => {
+var make13 = (value) => {
   const database = {
     dialect: value.dialect,
     migrate: value.migrate,
@@ -18846,7 +18876,8 @@ function layerEmbedded(options) {
     blobStoreLayer: options.blobStoreLayer,
     artifactStoreLayer: options.artifactStoreLayer,
     promptAssemblerLayer: options.promptAssemblerLayer,
-    schemaRegistryLayer: options.schemaRegistryLayer
+    schemaRegistryLayer: options.schemaRegistryLayer,
+    ...options.onCheckpointCommitted === undefined ? {} : { onCheckpointCommitted: options.onCheckpointCommitted }
   });
   const host = normalizeHost(publicGraph(withHosts(runner, options), runtimeLayer(options.database), "embedded", {
     fanOut: options.childFanOutHostLayer !== undefined,
@@ -18864,6 +18895,7 @@ var layerRunner = (options) => {
     artifactStoreLayer: options.artifactStoreLayer,
     promptAssemblerLayer: options.promptAssemblerLayer,
     schemaRegistryLayer: options.schemaRegistryLayer,
+    ...options.onCheckpointCommitted === undefined ? {} : { onCheckpointCommitted: options.onCheckpointCommitted },
     cluster: options.cluster
   });
   return normalizeHost(publicGraph(runner, runtimeLayer(options.database), "runner"), "runner", options.database.dialect);
@@ -18879,4 +18911,4 @@ var layerClient = (options) => {
   return embeddedOutput(normalizeHost(publicGraph(runner, runtimeLayer(options.database), "client"), "client", options.database.dialect));
 };
 
-export { exports_child_fan_out_host, exports_artifact_store_service, exports_blob_store_service, exports_prompt_assembler_service, Dialect, dialect, fromDbTimestamp, fromNullableDbTimestamp, timestampParam, encodeJson, decodeJson, decodeBool, exports_embedding_model_service, exports_language_model_service, exports_model_hub, exports_schema_registry_service, RuntimeConfigurationError, normalizeAcquisitionCause, DatabaseIdentity, makeDatabaseIdentity, exports_workflow_definition_host, Service73 as Service, make12 as make, runtimeLayer, exports_tool_runtime, SqlFailure, DatabaseAlreadyOwned, MigratorError, SchemaHeadMismatch, RuntimeTopologyError, RuntimeMigrationError, exports_runtime };
+export { exports_child_fan_out_host, exports_artifact_store_service, exports_blob_store_service, exports_prompt_assembler_service, Dialect, dialect, fromDbTimestamp, fromNullableDbTimestamp, timestampParam, encodeJson, decodeJson, decodeBool, exports_embedding_model_service, exports_language_model_service, exports_model_hub, exports_schema_registry_service, RuntimeConfigurationError, normalizeAcquisitionCause, DatabaseIdentity, makeDatabaseIdentity, exports_workflow_definition_host, Service73 as Service, make13 as make, runtimeLayer, exports_tool_runtime, SqlFailure, DatabaseAlreadyOwned, MigratorError, SchemaHeadMismatch, RuntimeTopologyError, RuntimeMigrationError, exports_runtime };