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

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 {
@@ -280,6 +281,7 @@ import {
   modelResponseInterruptedRecordId,
   modelResponseRecordId,
   projectRunJournalStream,
+  initialRunJournal,
   type JournalBoundary,
   type RunJournalProjection,
   type RunJournalContext,
@@ -846,6 +848,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;
 }
@@ -1374,6 +1381,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,6 +1456,17 @@ 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);
 
@@ -1453,8 +1476,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     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 +1730,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 +1797,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 +2591,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 = {
@@ -2633,8 +2650,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 = {
@@ -4856,23 +4872,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 +5220,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 +5229,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 +5250,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 +5302,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 +5363,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 });
@@ -5549,37 +5546,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
@@ -7834,35 +7832,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 +7911,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,17 +8150,14 @@ 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
@@ -8173,7 +8171,8 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           committedPromptSuffix = undefined;
         }),
       );
-      session = yield* withProgressSession({
+
+      const promptSession: RunStorageSession = {
         ...storageSession,
         append: (batch, executions) => {
           const suffix = committedPromptSuffix;
@@ -8208,17 +8207,117 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
             Effect.tapCause(() => Effect.sync(() => suffix.discard())),
           );
         },
-      });
+      };
+
+      session = yield* withProgressSession(promptSession);
       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;
+                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,
+                };
+              }),
+            )
+          : 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 +8332,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 +8468,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 +8500,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 +8512,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 +8564,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 +8704,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,
@@ -8933,6 +9047,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 +9134,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
                   });
                 },
                 options?.yieldAfter,
+                freshlyAdmitted,
               ),
             threadId,
             claim,
@@ -10395,6 +10513,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 +10567,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 +11060,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 +11098,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 +11326,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 +11342,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;