@yielded/agent 0.1.0-beta.174 → 0.1.0-beta.176

package/src/durable/DurableAgentRuntime.ts

@@ -63,6 +63,7 @@ import {
   getToolExecutionKind,
   SubagentParentLink,
 } from "../core/SubagentContract.ts";
+import { Store as ConversationStore, makeMemoryStore } from "../core/Thread.ts";
 import { Selection, Snapshot } from "../core/ToolExposure.ts";
 import type { ToolParameterRejection } from "../core/ToolResult.ts";
 import {
@@ -157,7 +158,7 @@ import {
 } from "./internal/agent-registration.ts";
 import { makeAgentUpdateRuntime } from "./internal/agent-updates.ts";
 import { inspectForeignDiagnostic, safeUnknownString } from "./internal/foreign-diagnostic.ts";
-import { initialContext } from "./internal/initial-context.ts";
+import { initialContext, type InitialContextInput } from "./internal/initial-context.ts";
 import {
   makeJournalMetadata,
   type JournalMetadata,
@@ -280,6 +281,7 @@ import {
   modelResponseInterruptedRecordId,
   modelResponseRecordId,
   projectRunJournalStream,
+  initialRunJournal,
   type JournalBoundary,
   type RunJournalProjection,
   type RunJournalContext,
@@ -401,6 +403,9 @@ import {
   getRunInput,
   ThreadReader,
   MAX_THREAD_EXPORT_PAGE_BYTES,
+  PreparedAppend,
+  type CommitBatch,
+  type ExecutionUpdate,
 } from "./ThreadStore.ts";
 import {
   type WorkIndexRebuildRequest,
@@ -592,6 +597,11 @@ export { threadCreatedBatchId, threadCreatedRecordId } from "./internal/thread-i
 export const recoveryRepairBatchId = (submissionId: SubmissionId, decisionTag: string): BatchId =>
   decodeBatchId(`repair:${submissionId}:${decisionTag}`);
 
+const isOriginalInputRecord = (
+  record: RecordEnvelope,
+): record is RecordEnvelope & { readonly payload: UserInputRecorded } =>
+  record.payload._tag === "UserInputRecorded";
+
 /** Deterministic record identity of one executed recovery decision's `RepairAnnotated` record. */
 export const recoveryRepairRecordId = (submissionId: SubmissionId, decisionTag: string): RecordId =>
   decodeRecordId(`repair:${submissionId}:${decisionTag}`);
@@ -846,6 +856,11 @@ export class RecoverySweepResult extends Schema.Class<RecoverySweepResult>("Reco
 /** Recover one bounded page of native work, optionally confined to one Thread. */
 export interface RecoverySweepOptions {
   readonly threadId?: ThreadId;
+  /** Leave this incarnation's untouched root admissions to their first actual claim.
+   * A verified sole admission needs no recovery inventory; other owners retain bounded
+   * discovery and deferred reports. Neither case supplies ownership or a recovery decision:
+   * the Attempt still verifies current controls, journal, fencing and historyDigest. */
+  readonly deferUnclaimedAdmissions?: boolean;
   /** Continue the previous pass with the same Thread selection until its result has no cursor. */
   readonly cursor?: string;
 }
@@ -1357,7 +1372,7 @@ interface OpenCallReview {
 
 interface InitialJournalSource {
   records: ReadonlyArray<JournalRecordEnvelope> | undefined;
-  readonly original: CanonicalRecordEnvelope;
+  readonly original: InitialContextInput;
   readonly suffix: ReadonlyArray<CanonicalRecordEnvelope>;
   cacheable: boolean;
   readonly prefix?: CachedPromptHistory;
@@ -1374,6 +1389,11 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
   const reader = ThreadReader.fromStore(store);
   const promptHistory = yield* makePromptHistoryCache();
 
+  // One incarnation remembers only newly accepted root input, never a recovery decision.
+  // A claim consumes the hint before binding/application code can run. Cold owners,
+  // replays, linked inputs, and any changed ledger state retain the recovery path.
+  const unclaimedAdmissions = new Map<SubmissionId, ThreadId>();
+
   const workDiscovery = yield* ThreadWorkDiscovery.pipe(
     Effect.provide(ThreadWorkDiscovery.layer),
     Effect.provideService(ThreadStore, store),
@@ -1444,17 +1464,27 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
   // observer must never replace this host choice on a fresh or replacement Attempt.
   const toolFailureObserver = yield* CurrentToolFailureObserver;
 
+  const runServices = Context.make(CurrentToolFailureObserver, toolFailureObserver).pipe(
+    Context.add(RunToolVisibility, runToolVisibility),
+    Context.add(RunToolScheduling, runToolScheduling),
+    Context.add(ContextCompactor, compactor),
+    Context.add(RunContextPreparation, runContextPreparation),
+  );
+
+  const journalServices = Context.make(ThreadReader, reader).pipe(
+    Context.add(Crypto.Crypto, crypto),
+  );
+
   const withCrypto = <A, E>(effect: Effect.Effect<A, E, Crypto.Crypto>): Effect.Effect<A, E> =>
     Effect.provideService(effect, Crypto.Crypto, crypto);
 
   // Rebuild the pinned admission and captured suffix using this runtime's host dependencies.
   const readInitialJournal = (
-    original: CanonicalRecordEnvelope,
+    original: InitialContextInput,
     suffix: ReadonlyArray<CanonicalRecordEnvelope>,
   ) =>
     initialContext(original).pipe(
-      Effect.provideService(ThreadReader, reader),
-      Effect.provideService(Crypto.Crypto, crypto),
+      Effect.provideContext(journalServices),
       Effect.map((history) => history.concat(suffix)),
     );
 
@@ -1708,10 +1738,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
         if (found === undefined) {
           // An exact lookup distinguishes missing evidence from an incomplete native index.
-          yield* resolveEvidence(threadId, ref).pipe(
-            Effect.provideService(ThreadReader, reader),
-            Effect.provideService(Crypto.Crypto, crypto),
-          );
+          yield* resolveEvidence(threadId, ref).pipe(Effect.provideContext(journalServices));
 
           return yield* invalid(
             "Required Run evidence is absent from its locator; rebuild the index explicitly",
@@ -1778,8 +1805,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         } else {
           saved = yield* readRunContext(initial, input, cursor.savedContext.recordId).pipe(
             Effect.provide(RunContextReader.layer(threadId)),
-            Effect.provideService(ThreadReader, reader),
-            Effect.provideService(Crypto.Crypto, crypto),
+            Effect.provideContext(journalServices),
             Effect.mapError(() =>
               invalid("Saved original context cannot be resolved from its evidence"),
             ),
@@ -2573,8 +2599,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     const progress =
       active?.writer ??
       (yield* makeProgressWriter(writer.threadId, config.deploymentId).pipe(
-        Effect.provideService(ThreadReader, reader),
-        Effect.provideService(Crypto.Crypto, crypto),
+        Effect.provideContext(journalServices),
       ));
 
     const owned: RunWriter = {
@@ -2600,7 +2625,10 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       Effect.map(({ owned }) => owned),
     );
 
-  const withProgressSession = Effect.fnUntraced(function* (session: RunStorageSession) {
+  const withProgressSession = Effect.fnUntraced(function* (
+    session: RunStorageSession,
+    originalInput?: () => InitialContextInput | undefined,
+  ) {
     const { owned, progress } = yield* withProgress(session);
 
     activeProgress.set(session.threadId, { writer: progress });
@@ -2611,9 +2639,44 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       }),
     );
 
+    const inputWriter =
+      session.appendInput === undefined
+        ? undefined
+        : {
+            ...session,
+            append: session.appendInput,
+          };
+
     const wrapped: RunStorageSession = {
       ...session,
       append: owned.append,
+      ...(inputWriter === undefined
+        ? {}
+        : {
+            appendInput: (batch: CommitBatch) =>
+              storageOwner.withProgress(
+                session.threadId,
+                storageOwner.withMutation(
+                  Effect.gen(function* () {
+                    yield* session.checkActive;
+                    // The captured empty canonical prefix is enforced again by the append tail and
+                    // checkpoint revision-zero CAS. It is not a cache entry across preparation IO.
+                    const original = originalInput?.();
+                    const commit = progress.commit(batch);
+
+                    return yield* (
+                      original === undefined
+                        ? commit
+                        : progress.withVerifiedEmptyRun(
+                            runIdForSubmission(session.claim.submissionId),
+                            CanonicalSequence.make(original.sequence - 1),
+                            commit,
+                          )
+                    ).pipe(Effect.provideService(CurrentRunWriter, inputWriter));
+                  }),
+                ),
+              ),
+          }),
       publishSettlement: (batch) =>
         progress.publish(batch).pipe(Effect.provideService(CurrentRunSettlement, session)),
     };
@@ -2633,8 +2696,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       const progress =
         active?.writer ??
         (yield* makeProgressWriter(request.threadId, config.deploymentId).pipe(
-          Effect.provideService(ThreadReader, reader),
-          Effect.provideService(Crypto.Crypto, crypto),
+          Effect.provideContext(journalServices),
         ));
 
       let tail = {
@@ -3151,6 +3213,20 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     );
   });
 
+  const prepareOriginalInput = (submission: SubmissionSnapshot) =>
+    makeEnvelope(
+      submissionInputRecordId(submission.submissionId),
+      UserInputRecorded.make({
+        submissionId: submission.submissionId,
+        kind: "user",
+        runId: runIdForSubmission(submission.submissionId),
+        input: submission.inputPayload,
+        ...(submission.messageAdmission === undefined
+          ? {}
+          : { messageAdmission: submission.messageAdmission }),
+      }),
+    );
+
   /**
    * Plan step 2: append the deterministic `UserInputRecorded` record (batch idempotency makes it
    * exactly-once canonical, DUR-007) and mark it applied. When canonical history already carries
@@ -3176,18 +3252,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       return;
     }
 
-    const envelope = yield* makeEnvelope(
-      recordId,
-      UserInputRecorded.make({
-        submissionId,
-        kind: "user",
-        runId: runIdForSubmission(submissionId),
-        input: submission.inputPayload,
-        ...(submission.messageAdmission === undefined
-          ? {}
-          : { messageAdmission: submission.messageAdmission }),
-      }),
-    );
+    const envelope = yield* prepareOriginalInput(submission);
 
     const result = yield* appendBatch(
       ctx,
@@ -3238,8 +3303,13 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     maxDurationMillis: number,
     records: ReadonlyArray<CanonicalRecordEnvelope>,
     operational: ReadonlyArray<RecordEnvelope>,
+    input?: RecordEnvelope,
   ) {
     const writer = yield* CurrentRunWriter;
+    const append = input === undefined ? writer.append : writer.appendInput;
+
+    if (append === undefined)
+      return yield* RunJournalError.make({ message: "Fresh startup requires an input publisher" });
     const runId = runIdForSubmission(submission.submissionId);
     const recordId = runStartedRecordId(runId);
     const existing = yield* readRunStart(submission.threadId, runId, operational);
@@ -3288,13 +3358,21 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       }
       yield* hit("run:before-start-append");
       yield* appendBatch(
-        writer,
+        { threadId: writer.threadId, append },
         CanonicalBatch.make({
-          batchId: runStartedBatchId(runId),
+          batchId:
+            input === undefined
+              ? runStartedBatchId(runId)
+              : submissionInputBatchId(submission.submissionId),
           producerId: config.producerId,
-          records: [start, ...(context === undefined ? [] : [context])],
+          records: [
+            input ?? start,
+            ...(input === undefined ? [] : [start]),
+            ...(context === undefined ? [] : [context]),
+          ],
         }),
       );
+      if (input !== undefined) yield* hit("input:after-canonical-append");
       committed = true;
       yield* hit("run:after-start-append");
     });
@@ -4840,12 +4918,14 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       // Unrelated Thread traffic does not invalidate an already validated owner projection.
       const projectionThrough = Math.max(progressThrough ?? 0, records.at(-1)?.sequence ?? 0);
 
-      const originalInput = records.find(
-        ({ record: { payload } }) =>
-          payload._tag === "UserInputRecorded" &&
-          payload.kind === "user" &&
-          payload.submissionId === submissionId,
-      );
+      const originalInput =
+        initialJournal?.original ??
+        records.find(
+          ({ record: { payload } }) =>
+            payload._tag === "UserInputRecorded" &&
+            payload.kind === "user" &&
+            payload.submissionId === submissionId,
+        );
 
       if (originalInput === undefined)
         return yield* RunJournalError.make({ message: "Run has no original context boundary" });
@@ -4856,23 +4936,35 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           historyEvidence.set(entry.record.recordId, entry);
       };
 
+      // An exact cache prefix followed only by this fresh input has no response,
+      // policy reservation or context to replay. Keep recovery on the full projector.
+      const freshPrefix =
+        priorContext === undefined &&
+        initialJournal?.prefix !== undefined &&
+        initialJournal.records?.length === 1 &&
+        initialJournal.records[0] === originalInput
+          ? initialJournal.prefix.prompt
+          : undefined;
+
       let journal =
-        cached !== undefined &&
-        cached.threadId === ctx.threadId &&
-        cached.through === projectionThrough &&
-        cached.runId === runId &&
-        cached.contextRecordId === priorContext?.recordId
-          ? (boundaries.push(...cached.boundaries),
-            cached.contextEvidence.forEach(retainHistory),
-            cached.journal)
-          : yield* projectRunJournalStream(
-              canonical,
-              runId,
-              (boundary) => boundaries.push(boundary),
-              priorContext,
-              journalMetadata,
-              priorContext === undefined ? retainHistory : undefined,
-            );
+        freshPrefix !== undefined
+          ? initialRunJournal(freshPrefix)
+          : cached !== undefined &&
+              cached.threadId === ctx.threadId &&
+              cached.through === projectionThrough &&
+              cached.runId === runId &&
+              cached.contextRecordId === priorContext?.recordId
+            ? (boundaries.push(...cached.boundaries),
+              cached.contextEvidence.forEach(retainHistory),
+              cached.journal)
+            : yield* projectRunJournalStream(
+                canonical,
+                runId,
+                (boundary) => boundaries.push(boundary),
+                priorContext,
+                journalMetadata,
+                priorContext === undefined ? retainHistory : undefined,
+              );
 
       if (initialJournal?.prefix !== undefined) {
         const prompt = initialJournal.prefix.prompt;
@@ -5192,9 +5284,6 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           ),
         );
 
-      const addUsageTotal = (field: string, left: number, right: number) =>
-        checkedUsageTotal(field, left + right);
-
       const subtractUsageTotal = (field: string, left: number, right: number) =>
         checkedUsageTotal(field, left - right);
 
@@ -5204,11 +5293,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           let unobservedModelCalls = journal.usage.unobservedModelCalls ?? 0;
 
           for (const count of stagedUnobservedCalls.values()) {
-            unobservedModelCalls = yield* addUsageTotal(
-              "unobservedModelCalls",
-              unobservedModelCalls,
-              count,
-            );
+            unobservedModelCalls += count;
           }
           const detailedCalls = [...journal.usage.modelUsage, ...stagedCalls];
 
@@ -5229,17 +5314,15 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           let costMicrousd = journal.usage.costMicrousd;
 
           for (const usage of stagedUsage.values()) {
-            inputTokens = yield* addUsageTotal("inputTokens", inputTokens, usage.inputTokens);
-            outputTokens = yield* addUsageTotal("outputTokens", outputTokens, usage.outputTokens);
-            costMicrousd = yield* addUsageTotal("costMicrousd", costMicrousd, usage.costMicrousd);
+            inputTokens += usage.inputTokens;
+            outputTokens += usage.outputTokens;
+            costMicrousd += usage.costMicrousd;
           }
 
-          const modelCalls = yield* addUsageTotal(
-            "modelCalls",
-            journal.usage.modelCalls,
-            stagedCalls.length,
-          );
+          const modelCalls = journal.usage.modelCalls + stagedCalls.length;
 
+          // Reconciliation must reject negative legacy deltas independently of
+          // the final summary's complete safe-integer and additive checks.
           const legacyCalls = yield* subtractUsageTotal(
             "legacy.modelCalls",
             modelCalls,
@@ -5283,81 +5366,52 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
             const existing = existingIndex < 0 ? undefined : byModel[existingIndex];
 
-            const legacyGroup = ModelUsageGroup.make({
+            const legacyGroup = yield* ModelUsageGroup.makeEffect({
               provider: "unknown",
               model: "legacy-record",
-              modelCalls: yield* addUsageTotal(
-                "byModel.modelCalls",
-                existing?.modelCalls ?? 0,
-                legacyCalls,
-              ),
-              inputTokens: InputTokenUsage.make({
-                total: yield* addUsageTotal(
-                  "byModel.inputTokens.total",
-                  existing?.inputTokens.total ?? 0,
-                  legacyInput,
-                ),
-                uncached: yield* addUsageTotal(
-                  "byModel.inputTokens.uncached",
-                  existing?.inputTokens.uncached ?? 0,
-                  legacyInput,
-                ),
+              modelCalls: (existing?.modelCalls ?? 0) + legacyCalls,
+              inputTokens: {
+                total: (existing?.inputTokens.total ?? 0) + legacyInput,
+                uncached: (existing?.inputTokens.uncached ?? 0) + legacyInput,
                 cacheRead: existing?.inputTokens.cacheRead ?? 0,
                 cacheWrite: existing?.inputTokens.cacheWrite ?? 0,
-              }),
-              outputTokens: OutputTokenUsage.make({
-                total: yield* addUsageTotal(
-                  "byModel.outputTokens.total",
-                  existing?.outputTokens.total ?? 0,
-                  legacyOutput,
-                ),
-                text: yield* addUsageTotal(
-                  "byModel.outputTokens.text",
-                  existing?.outputTokens.text ?? 0,
-                  legacyOutput,
-                ),
+              },
+              outputTokens: {
+                total: (existing?.outputTokens.total ?? 0) + legacyOutput,
+                text: (existing?.outputTokens.text ?? 0) + legacyOutput,
                 reasoning: existing?.outputTokens.reasoning ?? 0,
-              }),
-              costMicrousd: yield* addUsageTotal(
-                "byModel.costMicrousd",
-                existing?.costMicrousd ?? 0,
-                legacyCost,
+              },
+              costMicrousd: (existing?.costMicrousd ?? 0) + legacyCost,
+            }).pipe(
+              Effect.mapError((cause) =>
+                RunJournalError.make({
+                  message: "Run legacy usage exceeds safe-integer accounting bounds",
+                  cause,
+                }),
               ),
-            });
+            );
 
             if (existingIndex < 0) byModel.push(legacyGroup);
             else byModel[existingIndex] = legacyGroup;
           }
 
-          const uncached = yield* addUsageTotal(
-            "inputTokens.uncached",
-            detailed.inputTokens.uncached,
-            legacyInput,
-          );
-
-          const text = yield* addUsageTotal(
-            "outputTokens.text",
-            detailed.outputTokens.text,
-            legacyOutput,
-          );
-
-          return RunUsageSummary.make({
+          return yield* RunUsageSummary.makeEffect({
             ...(legacyCalls === 0 && detailed.webSearchCalls !== undefined
               ? { webSearchCalls: detailed.webSearchCalls }
               : {}),
             modelCalls,
-            inputTokens: InputTokenUsage.make({
+            inputTokens: {
               total: inputTokens,
               // Legacy aggregate inputs are conservatively classified as uncached.
-              uncached,
+              uncached: detailed.inputTokens.uncached + legacyInput,
               cacheRead: detailed.inputTokens.cacheRead,
               cacheWrite: detailed.inputTokens.cacheWrite,
-            }),
-            outputTokens: OutputTokenUsage.make({
+            },
+            outputTokens: {
               total: outputTokens,
-              text,
+              text: detailed.outputTokens.text + legacyOutput,
               reasoning: detailed.outputTokens.reasoning,
-            }),
+            },
             costMicrousd,
             byModel,
             unobservedModelCalls,
@@ -5373,7 +5427,14 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
                   ? "unknown"
                   : "partial"
                 : detailed.pricingStatus,
-          });
+          }).pipe(
+            Effect.mapError((cause) =>
+              RunJournalError.make({
+                message: "Run usage summary exceeds safe-integer accounting bounds",
+                cause,
+              }),
+            ),
+          );
         });
 
       const activeExecution = yield* reader.readExecution({ threadId: ctx.threadId, runId });
@@ -5450,18 +5511,6 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           usageSummary: yield* currentUsageSummary(),
         };
       }
-      // Summaries cover only prior Runs. Pruning and rollover also map fully settled
-      // current-Run records and preserves the canonical instruction/input block during replay.
-      let ownerFirstSequence: CanonicalSequence | undefined;
-
-      for (const envelope of records) {
-        const payload = envelope.record.payload;
-
-        if ("runId" in payload && payload.runId === runId) {
-          ownerFirstSequence = envelope.sequence;
-          break;
-        }
-      }
 
       /** Only canonical joined inputs can require restoration from an earlier Attempt. */
       let joinBacklog: ReadonlyArray<JoinSnapshot> | undefined =
@@ -5549,37 +5598,38 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       const recordHalt = <A, R>(
         effect: Effect.Effect<A, DurableWorkerFailure, R>,
       ): Effect.Effect<A, CoordinatorHalt | AgentPersistenceCapacityError, R> =>
-        effect.pipe(
-          Effect.tapError((failure) =>
-            failure instanceof ThreadStoreError &&
-            failure.cause instanceof AgentPersistenceCapacityError
-              ? Effect.void
-              : Ref.set(haltRef, failure),
-          ),
-          Effect.catchCause((cause) =>
-            Effect.failCause(
-              Cause.map(cause, (failure) =>
-                failure instanceof ThreadStoreError &&
-                failure.cause instanceof AgentPersistenceCapacityError
-                  ? failure.cause
-                  : new CoordinatorHalt(failure),
-              ),
+        Effect.catchCause(effect, (cause) => {
+          const first = Cause.findErrorOption(cause);
+
+          const failure = Effect.failCause(
+            Cause.map(cause, (error) =>
+              error instanceof ThreadStoreError &&
+              error.cause instanceof AgentPersistenceCapacityError
+                ? error.cause
+                : new CoordinatorHalt(error),
             ),
-          ),
-        );
+          );
+
+          return Option.isNone(first) ||
+            (first.value instanceof ThreadStoreError &&
+              first.value.cause instanceof AgentPersistenceCapacityError)
+            ? failure
+            : Effect.andThen(Ref.set(haltRef, first.value), failure);
+        });
 
       // Infrastructure errors can be wrapped by broker/Tool APIs. The interpreter checks this
       // authority before semantic work; progress delivery is not a coordinator checkpoint.
-      const checkpoint = recordHalt(
-        Effect.gen(function* () {
-          const failure = yield* Ref.get(haltRef);
+      const progress = progressWriters.get(ctx);
 
-          if (failure !== undefined) return yield* failure;
-          const progress = progressWriters.get(ctx);
+      const checkProgress =
+        progress === undefined
+          ? Effect.void
+          : progress.check(runId).pipe(Effect.provideService(CurrentRunWriter, ctx));
 
-          if (progress !== undefined)
-            yield* progress.check(runId).pipe(Effect.provideService(CurrentRunWriter, ctx));
-        }),
+      const checkpoint = recordHalt(
+        Effect.flatMap(Ref.get(haltRef), (failure) =>
+          failure === undefined ? checkProgress : Effect.fail(failure),
+        ),
       );
 
       // One readonly Turn may own its response without publishing it. Promotion and settlement
@@ -5841,6 +5891,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
               const start = yield* CurrentRunStart;
 
               yield* start.commit(yield* makeEnvelope(recordId, payload));
+              knownIds.add(originalInput.record.recordId);
               knownIds.add(runStartedRecordId(runId));
               knownIds.add(recordId);
               historyEvidence.clear();
@@ -6402,13 +6453,10 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
             );
           }
 
-          // Summaries use the initial prior-Run boundaries; pruning and rollover also admit
-          // complete current-Run boundaries from the fresh canonical source above.
+          // The validated original input bounds summaries even when startup deferred its append.
+          // Pruning and rollover also admit complete current-Run canonical boundaries.
           const coverable = sourceBoundaries.filter(
-            (boundary) =>
-              commit.kind !== "summarize" ||
-              ownerFirstSequence === undefined ||
-              boundary.sequence < ownerFirstSequence,
+            (boundary) => commit.kind !== "summarize" || boundary.sequence < originalInput.sequence,
           );
 
           if (coverable.length === 0) {
@@ -7834,35 +7882,39 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
               stagedUnobservedCalls.set(turn, (stagedUnobservedCalls.get(turn) ?? 0) + 1);
             }),
         }),
-        Effect.provide(ThreadHistory.layer),
-        Effect.provideService(SubagentHost.forTool, (source) =>
-          source.threadId !== submission.threadId ||
-          source.agentId !== submission.agentId ||
-          source.runId !== runId
-            ? SubagentHost.unavailable
-            : workerRuntime.facet(
-                {
-                  source,
-                  policy: agent.definition.policy,
-                  depth: delegationDepth,
-                  ...(inheritedGrant === undefined ? {} : { grant: inheritedGrant }),
-                },
-                submission.principal,
-                submission.submissionId,
-              ),
-        ),
-        Effect.provideService(MessagingHost.forTool, (source) =>
-          source.threadId !== submission.threadId ||
-          source.agentId !== submission.agentId ||
-          source.runId !== runId
-            ? MessagingHost.unavailable
-            : messagingRuntime.forTool(source, submission.principal),
+        (body) =>
+          body.pipe(
+            Effect.provideServiceEffect(ThreadHistory, ThreadHistory.makeFromStore),
+            Effect.provideServiceEffect(ConversationStore, makeMemoryStore),
+            Effect.scoped,
+          ),
+        Effect.provideContext(
+          runServices.pipe(
+            Context.add(SubagentHost.forTool, (source) =>
+              source.threadId !== submission.threadId ||
+              source.agentId !== submission.agentId ||
+              source.runId !== runId
+                ? SubagentHost.unavailable
+                : workerRuntime.facet(
+                    {
+                      source,
+                      policy: agent.definition.policy,
+                      depth: delegationDepth,
+                      ...(inheritedGrant === undefined ? {} : { grant: inheritedGrant }),
+                    },
+                    submission.principal,
+                    submission.submissionId,
+                  ),
+            ),
+            Context.add(MessagingHost.forTool, (source) =>
+              source.threadId !== submission.threadId ||
+              source.agentId !== submission.agentId ||
+              source.runId !== runId
+                ? MessagingHost.unavailable
+                : messagingRuntime.forTool(source, submission.principal),
+            ),
+          ),
         ),
-        Effect.provideService(CurrentToolFailureObserver, toolFailureObserver),
-        Effect.provideService(RunToolVisibility, runToolVisibility),
-        Effect.provideService(RunToolScheduling, runToolScheduling),
-        Effect.provideService(ContextCompactor, compactor),
-        Effect.provideService(RunContextPreparation, runContextPreparation),
         Effect.andThen(checkpoint),
         // A wrapped Tool/approval failure cannot outrank retained infrastructure authority.
         // Preserve independent defects, interruptions and already-marked coordinator failures.
@@ -7909,21 +7961,20 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         }),
       );
 
-      const execution = Effect.raceFirst(consume, abortWatcher);
-
-      const raced = (
-        yieldAfter === undefined && submissionScheduling.yieldTo === undefined
-          ? execution
-          : Effect.raceFirst(
-              execution,
+      const raced = Effect.raceAllFirst([
+        consume,
+        abortWatcher,
+        ...(yieldAfter === undefined && submissionScheduling.yieldTo === undefined
+          ? []
+          : [
               Deferred.await(yieldSignal).pipe(
                 Effect.map((nextSubmissionId) => ({
                   _tag: "yielded" as const,
                   ...(nextSubmissionId === undefined ? {} : { nextSubmissionId }),
                 })),
               ),
-            )
-      ).pipe(Effect.provideService(IdGenerator, idGenerator));
+            ]),
+      ]).pipe(Effect.provideService(IdGenerator, idGenerator));
 
       const result = yield* raced.pipe(
         Effect.catchCauseFilter(
@@ -8149,23 +8200,21 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       resumeAfterRetention: () => void,
       onHandoff: (nextSubmissionId: SubmissionId) => void,
       yieldAfter?: DateTime.Utc,
+      freshlyAdmitted = false,
     ) {
       // Recheck ownership outside the disposable cache's failure recovery.
       yield* session.checkActive;
 
       const checkpointPrompt = yield* promptHistory
         .take({ threadId: session.threadId })
-        .pipe(
-          Effect.provideService(ThreadStore, store),
-          Effect.provideService(ThreadReader, reader),
-          Effect.provideService(Crypto.Crypto, crypto),
-        );
+        .pipe(Effect.provideService(ThreadStore, store), Effect.provideContext(journalServices));
 
       // withProgressSession exposes only progress.commit/publish. Their prepare step owns and
       // freezes each canonical fact before reaching this raw writer. Snapshot the private array
       // before suspension; only acknowledged ranges enter this Attempt's disposable suffix.
       let committedPromptSuffix: CommittedPromptSuffix | undefined;
       const storageSession = session;
+      let pendingOriginal: InitialContextInput | undefined;
 
       yield* Effect.addFinalizer(() =>
         Effect.sync(() => {
@@ -8173,8 +8222,30 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           committedPromptSuffix = undefined;
         }),
       );
-      session = yield* withProgressSession({
+
+      const promptSession: RunStorageSession = {
         ...storageSession,
+        ...(storageSession.appendInput === undefined
+          ? {}
+          : {
+              appendInput: (batch: CommitBatch, executions?: ReadonlyArray<ExecutionUpdate>) =>
+                storageSession.appendInput!(batch, executions).pipe(
+                  Effect.tap((result) =>
+                    Effect.sync(() => {
+                      if (
+                        pendingOriginal !== undefined &&
+                        !result.replayed &&
+                        result.firstSequence === pendingOriginal.sequence
+                      )
+                        committedPromptSuffix = makeCommittedPromptSuffix({
+                          threadId: storageSession.threadId,
+                          sequence: result.firstSequence,
+                          record: batch.records[0]!,
+                        });
+                    }),
+                  ),
+                ),
+            }),
         append: (batch, executions) => {
           const suffix = committedPromptSuffix;
           const append = storageSession.append(batch, executions);
@@ -8208,17 +8279,153 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
             Effect.tapCause(() => Effect.sync(() => suffix.discard())),
           );
         },
-      });
+      };
+
+      session = yield* withProgressSession(promptSession, () => pendingOriginal);
       const { claim, threadId } = session;
       const submissionId = claim.submissionId;
 
-      const snapshot = yield* ledger.loadRecoverySnapshot(
-        RecoverySnapshotRequest.make({ submissionId }),
-      );
+      // The hint only selects this preparation. A real claim, current controls, exact
+      // evidence and checkpoint absence are verified under its owner before any reuse.
+      // No binding, instructions, model, Tool or cross-Thread operation runs in the window.
+      let prepared =
+        freshlyAdmitted && session.withInitialization !== undefined
+          ? yield* session.withInitialization(
+              Effect.gen(function* () {
+                const snapshot = yield* ledger.loadRecoverySnapshot(
+                  RecoverySnapshotRequest.make({ submissionId }),
+                );
+
+                const submission = snapshot.submission;
+
+                if (
+                  submission.state !== "ready" ||
+                  submission.workerAdmission !== undefined ||
+                  submission.messageAdmission !== undefined ||
+                  submission.parentLinkage !== undefined ||
+                  snapshot.inputApplied !== undefined ||
+                  snapshot.abortIntent !== undefined ||
+                  snapshot.approvalDecisions.length !== 0
+                )
+                  return undefined;
+                yield* ensureThreadCreated(threadId, submission.agentId, submission.agentDigests);
+                yield* session.refresh;
+                const before = (yield* session.tail).sequence;
+
+                const view = yield* recoveryView(
+                  threadId,
+                  before,
+                  [submissionId],
+                  runIdForSubmission(submissionId),
+                );
+
+                if (
+                  view.progress !== undefined ||
+                  view.context !== undefined ||
+                  view.operational.length !== 0 ||
+                  view.records.some(({ record }) => record.payload._tag !== "ThreadCreated")
+                )
+                  return undefined;
+                if (session.appendInput !== undefined) {
+                  const captured = yield* PreparedAppend.capture(
+                    AppendRequest.make({
+                      threadId,
+                      expectedTailSequence: before,
+                      batch: CanonicalBatch.make({
+                        batchId: submissionInputBatchId(submissionId),
+                        producerId: config.producerId,
+                        records: [yield* prepareOriginalInput(submission)],
+                      }),
+                    }),
+                  );
+
+                  const record = captured.records[0]!.canonical;
+
+                  if (!isOriginalInputRecord(record))
+                    return yield* RunJournalError.make({
+                      message: "Captured startup has no original input",
+                    });
+                  pendingOriginal = {
+                    threadId,
+                    sequence: CanonicalSequence.make(before + 1),
+                    record,
+                  };
+
+                  const start = yield* makeRunStart(
+                    submission,
+                    Duration.toMillis(registeredAgent.definition.policy.maxDuration),
+                    view.records,
+                    view.operational,
+                    record,
+                  ).pipe(Effect.provideService(CurrentRunWriter, session));
+
+                  return { snapshot, through: before, view, start, input: pendingOriginal };
+                }
+                const progress = progressWriters.get(session);
+
+                const applyInput = applyCanonicalInput(
+                  session,
+                  submission,
+                  session,
+                  view.records,
+                  undefined,
+                );
+
+                yield* progress === undefined
+                  ? applyInput
+                  : progress
+                      .withVerifiedEmptyRun(runIdForSubmission(submissionId), before, applyInput)
+                      .pipe(Effect.provideService(CurrentRunWriter, promptSession));
+                const through = (yield* session.tail).sequence;
+                const added = yield* selectedRange(threadId, [submissionId], through, before);
+                const records = [...view.records, ...added];
+
+                const accepted = progressWriters
+                  .get(session)
+                  ?.acceptedCheckpoint(runIdForSubmission(submissionId));
+
+                if (
+                  accepted === undefined ||
+                  accepted.throughSequence !== through ||
+                  accepted.progress.runId !== runIdForSubmission(submissionId) ||
+                  accepted.progress.submissionId !== submissionId
+                )
+                  return undefined;
+
+                const start = yield* makeRunStart(
+                  submission,
+                  Duration.toMillis(registeredAgent.definition.policy.maxDuration),
+                  records,
+                  view.operational,
+                ).pipe(Effect.provideService(CurrentRunWriter, session));
+
+                return {
+                  snapshot,
+                  through,
+                  view: {
+                    ...view,
+                    records,
+                    progress: accepted.progress,
+                    progressThrough: accepted.throughSequence,
+                    operational: accepted.operational,
+                  },
+                  start,
+                  input: undefined,
+                };
+              }),
+            )
+          : undefined;
+
+      const preparedInput = prepared !== undefined;
+
+      const snapshot =
+        prepared?.snapshot ??
+        (yield* ledger.loadRecoverySnapshot(RecoverySnapshotRequest.make({ submissionId })));
 
       const submission = snapshot.submission;
 
-      yield* ensureThreadCreated(threadId, submission.agentId, submission.agentDigests);
+      if (prepared === undefined)
+        yield* ensureThreadCreated(threadId, submission.agentId, submission.agentDigests);
       if (submission.workerAdmission?.origin.reporting?.mode === "standard")
         yield* updateRuntime.repairRun(threadId, submissionId);
       if (submission.workerAdmission !== undefined) {
@@ -8233,18 +8440,20 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       if (submission.state === "admitted") {
         yield* ledger.markReady(MarkReadyRequest.make({ submissionId }));
       }
-      yield* session.refresh;
+      if (prepared === undefined) yield* session.refresh;
       const ctx: AttemptAppendContext = session;
-      let controlThrough = (yield* session.tail).sequence;
+      let controlThrough = prepared?.through ?? (yield* session.tail).sequence;
 
       const initialThrough = controlThrough;
 
-      const initialView = yield* recoveryView(
-        threadId,
-        initialThrough,
-        [submissionId],
-        runIdForSubmission(submissionId),
-      );
+      const initialView =
+        prepared?.view ??
+        (yield* recoveryView(
+          threadId,
+          initialThrough,
+          [submissionId],
+          runIdForSubmission(submissionId),
+        ));
 
       let journalMetadata: ReturnType<typeof makeJournalMetadata> | undefined;
 
@@ -8367,15 +8576,17 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           ),
         );
       }
-      yield* applyCanonicalInput(ctx, submission, session, records, snapshot.inputApplied);
+      if (prepared === undefined)
+        yield* applyCanonicalInput(ctx, submission, session, records, snapshot.inputApplied);
 
-      const start = yield* makeRunStart(
-        submission,
-        Duration.toMillis(agent.definition.policy.maxDuration),
-        yield* refreshControl(),
-        // Applying the input cannot change the Run start captured by this Attempt's owner.
-        initialView.operational,
-      ).pipe(Effect.provideService(CurrentRunWriter, ctx));
+      const start =
+        prepared?.start ??
+        (yield* makeRunStart(
+          submission,
+          Duration.toMillis(agent.definition.policy.maxDuration),
+          yield* refreshControl(),
+          initialView.operational,
+        ).pipe(Effect.provideService(CurrentRunWriter, ctx)));
 
       const savedRunTiming = start.timing;
 
@@ -8397,8 +8608,11 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
             };
 
       let expiredChildObligation = false;
+      let preparedControl = prepared !== undefined;
 
       if ((yield* Clock.currentTimeMillis) >= DateTime.toEpochMillis(runTiming.deadline)) {
+        prepared = undefined;
+        preparedControl = false;
         yield* commitStart;
         yield* reconcileRetainedChildren(ctx, submission, session);
         expiredChildObligation = yield* completeJoinedReleases(submission);
@@ -8406,7 +8620,9 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
       // Recheck after duration interruption too: that Attempt may have declared new ordinary calls.
       const ordinaryCallsResolved = Effect.gen(function* () {
-        const reconciliationRecords = yield* refreshControl();
+        const reconciliationRecords = preparedControl ? records : yield* refreshControl();
+
+        preparedControl = false;
 
         const reconciliationEvidence = yield* evidenceFor(
           reconciliationRecords,
@@ -8456,7 +8672,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       if (!expiredChildObligation && !(yield* ordinaryCallsResolved))
         return Option.none<Settlement>();
 
-      const continuationRecords = yield* refreshControl();
+      const continuationRecords = prepared === undefined ? yield* refreshControl() : records;
 
       const continuation = yield* pendingToolBatchFor(
         continuationRecords,
@@ -8596,24 +8812,30 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
       const lineage: AttemptLineage = {
         attemptId: claim.attemptId,
-        inputWasRecorded: evidence.inputRecorded,
+        inputWasRecorded: !preparedInput && evidence.inputRecorded,
       };
 
       let approvalDecisionIntents = snapshot.approvalDecisions;
 
       while (true) {
-        yield* session.refresh;
+        const initialization = prepared;
+
+        prepared = undefined;
+        if (initialization === undefined) yield* session.refresh;
         const tail = yield* session.tail;
 
-        const currentRecords = yield* refreshControl(tail.sequence);
+        const currentRecords =
+          initialization === undefined ? yield* refreshControl(tail.sequence) : records;
 
-        const view = yield* recoveryView(
-          threadId,
-          tail.sequence,
-          [submissionId],
-          runIdForSubmission(submissionId),
-          currentRecords,
-        );
+        const view =
+          initialization?.view ??
+          (yield* recoveryView(
+            threadId,
+            tail.sequence,
+            [submissionId],
+            runIdForSubmission(submissionId),
+            currentRecords,
+          ));
 
         let canonical: Stream.Stream<
           JournalRecordEnvelope,
@@ -8623,12 +8845,14 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         let initialJournal: InitialJournalSource | undefined;
 
         if (view.context === undefined) {
-          const original = currentRecords.find(
-            ({ record }) =>
-              record.payload._tag === "UserInputRecorded" &&
-              record.payload.kind === "user" &&
-              record.payload.submissionId === submissionId,
-          );
+          const original =
+            initialization?.input ??
+            currentRecords.find(
+              ({ record }) =>
+                record.payload._tag === "UserInputRecorded" &&
+                record.payload.kind === "user" &&
+                record.payload.submissionId === submissionId,
+            );
 
           if (original === undefined)
             return yield* RunJournalError.make({
@@ -8638,7 +8862,10 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           const suffix = currentRecords.filter((entry) => entry.sequence > original.sequence);
 
           const fresh =
-            !lineage.inputWasRecorded && tail.sequence === original.sequence && suffix.length === 0;
+            initialization?.input !== undefined ||
+            (!lineage.inputWasRecorded &&
+              tail.sequence === original.sequence &&
+              suffix.length === 0);
 
           // Every replay stays bounded at the ORIGINAL admission, never the later Thread tail.
           const source: InitialJournalSource = yield* Effect.gen(function* () {
@@ -8681,9 +8908,10 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         }
 
         committedPromptSuffix?.discard();
-        committedPromptSuffix = initialJournal?.cacheable
-          ? makeCommittedPromptSuffix(initialJournal.original)
-          : undefined;
+        committedPromptSuffix =
+          initialJournal?.cacheable && initialization?.input === undefined
+            ? makeCommittedPromptSuffix(initialJournal.original)
+            : undefined;
 
         const outcome = yield* runModel(
           agent,
@@ -8693,7 +8921,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           currentRecords,
           canonical,
           initialJournal,
-          tail.sequence,
+          initialization?.input?.sequence ?? tail.sequence,
           view.progressThrough,
           view.progress,
           view.context,
@@ -8933,6 +9161,9 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           const session = claimed.value;
           const { claim } = session;
 
+          const freshlyAdmitted = unclaimedAdmissions.get(claim.submissionId) === threadId;
+
+          unclaimedAdmissions.delete(claim.submissionId);
           firstClaimedSubmissionId ??= claim.submissionId;
 
           const attributes = {
@@ -9017,6 +9248,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
                   });
                 },
                 options?.yieldAfter,
+                freshlyAdmitted,
               ),
             threadId,
             claim,
@@ -10395,6 +10627,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
   const recoverOwnedWork = Effect.fnUntraced(function* (
     request: WorkRecoveryRequest,
     recoveredAdmissions = new Map<SubmissionId, RecoveryReport>(),
+    deferUnclaimedAdmissions = false,
   ): Effect.fn.Return<WorkRecoveryReport, DurableWorkerFailure> {
     const { threadId, work: entry } = yield* Schema.decodeEffect(WorkRecoveryRequest)(request).pipe(
       Effect.mapError((cause) =>
@@ -10448,6 +10681,21 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       const original = yield* lookupKnownSubmission("recover work", owner.submissionId);
 
       if (original.threadId !== threadId) return yield* invalid();
+      if (
+        deferUnclaimedAdmissions &&
+        unclaimedAdmissions.get(owner.submissionId) === threadId &&
+        original.state === "ready" &&
+        !storageOwner.hasOwner(threadId) &&
+        (yield* ledger.readAbortIntent(
+          AbortIntentRequest.make({ submissionId: owner.submissionId }),
+        )) === undefined
+      ) {
+        // The worker's first scoped claim performs the authoritative control/journal
+        // read. This hint skips only a redundant pre-claim recovery traversal; it grants
+        // no claim, synthesizes no decision, and supplies no model-visible facts.
+        return report("deferred");
+      }
+      unclaimedAdmissions.delete(owner.submissionId);
       const submission = yield* recoverAdmission(owner.submissionId);
 
       return report(submission.disposition, submission);
@@ -10926,6 +11174,29 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
       const outcome = yield* isolateRecovery(
         Effect.gen(function* () {
+          // This incarnation admitted the sole untouched root. The native snapshot proves
+          // there is no old owner to repair; claim and live controls still run normally.
+          // New source mutations retain their dirty generation for the next maintenance scan.
+          if (
+            workCursor === undefined &&
+            options?.deferUnclaimedAdmissions === true &&
+            workDiscovery.isOnlyFreshAdmission !== undefined &&
+            !storageOwner.hasOwner(threadId)
+          ) {
+            const fresh = [...unclaimedAdmissions].find(([, owner]) => owner === threadId);
+
+            if (
+              fresh !== undefined &&
+              (yield* workDiscovery.isOnlyFreshAdmission({
+                threadId,
+                submissionId: fresh[0],
+              }))
+            ) {
+              complete = true;
+
+              return;
+            }
+          }
           for (
             let pages = 0;
             pages < MAX_RECOVERY_PAGES && workReports.length < MAX_RECOVERY_WORK_ITEMS;
@@ -10941,7 +11212,11 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
             phase = "recovery";
             for (const work of workPage.entries) {
-              const repaired = yield* recoverOwnedWork({ threadId, work }, recoveredAdmissions);
+              const repaired = yield* recoverOwnedWork(
+                { threadId, work },
+                recoveredAdmissions,
+                options?.deferUnclaimedAdmissions === true,
+              );
 
               workReports.push(repaired);
               if (
@@ -11165,7 +11440,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         queueSequence: admitted.queueSequence,
       });
     }
-    const admitted = yield* ledger.admit(request);
+    const admitted = yield* ledger.admit(request, { readyIfInitialized: true });
 
     yield* hit("submit:after-admit");
 
@@ -11181,10 +11456,24 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     if (admitted.replayed && admitted.state !== "admitted") {
       return receipt;
     }
-    yield* materializeThread(options.threadId);
-    yield* ensureThreadCreated(options.threadId, agent.definition.id, options.definitions);
-    yield* hit("submit:after-materialize");
-    yield* ledger.markReady(MarkReadyRequest.make({ submissionId: admitted.submissionId }));
+    if (admitted.state === "admitted") {
+      yield* materializeThread(options.threadId);
+      yield* ensureThreadCreated(options.threadId, agent.definition.id, options.definitions);
+      yield* hit("submit:after-materialize");
+      yield* ledger.markReady(MarkReadyRequest.make({ submissionId: admitted.submissionId }));
+    }
+    if (
+      !admitted.replayed &&
+      messageAdmission === undefined &&
+      options.workerAdmission === undefined
+    ) {
+      unclaimedAdmissions.set(admitted.submissionId, options.threadId);
+      if (unclaimedAdmissions.size > 128) {
+        const oldest = unclaimedAdmissions.keys().next().value;
+
+        if (oldest !== undefined) unclaimedAdmissions.delete(oldest);
+      }
+    }
     yield* wake.notify(options.threadId);
 
     return receipt;