effect-agent 0.1.0-beta.152 → 0.1.0-beta.153

package/src/durable/DurableAgentRuntime.ts

@@ -151,6 +151,7 @@ import {
   type ResolvedBinding,
   resolveDefinitionBinding,
   resolveWorkerBinding,
+  CurrentBindingSelection,
 } from "./internal/agent-registration.ts";
 import { makeAgentUpdateRuntime } from "./internal/agent-updates.ts";
 import { inspectForeignDiagnostic, safeUnknownString } from "./internal/foreign-diagnostic.ts";
@@ -184,6 +185,7 @@ import {
   CompactionCreated,
   DefinitionDigests,
   ModelResponseInterrupted,
+  ModelCallAborted,
   PersistedJson,
   ProducerEpoch,
   RecordEnvelope,
@@ -240,6 +242,7 @@ import {
   modelResponseRecordId,
   projectRunJournalStream,
   type JournalBoundary,
+  type RunJournalProjection,
   runCompletedRecordId,
   runCompletionDigest,
   runIdForSubmission,
@@ -296,6 +299,7 @@ import {
   ClaimHandoff,
   SubmissionScheduling,
   ClaimJoiningRequest,
+  type JoiningClaim,
   ClaimRequest,
   IdempotencyKey,
   LedgerError,
@@ -1257,11 +1261,25 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
   bindings: ReadonlyArray<ResolvedBinding>,
 ) {
   const registeredBindings = [...bindings];
+  const bindingSelection = yield* CurrentBindingSelection;
   const workerAdmissionPort = yield* WorkerAdmissionPort;
   const ledger = yield* SubmissionLedger;
   const submissionScheduling = yield* SubmissionScheduling;
   const store = yield* ThreadStore;
 
+  // Disposable: canonical tail and owner identify the exact projection, never ownership.
+  // Retain only the most recent view; persisted checkpoints still govern cold recovery.
+  let projectedJournal:
+    | {
+        readonly threadId: ThreadId;
+        readonly through: CanonicalSequence;
+        readonly runId: RunId;
+        readonly seedThrough: CanonicalSequence | undefined;
+        readonly journal: RunJournalProjection;
+        readonly boundaries: ReadonlyArray<JournalBoundary>;
+      }
+    | undefined;
+
   const wake = yield* WakeScheduler;
   const failpoint = yield* DurableRuntimeFailpoint;
   const config = yield* DurableRuntimeConfig;
@@ -1301,20 +1319,11 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     Effect.provideService(effect, Crypto.Crypto, crypto);
 
   const contractsFor = (definition: Agent.AnyDefinition) => {
-    const registered = registeredBindings.filter((binding) => binding.agentId === definition.id);
-    const binding = registered.length === 1 ? registered[0] : undefined;
-
-    // Attempts may restore the accepted Run policy on a Definition copy. Replay contracts
-    // describe Tools, so retain the registration's semantic versions while all declarations
-    // that affect those contracts are unchanged. Replaced Tools or completion declarations
-    // must not inherit another executable's replay authority.
-    const current =
-      binding?.definition.toolkit === definition.toolkit &&
-      binding.definition.completion === definition.completion &&
-      binding.definition.completionFromTools === definition.completionFromTools
-        ? binding
-        : undefined;
+    const registered = registeredBindings.filter(
+      (binding) => binding.agentId === definition.id && Object.is(binding.definition, definition),
+    );
 
+    const current = registered.length === 1 ? registered[0] : undefined;
     const contracts = current?.digests.replay?.tools;
 
     return contracts === undefined
@@ -1324,9 +1333,15 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       : Effect.succeed(contracts);
   };
 
-  const currentOperationsFor = Effect.fnUntraced(function* (agentId: AgentId) {
-    const registered = registeredBindings.filter((binding) => binding.agentId === agentId);
-    const binding = registered.length === 1 ? registered[0] : undefined;
+  const resolveCurrentBinding = (submission: SubmissionSnapshot) =>
+    resolveWorkerBinding(registeredBindings, submission).pipe(
+      Effect.provideService(CurrentBindingSelection, bindingSelection),
+    );
+
+  const currentOperationsFor = Effect.fnUntraced(function* (submission: SubmissionSnapshot) {
+    const binding = yield* resolveCurrentBinding(submission).pipe(
+      Effect.catchTag("BindingUnavailable", () => Effect.succeed(undefined)),
+    );
 
     return binding === undefined
       ? undefined
@@ -4551,6 +4566,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     journalMetadata: JournalMetadata | undefined,
     lineage: AttemptLineage,
     approvalDecisions: ReadonlyArray<ApprovalDecisionIntent>,
+    currentContracts: Readonly<Record<string, Digest>>,
     runTiming: { readonly startedAt: DateTime.Utc; readonly deadline: DateTime.Utc },
     yieldAfter?: DateTime.Utc,
   ) =>
@@ -4560,13 +4576,31 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       const runId = runIdForSubmission(submissionId);
       const boundaries: Array<JournalBoundary> = [];
 
-      const journal = yield* projectRunJournalStream(
-        canonical,
+      const cached = projectedJournal;
+
+      const journal =
+        cached !== undefined &&
+        cached.threadId === ctx.threadId &&
+        cached.through === canonicalThrough &&
+        cached.runId === runId &&
+        cached.seedThrough === journalSeed?.throughSequence
+          ? (boundaries.push(...cached.boundaries), cached.journal)
+          : yield* projectRunJournalStream(
+              canonical,
+              runId,
+              (boundary) => boundaries.push(boundary),
+              journalSeed,
+              journalMetadata,
+            );
+
+      projectedJournal = {
+        threadId: ctx.threadId,
+        through: canonicalThrough,
         runId,
-        (boundary) => boundaries.push(boundary),
-        journalSeed,
-        journalMetadata,
-      );
+        seedThrough: journalSeed?.throughSequence,
+        journal,
+        boundaries,
+      };
 
       const saveRecoveryCheckpoint = Effect.fn("DurableAgentRuntime.saveRecoveryCheckpoint")(
         function* (compactionId: RecordId): Effect.fn.Return<void, DurableWorkerFailure> {
@@ -4873,8 +4907,6 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
               journalSeed,
             );
 
-      const currentContracts = yield* contractsFor(agent.definition);
-
       const rolloverOperation =
         journal.pendingContextToolCallId === undefined
           ? undefined
@@ -5009,15 +5041,43 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
 
       // Staging also backs the cumulative summary; keep it intact and track canonical prefixes.
       const committedUsageLengths = new Map<number, number>();
+      const committedUnobservedCalls = new Map<number, number>();
+
+      const usageForCommit = (turn: number) => {
+        const staged = stagedUsage.get(turn);
+
+        if (staged === undefined) return undefined;
+        const modelUsage = staged.modelUsage.slice(committedUsageLengths.get(turn) ?? 0);
+
+        if (modelUsage.length === 0) return undefined;
+
+        return {
+          modelUsage,
+          inputTokens: modelUsage.reduce((sum, call) => sum + call.inputTokens.total, 0),
+          outputTokens: modelUsage.reduce((sum, call) => sum + call.outputTokens.total, 0),
+          costMicrousd: modelUsage.reduce((sum, call) => sum + call.costMicrousd, 0),
+        };
+      };
+
+      const unobservedForCommit = (turn: number) =>
+        (stagedUnobservedCalls.get(turn) ?? 0) - (committedUnobservedCalls.get(turn) ?? 0);
 
       const recordCommittedUsage = (batch: CanonicalBatch) => {
         for (const record of batch.records) {
-          if (record.payload._tag !== "ModelResponseRecorded") continue;
+          if (
+            record.payload._tag !== "ModelResponseRecorded" &&
+            record.payload._tag !== "ModelCallAborted"
+          )
+            continue;
           const payload = record.payload;
 
           committedUsageLengths.set(
             payload.turn,
-            Math.max(committedUsageLengths.get(payload.turn) ?? 0, payload.modelUsage?.length ?? 0),
+            (committedUsageLengths.get(payload.turn) ?? 0) + (payload.modelUsage?.length ?? 0),
+          );
+          committedUnobservedCalls.set(
+            payload.turn,
+            (committedUnobservedCalls.get(payload.turn) ?? 0) + (payload.unobservedModelCalls ?? 0),
           );
         }
       };
@@ -5430,7 +5490,9 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
         completedExhausted: undefined,
       });
 
-      const turnCounter = yield* Ref.make(journal.committedTurns);
+      const turnCounter = yield* Ref.make(
+        journal.committedTurns + (journal.policyUsage.modelRestarts ?? 0),
+      );
 
       const idGenerator: (typeof IdGenerator)["Service"] = {
         nextThreadId: Effect.succeed(submission.threadId),
@@ -5543,6 +5605,37 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
             };
 
       const durability: RunDurabilityHook<CoordinatorHalt | CompactionError, never> = {
+        commitModelRestart: (restart) =>
+          recordHalt(
+            Effect.gen(function* () {
+              if (knownIds.has(modelResponseRecordId(runId, restart.turn)))
+                return yield* RunJournalError.make({
+                  message: "Cannot restart a canonical model response",
+                });
+              const recordId = decodeRecordIdSync(`model-aborted:${runId}:${restart.restart}`);
+
+              const record = yield* makeEnvelope(
+                recordId,
+                ModelCallAborted.make({
+                  runId,
+                  ...restart,
+                  reason: "joined-input",
+                  modelUsage: usageForCommit(restart.turn)?.modelUsage ?? [],
+                  unobservedModelCalls: unobservedForCommit(restart.turn),
+                }),
+              );
+
+              const batch = CanonicalBatch.make({
+                batchId: decodeBatchIdSync(recordId),
+                producerId: config.producerId,
+                records: [record],
+              });
+
+              yield* appendBatch(ctx, batch);
+              recordCommittedUsage(batch);
+              knownIds.add(recordId);
+            }),
+          ),
         noteToolExposure: (turn, snapshot) =>
           Effect.sync(() => {
             stagedToolExposure.set(turn, snapshot);
@@ -5624,8 +5717,8 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
                   ...(canonicalTurn === 1 && pendingSlice.length > 0
                     ? { runScopedPrefixLength: pendingSlice.length }
                     : {}),
-                  usage: stagedUsage.get(canonicalTurn),
-                  unobservedModelCalls: stagedUnobservedCalls.get(canonicalTurn),
+                  usage: usageForCommit(canonicalTurn),
+                  unobservedModelCalls: unobservedForCommit(canonicalTurn),
                 }),
               );
 
@@ -6210,10 +6303,114 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
           yield* commitPendingTurn;
       });
 
+      // Claims are authority, wakes are hints. A cancelled waiter retains every claim
+      // for the seam drain; it never appends input while an old response can still commit.
+      type PreparedJoin = {
+        readonly claim: JoiningClaim;
+        readonly input: Pick<UserInputRecorded, "input" | "messageAdmission">;
+        readonly rendered: Prompt.RawInput;
+      };
+
+      const pendingJoinClaims: Array<{ readonly claim: JoiningClaim; prepared?: PreparedJoin }> =
+        [];
+
+      const claimInputs = Effect.fnUntraced(function* (maxCount: number) {
+        const ownershipToken = yield* Ref.get(tokenRef);
+
+        const claims = yield* ledger.claimJoining(
+          ClaimJoiningRequest.make({
+            threadId: submission.threadId,
+            hostSubmissionId: submissionId,
+            ownershipToken,
+            maxCount,
+          }),
+        );
+
+        pendingJoinClaims.push(...claims.map((claim) => ({ claim })));
+
+        return claims.length;
+      }, Effect.uninterruptible);
+
+      const revertClaims = Effect.fnUntraced(function* (
+        claims: ReadonlyArray<(typeof pendingJoinClaims)[number]>,
+      ) {
+        for (const pending of claims) {
+          yield* ledger.revertJoining(
+            RevertJoiningRequest.make({ submissionId: pending.claim.submissionId }),
+          );
+          pendingJoinClaims.splice(pendingJoinClaims.indexOf(pending), 1);
+        }
+      }, Effect.uninterruptible);
+
+      // Preparation remains interruptible; a completed render stays with its claim so
+      // cancellation of the waiter cannot lose it or invoke the callback again at the seam.
+      const prepareInputs = Effect.fnUntraced(function* (limit: number, firstReady = false) {
+        if (
+          pendingJoinClaims.length < limit &&
+          (yield* claimInputs(limit - pendingJoinClaims.length)) > 0
+        )
+          yield* hit("join:after-claim");
+        const prepared: Array<PreparedJoin> = [];
+
+        for (const pending of pendingJoinClaims.slice(0, limit)) {
+          const claim = pending.claim;
+
+          const snapshot = yield* ledger.loadRecoverySnapshot(
+            RecoverySnapshotRequest.make({ submissionId: claim.submissionId }),
+          );
+
+          if (snapshot.abortIntent !== undefined) {
+            yield* revertClaims([pending]);
+            continue;
+          }
+          if (pending.prepared === undefined) {
+            const input = {
+              input: claim.inputPayload,
+              ...(snapshot.submission.messageAdmission === undefined
+                ? {}
+                : { messageAdmission: snapshot.submission.messageAdmission }),
+            };
+
+            const rendered = yield* Effect.result(renderJoinedInput(input));
+
+            if (Result.isFailure(rendered)) {
+              // A rejected prompt and its suffix retain their own Runs in queue order.
+              yield* revertClaims(pendingJoinClaims.slice(pendingJoinClaims.indexOf(pending)));
+              break;
+            }
+            pending.prepared = { claim, input, rendered: rendered.success };
+          }
+          prepared.push(pending.prepared);
+          if (firstReady) break;
+        }
+
+        return prepared;
+      });
+
+      const awaitJoin = recordHalt(
+        Effect.gen(function* () {
+          while (true) {
+            const ready = yield* Effect.scoped(
+              Effect.gen(function* () {
+                const notified = yield* wake.subscribe(submission.threadId);
+
+                if ((yield* prepareInputs(MAX_JOIN_DRAIN, true)).length > 0) return true;
+                yield* notified;
+
+                return false;
+              }),
+            );
+
+            if (ready) return;
+          }
+        }),
+      );
+
       const input: RunInputHook<
         CoordinatorHalt | Agent.Failure<typeof agent>,
         Agent.DefinitionRequirements<(typeof agent)["definition"]>
       > = {
+        awaitJoin,
         drain: (policy) =>
           Effect.gen(function* () {
             const joinedInputs = yield* recordHalt(
@@ -6233,8 +6430,9 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
 
                   joinBacklog = hostSnapshot.joins;
                 }
+                // These inputs were already consumed by an earlier attempt. Restore the
+                // entire uncovered prompt; only fresh claims are subject to the drain bound.
                 for (const join of joinBacklog) {
-                  if (joinedInputs.length >= limit) break;
                   const joinId = join.submissionId;
 
                   if (deliveredJoinInputs.has(joinId)) continue;
@@ -6269,109 +6467,62 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
                   yield* preserveToolResults;
                   joinedInputs.push(payload);
                 }
-                if (joinedInputs.length < limit) {
-                  const ownershipToken = yield* Ref.get(tokenRef);
-
-                  const claims = yield* ledger.claimJoining(
-                    ClaimJoiningRequest.make({
-                      threadId: submission.threadId,
-                      hostSubmissionId: submissionId,
-                      ownershipToken,
-                      maxCount: limit - joinedInputs.length,
-                    }),
-                  );
+                const claims = yield* prepareInputs(limit);
 
-                  if (claims.length > 0) {
-                    yield* hit("join:after-claim");
-                  }
-                  for (const claim of claims) {
-                    const claimSnapshot = yield* ledger.loadRecoverySnapshot(
-                      RecoverySnapshotRequest.make({ submissionId: claim.submissionId }),
+                pendingJoinClaims.splice(0, claims.length);
+                for (const { claim, input: payload, rendered } of claims) {
+                  yield* preserveToolResults;
+                  const recordId = submissionInputRecordId(claim.submissionId);
+                  let sequence: CanonicalSequence;
+                  const existing = joinedInputEnvelopes.get(claim.submissionId);
+
+                  if (existing !== undefined) {
+                    // Defensive reattach: the exact record is already canonical, so only the
+                    // marker and the delivery remain (DUR-016 — never a duplicate append).
+                    sequence = existing.sequence;
+                  } else {
+                    const envelope = yield* makeEnvelope(
+                      recordId,
+                      UserInputRecorded.make({
+                        submissionId: claim.submissionId,
+                        kind: "steering",
+                        runId,
+                        input: claim.inputPayload,
+                        ...(payload.messageAdmission === undefined
+                          ? {}
+                          : { messageAdmission: payload.messageAdmission }),
+                      }),
                     );
 
-                    if (claimSnapshot.abortIntent !== undefined) {
-                      // Aborted before the host consumed the input: honor the intent by
-                      // returning the claim to ready (revert-then-abort, plan §2.5); it settles
-                      // aborted once it heads the lane.
-                      yield* ledger.revertJoining(
-                        RevertJoiningRequest.make({ submissionId: claim.submissionId }),
-                      );
-                      continue;
-                    }
-
-                    const payload = {
-                      input: claim.inputPayload,
-                      ...(claimSnapshot.submission.messageAdmission === undefined
-                        ? {}
-                        : { messageAdmission: claimSnapshot.submission.messageAdmission }),
-                    };
-
-                    const rendered = yield* Effect.result(renderJoinedInput(payload));
-
-                    if (Result.isFailure(rendered)) {
-                      // The rejecting input gets its own Run and normal typed failure.
-                      // Leave it and the unconsumed suffix ready, preserving queue order
-                      // and preventing one invalid prompt from failing unrelated receipts.
-                      for (const remaining of claims.slice(claims.indexOf(claim))) {
-                        yield* ledger.revertJoining(
-                          RevertJoiningRequest.make({ submissionId: remaining.submissionId }),
-                        );
-                      }
-                      break;
-                    }
-                    yield* preserveToolResults;
-                    const recordId = submissionInputRecordId(claim.submissionId);
-                    let sequence: CanonicalSequence;
-                    const existing = joinedInputEnvelopes.get(claim.submissionId);
-
-                    if (existing !== undefined) {
-                      // Defensive reattach: the exact record is already canonical, so only the
-                      // marker and the delivery remain (DUR-016 — never a duplicate append).
-                      sequence = existing.sequence;
-                    } else {
-                      const envelope = yield* makeEnvelope(
-                        recordId,
-                        UserInputRecorded.make({
-                          submissionId: claim.submissionId,
-                          kind: "steering",
-                          runId,
-                          input: claim.inputPayload,
-                          ...(claimSnapshot.submission.messageAdmission === undefined
-                            ? {}
-                            : { messageAdmission: claimSnapshot.submission.messageAdmission }),
-                        }),
-                      );
-
-                      const result = yield* appendBatch(
-                        ctx,
-                        CanonicalBatch.make({
-                          batchId: submissionInputBatchId(claim.submissionId),
-                          producerId: config.producerId,
-                          records: [envelope],
-                        }),
-                      );
-
-                      sequence = result.firstSequence;
-                      knownIds.add(recordId);
-                      yield* hit("join:after-canonical-append");
-                    }
-                    // Re-read the token: the concurrent lease renewal may rotate it mid-batch.
-                    const markToken = yield* Ref.get(tokenRef);
-
-                    yield* ledger.markJoined(
-                      MarkJoinedRequest.make({
-                        submissionId: claim.submissionId,
-                        ownershipToken: markToken,
-                        recordId,
-                        sequence,
+                    const result = yield* appendBatch(
+                      ctx,
+                      CanonicalBatch.make({
+                        batchId: submissionInputBatchId(claim.submissionId),
+                        producerId: config.producerId,
+                        records: [envelope],
                       }),
                     );
-                    deliveredJoinInputs.add(claim.submissionId);
-                    joinedInputs.push({
-                      ...payload,
-                      rendered: rendered.success,
-                    });
+
+                    sequence = result.firstSequence;
+                    knownIds.add(recordId);
+                    yield* hit("join:after-canonical-append");
                   }
+                  // Re-read the token: the concurrent lease renewal may rotate it mid-batch.
+                  const markToken = yield* Ref.get(tokenRef);
+
+                  yield* ledger.markJoined(
+                    MarkJoinedRequest.make({
+                      submissionId: claim.submissionId,
+                      ownershipToken: markToken,
+                      recordId,
+                      sequence,
+                    }),
+                  );
+                  deliveredJoinInputs.add(claim.submissionId);
+                  joinedInputs.push({
+                    ...payload,
+                    rendered,
+                  });
                 }
 
                 return joinedInputs;
@@ -7306,8 +7457,8 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
               createdAt,
               ...(runScopedPrefixLength > 0 ? { runScopedPrefixLength } : {}),
               ...(completedRun === undefined ? {} : { runCompletion: completedRun }),
-              usage: stagedUsage.get(canonicalTurn),
-              unobservedModelCalls: stagedUnobservedCalls.get(canonicalTurn),
+              usage: usageForCommit(canonicalTurn),
+              unobservedModelCalls: unobservedForCommit(canonicalTurn),
             }),
           );
 
@@ -7373,6 +7524,11 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
 
       const handleEvent = (event: RunEvent): Effect.Effect<void, DurableWorkerFailure> => {
         switch (event._tag) {
+          case "ModelRestarted": {
+            // A finish part can arrive before the provider stream closes. Its TurnCompleted
+            // only staged this disposable Turn; never let the next seam commit its prefix.
+            return Ref.update(stateRef, (state) => ({ ...state, pendingTurn: undefined }));
+          }
           case "TurnStarted": {
             // Suspension owns only this Turn's siblings. Earlier results are already canonical
             // under their original Turn and must never be re-recorded with a later Turn id.
@@ -8004,6 +8160,10 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
               definition: { ...registeredAgent.definition, policy: childPolicy },
             };
 
+      // Restoring the accepted child policy changes no Tool declarations. Retain the
+      // selected registration's contracts instead of resolving the copied Definition.
+      const currentContracts = yield* contractsFor(registeredAgent.definition);
+
       const evidence = yield* evidenceFor(records, submissionId, true, snapshot.hostSubmissionId);
       const knownIds = knownRecordIdsOf(records);
 
@@ -8099,7 +8259,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
           reconciliationRecords,
           reconciliationEvidence.openToolCalls,
           knownIds,
-          { definition: agent.definition, contracts: yield* contractsFor(agent.definition) },
+          { definition: agent.definition, contracts: currentContracts },
         );
 
         if (review.uncertain.length > 0 || review.unproven.length > 0) {
@@ -8139,7 +8299,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       if (continuation !== undefined) {
         const current = {
           definition: agent.definition,
-          contracts: yield* contractsFor(agent.definition),
+          contracts: currentContracts,
         };
 
         const operations = operationsFor(continuationRecords, runIdForSubmission(submissionId));
@@ -8314,6 +8474,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
           journalMetadata?.snapshot(),
           lineage,
           approvalDecisionIntents,
+          currentContracts,
           runTiming,
           yieldAfter,
         );
@@ -8759,9 +8920,6 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       );
     });
 
-  const resolveCurrentBinding = (submission: SubmissionSnapshot) =>
-    resolveWorkerBinding(registeredBindings, submission.agentId);
-
   const processThreadResolvedImpl = (
     threadId: ThreadId,
   ): Effect.Effect<ReadonlyArray<Settlement>, DurableWorkerFailure | DurableBindingFailure> =>
@@ -9011,7 +9169,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
       records,
       evidence.openToolCalls.filter((call) => markableIds.has(call.toolCallId)),
       knownIds,
-      yield* currentOperationsFor(submission.agentId),
+      yield* currentOperationsFor(submission),
     );
 
     let disposition: "repaired" | "deferred" | "unknown";
@@ -9050,7 +9208,7 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
     if (!snapshot.unknownResolutions.some((intent) => intent.resolution._tag === "SafeToRetry"))
       return false;
     const submission = snapshot.submission;
-    const current = yield* currentOperationsFor(submission.agentId);
+    const current = yield* currentOperationsFor(submission);
     const operations = operationsFor(records, runIdForSubmission(submission.submissionId));
 
     for (const intent of snapshot.unknownResolutions) {
@@ -10988,6 +11146,29 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
   }).pipe(Effect.provideService(WorkerRuntime, workerRuntime));
 
   return DurableAgentRuntime.of({
+    bindingRegistryKey: yield* withCrypto(
+      digestJson({
+        selection: bindingSelection?.key ?? null,
+        bindings: (yield* Effect.forEach(registeredBindings, (binding) =>
+          withCrypto(
+            digestJson({
+              agentId: binding.agentId,
+              agent: binding.digests.agent,
+              model: binding.digests.model,
+              tools: binding.digests.tools,
+              replay:
+                binding.digests.replay === undefined
+                  ? null
+                  : {
+                      agent: binding.digests.replay.agent,
+                      agentBehavior: binding.digests.replay.agentBehavior ?? null,
+                      tools: binding.digests.replay.tools,
+                    },
+            }),
+          ),
+        ).pipe(Effect.orDie)).sort(),
+      }),
+    ).pipe(Effect.orDie),
     workerHost: workerRuntime.acquire,
     messagingHost: messagingRuntime.acquire,
     submitRegistered,
@@ -11079,6 +11260,8 @@ const make = Effect.fn("DurableAgentRuntime.make")(function* (
 export class DurableAgentRuntime extends Context.Service<
   DurableAgentRuntime,
   {
+    /** Stable registration identity for hosts parking unavailable bindings; never an admission authority. */
+    readonly bindingRegistryKey: string;
     /** Acquire an authenticated source Thread facet; its References confer no authority. */
     readonly workerHost: (request: {
       readonly sourceThreadId: ThreadId;
@@ -11330,7 +11513,7 @@ export class DurableAgentRuntime extends Context.Service<
 >()("@effect-agent/thread/DurableAgentRuntime") {
   /**
    * Resolve typed registrations and capture their services once in the runtime's Layer Scope.
-   * Every claimed head must match an exact registered identity and digest triple. Worker calls
+   * Every claimed head must select exactly one current registered Definition. Worker calls
    * cannot replace these registrations or their captured services. Tool authorization is required.
    */
   static layerRegistered<const Entries extends ReadonlyArray<AgentRegistration>>(